yjTfUdZddlZddlZddlZddlZddlZddlZddlZddlZ ddl Z ddl Z ddl Z ddl mZddlmZmZddlmZmZmZmZmZejeZdedefdZd[d ed edefd Zd ejddfdZdZ de!de!ddfdZ"ddde!fdZ#d\dZ$d]dZ%d]dZ& ddl'm(a(m)a)m*a*m+a+m,a, ddl'm-a-n #e.$rda-YnwxYwddl/m0a0m1a1m2a2m3a4m5a5m6a6ddl7m8a8m9a9ddl:m;a;daZ>dd#l?m@ZAe>jBCdeeAeDEjFd$dd%lGmHZHdd&lImJZJmKZKdd'lLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\dd(l]m^Z^dd)l_m`Z`maZambZbdd*lcmdZdmeZemfZfhd+Zgd,d-d-d.d/d0Zhd1d2d2d3d4d5Zid6edeejfd7Zkd8edeejfd9Zldemfd:Zndemfd;Zoe jpd<Zqd=edefd>Zrd=edefd?Zse jpd@Ztd=edefdAZuddBlvmwZxmyZymzZ{e jpdCe j|Z}d=edefdDZ~dEZdFZdGZdHZdEZdIZdHZdHZedJdKZeeejedL<GdMdNeZGdOdPeMZdefdQZdRZdemfdSZddd dTdUZd]dVZdWedXededzfdYZd]dZZdS)^z Telegram platform adapter. Uses python-telegram-bot library for: - Receiving messages from users/groups - Sending responses back - Handling media and commands N) ContextVar)datetimetimezone)DictListOptionalSetAnyerrorreturncz|dnt|}|s|S ddlm}||dS#t$rYdSwxYw)zORedact secrets from Telegram transport errors before logging or returning them.Nr)redact_sensitive_textTforcez)str agent.redactr Exception)r textrs H/home/ragecks/.hermes/hermes-agent/plugins/platforms/telegram/adapter.py_redact_telegram_error_textrss22CJJD  +666666$$T6666 +++***+s , ::rnamedefaultc ddlm}|||S#t$r+tj|p|cYSwxYw)uRead a TELEGRAM_*/GATEWAY_* authorization gate env var per-profile. Under gateway.multiplex_profiles the process env is first-writer-wins (the YAML→env bridge in ``_apply_yaml_config``), so a raw ``os.getenv`` can return ANOTHER profile's allowlist (issue #72348, Telegram mirror). Reads the active profile's secret scope when installed; falls back to ``os.getenv`` outside multiplex — identical single-profile behavior. r)_platform_gate_env)gateway.authz_mixinrrosgetenvstrip)rrrs r_scoped_gate_envr )sl4::::::!!$000 444 $*711333334s2A A taskc |dS#tj$rYdSt$r tddYdSwxYw)zFObserve a detached task's terminal exception to avoid noisy loop logs.z1Abandoned Telegram init task failed after timeoutTexc_infoN) exceptionasyncioCancelledErrorrloggerdebug)r!s r_consume_abandoned_taskr*:szY   !     YYY HSW XXXXXXYsA%AA@timeoutgracectd|| tjddS#t$r tddYdSwxYw)u/Emit diagnostics from the deadline timer thread when the loop is stuck. Runs OFF the event loop, so it works precisely when the loop cannot. The faulthandler dump names the frame the loop thread is blocked in — the one piece of information #63309-class hangs otherwise never surface. u[Telegram] init deadline (%.0fs) expired but the event loop has not processed the expiry after a further %.0fs — the loop thread appears BLOCKED in a synchronous call, which is why no timeout fires (#63309). Dumping all thread stacks to stderr to identify the blocking frame.T) all_threadsz"faulthandler traceback dump failedr#N)r(warning faulthandlerdump_tracebackrr))r,r-s r_dump_loop_blocked_diagnosticsr3Ls NN N  J#555555 JJJ 9D IIIIIIJs5&AA) on_abandonc Ktj|}tj  t jd fd d fd }d fd }t jtd|}d|_| t jtdtz|}d|_|  tj | htj d{V\}} ||vrm s |d{V ||S||t"|;tjt%|} | t"tj#||wxYw) a*Await with a wall-clock deadline that does not depend on loop timers. ``asyncio.wait_for`` schedules its timeout on the event loop and then waits for cancellation to propagate. PTB/httpcore initialization can sit inside cancellation-shielded anyio scopes, so a timed-out initialize() may never hand control back to the retry ladder under some supervisors. This helper lets a daemon ``threading.Timer`` wake the loop and, on timeout, abandons the shielded task instead of awaiting cancellation completion. ``on_abandon`` (optional) is a zero-arg callable returning an awaitable that is scheduled as a detached best-effort cleanup when the task is abandoned on timeout. The abandoned initialize() may leave a half-built httpx client / connection pool open (it never completed and we do not await its cancellation), so the caller uses this to shut that state down and avoid leaking a pool per retry attempt. Cleanup runs detached and its own errors are swallowed, so it can never re-block the retry ladder. r NcsddSdSN)setdone set_result)deadlineloop_processed_expirysr _mark_expiredz2_await_with_thread_deadline.._mark_expired{sI!!###}} &    % % % % % & &c2dSr7)call_soon_threadsafe)r=loopsr_expire_from_threadz8_await_with_thread_deadline.._expire_from_threads !!-00000r>c^sttdSdSr7)is_setr3_LOOP_BLOCKED_DUMP_GRACE)r<r,sr_watchdog_checkz4_await_with_thread_deadline.._watchdog_checks=%++-- N *74L M M M M M N Nr>T return_whenr N)r& ensure_futureget_running_loop create_future threadingEventTimermaxdaemonstartrEwaitFIRST_COMPLETEDr9cancelr8add_done_callbackr*_run_abandon_cleanup TimeoutError) awaitabler,r4r!rBrFtimerwatchdogr9_cleanupr=r;rAr<s ` @@@@r_await_with_thread_deadliner_as$   + +D  # % %D!!##H&O--&&&&&&& 1111111NNNNNNN OC--/B C CEEL KKMMM GS44oHHO NN$ 8 /         a 4<<==?? "!!!::::::    !!####!  6777  ! +,@,L,LMMG  % %&= > > >"$$$  !!####s0AH A>H >Ifuturesasyncio.FuturecpKtjt|tjd{VdS)uReturn when the first of ``futures`` completes. Used by the strict cold-start readiness gate to wait on "progress OR polling error", whichever fires first (#67498). Does not cancel the losers — the caller owns their lifecycle. rHN)r&rTr8rU)r`s r_first_completedrcs> ,s7||1H I I IIIIIIIIIIr>cK |}tj|stj|r |d{VdSdS#t$r tddYdSwxYw)uRun the abandonment cleanup coroutine, swallowing any failure. Wrapped so a cleanup that itself hangs or raises cannot surface as an unhandled task error or block anything — it is fully fire-and-forget. Nz&Abandoned Telegram init cleanup failedTr#)r& iscoroutineisfuturerr(r))r4results rrXrXs N  v & & '*:6*B*B LLLLLLLLL   NNN = MMMMMMNs:A&A,+A,cK|dS |d{Vn,#t$rtddYnwxYwt |dd}|t |ddnd}|sdS|D]}}t |dd}| |}t j|st j|r|d{VR#t$rtddYzwxYwdS) uRelease a half-built PTB app's httpx transports after init was abandoned. ``Application.shutdown()`` / ``Bot.shutdown()`` are gated on the app's ``_initialized`` / ``_requests_initialized`` flags, which a wedged ``initialize()`` (the case this whole path exists for) may never have set — so calling only ``app.shutdown()`` no-ops and leaks the connection pool it was meant to close. ``HTTPXRequest`` builds its ``httpx.AsyncClient`` eagerly in its constructor and its ``shutdown()`` gates only on ``client.is_closed``, so closing the request transports directly releases the pool regardless of PTB init state. We try the clean path first, then fall back to the transports. All best-effort and swallowed. Nz(Abandoned Telegram app.shutdown() failedTr#bot_requestshutdownz*Abandoned Telegram request shutdown failed)rkrr(r)getattrr&rerf)apprirequestsrequestrkrgs r_shutdown_abandoned_apprpsm {Pllnn PPP ?$ OOOOOP #ud # #C14wsJ---dH  V V7J55    VXZZF"6** g.>v.F.F   V V V LLEPTL U U U U U V V Vs!#&A  A :C  &C65C6)UpdateBotMessageInlineKeyboardButtonInlineKeyboardMarkupLinkPreviewOptions ApplicationCommandHandlerCallbackQueryHandlerMessageHandler ContextTypesfilters ParseModeChatType HTTPXRequestTFceZdZeZdS)_MockContextTypesN)__name__ __module__ __qualname__r DEFAULT_TYPEr>rrrs r>r)Path)_coerce_allow_set)PlatformPlatformConfig)BasePlatformAdapter MessageEvent MessageTypeProcessingOutcome SendResultclassify_send_errorcache_image_from_bytescache_audio_from_bytescache_video_from_bytescache_document_from_bytesresolve_proxy_urlSUPPORTED_VIDEO_TYPESSUPPORTED_DOCUMENT_TYPESSUPPORTED_IMAGE_DOCUMENT_TYPES_TEXT_INJECT_EXTENSIONS utf16_len)normalize_telegram_chat_id)TelegramFallbackTransportdiscover_fallback_ipsparse_fallback_ip_env)atomic_replace env_floatenv_int>.gif.jpg.png.jpeg.webprrrr) image/png image/jpegz image/jpg image/webp image/gifrrrr)rrrrrvaluec ttt|}n#ttf$rYdSwxYw|dkr|ndS)zBRound a raw length to whole positive seconds, or None if unusable.Nr)introundfloat TypeError ValueError)rsecss r_coerce_duration_secondsrFs]5u&&'' z "tt!8844%s),AApathc xtj|d}|dkr ddl}||d5}|pd}|rAt|t|z }||cdddSdddn #1swxYwYn#t$rYnwxYw ddl }| |}ttt|dddd}||Sn#t$rYnwxYw ddl}ddl} |drT| dd d d d d d|gddddd} | jdkr&t| jSn#t$rYnwxYwdS)u%Best-effort audio length in whole seconds for outgoing voice/audio. Telegram only auto-derives a clip's duration from container metadata for short recordings; longer ones (roughly 5 min+) are sent with duration 0 and render as ``0:00`` in the player. We read the length locally and pass it explicitly so the bubble shows the real time. Mirrors ``gateway.run._probe_audio_duration``: stdlib ``wave`` for WAV, then mutagen for OGG/Opus/MP3/M4A metadata, then an ``ffprobe`` fallback. All three are optional — when none can read the file we return ``None`` and the caller omits ``duration``, falling back to Telegram's own (possibly absent) metadata, i.e. the prior behavior. Blocking (mutagen read + ffprobe subprocess), so call it via ``asyncio.to_thread``. z.wavrNrbinfolengthffprobez-vr z -show_entrieszformat=durationz-ofz"default=noprint_wrappers=1:nokey=1Tutf-8replace)capture_outputrencodingerrorsr,)rrsplitextlowerwaveopen getframerater getnframesrrmutagenFilerlshutil subprocesswhichrun returncodestdoutr) rextrwfraterraudiorrprocs r_probe_voice_duration_secondsrOsr '  4  # ) ) + +C f}}  KKK4&& $"((-A$3BMMOOeDkk4QRRD'#  $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $     D    T""' GE6400(D A A    K           << " " E>>D'?rtelegram_deps_presentrs  r>c^trdS ddlm}|ddn#t$rYdSwxYw ddlm}m}m}ddlm}m } dd lm }n#t$rd }YnwxYwdd l m }m}m} m} m} m} dd lm} m}dd lm}n#t$rYdSwxYw|a|a|a|a|a |a |a |a| a| a| a| a| a|a|adadS)aFCheck if Telegram dependencies are available. If python-telegram-bot is missing, attempts to lazy-install it via ``tools.lazy_deps.ensure("platform.telegram")``. After a successful install, re-imports the SDK and flips ``TELEGRAM_AVAILABLE`` to True so the adapter's class-level type aliases get rebound. Tr)ensurezplatform.telegramF)prompt)rqrrrs)rtrurvNrxrr)rtools.lazy_depsrrtelegramrqrrrsrtrurw ImportError telegram.extryrzr{r|r}r~telegram.constantsrrtelegram.requestrTelegramMessageHandler) _lazy_ensure_Update_Bot_Message_IKB_IKM_LPO_App_CH_CQH_MH_CT_filters_PM_CtT_HRs rcheck_telegram_requirementsrst:::::: (77777 uuPPPPPPPPPPWWWWWWWW  ; ; ; ; ; ; ;   DDD                 JIIIIIII8888888 uu F CGKN LGIHL 4sA --A<A A< AA<A!A<< B  B z([_*\[\]()~`>#\+\-=|{}.!\\])rc8td|S)zIEscape Telegram MarkdownV2 special characters with a preceding backslash.z\\\1)_MDV2_ESCAPE_REsubrs r _escape_mdv2rs   w - --r>ctjdd|}tjdd|}tjdd|}tjdd|}tjdd|}tjdd|}|S)zStrip MarkdownV2 escape backslashes to produce clean plain text. Also removes MarkdownV2 formatting markers so the fallback doesn't show stray syntax characters from format_message conversion. z\\([_*\[\]()~`>#\+\-=|{}.!\\])\1z\*\*([^*]+)\*\*z \*([^*]+)\*z(?z2(?m)^``` (?P(?:\\)?\(\d+/\d+(?:\\)?\))$c8td|S)aMove ``(N/M)`` chunk markers off Telegram code-fence lines. ``truncate_message()`` appends chunk indicators to the end of a chunk. When the chunk had to close an in-progress fenced code block, that creates a line like ````` \(1/2\)`` after MarkdownV2 escaping. Telegram does not treat that as a clean closing fence, so it can reject MarkdownV2 and fall back to plain text. Put the indicator on its own line immediately after the closing fence. z```\n\g)_CHUNK_INDICATOR_ON_FENCE_RErrs r$_separate_chunk_indicator_from_fencers ( + +,A4 H HHr>)TABLE_SEPARATOR_REcompile_mention_patternsconvert_table_to_bulletsz(?:```[^\n]*\n[\s\S]*?```)|(?:^[^\n]*\|[^\n]*\n[ \t]*\|?[ \t]*:?-+:?[ \t]*(?:\|[ \t]*:?-+:?[ \t]*)+\|?[ \t]*(?:\n[^\n]*\|[^\n]*)*)c|rd|vr|Sg}d}t|D]}|||}|t jdd|||d|}||d}|t jdd|d|S)uConvert single ``\n`` to Markdown hard breaks for the rich-message path. Standard Markdown treats a lone ``\n`` as whitespace (soft break), so Bot API 10.1 ``sendRichMessage`` collapses multi-line content — e.g. slash-command lists joined with ``"\n".join(lines)`` — into a single paragraph. Adding two trailing spaces before each single newline forces a hard line break (``
``) in the rendered output. Paragraph breaks (``\n\n``), fenced code blocks, and GFM pipe-table blocks are left untouched: tables render natively in the rich path and a hard break injected into a row separator would corrupt the table.  rz(?.@@>@N@r@telegram_polling_generation)r_POLLING_GENERATION_CONTEXTceZdZdZdS)_PollingLifecycleAbortz=Internal control flow for polling startup fenced by teardown.N)rrr__doc__rr>rrrusGGGGr>rceZdZUdZdZdZdZdZeZdZ dZ dZ dZ e ed<dZe ed <dZe ed <d Zd Zd ZdZeddddededeedeedef dZedZdeffd Zdvfd Zdvfd Zdedede ddffd Z de fd Z!d!ee"ee#fde"ee#ffd"Z$ddddd#d$ed%eed&eed'eed(eede f d)Z%de&fd*Z'de fd+Z(de fd,Z)de&de fd-Z*e+d!ee"ee#fdeefd.Z,e+d!ee"ee#fdeefd/Z-e+d!ee"ee#fdee.fd0Z/e+d%ed'eed!ee"ee#fde fd1Z0edefd2Z1e+ dwd3eed!ee"ee#fd4eedee.fd5Z2e+ dxd%ed'eed!ee"ee#fd6ee.d4eede"ee#ff d7Z3e+d'eedee.fd8Z4e+d'eedee.fd9Z5ed:e6de fd;Z7d%e#d'e#ddfd<Z8ed:e6de fd=Z9e+d:e6d!ee"ee#fd6ee.de fd>Z: dyd?e#d@e"ee#fd!ee"ee#fd6ee.dAedBee#de#fdCZ;deed:e6de fdFZ?ed:e6de fdGZ@ed:e6de fdHZAdzdJede de fdKZBddddJededeedeedef dLZCde"ee#ffdMZDdNede fdOZEde fdPZFeGjHdQeGjIeGjJzZKeGjHdReGjIeGjJzZLeGjHdSZMdNede fdTZNdNede fdUZOdNede fdVZPde fdWZQdNede fdXZR dydNed!ee"ee#fde fdYZS dydNed!ee"ee#fde fdZZTdee.fd[ZUdId\dNed]e de"ee#ffd^ZVd_e6de fd`ZWd_e6de fdaZXd%ed3eed!ee"ee#fd'eedeeYf dbZZd%edNed3eed!ee"ee#fdee[f dcZ\ dyd%eddedNed!ee"ee#fdee[f deZ]dNede fdfZ^d%edge.dNed!ee"ee#fde f dhZ_dvdiZ`deYe.eajbffdjZcdke.ddfdlZddmZednZfdIddodpe dqe dre deYe.eajbffdsZgdke.dteajbddfduZhdeajifdvZjdvdwZkd:e6dxeddfdyZldIdzd{e de fd|ZmdId}dpe d~e de fdZnd:e6ddfdZodvdZpdeddfdZq dwdkee.dteeajbddfdZrdvdZsd:e6ddfdZtdvdZu dwd%e.dedee.deedee.f dZvdededeefdZwdzd%edede deefdZxd%e.d'e.deddfdZy dzd%e.ded'e.de ddf dZzdvdZ{dvdZ|dvdZ}dvdZ~dIdde de fdZde ddfdZdvdZdedede fdZdvdZd3eede.de fdZ dwd%edNed3eed!ee"ee#fde[f dZddd%ededNed!ee"ee#fde[f dZdIddd%eddedNede d!ee"ee#fde[f dZdNedefdZddd%eddedNede d!ee"ee#fde[f dZd%eddede fdZ dwd&eed!ee"ee#fde fdZ dyd%edge.dNed!ee"ee#fde[f dZdZ d{d%edededed!ee"ee#fde[f dZdZdZdZdZdZdedefdZ d|d%edededed!ee"ee#fde de de de[fdZ dyd%ededededed!ee"ee#fde[fdĄZ dyd%ededee<deded!ee"ee#fde[fdȄZ dyd%edeZdefd?Zېd=edefd@ZܐdAe&defdBZސdAe&d=eddfdCZߐdAe#d=eddfdDZdAe&fdEZedFeedGedefdHZ dydAe&d=eِdIed_e6dJeeddf dKZ dwde&dLeݐdMee.d=eeddf dNZde&de fdOZdIdPde&dQe de fdRZdvdSZdedee&fdTZdedejddfdUZdedejddfdVZdedejddfdWZd=edefdXZd=eddfdYZdJeddfdZZd=eِdAe&defd[Zd\eddfd]Zd\ed=eddfd^Zdedejddfd_Zd`ed=eddfdaZd`eddfdbZdAe&d=dcddfddZdvdeZd%ed'eedee"ee#ffdfZd%ed'ededdfdgZe+dhe#defdiZe+dje#defdkZe+dle#deefdmZ dyde&dLeݐdMee.defdnZde fdoZd%eddedpede fdqZd%eddede fdrZd=eddfdsZd=eِdteddfduZxZS(TelegramAdapterz Telegram bot adapter. Handles: - Receiving messages from users and groups - Sending responses with Telegram markdown - Forum topics (thread_id support) - Media messages Tii皙?1REQUIRES_EDIT_FINALIZEFALLBACK_ON_FINAL_EDIT_FLOOD%RESEND_FINAL_ON_EMPTY_STREAM_FALLBACKi@g ףp= ?gQ?N min_value max_valuerrr+r,r cVddl}tj|} |t|nt|}n&#tt f$rt|}YnwxYw||st|}|t||}|t||}|S)zRead a float env var, reject non-finite values, and clamp to bounds. Guarantees the returned value is a finite number usable directly in ``asyncio.sleep()`` and similar APIs that reject NaN / Inf. rN) mathrrrrrisfiniterQmin)rrr+r,r.rawrs r_env_float_clampedz"TelegramAdapter._env_float_clampeds  ioo #"%/E#JJJuW~~EE:& # # #'NNEEE #}}U## #'NNE  y))E  y))E s ; AActS)z6Telegram measures message length in UTF-16 code units.)rselfs rmessage_len_fnzTelegramAdapter.message_len_fns r>configct|tjd|_d|_d|_||_t|ddpd|_ | dd|_ | dd|_ | dd|_d|_d|_i|_|ddd d |_t)d d |_i|_i|_i|_i|_|dddd |_|dd |jd |_i|_i|_d|_d|_ d|_!d|_"d|_#d|_$tKj&|_'d|_(d|_)d|_*d|_+d|_,d|_-d|_.d|_/d|_0d|_1d|_2tKj3|_4i|_5tm|_7tKj3|_8ts|j:j;<dd|_=t}|j:j;<dd|_?t}|j:j;<dd|_@|j:j;<dg|_Ad|jAD|_B|j:j;<drdnd|_Ci|_Di|_Ei|_Fi|_Gi|_Hd|_Ii|_Ji|_Kd|_LdS) NF reply_to_modefirstdisable_link_previews rich_messages rich_draftstyping_cooldown_secondsr?rr*)HERMES_TELEGRAM_MEDIA_BATCH_DELAY_SECONDSr$(HERMES_TELEGRAM_TEXT_BATCH_DELAY_SECONDSg333333?g{Gz?r.HERMES_TELEGRAM_TEXT_BATCH_SPLIT_DELAY_SECONDSg@rstatus_indicator status_onlineOnlinestatus_offlineOffline dm_topicsc@h|]}d|vt|dSchat_idr).0es r z+TelegramAdapter.__init__..\s0- - - "#aC)  r>base_urll@ important)Msuper__init__rTELEGRAM_app_bot _webhook_mode_compile_mention_patterns_mention_patternsrl_reply_to_mode_coerce_bool_extra_disable_link_previews_rich_messages_enabled_rich_drafts_enabled_rich_send_disabled_rich_draft_disabled_telegram_typing_cooldown_until_coerce_float_extra!_telegram_typing_cooldown_secondsr_media_batch_delay_seconds_pending_photo_batches_pending_photo_batch_tasks_media_group_events_media_group_tasksr2_text_batch_delay_seconds_text_batch_split_delay_seconds_pending_text_batches_pending_text_batch_tasks_drop_delayed_deliveries_polling_error_task_polling_conflict_count%_polling_conflict_recovery_generation_polling_network_error_count_polling_generationr&rO_polling_progress_event_polling_progress_accepting_polling_progress_verifier_task_polling_teardown_started_polling_error_callback_ref_polling_heartbeat_task_bot_username_observed_bot_identity_checked_at_bot_identity_refresh_task_polling_pending_stuck_count_polling_not_running_count_send_path_degradedLock_general_request_drain_lock _dm_topicsr8_forum_command_registered _forum_lockboolr7extraget_status_indicator_enabledr_status_online_text_status_offline_text_dm_topics_config_dm_topic_chat_ids_max_doc_bytes_model_picker_state_choice_picker_state_approval_state_slash_confirm_state_clarify_state_notifications_mode_status_message_ids_last_overflow_preview_post_connect_task)r5r7 __class__s rrTzTelegramAdapter.__init__s !2333+/ #' #(!%!?!?!A!A#*6?G#L#L#WPW,0,C,CD[]b,c,c#-1,C,COUZ,[,[#+/*A*A-QV*W*W!*/ */! BD,8<8P8P %  9Q9 9 .+44_ad*e*e'?A#CE'<> ;=*.)@)@ 6  *A* * & 04/F/F < 4 0G0 0 , ?A"BD&(-%;? ,-$DH212)() '.}$16(GK,/4&+/(?C$ 6:# :>%BF' 23)01' */ +2<>>(*,3655&"<>>04 K  ! !"4e < <0 0 &), K  ! !/8 < <) )  *- K  ! !"2I > >* * !8<{7H7L7L[Z\7]7]- - '+'=- - - { $$Z00 " " "!  57 57!/157!/1)4 68 9;# ;?r>cVd|_tdS)NF)rnrS_mark_connectedr5rs rrzTelegramAdapter._mark_connecteds'(-% !!!!!r>cVd|_tdS)NT)rnrS_mark_disconnectedrs rrz"TelegramAdapter._mark_disconnecteds'(,% ""$$$$$r>codemessage retryablec^d|_t|||dS)NTr)rnrS_set_fatal_error)r5rrrrs rrz TelegramAdapter._set_fatal_errors0(,%   w) DDDDDr>c>tt|ddS)u*True once teardown/fatal-error started — delayed flushes must drop. Buffered text/photo/media-group flushes sit behind an asyncio.sleep(). If disconnect wins the race, dispatching them spawns an agent on a torn-down session, producing stale/duplicate deliveries. rnFrrlr4s r_should_drop_delayed_deliveryz-TelegramAdapter._should_drop_delayed_deliverysGD"metadatacjt|dddkriS|pidriSddiS)a!Return disable_notification kwargs when the adapter is in silent mode. In "important" mode, all message sends are silently delivered (disable_notification=True) unless the caller explicitly requests a notification by setting ``metadata["notify"] = True``. rrRnotifydisable_notificationT)rlr)r5rs r_notification_kwargsz$TelegramAdapter._notification_kwargssK 4. < < K KI N   ) ) I&--r>rK chat_type thread_id user_nameuser_idrKrrrc t|pd}|sdStt|dddd}t|dd}t|r ddlm} t|pd pd } | d krd } n | d kr|d nd } | tjt|p|| ||r!t|nd|t|nd} t|| S#t$r t d|dYnwxYwtd} | s#tddvSd| dD} d| vp|| vS)zIReturn whether a Telegram inline-button caller may perform gated actions.rF_message_handlerN__self___is_user_authorizedr SessionSourcedmprivate supergroupforumrplatformrKrrrrz=[Telegram] Falling back to env-only callback auth for user %sTr#TELEGRAM_ALLOWED_USERSGATEWAY_ALLOW_ALL_USERS>r%yestruec^h|]*}||+SrrrMuids rrOz?TelegramAdapter._is_callback_user_authorized..s-TTTs Tsyy{{TTTr>,*)rrrlcallablegateway.sessionrrrrUrrr(r)r split)r5rrKrrrnormalized_user_idrunnerauth_fnrnormalized_chat_typesource allowed_csv allowed_idss r_is_callback_user_authorizedz,TelegramAdapter._is_callback_user_authorizeds*!B//5577! 5'94@@*dSS&"7>> G    999999'*9+<'='='C'C'E'E'K'K'M'M'UQU$'944+/(()\996?6K77QX(&%. =+=>>2.8AKc)nn22444t090Ec)nnn4 GGFOO,,,    S&! ''?@@FFHH  _ $$=>>DDFFJ^^ ^TTk.?.?.D.DTTT k!F%7;%FFs)CD11'EEcddlm}t|dd}t|dd}tt|ddpd}tt|ddpt|d dpdpd}|s{t|d d}|htt|ddpd}|s4tt|d dpdpd}tt|ddp|}tt|d d pd } | dkrd } nR| dkrLt|dd} t t|dd} t|dddu} | | s| rdnd} d} t|dd} | bt t|dd} t|dddu} | dkr| s| rt| } n| d kr| rt| } |tj|pd| ||| S)a`Build the same Telegram source shape the gateway auth path expects. Resolves the identity to authorize from ``from_user`` for normal messages, falling back to ``sender_chat`` for channel posts (which carry no ``from_user``) so a removed/unauthorized channel cannot inject content via the broadcast path either. rr from_userNchatidrusername full_name sender_chattitletyperrrmessage_thread_idis_topic_messageFis_forumTrrr) rrrlrrrrrrU)r5rruserrrrrrKr thread_id_rawris_forum_grouprs r_source_from_message_for_authz-TelegramAdapter._source_from_message_for_auths 211111w T22w--gdD"--..4466>$ j"--U{B1O1OUSU V V \ \ ^ ^    !'=$??K&gk4<<==CCEEM GK"==CDDJJLLTPTgdD"--..4466A'fd3344::<<BBDDL  ! !II , & &#G-@$GGM#GG5G$O$OPP $T:u==EN!,2B,n,   )c8d}td|DS)zDReturn True when Telegram auth env vars make an early decision safe.)rTELEGRAM_GROUP_ALLOWED_USERSTELEGRAM_GROUP_ALLOWED_CHATSTELEGRAM_ALLOW_ALL_USERSGATEWAY_ALLOWED_USERSrc3XK|]%}t|V&dSr7)r r)rMkeys r z@TelegramAdapter._telegram_auth_env_configured..+s7AAS#C((..00AAAAAAr>)any)r5keyss r_telegram_auth_env_configuredz-TelegramAdapter._telegram_auth_env_configured!s( AADAAAAAAr>c$|jdkrdStt|dddd}t|dd}t|rW |tjt|ddd kS#t $rt d d YnwxYwtt|d dddpi}t| dd d kS)uReturn True when an unauthorized DM must still reach gateway pairing. Early auth (#40863) rejects before event construction. That is correct when unauthorized DMs are ignored, but it must not short-circuit the gateway pairing handshake when ``unauthorized_dm_behavior`` resolves to ``pair`` — including the case where an allowlist is set and the operator explicitly opted back into pairing via a platform override (resolution rule 1 in ``_get_unauthorized_dm_behavior``). rFrNr_get_unauthorized_dm_behaviorprofile)rpairz][Telegram] Failed to resolve unauthorized DM behavior; falling back to adapter-local overrideTr#r7runauthorized_dm_behaviorr) rrlrrrUrr(r)rrrr)r5rr behavior_fnrs r(_should_pass_unauthorized_dm_for_pairingz8TelegramAdapter._should_pass_unauthorized_dm_for_pairing-s=  t # #5'94@@*dSSf&EtLL K   K ) ' 4 @ @     =! h55wEEK5997<<==CCEEKKMMQWWWs)A99&B"!B"c ||}|j}|sdSd}|jpd}|dvr |jjd}n|jjd}|t |}||vpd|v}|l|jd}t|rC t|||j |j|j |j }n#t$rYnwxYw|tt|d dd d} t| d d} t| r]|sdS t| |}n-#t$r t d |dYnwxYw|Lt%d} | sdSd| dD} d| vp|| v}|rdS||S)aCheck if the sender of a Telegram message is authorized. Intake prefilter that runs BEFORE text batching, event construction, and unmentioned-group observation, so a removed/unauthorized user cannot inject prompt content into the agent path or the observed transcript (fixes #40863). It only rejects when it can make the same context-aware decision the runner would make. Unknown DMs with no allowlist still pass through so the normal pairing flow can run. Unknown DMs with an allowlist still pass through when pairing is the effective unauthorized-DM behavior (explicit platform override). TNr)rrchannelgroup_allow_from allow_fromrrrrrrz4[Telegram] Falling back to env-only auth for user %sr#rc^h|]*}||+Srrrs rrOzCTelegramAdapter._is_user_authorized_from_message..s-XXX3CIIKKX399;;XXXr>r)rrrr7rrr__dict__rrrKrrrrlrr(r)r rrr) r5rrr authorizedradapter_allow_fromallowed callback_authrrrrs r _is_user_authorized_from_messagez0TelegramAdapter._is_user_authorized_from_messageOs33G<<.  4%) $* 5 5 5!%!2!6!67I!J!J  !%!2!6!6|!D!D   )'(:;;G G+=sg~J   M--.LMMM &&  !%% #$*N&,&6&,&6&,&6 ""JJ!D  WT+=tDDjRVWWFf&;TBBG  99;; 4!%ggfoo!6!6JJ LLN!%!  *+CDDJJLLK tXX+2C2CC2H2HXXXK +Ew+/EJ  4<Q1R1R !*!6s9~~~D@r>c|sdS|dp|d}|t|ndS)Ndirect_messages_topic_id!telegram_direct_messages_topic_idr)rrtopic_ids r"_metadata_direct_messages_topic_idz2TelegramAdapter._metadata_direct_messages_topic_idsH 4<< :;;px||Lo?p?p ( 4s8}}}$>r>cZ|sdS|d}|t|ndS)Ntelegram_reply_to_message_id)rr)rrreply_tos r_metadata_reply_to_message_idz-TelegramAdapter._metadata_reply_to_message_ids6 4<< >?? ( 4s8}}}$>r>c ||;t|o+|do||duS|r|drdSt|o|o|dS)N telegram_dm_topic_reply_fallback"telegram_dm_topic_created_for_sendF)rrrr )rrKrrs r_is_private_dm_topic_sendz)TelegramAdapter._is_private_dm_topic_sends  1 1( ; ; GLLL!CDDL55h??tK    %IJJ 5  A A ?@@   r>cdS)Nz`Telegram DM topic delivery requires a reply anchor; refusing to send outside the requested topicrrr>r_dm_topic_missing_anchor_errorz.TelegramAdapter._dm_topic_missing_anchor_errorsqqr>r r9c|rt|S|r2|dr|dkrdS||SdS)Nr off)rrr )rr rr9s r_reply_to_message_id_for_sendz-TelegramAdapter._reply_to_message_id_for_sends]  !x==  ? %GHH ?%%t44X>> >tr>reply_to_message_idc|r|drx|dkrd||iS|||}|+||}|dt |dSiSd||iS||}|dt |dSd||iS)aAReturn Telegram send kwargs for forum and direct-message topic routing. Supergroup/forum topics use ``message_thread_id``. True Bot API Direct Messages topics can opt in with explicit ``direct_messages_topic_id`` metadata. Hermes-created private-chat topic lanes are marked with ``telegram_dm_topic_reply_fallback``. Live replies send the private topic thread id together with a reply anchor; synthetic/resumed sends without an anchor use ``direct_messages_topic_id`` when metadata has it. ``message_thread_id`` alone can render outside the visible lane. When ``reply_to_mode`` is ``"off"``, the reply anchor is suppressed for DM topic fallback sends while preserving the ``message_thread_id`` so the message still lands in the correct topic. r rrN)rr)r_message_thread_id_for_sendr rr)rrKrrrr9direct_topic_ids r_thread_kwargs_for_sendz'TelegramAdapter._thread_kwargs_for_sends .  U %GHH U%%+S-L-LY-W-WXX"*&)&G&G&Q&Q#"*"%"H"H"R"R".-1474H4H ')H)H)S)ST T@@JJ  &%),/,@,@ $S%D%DY%O%OPPr>cX|rt||jkrdSt|Sr7)r_GENERAL_TOPIC_THREAD_IDrrrs rrz+TelegramAdapter._message_thread_id_for_sends. C NNc.JJJ49~~r>c(|sdSt|Sr7)rrs r_message_thread_id_for_typingz-TelegramAdapter._message_thread_id_for_typings 49~~r>r cHdt|vS)Nthread not found)rr)r s r_is_thread_not_found_errorz*TelegramAdapter._is_thread_not_found_error!s!SZZ%5%5%7%777r>c||dSt|dd}|dSt|dd}|t|dsdS |t|t|}n5#t$r(t d|j||dYdSwxYw|r$t d |j||dSdS) uNDrop the stale ``telegram_dm_topic_bindings`` row for a topic Telegram has confirmed deleted. Without this prune the recovery logic in ``gateway.run._recover_telegram_topic_thread_id`` keeps steering future inbound messages to the dead thread (the bug behind #31501 — tool progress, approvals, replies all end up in the wrong place even though the user has moved on to a fresh topic). Best-effort: we never raise from a send-fallback path — a failed cleanup must not turn into a failed user-facing send. N_session_store_dbdelete_telegram_topic_binding)rKruR[%s] delete_telegram_topic_binding failed for chat=%s thread=%s — skipping pruneTr#zY[%s] Pruned stale Telegram DM topic binding chat=%s thread=%s (Bot API: thread not found)) rlhasattrr$rrr(r)rr)r5rKrstoredbremoveds r_prune_stale_dm_topic_bindingz-TelegramAdapter._prune_stale_dm_topic_binding%s ?i/ F.55 = F UE4 ( ( :WR)HII: F 66G I7GG    LL7 7I     FF     KK@ 7I       s1A44.B&%B&c|jj}|dks|drdS ddlm}t ||S#t$rYdSwxYw)N badrequestTr BadRequestF)rrrendswithtelegram.errorr- isinstancer)r rr-s r_is_bad_request_errorz%TelegramAdapter._is_bad_request_errorNs'--// <  4==#>#> 4  1 1 1 1 1 1eZ00 0   55 sA A! A!c"|r|dsdS||sdSt||dvrdS|drd}t fd|DrdSdS) uTrue when a DM-topic send should be retried with routing stripped. Two cases trigger the retry: 1. The original anchor-stale case — the reply target was deleted, so Bot API returns "message to be replied not found". The retry drops the reply anchor and the topic id together. 2. The synthetic-event case (added when #27937 introduced ``direct_messages_topic_id`` fallback for sends without an anchor): if Bot API rejects the topic id itself with any BadRequest that mentions topic/thread routing, we retry without routing rather than dropping the message. r FNmessage to be replied not foundTr)direct_messages_topiczmessage thread not foundr topic_closed topic_deletedztopic not foundc3 K|]}|vV dSr7r)rMmarker err_lowers rrzNTelegramAdapter._should_retry_without_dm_topic_reply_anchor..s(CC66Y&CCCCCCr>)rr1rrr)rr rr topic_markersr9s @r+_should_retry_without_dm_topic_reply_anchorz;TelegramAdapter._should_retry_without_dm_topic_reply_anchorYs* X\\*LMM 5((// 5JJ$$&&  */PT]/]/]4 <<2 3 3 MCCCC]CCCCC tur>send_fn send_kwargs media_label reset_mediac K |di|d{VS#t$r}||||std|j|t || |t |}d|d<|dd|dd|di|d{VcYd}~Sd}~wwxYw)zFRetry stale private-topic media replies once without the topic anchor.NzR[%s] Reply target deleted for Telegram %s, retrying without reply/topic anchor: %srrrr)rr;r(r0rrdictpop) r5r<r=rrr>r?send_err retry_kwargss r&_send_with_dm_topic_reply_anchor_retryz6TelegramAdapter._send_with_dm_topic_reply_anchor_retrys6 1 //;//////// / 1 1 1CC#   NN: +H55    &  ,,L26L. /   0$ 7 7 7   7 > > > 00<00000000 0 0 0 0 0 0) 1s  CB C<CCc&t|jddr |jjdgng}t |t r|d}t|rdd|DndS)zNReturn validated fallback IPs from config (populated by _apply_env_overrides).rN fallback_ipsrc34K|]}t|VdSr7rLrMvs rrz0TelegramAdapter._fallback_ips..s(-I-Ic!ff-I-I-I-I-I-Ir>) rlr7rrr0rrrrr5 configureds r _fallback_ipszTelegramAdapter._fallback_ipssBI$+W^`dBeBemT[&**>2>>>km j# & & /#))#..J$Z%aSXX-I-Ij-I-I-I%I%I%I]abbbr>ct|}|jjdkpd|vpd|vS)Nconflictz&terminated by other getupdates requestzanother bot instance is running)rrrr)r rs r_looks_like_polling_conflictz,TelegramAdapter._looks_like_polling_conflictsQ5zz!! O $ * * , , : 974? 90D8 r>c|jj}|dvrdS|dvrdS ddlm}m}m}m}m}m }t|||||frdSt|||frdSn#t$rYnwxYwt|tS)zDReturn True for transient transport failures that warrant reconnect.> forbiddenr+ retryafter invalidtokenF>timedout networkerrorconnectionerrorTr)r- Forbidden InvalidToken NetworkError RetryAfterTimedOut) rrrr/r-rXrYrZr[r\r0rOSError)r rr-rXrYrZr[r\s r_looks_like_network_errorz)TelegramAdapter._looks_like_network_errors'--// L L L5 B B B4                 %*lIz!RSS u%,!9:: t     D %)))s$A'A'' A43A4ct}|g}|r|}t|}||vr*|||jj}t|}d|vsd|vsd|vrdSt|dd}t|dd}|| ||| ||dS) a*Return True when a Telegram TimedOut wraps a connect-timeout. A plain Telegram TimedOut may mean the request reached Telegram and should not be re-sent. A ConnectTimeout means the TCP connection was never established, so retrying is safe and prevents silent drops. connecttimeoutzconnect timeoutzconnect timed outT __cause__N __context__F r8rBraddrrrrrlr  r seenstackcuridentrrcausecontexts r_looks_like_connect_timeoutz+TelegramAdapter._looks_like_connect_timeouts&+W &))++CsGGE}} HHUOOO=)//11Ds88>>##D4''+<+D+DH[_cHcHctCd33Ec=$77G  U###" W%%% & ur>ct}|g}|r|}t|}||vr*|||jj}t|}d|vs d|vsd|vrd|vrdSt|dd}t|dd}|| ||| ||d S) aReturn True when a Telegram TimedOut wraps an httpx pool timeout. PTB converts ``httpx.PoolTimeout`` into ``telegram.error.TimedOut`` with a message that explicitly states the request was *not* sent (``"Pool timeout: All connections in the connection pool are occupied. Request was *not* sent to Telegram."``). Because the request never left the process, re-sending is safe and cannot duplicate -- the opposite of a generic TimedOut, which may have reached Telegram. We match the wrapped ``httpx.PoolTimeout`` class as well as the message string so the check survives PTB message-wording changes. pooltimeoutz pool timeoutzconnection pooloccupiedTraNrbFrcres r_looks_like_pool_timeoutz(TelegramAdapter._looks_like_pool_timeouts &+W &))++CsGGE}} HHUOOO=)//11Ds88>>##D$$$(>(>!T))jD.@.@tCd33Ec=$77G  U###" W%%%# &$ur>Frc(t|jddr|jj|nd}||St |t r4|}|dvrdS|dvrdS|St|S)Nr>r%onrrT>0norfalseF) rlr7rrr0rrrr)r5rrrlowereds rr\z"TelegramAdapter._coerce_bool_extras.5dk7D.Q.Q[ !%%c***W[ =N eS ! ! kkmm))++G444t555uNE{{r>ct|jddr|jj|nd}||S t |}n#t t f$r|cYSwxYw|t||}|t||}|S)Nr) rlr7rrrrrrQr0)r5rrr+r,rparseds rrcz#TelegramAdapter._coerce_float_extras/6dk7D.Q.Q[ !%%c***W[ =N 5\\FF:&   NNN   ++F  ++F sA A#"A#cbt|ddsiStdtdiSddiS)Nr]Flink_preview_optionsT) is_disableddisable_web_page_preview)rlrwr4s r_link_preview_kwargsz$TelegramAdapter._link_preview_kwargs1sDt5u== I  )*,>4,P,P,PQ Q*D11r>contentc2t||jkS)aCheap pre-check for the one hard rich limit we can count locally. Only the 32,768 UTF-8 character text cap is enforced here. Other Bot API rich limits (500 blocks, 16 nesting levels, 20 table columns, ...) are not pre-counted; if exceeded Telegram returns a BadRequest, which :meth:`_is_rich_fallback_error` classifies as permanent so the send degrades to the legacy chunking path. )lenRICH_MESSAGE_MAX_CHARSr5r~s r_content_fits_rich_limitsz)TelegramAdapter._content_fits_rich_limitsCs7||t:::r>cRtjt|jddS)uTrue when the bound bot can issue raw ``sendRichMessage`` calls. Gates on ``do_api_request`` being an *async* callable. The real ``telegram.Bot.do_api_request`` is a coroutine function; test doubles that opt into rich set it to an ``AsyncMock`` (also a coroutine function). Plain ``MagicMock`` bots expose a *sync* auto-child and ``SimpleNamespace`` bots lack the attribute entirely — both resolve to ``False`` here, so the legacy path is used unchanged. do_api_requestN)inspectiscoroutinefunctionrlrWr4s r_bot_supports_richz"TelegramAdapter._bot_supports_richNs%*749>NPT+U+UVVVr>z]*>.*?z(\$\$.*?\$\$|\\\[.*?\\\]|\\\(.*?\\\)|\\(?:sum|frac|alpha|beta|gamma|delta|theta|lambda|mu|pi|sigma|int|prod|sqrt|lim|infty|begin\{(?:equation|align|matrix|cases)\}))u.[぀-ヿ㐀-䶿一-鿿가-힯豈-﫿𠀀-𲎯]c|sdS|j|D]}|j|rdS dS)aReturn True for rich-message details+math content that crashes TDesktop. Telegram Desktop 6.9.1 can crash while rendering Bot API 10.1 rich messages containing math inside a collapsible details block (telegramdesktop/tdesktop#30808). The Bot API accepts the payload, so Hermes must skip rich delivery up front and use the legacy MarkdownV2 path until affected Desktop clients age out. FT)_RICH_DETAILS_REfindall_RICH_MATH_IN_DETAILS_REsearch)r5r~ details_blocks r._has_telegram_desktop_details_math_crash_shapez>TelegramAdapter._has_telegram_desktop_details_math_crash_shapens[ 5!2::7CC  M,33MBB tt ur>cTt|o|j|S)asReturn True for CJK content that current TDesktop rich drafts garble. Telegram Mac/Desktop Bot API 10.1 rich-message rendering currently leaves overlapping draft/overlay glyph artifacts for CJK text (#47653). The legacy MarkdownV2 path renders the same text cleanly, so skip rich delivery up front until affected clients age out. )r _RICH_CJK_RErrs r+_has_telegram_desktop_cjk_rich_garble_shapez;TelegramAdapter._has_telegram_desktop_cjk_rich_garble_shape~s(GA 1 8 8 A ABBBr>c|sdStd|DrdStjd|rdStjd|rdSd|vrdSdS)aReturn True for markdown constructs that the legacy path degrades. Keep ordinary replies on the pre-rich MarkdownV2 path so Telegram clients render a consistent font weight/spacing. The rich endpoint is reserved for constructs where raw markdown materially improves output: pipe tables (MarkdownV2 has no table syntax and rewrites them into bullet lists), GFM task lists, collapsible ``
`` blocks, and block math. Adapted from #45995 (@YonganZhang). Fc3>K|]}tj|VdSr7)_TABLE_SEPARATOR_REmatchrMlines rrz8TelegramAdapter._needs_rich_rendering..s.PP4"(..PPPPPPr>Tz(?m)^\s*[-*]\s+\[[ xX]\]\s+z3(?m)^|^z$$)r splitlinesrrrs r_needs_rich_renderingz%TelegramAdapter._needs_rich_renderings 5 PP7;M;M;O;OPPP P P 4 93W = = 4 9KW U U 4 7??4ur>c>tt|ddS)zcht|ot|dd o|o}|oi||oT|| o>|| o(||o|S)aCapability/content eligibility for rich, ignoring ``expect_edits``. Shared core of :meth:`_should_attempt_rich` minus the per-call ``expect_edits`` metadata gate. The rich EDIT-finalize path (:meth:`_try_edit_rich`) needs this: a streamed preview is sent with ``expect_edits=True`` to stay on the editable path mid-stream, but the FINAL edit should still upgrade to rich when the content warrants it. r`F) rrrlrrrrrrrs r_rich_eligiblezTelegramAdapter._rich_eligibles  ' ' ) ) *D"7??? * *  ***733  * GGPPP  * DDWMMM  *..w77 *''))   r>cvt|pid o||S)N expect_edits)rrrr5r~rs r_should_attempt_richz$TelegramAdapter._should_attempt_richsDR$$^44 4 -##G,,   r>cdS)uUWhether to replace a streamed preview with a fresh rich final. Disabled for Telegram. The fresh-final path briefly shows two copies of the final answer, then deletes the streaming preview after the rich send succeeds — it looks like duplicate delivery at the end of every streamed turn (the reason #46206 reverted it). Rich finalize is instead handled by editing the existing preview in place via Bot API 10.1's ``editMessageText`` ``rich_message`` parameter (see :meth:`_try_edit_rich`), so no fresh re-send / delete is needed. Frrs rprefers_fresh_final_streamingz-TelegramAdapter.prefers_fresh_final_streamings ur>ct|ddr,t|dds|r|jSdS)uDAllow the stream consumer to accumulate up to the rich-message cap before splitting, so a reply that fits one ``sendRichMessage`` / ``sendRichMessageDraft`` isn't fragmented at the 4,096 MarkdownV2 limit. Gated on the same rich capability as the send path (minus the content-length check — raising that cap is the whole point): rich not latched off and the bot exposes an async ``do_api_request``. Returns ``None`` (→ legacy 4,096 limit) when rich isn't available, so non-rich streams split exactly as before. r^Tr`FN)rlrrr4s rstreaming_overflow_limitz(TelegramAdapter.streaming_overflow_limitsT D2D 9 9 /D"7?? /'')) / . .tr>)skip_entity_detectionrc6dt|i}|rd|d<|S)uBuild the ``InputRichMessage`` object from RAW markdown. Never pass ``format_message(content)`` here — that converts to MarkdownV2 and would escape/destroy rich syntax like table pipes. Single newlines are normalized to Markdown hard breaks so that multi-line content (slash-command lists, etc.) renders correctly in the rich-message path. See ``_rich_normalize_linebreaks``. markdownTr)r)r5r~rpayloads r_rich_message_payloadz%TelegramAdapter._rich_message_payloads/$./I'/R/R"S  4/3G+ ,r>excc.|jj}|dvrdSt|tt t frdSt|dddkrdSt|}d|vsd|vr d|vsd |vrdSd |vS) ufTrue ⇒ the rich endpoint itself is unavailable (old PTB/server). These latch rich off for the rest of the adapter's life — retrying is pointless and would cost a failed roundtrip on every send. Per-message rejections (BadRequest from a parser/limit issue) are NOT capability errors: the next message may be fine. >rTendpointnotfoundT error_codeNimethodendpointz not foundzdoes not existzno such method) rrrr0AttributeErrorrNotImplementedErrorrlr)r5rrss r_is_rich_capability_errorz)TelegramAdapter._is_rich_capability_errors}%++-- 7 7 74 cNI7JK L L 4 3 d + +s 2 24 HHNN   MMZ1__ 1   0A 5 541$$r>c||rdS||rdSt|}d|vpd|vS)uyTrue ⇒ permanent/capability error ⇒ safe to fall back to legacy. Conservative on purpose: only clearly-permanent failures (BadRequest, capability errors, unknown/unsupported endpoint) qualify. Everything else is treated as transient — the rich request may have reached Telegram, so we must NOT legacy-resend and risk a duplicate. T unsupportedznot implemented)r1rrr)r5rrs r_is_rich_fallback_errorz'TelegramAdapter._is_rich_fallback_errorse  % %c * * 4  ) )# . . 4 HHNN  !;%6!%;;r>c||}||||}|o.|jdko#t|o|d}|p|r|t |nd}|r|duo |jdk} n||d} | r|rt|nd} ||||| |j} |r| |s| dsdS| | fS)u;Routing for a single (rich) send — mirrors send()'s index-0 block. Returns ``(reply_to_id, thread_kwargs)``, or ``None`` to signal "skip rich, let the legacy path handle it" — used for the DM-topic fail-loud case so the legacy path stays the single source of the refuse result. rr Nrrr9r) r rr[rrr_should_thread_replyrr) r5rKr rrmetadata_reply_toprivate_dm_topic_senddm_topic_reply_to_offreply_to_source should_thread reply_to_id thread_kwargss r_compute_single_send_routingz,TelegramAdapter._compute_single_send_routings_!>>xHH $ > >w S[ \ \ ! T#u, TXR(,,/Q"R"RSS  # $ ):)F ! " " "  ! J+47XDcK||}|||||}|dS|\}}t|||d} | d|D| ||t|ddrddi| d<|d |i| d < |j d | d{V} n#t$ry} | | rP| | rd|_ td |jt#| Yd} ~ dSt%| } ddlm} n#t,t.f$rd} YnwxYw| rt1| | pd| v}|| }t| dd}|Dddl}|d| |j}|r"t;|d}t#| }td|j|tAd||p| |cYd} ~ Sd} ~ wwxYwd}t1| tBrB| "d }|*| "dpi"d }nt| d d}|I ddl#m$}|%t%|t%||n#t$rYnwxYwtAd|t%|ndS)a#Attempt a single ``sendRichMessage`` send. Returns a :class:`SendResult` (success, or a transient failure that the caller must NOT legacy-resend), or ``None`` to signal "fall back to the legacy MarkdownV2 path" (permanent/capability error or DM-topic skip). N)rK rich_messageci|] \}}||| Sr7rrMkrJs r z2TelegramAdapter._try_send_rich.._PPPA!-1---r>r]Fr{Trz message_idreply_parameterssendRichMessage api_kwargsuA[%s] sendRichMessage rejected (%s) — falling back to MarkdownV2rr\ timed out retry_afterzretry\s+(?:in\s+)?(\d+)rz=[%s] sendRichMessage transient failure (no legacy resend): %s)successr rrrgrich_sent_storerr)&rrrrupdateitemsrrlrWrrrrr`r(r)rrrrr/r\rrr0rlrr IGNORECASErrr0rrArgatewayrrecord)r5rKr~r rrroutingrrrmsgrerr_str _TimedOut is_timeoutis_connect_timeout _retry_after_re_m safe_errorrrs r_try_send_richzTelegramAdapter._try_send_richEs*,,X66 33GXxQZ[[ ?4%," ]2':: 66w??# #  PP)<)<)>)>PPPQQQt00::;;; 415 9 9 D/.rr>r]Fr{TrzeditMessageTextr not modifiedruK[%s] rich editMessageText rejected (%s) — falling back to MarkdownV2 editrrrzB[%s] rich editMessageText transient failure (no legacy resend): %srr rr) rrrrrr[rrrlrWrrrrr`rrrr(r)rrr/r\rrr0rlr0rrr)r5rKrr~rrrrrrrrrrrs r_try_edit_richzTelegramAdapter._try_edit_richsz*2'::j// 66w??# #  ,,X66 44    $- 5   PP)<)<)>)>PPPQQQ 415 9 9 D/>>>st4"C I6#A$I1I6 .I13I14I6:!I1G#"I1#G96I18G99A2I1+I61I6:7J22 J?>J?c~tt|ddot|ddot|dd o|t|dd oj|oh|oT|| o>|| o(||o|S)Nr^Tr_Fr`ra)rrlrrrrrrs r_should_attempt_rich_draftz*TelegramAdapter._should_attempt_rich_drafts D2D 9 9 *4e<< *D"7??? *D"8%@@@ * *   * GGPPP *DDWMMM *..w77 *''))   r>draft_idcDKt|t|||d}||}|t||d< |jd|d{V}t |S#t$r}||r6d|_ t d|j t|n.t d|j t|Yd}~d Sd}~wwxYw) uEmit one ``sendRichMessageDraft`` preview frame; True on success. Draft frames are ephemeral and overwritten by the next frame / the final ``sendRichMessage``, so a duplicate or lost rich draft is harmless — any failure simply returns False and the caller renders the legacy plain-text draft. A permanent/capability failure additionally latches ``_rich_draft_disabled`` so later frames skip the rich attempt. )rKrrNrsendRichMessageDraftrTuB[%s] sendRichMessageDraft unsupported (%s) — using legacy draftsuL[%s] sendRichMessageDraft transient failure (%s) — legacy draft this frameF)rrrrrWrrrrrar(r)rr) r5rKrr~rrrokrs r_try_send_rich_draftz$TelegramAdapter._try_send_rich_draftsH 2'::H  66w??# #  ,,X66  +.y>>G' ( y//0FSZ/[[[[[[[[B88O   --c22 ,0) XI:3??  bI:3??55555 s 0B DA9DDcdK|jr |jjsdS |jjjd}n#t$rYdSwxYw t j|td{Vn2#t$r%t d|j dYnwxYw t j| td{Vt d|j dS#t$r&t d|j dYdSwxYw) urReset the httpx connection pool used for getUpdates polling. Network errors (especially through proxies like sing-box) can leave httpx connections in a half-closed state that still occupy pool slots. After enough reconnect cycles the pool fills up entirely, causing ``Pool timeout: All connections in the connection pool are occupied.`` We reset ONLY ``_request[0]`` (the getUpdates request) — the general request (``_request[1]``) is left untouched so concurrent ``send_message`` / ``edit_message`` calls are never interrupted. Implementation note: accesses ``Bot._request[0]`` which is the get-updates ``BaseRequest`` in the PTB 22.x internal tuple ``(get_updates_request, general_request)``. There is no public accessor for the polling request; review if upgrading to PTB 23+. Nrr,z:[%s] Polling request shutdown failed/timed out (non-fatal)Tr#z2[%s] Polling request pool drained before reconnectz?[%s] Polling request re-initialize failed/timed out (non-fatal)) rVrirjrr&wait_forrk_DRAIN_TIMEOUTr(r)r initialize)r5 polling_reqs r_drain_polling_connectionsz*TelegramAdapter._drain_polling_connections;s"  dim  F )-03KK    FF  ";#7#7#9#9>RRR R R R R R R R R    LLL D        ";#9#9#;#;^TTT T T T T T T T LLDdi         LLQ D        s11 ??3A77,B&%B&*AC??,D/.D/ct|ddrNd|_d|_t|dd}|tj}||_t|dd|fSt|dd}|(|s|d|_t|ddd z|_ tj|_d|_d|_|j |jfS) zAStart accepting progress for a new getUpdates polling generation.rwFTrtNrsrrvr) rlrurr&rOrtr9rVrvrs)r5progressverifiers r_begin_polling_generationz)TelegramAdapter._begin_polling_generationhs 44e < < E/4D ,'+D $t%>EEH"=??/7,4!6::HD D4!BDII     OO   /3,#*41F#J#JQ#N '.}$+/(#' ')EEEr> generationct|ddrdS|jsdS||jkrdS|jd|_||jkrd|_nd|_d|_dS)zARecord successful getUpdates I/O for the current generation only.rwFNr) rlrursrtr8rrrqrpr)r5rs r_record_polling_progressz(TelegramAdapter._record_polling_progress}s 44e < <  F/  F 1 1 1 F $((***,-) C C C9=D 6 6+,D (#(   r>c|\}}|d|cxkrdksndS ||}n#t$rYdSwxYwt|tr2|ddurd|vr||dSdSdSdS)aRecord getUpdates progress from an observed do_request result. Purely observational: PTB still parses the untouched payload and owns any resulting exception. Kept as its own method so the observation logic is shared and independently testable. Ni,rTrg)parse_json_payloadrr0rArr)r5rorrg status_coderenvelopes r_observe_polling_request_resultz/TelegramAdapter._observe_polling_request_results & W  c[&>&>&>&>3&>&>&>&> F 11'::HH    FF  x & & 6 T""d**H$$  ) )* 5 5 5 5 5  6 6**$$s 0 >>cX|t|}Gfdd|}||_|S)aInstrument one dedicated PTB getUpdates request with progress tracking. PTB's request classes (``BaseRequest`` / ``HTTPXRequest``) use ``__slots__``. On Python 3.13 their instances no longer carry a ``__dict__`` (the ``AbstractAsyncContextManager`` MRO stopped yielding one), so ``request.do_request = wrapper`` raises ``AttributeError: 'HTTPXRequest' object attribute 'do_request' is read-only`` and the whole Telegram connect fails (#64482). It only appeared to work on Python 3.12, where those instances still had a ``__dict__``. Instead of monkey-patching the instance, re-tag it to a thin subclass that overrides ``do_request``. This is portable across Python versions and works for both the real request and the test doubles. The subclass declares ``__slots__ = ()`` so its instance layout stays identical to the base, which is what makes the ``__class__`` swap legal on a slotted instance. c&eZdZdZfdZxZS)PTelegramAdapter._instrument_polling_request.._InstrumentedPollingRequestrcKt}tj|i|d{V}||||Sr7)rrrS do_requestr)r5argskwargsrrgradapters rr z[TelegramAdapter._instrument_polling_request.._InstrumentedPollingRequest.do_requestsb8<<>> 1uww14B6BBBBBBBB77j&QQQ r>)rrr __slots__r  __classcell__)rrs@r_InstrumentedPollingRequestr sCI          r>r)rr)r5robase_clsrrs @r_instrument_polling_requestz+TelegramAdapter._instrument_polling_requestsX&==       (   8r>)abandon_app_on_timeoutschedule_verifierdrop_pending_updatesrrc Ktddrtd\ }jstddtddf fd }t  } t|j tj ||t|r|fd nd d{Vt |n#t |wxYwtddrd_d _td|r | |fS) uStart one generation and verify real getUpdates progress. Returns the ``(generation, progress_event)`` pair created for this polling generation so callers that must gate on readiness (strict cold start, #67498) can bind to exactly this generation instead of re-reading ``self._polling_progress_event`` — which a concurrent recovery task may have replaced with a newer generation's event. rwFz!Telegram polling teardown startedr r NctddrdSjkrdSatd} |t|dS#t|wxYwdS)NrwF)rlrsrr8reset)r callback_context_tokenerror_callbackrr5s r_generation_error_callbackzGTelegramAdapter._start_polling_once.._generation_error_callbackst8%@@ T555))D)H)H)N)N&N"N5)))/556LMMMMM/556LMMMM *)s A&&B)allowed_updatesrrc t|Sr7rprms rz5TelegramAdapter._start_polling_once..s%r,r4T)rlrrrurrr8r_updater start_pollingrq ALL_TYPES_UPDATER_START_TIMEOUTrr#_schedule_polling_progress_verifier) r5rmrrrrrr context_tokenrs ` ` @r_start_polling_oncez#TelegramAdapter._start_polling_onces" 44e < < N()LMM M#==?? H/ N()LMM M Ni ND N N N N N N N N477 CC  = . ))$*$4)=#=* /.AAAA           ( - -m < < < < ' - -m < < < < 44e < < N/4D ,'+D $()LMM M  K  4 4Z J J J8##s ?A C##C?rctddrd_d_dStdd}|(|s|t j||}|_ j |dt j ddffd }| |dS) z._clear_finished_verifier s?  " * *8 4 4 43x??7;444@?r>)rlrurr9rVr&rL create_task_verify_polling_after_reconnectrvr.rdTaskrW)r5rrpreviousr!r0s` rr(z3TelegramAdapter._schedule_polling_progress_verifier s 44e < < /4D ,'+D $ F4!BDII     OO   '))55  0 0X F F  04, ""4((( c`t|dd}|tj}||_|S)Nr)rlr&rr)r5locks r_get_general_request_drain_lockz/TelegramAdapter._get_general_request_drain_lock s1t:DAA <<>>D/3D , r>cKtt|dddd}|t|dd}|dS |jd}n#t$rYdSwxYw|4d{V |d{Vn2#t$r%t d|jdYnwxYw |d{Vt d |jn2#t$r%t d |jdYnwxYwdddd{VdS#1d{VswxYwYdS) a4Reset the Bot API request pool after a confirmed send pool timeout. ``send_message`` uses PTB's general request pool (``_request[1]``). When httpx reports that this pool is exhausted, PTB says the request was not sent, so it is safe to reset the wedged pool before retrying. rVNrirWrzC[%s] General request shutdown failed after pool timeout (non-fatal)Tr#z=[%s] General request pool drained after Telegram pool timeoutzH[%s] General request re-initialize failed after pool timeout (non-fatal)) rlrjrr7rkr(r)rrr0)r5ri general_reqs r-_drain_general_connections_after_pool_timeoutz=TelegramAdapter._drain_general_connections_after_pool_timeout' sWgdFD115$?? ;$--C ; F ,q/KK    FF 7799         !**,,,,,,,,,,    YI  !,,.........SI    ^I                               sk A AA4E6BE,C=E?CE:C?>E?,D.+E-D..E EEreasoncRt|ddrdS|jrdS|jrJ|js1td|j|t|dSd|_t d|j|t|tj }| | ||_|j|j|j|jjdS)aySchedule polling recovery without failing gateway startup. A Telegram bootstrap failure (deleteWebhook / initial start_polling) caused by a transient network error should degrade only the Telegram adapter: the gateway process stays alive and the existing reconnect ladder (``_handle_polling_network_error``) recovers in the background. rwFNzA[%s] Telegram polling recovery already scheduled; ignoring %s: %sTzR[%s] Telegram polling degraded (%s); gateway stays alive and will retry. Error: %s)rlhas_fatal_errorror9r(r)rrrr0r&rLr1_handle_polling_network_errorr.rdrWr/)r5r r;rAs r_schedule_polling_recoveryz*TelegramAdapter._schedule_polling_recoveryL s& 44e < <  F    F  # D,D,I,I,K,K  LLS 6#>u#E#E    F#'  ` Iv:5AA   '))#'#3#3D4V4VW\4]4]#^#^  ""4#;<<<  2243I3QRRRRRr>require_successrAcK|jsdSt|jdd}t|sdS t|dtd{VdS#t $rh}||rM|rtd|t d|j t|d|_ Yd}~dSd}~wwxYw) a>Clear stale webhook, optionally failing closed on initial connect. Reconnect can recover a transient error in background. Cold startup uses ``require_success`` so GatewayRunner disposes the partial adapter and retries with a fresh PTB Application instead of publishing degraded state. Fdelete_webhookNT)rrz>Telegram deleteWebhook did not complete during initial connectzu[%s] deleteWebhook failed with a recoverable network error; continuing to polling so getUpdates/retry can recover: %s) rWrlrr_r'rr^r]r(r0rrr)r5rArCerrs r_delete_webhook_best_effortz+TelegramAdapter._delete_webhook_best_efforth s3y 5 ,._strict_error_callback sd (%1&u---F#/ ''...))*<*@AAAAAr>)rrrrrz,Telegram getUpdates made no progress within .0fuas during initial connect — failing startup so the gateway retries with a fresh adapter (#67498)return_exceptionszQTelegram polling errored before first getUpdates success during initial connect: rz?Telegram getUpdates did not become ready during initial connectz[[%s] Telegram polling bootstrap conflict; gateway stays alive while conflict retry runs: %szpolling bootstrapr;)$rlrVr$ RuntimeErrorr&rOrLrr*rKrTr_rc!_INITIAL_POLLING_PROGRESS_TIMEOUTrYr]r9rVgatherrDrrxrrPr(r0rr1_handle_polling_conflictror.rdrWr/r^r?)r5rrrFeffective_callbackrLrr progress_wait error_waitrfutrDrArIrJrKs ` @@@@r_start_polling_resilientz(TelegramAdapter._start_polling_resilient s 44e < < 5  Odi/ OMNN N-/ $]__+  8+--D Bi BD B B B B B B B B B B"8 N *.)A)A %91'7'7"6*B**$$$$$$ J ' B!( 5hmmoo F F $23E3J3J3L3LMM 5( CC A+!1<S111   !.z:))"xxzz)JJLLL!.%zT!.z:))"xxzz)JJLLL!.%zT +(9(9+!J6|AGGJJ(? +  ((!Y $) 3A04%   55   t8%@@ uuuuu 0055 4I:3?? /11+/+;+;Dr.rdrWr/ro) r5r MAX_NETWORK_RETRIES BASE_DELAY MAX_DELAYattemptrdelayrrm retry_errsafe_retry_errorr!s rr>z-TelegramAdapter._handle_polling_network_error s 44e < <  F    F    ))Q.))#' 3 ( ( (24GH  LL149gGbchGiGi j j j  ! !":Gt ! T T T3355 5 5 5 5 5 5 5 FJ!! "45yAA077  Y Iw 3UJ   mE""""""""" 44e < <  F i  s{ s{': "*3;+;+;+=+=G\]]]]]]]]]]]+NN9     D  44e < <  F--///////// 44e < <  F$ 0 Z"#XYYY**%*#?+        KK5 7      &    FF 0 0 0t8%@@ :9EE  NNGTd e e e( 0&A5II 0,66yAA&**4000&&t'='EFFF ,0((((((( 0 0 0 0 0 0 0 0 0 0 0 0 0s\2F78FF7/F30F72F33F77 GGAI M, M5M  B/M  McKd}d}d}d} tj|d{Vt|ddrdS|jrdS|j}||st j}||ur|}|}n||z tkr||z }t d|j | | n#t$rYnwxYw|d d |zd |d{VdSnd}|jr |jjnd}|t%t|d dsdStj||d{Vt j|_|t|d d|||d{Vn#tj$rYdStjt4f$r!} || dYd} ~ nLd} ~ wt$r<} || r|| dYd} ~ FYd} ~ nd} ~ wwxYwT)uDetect dead Telegram TCP sockets (CLOSE-WAIT) by periodic probing. PTB's long-poll task blocks on epoll waiting for Telegram to push an update. When the underlying TCP connection enters CLOSE-WAIT (the remote sent a FIN but the httpx pool has not yet noticed), epoll still reports the socket as readable and no exception is raised — so PTB's ``error_callback`` never fires and the gateway silently stops receiving messages. This loop probes ``get_me()`` every ``HEARTBEAT_INTERVAL`` seconds on the *general* request path (not the getUpdates pool), so a healthy long-poll waiting for the 30-second Telegram window is never interrupted. On any connect-level failure the loop hands off to ``_handle_polling_network_error`` — the same path triggered by PTB's own ``error_callback`` — which drains the dead pool and restarts polling. Unlike the generation verifier (a one-shot progress deadline after every polling start), this loop runs for the full lifetime of the polling connection, so it catches a socket that wedges later during steady-state operation without any prior error event. ZNrGTrwFz[%s] Telegram reconnect task wedged for %.0fs with no ladder progress; forcing retryable-fatal so the gateway reconnects instead of staying silently deaf.r]zDTelegram reconnect task wedged for %.0fs; forcing gateway reconnect.rget_merzheartbeat proberP)r&rarlr=ror9time monotonic!_POLLING_ERROR_TASK_STUCK_TIMEOUTr(r rrVrrr`rVrirrror{_note_bot_username_probe_pending_updatesr'rYr]r?r^) r5HEARTBEAT_INTERVAL PROBE_TIMEOUTstuck_task_refstuck_task_since recovery_tasknow stuck_forri probe_errs r_polling_heartbeat_loopz'TelegramAdapter._polling_heartbeat_loop sC,  26M L m$67777777774!rQrrrYr]r)r5rir~r$rArrpendings rrtz&TelegramAdapter._probe_pending_updates s7. 44e < <  F    F  # D,D,I,I,K,K ./D + F9=L'$)Y555 ?01D - Fw 511 12D -  + +q 0 + + NN2 4:    .!3323/4!>C!DD a<<01D - F ))Q.)) * Iw A    , 1 101D -t8%@@  NN-     +--D'+'7'722 ![\\((D $ $ $ 2 1s>#F""F<;F<cKd}t|ddrdS||j}||j} tj|t d{Vn#tj$rYnwxYwt|ddrdS|s|j rdS|j sdS||jkrdS||jurdS|j }|r|j r |j j sFtd|j|t%dd dS tj|j|d{Vn#t*$r}t|ddrYd}~dS|j s|j sYd}~dS||jkrYd}~dS||jus|rYd}~dS||s4td |jt/|Yd}~dStd |jt/|||d Yd}~dSd}~wwxYwt|ddrdS|j s|j sdS||jkrdS||jus|rdS|t%d d dS)aRequire getUpdates progress, using getMe only to classify failure. The generation-bound event is set only by a successful response on the dedicated getUpdates request. A general-path getMe success can classify connectivity, but cannot heal polling health. Connectivity failures enter the guarded recovery ladder; auth/validation errors do not churn. r[rwFNrz;[%s] Updater made no getUpdates progress and is not runningz3Updater not running after polling progress deadlinez.polling progress verifier: updater not runningrPzN[%s] Polling progress verifier hit a non-connectivity error (not retrying): %sz<[%s] Polling progress verifier connectivity probe failed: %sz.polling progress verifier connectivity failurez4getUpdates made no progress before verifier deadlinezFpolling progress verifier: general path healthy but getUpdates stalled)rlrsrtr&rrT_POLLING_PROGRESS_TIMEOUTrYrDr=rurVr$rbr(r0rr?rQrirorr^r)r5rrrvrmr|s rr2z/TelegramAdapter._verify_polling_after_reconnectg s 44e < <  F  1J  3H " )B        #    D  44e < <  F ??    4  F/  F 1 1 1 F 47 7 7 Fi   (;  NNM      + +RSSG ,    F "37>>#3#3]CC C C C C C C C C   t8%@@ # 4+K T555t;;;x?P?P;11)<< *I:9EE  NNN 6yAA     + +G ,    FFFFF1 4 44e < <  F   t'G  F 1 1 1 F 47 7 78??;L;L 7 F '' O P P[ (     sI3AA10A1(2E I&I=I I"IAIAIIc|jrt|jddnd}|dSdD]y}t||d}t|tjrL|s5|td|j |dSztd|j dS)uSynchronously stop PTB's internal polling retry loop. PTB wraps ``getUpdates`` in ``network_retry_loop`` with ``max_retries=-1`` (retry forever). When a ``TelegramError`` (including a 409 ``Conflict``) fires, that loop calls our ``error_callback`` *synchronously*, then sleeps and re-checks ``while is_running()`` before polling again. Our ``error_callback`` only schedules an async recovery task (``loop.create_task(...)``) and returns immediately, so PTB's loop keeps polling while our handler concurrently runs ``stop -> sleep -> start_polling``. The two polling sessions overlap and Telegram returns a fresh 409 — a self-inflicted conflict loop on a ~31s cadence. The loop is wired with ``is_running=lambda: updater.running`` and a private ``stop_event`` (``do_action`` races that event and returns the moment it is set). Setting that event *synchronously inside the callback* — before it returns — makes PTB's loop exit on its own next tick instead of racing our recovery. Our async handler then performs the real ``await updater.stop()`` (idempotent) followed by drain + ``start_polling()``, which builds a fresh ``stop_event`` so the restart is not poisoned. Best-effort and defensive: PTB names the attribute differently across versions (``_Updater__polling_task_stop_event`` via name-mangling), so we probe for both spellings. If neither is found we do nothing and fall back to the prior behaviour (async ``updater.stop()`` racing PTB) — i.e. we never make things worse than before. We deliberately do NOT fall back to flipping ``updater._running``: ``stop()`` raises ``RuntimeError`` when ``running`` is already False and our recovery handler guards its ``stop()`` call on ``running``, so clearing the flag here would skip the real teardown and leave PTB's stop_event uncleared — poisoning the subsequent ``start_polling()``. The stop_event lever leaves ``_running`` True, so the handler's ``await updater.stop()`` still runs, drains the polling task, and clears the event for a clean restart. r$N)!_Updater__polling_task_stop_event_polling_task_stop_eventz+[%s] Disarmed PTB polling retry loop via %szu[%s] Could not disarm PTB polling retry loop (stop_event not found on this PTB version); falling back to async stop()) rVrlr0r&rOrDr8r(r)r)r5r$attr stop_events r_disarm_ptb_retry_loopz&TelegramAdapter._disarm_ptb_retry_loop sL:>L'$)Y555 ? F  D!$55J*gm44 !((**NN$$$LLE 4    + I      r>c Kt|ddrdS|jr |jdkrdS|xjdz c_d}d|jdzz}|j|krtd|j|j||t| |jr|jj r|jj j rt tj |jj td{Vn5#tj$r#td |jYnwxYwn#t $rYnwxYwtj|d{Vt|ddrdS|d{Vt|ddrdS|j}|jdz}|st)d ||_ ||d |j d{Vtd |j|j| |j|kr d|_dSdS#t2$rY|j|kr d|_dSdSt $r}t|ddrYd}~|j|kr d|_dSdStd|j|j|t||j|krkt|ddsZtj}||||_Yd}~|j|kr d|_dSdSYd}~nd}~wwxYw|j|krd|_n#|j|krd|_wxYwt|ddrdSd|t=dt?d|dzDfz}t d|j|t||jo |jdk} |!d|d |jrI|jj r=tj |jj td{Vnj#tj$r#td|jYn9t $r-} td|j| d Yd} ~ nd} ~ wwxYw| s|"d{VdSdS)NrwFtelegram_polling_conflictrrr[u[%s] Telegram polling conflict (%d/%d) — previous session still held open on Telegram's servers. Waiting %ds for it to expire. Error: %srzZ[%s] updater.stop() timed out during conflict retry (likely CLOSE-WAIT socket); continuingz. s*(a(aa"f(a(a(a(a(a(ar>z[%s] %s Original error: %srzv[%s] updater.stop() timed out after exhausting conflict retries (likely CLOSE-WAIT socket); proceeding to fatal notifyzK[%s] Failed stopping Telegram updater after exhausting conflict retries: %sr#)#rlr=fatal_error_coderpr(r0rrrVr$rbr&rrcrdrYrrarrsrQrqr*rxrrrLr1rTrosumranger rr`) r5r MAX_CONFLICT_RETRIES RETRY_DELAYrmexpected_generationrjrAr_already_fatal stop_errors rrTz(TelegramAdapter._handle_polling_conflict s 44e < <  F   D$9=X$X$X F$ $$)$$  D82=>  '+? ? ? NN 479M8??     9!2ty7H7P%.ty/@/E/E/G/GQfggggggggggg"/K I     - ,, , , , , , , ,t8%@@ 1133 3 3 3 3 3 3 3t8%@@ )C"&":Q">  c"#abbb:MD 6. F..)-#'#C/  9It;=Q D=ATTTAED>>>UTC*   @=ATTTAED>>>UT?   4!>>UT9/It;=Q/ :: 03GGG#D*EuMMH#355D/3/?/?55i@@00D,FFF=ATTTAED>>>UT? >=ATTTAED>=ATTTAED>EEEE 44e < <  F  W $S(a(aeAG[^_G_>`>`(a(a(a%a%ab  c   ( Iw ;E B B      E%)DD  97eTTT y `TY. `&ty'8'='='?'?I^__________#    NNQ           NN] :            63355 5 5 5 5 5 5 5 5 5 6 6s $D%1=C/.D%//D!D% D!!D%% D21D29A H L$$L:; L$LL:/BLL:L:L$$L::M-AP>>/R%/ R%8#R  R%cKtj}|j|urd|_t|dd|urd|_|d{VdS)aNotify the runner without letting child teardown cancel this owner. The runner bounds adapter cleanup in a child task. ``disconnect()`` cancels the tracked polling-recovery task and the heartbeat task, so retaining the current notifier in either field would cancel the fatal callback before the runner can finish its reconnect or shutdown decision. Release only the current owner from whichever field tracks it; unrelated tasks remain under teardown control. Nry)r& current_taskrorlry_notify_fatal_error)r5rs rr`z,TelegramAdapter._handoff_polling_fatal_error sv+--  #| 3 3'+D $ 42D 9 9\ I I+/D (&&(((((((((((r> icon_coloricon_custom_emoji_idc FK|jsdS ||d}|||d<|r||d<|jjd i|d{V}|j}td|j||||S#t $r}t|} d| vsd| vr#td|j||n[d | vsd | vr#t d |j||n0t d |j||t|Yd}~dSd}~wwxYw)zCreate a forum topic in a private (DM) chat. Uses Bot API 9.4's createForumTopic which now works for 1-on-1 chats. Returns the message_thread_id on success, None on failure. N)rKrrrz5[%s] Created DM topic '%s' in chat %s -> thread_id=%stopic_name_duplicatealreadyzT[%s] DM topic '%s' already exists in chat %s (will be mapped from incoming messages)z not a forumforums_disabledz[%s] Cannot create DM topic '%s' in chat %s: Topics mode is not enabled. The user must open the DM with this bot in Telegram, tap the bot name at the top, and enable 'Topics' in chat settings before topics can be created.z2[%s] Failed to create DM topic '%s' in chat %s: %sr) rWcreate_forum_topicrr(rrrrrr0r) r5rKrrrrtopicrrN error_texts r_create_dm_topicz TelegramAdapter._create_dm_topic sy 4# 18$%G%GF%'1|$# F1E-.6$)6@@@@@@@@@@E/I KKG 4)       QJ&33yJ7N7N jItW*,,0AZ0O0OeItW HItW.I!.L.L44444+ sAA$$ D .B'DD parent_chat_idcK t|}n#ttf$rYdSwxYw|||d{V}|rt |ndS)a Create a forum topic for a session handoff. Works for DM topics (Bot API 9.4+, requires user to enable Topics in their chat with the bot) and forum supergroups. Returns the ``message_thread_id`` as a string, or ``None`` on failure. N)r)rrrrr)r5rr chat_id_intrs rcreate_handoff_threadz%TelegramAdapter.create_handoff_thread s n--KK:&   44 // $/GGGGGGGG !*4s9~~~4s )) topic_name force_createcdKt|pd}|sdS t|}n#ttf$rYdSwxYw|d|}|j|}|r|st|Sd}d} |jD]n} t| dt|kr6| } | dgD]} | d|kr| }n |rE|dr0|s.t|d} | |j|<t| S| |gd} |j| |-d|i}| dg|| |||d |d  d{V} | sdS| |d<t| |j|<| ||t| | t| S) zJReturn a private DM topic thread id, creating and persisting it if needed.rN:rKtopicsrrrKrrr)rrr)replace_existing) rrrrrrrrr  setdefaultr_persist_dm_topic_thread_id) r5rKrrrr cache_keycached topic_conf chat_entryentry candidaters rensure_dm_topiczTelegramAdapter.ensure_dm_topic s:#$$**,, 4 g,,KK:&   44 #++T++ $$Y//  , v;; /3 /3 +  E599Y''((C ,<,<<<J"YYx44   ==((D00!*JE1   "*..55 "l "J{344I)2DOI &y>> !  %0B??J  " ) )* 5 5 5   $J  ! !(B / / 6 6z B B B// !~~l33!+0F!G!G 0         4"+ ;%(^^ " ((dC NN]i(jjj9~~s;AAcK|jsdS t|}n#ttf$r|}YnwxYw|j|t||d{Vt d|j|||dS)z,Rename a forum topic in a private (DM) chat.N)rKrrz5[%s] Renamed DM topic in chat %s thread_id=%s -> '%s')rWrrredit_forum_topicr(rr)r5rKrr chat_id_args rrename_dm_topiczTelegramAdapter.rename_dm_topic< sy  F "g,,KK:& " " "!KKK "i((!)nn)          C Iw 4     s 33rc ddlm}|dz }|s#td|j|dSddl}t|dd5}||pi} dddn #1swxYwY| d i} | d i} | d i} | d g} d }d}| D]} t| ddt|k}n#ttf$rd }YnwxYw|sT|}| dgD]T}| d|kr9|s| ds | d|kr||d<d}n/U| dg||dd}|| |||dgdd}|r9ddlm}||| d d td|j||dSdS#t$$r.}td|j|dYd}~dSd}~wwxYw)zTSave a newly created thread_id back into config.yaml so it persists across restarts.rget_hermes_homez config.yamlz:[%s] Config file not found at %s, cannot persist thread_idNrrr platformsrrrHFrKrrrT)rrr)atomic_config_write)default_flow_style sort_keysz9[%s] Persisted thread_id=%s for topic '%s' in config.yamlz.[%s] Failed to persist thread_id to config: %sr#)hermes_constantsrexistsr(r0ryamlr safe_loadrrrrrr hermes_cli.configrrr)r5rKrrrr config_path_yamlfr7rtelegram_configrrHchangedmatching_chat_entryr chat_matchestrrNs rrz+TelegramAdapter._persist_dm_topic_thread_idS s@ j 8 8 8 8 8 8)/++m;K%%'' []a]fhsttt k3999 2Q++1r 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 ))+r::I'22:rBBO#..w;;E((b99IG"& '   )#&z~~i'C'C#D#DG #TLL!:.)))#(LLL)#&0##..x<< # #AuuV}} 22+/1553E3E/ uu[11Y>>1:+*. 3))(B77>>!+)DD#G"*  &(2KKL"" AAAAAA##',#   OIy*   j j j NNKTYXYdhN i i i i i i i i i jshAH< H<"B: H<B  H< B A#H<24D'&H<'D=:H<<D==C;H<< I4#I//I4c K|jsdS|jD]}|d}|dg}|r|s3td|jt |||D]}|d}|s|d|}|d}|r:t ||j|<td|j||s|d }|d } |t|||| d{V} | r| |j|<td |j|| | t |||  |j t|| d |d{VQ#t$r-} td|j|| Yd} ~ d} ~ wwxYwdS)uLoad or create configured DM topics for specified chats. Reads config.extra['dm_topics'] — a list of dicts: [ { "chat_id": 123456789, "topics": [ {"name": "General", "icon_color": 7322096, "thread_id": 100}, {"name": "Accessibility Auditor", "icon_color": 9367192, "skill": "accessibility-auditor"} ] } ] If a topic already has a thread_id in the config (persisted from a previous creation), it is loaded into the cache without calling createForumTopic. Only topics without a thread_id are created via the API, and their thread_id is then saved back to config.yaml for future restarts. NrKrz*[%s] Setting up %d DM topic(s) for chat %srrrz4[%s] DM topic loaded from config: %s -> thread_id=%srr)rKrrrz([%s] DM topic cached: %s -> thread_id=%su📌 )rKrrz2[%s] Could not send seed message to topic '%s': %s)rrr(rrrrrrrrrW send_messagerr)) r5rrKrrrrexisting_thread_idr icon_emojirseed_errs r_setup_dm_topicsz TelegramAdapter._setup_dm_topics s&%  F0< < J nnY//G^^Hb11F &  KK< 3v;;    %1 1  '^^F33 !&5555 &0^^K%@%@"%145G1H1HDOI.KKN 9.@(^^L99 '^^,BCC "&"7"76w??#))3 #8## 1:DOI.KKB 9i 44S\\:yYYY "i44$>w$G$G.7!;z!;!;5 % P Iz8#91 < < s3G G?"G::G?cBK tj|jd{Vt|ddrdS|jrdS|dd{VnC#tj$rYdSt$r%t d|j dYnwxYw)uhKeep the cached @username fresh when no heartbeat is running. Polling mode re-reads identity via the heartbeat's ``get_me()`` probe. Webhook mode has no such probe — nothing calls ``get_me()`` again after ``initialize()`` — so without this loop a BotFather rename breaks mention routing until the gateway restarts. TNrwFrz4[%s] Telegram identity refresh loop iteration failedr#) r&ra_BOT_IDENTITY_TTL_SECONDSrlr=_refresh_bot_identityr'rr(r)rr4s r_bot_identity_refresh_loopz*TelegramAdapter._bot_identity_refresh_loop s  mD$BCCCCCCCCC4!c K ddlmm}m}m}ddlm}m}|js& |j tj ur d|_ dSdS|}||\}}fd|D} |||fD]} t| dt| } |j| | d{Vtd |j| t%| {#t&$r,} td |j| | Yd} ~ d} ~ wwxYw|r0td |jt%|||nG#t&$r:} td |jt+| d Yd} ~ nd} ~ wwxYw |d d{Vn#t&$rYnwxYw |d{Vn:#t&$r-}td|j|d Yd}~nd}~wwxYwn#tj$rwxYw|j tj ur d|_ dSdS#|j tj urd|_ wxYw)uRegister the command menu, surface the status indicator, and set up DM topics — all off the connect path so a slow Bot API call cannot blow the gateway connect timeout (#46298). Every step is non-fatal.r) BotCommandBotCommandScopeAllPrivateChatsBotCommandScopeAllGroupChatsBotCommandScopeDefaulttelegram_menu_commandstelegram_menu_max_commandsN max_commandsc.g|]\}}||SrrrMrdescrs r zBTelegramAdapter._run_post_connect_housekeeping../)WWW:4 4 6 6WWWr>rscopez.[%s] set_my_commands OK for scope %s (%d cmds)z,[%s] set_my_commands FAILED for scope %s: %szc[%s] Telegram menu: %d commands registered, %d hidden (over %d limit). Use /commands for full list.z1[%s] Could not register Telegram command menu: %sTr#onlinez+[%s] DM topics setup failed (non-fatal): %s)rrrrrhermes_cli.commandsrrrWrr&rrlrset_my_commandsr(rrrrr0r_set_status_indicatorrr')r5rrrrrr menu_commands hidden_count bot_commands scope_cls scope_name scope_errrN topics_errrs @rrz.TelegramAdapter._run_post_connect_housekeepingsF /+  cbbbbbbbyp&'*>*@*@@@*.'''A@e :9;; .D.DR^._._._+ |WWWWWWW #9:XZv!wyyI!(JI!O!OJy"i77 IIKK7XXXXXXXXX $TVZV_akmpq}m~m~$yyy'UW[W`blnwxxxxxxxxy  KK} 3}#5#5|\   GI/22!   000==========      ++----------   AIzD  %     &'*>*@*@@@*.'''A@t&'*>*@*@@@*.'....sEA EAC.-E. D$8"DED$$5EH& F$0FH&FH&"F?>H&? G  H& G  H&G+*H&+ H"5#HH&H""H&%I&H77I#J) is_reconnectrc &)*Kd_d_ts:tdjddddSjjs:tdjddddS d jjd sdStj jj}jj d }|ri||}|jj d |}td j|jj dr5|d}tdjdt$dt&dt&fd}dt$dt(dt(fd}|dd|dd|dd|dd|dddd }d!d"lm}|}|-d!d#l} | |d$|j|j%)nd#)dfd&t6t8dt8f)fd' } t;jd(d) d*v} !} | sht"d+jtGd#{V} td,jd-$| d.g| } tKd/| 0}| r||sz| sxtd1jd-$| i}))|d2<tMdgi|d&d3tO| fi|ii}tMdgi|d&d3tO| fi|ii}n|rTtd4j|tMdgi||| d5}tMdgi||| d5}nR| r td6jtMdgi|d&| i}tMdgi|d&| i}(|}|)|*|}|+_,j,j-_.j,/tatbj2tbj3zj4j,/tatbj3j5j,/tatbj6totbd7tbj6zj8j,/tatbj9tbj:ztbj;ztbj<ztbj=j>ztbj?j>zj@j,/tjBd8}|d9d:}tjDE||zzd;z}t|D]}d} tjDE|kr!td<|d=|d>d?||zd;zd>d@t"dAj|dBz|tj,I|j,fdCDd#{V |r||dBz krډj,}|+_,j,j-_.j,/tatbj2tbj3zj4j,/tatbj3j5j,/tatbj6totbd7tbj6zj8j,/tatbj9tbj:ztbj;ztbj<ztbj=j>ztbj?j>zj@j,/tjB t|d#{Vn#t$rYnwxYwn#tjL$r{d}||dBz krUtdE|zdF}t"dGj|dBz|||tjN|d#{Vntd<|d=|d>dHYnt$rl}d}||dBz krUtdE|zdF}t"dIj|dBz|||tjN|d#{VnYd#}~nd#}~wt$r}d}O|s||dBz krUtdE|zdF}t"dIj|dBz|||tjN|d#{VnYd#}~nd#}~wt$rt"dJj|dBz|ttjSdBtjTrdKn*ttjSdBjVwxYw|r||dBz kr܉j,}|+_,j,j-_.j,/tatbj2tbj3zj4j,/tatbj3j5j,/tatbj6totbd7tbj6zj8j,/tatbj9tbj:ztbj;ztbj<ztbj=j>ztbj?j>zj@j,/tjB t|d#{V#t$rYwxYw#|r||dBz krۉj,}|+_,j,j-_.j,/tatbj2tbj3zj4j,/tatbj3j5j,/tatbj6totbd7tbj6zj8j,/tatbj9tbj:ztbj;ztbj<ztbj=j>ztbj?j>zj@j,/tjB t|d#{Vw#t$rYwwxYwwwxYwj,Wd#{Vt;jdLd)}|rotdMdN}t;jdOd)pAt%jj pi dPpd)}d!dQlYmZ}m[} |dRpd)}n2#|$r*t;jdRd)}YnwxYw|stdSd!dTl]m^} | |j_pdU}!j,j`a|||!||tjc| Vd#{Vd_d_dd_etdWj|pdX||!nf| Yd#{VtjD*dZtdd#f*fd[ }"|"_gh| |"| \d#{V}#|#s t"d]jijrd^nd_}$td`j|$jsdjjr2jjksjjltjmn_jotoj.dad#tjp_qjrftodbd#}%|%r(|%ks|%ltjmr_stdS#t$rl}&ut|&}'dc|'}(dd|(dtdej|'Yd#}&~&dSd#}&~&wwxYw)huConnect to Telegram via polling or webhook. By default, uses long polling (outbound connection to Telegram). If ``TELEGRAM_WEBHOOK_URL`` is set, starts an HTTP webhook server instead. Webhook mode is useful for cloud deployments (Fly.io, Railway) where inbound HTTP can wake a suspended machine. ``is_reconnect`` distinguishes a cold first boot (False — drop any stale Bot API queue) from a watcher reconnect after a prolonged outage (True — preserve the updates Telegram queued while the bot was offline, otherwise every message sent during the outage is silently lost). The in-process network-error ladder and the 409-conflict handler already pass ``drop_pending_updates=False`` for the same reason; bootstrap follows suit on the reconnect path. Env vars for webhook mode:: TELEGRAM_WEBHOOK_URL Public HTTPS URL (e.g. https://app.fly.dev/telegram) TELEGRAM_WEBHOOK_PORT Local listen port (default 8443) TELEGRAM_WEBHOOK_HOST Bind host (default: unset → dual-stack, all interfaces IPv4+IPv6) TELEGRAM_WEBHOOK_SECRET Secret token for update verification FzL[%s] python-telegram-bot not installed. Run: pip install python-telegram-botmissing_dependencyz!python-telegram-bot not installedrz[%s] No bot token configuredmissing_credentialszNo bot token configuredztelegram-bot-tokenzTelegram bot tokenrP base_file_urlz'[%s] Using custom Telegram base_url: %s local_modeTz5[%s] Using Telegram local_mode (read files from disk)rrr c ttj|t|S#tt f$r|cYSwxYwr7)rrrrrrrrs r_env_intz)TelegramAdapter.connect.._env_intsP#rys7||<<===!:.###"NNN#.1AAc ttj|t|S#tt f$r|cYSwxYwr7)rrrrrrrs r _env_floatz+TelegramAdapter.connect.._env_floatsP# 4W!>!>???!:.###"NNN#rHERMES_TELEGRAM_HTTP_POOL_SIZEi!HERMES_TELEGRAM_HTTP_POOL_TIMEOUTg @$HERMES_TELEGRAM_HTTP_CONNECT_TIMEOUTg$@!HERMES_TELEGRAM_HTTP_READ_TIMEOUTg4@"HERMES_TELEGRAM_HTTP_WRITE_TIMEOUTr)connection_pool_size pool_timeoutconnect_timeout read_timeout write_timeoutmedia_write_timeoutr)platform_httpx_limitsNr )max_connectionsmax_keepalive_connectionskeepalive_expiry httpx_kwargsc@t|pi} d|vr|d<|S)uMerge tuned keepalive limits into httpx client kwargs. Used by the proxy and direct-DNS branches, where httpx honours the client-level ``limits`` kwarg. A caller-supplied ``limits`` is left untouched; otherwise the CLOSE_WAIT-safe limits are injected. The fallback-IP branch does NOT use this helper — see the ``_transport_kwargs`` note below for why. Nlimits)rA)rr _pool_limitss r _with_limitsz-TelegramAdapter.connect.._with_limitss6l0b11+0F0F'3F8$ r>$HERMES_TELEGRAM_DISABLE_FALLBACK_IPSr>r%rrrru@[%s] Discovering Telegram API fallback IPs via DNS-over-HTTPS…z.[%s] Auto-discovered Telegram fallback IPs: %sz, zapi.telegram.orgTELEGRAM_PROXY) target_hostsz%[%s] Telegram fallback IPs active: %sr transportz;[%s] Proxy detected; passing explicitly to HTTPXRequest: %s)proxyrz4[%s] Telegram fallback-IP transport disabled via envVENUEHERMES_TELEGRAM_INIT_TIMEOUTrg^@z(Telegram initialization timed out after z attempts (rMu-s each) — total connect watchdog deadline (zs) exceeded. Check network connectivity to api.telegram.org or set HERMES_TELEGRAM_HTTP_CONNECT_TIMEOUT / HERMES_TELEGRAM_INIT_TIMEOUT to a lower value.u.[%s] Connecting to Telegram (attempt %d/%d)…rc t|Sr7r r!s rr"z)TelegramAdapter.connect..ts9PQT9U9Ur>r#r^rnuD[%s] Connect attempt %d/%d timed out after %.0fs — retrying in %dszus each). Check network connectivity to api.telegram.org or set HERMES_TELEGRAM_HTTP_CONNECT_TIMEOUT to a lower value.u9[%s] Connect attempt %d/%d failed: %s — retrying in %dsu<[%s] Connect attempt %d/%d interrupted by %s — propagatingr'TELEGRAM_WEBHOOK_URLTELEGRAM_WEBHOOK_PORTi TELEGRAM_WEBHOOK_HOST webhook_host)UnscopedSecretError get_secretTELEGRAM_WEBHOOK_SECRETuTELEGRAM_WEBHOOK_SECRET is required when TELEGRAM_WEBHOOK_URL is set. Without it, the webhook endpoint accepts forged updates from anyone who can reach it — see https://github.com/NousResearch/hermes-agent/security/advisories/GHSA-3vpc-7q5r-276h. Generate a secret and set it in your .env: export TELEGRAM_WEBHOOK_SECRET="$(openssl rand -hex 32)" Then register it with Telegram when setting the webhook via setWebhook's secret_token parameter.)urlparsez /telegram)listenporturl_path webhook_url secret_tokenrrz([%s] Webhook server listening on %s:%d%sz* (all interfaces, IPv4+IPv6)r@r c>tddrdSjrjsdS|r|_jjj jj dS |rt dj||_jjj jj dStdj|ddS)NrwFzR[%s] Telegram network _redact_telegram_error_text(error), scheduling reconnect: %sz<[%s] Telegram polling _redact_telegram_error_text(error): %sTr#)rlror9rPrr1rTr.rdrWr/r^r(r0rr>r )r rAr5s r_polling_error_callbackz8TelegramAdapter.connect.._polling_error_callback/st%@%HH/8P8U8U8W8W88??F33555373C3CDDaDabgDhDh3i3i0.2243KLLL0BB4CYCabbbbb77>>F'{~B~GINOOO373C3CDDfDfglDmDm3n3n0.2243KLLL0BB4CYCabbbbb %ceienpuAE FFFFFr>)rrrFze[%s] Connected in degraded Telegram mode: gateway is alive, polling will be retried in the backgroundwebhookpollingz$[%s] Connected to Telegram (%s mode)rr|zTelegram startup failed: telegram_connect_errorz&[%s] Failed to connect to Telegram: %sr7r)wrwrXrr(r rrr7token_acquire_platform_lockrybuilderrrrPrrrrrr%gateway.platforms._http_client_limitsrhttpxLimitsrrrrArrrrrMr0rrrrrrroget_updates_requestbuildrVrirW add_handlerrr~TEXTCOMMAND_handle_text_message_handle_commandLOCATIONrl_handle_location_messagePHOTOVIDEOAUDIOVOICEDocumentALLSticker_handle_media_messager{_handle_callback_queryr&rLrprr]r_rrprrYr0rar^ BaseExceptionr0sysr$r'rrrSragent.secret_scoper)r*rQ urllib.parser,rr$ start_webhookrqr&rurrErxrYrryr9rVrKr}rsrqr{rr|r_release_platform_lockr)+r5rr9custom_base_urlrrrequest_kwargsr _base_limits_httpxrdisable_fallbackrG proxy_targets proxy_url_transport_kwargsror= _max_connect _init_timeout_total_deadline_attempt rebuild_appold_apprTinit_errr0 webhook_portr(r)r*webhook_secretr, webhook_pathr3polling_startedmode identity_taskrNrrrrAs+` @@rconnectzTelegramAdapter.connectbs6*/&#!  LL^      ! !"68[gl ! m m m5{   LL7 C C C  ! !"79R^c ! d d d5z ../CT[EVXlmm u")++11$+2CDDG"k/33J??O !**?;;!//K%))/?KK =I{ $$\22 `!,,T22 SUYU^___  #s #S #S # # # #  # #u # # # # #)11QSV(W(W * +NPS T T#-:.TVZ#[#[ * +NPT U U!+,PRV!W!W(,!N> T S S S S S0022L'&&&&%}}$23I$J.:.T%1%B -   $   8D> T      !# *PRT U U [ [ ] ] c c e ejD!D --//L acgclmmm%:%<%<<<<<<<  DIIIl++ 0?,?M)*:WWWI0 I0 6F0  ;IIIl+++-!+2>%h/&$$%>(&&,=&&"'3''$''$%>(&&,=&&"'''##  Y[_[dfoppp&$,5LLNN'3''$',5LLNN''''##$cKK VX\Xabbb&UUUUllnnUUU&2''$''3?<>>'''##'"B"BCV"W"W oog..BBCVWWG DI DI I ! !"8 //)##    I ! !"8$##    I ! !"8 77GW=M#N#NN-##    I ! !"8  - = MPWP`Pddgngvgzz*##    I ! !"6t7R"S"S T T T L&J'EtLLM (**//11,./  ",//x !x !# v!/116688OKK%N|NN -VNN)6)E)M`NNNNNH 8a<6 ,,.. -/3i#U#U#U          @#!x,2B'B'B"&)$+MMOO $(IM  --.D#LGO+;; 5// --.D#O 0// --.D#,wwIY/Z/ZZ 9// --.D#MGM9GMIGMY\c\l\ppsztCtGG 6// --.B4C^._._```!"9'"B"BBBBBBBBB(!!! D!q+"&K,"222"1="55b Ix!|\=RV&mD1111111111%]|]] -k]]]21   "&K,"222"1="55W Ix!|\8T&mD111111111121111!   "&K99(CC,"222"1="55W Ix!|\8T&mD111111111121111%NNV  1 $%clnnQ&79OPP>((!#,.."344=#0#!x,2B'B'B"&)$+MMOO $(IM  --.D#LGO+;; 5// --.D#O 0// --.D#,wwIY/Z/ZZ 9// --.D#MGM9GMIGMY\c\l\ppsztCtGG 6// --.B4C^._._```!"9'"B"BBBBBBBBB(!!! D!3#!x,2B'B'B"&)$+MMOO $(IM  --.D#LGO+;; 5// --.D#O 0// --.D#,wwIY/Z/ZZ 9// --.D#MGM9GMIGMY\c\l\ppsztCtGG 6// --.B4C^._._```!"9'"B"BBBBBBBBB(!!! D!3!'B6)//## # # # # # # #)$:B??EEGGKB  ''>EE I5r::@@BBXDK-388HHNBOOUUWW V&0j1J&K&K&Qr%X%X%Z%ZNN*VVV%'Y/H"%M%M%S%S%U%UNNNV% & K   211111'x 449H[ i'55'%) +!/$*$4 .:)96         &*"380+0( >I C$C  66(4$47/11F9FFFFFFFF44K0(,(E(E.:)9#:)5%5 )F))######'NND   " " " $ 2A99 D KK> 4 P P P % /:8T8Y8Y8[8[:077999/6/D002200,  # #GDIz4$H$H I I I,0N,<,*>>G  ! !":Gt ! T T T LLA49j Y Y Y55555  s1!AK9?X AK9 B&e1GAK92eAK9 eAK9eAK9Bm.!u$ m.-A!iu m.!A7kuBm..u1GAK92u AK9 uAK9uAK9G}|43}4 } >}} }C AK9@A@4@3AK9@4,AA#A AK9A"AA#A#JAK9K9 AM/LA!AM*M*AM/rc Kt|ddsdS|j}|dS|r|jn|j}|dd} ||d{Vt d|j|dS#t$r:}t d|j|t|Yd}~dSd}~wwxYw)u]Set the bot's short description to the online/offline status text. The short description is the line shown under the bot's name in its profile. It is the closest Bot API surface to a presence indicator — bots have no real online/offline dot (that's a user-account feature). No-op unless ``extra.status_indicator`` is enabled. Best-effort: any failure is logged at debug and swallowed so it never blocks connect or disconnect. The default (no language_code) description applies to every user who doesn't have a language-specific one set. rFNx)short_descriptionz#[%s] Set bot status indicator to %rz1[%s] Failed to set bot status indicator to %r: %s) rlrWrrset_my_short_descriptionr(rrrr)r)r5rrirrNs rrz%TelegramAdapter._set_status_indicators t8%@@  Fi ; F+1Pt''t7PDSDz ...FF F F F F F F F KK=ty$ O O O O O    LLC 4!.collects 499;; $,*>*>XXF~~ HHV      & & &%% -)rorvrOT)r&rr8rr3listrivaluesrgrmrlrVrSclearrhrfrlrorv)r5rsr!rqrrrrfs @@@@r_cancel_pending_delivery_tasksz.TelegramAdapter._cancel_pending_delivery_tasksse+-- ,. .0 -(7<0 -T - - - - - - - - -07799::  D GDMMMM8??AABB  D GDMMMM7>>@@AA  D GDMMMM3T::;;;?FFGGG!  D KKMMMM  K./JTJJ J J J J J J J %%'''  &&((( '--/// #))+++ &,,... "((*** 4. 5 5\ I I'+D $ 4:D A A U U37D 0 0 0 V Ur>r,stepc.Ktj|} |dkrtj|hd{V\}}n tj|h|d{V\}}nB#tj$r0||t wxYw||vr! |d{Vn#tj$rYnwxYwdS||t td|j ||dS)uAwait one disconnect step; detach on timeout so teardown advances. ``asyncio.wait_for`` cancels an overdue child but then waits for it to exit. Lifecycle / PTB close paths that swallow ``CancelledError`` on a half-dead socket can therefore wedge disconnect forever (#80598). Detach at the deadline and continue — the abandoned task is observed via ``_consume_abandoned_task``. rNrTzD[%s] %s timed out after %.1fs during disconnect; continuing teardownF) r&rKrTr'rVrWr*r(r0r)r5rZr,rxr!r9_pendings r_await_disconnect_stepz&TelegramAdapter._await_disconnect_stepsY$Y// !||'.|TF';';!;!;!;!;!;!;hh'.|TFG'L'L'L!L!L!L!L!L!Lh%    KKMMM  " "#: ; ; ;   4<<  )    4  6777 R I      usAA?B%B..C?Cc< K|d|_d|_t|dddz|_t j|_d|_| t j }g}t}t|ddt|ddfD]}|r| s||urt|}||vr1|||t j|st j|r|||r1|t j|d dit*d d{Vt|dd|urd|_t|dd|urd|_d|_d|_t|d d}|r^| sJ||t j|d t*d d{Vd|_t|dd}|rJ| s6|||t*dd{Vd|_t|dd}|rJ| s6|||t*dd{Vd|_ ||dt*dd{Vn#t8$rYnwxYw||t*dd{V|jrg |jjr|jjj r ||jj!tDdd{VnE#t8$r8} tF$d|j%tM| Yd} ~ nd} ~ wwxYw|jj r9||j!t*dd{V||j't*dd{VnE#t8$r8} tF$d|j%tM| Yd} ~ nd} ~ wwxYwd|_d|_(tF)d|j%dS)zHStop polling/webhook, cancel pending delayed deliveries, and disconnect.TFrsrrroNrvrOzlifecycle-task cancelrrNzpost-connect cancelryzheartbeat cancelr|zidentity-refresh cancelrzstatus-indicator updatezpending-delivery cancelzupdater.stop()z0[%s] updater.stop() failed during disconnect: %sz app.stop()zapp.shutdown()z)[%s] Error during Telegram disconnect: %sz[%s] Disconnected from Telegram)*rrwrurlrsr&rOrtrrTrr8r9rrdrVrfrer r{rS_DISCONNECT_STEP_TIMEOUTrorvrryr|rrrwrVr$rbrcrdr(r0rrrkrWr) r5rlifecycle_taskslifecycle_seenr!r8post_connect_taskpolling_heartbeat_taskrirrNs r disconnectzTelegramAdapter.disconnects !!!)-&+0(#*41F#J#JQ#N '.}$#' ##%%% +-- .0#&55 D/ 6 6 D;T B B - -D 499;; $,*>*>XXF''   v & & & KKMMM%% -)EE  %6%;%;%=%=   $ $ & & &--0DIII(%        #'")/H$!O!O ! *@*E*E*G*G  " ) ) + + +--&("        (,$ &BDII  !3!3!5!5   " " "--()        +/' --**%*88()             D ))  / / 1 1 $ %         9% $  9$ ):)B  "99 I-22441, %N I7 CC9$55 ((0$ 11I&&((,$    ?I:1==     5tyAAAAAsU6L;; MMR)&>O%$R)% P'/.P"R)"P''BR)) S+3.S&&S+ chunk_indexcD|sdS|j}|dkrdS|dkrdS|dkS)a3Determine if this message chunk should thread to the original message. Args: reply_to: The original message ID to reply to chunk_index: Index of this chunk (0 = first chunk) Returns: True if this chunk should be threaded to the original message FrallTr)r[)r5r rrhs rrz$TelegramAdapter._should_thread_replys@ 5" 5==5 U]]4!# #r>c K|jstddSt|ddrtdddS|r|stdd S ||| ro|||||d{V}|O|jrF|pid s/ ||| d{Vn#t$rYnwxYw|S| |}| ||j t }t|d kr d|D}g}||} || } d} ddlm} n#t&$r t(} YnwxYw ddlm} n#t&$rd} YnwxYw ddlm}n#t&t.f$rd}YnwxYwt1|D]\}}d}||}||| |}|o.|jdko#t9|o|d}|p|r|t;|nd}|r|duo |jdk}n|||}|r|rt?|nd}|r*|(|s&td| dcS|!|| |||j}| r)|dtE|}d|d<|d}d}tGdD]{} |jj$d2tK||tLj'|d||(|)|d{V}n#t$r}dt;|*vs#dt;|*vrtV,d|j-|t]|}|jj$d2tK||d|d||(|)|d{V}nYd}~nd}~wwxYwn5#| $rz}| rt_|| r|0|r||s|r=|dr(tdt;|dcYd}~ccS|s)d}tV,d|j-|Yd}~tV,d|j-||1||d} d}ddi}Yd}~*t;|*}d|vr||r*te|} td| dcYd}~ccSte|} tV,d |j-| d}|r|dri}d}n4|!|| |||j}|d}Yd}~|3|}!|r(t_||r|4|s|!s|!r|5d{V|d!krUd!|z}"te|} tV,d"|j-|d z|"| tmj7|"d{VnYd}~d}~wt$r}t|d#d}#|##d$t;|*vrn|d!krh|#tq|#nd%}"te|} tV,d&|j-|d z|"| tmj7|"d{VYd}~td}~wwxYw|9t;|j:|pid s/ ||| d{Vn#t$rYnwxYwtd|r|dnd|| | d'(S#t$r"}$te|$}%tV;d)|j-|%t;|$*}&ty|$}'d*|&vsd+|&vr7tV=d,|j-tdd*d-.cYd}$~$St}d/}(|(rt_|$|(pd0|&v})|4|$}*|3|$}!td|%|*p|!p|) |'1cYd}$~$Sd}$~$wwxYw)3z"Send a message to a Telegram chat.F Not connectedrr rsend_path_degradedTrNrrrlen_fnrc Tg|]%}ttjdd|&S)z \((\d+)/(\d+)\)$z \\(\1/\2\\))rrr)rMchunks rrz(TelegramAdapter.send..sF93_eLLr>r)rZr,rrr rrrrKr parse_moderparserz<[%s] MarkdownV2 parse failed, falling back to plain text: %sr z;[%s] Thread %s not found, retrying once with same thread_idz<[%s] Thread %s not found, retrying without message_thread_idr3z8[%s] Reply target deleted, retrying without reply_to: %sr^z>[%s] Network error on send (attempt %d/3), retrying in %ds: %sr retry afterr?zI[%s] Telegram flood control on send (attempt %d/3), retrying in %.1fs: %s) message_idsrequested_thread_idthread_fallback)rr raw_responsez([%s] Failed to send Telegram message: %smessage_too_longtoo longzF[%s] send() content too long, falling back to new-message continuationtoo_long)rr error_kindrr)rr rrr)?rWrrlrrrrr send_typingrformat_messagetruncate_messageMAX_MESSAGE_LENGTHrrrrr/rZrr]r-r\r enumerater rr[rrrrrrrArrrr MARKDOWN_V2r}rrr(r0rrr0r r)rrprlr:r&rarr rr rr)locals)+r5rKr~r r rich_result formattedchunksrrrused_thread_fallback_NetErr_BadReqrrrretried_thread_not_foundrrrrrrreffective_thread_idr _send_attemptmd_error plain_chunkrCr9safe_send_erroris_pool_timeoutrTrrNrrr_torrs+ rsendzTelegramAdapter.sendsS y De?CCC C 4. 6 6 Ye3GSWXXX X =gmmoo =dt<<< <r  ((8(DD '$($7$7(T\$]$]]]]]]] *"* %!)B33H==%%&*&6&6w&6&R&R R R R R R R R R#,%%% $%&&++G44I**429+F6{{Q"( K00::I"&"B"B9"M"M #(  "BBBBBBB " " "! " @@@@@@@     !@@@@@@@0 ! ! !  !&f--@ 8@ 85+0($($F$Fx$P$P!(,(F(FwPY[c(d(d%*\+u4\XZ(,,7Y*Z*Z[[& #+#.CoHYHeC)***ko )R't39 /58"M %)$=$=oq$Q$QM6Caac/222]a ([-@I^-@% %"AACC"' !% < <(3"&"5 !=!! (>M,=,=>Q,R,R,^$($7$7M9=M"56&3&7&78K&L&L#%*1XXSSMR&(> (>)(B7(K(K%*+4+@4? )) #0 ) #'";";"="= )#'";";H"E"E))######CC )&&&&#h--*=*=*?*???:QTU]Q^Q^QdQdQfQfCfCf &/mosox{C!D!D!D.9%.@.@ ,BDI,B-",Fw,O,O)4/38C -"-" '4 -" '+&?&?&A&A -"'+&?&?&I&I-"-"'"'"'"'"'"'"!&!$ & "e"e"e" #G"z(G'D'DG"#>>xHH$)M`Ml#8!&X!&(,,W{J|J|!&+505.1(mm27,&,&,&%&%&%&%&%&%&%&%&%&%&(@!-?C$<$*NN(e(, 3F%&%&%&%-HHHH!'$b$(I/B!"!"!"!% B B$+-@!"!"!"8< 46: 31Dd0K ((+H (;(;(=(=I@IMMR]Ri#8!&6QRZ6[6[O+505.=27,&,&,&%&%&%&%&%&%&%&%&%&%&3Nh2W2W &$^$(I!"!"!"/3 #+ !a =_0`0` !a46M:>$7$7484P4P(/(1(0>d#.+>';    4Q77J LLCTYPZ [ [ [!ffllnnG,Q//J"W,, g0E0E \I"%7IV`aaaaaaaaa ((,,{++C4*Q"4"4O9OJ!%!A!A!!D!D ";;A>>O -RR N%       - s&A`:<C`: C'$`:&C''`:,B`:1E87`:8F  `: F  `:F`: F&#`:%F&&`:*F10`:1G`:GC6`:>A3`:3ANQ6 Q0C Q+&Q6+Q00Q63`:6^(B^#`:"^##^((A`:,` `: ``:`"`:: e'Be"e'$A8e"e'"e'r status_keycKt|t|f}|j|}|g||||d|d{V}|jr%|jrt|j|j|<|S|j|d||||d{V}|jr#|jrt|j|j|<|S)aSend a status message, or edit the previous one with the same key. Issue #30045: progress/status callbacks (context-pressure, lifecycle, compression, etc.) used to append a fresh bubble on every call. With this method, the first call sends and the message id is remembered; subsequent calls with the same (chat_id, status_key) edit that same message in place. If the edit fails (message deleted, too old, etc.) we drop the cached id and send fresh. NTfinalizerr)rrr edit_messagerrrBr)r5rKrr~rr cached_idrgs rsend_or_update_statusz%TelegramAdapter.send_or_update_statuss'"7||S__-,0055  ,,GdX-F~ $K478I4J4JD,S1  $ ( (d 3 3 3yy'HyEEEEEEEE > Cf/ C,/0A,B,BD $S ) r>rrc K|jstddS|r8||r#|||||d{V}||St |t |f}d}|r|j|dt||jkri|r | |||||d{VS| |}d}|j ||krtd|Sn|s|j|d |sZ|j t|t|| d{V|r ||j|<td|S||} |j t|t|| t j d{Vn#t$$r} d t | vrtd|cYd} ~ St)| } t*d |j| |rt1|n|} |j t|t|| d{VYd} ~ nd} ~ wwxYwtd|S#t$$r/} t | d vrtd|cYd} ~ Sd vsdvrt*d|jt||j|r%| |||||d{VcYd} ~ S| |}|j ||krtd|cYd} ~ S|j t|t|| d{V||j|<td|cYd} ~ St5| dd}|dvr|r|nd}t*d|j||dkr'tdd|t7|cYd} ~ St9j|d{V |j t|t|| d{Vtd|cYd} ~ S#t$$rP}t)|}t*d|j|td|cYd}~cYd} ~ Sd}~wwxYwd}t?fd|D}|rHt)| }t*d|j||td|dcYd} ~ St)| }t*d|j||td|cYd} ~ Sd} ~ wwxYw)a"Edit a previously sent Telegram message. Telegram caps single-message text at 4096 UTF-16 codeunits. Streaming replies that grow past this limit must NOT be silently truncated and must NOT return failure (the consumer would re-send and create a duplicate). Instead this method split-and-delivers: edit the existing message with the first chunk and send the rest as continuation messages, returning the final chunk's id so subsequent edits target the most recent visible message. FrrrNrTrrKrrrKrrrrz;[%s] MarkdownV2 edit failed, falling back to plain text: %srrz6[%s] edit_message overflow (%d UTF-16 > %d), splittingrrr?z*[%s] Telegram flood control, waiting %.1fsr+zflood_control:)rr rz+[%s] Edit retry failed after flood wait: %s) connecterrorz connect errorzconnection errorrVz network errorr readtimeout writetimeoutzserver disconnectedztemporarily unavailableztemporary failurer;c3 K|]}|vV dSr7r)rMrrs rrz/TelegramAdapter.edit_message..s'IIW IIIIIIr>z@[%s] Transient network error editing message %s (will retry): %srz+[%s] Failed to edit Telegram message %s: %s) rWrrrrrrBrr_edit_overflow_split!_truncate_stream_overflow_previewredit_message_textrrrrrrrrr(r0rrr)rlrr&rar r)r5rKrr~rrr _preview_key_saturated_previewrfmt_errsafe_format_error_plainrN truncatedrrTrjrk_transient_markers _is_transientrrs @rrzTelegramAdapter.edit_messagesx&y De?CCC C  #++G44 # $ 3 3Wx!4!!K&""G c*oo6 "  @  ' + +L$ ? ? ? W   7 7 7 !66Z8h7<>> > > > > > >_ ?s2AKK$AG-,K- J:73J5*J:+K0BJ50K5J::K X5XXAX2X8AX;XAXXA&XX X%A S82X8 UAU UXX UA$X6Xc K|||jt}t|dkr|g}|d} |rt ||} |jt|t||tj d{Vn#t$r} dt| vrxtd|jt%| |jt|t|t'|d{VYd} ~ nEd} ~ wwxYw|jt|t||d{Vn#t$r} t| } d| vrnStd |jt%| d t+d t%|  cYd} ~ SYd} ~ nd} ~ wwxYwg} |g} |}||}|ddD]3}d}|rt|nd}|||||}|rdndD]} |r#t ||}n|rt'|n|}|jjd!t|||r tj nd|d||||d{V}n[#t$rM}dt|vr|r|drin||||d} |jjd!t||rt'|n|d||||d{V}Yd}~n#t$r?}td|jt%|d}Yd}~Yd}~nNd}~wwxYw|rYd}~td|jt%|d}Yd}~nd}~wwxYw|td|jdt| zt|dd| D}t+d |dd d dt| zt|||t;| dt;| cStt=|ddp|}| || ||}5| r| dn|}t d|jdt| z|t+d |t;|  S)"uSplit an oversized edit across the existing message + continuations. Edit the original ``message_id`` with chunk 1 (with the platform's usual ``(1/N)`` suffix preserved), then send the remaining chunks as new messages threaded as replies to the previous chunk so the user sees them grouped. Returns ``SendResult(success=True, message_id=, continuation_message_ids=(...))`` so the stream consumer can keep editing the most recent visible message and the gateway has full visibility into every message id we put on screen. Falls back to ``SendResult(success=False)`` only if even the first- chunk edit fails — that's a real adapter problem, not an overflow. rrrrNrzW[%s] Overflow split: MarkdownV2 first-chunk edit failed, falling back to plain text: %srz0[%s] Overflow split: first-chunk edit failed: %sTr#FrrTFFrzreply message not foundr )rKrz4[%s] Overflow continuation no-reply retry failed: %sz*[%s] Overflow continuation send failed: %sz6[%s] Overflow split: stopped at %d/%d chunks deliveredrc3BK|]}tjdd|VdS)z \(\d+/\d+\)$rNr)rM delivereds rrz7TelegramAdapter._edit_overflow_split..sE++!F+R;;++++++r>overflow_continuation_failed)partial_overflowdelivered_chunks total_chunkslast_message_iddelivered_prefixcontinuation_message_ids)rrr rrrrz3[%s] Overflow split delivered %d chunks; last_id=%s)rrrr)!rrrrrrrWrrrrrrrrr(r0rrrr rrrrr}rrrtuplerlr r))r5rKrr~rrr first_chunkrrrNrcontinuation_idsrprev_idrrsent_msgrr use_markdownrrCretry_thread_kwargs _retry_errrnew_idlast_ids rrz$TelegramAdapter._edit_overflow_splits.&& T,Y'   v;;!  YFQi + W A'' 44 )55 :7 C C#&z??&#,#8 6 !   %S\\-?-?-A-AAAE I'B7'K'K #i99$>w$G$G'*:!,[!9!9: i116w??":$2  W W W!ffllnnG(( FI:1=="%7RST7U7UVVVVVVVVV  W&')'=,,X66 ABBZe e EH*1;#g,,,tK 88$/ 9M 2: G x: :  9# IC //66  6>H{51115%;TY%;& :7 C C!"","-CTY-C.(B7(K(K;C%N[%7%7%7..#6.#'";";"="= . #'";";H"E"E ..((((((H"EEEEE(""""NN V $ +Fz+R+R(,H!EEEEEEEEE "$! NND #>x#H#H $HEEEEEI$JLIq3'7#8#88#f++$&77++%5+++$$ "!&8",0,-4D0E0E,E(+F +2,<49:J4K4K "".33C-D-D<<<==HF  # #F + + +  # #E * * *GG*:J"2&&  A Iq3/000'   %*+;%<%<    s%F#*AB32F#3 E"=BEF#E""AF## H0-A3H+ H0+H0BL00 R;ARA"O99 Q 0P= 3R=Q R 0RRc $K|jsdS |jt|t|d{VdS#t$r:}t d|j|t|Yd}~dSd}~wwxYw)uDelete a previously sent Telegram message. Used by the stream consumer's fresh-final cleanup path (ported from openclaw/openclaw#72038) to remove long-lived preview messages after sending the completed reply as a fresh message. Telegram's Bot API ``deleteMessage`` works for bot-posted messages in the last 48 hours. Failures are non-fatal — the caller leaves the preview in place and logs at debug level. F)rKrNTz-[%s] Failed to delete Telegram message %s: %s) rWdelete_messagerrrr(r)rrr5rKrrNs rrzTelegramAdapter.delete_messagesy 5 )**27;;z??+       4    LL? :'B1'E'E   55555  srr)rWr%rlr)r5rrs rsupports_draft_streamingz(TelegramAdapter.supports_draft_streamingst0y  3G H H 5 D2E : : D"8%@@ 5R&&((,===r>c PK|jstddS||r/|||||d{VrtddSt |jdstddSt ||jkr|n'|||jt d }| |}d D]7}t|t||r| |n|d }|rtj|d <|||d< |jjdi|d{V} | rtddcStddcS#t $r} |rJ|| r5t$d|j||t+| Yd} ~ t$d|j||| tdt+| cYd} ~ cSd} ~ wwxYwtddS)uStream a partial message via Telegram's native draft API. Uses ``sendRichMessageDraft`` (Bot API 10.1) with the raw markdown when rich messages are enabled and supported, otherwise the plain-text ``sendMessageDraft``. The Bot API animates the preview when the same ``draft_id`` is reused across consecutive calls in the same chat. When the response finishes, the caller sends the final text via the normal ``send`` path; the draft preview clears naturally on the client (Telegram has no Bot API to "promote" a draft to a real message — the final ``sendMessage``/``sendRichMessage`` is what the user receives in their history). F not_connectedrNTrrapi_unavailablerrr)rKrrrrdraft_rejectedz[[%s] sendMessageDraft MarkdownV2 rejected, retrying as plain text (chat=%s draft_id=%s): %sz6[%s] sendMessageDraft failed (chat=%s draft_id=%s): %sr)rWrrrr%rrrrrrrrrrrrr1r(r)rr) r5rKrr~rrrrrrrNs r send_draftzTelegramAdapter.send_drafts&y De?CCC C  * *7 3 3 A..w'8TTTTTTTT A!$4@@@@ty"677 Fe3DEEE Eg,,$*AAAww  ! !'4+B9 ! U UVW X ,,X66 *# W# WL5g>>MM5AK++D111t&&F  ='0'<|$$.7*+ W7497AA&AAAAAAAAE&dtDDDDDD!%7GHHHHHH W W W  D$>$>q$A$ALLB 7H6QRS6T6T HHHH LIw!"%7RST7U7UVVVVVVVVVVV# W&%/?@@@@s,1*E1E11 H;AHAHHHc$K|jstd|d} |jjdi|d{VS#t$r}|||r||rtd|j || |d|t|}| dd|jjdi|d{VcYd}~Sd}~wwxYw)aSend a Telegram message, retrying once without message_thread_id if Telegram returns 'Message thread not found'. Used for control-style sends (approval prompts, model picker, update prompts) that can carry a stale thread_id from a DM reply chain. The streaming send loop has its own equivalent (PR #3390) at the body of ``send``; this helper applies the same retry pattern to the non-streaming control paths. rrNzP[%s] Thread %s not found for control message, retrying without message_thread_idrKr) rWrQrrrr1r r(r0rr)rArB)r5rrrCrDs r"_send_message_with_thread_fallbackz2TelegramAdapter._send_message_with_thread_fallbackTshy 0// /"JJ':;; //99&99999999 9   !-..x88.33H==.fI%22JJy))+< $F||   !4d;;;3TY3CClCCCCCCCCCCCCCC + s$A DB2D D D  Drr session_keyc K|jstddS |rd|dnd}|d||}tt dd t d d gg}||} |d ||j} |jdt||tj || d| || || |j| d {V} tdt| jS#t $rV} t"d|jt)| tdt)| cYd } ~ Sd } ~ wwxYw)zSend an inline-keyboard update prompt (Yes / No buttons). Used by the gateway ``/update`` watcher when ``hermes update --gateway`` needs user input (stash restore, config migration). Frrz (default: )ru ⚕ *Update needs your input:* u✓ Yeszupdate_prompt:y callback_datau✗ Nozupdate_prompt:nNr9rKrr reply_markuprrTrz"[%s] send_update_prompt failed: %sr)rWrrrurtrrr[rrrrrr}rrrr(r0rr) r5rKrrrr default_hintrkeyboardrrrrNs rsend_update_promptz"TelegramAdapter.send_update_prompt{sy De?CCC C S7>F33333BL&&'bF'bT`'b'bccD+(BSTTT(ARSSS-H 00::I<7J7JKKK K S S S NN?LghiLjLj k k ke3Nq3Q3QRRR R R R R R R SsD D&& F0A F;FFu)⚠️ Command Approval Required z
z
zG Smart DENY: owner override applies to this one operation only.rc*tj|Sr7)_htmlescape)r5rs r _ea_escapezTelegramAdapter._ea_escapes|D!!!r>dangerous commandcommand descriptionallow_permanent allow_session smart_deniedc K|jstddS ||||} ||} ddl} t |ds| d|_t|j} tdd |  g|sR|rP td d |  |r' td d|   tdd|  fdtdtdD} t| }t|| tj|d|}|d||j}||d<|||| |||j|jdi|d{V}||j| <tdt1|jS#t4$rV}t6d|jt=|tdt=|cYd}~Sd}~wwxYw)uSend an inline-keyboard approval prompt with interactive buttons. The buttons call ``resolve_gateway_approval()`` to unblock the waiting agent thread — same mechanism as the text ``/approve`` flow. FrrrN_approval_counterru✅ Allow Oncezea:once:ru ✅ Sessionz ea:session:u ✅ Alwaysz ea:always:u❌ Denyzea:deny:c*g|]}||dzSr^rrMrbuttonss rrz6TelegramAdapter.send_exec_approval..s&HHHGAa!eG$HHHr>r^rKrrrrrrTrz"[%s] send_exec_approval failed: %sr)rWr_format_exec_approvalr itertoolsr%countrnextrtr rrrurrHTMLr}rr[rrrrrrrr(r0rr)r5rKrrrrrrrrrr approval_idrowsrrrrrNr s @rsend_exec_approvalz"TelegramAdapter.send_exec_approvalsy De?CCC C: S--g{LQQD00::I    4!455 <)2););&t566K%%5E]P[E]E]^^^G  M (FaT_FaFabbb#NN,\IcVaIcIcddd NN/ JbU`JbJbccc d d dIHHHeAs7||Q.G.GHHHD+D11H6g>>'n ( && ++-- &F<7J7JKKK K S S S NN?LghiLjLj k k ke3Nq3Q3QRRR R R R R R R SsGNg[eNgNghhh )E^R\E^E^___ -H00::I5g>>'3 ( && ++-- &F<7J7JKKK K S S S NN?LghiLjLj k k ke3Nq3Q3QRRR R R R R R R SsE E** G 4A G?G G questionchoices clarify_idc dK|jstddS dtj|}||}|r4ddt |D} |d| z }t||tj d| } |rg} tt|D]=} | tt| d zd |d |  g>| td d |d gt!| | d<|d|} | | d<| ||||| |jdi| d{V}||j|<tdt|jS#t.$rV}t0d|jt7|tdt7|cYd}~Sd}~wwxYw)u$Render a clarify prompt with one inline button per choice. Multi-choice mode (``choices`` non-empty): renders one button per option plus a final "✏️ Other (type answer)" button. Picking the "Other" button flips the entry into text-capture mode so the next message becomes the response. Open-ended mode (``choices`` empty): renders the question as plain text — no buttons. The next message in the session is captured by the gateway's text-intercept and resolves the clarify. Frr❓ r c3nK|]0\}}|dzdtjt|V1dS)rz. N)rrr)rMrcs rrz/TelegramAdapter.send_clarify..Ls\))11u66 SVV 4 466))))))r> rKrrrcl:rru✏️ Other (type answer)z:otherrNrrTrz[%s] send_clarify failed: %sr)rWrrrrrrrrrr}rrr rtrrurrrrrrrr(r0rr)r5rKrrrrrrr option_linesrridxrrrNs r send_clarifyzTelegramAdapter.send_clarify,s(y De?CCC C9 S2%,x0022D00::I . $yy)) )' 2 2)))   -|---6g>>'n&&++-- &F D W..CKK,aLL*B *B*BS*B*B!  (4&>J&>&>&> *>d)C)C~&<7J7JKKK K S S S NN949FabcFdFd e e ee3Nq3Q3QRRR R R R R R R SsF2G H/A H*$H/*H/ providers current_modelcurrent_providerc xK|jstddS ddlm}n#t$rd}YnwxYw ||d\} } ||} |d|pdd | d | } |r|d nd } |d ||j }|j dt|| tj | |d||| |||j |d {V}|j|||||dd|jt%|<tdt%|jS#t&$rV}t(d|jt/|tdt/|cYd }~Sd }~wwxYw)uSend an interactive inline-keyboard model picker. Two-step drill-down: provider selection → model selection. Edits the same message in-place as the user navigates. Frrr get_labelc|Sr7rslugs rr,z4TelegramAdapter.send_model_picker..get_label r>+⚙ *Model Configuration* Current model: `unknown ` Provider:  Select a provider:rNrrr)msg_idr'ron_model_selectedr(r) provider_pageTrz![%s] send_model_picker failed: %sr)rWrhermes_cli.providersr,r_build_provider_keyboardrrrr[rrrrrr}rrrrr(r0rr)r5rKr'r(r)rr6rr,rprovider_page_infoprovider_labelrrrrrNs rsend_model_pickerz!TelegramAdapter.send_model_picker~sy De?CCC C  6 6 6 6 6 6 6         . S+/+H+HTU+V+V (H(&Y'788N&&>'4'A >>!/>>*<>>D6>G [1114I<7J7JKKK K S S S NN> KfghKiKi j j je3Nq3Q3QRRR R R R R R R Ss+# 33D!E F9#A F4.F94F9r[c K|jstddS gt|D]\}}t|dp|dpd} |drd| } t | d | stdd Stfd td tdD} |r|dnd} | d||j } |j dt|||tj| | d||| || |j |d{V} | j|||d|jt|<tdt| jS#t*$rV}t,d|jt3|tdt3|cYd}~Sd}~wwxYw)u)Send a flat inline-keyboard choice picker (one tap → one value). Generic single-level companion to ``send_model_picker`` used by `/reasoning`, `/fast`, and any future finite-choice command. Each choice dict: ``{"value": str, "label": str, "is_current": bool}``. Frrlabelrr is_current✓ cp:rz No choicesc*g|]}||dzSr rr s rrz6TelegramAdapter.send_choice_picker..s&EEEa1q5!EEEr>rr^rNrrr)r5rron_choice_selectedTrz"[%s] send_choice_picker failed: %sr)rWrrrrr rtrurrrr[rrrrrrr}rrrr(r0rr)r5rKrrrrCrrchoicer>rrrrrNr s @rsend_choice_pickerz"TelegramAdapter.send_choice_pickersy De?CCC C+ SG&w//   6FJJw//L6::g3F3FL"MM::l+++*5NNE(iAiiHHH E!%|DDDD+EEEE5CLL!+D+DEEEH6>G [1114I<7J7JKKK K S S S NN?LghiLjLj k k ke3Nq3Q3QRRR R R R R R R Ss&B#G&D$G&& I0A I;IIdatac K|j|}|s|dd{VdSt|dd}t|dd}|t t|jddt|ddt|d dt t|d dndt|d dt t|d dndt|jd d s|d d{VdS t|dd}|d|}n4#ttf$r |dd{VYdSwxYw|d} | s|dd{VdS | |t |dpdd{V} n7#t$r*} t d| d| } Yd} ~ nd} ~ wwxYw | || tjdd{Vn@#t$r3 | | ddd{Vn#t$rYnwxYwYnwxYw|d{V|j|ddS)z.Handle choice picker button taps (cp:).u)Picker expired — run the command again.rNrrrrrKrr first_nameru2⛔ You are not authorized to change this setting.rrInvalid selection.rCPicker expired.rz"Choice picker selection failed: %szError applying selection: rrr)rranswerrlrrrrr IndexErrorrr(r rrrrrB) r5queryrFrKstate query_message query_chatr%rDcallback result_textrs r_handle_choice_picker_callbackz.TelegramAdapter._handle_choice_picker_callbacks)--g66 ,,$O,PP P P P P P P P F  y$77 ]FD99 00 r22 3 3M9d;;@G TZ\`@a@a@mc'*fd;;<<JJ0 J*'J0)J**J0/J0r"rpagec  ddlm}n#t$rd}YnwxYwd|Dd}g}||d|DD]}|ddkrfd |d D}td |D}|d d |d} t d|Drd| } |t | d|d|d} | ||| n#|D] } ||| !||||j \} | d}| d} fdtdtdD} | dkrg}|dkr*|t dd|dz |t |dzd| d|| dz kr*|t dd|dz| || t dd gt| | d!fS)"aBuild the paginated top-level provider keyboard, folding groups. Provider families (Kimi/Moonshot, MiniMax, xAI Grok, ...) collapse to a single ``mpg:`` button; tapping it drills into a member sub-keyboard. Single providers (and groups with only one authenticated member) render as direct ``mp:`` buttons. Grouping mirrors the CLI ``hermes model`` picker via the shared ``group_providers`` fold, so all surfaces stay consistent. r)group_providersNc:i|]}|d|Sr.rrMps rrz.Rs$777155==!777r>c |dt|dg}|dd|d}|drd|}t|d|d  S) N total_modelsmodelsr (rr?r@mp:r/r)rrrt)r[rr>s r_provider_buttonzBTelegramAdapter._build_provider_keyboard.._provider_buttonTsEE.#aeeHb.A.A*B*BCCEy,,E,,,Euu\"" '&u'=N1V9=N=NOOO Or>c8g|]}|dSr.rYrZs rrz.]s"'I'I'I!f 'I'I'Ir>kindrc(g|]}|v|SrrrMrby_slugs rrz._s"RRRaQ'\\wqz\\\r>membersc 3K|];}|dt|dgV.`sW  LMnc!%%"2E2E.F.FGG      r>r>u ▸ (rc3@K|]}|dVdS)r?NrYris rrz;TelegramAdapter._build_provider_keyboard..ds.@@1155..@@@@@@r>r@mpg:group_idrr/rU total_pagesc*g|]}||dzSr r)rMr page_buttonss rrz.ws&PPPA QQY'PPPr>r^r◀ Prevmpv:/mx:noopNext ▶ ✗ Cancelmx page_info) hermes_cli.modelsrWrrrr rtr_format_choice_page_PROVIDER_PAGE_SIZErrru)r5r'rUrWrar rowrgrr>r[ page_metarmrnavrfros @@rr9z(TelegramAdapter._build_provider_keyboardCsR # 9 9 9 9 9 9 9 # # #"OOO #87Y777 P P P  &&'I'Iy'I'I'IJJ < <v;'))RRRR3y>RRRG  QX   E #7|;;5;;;E@@@@@@@/ .uNN,UBZZBZBZ[[[ CK00A}'7'7':':;;; <" 4 4//223333"&":": T43# #  i  . PPPPq#l:K:KQ1O1OPPP ??Caxx / J[QUXYQYJ[J[\\\]]] JJ+tax,G,G+,G,GW`aaa b b bkAo%% / J[QUXYQYJ[J[\\\]]] KK    ),dKKKLMMM#D))9[+AAAs  r^c ||||j\}}|d}|d}|d}g t|D]r\}}||z} d|vr|ddn|} t | dkr | ddd z} t | d |  s fd td t dD} |dkrg} |d kr*| t dd|dz  | t |dzd|d ||dz kr*| t dd|dz | | | t dd t dd gt| |dfS)zBBuild paginated model buttons. Returns (keyboard, page_info_text).rUrmrSrrr&N#z...mm:rc*g|]}||dzSr rr s rrz9TelegramAdapter._build_model_keyboard..s&FFFqAE "FFFr>rr^rrpmg:rsrt◀ Backmbrurvrw) ry_MODEL_PAGE_SIZErrrr rtrru)r5r^rU page_modelsr|rmrSrmodel_idabs_idxshortrr}r s @r_build_model_keyboardz%TelegramAdapter._build_model_keyboards5!%!9!9 D$/" "  Y  . '"$[11  KAxaiG/2hHNN3''++HE5zzBcrc U* NN$U///JJJ    GFFFE!S\\1,E,EFFF ??Caxx / JZPTWXPXJZJZ[[[\\\ JJ+tax,G,G+,G,GW`aaa b b bkAo%% / JZPTWXPXJZJZ[[[\\\ KK    4 @ @ @ T B B B    $D))9[+AAAr>c J$%&K|j|}|s|dd{VdS ddlm}n#t $rd}YnwxYw|dr\|dd&t&fd |d Dd}|s|d d{VdS|d g}&|d <|d&|d<||d<d|d<||d\}} |d&} |dt|} t|} | | kr d| | z dnd} | | d| d| d| tj |d{V|d{VdS|dr| t|dd}n-#t$r |dd{VYdSwxYw|dg}||d<|||\}} |dd} |d d&t&fd|d Dd}|r#|dt|nt|} t|} | | kr d| | z dnd} | | d| d| d| tj |d{V|d{VdS|dr t|dd}n-#t$r |dd{VYdSwxYw||d<||d |\}} ||d }n#t"$r |d }YnwxYw| | d!|d"pd#d$|d%|tj |d{V|d{VdS|d&r t|dd}n-#t$r |d'd{VYdSwxYw|dg}|dks|t|kr|d(d{VdS||}|d d&|d)}|s|d*d{VdSd+} |||&d{V}n9#t"$r,}t$d,|d-|}d.}Yd}~nd}~wwxYw | | |tj dd{Vn@#t"$r3 | |ddd{Vn#t"$rYnwxYwYnwxYw||rd/nd0d{V|j|ddS|d1r t|dd}n-#t$r |d'd{VYdSwxYw|dg}|dks|t|kr|d(d{VdS||}|d d&|d)}|s|d*d{VdS dd2lm}t/j||&3d{V}n#t"$rd}YnwxYw|t3t5d4d&|5gt5d6d75t5d8d95gg}| | d:|jtj |d{V|d;d{VdSd+} |||&d{V}n9#t"$r,}t$d,|d-|}d.}Yd}~nd}~wwxYw | | |tj dd{Vn@#t"$r3 | |ddd{Vn#t"$rYnwxYwYnwxYw||rd/nd0d{V|j|ddS|d<r|dd} dd=lm}||ddgf\}}}n#t"$rdg}}YnwxYwd>|d D%%fd?|D}|s|d@d{VdSg$|D]} | dt| d g}!| ddA|!dB}"| dCrdD|"}"$t5|"d| dE5$fdFt?dt$dGD}#|#t5d6d75t5d8d95gt3|#}| | dH|p|dItj |d{V|d{VdS|d7krt|ddpd}||d |\}} ||d }n#t"$r |d }YnwxYw| | d!|d"pd#d$|d%|tj |d{V|d{VdS|d9krT|j|d| dJdKd{V|d{VdS|d{VdS)LzHHandle model picker inline keyboard callbacks (mp:/mm:/mc:/mb:/mx:/mg:).u$Picker expired — use /model again.rNrr+c|Sr7rr.s rr,z@TelegramAdapter._handle_model_picker_callback..get_labelr0r>r`rc34K|]}|dk|VdSr/NrrMr[ provider_slugs rrz@TelegramAdapter._handle_model_picker_callback..1MMq!F)}2L2L2L2L2L2LMMr>r'zProvider not found.r^selected_providerrselected_provider_name model_list model_pager]z _u2 more available — type `/model ` directly_ru&⚙ *Model Configuration* Provider: *rz Select a model:rKrz Invalid page.c34K|]}|dk|VdSrrrs rrz@TelegramAdapter._handle_model_picker_callback..rr>rqr7r)r1r(r2r3r4mc:rIzInvalid model index.r6rJFzModel picker switch failed: %szError switching model: TzSwitch failed.zModel switched!r)expensive_model_warning)providerz Switch anywayrrrrurvu⚠ *Expensive Model Warning* zConfirm expensive modelrk)PROVIDER_GROUPSc i|] }|d| Sr.rrZs rrzATelegramAdapter._handle_model_picker_callback..s@@@qy!@@@r>c(g|]}|v|Srrres rrzATelegramAdapter._handle_model_picker_callback..s"HHHa1<zGroup not found.r_rr?r@r/c*g|]}||dzSr rr s rrzATelegramAdapter._handle_model_picker_callback..s&JJJ1GAAI&JJJr>r^u-⚙ *Model Configuration* Provider family: *z* Select a provider:zModel selection cancelled.rr) rrrLr8r,r startswithrrrrrrrrrr9rr(r rBhermes_cli.model_cost_guardrr& to_threadrurtrrxrr r)'r5rNrFrKrOr,rr^rrwpnametotalshownrrUr:r;r%rrrR switch_failedrSrrr0rlr_label_desc member_slugsrgr[rr>rr rfrs' @@@r_handle_model_picker_callbackz-TelegramAdapter._handle_model_picker_callbacks(,,W55 ,,$J,KK K K K K K K K F  6 6 6 6 6 6 6          ??5 ! !~ ! HMMMMME+.MMMH ll(=l>>>>>>>>>\\(B//F)6E% &.6ll6=.Q.QE* +"(E, "#E, "&"<">MMMMME+.MMMHBJZHLLV===sSY{{EKKE_dgl_l_l[%%-[[[[rtE))((2&+22.722*/22%0%*         ,,.. __V $ $u ! 48}}   lll888888888 &*E/ "+/+H+Hk"D,, (H( ;!*51C+D!E!E ; ; ;!&'9!: ;))((B+0+A+NYBB%3BB.@BB%0%*         ,,.. __U # #U ! $qrr(mm   ll(l?????????!#H!II&92>>Myy!455H ll(9l:::::::::!M %$,HWh $N$NNNNNNN  % % % =sCCC=== $  %  --,,[99(4!%.    11(#'%)2 !D ,,)6M%%l?????????!#H!II&92>>Myy!455H ll(9l::::::::: OOOOOO!( 1+*!!!     "/)/sUUUV,ZtLLL,\NNN1--,,MGOMM )4!) .ll(AlBBBBBBBBB!M %$,HWh $N$NNNNNNN  % % % =sCCC=== $  %  --,,[99(4!%.    11(#'%)2 !D ,,)6M%%OAfI>O>OPPPKJJJaWq0I0IJJJD KK$ZtDDD$\FFF   ,D11H))((.-3-?x...%0%*         ,,.. T\\uyy!449::D+/+H+Hk"D,, (H( ;!*51C+D!E!E ; ; ;!&'9!: ;))((B+0+A+NYBB%3BB.@BB%0%*         ,,.. T\\  $ ( ($ 7 7 7))1!*       ,,.. ,,.. s>A AA$G<<&H&%H&5N &N76N7O11PPR &S  S 0V V:"V55V:>;W:: X7X$#X7$ X1.X70X11X76X7Z&&&[[4#^ ^'&^'a(( b2"bb";c d)dd ddddd<#f f10f1n//oo user_displaycK |dd{Vn#t$rYnwxYw |dtj|jjpddtjdd{VdS#t$rYdSwxYw)uTell the user a clarify tap arrived too late to be delivered. Fires when the clarify entry was evicted by ``clarify_timeout`` or the gateway restarted between asking and the tap. In both cases the agent thread is no longer waiting, so the tap would otherwise leave a misleading ✓ (or an "awaiting typed response" prompt) on a button the agent never receives. u-⚠️ This prompt expired — please /retry.rNrruM ⚠️ This question expired or the session reset — please /retry.rK) rLrrrrrrrr)r5rNrs r_notify_clarify_expiredz'TelegramAdapter._notify_clarify_expireds ,,$S,TT T T T T T T T T    D  ))b5< (:(@bAAbbb%>! *             DD s! ..A A>> B  B rrqrkContextTypes.DEFAULT_TYPEc K|j}|r|jsdS|j}t|dd}t|dd}t|dd}t|dd}t|dd} t|jdd} |drC|jrt |jjnd} | r|||| d{VdS|d rC|jrt |jjnd} | r| ||| d{VdS|d r#| ||||| | d{VdS|d rp| d d} t| dkrD| d} t| d}n4#ttf$r |dd{VYdSwxYwt t|jdd}||||t |nd| t | nd| s|dd{VdS|j|d}|s|dd{VdSt|jdd} ddlm}||| }t,d||| |n4#t0$r'}t,d|d}Yd}~nd}~wwxYw|r%dddd d!}|| d"}|d#|}nd$}|d%}||d{V |||t:jd&d{Vn#t0$rYnwxYw|r$|"|t |dS|d'r;| d d} t| dkr| d} | d}t t|jdd}||||t |nd| t | nd| s|d(d{VdS|j |d}|s|d)d{VdSdd*d+d,}t|jdd}|| d"}||d{V |||d#|t:jd&d{Vn#t0$rYnwxYw dd-l!m"}|#||| d{V}|rE|jr=t|jdd}t|jdd}t|dd}t|jd.d}t|jj||t:jd/|$}t|d0|} t | %d1t tLj'%t ttLj'd0tLj'%hv}!||!r}|{t|}"|"|d2<|(|)t |jjt |t |d3d4|"|j*5nf|d|(|)t |jjt |d6t |i|j*7|j+d_i|d{Vn:#t0$r-}t,d8|j,|d39Yd}~nd}~wwxYwdS|d:r9| d d} t| dkr | d}#| d}$t t|jdd}||||t |nd| t | nd| s|d(d{VdS|j-|#}|s|d)d{VdSt|jdd}|$d;krd<}% dd=l.m/}&|&|#}%n8#t0$r+}t,0d>|j,|Yd}~nd}~wwxYw|%s9|j-|#d|1||d{VdS|d?d{V |d@|jj2pddAtgj4|dBt:j5d&d{Vn#t0$rYnwxYwdS t|$}'n4#ttlf$r |dCd{VYdSwxYwd}( ddDl.m7})|)|#}*|*r6|*j8r/d|'cxkrt|*j8krnn |*j8|'}(n#t0$rd}(YnwxYw|(dE|'dz}(|j-|#d ddFl.m9}+|+|#|(},n:#t0$r-}t,dG|j,|d<},Yd}~nd}~wwxYw|,r|dH|(ddId{V |d@tgj4|jj2pddJtgj4|dKtgj4|(t:j5d&d{Vn#t0$rYnwxYwt,dL|#|(|n7|1||d{Vt,0dM|#dS|dNsdS| d dd}-t t|jdd}||||t |nd| t | nd| s|dOd{VdS|dP|-dQd{V|-dRkrdSndT} ||dU|dVt:jd&d{Vn#t0$rYnwxYw ddWl:m;}.|.}/|/dXz }0|0<dY}1|1=|-dZ[|1>|0t,d\|-t|jdd]dS#t0$r&}t,d^|Yd}~dSd}~wwxYw)`z%Handle inline keyboard button clicks.NrrKrrrrH)r`rkrqrrrrvrrAzgt:) query_chat_idquery_chat_typequery_thread_idquery_user_namezea:rr^rrzInvalid approval data.rrrru/⛔ You are not authorized to approve commands.z(This approval has already been resolved.Userr)resolve_gateway_approvalzKTelegram button resolved %d approval(s) for session %s (choice=%s, user=%s)z;Failed to resolve gateway approval from Telegram button: %su✅ Approved onceu✅ Approved for sessionu✅ Approved permanentlyu ❌ Denied)oncesessionalwaysdenyResolved by u⌛ Approval expiredu] — no command was waiting. It already timed out (and was denied) or was resolved elsewhere.rKzsc:u1⛔ You are not authorized to answer this prompt.z&This prompt has already been resolved.u🔒 Always approveu ❌ Cancelled)rrrV) slash_confirmrr"rrrT)rr rrrz&[%s] slash-confirm callback failed: %sr#r#otherF)mark_awaiting_textz"[%s] mark_awaiting_text failed: %su$✏️ Type your answer in the chat.rz" Awaiting typed response from u…zInvalid choice.)_entrieszchoice )resolve_gateway_clarifyz'[%s] resolve_gateway_clarify failed: %sr@r\z z: z edit_textr_slash_confirm_modrSrrrprompt_message_idr=chat_type_valueis_private_chatrr choice_tokenflippedrr% resolved_text_clarify_entriesrrresolvedrLrhome response_pathtmps2 rrNz&TelegramAdapter._handle_callback_querysG% EJ  Fzy$77  y$?? ]FD99 !*fd;;!-1DdKK!%/<FF ??S T T 49MKc%-/000tG O88gNNNNNNNNN F ??5 ! ! 49MKc%-/000tG P99%wOOOOOOOOO F ??5 ! ! 44+ / / / 5        F ??5 ! !R JJsA&&E5zzQq"%eAh--KK"J/,,,D,EEEEEEEEEFF  r B BCC 88)6E6Qc/222W[6E6Qc/222W[- 9 ,,,],^^^^^^^^^F"266{DII ",,,V,WWWWWWWWWF&u fMM  GGGGGG44[&IIEKKe{FL!LL!^`cdddEEEEEE!4#="< , !!I &MM&*==E#( < *>*D*D*F*F% 0117799(8'8CS T TUU[[]]K+ %0_0IZIf*-.?*@*@KALK(=>'.. $ < <$' (=$>$>$' NN58^^LP%&%&9D262E!= !" !"    '2'.. $ < <$' (=$>$>$' NN%0#i..$A262E !=!"!"FdETT TTTTTTTTT jjjLL!I49VYdhLiiiiiiiij F ??5 ! !q JJsA&&E5zzQ"1X $Qx r B BCC 88)6E6Qc/222W[6E6Qc/222W[- 9 ,,,_,`````````F"155jAA ",,,T,UUUUUUUUUF&u fMM 7**$G]LLLLLL"4"4Z"@"@$]]]'KTYX[\\\\\\\\]#+// DAAA"::5,OOOOOOOOO,,,R,SSSSSSSSS#55"J (:(@b"J"JfkfrsgAgA"J"J"J'0~)-6 %Fl++CC"I.,,,=,>>>>>>>>>FF04 )RRRRRR,00<P>P3P3P3P3P3P(- c(:  )))$(MMM)!(%8cAg$7$7M#'' D999%MMMMMM66z=QQHH %%%LL!JDIWZ[[[$HHHHHH%,,,G="3E,G,G,HHHHHHHHH#55"W U]5G5M2(N(N"W"WW\WcdpWqWq"W"Wy~zFGTzUzU"W"W'0~)-6 %KKV"M<66ulKKKKKKKKKNNa" F/00  FC##A&r::;; 00 !.=.Ic/***t.=.Ic/***t% 1   ,,$Z,[[ [ [ [ [ [ [ [ Fll I I I IlJJJJJJJJJ3D ))(()Q)Q)Q)QRR$0!*             D  S 8 8 8 8 8 8"?$$D #55M++F33C NN6GN 4 4 4 KK & & & KKIy I I K K K K K S S S LLLc R R R R R R R R R Ss8G-G?>G?0L L3 L..L3;N== O  O  AV VVI+` a#`<<a-e?? f4 !f//f4A i i*)i*0j-j10j17Al llm n  #nn :A3p.. p;:p;0?v00 v=<v=By y9y44y9z send-draft.shu✓ sent draftz archive.shu ✓ archivedzdraft-blank.shu✓ drafted replyzspam.shu✓ marked spamz mute-add.shemailu ✓ muteddomainu✓ muted domainztrusted-ops-add.shu ✓ trustedu✓ trusted domainz vip-add.shu✓ marked VIPu✓ marked VIP domain) rarchivedraftspammutez mute-domaintrustz trust-domainvipz vip-domainc K|dd}t|dkr|dd{VdS|d|d} }tt |jdd } || ||t|nd|t|nd| s|d d{VdS|j|} | s!|d |d{VdS| \} } }}tj d z dz dz | z }| sC|d| dd{Vt d|j|dSt|| g| }d} tj|tjjtjjdd{V}tj|dd{V\}}|jdkr'|}d}td|j|| n|dd}|r|dn d|j}d|d|dd }t d!|j|| |j|n|#tj$r+d|d"}t d#|j|| YnCt6$r7}d|d$|}t d%|j|| |d&Yd}~nd}~wwxYw||d{V|sdSt |jd'd(}|jr|jjpd nd }|d)|d*|} |r||d{VdS||d+d{VdS#t6$rYdSwxYw),z=Dispatch a gmail-triage inline-button callback (gt:verb:arg).rr^rzInvalid gmail-triage data.rNrrrru0⛔ You are not authorized to act on this email.zUnknown verb: z.hermesscriptsz gmail-triageu❌ z missingz$[%s] gmail-triage script missing: %sF)rstderrr\rrTz-[%s] gmail-triage callback ok: verb=%s arg=%srr)rrzexit z failed: PzA[%s] gmail-triage callback failed: verb=%s arg=%s rc=%s stderr=%sz timed outz4[%s] gmail-triage callback timed out: verb=%s arg=%sz error: z;[%s] gmail-triage callback exception: verb=%s arg=%s err=%sr#rHru — rr)rrrLrrlrr_GT_VERB_DISPATCHr_Pathrrr(r rr&create_subprocess_execrPIPEr communicaterrdecoderrrYrrrr)r5rNrFrrrrrverbargrr script_name extra_args success_label is_state_verb script_pathcmdrr _stdout_bytes stderr_bytesr> stderr_text last_linerr original_textappendeds rrz-TelegramAdapter._handle_gmail_triage_callbacksK 3"" u::??,,$@,AA A A A A A A A F!HeAhcr::;; 00 !.=.Ic/***t.=.Ic/***t% 1   ,,$V,WW W W W W W W W F&**400 ,,$;T$;$;,<< < < < < < < < F@E= Z jllY.:^KkY !!## ,,$@;$@$@$@,AA A A A A A A A LL?K X X X F;2z2  7).).D 180@  ""B111++++++ 'M<!##% CItS +11')1LLRRTT t>>in>> WItS$/;# g g g+4+++E LLOQUQZ\`be f f f f f   .4....E LLM 4cD          lll&&&&&&&&&  Fu fEE 6;mK+1r #DD5DDlDD  P--8-<<<<<<<<<<<--8$-OOOOOOOOOOO    DD s7'D!K 7M M -L==MO=O O*)O*r>rcH|d|}|dr|dz }|S)zBuild an actionable file-not-found error for gateway MEDIA delivery. Paths like /workspace/... or /output/... often only exist inside the Docker sandbox, while the gateway process runs on the host. z file not found: )z /workspace/z/output/z /outputs/z (path may only exist inside the Docker sandbox. Bind-mount a host directory and emit the host-visible path in MEDIA: for gateway file delivery.))r)r5r>rr s r_missing_media_path_errorz)TelegramAdapter._missing_media_path_errorsB 11411 ??C D D  = E  r> file_size max_bytesctd|dz} t|pddz }|dd}n#ttf$rd}YnwxYwd|d|d |d S) Nrrz.1fz MBz unknown sizez [Telegram z skipped: file size z exceeds the z0 MB limit. Ask the user to send a smaller file.])rQrrr)r5r>rrlimit_mbsize_mb size_texts r_telegram_media_too_large_notez.TelegramAdapter._telegram_media_too_large_notesq) 455 ').q))[9G"++++II:& ' ' '&III ' J J JI J J J J J s0AArctt|ddpd}t|dd} t|pd}n#ttf$rd}YnwxYw|dkrdS||krdSd||||fS)zrrsizes r_telegram_media_size_allowedz,TelegramAdapter._telegram_media_size_alloweds&68HII]M]^^ FK66  y~A&&DD:&   DDD  199: 9  :d99%yQQQQsAAA audio_pathcaptionc . K|jstddS tj|s%td|d|St jt|d{V}g}|r | |} t| dkr!| | tj fn2#t$r%td|jd YnwxYw| |dddfn| d t%|d 5tj|d } | d vry||} ||||j} ||| || |j} d}d}|D] \}} ||jjt7|||| |t8d| |||| dfdd{V}n#t$r}|dt=|vs#dt=|vrKtd|jtA||}!dYd}~d}~wwxYw||ptEdn| dvr||}||||j} ||||| |j}||jj#t7||r |ddnd| |t8d||||| dfdd{V}n,|$|||||d{VcdddSdddn #1swxYwYtdt=|j%S#t$rf}t&d|jtA|d tO||||| d{VcYd}~Sd}~wwxYw)!z.opus.oggrr)rKvoicer rrdurationrrc.dSNrseek audio_filesrr"z,TelegramAdapter.send_voice..zsJOOA4F4Fr>r?rentitz:[%s] voice caption MarkdownV2 rejected, retrying plain: %srz3Telegram send_voice failed for all caption variants>.m4a.mp3)rKrr rrrrc.dSrrrsrr"z,TelegramAdapter.send_voice..sJOOA,>,>r>)rK file_pathr r rrzJ[%s] Failed to send Telegram voice/audio, falling back to base adapter: %sr)(rWrrrrrr&rrrrr rrrr(r)rrrrrrr[rrE send_voicer_MEDIA_SEND_READ_TIMEOUTrrr0rrrQ send_audio send_documentrr rS)r5rKr r r rr_duration_secs_caption_variants_formatted_captionr _voice_threadrvoice_thread_kwargsr_last_parse_error _cap_text_cap_parse_mode _cap_error _audio_threadaudio_thread_kwargsrNrrs @rr!zTelegramAdapter.send_voice+sy De?CCC CH g7>>*-- l!%t7U7UV]_i7j7jkkkk$+#4-z$$N.0  7 )-)<)4L !" !"': !"'+&?&?&I&I !"!) + ',F,F,F,F!)T))######C$"E("""!0 ;)0C OO4I4I4K4K)K)K,3s:7L7L7N7N,N,N &%9$(I$? $K$K !"!"!" 5? 1 * 2 2 2 (!!""{/<Q44#,,,$($<$(6,D  2 #77AA !#$>$>$>$>!L!!CC("&!3!3 '", '!)!) "4""q^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ~ds3>7J7JKKK K g g g LL\ +A..     ++GZ(]e+ffffffff f f f f f f gsAP$"$P$A CP$,D=P$?DAP$BO6#AIO6 K'B K"O6!K""K''C6O6 P$* P$6O::P$=O:>%P$$ R.AR RRrGimages human_delayc K|jsdS|sdS ddlm}nc#t$rV}td|j|t||||d{VYd}~dSd}~wwxYwg}g|D]^\}} | ds-| |r| || fG || f_|r+t||||d{VsdSddl m } ||} dfd tdt!D} t#| D]\} }|dkr | dkrt%j|d{Vg}g |D]\}} | r | dd nd}| dr| |d d}t(j|s"td |j||t/|d } || |||| ||||s- D]'} |#t$rY$wxYwEtd|jt!|| dzt!| |d||j}||| |||j}dfd }||jjt?|||t@d||!|||d|d{Vn#t$rw}td|j| dzt!| tE|dt||||d{VYd}~nd}~wwxYwD]'} |#t$rY$wxYw#D]'} |#t$rY$wxYwwxYwdS)a)Send a batch of images natively via Telegram's media group API. Telegram's ``send_media_group`` bundles up to 10 photos/videos into a single album. Larger batches are chunked. Animated GIFs cannot go into a media group (they require ``send_animation``), so they are peeled off and sent individually via the base default path. URL-based photos go into the group directly; local files are opened as byte streams. On failure the whole batch falls back to the base adapter's per-image loop. Nr)InputMediaPhotozD[%s] InputMediaPhoto unavailable, falling back to per-image send: %szfile://)r1)unquoter[c*g|]}||zSrr)rMrCHUNKphotoss rrz8TelegramAdapter.send_multiple_images..s&LLL!&1u9%LLLr>r)z.[%s] Skipping missing image in media group: %sr)mediar z5[%s] Sending media group of %d photo(s) (chunk %d/%d)rrrr c^D](} |d#t$rY%wxYwdSr)rr)fh opened_filess r_reset_opened_fileszATelegramAdapter.send_multiple_images.._reset_opened_files#sR*!!!GGAJJJJ(!!! D!!!s  **)rKr9rrz media grouprzI[%s] send_media_group failed (chunk %d/%d), falling back to per-image: %sTr#rJ)#rWrr3rr(r0rrSsend_multiple_imagesr_is_animation_urlr rRr4rrrrr&rarrrrcloserrr[rrEsend_media_grouprr"rr)r5rKr0rr1r3r animations image_urlalt_text_unquote_threadr chunk_idxrr9r  local_pathr;rrr=rNr6r<r7rs @@@rr>z$TelegramAdapter.send_multiple_imagessS$y  F  F  0 0 0 0 0 0 0    NNV 3   ''..w+VV V V V V V V V FFFFF  #%  #) 5 5 Ix'' 22 5t7M7Mi7X7X 5!!9h"78888 y(34444  ''..X;/         F444444**844LLLLLuQF U/K/KLLL )& 1 1L L  IuQ9q==mK000000000!E&(LF +0XX'Ix19ChuuootG ++I66 X%-Xim%<%< !w~~j99%"NN P $ :%!*d33$++B/// __2w%O%O%OPPPP __9g%V%V%VWWWW`'B $] KIs5zz9q=#f++#@@x_c_r@ss $ < <(3"&"5 !=!! !!!!!!AAI.#=g#F#F!&/:(@  (  33H== ! 3B   _Iy1}c&kk;VWX;Y;Y! gg22UH+3 'B $,B $QL L s A<A A77A<C'N  J J,+J,1CN  P= PA-P P= PP=P++ P87P8=Q)QQ) Q% "Q)$Q% %Q) image_pathc (K|jstddS tj|s%td|d|S||}||||j}| |||||j} t|d5| |jj t||r |dd nd|td | ||||d fd  d{V} dddn #1swxYwYtdt!| jS#t$$r} t!| } d| vpd| v} | r"t&d|j|n0t&d|jt/| d ||||tj|||d{VcYd} ~ S#t$$r^}t&d|j|dt7|||||d{VcYd}~cYd} ~ Sd}~wwxYwd} ~ wwxYw)z5Send a local image file natively as a Telegram photo.FrrImagerrrNr)rKphotor rrrMc.dSrr) image_filesrr"z1TelegramAdapter.send_image_file..ss (:(:r>rTrPhoto_invalid_dimensionsPHOTO_INVALID_DIMENSIONSzK[%s] Image dimensions exceed Telegram photo limits, sending as document: %szO[%s] Failed to send Telegram local image as photo, trying document fallback: %sr#)rKr r  file_namer rzV[%s] Failed to send Telegram local image as document, falling back to base adapter: %sr)rWrrrrrrrr[rrrE send_photorr"rrrrr(rrr0rr$basenamer rSsend_image_file)r5rKrIr r rrrFrrrrN error_str is_dim_errordoc_errrOrs @rrUzTelegramAdapter.send_image_fileJsy De?CCC CO p7>>*-- l!%t7U7UV]_i7j7jkkkk..x88G<>$/:(@  ( 33H== : : : :H               "ds3>7J7JKKK K0 p0 p0 pAI+i7;-:   .I 3I/22!  p!//#(# g..z::%% 0 p p p 7I! #WW44Wj'S[fn4ooooooooooooooooooo pQ0 ps|AE'"A!E'A*D9- E'9D==E'D=%E'' J2A+J =H!J! J +AJ9J :J >JJ  J  Jr rRc K|jstddS tj|s%td|d|S|ptj|}||} ||||j } | || || |j } t|d5| |jj t|||r |dd nd| td | |||| d fd  d{V} dddn #1swxYwYtdt#| jS#t&$re} t(d|jt/| t1 ||||||d{VcYd} ~ Sd} ~ wwxYw)z.q r>rTrz [%s] Failed to send document: %sr)rWrrrrrrTrrr[rrrEr$rr"rrrrr(r0rrrS)r5rKr r rRr rr display_namerFrrrrNrrs @rr$zTelegramAdapter.send_documentsy De?CCC C' t7>>),, j!%t7U7UV\^g7h7hiiii$C(8(8(C(CL..x88G<>$/:(@  ( 33H==  1 1 1 1H               $ds3>7J7JKKK K t t t NN2 6q99   ..w 7IW_jr.ssssssss s s s s s s  tsKAF "BF $A+E F EF "E#%F G8AG3-G83G8 video_pathc  K|jstddS tj|s%td|d|S||}||||j}| |||||j} t|d5 | |jj t| |r |dd nd|td | ||||d fd  d{V} dddn #1swxYwYtdt!| jS#t$$rd} t&d|jt-| t/ |||||d{VcYd} ~ Sd} ~ wwxYw)z2Send a video natively as a Telegram video message.FrrVideorrrNr))rKvideor rrrcc.dSrrr]srr"z,TelegramAdapter.send_video..r^r>rTrz[%s] Failed to send video: %sr)rWrrrrrrrr[rrrE send_videorr"rrrrr(r0rrrS)r5rKr`r r rrrFrrrrNrrs @rrezTelegramAdapter.send_videosy De?CCC C$ g7>>*-- l!%t7U7UV]_i7j7jkkkk..x88G<>$/:(@  ( 33H== 1 1 1 1H               "ds3>7J7JKKK K g g g NN/ 6q99   ++GZ(]e+ffffffff f f f f f f  gsKAE'"A!E'A*D9- E'9D==E'D=%E'' G1AG GGrCc RK|jstddSddlm}||sLtd|jt|||||d{VS | |}| |||j }| |||||j } | |jjt|||r |dd nd|t d | ||||d d{V} tdt%| jS#t($r} td|jt+| d ddlm} ddlm} | dd| gi4d{V }||d{V}||j}dddd{Vn#1d{VswxYwY| |||||j }| |jjt|||r |dd nd|t d |||||dd{V} tdt%| jcYd} ~ S#t($r^}td|j|dt|||||d{VcYd}~cYd} ~ Sd}~wwxYwd} ~ wwxYw)zSend an image natively as a Telegram photo. Tries URL-based send first (fast, works for <5MB images). Falls back to downloading and uploading as file (supports up to 10MB). Frrr) is_safe_urlz/[%s] Blocked unsafe image URL (SSRF protection)rNrrr)rLz URL photoTrz8[%s] URL-based send_photo failed, trying file upload: %sr#)_ssrf_redirect_guard)create_ssrf_safe_async_clientrresponse)r, event_hookszuploaded photoz+[%s] File upload send_photo also failed: %s)rWrtools.url_safetyrgr(r0rrS send_imagerrr[rrErSrr"rrrrrgateway.platforms.baserhrirraise_for_statusr~r )r5rKrCr r rrg _photo_threadrphoto_thread_kwargsrrNrhriclientresp image_dataupload_thread_kwargse2rs rrmzTelegramAdapter.send_imagesy De?CCC C000000{9%% f NNLdi X X X++GY\d+eeeeeeee eN j 44X>>M<">$/"1 #?## CC $9'BB&18Bwuu~~d+6$<  * //99Cds3>7J7JKKK K3 j3 j3 j NNJ +A..    + jGGGGGGJJJJJJ88 !+.B-C D........!'I!6!6666666D))+++!%J ...........................(,'C'C!(3"&"5 (D(($!GGI(#=g#F#F!+5<#F75D5>>$/:(@  / 33H==$"$3s~;N;NOOOOOOOOO j j j AI! #WW//GX`h/iiiiiiiiiiiiiiiiiii jW3 jsu:CE L&0L!"J617G:(J6: H J6H B(J60L&6 LALLL!L&LL!!L& animation_urlc K|jstddS ||}||||j}||||||j}||jjt|||r |ddnd|td|| |||d d{V} td t| j  S#t$rZ} td |jt#| d ||||||d{VcYd} ~ Sd} ~ wwxYw)zJSend an animated GIF natively as a Telegram animation (auto-plays inline).FrrrrNr))rK animationr rrryTrzA[%s] Failed to send Telegram animation, falling back to photo: %sr#r)rWrrrr[rrEsend_animationrr"rrrrr(r rrrm) r5rKrwr r r _anim_threadranimation_thread_kwargsrrNs rrzzTelegramAdapter.send_animationwsy De?CCC C" g33H==L<7J7JKKK K g g g LLS +A..    -(]effffffff f f f f f f gsCC44 E>AE EEct|dd}|dSt|ddpt|dd}t|tr|dks|dkrdSt|t fdd DrdSt|t tttjfrdSd S) z:Return True for Telegram typing errors worth cooling down.rNTrriic3 K|]}|vV dSr7r)rMr8rs rrz=TelegramAdapter._is_transient_typing_error..s'tt&v~ttttttr>)ztoo many requestsz rate limitrr,temporarF) rlr0rrrrr]rYConnectionErrorr&)rrrrs @r_is_transient_typing_errorz*TelegramAdapter._is_transient_typing_errorsc=$77  "4c=$77U73PT;U;U k3 ' ' [C-?-?;RUCUCU43xx~~ tttt,sttt t t 4 cG\?GDXY Z Z 4ur>ct|dsi|_tj}t |dd} |t |n|j}n#ttf$r |j}YnwxYwtdt|d}| |z|jt|<dS)zJSuppress Telegram typing refreshes for this chat after transient failures.rbrNr?r) r%rbr&rLrlrrdrrrQr0rpr)r5rKrrArris r_record_typing_cooldownz'TelegramAdapter._record_typing_cooldownst>?? 635D 0'))c=$77  ;*5*AE+&&&tGmEE:& ; ; ;:EEE ;CUE**++=AYY[[5=P,S\\:::sAA10A1c>t|dsi|_d|_|jt |}|dSt j|krdS|jt |ddS)NrbrFT) r%rbrdrrr&rLrprB)r5rKuntils r_typing_in_cooldownz#TelegramAdapter._typing_in_cooldownst>?? :35D 059D 2488WFF =5  # % % * * , ,u 4 44 ,00WtDDDur>cK|jr||rdSd}d} ||}t|o|d}||}|jt|d|d{V|j t|ddS#t$r }|r| |jt|dd{V|j t|dYd}~dS#t$r5}| |r| ||Yd}~n3d}~wwxYw| |r| ||td|jt#|d Yd}~dSd}~wwxYw) zSend typing indicator.NFr typing)rKactionr)rKrz1[%s] Failed to send Telegram typing indicator: %sTr#)rWrrrrrsend_chat_actionrrbrBrrrrr(r)rr)r5rKr _is_dm_topicr_typing_threadrN fallback_excs rrzTelegramAdapter.send_typingsuy D44W==  F" +/! !55h??N ]X\\:\-]-]^^L $ B B> R R ),,27;;"3-         0 4 4S\\4 H H H H H    9 1 = L)44 :7 C C'58<B&C G#GAD;; E:+E50G5E::AGG#c ZK|jsdddS |jt|d{V}d}|jtjkrd}n8|jtjkr d}|jrd}n|jtjkrd}|j p|j pt|||j t|dd d S#t$r[}td |j|t%|d t|dt|dcYd}~Sd}~wwxYw)z&Get information about a Telegram chat.Unknownr)rrNrrrrF)rrrrz0[%s] Failed to get Telegram chat info for %s: %sTr#)rrr )rWget_chatrrrGROUP SUPERGROUPrCHANNELrrrrrlrr(r rr)r5rKrrrNs r get_chat_infozTelegramAdapter.get_chat_infosny 5%t44 4 I++,Fw,O,OPPPPPPPPDIyHN**# h111# =( 'Ih...%  DdnDG ! M#D*e<<    I I I LLB +A..     LL$QHH H H H H H H IsB4C D*AD%D*%D*c@ |s|Sidgdtdtffd |}t|} fd}tjd||}tjd fd|} fd }tjd ||} fd }tjd ||tj }tjd fd|}tjd fd|}tjd fd|}tjd fd|} fd}tjd||tj }t |}t tD]}| ||}tj d|}g} t|D]R\} } | dzdkr| | $| fd} | tjd| | Sd | }|S)af Convert standard markdown to Telegram MarkdownV2 format. Protected regions (code blocks, inline code) are extracted first so their contents are never modified. Standard markdown constructs (headers, bold, italic, links) are translated to MarkdownV2 syntax, and all remaining special characters are escaped. rrr cJddd}dxxdz cc<||<|S)z@Stash *value* behind a placeholder token that survives escaping.zPHrrr)rrcounter placeholderss r_phz+TelegramAdapter.format_message.._ph-s;+71:+++C AJJJ!OJJJ %L Jr>c,|d}d|ddvr|ddznd}|d|}||d}|dd}|dddd }||zd zS) Nrr rr\\\`z\`z```)rindexr)rr1open_endopeningbody_and_closebodyrs r_protect_fencedz7TelegramAdapter.format_message.._protect_fenced<s''!**C.2c!""goosyy**1H)8)nG ^N!#2#&D<<f--55c5AAD3w~-.. .r>z(```(?:[^\n]*\n)?[\s\S]*?```)z (`[^`]+`)ch|dddS)Nrrr)rrrrs rr"z0TelegramAdapter.format_message..Ps+cc!''!**,,T6::;;r>ct|d}|ddddd}d|d|dS) Nrr^rrrz\)[]()rrr)rdisplayurlrs r _convert_linkz5TelegramAdapter.format_message.._convert_linkVsm"1771::..G''!**$$T622::3FFC3,7,,c,,,-- -r>z-\[([^\]]+)\]\(([^()]*(?:\([^()]*\)[^()]*)*)\)c|d}tjdd|}dt |dS)Nr \*\*(.+?)\*\*rr)rrrrr)rinnerrs r_convert_headerz7TelegramAdapter.format_message.._convert_header^sVGGAJJ$$&&EF+UE::E31<..11122 2r>z^#{1,6}\s+(.+)$)flagsrcbdt|ddS)Nrrrrrs rr"z0TelegramAdapter.format_message..k/cc9l1771::66999::r>z \*([^*\n]+)\*cbdt|ddS)Nr]rrrs rr"z0TelegramAdapter.format_message..trr>z ~~(.+?)~~cbdt|ddS)N~rrrs rr"z0TelegramAdapter.format_message..{rr>z \|\|(.+?)\|\|cbdt|ddS)N||rrrs rr"z0TelegramAdapter.format_message..s/cc;|AGGAJJ77;;;<<r>c 2|d}|d}|dr;|dr&|dt|dddS|dt|S)Nrr^z**r )rrr.r)rprefixr~rs r_convert_blockquotez;TelegramAdapter.format_message.._convert_blockquotesWWQZZFggajjG  && G7+;+;D+A+A GsfEE|GCRCL'A'AEEEFFF3&::<#8#8::;; ;r>z^((?:\*\*)?>{1,3}) (.+)$z(```[\s\S]*?```|`[^`]+`)r^rc|}|d}|dkr||dz dkr|S|dkr|dkr||dz dkr|S|dkr|d|}d|vsd|vrnd}t|dz t|d z d d D]F}||dkr'|dz}|dkr|dkr||dz dkr|cSn5||dkr|dz }Gd|zS) Nrrr(]rz](httprir)rSrrrQ)r_segrchbeforedepthjs r _esc_barez1TelegramAdapter.format_message.._esc_bares1 AB1uua!e!4!4! SyyQUUtAE{c/A/A! Syy!%bqb#v--$%E%*1q5#a$h2C2CR%H%H//#'7c>>$)QJE',qyy+,q55T!a%[C5G5G35III(-(1&*!W^^$)QJE"9$r>z[(){}]r)r_wrap_markdown_tablesrr MULTILINErreversedrtrrrrr r)r5r~rrrrrr _code_split _safe_parts_idxrrrrrs @@@rrzTelegramAdapter.format_messages N # s s       %T** / / / / /v ,    v  ; ; ; ;    . . . . . vF W[\\ 3 3 3 3 3 v R\    v  : : : :   v  : : : :   v  : : : :   v  < < < <    < < < < <v '  ,    D!!D!2!2!4!45566 8 8C<<\#%677DD h:DAA  #K00 G GJD$ax1}}""4(((('+%%%%2""26)Y#E#EFFFFww{## r>c |jjd}|:t|tr|dvSt |StjdddvS)zBReturn whether group chats should require an explicit bot trigger.require_mentionN>r%rrrrTELEGRAM_REQUIRE_MENTIONru r7rrr0rrrrrrKs r_telegram_require_mentionz)TelegramAdapter._telegram_require_mentions[&**+<==  !*c** H!''))-GGG ## #y3W==CCEEIcccr>cL|jjd}||jjd}|:t|tr|dvSt |StjdddvS)aMReturn whether skipped unmentioned group messages are stored as context. When enabled with ``require_mention``, Telegram matches the Yuanbao / OpenClaw-style group UX: observe ordinary group chatter in the session transcript, but only dispatch the agent when the bot is explicitly addressed. "observe_unmentioned_group_messagesN!ingest_unmentioned_group_messages>r%rrrr+TELEGRAM_OBSERVE_UNMENTIONED_GROUP_MESSAGESrurrKs r,_telegram_observe_unmentioned_group_messageszc |jjd}|:t|tr|dvSt |StjdddvS)zFReturn whether non-allowlisted groups may trigger via direct @mention. guest_modeN>r%rrrrTELEGRAM_GUEST_MODErurrKs r_telegram_guest_modez$TelegramAdapter._telegram_guest_modes~[&**<88  !*c** H!''))-GGG ## #y.88>>@@D^^^r>c |jjd}|:t|tr|dvSt |StjdddvS)zJReturn whether explicit @...bot mentions exclusively route group messages.exclusive_bot_mentionsN>r%rrrrTELEGRAM_EXCLUSIVE_BOT_MENTIONSrrrKs r _telegram_exclusive_bot_mentionsz0TelegramAdapter._telegram_exclusive_bot_mentionss[&**+CDD  !*c** H!''))-GGG ## #y:FCCIIKKOiiir>c|jjd}|td}t |t r d|DSdt |dDS)Nfree_response_chatsTELEGRAM_FREE_RESPONSE_CHATSch|]D}t|#t|ESrrrrMparts rrOz@TelegramAdapter._telegram_free_response_chats..=KKK$T9J9JKCIIOO%%KKKr>c^h|]*}||+Srrrs rrOz@TelegramAdapter._telegram_free_response_chats..-MMM M MMMr>rr7rrr r0rtrrr5r1s r_telegram_free_response_chatsz-TelegramAdapter._telegram_free_response_chatss{k##$9:: ;"#ABBC c4  LKK#KKK KMMS)<)<MMMMr>c|jjd}|td}t |t r d|DSdt |dDS)a5Return topic-level free-response allowlist entries as ``:``. Unlike ``free_response_chats`` (whole-chat), each entry opens a single forum topic for free-response. A missing/omitted thread id on incoming messages is normalized to the General topic (``1``). free_response_topicsNTELEGRAM_FREE_RESPONSE_TOPICSch|]D}t|#t|ESrrrs rrOzATelegramAdapter._telegram_free_response_topics.. rr>c^h|]*}||+Srrrs rrOzATelegramAdapter._telegram_free_response_topics.. rr>rrrs r_telegram_free_response_topicsz.TelegramAdapter._telegram_free_response_topicss}k##$:;; ;"#BCCC c4  LKK#KKK KMMS)<)<MMMMr>c |}|sdSttt|dddd}|sdS||}|t|n|j}|d||vS)zGTrue when the message's chat/topic pair is in ``free_response_topics``.FrNrrr)rrrl_effective_message_thread_idr)r5rrrKrrs r _telegram_is_free_response_topicz0TelegramAdapter._telegram_is_free_response_topics4466 5gggvt<> %.%:3y>>>@]&&H&&&00r>c|jjd}|td}t |t r d|DSdt |dDS)a_Return the whitelist of group/supergroup chat IDs the bot will respond in. When non-empty, group messages from chats NOT in this set are silently ignored unless ``guest_mode`` is enabled and the bot is explicitly @mentioned. DMs are never filtered. Empty set means no restriction (fully backward compatible). allowed_chatsNTELEGRAM_ALLOWED_CHATSch|]D}t|#t|ESrrrs rrOz:TelegramAdapter._telegram_allowed_chats..&rr>c^h|]*}||+Srrrs rrOz:TelegramAdapter._telegram_allowed_chats..'rr>rrrs r_telegram_allowed_chatsz'TelegramAdapter._telegram_allowed_chatss|k##O44 ;"#;<c|jjd}|td}t |t r d|DSdt |dDS)z0Return Telegram chats authorized at group scope.group_allowed_chatsNrch|]D}t|#t|ESrrrs rrOz@TelegramAdapter._telegram_group_allowed_chats../rr>c^h|]*}||+Srrrs rrOz@TelegramAdapter._telegram_group_allowed_chats..0rr>rrrs r_telegram_group_allowed_chatsz-TelegramAdapter._telegram_group_allowed_chats)s{k##$9:: ;"#ABBC c4  LKK#KKK KMMS)<)<MMMMr>c|}|stS|}|r||zS|S)a#Chats where observed group context may use a shared source. ``group_allowed_chats`` is the gateway authorization allowlist for user-less group sources. ``allowed_chats`` remains an optional response gate; when set, observed context must satisfy both lists. )rr8r)r5 group_allowedresponse_alloweds r_telegram_observe_allowed_chatsz/TelegramAdapter._telegram_observe_allowed_chats2sR::<<  55L7799  4 #33 3r>c|jjd}|td}t |t r d|DSdt |dDS)aaReturn the whitelist of Telegram forum topic IDs this bot handles. When non-empty, group/supergroup messages from other topics are silently ignored. DMs are never filtered by topic. Telegram may omit ``message_thread_id`` for the forum General topic, so ``None`` is treated as topic ``1`` for matching purposes. allowed_topicsNTELEGRAM_ALLOWED_TOPICSch|]D}t|#t|ESrrrs rrOz;TelegramAdapter._telegram_allowed_topics..Mrr>c^h|]*}||+Srrrs rrOz;TelegramAdapter._telegram_allowed_topics..Nrr>rrrs r_telegram_allowed_topicsz(TelegramAdapter._telegram_allowed_topicsAs}k##$455 ;"#<==C c4  LKK#KKK KMMS)<)<MMMMr>c|jjd}|td}t |t r|}n"t |d}t}|D]}t | }|s& | t|J#ttf$r$td|j|Y~wxYw|S)Nignored_threadsTELEGRAM_IGNORED_THREADSrz,[%s] Ignoring invalid Telegram thread id: %r)r7rrr r0rtrrr8rrdrrrr(r0r)r5r1ruignoredrrs r_telegram_ignored_threadsz)TelegramAdapter._telegram_ignored_threadsPsk##$566 ;"#=>>C c4  )FFXX^^C((FEE a aEu::##%%D  a CII&&&&z* a a aMtyZ_````` as""C2C:9C:c|jjd}|tjdd}|rg t j|}nO#t$rBd| D}|sd| dD}YnwxYw|}|gSt||j dd t S) z=Compile optional regex wake-word patterns for group triggers.mention_patternsNTELEGRAM_MENTION_PATTERNSrc^g|]*}||+Srrrs rrz=TelegramAdapter._compile_mention_patterns..ns-XXXt4::<<XdjjllXXXr>c^g|]*}||+Srrrs rrz=TelegramAdapter._compile_mention_patterns..ps-!Z!Z!Z4TZZ\\!Z$**,,!Z!Z!Zr>rrTelegram) log_prefixplatform_label display_labellogger_)r7rrrrrjsonloadsrrrrrr()r5patternsr1loadeds rrYz)TelegramAdapter._compile_mention_patternses;$(();<<  )7<<BBDDC "[!Z__FF [[[XXs~~7G7GXXXF![!Z!Z399S>>!Z!Z!Z["  I' y%$     s A!!A B-,B-ct|dd}|sdStt|dddd}|dvS)NrFrr.r>rr)rlrrr)r5rrrs r_is_group_chatzTelegramAdapter._is_group_chatsdw-- 5fb112288==bAGGII 333r>ct|dd}|rItt|ddddnd}t|dd}t t|dd }|d vot|d d d u}|0|s|d vr|rt|S|d kr|rt|SdS|r|jSdS)aHReturn the routable thread id for a Telegram message. Forum supergroup messages posted in the General topic arrive with ``message_thread_id=None`` while Telegram itself addresses that topic as thread id ``1``. Ordinary replies are the opposite footgun: Telegram populates ``message_thread_id`` with a reply-UI anchor id on plain group/DM replies, but those ids are not topic/session routing ids and must not be treated as such. Gating, skill binding, and outbound routing must all agree on the same normalized value. rNrrr rrrF)rrrTr)rlrrrrr)rrrrr1rrs rrz,TelegramAdapter._effective_message_thread_ids w--MQYCfb112288==bAGGIIIWY g2D991CU K KLL"&==j'$PZ\aBbBbfjBj ? )/F"F"FK["F3xxI%%*:%3xx4  0/ /tr>z[a-z0-9_]{2,29}botrct|dd}|r|St|jddpddS)uGReturn this bot's live @username (lowercased, no leading ``@``). Prefers the most recently observed handle over PTB's ``get_me()`` cache. ``Bot.username`` reads ``Bot._bot_user``, which is written only by ``get_me()`` — after a BotFather rename it keeps returning the old handle, so every mention comparison silently stops matching and the exclusive-mention gate concludes the message is addressed to a different bot. Observing the handle from inbound updates closes that window without an extra Bot API round-trip. rzNrr@)rlrWlstripr)r5observeds r_current_bot_usernamez%TelegramAdapter._current_bot_usernamesV4!94@@  O :t44:BB3GGMMOOOr>rc|pdd}|sdSt|dd}||krdS||_t j|_|r$td|j ||dSdS)z9Record the bot's current @username, logging real renames.rr$Nrzz[[%s] Telegram bot username changed: @%s -> @%s (mention routing now follows the new handle)) r%rrlrzrprqr{r(rr)r5rhandler4s rrsz"TelegramAdapter._note_bot_usernames.b((--3355  F4!94@@ v   F&,#(,(8(8%   KK? 8V       r>ct|jdd}|dSt|ddtt|ddddfD]?}|t|dd|kr|t|dd@dS)uLearn our own handle from a message Telegram says we authored. Telegram stamps the *current* username on the bot's own outgoing messages and on ``reply_to_message`` when a user replies to us, so a rename is observable from the update stream itself — no getMe needed. Only trusted when the user id matches this bot, so another account's handle can never be adopted as our own. rNrreply_to_messager)rlrWrs)r5rbot_idrs r"_observe_bot_identity_from_messagez2TelegramAdapter._observe_bot_identity_from_messagesD$// > F G[$ / / GG%7>> T R R  J JI y$--77  # #GIz4$H$H I I I I J Jr>cjt|dd}|dStj|z |jkS)aTTrue when identity was re-read within the TTL. ``None`` means never checked, which is always stale. Do not fold the sentinel into ``0.0``: monotonic clocks have an arbitrary epoch that can legitimately be smaller than the TTL on a freshly-booted host, which would make "never" look like "just now". r{NF)rlrprqr)r5 checked_ats r_bot_identity_is_freshz&TelegramAdapter._bot_identity_is_freshs<T#=tDD  5  :-1OOOr>rrc&K|j}|tt|ddsdS|s|rdS t j||jd{V}n]#tj$rt$rA}t d|j | pd|Yd}~dSd}~wwxYwtj|_|t|dddS)a'Re-read the bot's identity from Telegram when the cache may be stale. ``get_me()`` rewrites PTB's ``Bot._bot_user`` in place, so this also repairs every other consumer of ``self._bot.username``. Best-effort: a failed probe leaves the last known handle in place. Nroz7[%s] Telegram identity refresh failed (keeping @%s): %sr2r)rWrrlr0r&rro_BOT_IDENTITY_PROBE_TIMEOUTr'rr(r)rr'rprqr{rs)r5rrimers rrz%TelegramAdapter._refresh_bot_identitys8i ;hwsHd'C'CDD; F 4466  F ' d6VWWWWWWWWBB%        LLI 45577D9c    FFFFF   )-(8(8% J = =>>>>>s2A88C6C  Crc|jrt|ddsdSt|jdd}t|o(t|ddt|jddkS)Nr+Frr)rWrlr+r)r5r reply_users r_is_reply_to_botz TelegramAdapter._is_reply_to_bot smy 1CT J J 5W5{DII Jd7:tT#B#BgdiY]_cFdFd#deeer> self_usernamec t}|pdddtdtffd }fd}|D]\}}|D]}tt |dddd } | d vrQtt |d d } tt |d d } | d ks| d krt || |  } | dkrI| d} || r| | | d}|d kr4| |dzd }||r| ||D]i\}}|r|r tjd|D]I}|d} || r| | Jj|S)aExtract explicit Telegram bot usernames mentioned in text/captions. Foreign handles are only treated as bot mentions when they look bot-shaped (``...bot``), which keeps human ``@handles`` from acting as routing hints. ``self_username`` opts our OWN handle into the same set regardless of shape: collectible (Fragment) usernames can be assigned to bots and need not end in "bot" (@jarvis, @pic), and a bot addressed by such a handle must still recognise itself. Entity mentions are authoritative. The raw-text fallback is intentionally narrow so entity-less mobile/client variants still work without treating email addresses or arbitrary substrings as bot mentions. rr$r)r cn|sdSr|krdStj|S)NFT)r_FOREIGN_BOT_HANDLE_RE fullmatch)r)rowns r_is_bot_handlezFTelegramAdapter._extract_bot_mention_usernames.._is_bot_handle# sD u v}}t2<c3KtddpdtddpgfVtddpdtddpgfVdSNrrentitiesr caption_entitiesrlrsr _iter_sourceszETelegramAdapter._extract_bot_mention_usernames.._iter_sources* x'64006BUY8Z8Z8`^`` ` ` `'9d339r77L^`d;e;e;kikk k k k k kr>rr r>mention bot_commandoffsetrrrFrNz.(?i)(?>DDSII"MSSUU &@@@WVXr::;;WVXq99::A::1-CCKQWY_``ffhh )++(//44::<.11@+//???3 @<#0-// 8 8 Hh x %VX`aa 8 8Q--//!>&))8+//777 8 '&r>rLrHrc|dks|dkrdS |d}|dz}||zdz}|||dS#t$rYdSwxYw)z=Return a Telegram entity span using UTF-16 code-unit offsets.rrz utf-16-ler^)encoderUnicodeDecodeError)rLrHrr1rSrs rrIz%TelegramAdapter._telegram_entity_textW s A::12 $$[11CQJEF?a'CuSy>((55 5!   22 s>A AAc |jsdS|}t|jdd}|rd|nd}fd}|D]\}}|D]}tt|dddd} | d kr|rt t|d d} t t|d d } | d ks| d kr||| | |krd S| dkr.t|dd} | rt| dd|krd S| dkr|rt t|d d} t t|d d } | d ks| d krg||| | } | d}|d kr| |d|krd SӐ|r|| |vSdS)NFrr$c3KtddpdtddpgfVtddpdtddpgfVdSr?rBrCsrrDz._iter_sourcesl rEr>rrr rrFrHrrT text_mentionrrG) rWr'rlrrrrrIrrJrS)r5r bot_usernamer,expectedrDrLr@rMrNrHrr command_textrPs ` r_message_mentions_botz%TelegramAdapter._message_mentions_botd sy 51133 D$//)5?%|%%%4 l l l l l&3]__! $! $ !K" $ $!'&&""="=>>DDSII"MSSUU )+++ 2!>!>??F 1!=!=>>FzzVq[[ 11+vvNNTTVV\\^^bjjj#tttk N22"66488D$dD 9 9V C C#ttt M11h1!2!>!>??F 1!=!=>>FzzVq[[ #'#=#=k6SY#Z#ZL+0055H!|| #HII.4466<<>>(JJ#tttA $B  ^4#F#FwP\#]#]] ]ur>ct|dd}||sdS|rdS tj}n#t $rYdSwxYw||}||_t|dd}t|tr1| || |j dSdS)u0Fire a TTL-guarded identity refresh in the background. Called when routing is about to discard a message because the bot handles it names don't include ours — the exact symptom of a stale username after a BotFather rename. The TTL in ``_refresh_bot_identity`` bounds this to one getMe per ``_BOT_IDENTITY_TTL_SECONDS``, so a busy group that legitimately addresses other bots cannot turn this into per-message API traffic. Fire-and-forget: the current message still routes on what we know now. r|Nr.)rlr9r0r&rLrQr1rr|r0r8rdrWr/)r5existingrAr!trackeds r_schedule_bot_identity_recheckz.TelegramAdapter._schedule_bot_identity_recheck s4!=tDD     F  & & ( (  F +--DD    FF  : : < <==*.'$ 3T:: gs # # 4 KK     " "7? 3 3 3 3 3 4 4sA A#"A#c|jsdS|}|sdS|||}t|o||v}|r||S)aLReturn True when explicit bot handles target other bots, not this one. Telegram groups can contain several Hermes bot profiles. A message like ``@bot3 hi @bot4`` must not wake ``@bot1`` through reply/wake-word fallbacks. Treat explicit bot-handle mentions as an exclusive routing hint: if at least one @...bot username is present and none matches this adapter's own bot username, this adapter should ignore the message. MessageEntity values are preferred, but some Telegram clients expose selected bot handles as plain text in group messages. Foreign handles are limited to the ``...bot`` shape so human @handles never suppress this bot; our own handle is matched by identity, so a collectible username without that suffix still counts as addressing us. F)rWr'rSrra)r5rrZrK excludes_selfs r#_explicit_bot_mentions_exclude_selfz3TelegramAdapter._explicit_bot_mentions_exclude_self sy 51133  5"&"E"Eg|"\"\455e,Ne:e  2  / / 1 1 1r>c|jsdSt|ddt|ddfD](}|s|jD]}||rdS)dS)NFrr T)rZrlr)r5rrpatterns r!_message_matches_mention_patternsz1TelegramAdapter._message_matches_mention_patterns s% 5!'6488''9VZ:[:[\  I 1  >>),, 444  ur>cT|o||S)zReturn True for the narrow guest-mode bypass: explicit bot mention. The caller (:meth:`_should_process_message`) has already verified the message is a group chat, so that check is not repeated here. )rr])r5rs r_is_guest_mentionz!TelegramAdapter._is_guest_mention s) ((**Rt/I/I'/R/RRr>c|}|r|s|Stj|}tjd|dd|}|p|S)Nz(?i)@z \b[,:\-]*\s*r)r'rrrr)r5rrZrrs r_clean_bot_trigger_textz'TelegramAdapter._clean_bot_trigger_text sk1133  < K9\**&8(888"dCCIIKK$r>c ||rdS|sdS||sdSt|dd}|}|r|t |n|j}||vrdS|? t||vrdSn#ttf$rYdSwxYwt tt|dddd}| r| |rdS| }|r||vrdS||vrdS||rdS|sdS||rdS||rdS||rdSdS)zEReturn True when a group message should be stored but not dispatched.FrNrrrT)_is_own_messagerr!rlr rrrrrrrrdrrrrr6r]rg)r5rrrr chat_id_strrs r)_should_observe_unmentioned_group_messagez9TelegramAdapter._should_observe_unmentioned_group_message s%    ( ( 5@@BB 5""7++ 5G%8$?? 6688  )2)>s9~~~DDaH~--u   y>>T%C%C%E%EEE 5Fz*   uu '''64"@"@$KKLL  0 0 2 2 t7_7_`g7h7h 56688  +W445 $<<>> > >5  0 0 9 9 5--// 5   ) ) 5  % %g . . 5  1 1' : : 5ts #B33CCc2tj|dddS)zFReturn a chat/topic-scoped source for observed Telegram group context.N)rr user_id_alt) dataclassesr)r5rs r%_telegram_group_observe_shared_sourcez5TelegramAdapter._telegram_group_observe_shared_source'!s"644UYZZZZr>eventc^|jjpd}|jjp|}d|d|d|jpdS)Nr2r|z] r)rrrr)r5rtrsenders r'_telegram_group_observe_attributed_textz7TelegramAdapter._telegram_group_observe_attributed_text+!sE,&3)'27:6::G:: (8b:::r>c|pd}tt|ddddpd}d|d|dS)Nr2rWrzIYou are handling a Telegram group chat message. - Your identity: user_id=z , @-mention name in this group=@a) - observed Telegram group context may be provided in a separate context-only block before the current message; it is not necessarily addressed to you. - Treat only the current new message as a request explicitly directed at you, and use observed context only when the current message asks for it.)r'rl)r5rr,s r&_telegram_group_observe_channel_promptz6TelegramAdapter._telegram_group_observe_channel_prompt0!si--//<9vt44dDAANY R(. R RPX R R R r>c F|s|St|dd}|r||s|Sttt|dddd}|}|r||vr|S||j}|}|jr |jd|n|}|j tj krtj ||Stj |||||S) z>Align triggered group turns with observed-history attribution. raw_messageNrrrr!)channel_prompt)rrr})rrlr!rrrsrrzr} message_typerrArrrrx)r5rtr|rnr shared_sourceobserve_promptr}s r)_apply_telegram_group_observe_attributionz9TelegramAdapter._apply_telegram_group_observe_attributionrc|jr tjS|jr tjS|jr tjS|jr tjS|j r tj Stj S)z5Classify a Telegram media message into a MessageType.) stickerrSTICKERrMrFrcrGrrHrrIDOCUMENT)r5rs r_media_message_typez#TelegramAdapter._media_message_type]!sj ; '& & 9 %$ $ 9 %$ $ 9 %$ $ 9 %$ $##r>cKddlm}||\}}}}|dSt|dd}t|dd} t | pd} n#t t f$rd} YnwxYwd| cxkr|ksHn|dz} ||jd| d |_t d | dS | d{V} t| d{V} |s0tjt| d d pd }|| ||| }nB#t"$r5}tdt'|dYd}~dSd}~wwxYw|"||jd|_dS|jg|_|jg|_|jdkrt0j|_n9|jdkrt0j|_n|jdkrt0j|_||j||_t d|j|jdS)a2Cache an unmentioned group attachment and annotate the observed text. Passive group traffic, so downloads are bounded by the same ``_max_doc_bytes`` limit as the addressed document path. Oversized or unsupported attachments are noted in the transcript without downloading. rcache_media_bytesNrrQrrzB[Observed Telegram attachment too large or unverifiable. Maximum: z MB.]z6[Telegram] Observed group attachment skipped (size=%s)r rr[ mime_type default_kindz3[Telegram] Failed to cache observed group media: %sTr#z=[Observed Telegram attachment could not be read, not cached.]imagercrz)[Telegram] Cached observed group %s at %s)rnr_observed_media_sourcerlrrr_append_observed_noterr(rget_filebytesdownload_as_bytearrayrrrTrr0r media_urls media_type media_typesrcrrFr~rGrH context_note)r5rrtrrr[mimercrrr rfile_objrFrrs r_cache_observed_mediaz%TelegramAdapter._cache_observed_mediak!s =<<<<<'+'B'B3'G'G$$ > FD"24DEE FK66  y~A&&DD:&   DDD D%%%%I%%%% [1H33 dU]dddEJ KKPR[ \ \ \ F #__........Hx==????????@@D V7++GHk2,N,N,TRTUU&&th$]abbbFF    NNPRmnqRrRr~BN C C C FFFFF  >33 [EJ F"K=#./ ;' ! !!,!2E   [G # #!,!2E   [G # #!,!2E // F FD"24DEE FK66  y~A&&DD:&   DDD D%%%%I%%%% F #__........Hx==????????@@D V7++GHk2,N,N,TRTUU&&th$]abbbFF    NNLNijmNnNny}N ~ ~ ~ FFFFF  > F  ,,,   !2333 u A % %{g%%%0%6""''%0%6""''%0%6"// J Y6; Y Y&*= Y Y6; Y Y Y     ;V[&+VVVVVs+A11BBBD E)*EEc6|jr|jddddfS|jr |jdddfS|jr |jdddfS|jr!|jt |jd dpdddfS|jr-|j}||jpd|jpdd fSd S) zEReturn (telegram_file_source, filename, mime, default_kind) or Nones.rrr video/mp4rcz voice.ogg audio/oggrrRN)NrrN) rMrcrrrlrZrRrr)r5rdocs rrz&TelegramAdapter._observed_media_source!s 9 29R="b'1 1 9 79b+w6 6 9 @9k;? ? 9 U9gcibAAGRWT T < Q,C +cm.Ar-H-H-J-JDP P!!r>r_notec$|s|pdS|s|S|d|S)Nrr!r)r_rs rrz%TelegramAdapter._append_observed_note!s5 ">r ! K&&&&&r>rcr_cRK|rd|dnd} |d||d|jjdd{Vn5#t$r(}td||d Yd}~nd}~wwxYwd ||d |jjd }||j||_dS) uKSurface a failed media download/cache on BOTH ends instead of swallowing it. When download_as_bytearray()/cache_*_from_bytes() raises (typically a transient httpx.ConnectError to Telegram's CDN), the attachment never made it into event.media_urls. Without this, the handler falls through and dispatches an empty turn: the user thinks the file was delivered, the agent sees nothing, and the only record is a buried log warning. This (1) replies to the user in Telegram so they know to retry, and (2) appends an agent-visible notice to event.text via the existing observed-note channel so the agent knows an attachment was attempted and failed — never a silent empty turn. No new event fields (the structured-event refactor is out of scope per #23045). r_rru⚠️ Couldn't download your z). Please try sending it again.Nz;[Telegram] Failed to notify user about %s cache failure: %sTr#z[The user attempted to send a z! but it could not be downloaded (z"); they have been asked to retry.]) reply_textrrrr(r0rr) r5rrtrcrr_named reply_err agent_notes r_surface_media_cache_failurez,TelegramAdapter._surface_media_cache_failure!sR,)5<$\$$$$" ..LtLULLM*LLL            NNM           VT V5 V V=1 V V V // JGG s.= A/A**A/msg_type update_idc t|dd}|sdS |p||||}||j}||}d||t jtj  dd}|j rt|j |d<| |j|t|d d } td | tt|d dd d|jjpddS#t$$r8} t|d d } td| | Yd} ~ dSd} ~ wwxYw)zGAppend skipped group chatter to the target session without dispatching.r"Nrr)tzT)roler~ timestampr&rrrzF[%s] Telegram group message observed (no bot trigger): chat=%s from=%srrr2z1[%s] Failed to observe Telegram group message: %s)rl_build_message_eventrsrget_or_create_sessionrxrrzrutc isoformatrrappend_to_transcript session_idr(rrrr0) r5rrrrtr&r session_entryr adapter_namers r"_observe_unmentioned_group_messagez2TelegramAdapter._observe_unmentioned_group_message"s.55  F c^T66wT]6^^E FFu|TTM!77 FFMGGNN%\X\:::DDFF E  <&)%*:&;&;l#  & &}'? G G G"4<-E99E>c|jsdSt|dd}|dSt|jdd}t|dd}|duo |duo||kS)acReturn True when the message was sent by this bot itself. In some Telegram environments (groups, supergroups where the bot can see its own messages), getUpdates returns the bot's own outgoing messages as updates. These must be filtered out so they are not counted as incoming unread messages in the Hermes inbox. FrNr)rWrl)r5rrr,rs rrmzTelegramAdapter._is_own_message8"sry 5G[$77  5D$//)T400T!OgT&9Of>OOr> is_commandrc ||||rdS||sdS||}|}|r|t |n|j}||vrdS|_ t||vrdSn8#ttf$r$t d|j |YnwxYw||s^|Z|jjddr:t t#t#|dddd}|s ||jvrdSdSt t#t#|dddd}|r||rdS||}|} | r|| vr|S|rdS||vrdS||rdS|sdS||rdS|s||rdS||S) uApply Telegram group trigger rules. DMs remain unrestricted. Group/supergroup messages are accepted when: - the chat passes the ``allowed_chats`` whitelist (when set), or ``guest_mode`` is enabled and the bot is explicitly mentioned - the chat is explicitly allowlisted in ``free_response_chats`` - ``require_mention`` is disabled - the message replies to the bot - the bot is @mentioned - the text/caption matches a configured regex wake-word pattern When ``allowed_chats`` is non-empty, it remains a hard gate except for the narrow ``guest_mode`` bypass: group/supergroup messages that explicitly @mention this bot. Replies and regex wake words do not bypass ``allowed_chats``. When ``require_mention`` is enabled, slash commands are not given special treatment — they must pass the same mention/reply checks as any other group message. Users can still trigger commands via the Telegram bot menu (``/command@botname``) or by explicitly mentioning the bot (``@botname /command``), both of which are recognised as mentions by :meth:`_message_mentions_bot`. FTNz8[%s] Ignoring non-numeric Telegram message_thread_id: %rignore_root_dmrrr)r-rmr!rr rrrrrrr(r0rr7rrrlrrrdrirrrrr6rr]rg) r5rrrrrrKrn guest_mentionrs r_should_process_messagez'TelegramAdapter._should_process_messageI"s@ //888    ( ( 5""7++ 455g>> 6688  )2)>s9~~~DDaH~--u   qy>>T%C%C%E%EEE 5Fz* q q qY[_[dfoppppp q""7++  T[%6%:%:;KU%S%S gggvt&D&DdBOOPP!!g1H&H&H 54'''64"@"@$KKLL  0 0 2 2 t7_7_`g7h7h 5..w77 ..00  !{'11  4 $<<>> > >4  0 0 9 9 4--// 4   ) ) 4((** t/I/I'/R/R 455g>>>s#B662C+*C+c $ K|j4d{V t|dd}|rt|dds dddd{VdSt|j}||jvr dddd{VdSddlm m}ddlm }m }||\}} fd |D} |j | ||  d{V|j |td |jt#| |nE#t$$r8} td |jt)| Yd} ~ nd} ~ wwxYwdddd{VdS#1d{VswxYwYdS)uLazy-register bot commands for forum supergroups. Forum topics don't inherit AllGroupChats scope — Telegram resolves via BotCommandScopeChat(chat_id). Register on first message so the command menu works in topic views. NrrFr)rBotCommandScopeChatrrc.g|]\}}||Srrrs rrz:TelegramAdapter._ensure_forum_commands.."rr>rJrz2[%s] Lazy-registered %d commands for forum chat %sz/[%s] Forum command lazy-registration failed: %s)rrlrrrrrrrrrrWrrdr(rrrrr0r) r5rrrKrrrrr]rrNrs @r_ensure_forum_commandsz&TelegramAdapter._ensure_forum_commands"s7# } } } } } } } } }w5574U#C#C  } } } } } } } } } } } } } } dg,,d<<< } } } } } } } } } } } } } }EDDDDDDDbbbbbbbb#9#9GaGaGcGc#d#d#d qWWWWWWW i// DWDW`gDhDhDh/iiiiiiiii.227;;; PRVR[]`am]n]npwxxxx } } }PRVR[]xyz]{]{|||||||| } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } }sGE?$D' D'c &K||}|r|jsdS||sZtdt t |ddddt t |dddddS||s>||r'||tj |j dS| |j d{V||tj |j }||j|_|||d{V||}||dS)zHandle incoming text messages. Telegram clients split long messages into multiple updates. Buffer rapid successive text messages from the same user/chat and aggregate them into a single MessageEvent before dispatching. N2[Telegram] Blocked unauthorized user %s in chat %srrrr)rrrr(r0rlrrorrr@rrrrrkrr_enqueue_text_eventr5rrkrrts rrBz$TelegramAdapter._handle_text_message"s,,V44 #(  F 44S99  NND[$77tDDVT22D$??    F++C00 ==cBB k77[=MY_Yi7jjj F))&.999999999))#{/?6K[)\\11%*== ''U333333333>>uEE   '''''r>c K||}|r|jsdS||dsdS||sZtdt t |ddddt t |dddddS||d{V||tj |j }| |j|_| ||d{V||}t|jpd |jkr||dS||d{VdS) z!Handle incoming command messages.NTrrrrrrr)rrrrr(r0rlrrrrArrkrrr_SPLIT_THRESHOLDrhandle_messagers rrCzTelegramAdapter._handle_command"s,,V44 #(  F++CD+AA  F44S99  NND[$77tDDVT22D$??    F))#.........))#{/BfN^)__11%*== ''U333333333>>uEE uzR D$9 9 9  $ $U + + + F!!%(((((((((((r>c K||}|sdS||sZtdt t |ddddt t |dddddS||s>||r'||tj |j dSt |dd}|rt |ddnt |dd}|sdSt |d d}t |d d}||dSd g}|rVt |d d} t |d d} | r| d| | r| d| | d|| d|| d|d|| d| |tj |j } d || _|| } || d{VdS)z,Handle incoming location/venue pin messages.Nrrrrrvenuelocationlatitude longitudez![The user shared a location pin.]raddresszVenue: z Address: z latitude: z longitude: z5Map: https://www.google.com/maps/search/?api=1&query=rzSAsk what they'd like to find nearby (restaurants, cafes, etc.) and any preferences.r )rrr(r0rlrrorrrDrr rrrrr) r5rrkrrrlatlonrrrrts rrEz(TelegramAdapter._handle_location_message #s,,V44  F44S99  NND[$77tDDVT22D$??    F++C00 ==cBB o77[=Q]c]m7nnn FWd++7<`75*d333'#z[_B`B`  Fh D11h T22 ;#+ F55  4E7D11EeY55G 0 .u../// 4 222333 '#''((( (3(())) XSXXSVXXYYY jkkk))#{/CvO_)``YYu%% >>uEE!!%(((((((((((r>cddlm}||||j|jjdd|jjdd|jjS)aSession-scoped key for text message batching. Applies the installed topic-recovery hook first so DM-topic batches coalesce on (and dispatch to) the recovered lane rather than the raw inbound ``message_thread_id`` Telegram may have attached. rbuild_session_keygroup_sessions_per_userTthread_sessions_per_userF)rrr)rr_apply_topic_recoveryrr7rrr)r5rtrs r_text_batch_keyzTelegramAdapter._text_batch_key@#s 655555 ""5)))  L$(K$5$9$9:SUY$Z$Z%)[%6%:%:;UW\%]%]L(     r>c|rtddS||}|j|}t |jpd}|||_||j|<nw|jr$|jr|jd|jn|j|_||_|j r>|j |j |j |j |j |}|r(| s|tj|||j |<dS)a2Buffer a text event and reset the flush timer. When Telegram splits a long user message into multiple updates, they arrive within a few hundred milliseconds. This method concatenates them and waits for a short quiet period before dispatching the combined message. z?[Telegram] Dropping text batch enqueue after disconnect startedNrr )rr(r)rrlrrr_last_chunk_lenrextendrrmr9rVr&r1_flush_text_batch)r5rtrr_ chunk_len prior_tasks rrz#TelegramAdapter._enqueue_text_eventP#s|  - - / /  LLZ [ [ [ F""5))-11#66 (b))  $-E !.3D &s + +z bDLM a8= @ @EJ @ @ @W\Wa '0H $ ?#**5+;<<<$++E,=>>>377<<  joo//      .5.A  " "3 ' '/ / &s+++r>cKtj} |j|}|rt |ddnd}|r t t |ddpdnd}||jkr|j}nS||jkrt|j |j }n-||j krt|j |j }n|j }tj|d{V|j|d}|s< |j||ur|j|ddSdS|rVt$d |j||ur|j|ddSdSt$d|t |jpd||d{V|j||ur|j|ddSdS#|j||ur|j|dwwxYw)zWait for the quiet period then dispatch the aggregated text. Uses a longer delay when the latest chunk is near Telegram's 4096-char split point, since a continuation chunk is almost certain. rrrrNz=[Telegram] Dropping text batch flush after disconnect startedz,[Telegram] Flushing text batch %s (%d chars))r&rrlrrlrrrk_TEXT_BATCH_FAST_LENr0rj_TEXT_BATCH_FAST_DELAY_S_TEXT_BATCH_SHORT_LEN_TEXT_BATCH_SHORT_DELAY_SrarBrmrr(r)rrr)r5rrrlast_len total_lenrirts rrz!TelegramAdapter._flush_text_batcht#s +-- & >044S99GAHOww(91===aHCJQGGVR88>B???PQI4000<d777D:DS)r**   %%e,, , , , , , , ,-11#66,FF.223=====GFt-11#66,FF.223====GsC0H3.H3-A H33:I-cddlm}||j|jjdd|jjdd}t |dd }|r|d |S|d S) z1Return a batching key for Telegram photos/albums.rrrTrF)rrmedia_group_idNz:album:z :photo-burst)rrrr7rrrl)r5rtrrrrs r_photo_batch_keyz TelegramAdapter._photo_batch_key#s555555'' L$(K$5$9$9:SUY$Z$Z%)[%6%:%:;UW\%]%]   !&6==  ;!::.:: :++++r> batch_keyctKtj} tj|jd{V|j|d}|s< |j||ur|j|ddSdS|rVt d |j||ur|j|ddSdSt d|t|j ||d{V|j||ur|j|ddSdS#|j||ur|j|dwwxYw)z;Send a buffered photo burst/album as a single MessageEvent.Nz>[Telegram] Dropping photo batch flush after disconnect startedz3[Telegram] Flushing photo batch %s with %d image(s))r&rrarerfrBrgrrr(r)rrrr)r5rrrts r_flush_photo_batchz"TelegramAdapter._flush_photo_batch#s+--  E- ?@@ @ @ @ @ @ @ @/33ItDDE .229==MM/33ItDDDDDNM 1133  ]^^^.229==MM/33ItDDDDDNM KKMyZ]^c^nZoZo p p p%%e,, , , , , , , ,.229==MM/33ItDDDDDNMt.229==MM/33ItDDDDNsc K|jsdS||jsdtdt t |jddddt t |jdddddS||js||jr|j}||}||||j }|j r| |j |_ | ||d{V|||j|j |dS|j}||}||||j }|j r| |j |_ |jrN|||d{V||}||d{VdS||}|jr |jd} | d{V} | d{V} d } | jr5d D]2} | j| r| } n3t5t7| | }|g|_d | d g|_td|t |dd}|r*|tA||d{Vn,|!||}|"||dS#tF$rR}t$dtK|d|&||d|d{VYd}~nd}~wwxYw|j'rs |(|j'd\}}|sn|)|j |pd|_ tdt |j'dd||d{VdS|j'd{V} | d{V}tUt7|d }|g|_dg|_td| n#tF$rS}t$dtK|d|&||d|d{VYd}~ nd}~wwxYw|j+rs |(|j+d\}}|sn|)|j |pd|_ tdt |j+dd||d{VdS|j+d{V} | d{V}tUt7|d }|g|_dg|_td |n#tF$rS}t$d!tK|d|&||d|d{VYd}~nId}~wwxYw|j,r |(|j,d"\}}|sn|)|j |pd|_ td#t |j,dd||d{VdS|j,d{V} | d{V}d$} t | d%dr:tZD]2} | j| r| } n3t]t7|| }|g|_t[j/| d&g|_td'|n#tF$rS}t$d(tK|d|&||d"|d{VYd}~nnd}~wwxYw|j0r^|j0} d} |j1pd}|r6tdj34|\}} | } |j5pd}| sR|rPtl/|d} | s3d)toj8D}|/|d} |j9r|j9|j:krR|j:d*z}d+|d,|_ td-|j9||d{VdS| tvvs|<d r|d{V} | d{V} | tvvr| ntl/|d } t5t7| | }nn#tz$ra}t$d.tK|dd/|p|p| pd0d1|_ ||d{VYd}~dSd}~wwxYwt|j?|_|g|_|<d r|nt/|d2g|_td3|t |dd}|r*|tA||d{Vn,|!||}|"||dS| s?|j5r8d4t[j8D}|/|j5d} | sS|j5rLi}tj8D]\}} |B| ||/|j5d} | tZvr|d{V} | d{V}t]t7|| }|g|_tZ| g|_t|jC|_td5|||d{VdS|d{V} | d{V}!t7|!}"d6d7lDmE}#|#|"|pd8| pd9|:}$|$.d;|p|p| pd0d<|_ ||d{VdS|$j3g|_|$jFg|_|$jGd=krt|jH|_td>|$jG|$j3|$jFd?}%| tvp|pd<d@}&|&rt|"|%krn |"KdA}'|pd8| pdB}(tjMdCdD|(}(dE|(dF|'})|j r|)dG|j |_ n|)|_ n#t$rYnwxYwnr#tF$re}t$dHtK|d|&||dI|t |dJdpdKd{VYd}~nd}~wwxYwt |dd}|r+|tA||d{VdS||d{VdS)LzBHandle incoming media messages, downloading images to local cache.Nz=[Telegram] Blocked media from unauthorized user %s in chat %srrrr)rrtrr)rrrrrrzimage/r z"[Telegram] Cached user photo at %srz$[Telegram] Failed to cache photo: %sTr#rMz voice messagerz1[Telegram] Skipped oversized user voice (size=%s)rrrz"[Telegram] Cached user voice at %sz$[Telegram] Failed to cache voice: %sz audio filez1[Telegram] Skipped oversized user audio (size=%s)rz audio/mp3z"[Telegram] Cached user audio at %sz$[Telegram] Failed to cache audio: %sz video filez1[Telegram] Skipped oversized user video (size=%s)z.mp4r rz"[Telegram] Cached user video at %sz$[Telegram] Failed to cache video: %sci|]\}}|| Srrrs rrz9TelegramAdapter._handle_media_message..w$s&Y&Y&Y1q!&Y&Y&Yr>rzFThe document is too large or its size could not be verified. Maximum: z MB.z'[Telegram] Document too large: %s bytesz-[Telegram] Failed to cache image document: %szImage document 'r2z ' could not be read as an image.rz+[Telegram] Cached user image-document at %sci|]\}}|| Srrrs rrz9TelegramAdapter._handle_media_message..$s(X(X(X$!QA(X(X(Xr>z+[Telegram] Cached user video document at %srrrZz.bin)r[rz Document 'z' could not be cached.rz$[Telegram] Cached user %s at %s (%s)iztext/rz.txtz [^\w.\- ]r]z [Content of z]: r!z'[Telegram] Failed to cache document: %s attachmentrR)r_)Orrr(rrlrrorrrr rkrrrr~r_handle_stickerrrrMrrr rr.rrrr%r_queue_media_group_eventrrrrr0rrrr rrrrcrrrrZrRrrrr_TELEGRAM_IMAGE_MIME_TO_EXTrrrr_TELEGRAM_IMAGE_EXTENSIONSrrrrF_TELEGRAM_IMAGE_EXT_TO_MIMErrrGrnrrrcrHrrrrrrV)*r5rrkr _observe_type_eventrrrtrMr image_bytesrr cached_pathrrrNrr audio_bytes video_bytesroriginal_filenamer]doc_mime mime_to_extr image_extvideo_mime_to_extimage_mime_to_ext_ext_mime doc_bytes raw_bytesrrMAX_TEXT_INJECT_BYTES_is_text text_contentr_ injections* rrMz%TelegramAdapter._handle_media_message#s~  F44V^DD  KKO TBBD$OO==tTJJ    F++FN;; ==fnMM ^ $ 8 8 < < 222}PVP`2aa:K"&">">rz"J"JFK00V<<<<<<<<<77+v7Gv8 Fn++C00))#x6CS)TT ; C55ckBBEJ ; &&sE22 2 2 2 2 2 2 2BB5IIE%%e,, , , , , , , , F>>uEE 9 P P " !&!1!1111111$,$B$B$D$DDDDDDD %"%O"" #-3355>>yII""+C!E"5U;5G5GSQQQ $/= %?cjjoo%?%?$A! @+NNN!(.>!E!E!@77N8K8KUSSSSSSSSSS $ 5 5eS A AI--i??? P P PEGbcdGeGeptuuu77UGQOOOOOOOOOOOOOO P 9T  X $ A A#)_ ] ] !%!;!;EJ PR!S!SEJKK SU\]`]fhsuyUzUz{{{--e444444444F!$!3!3!5!5555555$,$B$B$D$DDDDDDD 4U;5G5GVTTT $/= %0M! @+NNNN X X XEGbcdGeGeptuuu77UOUVWWWWWWWWWWWWWW XYC  U $ A A#)\ Z Z !%!;!;EJ PR!S!SEJKK SU\]`]fhsuyUzUz{{{--e444444444F!$!3!3!5!5555555$,$B$B$D$DDDDDDD 4U;5G5GVTTT $/= %0M! @+NNNN U U UEGbcdGeGeptuuu77ULRSTTTTTTTTTTTTTT UYq  U $ A A#)\ Z Z !%!;!;EJ PR!S!SEJKK SU\]`]fhsuyUzUz{{{--e444444444F!$!3!3!5!5555555$,$B$B$D$DDDDDDD 8[$77"%:"" #-3355>>yII""+C!E"5U;5G5GSQQQ $/= %:%>sK%P%P$Q! @+NNNN U U UEGbcdGeGeptuuu77ULRSTTTTTTTTTTTTTT U \X ,CV $'M$7R!$&W--.?@@FAs))++C M/R6688s)C(DE%)4):E&KK M{[[[--e444444444F"%//////"*"@"@"B"BBBBBBB !),, DDDDDD**.L2LS]F2L2L& >/%6%V(%Vc%VY///J--e444444444F$*K= %+%6$7!;')))4):E& :KK% )3%"99ahn"=X=XY`=a=a I2G G G '0'7'7'@'@ '8'Vc@Ktj} tj|jd{V|j|d}||rVtd |j ||ur|j |ddSdS| |d{VnO#tj $r=Y|j ||ur|j |ddSdSwxYw|j ||ur|j |ddSdS#|j ||ur|j |dwwxYw)Nz>[Telegram] Dropping media group flush after disconnect started) r&rraMEDIA_GROUP_WAIT_SECONDSrhrBrr(r)rirrr')r5rrrts rrz(TelegramAdapter._flush_media_group_event#%s+--  B- =>> > > > > > > >,00FFE 5577LL!abbb &**>::lJJ'++NDAAAAAKJ ))%000000000%    &**>::lJJ'++NDAAAAAKJ &**>::lJJ'++NDAAAAAKJt&**>::lJJ'++NDAAAAKs0A*C=CE#D%(E#$D%%E##:FrcBKddlm}m}m}m}m}|j}|jpd} |jpd} |j s|j r|| |_ dS||j } | rb|| d| d| | d| |_ td|j dS |d{V} | d{V} t%t'| d }td |dd lm}||| d{V}t-j|}| dr=| dd}||j || | ||| | |_ dS|| rd| nd| | |_ dS#t0$rN}tdt5|d|| rd| nd| | |_ Yd}~dSd}~wwxYw)a Describe a Telegram sticker via vision analysis, with caching. For static stickers (WEBP), we download, analyze with vision, and cache the description by file_unique_id. For animated/video stickers, we inject a placeholder noting the emoji. r)get_cached_descriptioncache_sticker_descriptionbuild_sticker_injection build_animated_sticker_injectionSTICKER_VISION_PROMPTrNremojiset_namez [Telegram] Sticker cache hit: %srrz"[Telegram] Analyzing sticker at %s)vision_analyze_tool)rC user_promptranalysisz a stickerza sticker with emoji z%[Telegram] Sticker analysis error: %sTr#)gateway.sticker_cacherrrrrrrr is_animatedis_videorfile_unique_idrr(rrrrrtools.vision_toolsrrrrr0r)r5rrtrrrrrrrrrrrrr result_jsonrgrrNs rrzTelegramAdapter._handle_sticker3%s              + ##)r   '"2 99%@@EJ F('(>??  00}%vzz'5'A'A6::jZbCcCcEJ KK:G > @ @@@@@@@K0{1C1CQQQK KK > > > > > 3 3%1!!!KZ ,,Fzz)$$ $jj[AA ))'*@+uV^___44[%RR 547<M3E333+8     NNBD_`aDbDbmqN r r r0038I////kxEJJJJJJJ s ?C*G+G HAHHc ddlm}|}|didididg}|sg|_t |_dS||_d|D|_|D]}|d }|s|d gD]y}|d }|d }|rK|rI|d |} | |jvr9t||j| <t d|j | |zdS#t$r,} t d|j | Yd} ~ dSd} ~ wwxYw)zRe-read dm_topics from config.yaml and load any new thread_ids into cache. This allows topics created externally (e.g. by the agent via API) to be recognized without a gateway restart. r)load_config_readonlyrrrrHNc@h|]}d|vt|dSrJrL)rMrs rrOz@TelegramAdapter._reload_dm_topics_from_config..%s7'''/9)WaJaJaJy)**JaJaJar>rKrrrrz8[%s] Hot-loaded DM topic from config: %s -> thread_id=%sz/[%s] Failed to reload dm_topics from config: %s) rr'rrr8rrrr(rrrr)) r5r'r7rHrcidrtidrrrNs r_reload_dm_topics_from_configz-TelegramAdapter._reload_dm_topics_from_configt%s ( Z ? > > > > >))++F ;++Z$$Wb!!["%%   )+&*-%%'&/D "''=F'''D #(    nnY//#"55  A%% ,,C55==Dt'*OOTOO $DO;;9E CE E?!E::E?cx|sdSt|}|jD]\}}||kr||dr|ddd}|jD]b}t |d|kr:|dgD]#}|d|kr|cccS$cd|icS||jD]\}}||kr||dr|ddd}|jD]b}t |d|kr:|dgD]#}|d|kr|cccS$cd|icSdS)zLook up DM topic config by chat_id and thread_id. Returns the topic config dict (name, skill, etc.) if this thread_id matches a known DM topic, or None. NrrrKrr) rrrrrrrrr+) r5rKr thread_id_intr cached_tidrrrs r_get_dm_topic_infoz"TelegramAdapter._get_dm_topic_info%s  4I  $4466 , ,OC]**s~~mmm/L/L* YYsA..q1 "&"8))J:>>)4455@@!+"!=!=))A uuV}} ::'( ; ++++ **,,, $4466 , ,OC]**s~~mmm/L/L* YYsA..q1 "&"8))J:>>)4455@@!+"!=!=))A uuV}} ::'( ; ++++tr>c|d|}||jvr;t||j|<td|j||dSdS)zLCache a thread_id -> topic_name mapping discovered from an incoming message.rz5[%s] Cached DM topic from message: %s -> thread_id=%sN)rrr(rr)r5rKrrrs r_cache_dm_topic_from_messagez,TelegramAdapter._cache_dm_topic_from_message%sh---- DO + +),YDOI & KKG 9i      , +r>rc|dSt|tr|St|tr!dfd|DSt|trX|d}||S|d}||SdS)zFBest-effort plaintext flattener for Bot API rich-message inline nodes.Nrc3BK|]}|VdSr7)_flatten_rich_inline_text)rMitemrs rrz.%s1QQ4388>>QQQQQQr>rchildren)r0rrtrrArr4)rrrr6s` rr4z)TelegramAdapter._flatten_rich_inline_text%s =2 eS ! ! L eT " " R77QQQQ5QQQQQ Q eT " " ?99V$$D44T:::yy,,H#44X>>>rr>blocksc>t|tsdSg}|D]b}t|ts|d}|dkr|dgD]}t|ts||d}|sC|d}|}|so|d} |r|d| } || ||d d Ő| |d } | r'|| dd d |DS)z@Best-effort plaintext flattener for Bot API rich-message blocks.rrrtrr7r>rrrNrr c3BK|]}||VdSr7)rstriprs rrz7TelegramAdapter._flatten_rich_blocks.. &s/AA4DAAAAAAAr>) r0rtrAr_flatten_rich_blocksrrr rr4r) rr7linesblock block_typer5 item_textr> item_lines first_liners rr;z$TelegramAdapter._flatten_rich_blocks%s&$'' 2 0 0EeT** 6**JV##!IIgr2211D%dD11! # 8 8(9K9K L LI$!  HHW--E!*!5!5!7!7J%! !+AJE(-%<%< %<%<%B%B%D%D LL,,,LLABB00000061B1BCCD 0 T__..///yyAA5AAAAAAr>r+cN t|dd}t|dd}t|sdS|d}t|dd}t|sdS||d}|pdS#t$rYdSwxYw)zAReturn plaintext echoed by Telegram's rich_message reply payload.rNrrr7)rlrr;rr)rr+rgetterr rich_getterrs r_extract_rich_reply_textz(TelegramAdapter._extract_rich_reply_text &s  !1<FFJZ55FF## t!6.11L!,t<rrrrNrskillforum_topic_created group_topicscg|] \}}||d S)rr)rM cfg_chat_idrs rrz8TelegramAdapter._build_message_event..W&s4%%%+ V!,v>>%%%r>c<g|]}t|t|Sr)r0rA)rMrs rrz8TelegramAdapter._build_message_event..\&s8%%%#jPT>U>U%%%%r>rKrrr>rris_botF) rK chat_namerrrr chat_topicrrMquoterrr)resolve_channel_prompt) rr~rr|rplatform_update_idr reply_to_text auto_skillr}r)%rrrrlrrrr/rrr%rHrr1r7rr0rArrt build_sourcerrrrr+rr rErrlookuprrnrQrdate)r5rrrrrtelegram_chat_typer thread_id_strrO topic_skill topic_info created_namegroup_topics_configgroup_topics_iterrrrr*rrrSrP quote_textrrQ _chat_id_str_channel_prompts rrz$TelegramAdapter._build_message_event&s|  !vr!:!:;;AA#FFrJPPRR !8 8 8II 9 , ,!I99'BB      00TW}MMJ 6'^^F33 (nnW55 w 566 27;V 2&:? 255c$'llMS_```%2%1 ' ! !m ! #'+"3"7"7"K"K -t44 '%%/B/H/H/J/J%%%!!/66 '%%':%%%!!%'!/   z~~i4455TWEE'^^Hb99F%fd33$!#!'"")%66%$#ii 44?s3xx=/H/H).6):):J*/))G*<*(>$**D$!7-..;?J4h66777U+#  @   # -g6ABBKGWd33E9>9J555PTJ - * ,1/7 %\%)$A$A'BZ$[$[M$--;;;;;;(7(>(>LL+)) %---(, - BAAAAA47|| 00 K   )\) 3LLt   #!7-..( +'"*l    s;.P** P98P9cTtjdddvS)z6Check if message reactions are enabled via config/env.TELEGRAM_REACTIONSru>rsrtru)rrrr4s r_reactions_enabledz"TelegramAdapter._reactions_enabled&s'y-w77==??G[[[r>rc &K|jsdS |jt|t||d{VdS#t$r:}t d|j|t|Yd}~dSd}~wwxYw)z2Set a single emoji reaction on a Telegram message.FrKrreactionNTz)[%s] set_message_reaction failed (%s): %s rWset_message_reactionrrrr(r)rr)r5rKrrrNs r _set_reactionzTelegramAdapter._set_reaction&sy 5 )0027;;z??1        4    LLDdiQVXstuXvXv w w w55555 s=A B/B  Bc$K|jsdS |jt|t|dd{VdS#t$r9}t d|jt|Yd}~dSd}~wwxYw)uNClear all reactions from a Telegram message. Calling ``set_message_reaction`` with ``reaction=None`` (or an empty sequence) is the documented Bot API way to remove all bot-set reactions on a message — equivalent to Bot API 10.0's ``deleteMessageReaction`` but supported in PTB 22.6 already. FNrfTz[%s] clear reactions failed: %srhrs r_clear_reactionsz TelegramAdapter._clear_reactions&sy 5 )0027;;z??1        4    LL:DIGbcdGeGe f f f55555 s=A B.B  BcK|sdSt|jdd}t|dd}|r!|r!|||dd{VdSdSdS)z;Add an in-progress reaction when message processing begins.NrKru👀)rdrlrrj)r5rtrKrs ron_processing_startz#TelegramAdapter.on_processing_start&s&&((  F%, 488UL$77  Hz H$$Wj,GG G G G G G G G G G H H H Hr>outcomecJK|sdSt|jdd}t|dd}|r|sdS|tjkr|||d{VdS||||tjkrdndd{VdS)uSwap the in-progress reaction for a final success/failure reaction. Unlike Discord (additive reactions), Telegram's set_message_reaction replaces all existing reactions in one call — no remove step needed. On CANCELLED outcomes (e.g. the user runs ``/stop``, or a session is interrupted mid-flight), we explicitly clear the 👀 in-progress reaction so it doesn't linger on the user's message indefinitely. Without this clear, the only way to remove the 👀 was to wait for another agent run to swap it to 👍/👎 — which never happens if the cancellation was the last activity in the chat. NrKru👍u👎)rdrlrr CANCELLEDrlrjSUCCESS)r5rtrorKrs ron_processing_completez&TelegramAdapter.on_processing_complete&s&&((  F%, 488UL$77  J  F '1 1 1''<< < < < < < < < < <$$ '+<+D D D ,         r>rJr)NNNr7r)rrN)rNTTF)r)rrqrkrr N)NrG)NNNNr(rrrr rsupports_code_blockssplits_long_messagesrRICH_MESSAGE_MAX_BYTESrrrr&r__annotations__r'r(rrrr staticmethodrrrr2propertyr6rrTrrrrrr rrrsrrrr classmethodrrrr rrrrrrrr r)r1r;rErtrMrPr^rlrpr\rcr}rrrcompilerDOTALLrrrrrrrrrrrrrrrrrrrrrrr&rOrrrrr*r(rr7r:r?rErYr>r}rtr2rrTr`rrrrrrrrrrjrrwr{rrrrrrrrrrrr _EA_HEADER _EA_CODE_OPEN_EA_CODE_CLOSE_EA_SMART_DENY_LINE_EA_CMD_BUDGETrrrr&r<rzrErTrr9rrrrNrrrrr r!rr>rUr$rermrzrrrrrrrrrrr8rrrrrrr rPatternrYr!rr:rr'rsr-r0rr2r6rSrIr]rardrgrirkrorsrrxrzrrrrrrrrrrmrrrqrr}rrBrCrErrrrrrrMrrrr+r/r1r4r;rErrdrjrlrnrrsr)rs@rr"r"ysT,#4""$(D'''*. $---37)4666#  $ &*%) E?  E?   \6X|?~|?|?|?|?|?|?|""""""%%%%%%ESE3EdEtEEEEEEFtFFFF . c3h0 . c3h . . . .&"&#'#'#'2G2G2G2G# 2G C= 2G C= 2GC=2G 2G2G2G2Gh: W: : : : x Bt B B B B X$ X X X XDSESEDSESESESEjA8DcN+CAQT AAA[A ?(4S>:R?W_`cWd???[? ?Xd38n5M?RZ[^R_???[?   C= 4S>*      [ (rCrrr\r.2'+  3- 4S>*  }  #   [  .2-1'+ *Q*Q*QC=*Q4S>* *Q &c] *Q  } *Q c3h*Q*Q*Q[*QXHSMhsm[  hsm QT   [ 8)8888\8'''*' ''''RY4\))4S>*)&c] )  )))[)d&* 1 1 1#s(^ 14S>* 1 &c] 1  1c] 1  1 1 1 1DctCycccc I $   \ **t***\*09\6  d   \ D  c D T    $&*%)   E?  E?  *2d38n2222$ ; ; ; ; ; ; WD W W W W"rz"BBMTVT]D]^^)rz N  !   2:   Lcd C3C4CCCCST,CCCCC c d    ,BF   &.tCH~&>     BF   &.tCH~&>      (3-(>C6: c3h"%Y%4%%%%, <9 < < < < <,*,*3-,*4S>* ,* C= ,* % ,*,*,*,*\i i i 3- i 4S>* i *  i i i i `.2 S?S?S?S? S? 4S>* S? *  S?S?S?S?j  #  $     &&& & 4S>* &  &&&&P++++ZF5gm1C+DFFFF*)3)4)))) 6660   P(-"&>$>$>$# >$ !% >$ >$ sGM! ">$>$>$>$@99)09 99992####JS ScSdSSSS:*/###"&# ####T"' AAA#A  A  AAAAFw0w0tw0w0w0w0rppppdjujjjjj\%),0Y Y SMY 7=)Y   Y Y Y Y v= = = = ~n6In6$n6n6n6n6`))))*%).2 1111SM 1 'sm 1 # 1111f555 # 5555$33S3c3QU3bjknbo3333j          8"' HjHjHjHj Hj  Hj  HjHjHjHjTRRRRh0     J/J/J/J/X5:gggTgdggggR$4:08080808d'u'C'TX''''RWBWBWBWBr$Xc]$$QU$$$$0#'-1 EEEE3- E 4S>* E  EEEEZ .2       4S>*      P-1M?M?M?M?M? M?  M?4S>*M? M?M?M?M?^         ,.2H H H H H  H  H 4S>*H  H H H H TCST6$(-1>>C=>4S>*>  >>>>L.2 WAWAWAWA WA 4S>* WA  WAWAWAWAr%%%P9;-1)S)S)S$')S25)S)S4S>*)S  )S)S)S)SX?JM!NeN"s"s"""" /-1 $"" JSJSJS%(JS7:JSJS4S>*JS JS  JS  JS JSJSJSJS\?C.S.S.S#&.S14.SCF.S.S#+DcN#;.S .S.S.S.Sn.2PSPSPSPS$ PS  PS  PS4S>*PS PSPSPSPSt.2FSFSFSFS FS  FS  FS4S>*FS FSFSFSFSP.2=S=S=S=S =S  =S4S>*=S =S=S=S=S~8585),85 85858585tABAB$ABcAB%ABABABABF$BD$B$B$B$B$B$BLM!M!),M! M!M!M!M!^ 2zSzS)DzS zSzSzSzSH )r;KUZ[%r>UZ[)r;NUZ["r;LUZ[&y;UYZ&z;MUYZ-y=UYZ-z;OUYZ%y;KUYZ%z;RUYZ  \\ \\\\| s # #      C  C  TW  \_      R3 Rs RuTS[\_S`M`Ga R R R R$"&"&-1 UgUgUgUg# Ug 3- Ug 4S>* Ug UgUgUgUgUgUgv.2 FFFU F4S>* F  F  FFFFFFX"&"&-1 \p\p\p\p# \p 3- \p 4S>* \p \p\p\p\p\p\pD"&#'"&-15t5t5t5t# 5t C= 5t 3- 5t4S>*5t 5t5t5t5t5t5tv"&"&-1 1g1g1g1g# 1g 3- 1g 4S>* 1g 1g1g1g1g1g1gn"&"&-1 cjcjcjcj# cj 3- cj 4S>* cj cjcjcjcjcjcjR"&"&-1 .g.g.g.g# .g 3- .g 4S>* .g .g.g.g.g` d\" Qs Q Qt Q Q Q Q 3 4    (((c3h8P(\`((((T I3 I4S> I I I IDjcjcjjjj\d4ddddwdwwww"_d____j$jjjjNs3xNNNN NC N N N N 1 1D 1 1 1 1 NS N N N NNs3xNNNN S     N#c( N N N N3s8* 4 +;    84g4$44447x}[>(RZ(=r}MM %PsPPPP 8C=T"J'JdJJJJ, P P P P P3->4->->->->f ,l , ,S , , , ,E#E$EEEE"mcm,m4mmmm*j)&j)r"cZtjdd}|sn ddlm}ddlm}|}||dddd }|d vr3t |}n#t$rYnwxYw|pd }|d vrt d |d }|S)zResolve the Telegram notification mode (all/important) from env or config.yaml display.platforms.telegram.notifications, defaulting to 'important'. Mirrors the post-construction logic that used to live in gateway/run.py::_create_adapter().HERMES_TELEGRAM_NOTIFICATIONSrr)load_gateway_config)cfg_getrrr notifications>NrrR>rrRz[Unknown telegram notifications mode '%s', defaulting to 'important' (valid: all, important)) rrgateway.configr gateway.runrrrrrr(r0)rhrr_gw_cfg_raws r_resolve_notifications_moder#'s 94b 9 9D    : : : : : : + + + + + +))++G77I{JXXD:%%4yy((..00    D   ;D ''' &'+    KsAA66 BBc|t|} t|_n#t$r d|_YnwxYw|S)zFactory wrapper that constructs TelegramAdapter and applies the notification mode (preserving the gateway/run.py post-construction step).rR)r"rrr)r7rs r_build_adapterr='sUf%%G2&A&C&C## 222&1###2 Ns %99ct|dd}|sddlm}|dpd}t t |S)uTelegram is connected when a bot token is configured. check_telegram_requirements() only verifies the python-telegram-bot SDK is importable, NOT that a token is set — so without this is_connected the registry-driven plugin-enable pass in gateway/config.py would enable Telegram on any machine that merely has the SDK installed. Gate on the token (env or PlatformConfig.token), matching the generic token check Telegram had as a built-in. r7NrTELEGRAM_BOT_TOKENr)rlhermes_cli.gatewayr get_env_valuerrr)r7r7 gateway_mods r _is_connectedrH'si FGT * *E F000000))*>??E2 E   "" # ##r>)r media_filesforce_documentc Kt|dd}|sddlm}|ddpd}tt|dio|jd}dd lm} | ||||||| d{VS) awOut-of-process Telegram delivery. Delegates to the standalone ``_send_telegram`` REST sender in tools/send_message_tool.py (which already handles chunking-agnostic single sends, threads, media, retries, and parse-mode fallback). Implements the standalone_sender_fn contract so deliver=telegram cron jobs succeed when cron runs separately from the gateway.r7Nr)r*rrrr;)_send_telegram)rrr;r)rlrQr*rrrtools.send_message_toolr) pconfigrKrrrrr7r*r;rs r_standalone_sendrY's GWd + +E ; 211111 /44: "%%T'-*;*;c:ddlm}|dS)a`Configure Telegram bot credentials and allowlist. Delegates to the existing CLI setup helpers (managed-bot QR onboarding, token validation, allowlist capture) via lazy import so the full wizard behavior is preserved without duplicating ~150 lines. Replaces the _PLATFORMS["telegram"] static dict dispatch in hermes_cli/gateway.py. r)setupN) hermes_clir_setup_telegram) _setup_mods rinteractive_setupr~'s./.....     r>yaml_cfg telegram_cfgcLddl}i} ddlm}m}t |o |du}n#t $rd}YnwxYwd|vr|d|d|d|d}|Btj ds.t| tj d<d|vr.'(//a3q66//////r>rrc34K|]}t|VdSr7rLrIs rrz%_apply_yaml_config..'rr>rrc34K|]}t|VdSr7rLrIs rrz%_apply_yaml_config..'s(--Q#a&&------r>rrc34K|]}t|VdSr7rLrIs rrz%_apply_yaml_config..'s(%E%Ec!ff%E%E%E%E%E%Er>rr c34K|]}t|VdSr7rLrIs rrz%_apply_yaml_config..'s(&G&G!s1vv&G&G&G&G&G&Gr>r reactionsrcr[rrr9TELEGRAM_REPLY_TO_MODErrc34K|]}t|VdSr7rLrIs rrz%_apply_yaml_config..'s($C$CSVV$C$C$C$C$C$Cr>rrc34K|]}t|VdSr7rLrIs rrz%_apply_yaml_config..'(*O*Oa3q66*O*O*O*O*O*Or>rrc34K|]}t|VdSr7rLrIs rrz%_apply_yaml_config..'rr>r)rr;rr> dm_policyr group_policy reply_prefixr9channel_promptsnotice_deliveryreply_in_threadrallow_admin_fromchannel_skill_bindingsrgateway_restart_notification)rrQrrrrrrrrrrenvirondumpsr0rtrrrAr)rr_jsonextrasrr_skip_env_bridge _effective_rmfrcfrtacrr _telegram_extra _telegram_rtm_rtm_str allowed_usersgroup_allowed_usersr_key_GENERIC_MERGE_KEYS_k_vs r_apply_yaml_configr'seF!PPPPPPPP 3 3 5 5 \:N:N:P:PX\:\]] !!! !#l225|D_7`aaa $$%6 EV8W8WXXM 3M)N)N 14]1C1C1I1I1K1K -.\))")^2_2_ ./<// Bc8d8d/8;LIaN>Nw>W>WY]3^3^fl&&w///dfO)8L)H)H _%%   1 1 3K)L)L )U2255M8J8J8P8P8R8R/7 +, $$\22M mT * * DHH$C$C]$C$C$CCCM F 2J(K(K F36}3E3EBJ/ 0&**+=>>i/BUBUVhBiBi& )4 0 0 P"%((*O*O;N*O*O*O"O"O  R 2P(Q(Q R9<=P9Q9QBJ5 6&**+@AAo_EXEXYnEoEo& )4 0 0 P"%((*O*O;N*O*O*O"O"O  R 2P(Q(Q R9<=P9Q9QBJ5 6u88 <     dL$6 7 7 7 "''))&&B ( ( (   b" % % % >Ts+4 AAc|ddttttdgdt t dddtdd d d S) u:Plugin entry point — called by the Hermes plugin system.rrrz/Run `hermes setup` to install Telegram support.rrTELEGRAM_HOME_CHANNELr#u✈️T)rr>adapter_factorycheck_fnensure_deps_fn is_connected required_env install_hintsetup_fnapply_yaml_config_fnallowed_users_env allow_all_envcron_deliver_env_varstandalone_sender_fnmax_message_lengthrallow_update_commandN)register_platformrrrrrrr)ctxs rregisterr (s_ &&2"*+F"/204-!#r>rt)r`rar NrJ)r r&rrr1rrloggingrhtmlrrrNrp contextvarsrrrrrrrr r getLoggerrr(objectrrr r3r*rErr3r_rcrXrprrqrrrsrtrurwrrryrzr{r|rr}r~rrrrrrrrPpathlibrrrinsert__file__rparentsrrrrrrnrrrrrrrrrrrrrrrr'plugins.platforms.telegram.telegram_idsr+plugins.platforms.telegram.telegram_networkrrrutilsrrrrrrrrrrrrr|rrrrrgateway.platforms.helpersrrrrrrr rrdr}r'rRrrrrr"rrxrQrr"rrrrrrArrrr>rrs    """"""''''''''11111111111111  8 $ $ +v +# + + + +44344c4444"Y',Y4YYYYJEJ%JDJJJJ*PTK$K$K$%K$K$K$K$\JJJJ N N N N#V#V#V#VJ&%YYYYYYYYYYYYYY"/////// """!"76666666------%%% F CGKN LGIH$LLL+%. !!!!!!33uuX..008;<<===11111133333333$ 5444444444GGG       &C&HSM&&&&99 9999xt4T4444r"*<==.s.s.... cc, *rz9   Is Is I I I I* 'BJL SSH  %)!%*!! 9C!4:::Z 6 HHHHH\HHHXRXRXRXRXR)XRXRXRTeS4$T$$$$,"""""J ! ! ! !~~T~dTk~~~~Bs6C"-B43C"4B>;C"=B>>#C""2DD