Jj%0dZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Z m Z ddl mZmZmZmZmZejeZdedefdZdejddfd Zdd d efd ZdAd ZdAdZ ddlm a m!a!m"a"m#a#m$a$ ddlm%a%n #e&$rda%YnwxYwddl'm(a(m)a)m*a*m+a,m-a-m.a.ddl/m0a0m1a1ddl2m3a3da4n8#e&$r0da4ea ea!ea"ea#ea$da%ea(ea)ea*ea,ea3da.da0da1GddZ5e5a-YnwxYwddl6Z6ddl7m8Z9e6j:;dee9e<=j>dddl?m@Z@mAZAddlBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRddlSmTZTddlUmVZVmWZWmXZXddlYmZZZm[Z[m\Z\hdZ]d d!d!d"d#d$Z^d%d&d&d'd(d)Z_de`fd*Zae jbd+Zcd,edefd-Zdd,edefd.Zee jbd/Zfd,edefd0Zgdd1lhmiZjmkZle jbd2e jmZnd,edefd3Zod4ZpGd5d6eCZqdefd7Zrd8Zsde`fd9Ztdddd:d;ZudAd<Zvd=ewd>ewdewdzfd?ZxdAd@ZydS)Bz Telegram platform adapter. Uses python-telegram-bot library for: - Receiving messages from users/groups - Sending responses back - Handling media and commands N)datetimetimezone)DictListOptionalSetAnyerrorreturncz|dnt|}|s|S ddlm}||dS#t$rYdSwxYw)zORedact secrets from Telegram transport errors before logging or returning them.Nr)redact_sensitive_textT)forcez)str agent.redactr Exception)r textrs H/home/rurouni/.hermes/hermes-agent/plugins/platforms/telegram/adapter.py_redact_telegram_error_textrss22CJJD  +666666$$T6666 +++***+s , ::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)rs r_consume_abandoned_taskr&szY   !     YYY HSW XXXXXXYsA%AA) on_abandontimeoutc0 Ktj|}tj  d fd d fd }t jt |d|}d|_| tj | htj d{V\}}||vrE s |d{V | S| | t|;tjt|}| ttj#| 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 Nc^sddSdSN)done set_result)deadlinesr _mark_expiredz2_await_with_thread_deadline.._mark_expiredFs7}} &    % % % % % & &c2dSr$)call_soon_threadsafe)r(loopsr_expire_from_threadz8_await_with_thread_deadline.._expire_from_threadJs !!-00000r)T) return_whenr N)r ensure_futureget_running_loop create_future threadingTimermaxdaemonstartwaitFIRST_COMPLETEDr%canceladd_done_callbackr_run_abandon_cleanup TimeoutError) awaitabler!r rr-timerr%_cleanupr(r'r,s @@@r_await_with_thread_deadlinerC0s$   + +D  # % %D!!##H&&&&&&1111111 OC--/B C CEEL KKMMM 8 /         a 4<<==?? "!!!::::::     6777  ! +,@,L,LMMG  % %&= > > >"$$$ s AE?A>E??FcK |}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 iscoroutineisfuturerrr)r results rr=r=hs 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() failedTrbot_requestshutdownz*Abandoned Telegram request shutdown failed)rKrrrgetattrrrErF)apprIrequestsrequestrKrGs r_shutdown_abandoned_apprPvsm {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)rreres r)re)Path)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)rrrrrc^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)rTrUrVNrXr_rb)TELEGRAM_AVAILABLEtools.lazy_depsrrtelegramrQrRrSrTrUrW ImportError telegram.extrYrZr[r\r]r^telegram.constantsr`ratelegram.requestrcTelegramMessageHandler) _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_mdv2r1s   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(?(?:\\)?\(\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_fencerQs ( + +,A4 H HHr))TABLE_SEPARATOR_REconvert_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(?e ee!fdee ee!fd4ee+d?ed@ee!de!fdAZ9de:efdBZ;ed8e4de fdCZed8e4de fdFZ?dCdHede de fdIZ@de ee!ffdJZAdKede fdLZBde fdMZCeDjEdNeDjFeDjGzZHeDjEdOeDjFeDjGzZIeDjEdPZJdKede fdQZKdKede fdRZLdKede fdSZMdKede fdTZNdKede fdUZOdKede fdVZP dBdKedee ee!fde fdWZQ dBdKedee ee!fde fdXZRdee+fdYZSdGdZdKed[e de ee!ffd\ZTd]e4de fd^ZUd]e4de fd_ZVd#ed1eedee ee!fd%eedeeWf d`ZXd#edKed1eedee ee!fdeeYf daZZ dBd#edbedKedee ee!fdeeYf dcZ[dKede fddZ\d#edee+dKedee ee!fde f dfZ]d?dgZ^de_j`fdhZad?diZbd8e4djedd fdkZcde fdlZddme de fdnZed8e4dd fdoZfd?dpZgdqedd fdrZhd?dsZid?dtZjd8e4dd fduZk d@d#e+dedvee+dweedee+f dxZldyededeefdzZmdCd#ed{ed|e deefd}Znd#e+d%e+dedd fd~Zo dCd#e+d{ed%e+de dd f dZpd?dZqd?dZrd?dZsdGdde de fdZtde dd fdZud?dZvd?dZwd1eede+de fdZx d@d#edKed1eedee ee!fdeYf dZyd dd#ededKedee ee!fdeYf dZzdGd dd#edbedKede dee ee!fdeYf dZ{dKedefdZ|d dd#edbedKede dee ee!fdeYf dZ}d#edbede fdZ~ d@d$eedee ee!fde fdZ dBd#edee+dKedee ee!fdeYf dZdZ dDd#ededededee ee!fdeYf dZ dEd#ededededee ee!fdeYf dZ dBd#edededededee ee!fdeYfdZ dBd#ededee:dededee ee!fdeYfdZ dBd#ede:dedededee ee!fdeYfdZdZdZdFde:de+deWfdZde:de+deWfdZded#edd fdZdedd fdZ dGdZdgddGfdgddGfdgddGfdgddGfddgddfddgddfddgddfddgddfddgddfddgddfdМ Zdedd fdфZdededefdԄZdede!de+defdׄZde!dedeWe eeffdلZ dAd#ededeed1eedee ee!fdeYf fd܄ Z dHd#edeeWdee ee!fdedd f fd Z dAd#ededeed1eedee ee!fdeYf fd Z dId#ededeedeed1eedee ee!fdeYffd Z dAd#ededeed1eedee ee!fdeYf fd Z dAd#ededeed1eedee ee!fdeYf fd Z dAd#ededeed1eedee ee!fdeYf dZdBd#edee ee!fdd fdZd#ede ee!ffdZdKedefdZde fdZde fdZde fdZde fdZdeefdZdeefdZdeefdZdeefdZdeefdZdee+fdZdeeDjfdZde$de fdZe(de$deefdZde$de fdZede$deefdZde$de fdZde$de fdZde$de fdZde$de fdZdeedeefdZde$de fdZdZdedefdZdefdZdedefd Zd e$defd Zd e$dedd fd Zd e!dedd fd Zd e$fdZedeededefdZ dBd e$deded]e4deedd f dZ d@de$dedee+deedd f dZde$de fdZdGdde$de de fdZÐd?dZdedee$fdZdedejdd fdZdedejdd fdZdedejdd fd Zːdedefd!Z̐dedd fd"ZdHedd fd#Zΐded e$defd$Zϐd%edd fd&ZАd%ededd fd'Zdedejdd fd(ZҐd)ededd fd*ZӐd)edd fd+ZԐd e$dd,dd fd-ZՐd?d.Zd#ed%eedee ee!ffd/Zd#ed%ed{edd fd0Ze(d1e!defd2Ze(d3e!defd4Ze(d5e!deefd6Z dBde$dedee+defd7Zde fd8Zd#edbed9ede fd:Zd#edbede fd;Zߐdedd fd<Zded=edd fd>ZxZS(JTelegramAdapterz 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_FINALIZEi@g ףp= ?gQ?N min_value max_valuenamedefaultrrr 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) mathosgetenvfloat TypeError ValueErrorisfiniter6min)rrrrrrawvalues 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.)r~selfs rmessage_len_fnzTelegramAdapter.message_len_fns r)configct|tjd|_d|_d|_||_t|ddpd|_ | dd|_ | dd|_ | dd|_d|_d|_t#dd|_i|_i|_i|_i|_|d d d d |_|dd|jd |_i|_i|_d|_d|_d|_d|_d|_ d|_!d|_"d|_#d|_$tKj&|_'i|_(tS|_*tKj&|_+tY|j-j./dd|_0tc|j-j./dd|_2tc|j-j./dd|_3|j-j./dg|_4d|j4D|_5|j-j./drdnd|_6i|_7i|_8i|_9i|_:d|_;i|_<i|_=d|_>dS)NF reply_to_modefirstdisable_link_previews rich_messages rich_drafts)HERMES_TELEGRAM_MEDIA_BATCH_DELAY_SECONDSr(HERMES_TELEGRAM_TEXT_BATCH_DELAY_SECONDSg333333?g{Gz?g@r.HERMES_TELEGRAM_TEXT_BATCH_SPLIT_DELAY_SECONDS?g@rstatus_indicator status_onlineOnlinestatus_offlineOffline dm_topicsc@h|]}d|vt|dSchat_idr).0es r z+TelegramAdapter.__init__..`s0- - - "#aC)  r)base_urll@ important)?super__init__rmTELEGRAM_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_disabledr_media_batch_delay_seconds_pending_photo_batches_pending_photo_batch_tasks_media_group_events_media_group_tasksr_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_network_error_count_polling_error_callback_ref_polling_heartbeat_task_polling_pending_stuck_count_polling_not_running_count_send_path_degradedrLock_general_request_drain_lock _dm_topicsset_forum_command_registered _forum_lockboolrextraget_status_indicator_enabledr_status_online_text_status_offline_text_dm_topics_config_dm_topic_chat_ids_max_doc_bytes_model_picker_state_approval_state_slash_confirm_state_clarify_state_notifications_mode_status_message_ids_last_overflow_preview_post_connect_task)rr __class__s rrzTelegramAdapter.__init__s3 !2333+/ #' #(!%!?!?!A!A#*6?G#L#L#WPW,0,C,CD[]b,c,c#-1,C,COUZ,[,[#+/*A*A-QV*W*W!*/ */!+44_ad*e*e'?A#CE'<> ;=*.)@)@ 6  *A* * & 04/F/F < 4 0G0 0 , ?A"BD&(-%;? ,-$12)+/(?C$ 23)01'*/ +2<>>(*,3655&"<>>04 K  ! !"4e < <0 0 &), K  ! !/8 < <) )  *- K  ! !"2I > >* * !8<{7H7L7L[Z\7]7]- - '+'=- - - { $$Z00 " " "!  57 /157!/1)4 68 9;# ;?r)cVd|_tdS)NF)rr_mark_connectedrr8s rr:zTelegramAdapter._mark_connecteds'(-% !!!!!r)cVd|_tdS)NT)rr_mark_disconnectedr;s rr=z"TelegramAdapter._mark_disconnecteds'(,% ""$$$$$r)codemessage retryablec^d|_t|||dS)NTr@)rr_set_fatal_error)rr>r?r@r8s rrCz 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. rF)r'rLrs r_should_drop_delayed_deliveryz-TelegramAdapter._should_drop_delayed_deliverysGD"ryestruec^h|]*}||+Srjstripruids rrz?TelegramAdapter._is_callback_user_authorized..-TTTs Tsyy{{TTTr),*)rrbrLcallablegateway.sessionrUlowerrmrr'rrrrrsplit)rrOrrLrMrNnormalized_user_idrunnerauth_fnrUnormalized_chat_typesource allowed_csv allowed_idss r_is_callback_user_authorizedz,TelegramAdapter._is_callback_user_authorizeds2!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&! i 8"==CCEE  \ 96;;AACCG[[ [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. rrT from_userNchatidr username full_name sender_chattitletyperVrWrXmessage_thread_idis_topic_messageFis_forumTrYrrZ) rirUrLrrbrjr'rmr)rr?rUuserrvrOrNrzrrL thread_id_rawr~is_forum_grouprMs 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,   )z@TelegramAdapter._telegram_auth_env_configured...s:>>#29S"%%++-->>>>>>r))any)rkeyss r_telegram_auth_env_configuredz-TelegramAdapter._telegram_auth_env_configured$s( >>>>>>>>r)c ^||}|j}|sdS|jjd}|d|D}||vpd|vS|jd}t |rB t|||j|j |j |j S#t$rYnwxYwtt|ddd d}t|d d}t |r\|sdS t||S#t$r td |d YnwxYwt#jd d} | sdSd| dD} d| vp|| vS)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. T allow_fromNch|]D}t|#t|ESrjrrb)rus rrzCTelegramAdapter._is_user_authorized_from_message..Gs9TTT!SVV\\^^Ts1vv||~~TTTr)rgrsrKrQrRrSz4[Telegram] Falling back to env-only auth for user %srr\r c^h|]*}||+Srjrarcs rrzCTelegramAdapter._is_user_authorized_from_message..qrer)rf)rrOrr(r)__dict__rhr'rrLrMrNrrLrrrrrrbrk) rr?rprOadapter_allow_fromallowed callback_authrmrnrqrrs r _is_user_authorized_from_messagez0TelegramAdapter._is_user_authorized_from_message0s)33G<<.  4"[.22<@@  )TT/ATTTGg%7 7  ))*HII M " "  !M &"("2"("2"("2     '94@@*dSS&"7>> G   5577 t GGFOO,,,    J! i 8"==CCEE  4TTk.?.?.D.DTTT k!;W %;;s$0B11 B>=B>D00'EEc|sdS|dp|d}|t|ndS)NrMr}r)r)clsrFrMs r_metadata_thread_idz#TelegramAdapter._metadata_thread_idtsG 4LL--R>Q1R1R !*!6s9~~~D@r)c|sdS|dp|d}|t|ndS)Ndirect_messages_topic_id!telegram_direct_messages_topic_idr)rrFtopic_ids r"_metadata_direct_messages_topic_idz2TelegramAdapter._metadata_direct_messages_topic_id{sH 4<< :;;px||Lo?p?p ( 4s8}}}$>r)cZ|sdS|d}|t|ndS)Ntelegram_reply_to_message_id)r)int)rrFreply_tos r_metadata_reply_to_message_idz-TelegramAdapter._metadata_reply_to_message_ids6 4<< >?? ( 4s8}}}$>r)cZ t|dkS#ttf$rYdSwxYw)NrF)rrrrs r_looks_like_private_chat_idz+TelegramAdapter._looks_like_private_chat_ids? w<> >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. rrr}N)r}r)r)_message_thread_id_for_sendrrr)rrrMrFrrdirect_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|Sr$)r_GENERAL_TOPIC_THREAD_IDrrrMs rrz+TelegramAdapter._message_thread_id_for_sends. C NNc.JJJ49~~r)c(|sdSt|Sr$)rrs r_message_thread_id_for_typingz-TelegramAdapter._message_thread_id_for_typings 49~~r)r cHdt|vS)Nthread not found)rrj)r s r_is_thread_not_found_errorz*TelegramAdapter._is_thread_not_found_errors!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)rrMuR[%s] delete_telegram_topic_binding failed for chat=%s thread=%s — skipping pruneTrzY[%s] Pruned stale Telegram DM topic binding chat=%s thread=%s (Bot API: thread not found)) rLhasattrrrrrrrinfo)rrrMstoredbremoveds r_prune_stale_dm_topic_bindingz-TelegramAdapter._prune_stale_dm_topic_bindings ?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)r8rfrjendswithtelegram.errorr isinstancer)r rrs r_is_bad_request_errorz%TelegramAdapter._is_bad_request_error's'--// <  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. rFNmessage to be replied not foundTr)direct_messages_topiczmessage thread not foundr topic_closed topic_deletedztopic not foundc3 K|]}|vV dSr$rj)rmarker err_lowers rrzNTelegramAdapter._should_retry_without_dm_topic_reply_anchor..Zs(CC66Y&CCCCCCr))r)rrrjr)rr rFr topic_markersrs @r+_should_retry_without_dm_topic_reply_anchorz;TelegramAdapter._should_retry_without_dm_topic_reply_anchor2s* X\\*LMM 5((// 5JJ$$&&  */PT]/]/]4 <<2 3 3 MCCCC]CCCCC tur)send_fn send_kwargs media_label reset_mediaczK |di|d{VS#t$r}||||std|j||| |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: %srr}rrj)rrrwarningrdictpop) rrrrFrrrsend_err retry_kwargss r&_send_with_dm_topic_reply_anchor_retryz6TelegramAdapter._send_with_dm_topic_reply_anchor_retry^s. 1 //;//////// / 1 1 1CC#   NN:     &  ,,L26L. /   0$ 7 7 7   7 > > > 00<00000000 0 0 0 0 0 0) 1s  B:BB5/B:5B:c&t|jddr |jjdgng}t |t r|d}t|rdd|DndS)zNReturn validated fallback IPs from config (populated by _apply_env_overrides).r(N fallback_ipsrfc34K|]}t|VdSr$rrvs rrz0TelegramAdapter._fallback_ips..s(-I-Ic!ff-I-I-I-I-I-Ir)) rLrr(r)rrrkrrr 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)rrjr8rf)r rs r_looks_like_polling_conflictz,TelegramAdapter._looks_like_polling_conflictsQ5zz!! O $ * * , , : 974? 90D8 r)c|jj}|dvrdS ddlm}m}t |||frdSn#t$rYnwxYwt |tS)zJReturn True for transient network errors that warrant a reconnect attempt.>timedout networkerrorconnectionerrorTr NetworkErrorTimedOut) r8rfrjrrrrrOSError)r rrrs r_looks_like_network_errorz)TelegramAdapter._looks_like_network_errors'--// B B B4  = = = = = = = =%,!9:: t     D %)))sA AAct}|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 r$rrwaddr8rfrjrrLr 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 pooloccupiedTrNrFrrs 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(>ronr^r_T>0norfalseF) rLrr(r)rrrbrjr')rrrrlowereds rr z"TelegramAdapter._coerce_bool_extras.5dk7D.Q.Q[ !%%c***W[ =N eS ! ! kkmm))++G444t555uNE{{r)cbt|ddsiStdtdiSddiS)Nr Flink_preview_optionsT) is_disableddisable_web_page_preview)rLrWrs r_link_preview_kwargsz$TelegramAdapter._link_preview_kwargssDt5u== 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_CHARSrrs r_content_fits_rich_limitsz)TelegramAdapter._content_fits_rich_limitss7||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)inspectiscoroutinefunctionrLrrs r_bot_supports_richz"TelegramAdapter._bot_supports_richs%*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)rr details_blocks r._has_telegram_desktop_details_math_crash_shapez>TelegramAdapter._has_telegram_desktop_details_math_crash_shape's[ 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_REr'rs r+_has_telegram_desktop_cjk_rich_garble_shapez;TelegramAdapter._has_telegram_desktop_cjk_rich_garble_shape7s(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|VdSr$_TABLE_SEPARATOR_REmatchrlines rrz8TelegramAdapter._needs_rich_rendering..Ms.PP4"(..PPPPPPr)T(?m)^\s*[-*]\s+\[[ xX]\]\s+3(?m)^|^$$r splitlinesrr'rs r_needs_rich_renderingz%TelegramAdapter._needs_rich_renderingAs 5 PP7;M;M;O;OPPP P P 4 93W = = 4 9KW U U 4 7??4ur)c|r+td|DsdStjd|rdStjd|rdSd|vrdSdS)uTrue when pipe tables are the only rich construct in *content*. Tables are auto-routed to ``sendRichMessage`` even when the full ``rich_messages`` opt-in is off — MarkdownV2 has no table syntax and the legacy path rewrites them into bullet lists, which reads like a regression when users enable Telegram Topics and expect native tables. Task lists, ``
``, and block math still require the full opt-in. c3>K|]}tj|VdSr$r/r2s rrzATelegramAdapter._content_is_pipe_table_primary..`s?" " 04  %d + +" " " " " " r)Fr4r5r6Tr7rs r_content_is_pipe_table_primaryz.TelegramAdapter._content_is_pipe_table_primaryWs c" " 8?8J8J8L8L" " "    5 93W = = 5 9KW U U 5 7??5tr)chtt|ddp||S)z2Whether rich delivery is allowed for this payload.r T)r'rLr<rs r_rich_delivery_enabledz&TelegramAdapter._rich_delivery_enabledls: D2D 9 9 <227;;   r)cjt||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) r'r>rLrbr9r)r,rr"rs r_rich_eligiblezTelegramAdapter._rich_eligibless  ' ' 0 0 *D"7??? * *  ***733  * GGPPP  * DDWMMM  *..w77 *''))   r)cvt|pid o||S)N expect_edits)r'r)r@rrrFs 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. FrjrCs 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)rLr"rrs rstreaming_overflow_limitz(TelegramAdapter.streaming_overflow_limitsT D2D 9 9 /D"7?? /'')) / . .tr))skip_entity_detectionrIc6dt|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``. markdownTrI)r)rrrIpayloads 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. > invalidtokenendpointnotfoundT error_codeNimethodendpointz not foundzdoes not existzno such method) r8rfrjrAttributeErrorrNotImplementedErrorrLr)rrNrss 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)rrXrrj)rrNrWs 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. rrNrrrr) rrrr'r)r_should_thread_replyrr) rrrrFrMmetadata_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+47XDz2TelegramAdapter._try_send_rich..0PPPA!-1---r)r FrTr message_idreply_parameterssendRichMessage api_kwargsuA[%s] sendRichMessage rejected (%s) — falling back to MarkdownV2rr timed out retry_afterzretry\s+(?:in\s+)?(\d+)z=[%s] sendRichMessage transient failure (no legacy resend): %s)successr r@rurGrich_sent_storerwrn)&rrfrrMupdateitemsrJrLrrrr[rXr rrrrrjrrrrUrrrr' IGNORECASErrrrrsrr)gatewayryrecord)rrrrrFrMroutingrdrerLmsgrNerr_str _TimedOut is_timeoutis_connect_timeout _retry_after_re_m safe_errorrnrys r_try_send_richzTelegramAdapter._try_send_richs!,,X66 33GXxQZ[[ ?4%," ]2':: 66w??# #  PP)<)<)>)>PPPQQQt00::;;; 415 9 9 D/.rmr)r FrTreditMessageTextrq not modifiedrzuK[%s] rich editMessageText rejected (%s) — falling back to MarkdownV2 editrrsrtzB[%s] rich editMessageText transient failure (no legacy resend): %srwr r@rx) rrrMrrrr{r|rLrrrr[rXr rrjrsrrrrrrrUrrrrr~ryr)rrrnrrFrLrMrerNrrrrrrys r_try_edit_richzTelegramAdapter._try_edit_richsq*2'::j// 66w??# #  ,,X66 44    $- 5   PP)<)<)>)>PPPQQQ 415 9 9 D/>>>st4"C I)#A$I$I) !I$43I$'I)-!I$GI$G,)I$+G,,A2I$I)$I)-7J%% J21J2c~tt|ddot|ddot|dd o|t|dd oj|oh|oT|| o>|| o(||o|S)Nr Tr Fr r)r'rLrbr)r,rr"rs r_should_attempt_rich_draftz*TelegramAdapter._should_attempt_rich_drafts D2D 9 9 *4e<< *D"7??? *D"8%@@@ * *   * GGPPP *DDWMMM *..w77 *''))   r)draft_idcKt|t|||d}||}|t||d< |jd|d{V}t |S#t$rj}||r)d|_ t d|j |n!t d|j |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. )rrrhNr}sendRichMessageDraftrqTuB[%s] sendRichMessageDraft unsupported (%s) — using legacy draftsuL[%s] sendRichMessageDraft transient failure (%s) — legacy draft this frameF) rrrMrrrr'rrXrrrr) rrrrrFrLrMokrNs r_try_send_rich_draftz$TelegramAdapter._try_send_rich_drafts6 2'::H  66w??# #  ,,X66  +.y>>G' ( y//0FSZ/[[[[[[[[B88O   --c22 ,0) XIs  bIs55555 s 0B DADDcK|jr |jjsdS |jjjd}n#t$rYdSwxYw |d{Vn2#t$r%t d|jdYnwxYw |d{Vt d|jdS#t$r&t d|jdYdSwxYw)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+. Nrz0[%s] Polling request shutdown failed (non-fatal)Trz2[%s] Polling request pool drained before reconnectz5[%s] Polling request re-initialize failed (non-fatal)) rrIrJrrKrrr initialize)r polling_reqs r_drain_polling_connectionsz*TelegramAdapter._drain_polling_connections su"  dim  F )-03KK    FF  &&(( ( ( ( ( ( ( ( (    LLB D        ((** * * * * * * * LLDdi         LLG D        s01 ??A,B  B :C ,C=<C=c`t|dd}|tj}||_|S)Nr")rLrr!r")rlocks r_get_general_request_drain_lockz/TelegramAdapter._get_general_request_drain_lock7s1t: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. rNrIrrvzC[%s] General request shutdown failed after pool timeout (non-fatal)Trz=[%s] General request pool drained after Telegram pool timeoutzH[%s] General request re-initialize failed after pool timeout (non-fatal)) rLrJrrrKrrrrr)rrI 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 EEreasonc|jrdS|jr=|js$td|j||dSd|_td|j||tj }| | ||_|j |j|j|j jdS)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. NzA[%s] Telegram polling recovery already scheduled; ignoring %s: %sTzR[%s] Telegram polling degraded (%s); gateway stays alive and will retry. Error: %s)has_fatal_errorrr%rrrr rrr2 create_task_handle_polling_network_error_background_tasksrr<discard)rr rr,s r_schedule_polling_recoveryz*TelegramAdapter._schedule_polling_recoverycs    F  # D,D,I,I,K,K  LLS 65    F#'  ` Ivu   '))#'#3#3D4V4VW\4]4]#^#^  ""4#;<<<  2243I3QRRRRRr)c<K|jsdSt|jdd}t|sdS |dd{VdS#t$rI}||r.t d|j|d|_Yd}~dSd}~wwxYw)a3Clear any stale webhook, but never fail polling on a network error. Returns True when the webhook was cleared (or there was nothing to do) and False when a transient network error was swallowed so bootstrap can continue to polling; the reconnect ladder recovers from there. Fdelete_webhookNT)drop_pending_updateszu[%s] deleteWebhook failed with a recoverable network error; continuing to polling so getUpdates/retry can recover: %s) rrLrhrrrrrr )rrerrs r_delete_webhook_best_effortz+TelegramAdapter._delete_webhook_best_effort}sy 5 ,[%s] Telegram polling resumed after network error (attempt %d)rz*[%s] Telegram polling reconnect failed: %s)$rrr rr rrrC_notify_fatal_errorrrrsleeprrrunningwait_forstop_UPDATER_STOP_TIMEOUTr>rrrrrQrrrr1_verify_polling_after_reconnectrrr<rrr)rr MAX_NETWORK_RETRIES BASE_DELAY MAX_DELAYattemptr?delayrrMprobe retry_errsafe_retry_errorrs rrz-TelegramAdapter._handle_polling_network_errors<    F    ))Q.))#' 3 ( ( (&(;<  LL149gGbchGiGi j j j  ! !":Gt ! T T T**,, , , , , , , , FJ!! "45yAA077  Y Iw 3UJ   mE""""""""" i  s{ s{': "*3;+;+;+=+=G\]]]]]]]]]]]+NN9     D --/////////3 0 Z"#XYYY+++ & 0%*#?,        KKP 7   12D -(-D $' H-d.R.R.T.TUU&**5111''(>(FGGGGG H H 0 0 0:9EE  NNGTd e e e' 0,66yAA&**4000&&t'='EFFF ,0((((((( 0 0 0 0 0 0  0sP F"8EF/F  F F  F FF[%s] Polling heartbeat probe failed (%s); triggering reconnect)rrrrrIrhrLrr_probe_pending_updatesrr>rrrrrr%r2rrr)rHEARTBEAT_INTERVAL PROBE_TIMEOUTrI probe_errr,s r_polling_heartbeat_loopz'TelegramAdapter._polling_heartbeat_loop6s,  ( ' m$6777777777'F'+y:dimmd; Xt < <==F&szz||]CCCCCCCCC11#}EEEEEEEEEE)   ('2   TIy+D4L4Q4Q4S4SHHHH/11+/+;+;66yAA,,((((((    K( s=!B.B.B.$A B..E1E1AE!AE!! E10E1 probe_timeoutcK|jrdS|jr"|js d|_dS|jrt |jddnd}| d|_dSt |ddsd|_|xjdz c_td|j |j|jdkrtd|_td |j tj }| | td |_dSd|_t |d d}t|sdS tj||d{V}n#tjt$f$rYdSwxYwt't |d dpd}|dkr d|_dS|xjdz c_td |j ||j|jdkrvd|_td|j tj }| | td|_dSdS)uDetect a wedged getUpdates consumer via pending_update_count. PTB can report ``updater.running == True`` while its long-poll task is silently stuck (e.g. a socket that epoll keeps reporting readable on WSL2). ``get_me()`` stays healthy because it uses the general request path, so the CLOSE-WAIT heartbeat never fires — yet DMs queue in the Bot API and never reach handlers (#42909). ``get_webhook_info().pending_update_count`` is the one signal that exposes this: a growing/stuck queue while we believe we're polling means the consumer is dead. We only escalate after two consecutive stuck probes so a single update that's simply in-flight between probes does not trip a needless recovery. Recovery reuses ``_handle_polling_network_error`` — the same ladder PTB's own ``error_callback`` feeds — so no new restart machinery is introduced. This also covers the harsher case where the updater has stopped entirely (``running=False``) with no reconnect in flight: the long-poll task is gone rather than wedged, so even ``get_webhook_info`` can't report a queue against a live consumer. We detect the stopped updater directly and feed the same ladder (#55769). NrrrFrvzY[%s] Telegram polling heartbeat: updater stopped while in polling mode (stuck probe %d/2)rzV[%s] Telegram updater is not running (long-poll task gone); triggering polling restartz.Telegram updater stopped while in polling modeget_webhook_infopending_update_countzX[%s] Telegram polling heartbeat: %d update(s) queued but not consumed (stuck probe %d/2)zX[%s] getUpdates consumer appears wedged (queue not draining); triggering polling restartz8getUpdates consumer wedged: pending updates not draining)rrr%rrrLrrrrrr2rrrrhrr>rr)rrIrrr,rrpendings rrz&TelegramAdapter._probe_pending_updatesys2    F  # D,D,I,I,K,K ./D + F9=L'$)Y555 ?01D - Fw 511 12D -  + +q 0 + + NN2 4:    .!3323/8I /11+/+;+;66$%UVV,,( F*+'"3(:DAA())  F  )*:*:*<*>C!DD a<<01D - F ))Q.)) * Iw A    , 1 101D - NN-     +--D'+'7'722 ![\\((D $ $ $ 2 1s#E<<FFc^Kd}d}tj|d{V|jrdS|jr|jjr|jjjsKt d|j|| tdd{VdS tj |jj |d{Vd|_dS#t$rH}t d|j||| |d{VYd}~dSd}~wwxYw)a(Heartbeat probe scheduled after a successful reconnect. PTB's Updater can survive a botched stop()+start_polling() cycle with `running=True` but a wedged consumer task. No error callback fires, so the reconnect ladder doesn't advance on its own. This probe detects the wedge by: 1. Sleeping HEARTBEAT_PROBE_DELAY so a healthy long-poll has time to complete at least one cycle. 2. Verifying `Updater.running` is still True. 3. Probing the bot endpoint with a tight asyncio timeout. A wedged httpx pool fails this probe; a healthy one returns well under the timeout. On any failure, re-enter the reconnect ladder so the existing MAX_NETWORK_RETRIES path can ultimately escalate to fatal-error. rrNuC[%s] Updater not running %ds after reconnect — treating as wedgedz-Updater not running after reconnect heartbeatFz;[%s] Polling heartbeat probe failed %ds after reconnect: %s)rrrrrrrrrrrrrIrr r)rHEARTBEAT_PROBE_DELAYrrs rrz/TelegramAdapter._verify_polling_after_reconnects$!# m1222222222    F  di/ DI4E4M  NNU 0   44LMM        F @"49=#7#7#9#9=II I I I I I I I',D $ $ $ @ @ @ NNM 0)   44Y?? ? ? ? ? ? ? ? ? ? ? ? ? ?  @s>C D,$=D''D,c|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. rN)!_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()) rrLrrEventis_setr$rrr)rrattr 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 VK|jr |jdkrdS|xjdz c_d}d|jdzz}|j|krtd|j|j||| |jr|jjr|jjjrt tj |jj td{Vn5#tj $r#td|jYnwxYwn#t$rYnwxYwtj|d{V|d{V|j} |st#d|jt&jd |j d{Vtd |j|j|d |_dS#t$r}td |j|j|||j|krFtj}||||_Yd}~dSYd}~nd}~wwxYwd|t7dt9d|dzDfz}td|j|||jo |jdk}|d|d  |jrI|jjr=tj |jj td{Vnj#tj $r#td|jYn9t$r-} td|j| dYd} ~ nd} ~ wwxYw|s|d{VdSdS)Ntelegram_polling_conflictrvrru[%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: %srBzv[%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: %sTr) rfatal_error_coderrrrrrrrrrrr>rrrrrrQrrrr2rrrsumranger rCr) rr MAX_CONFLICT_RETRIES RETRY_DELAYrMrr,r?_already_fatal stop_errors rrz(TelegramAdapter._handle_polling_conflictK s   D$9=X$X$X F$ $$)$$  D82=>  '+? ? ? NN 479MU     9!2ty7H7P%.ty/@/E/E/G/GQfggggggggggg"/K I     - ,, , , , , , , ,1133 3 3 3 3 3 3 3)C% g&'efffk//$*$4).#'#C0  NIt;=Q01,   /It;=Q /2FFF#355D/3/?/?55i@@00D,FFFFFGFFFF : W $S(a(aeAG[^_G_>`>`(a(a(a%a%ab  c   ( Iw      E%)DD  97eTTT y `TY. `&ty'8'='='?'?I^__________#    NNQ           NN] :            -**,, , , , , , , , , , - -so,$D=CD/D>DDD DDA1G IA3I  IAL!!/N N#NN icon_coloricon_custom_emoji_idc,K|jsdS ||d}|||d<|r||d<|jjd i|d{V}|j}td|j||||S#t $r}t|} d| vsd| vr#td|j||nNd | vsd | vr#t d |j||n#t d |j|||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)rrrrz5[%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: %srj) rcreate_forum_topicr}rrrrrrjr) rrrrrkwargstopicrMr 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 HItWa44444+ sAA$$ D.BDDparent_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)rrr chat_id_intrMs 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.r N:rtopicsrrMrrrr)rrr)replace_existing) rrbrrrr#r)r-r setdefaultr_persist_dm_topic_thread_id) rrrrrr cache_keycached topic_conf chat_entryentry candidaterMs 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)rr}rz5[%s] Renamed DM topic in chat %s thread_id=%s -> '%s')rrrredit_forum_topicrrr)rrrMr chat_id_args rrename_dm_topiczTelegramAdapter.rename_dm_topicX 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_home config.yamlz:[%s] Config file not found at %s, cannot persist thread_idNrutf-8encoding platformsrr(rFrrrrMT)rrMr)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_constantsrexistsrrryamlopen safe_loadrrr)rrrhermes_cli.configrrr)rrrrMrr config_path_yamlfrrtelegram_configr(rchangedmatching_chat_entryr  chat_matchestrrs rr z+TelegramAdapter._persist_dm_topic_thread_ido 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. Nrrz*[%s] Setting up %d DM topic(s) for chat %srrrMz4[%s] DM topic loaded from config: %s -> thread_id=%srr)rrrrz([%s] DM topic cached: %s -> thread_id=%su📌 )rr}rz2[%s] Could not send seed message to topic '%s': %s)r-r)rrrrrr#rrr r send_messagerr) rr rrr rr existing_thread_idr icon_emojirMseed_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?c|j}|r|sdStj||_dS)zKick off deferred post-connect housekeeping in the background. Idempotent: if a previous housekeeping task is still running (e.g. a rapid reconnect), it is left in place rather than double-scheduled. N)r7r%rr1_run_post_connect_housekeeping)rrs r _start_post_connect_housekeepingz0TelegramAdapter._start_post_connect_housekeeping sR &     F")"7  / / 1 1# # r)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%|||n:#t&$r-} td |j| 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|]\}}||Srjrjrrdescr9s r zBTelegramAdapter._run_post_connect_housekeeping..3 )WWW:4 4 6 6WWWr)rfscopez.[%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: %sTronlinez+[%s] DM topics setup failed (non-fatal): %s)rr9r:r;r<hermes_cli.commandsr>r?rr7r current_taskrLrset_my_commandsrrrrrr_set_status_indicatorr4r)rr:r;r<r>r?rA menu_commands hidden_count bot_commands scope_cls scope_name scope_errr topics_errr9s @rr6z.TelegramAdapter._run_post_connect_housekeeping sF /+  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!   000==========      ++----------   AIzD  %     &'*>*@*@@@*.'''A@t&'*>*@*@@@*.'....sEA EAC.-E. D$8"DED$$5EH F$#F H FHF21H2 F?<H>F??HGH H(#H HHHIH**I#I5) is_reconnectrVc $%Kts"tdjdSjjs"tdjdS djjdsdStjjj}jj d}|ri| |}| jj d|}t dj|jj d r5|d }t d jd td t dt fd}d td t"dt"fd}|dd|dd|dd|dd|ddd}ddlm}|}|-ddl} | |d|j|j$nd$dWd t0t2dt2f$fd! } t5jd"d#d$v} } | shtd%jtAd{V} t d&jd'!| d(g| } tEd)| *}| r||sz| sxt d+jd'!| i}$$|d,<tGdXi|d d-tI| fi|ii}tGdXi|d d-tI| fi|ii}n|rTt d.j|tGdXi||| d/}tGdXi||| d/}nR| r t d0jtGdXi|d | i}tGdXi|d | i}|%|&|}|'_(j(j)_*j(+tYtZj.tZj/zj0j(+tYtZj/j1j(+tYtZj2tgtZd1tZj2zj4j(+tYtZj5tZj6ztZj7ztZj8ztZj9j:ztZj;j:zj<j(+t{j> dd2l?m@}mA}n#t$r tx}}YnwxYwd3}|d4d5}t|D]_} td6j|d7z|tj(F|j(fd89d{Vn#tjH$rx||d7z krUtd:|zd;}td<j|d7z|||tjJ|d{Vntd=|d>|d?d@Y||tf$rj}||d7z krUtd:|zd;}tdAj|d7z|||tjJ|d{VnYd}~Yd}~wwxYwj(Kd{Vt5jdBd#}|rtdCdD}t5jdEd#}|stdFddGlNmO}||jPpdH}j(jQRdI||||tjT| Jd{Vd _Ut dKj||nVd{VtjW%dLtddf%fdM }|_YZ| |Nd{V}|s tdOj[jUrdPndQ} t dRj| jUsdj\r2j\]sj\^tj_`_\ad S#t$rl}!bt|!}"dS|"}#ddT|#d UtdVj|"Yd}!~!dSd}!~!wwxYw)Yu`Connect 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_SECRET Secret token for update verification zL[%s] python-telegram-bot not installed. Run: pip install python-telegram-botFz[%s] No bot token configuredztelegram-bot-tokenzTelegram bot tokenr 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|cYSwxYwr$)rrrrrrrrs r_env_intz)TelegramAdapter.connect.._env_int sP#rys7||<<===!:.###"NNN#.1AAc ttj|t|S#tt f$r|cYSwxYwr$)rrrrrrr[s r _env_floatz+TelegramAdapter.connect.._env_float sP# 4W!>!>???!:.###"NNN#r]HERMES_TELEGRAM_HTTP_POOL_SIZEi!HERMES_TELEGRAM_HTTP_POOL_TIMEOUTg @$HERMES_TELEGRAM_HTTP_CONNECT_TIMEOUTg$@!HERMES_TELEGRAM_HTTP_READ_TIMEOUTg4@"HERMES_TELEGRAM_HTTP_WRITE_TIMEOUT)connection_pool_size pool_timeoutconnect_timeout read_timeout write_timeoutr)platform_httpx_limitsNre)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)r)rnr _pool_limitss r _with_limitsz-TelegramAdapter.connect.._with_limits s6l0b11+0F0F'3F8$ r)$HERMES_TELEGRAM_DISABLE_FALLBACK_IPSr >rrr^r_u@[%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: %srp transportz;[%s] Proxy detected; passing explicitly to HTTPXRequest: %s)proxyrnz4[%s] Telegram fallback-IP transport disabled via envVENUErHERMES_TELEGRAM_INIT_TIMEOUT>@u.[%s] Connecting to Telegram (attempt %d/%d)…rvc t|Sr$)rP)rMs rz)TelegramAdapter.connect..N s9PQT9U9Ur))r!r rruD[%s] Connect attempt %d/%d timed out after %.0fs — retrying in %dsz(Telegram initialization timed out after z attempts (z.0fzus 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 %dsTELEGRAM_WEBHOOK_URLTELEGRAM_WEBHOOK_PORTi TELEGRAM_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 /telegramz0.0.0.0)listenporturl_path webhook_url secret_tokenrrz-[%s] Webhook server listening on 0.0.0.0:%d%sr cjrjsdS|r|_jjjjj dS |rt dj ||_jjjjj dStdj |ddS)Nz5[%s] Telegram network error, scheduling reconnect: %sz[%s] Telegram polling error: %sTr)rr%rrrrrrr<rrrrrrr )r r,rs r_polling_error_callbackz8TelegramAdapter.connect.._polling_error_callback sp/8P8U8U8W8W88??i33555373C3CDDaDabgDhDh3i3i0.2243KLLL0BB4CYCabbbbb77>>i'^`d`ikpqqq373C3CDDfDfglDmDm3n3n0.2243KLLL0BB4CYCabbbbb %F SXcg hhhhhr))rrze[%s] Connected in degraded Telegram mode: gateway is alive, polling will be retried in the backgroundwebhookpollingz$[%s] Connected to Telegram (%s mode)zTelegram startup failed: telegram_connect_errorrBz&[%s] Failed to connect to Telegram: %sr$rj)errr rrtoken_acquire_platform_lockrYbuilderr(r)rrXrrYrrr%gateway.platforms._http_client_limitsrjhttpxLimitsrlrmrrrrrbrjrrrrryrcrrOget_updates_requestbuildrrIr add_handlerrr^TEXTCOMMAND_handle_text_message_handle_commandLOCATIONrL_handle_location_messagePHOTOVIDEOAUDIOVOICEDocumentALLSticker_handle_media_messager[_handle_callback_queryrrrrrrrCrrr>rrr8rr urllib.parserpathr start_webhookrQrrrr2rrrr:rr%r;r1rr7_release_platform_lockrrC)&rrVrcustom_base_urlr\r_request_kwargsrj _base_limits_httpxrrdisable_fallbackr proxy_targets proxy_url_transport_kwargsrOrrr _max_connect _init_timeout_attemptr9init_errr webhook_portwebhook_secretr webhook_pathrpolling_startedmoderrr?rqr,s&` @@rconnectzTelegramAdapter.connectf sQ ,"  LL^    5{   LL7 C C C5j ../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?<>>'''#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  2AAAAAAAAA 2 2 2*11 xxx 2L&J'EtLLM!,//) ) (NNH 8a<6 ,,.. -/3i#U#U#U          E+   ,"222"1="55b Ix!|\=RV&mD1111111111%]|]] -k]]]21%h8   ,"222"1="55W Ix!|\8T&mD111111111121111 )//## # # # # # # #)$:B??EEGGKa  ''>EE !#+Db!I!I!O!O!Q!Q% & K   211111'x 449H[ i'55$%) +!/$*$4 .:)96         &*" CI|\66888888888/11i9iiiiiiii04K0(,(E(E.:)9#: )F))######'NND   " " " $ 2A99 D KK> 4 P P P % /:8T8Y8Y8[8[:077999/6/D002200,  1 1 3 3 34     ' ' ) ) )4Q77J>*>>G  ! !":Gt ! T T T LLA49j Y Y Y55555  s~!hV$h&X/.h/YhY#h)A[hB_ h _A^>8h>_Ih j A!jj rJcjKt|ddsdS|j}|dS|r|jn|j}|dd} ||d{Vt d|j|dS#t$r-}t d|j||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. r*FNx)short_descriptionz#[%s] Set bot status indicator to %rz1[%s] Failed to set bot status indicator to %r: %s) rLrr+r,set_my_short_descriptionrrrrr)rrJrIrrs rrNz%TelegramAdapter._set_status_indicator st8%@@  Fi ; F+1Pt''t7PDSDz ...FF F F F F F F F KK=ty$ O O O O O    LLC 4          s=A;; B2"B--B2cKtjggtdttjddffd }t |jD] }||t |jD] }||t |j D] }||||j D]}| rtj ddid{V|j |j |j |j |j |j |j ur d|_ dSdS)aCancel every delayed-delivery task family before disconnect completes. Covers media-group, photo-batch and text-batch flush tasks plus the polling-error recovery task. Each sits behind an ``asyncio.sleep()``; if teardown leaves them running they dispatch ``handle_message`` into a torn-down session. Skips the current task so the coroutine driving teardown does not cancel itself. rr Nc<|r|s|urdSt|}|vrdS||t j|st j|r|dSdSr$)r%rwrrrrFrE)rrawaitable_tasksrL pending_tasksrs rcollectz?TelegramAdapter._cancel_pending_delivery_tasks..collect s 499;; $,*>*>XXF~~ HHV      & & &%% -)>@@AA  D GDMMMM()))!  D KKMMMM  K./JTJJ J J J J J J J %%'''  &&((( '--/// #))+++ &,,... "((***  #< 7 7'+D $ $ $ 8 7r)cK|t|dd}|rD|s0|t j|dd{Vd|_|jrV|js=|j |jd{Vn#tj$rYnwxYwd|_ | dd{Vn#t$rYnwxYw| d{V|j r" |j j r|j j jrt t j|j j t"d{Vn5#tj$r#t&d|jYnwxYw|j jr|j d{V|j d{VnE#t$r8}t&d |jt/|Yd}~nd}~wwxYw|d|_ d|_t&d |jdS) zHStop polling/webhook, cancel pending delayed deliveries, and disconnect.r7NT)rFrIrz`[%s] updater.stop() timed out during disconnect (likely CLOSE-WAIT socket); forcing app shutdownz)[%s] Error during Telegram disconnect: %sz[%s] Disconnected from Telegram)r=rLr%r;rrr7rrrNrrrrrrrrr>rrrrKrrrr)rpost_connect_taskrs r disconnectzTelegramAdapter.disconnect? s@ !!! $D*>EE  L%6%;%;%=%= L  $ $ & & &.!2dKKK K K K K K K K"&  ' 0L0Q0Q0S0S   ( / / 1 1 1 222222222)    '+$ ,,E,:: : : : : : : : :    D 11333333333 9   9$):)B%.ty/@/E/E/G/GQfggggggggggg"/O I 9$+)..*********i((**********   ?I:1==  ##%%%   5tyAAAAAsa/ B==CCC77 DD*H=FH/F85H7F88A H I.II 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)rrrrs rr^z$TelegramAdapter._should_thread_reply s@ 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 connectedrwr r send_path_degradedTrNrzrFrHlen_fnrvc Tg|]%}ttjdd|&S)z \((\d+)/(\d+)\)$z \\(\1/\2\\))rrr)rchunks rrEz(TelegramAdapter.send.. sF93_eLLr)r)rrrsrrr]r}rlrr parse_moderparserKz<[%s] MarkdownV2 parse failed, falling back to plain text: %srz;[%s] Thread %s not found, retrying once with same thread_idz<[%s] Thread %s not found, retrying without message_thread_idrz8[%s] Reply target deleted, retrying without reply_to: %srz>[%s] Network error on send (attempt %d/3), retrying in %ds: %sru retry afterrzI[%s] Telegram flood control on send (attempt %d/3), retrying in %.1fs: %s) message_idsrequested_thread_idthread_fallback)rwrn raw_responsez([%s] Failed to send Telegram message: %smessage_too_longtoo longzF[%s] send() content too long, falling back to new-message continuationtoo_long)rwr error_kindrrt)rwr r@rrj)?rrsrLrbrDrrwr) send_typingrformat_messagetruncate_messageMAX_MESSAGE_LENGTHr~rrrrrrrrrrU enumeraterrrr'rr^rrrrrr0rr` MARKDOWN_V2rrJrjrrrrrrrrr rrrrrrrnr rtrlocals)+rrrrrF rich_result formattedchunksrrMrused_thread_fallback_NetErr_BadReqrrrretried_thread_not_foundr_r`rarbrcrdreeffective_thread_idr _send_attemptmd_error plain_chunkrrsafe_send_erroris_pool_timeoutr9rurrrr_torrs+ rsendzTelegramAdapter.send sS 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. NTfinalizerFr)rr5r) edit_messagerwrnrr)rrrrrFr 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||dkrtdd|cYd} ~ St7j|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. FrrrNrTrzrrnrrrnrrrz;[%s] MarkdownV2 edit failed, falling back to plain text: %srrz6[%s] edit_message overflow (%d UTF-16 > %d), splittingrurrz*[%s] Telegram flood control, waiting %.1fsg@zflood_control:z+[%s] Edit retry failed after flood wait: %s) connecterrorz connect errorzconnection errorrz network errorrt readtimeout writetimeoutzserver disconnectedztemporarily unavailableztemporary failurerc3 K|]}|vV dSr$rj)rrrs 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)rrsr@rrr6rr~r_edit_overflow_split!_truncate_stream_overflow_previewr)edit_message_textrrrr`rrrjrrrrrrrLrrr r)rrrnrrrFr _preview_key_saturated_previewrfmt_errsafe_format_error_plainr truncatedrur9rr_transient_markers _is_transientrrs @rrzTelegramAdapter.edit_messagesZ&y De?CCC C  #++G44 # $ 3 3Wx!4!!K&""G c*oo6 "  @  ' + +L$ ? ? ? W   7 7 7 !66Z8h7<>> > > > > > >w[ ?s2AKK$AG-,K- J:73J5*J:+K0BJ50K5J::K W:5W5W:AW52W:8AW5;W:AW5W:AW56W:<W5A S*$W:* U4AT?4U5W59W:?UA$W5(W:.AW5/W:5W:cR|||jtdS)aReturn a one-message preview for oversized streaming edits. Streaming edits must keep targeting the original message. Splitting a mid-stream preview creates continuation messages and moves the active message id, so the next accumulated-token edit repeats the overflow cycle (#48648). Final edits still use ``_edit_overflow_split`` to deliver the complete response. rr)rrr~rs rr z1TelegramAdapter._truncate_stream_overflow_previews7$$   #%     r)cn K|||jt}t|dkr|g}|d} |rt ||} |jt|t||tj d{Vn#t$r} dt| vrktd|j| |jt|t|t%|d{VYd} ~ nEd} ~ wwxYw|jt|t||d{Vn#t$rv} t| } d| vrnFtd |j| d t)d t|  cYd} ~ SYd} ~ nd} ~ wwxYwg} |g} |}||}|ddD]}d}|rt|nd}|||||}|rdndD]} |r#t ||}n|rt%|n|}|jjd!t|||r tj nd|d||||d{V}nA#t$r3}dt|vr|r|drin||||d} |jjd!t||rt%|n|d||||d{V}Yd}~nx#t$r2}td|j|d}Yd}~Yd}~nAd}~wwxYw|rYd}~td|j|d}Yd}~nd}~wwxYw|td|jdt| zt|dd| D}t)d |dd d dt| zt|||t9| dt9| cStt;|ddp|}| || ||}| r| dn|}td|jdt| z|t)d |t9|  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. rrvrrNrzW[%s] Overflow split: MarkdownV2 first-chunk edit failed, falling back to plain text: %srz0[%s] Overflow split: first-chunk edit failed: %sTrFrrTFFrzreply message not foundr)rrz4[%s] Overflow continuation no-reply retry failed: %sz*[%s] Overflow continuation send failed: %sz6[%s] Overflow split: stopped at %d/%d chunks deliveredr c3BK|]}tjdd|VdS)z \(\d+/\d+\)$r Nr)r delivereds rrz7TelegramAdapter._edit_overflow_split..sE++!F+R;;++++++r)overflow_continuation_failed)partial_overflowdelivered_chunks total_chunkslast_message_iddelivered_prefixcontinuation_message_ids)rwrnr r@rr!rnz3[%s] Overflow split delivered %d chunks; last_id=%s)rwrnr!rj) rrr~rrrrr rrr`rrrrjrrrrr rsrrr0rrJr)rtuplerLrr)rrrnrrrFr first_chunkrrrrcontinuation_idsrprev_idrMrsent_msgrdre use_markdownrrretry_thread_kwargs _retry_errr new_idlast_ids rr z$TelegramAdapter._edit_overflow_splits.&& T,Y'   v;;!  YFQi + ? A'' 44 )55 :7 C C#&z??&#,#8 6 !   %S\\-?-?-A-AAAE Iw #i99$>w$G$G'*:!,[!9!9: i116w??":$2  ? ? ?!ffllnnG(( FIq4"%s1vv>>>>>>>>>  ?&')'=,,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 $ :(,H!EEEEEEEEE "$! NND 8 $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*AB32F3 E=BE FEAF H A&HHH:BL Q!AQ7A"O P )#P QP Q&#QQc K|jsdS |jt|t|d{VdS#t$r-}t d|j||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)rrnNTz-[%s] Failed to delete Telegram message %s: %s)rdelete_messagerrrrrrrrrnrs rr.zTelegramAdapter.delete_messagesy 5 )**27;;z??+       4    LL? :q   55555  srVrW)rrrj)rrLrFs rsupports_draft_streamingz(TelegramAdapter.supports_draft_streamingsCy  3G H H 5R&&((,===r)c 6K|jstddS||r/|||||d{VrtddSt |jdstddSt ||jkr|n'|||jt d }| |}d D]*}t|t||r| |n|d }|rtj|d <|||d< |jjdi|d{V} | rtddcStddcS#t $r} |r=|| r(t$d|j||| 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_connectedrNTrzr1api_unavailablerrr)rrrrr}draft_rejectedz[[%s] sendMessageDraft MarkdownV2 rejected, retrying as plain text (chat=%s draft_id=%s): %sz6[%s] sendMessageDraft failed (chat=%s draft_id=%s): %srj)rrsrrrrrrr~rrrrr`rr1rrrrrr) rrrrrFrrMr(rrrs 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 *# ?# ?L5g>>MM5AK++D111t&&F  ='0'<|$$.7*+ ?7497AA&AAAAAAAAE&dtDDDDDD!%7GHHHHHH ? ? ?  D$>$>q$A$ALLB 7Ha HHHH LIw!"%s1vv>>>>>>>>>>># ?&%/?@@@@s+1*E1E11 H;:H:AH:HHc$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. rr}NzP[%s] Thread %s not found for control message, retrying without message_thread_idrrj) rrr)r0rrrrrrrrr)rrr}rrs r"_send_message_with_thread_fallbackz2TelegramAdapter._send_message_with_thread_fallback*shy 0// /"JJ':;; //99&99999999 9   !-..x88.33H==.fI%22JJy))+< $F||   !4d;;;3TY3CClCCCCCCCCCCCCCC + s$A DB2D D D  Dr r session_keyc K|jstddS |rd|dnd}|d||}tt dd t d d gg}||} |d ||j} |jdt||tj || d| || || |j| d {V} tdt| jS#t $rI} t"d|j| 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: )r u ⚕ *Update needs your input:* u✓ Yeszupdate_prompt:y callback_datau✗ Nozupdate_prompt:nNrrrr reply_markuprr]Trzz"[%s] send_update_prompt failed: %srj)rrsrrUrTrrrr9rr`rrrrrnrrrr) rrrrr:rF default_hintrkeyboardrMrdrrs rsend_update_promptz"TelegramAdapter.send_update_promptQsy De?CCC C ;7>F33333BL&&'bF'bT`'b'bccD+(BSTTT(ARSSS-H 00::I<7J7JKKK K ; ; ; NN?A N N Ne3q66::: : : : : : : ;sD D&& E90>E4.E94E9dangerous commandcommand descriptionc tK|jstddS t|dkr |dddzn|}dtj|dtj|}||}d dl} t|d s| d |_ t|j } ttd d | tdd| gtdd| tdd| gg} t||tj| d|} |d||j} | | d<| ||||| |j|jdi| d{V}||j| <tdt/|jS#t2$rI}t4d|j|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. FrrN...u.⚠️ Command Approval Required 
z
Reason: r_approval_counterrvu✅ Allow Oncezea:once:r=u ✅ Sessionz ea:session:u ✅ Alwaysz ea:always:u❌ Denyzea:deny:rrrrAr?rr]Trzz"[%s] send_exec_approval failed: %srj)rrsr_htmlescaper itertoolsrcountrKnextrUrTrr`HTMLrrrr{rr9r1rrnrrrr)rrrFr:rGrF cmd_previewrrMrO approval_idrCrrdrrs rsend_exec_approvalz"TelegramAdapter.send_exec_approval|sy De?CCC C9 ;47LL44G4G'%4%.500WK7 [1177 < 4477 00::I    4!455 <)2););&t566K+()9IaT_IaIabbb(FaT_FaFabbb )E_R]E_E_```(C[kC[C[\\\ -  H6g>>'n ( && ++-- &F<7J7JKKK K ; ; ; NN?A N N Ne3q66::: : : : : : : ;sGG$$ H7.>H2,H72H7r{ confirm_idc K|jstddS |t|dkr|n |dddz}t t dd| t d d | gt d d | gg}||} t||tj |d| } | d||j } | | d<| ||| || |j |jdi| d{V} ||j|<tdt#| jS#t&$rI} t(d|j| tdt#| cYd} ~ Sd} ~ wwxYw)z8Render a three-button slash-command confirmation prompt.FrrrINrJu✅ Approve Oncezsc:once:r=u🔒 Always Approvez sc:always:u ❌ Cancelz sc:cancel:rLr?rr]Trzz"[%s] send_slash_confirm failed: %srj)rrsrrrUrTrrr`rrrrr{rr9r2rrnrrrr)rrr{r?r:rVrFpreviewrCrMrrdrrs rsend_slash_confirmz"TelegramAdapter.send_slash_confirmsC y De?CCC C& ;))S\\T5I5I''wW\X\W\~`eOeffG+();KbV`KbKbccc()>Ng[eNgNghhh )E^R\E^E^___ -H00::I5g>>'3 ( && ++-- &F<7J7JKKK K ; ; ; NN?A N N Ne3q66::: : : : : : : ;sEE66 G >G>G G questionchoices clarify_idc JK|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.$rI}t0d|j|tdt|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❓ rc3nK|]0\}}|dzdtjt|V1dS)rvz. N)rMrNr)rrcs rrz/TelegramAdapter.send_clarify..s\))11u66 SVV 4 466))))))r) rrrrvcl:rr=u✏️ Other (type answer)z:otherrANrrTrzz[%s] send_clarify failed: %srj)rrsrMrNrrrrr`rRrrrrrTrrUrr{rr9r3rnrrrr)rrrZr[r\r:rFrrM option_linesrrowsidxrdrrs r send_clarifyzTelegramAdapter.send_clarifys(y De?CCC C9 ;2%,x0022D00::I . $yy)) )' 2 2)))   -|---6g>>'n&&++-- &F D W..CKK,aLL*B *B*BS*B*B!  (4&>J&>&>&> *>d)C)C~&<7J7JKKK K ; ; ; NN949a H H He3q66::: : : : : : : ;sF2G H">HH"H" providers current_modelcurrent_providerc ^K|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&$rI}t(d|j|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|Sr$rjslugs rrmz4TelegramAdapter.send_model_picker..get_label[ r)+⚙ *Model Configuration* Current model: `unknown ` Provider:  Select a provider:rMNr?r@r])msg_idrhr:on_model_selectedrirj provider_pageTrzz![%s] send_model_picker failed: %srj)rrshermes_cli.providersrmr_build_provider_keyboardrr)rrr9rr`rrrrnr0rrrrr)rrrhrirjr:rwrFrmrCprovider_page_infoprovider_labelrrMrdrrs rsend_model_pickerz!TelegramAdapter.send_model_pickerFswy De?CCC C  6 6 6 6 6 6 6         . ;+/+H+HTU+V+V (H(&Y'788N&&>'4'A >>!/>>*<>>D6>G [1114I<7J7JKKK K ; ; ; NN> 1 M M Me3q66::: : : : : : : ;s*# 33D!E F,#>F'!F,'F,rryrpagec  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} t|} td| | zdz | z} tdt|| dz }|| z}t|| z| }|||fdtdtdD}| dkrg}|dkr*|t dd|dz |t |dzd| d|| dz kr*|t dd|dz|||t ddg| dkrd|dzd |d!| dnd"}t||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|Sror)rps rrlz.s$777155==!777r)c |dt|dg}|dd|d}|drd|}t|d|d  S) N total_modelsmodelsr (r< is_current✓ mp:rpr=)r)rrT)rrPlabels r_provider_buttonzBTelegramAdapter._build_provider_keyboard.._provider_buttonsEE.#aeeHb.A.A*B*BCCEy,,E,,,Euu\"" '&u'=N1V9=N=NOOO Or)c8g|]}|dSrorrs rrEz.s"'I'I'I!f 'I'I'Ir)kindrc(g|]}|v|Srjrjrrby_slugs rrEz.s"RRRaQ'\\wqz\\\r)membersc 3K|];}|dt|dgV.sW  LMnc!%%"2E2E.F.FGG      r)ru ▸ (r<c3@K|]}|dVdS)rNrrs rrz;TelegramAdapter._build_provider_keyboard..s.@@1155..@@@@@@r)rmpg:group_idr=rprvc*g|]}||dzSrrj)rr page_buttonss rrEz.s&PPPA QQY'PPPr)r◀ Prevmpv:/mx:noopNext ▶ ✗ Cancelmxr– of r )hermes_cli.modelsrrrrrrTr)_PROVIDER_PAGE_SIZErr6rrrU)rrhr~rrbuttonsrowrrPrr page_sizetotal total_pagesr8rrenav page_inforrs @@rrzz(TelegramAdapter._build_provider_keyboards # 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, G !ei/!3 ABB 1c$ a0011y %)#U++uSy) PPPPq#l:K:KQ1O1OPPP ??Caxx / J[QUXYQYJ[J[\\\]]] JJ+tax,G,G+,G,GW`aaa b b bkAo%% / J[QUXYQYJ[J[\\\]]] KK    ),dKKKLMMM.s&FFFqAE "FFFr)rrmg:rr◀ Backmbrrrrrr<r ) _MODEL_PAGE_SIZErr6rrrkrrTrrU)rrr~rrrr8r page_modelsrmodel_idabs_idxshortrerrrs @r_build_model_keyboardz%TelegramAdapter._build_model_keyboards) F !ei/!3 ABB 1c$ a0011y %)#U++U3Y' $[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    =H!OO888s888888QS #D))944r)datac 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.rNrrlc|Sr$rjros rrmz@TelegramAdapter._handle_model_picker_callback..get_label rqr)rrlc34K|]}|dk|VdSrpNrjrr provider_slugs rrz@TelegramAdapter._handle_model_picker_callback..1MMq!F)}2L2L2L2L2L2LMMr)rhzProvider not found.rselected_providerrselected_provider_name model_list model_pagerz _u2 more available — type `/model ` directly_r u&⚙ *Model Configuration* Provider: *rgz Select a model:rrrArz Invalid page.c34K|]}|dk|VdSrrjrs rrz@TelegramAdapter._handle_model_picker_callback..Err)rrxrjrrrirsrtrumc:zInvalid selection.zInvalid model index.rwzPicker expired.FzModel picker switch failed: %szError switching model: TzSwitch failed.zModel switched!r)expensive_model_warning)providerz Switch anywayr=rrrru⚠ *Expensive Model Warning* zConfirm expensive modelr)PROVIDER_GROUPSc i|] }|d| Srorjrs rrlzATelegramAdapter._handle_model_picker_callback..s@@@qy!@@@r)c(g|]}|v|Srjrjrs rrEzATelegramAdapter._handle_model_picker_callback..s"HHHa1<.s&JJJ1GAAI&JJJr)ru-⚙ *Model Configuration* Provider family: *z* Select a provider:zModel selection cancelled.rrA) r0r)answerryrmr startswithrQrrr rr`rrrrzrrr rhermes_cli.model_cost_guardrr to_threadrUrTr?rrrr)'rqueryrrstatermrrrCrpnamershownr(r~r{r|rfrrcallback switch_failed result_textrNrrrr_label_desc member_slugsrrrPrrerrrs' @@@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.rNr^r uM ⚠️ This question expired or the session reset — please /retry.r) rrr rMrNr?rr`rR)rrrs r_notify_clarify_expiredz'TelegramAdapter._notify_clarify_expiredPs ,,$S,TT T T T T T T T T    D  ))b5< (:(@bAAbbb%>! *             DD s! ..A A>> B  B r{rQrContextTypes.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 r#| ||||| | d{VdS|d rd| d d } t| dkr8| d} t| d }n4#ttf$r |dd{VYdSwxYwt t|jdd}||||t |nd| t | nd| s|dd{VdS|j|d}|s|dd{VdSddddd}t|jdd}|| d}||d{V |||d|t,jdd{Vn#t0$rYnwxYw d d!lm}||| }t6d"||| |n4#t0$r'}t6d#|d }Yd}~nd}~wwxYw|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,jdd{Vn#t0$rYnwxYw d d*l m!}|"||| d{V}|rE|jr=t|jdd}t|jdd}t|dd}t|jd+d}t|jj||t,jd,|#}t|d-|}t |$d.t tJj&$t ttJj&d-tJj&$hv} || r}|{t|}!|!|d/<|'|(t |jjt |t |d0d1|!|j)2nf|d|'|(t |jjt |d3t |i|j)4|j*dZi|d{Vn:#t0$r-}t6d5|j+|d06Yd}~nd}~wwxYwdS|d7r9| d d } t| dkr | d}"| d }#t t|jdd}||||t |nd| t | nd| s|d%d{VdS|j,|"}|s|d&d{VdSt|jdd}|#d8krd9}$ d d:l-m.}%|%|"}$n8#t0$r+}t6/d;|j+|Yd}~nd}~wwxYw|$s9|j,|"d|0||d{VdS|d<d{V |d=|jj1pdd>tej3|d?t,j4dd{Vn#t0$rYnwxYwdS t|#}&n4#ttjf$r |d@d{VYdSwxYwd}' d dAl-m6}(|(|"})|)r6|)j7r/d |&cxkrt|)j7krnn |)j7|&}'n#t0$rd}'YnwxYw|'dB|&dz}'|j,|"d d dCl-m8}*|*|"|'}+n:#t0$r-}t6dD|j+|d9}+Yd}~nd}~wwxYw|+r|dE|'ddFd{V |d=tej3|jj1pddGtej3|dHtej3|'t,j4dd{Vn#t0$rYnwxYwt6dI|"|'|n7|0||d{Vt6/dJ|"dS|dKsdS| d dd},t t|jdd}||||t |nd| t | nd| s|dLd{VdS|dM|,dNd{V|,dOkrdPndQ} ||dR|dSt,jdd{Vn#t0$rYnwxYw d dTl9m:}-|-}.|.dUz }/|/;dV}0|0<|,|0=|/t6dW|,t|jddXdS#t0$r&}t6dY|Yd}~dSd}~wwxYw)[z%Handle inline keyboard button clicks.Nr?rrvr|r} first_name)rrrrrrrrzgt:) query_chat_idquery_chat_typequery_thread_idquery_user_namezea:rrrlrvzInvalid approval data.rrwr rKu/⛔ You are not authorized to approve commands.z(This approval has already been resolved.u✅ Approved onceu✅ Approved for sessionu✅ Approved permanentlyu ❌ Denied)oncesessionalwaysdenyUserResolved by rr)resolve_gateway_approvalzKTelegram button resolved %d approval(s) for session %s (choice=%s, user=%s)z;Failed to resolve gateway approval from Telegram button: %szsc:u1⛔ You are not authorized to answer this prompt.z&This prompt has already been resolved.u🔒 Always approveu ❌ Cancelled)rrr;) slash_confirmrnrbrrWrT)rMrr]rMr?z&[%s] slash-confirm callback failed: %srrcotherF)mark_awaiting_textz"[%s] mark_awaiting_text failed: %su$✏️ Type your answer in the chat.r^z" Awaiting typed response from u…zInvalid choice.)_entrieszchoice )resolve_gateway_clarifyz'[%s] resolve_gateway_clarify failed: %srrz z: zcallback_queryrrLrurr?rrr_handle_gmail_triage_callbackrkrrr IndexErrorrrsr1rr)r rr`rrtools.approvalrrrr resume_typing_for_chatr2toolsrresolverrjraPRIVATEr{rrr9rr3tools.clarify_gatewayrrrrrMrNrRrrr[rr!r with_suffix write_textreplace)1rr{rrr query_messager query_chatrrrrpartschoicerT caller_idr: label_maprrrrPrNrV_slash_confirm_modrrMrvrLprompt_message_idrchat_type_valueis_private_chatrdr\ choice_tokenflippedrrf resolved_text_clarify_entriesrrresolvedrrhome response_pathtmps1 rrz&TelegramAdapter._handle_callback_queryis% EJ  Fzy$77  y$?? ]FD99 !*fd;;!-1DdKK!%/<FF ??S T T 49MKc%-/000tG O88gNNNNNNNNN F ??5 ! ! 44+ / / / 5        F ??5 ! !D JJsA&&E5zzQq"%eAh--KK"J/,,,D,EEEEEEEEEFF  r B BCC 88)6E6Qc/222W[6E6Qc/222W[- 9 ,,,],^^^^^^^^^F"266{DII ",,,V,WWWWWWWWWF098(  'u fMM ! fj99lll.........11!00E1M1M|1M1MNN#,#8%)2 !D GGGGGG44[&IIEKKe{FL!LL!^`cdddEEEEEED]6//M0B0BCCC F ??5 ! !a JJsA&&E5zzQq"1X r B BCC 88)6E6Qc/222W[6E6Qc/222W[- 9 ,,,_,`````````F"7;;JMM ",,,T,UUUUUUUUUF03- 'u fMM ! fj99lll.........11!00E1M1M|1M1MNN#,#8%)2 !D3jIIIIII(:(B(B#Z))######K#,Uu},U%,EM;NPT$U$U &u}fdCC$+D&$$?$? ,3EM*>*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 NN6 " " " KK & & & KKIy I I K K K K K S S S LLLc R R R R R R R R R Ss E66-F'&F'2AK33 L?L0L55 M&?M!!M&(AT)) T65T6:I+^&& _0#__ d e%!e  e+A g99 hh h-i  i Aj'' j65j6k22 l)<#l$$l)A3o oo ?u uuBw## x-xxz 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).rrrlzInvalid gmail-triage data.rNrvrwr rKu0⛔ You are not authorized to act on this email.zUnknown verb: z.hermesscriptsz gmail-triageu❌ z missingz$[%s] gmail-triage script missing: %sF)stdoutstderrrrrTz-[%s] gmail-triage callback ok: verb=%s arg=%srr)errorsr"zexit 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=%srrru — rr)rkrrrrLrurs_GT_VERB_DISPATCHr)_Pathrr"rr rrcreate_subprocess_exec subprocessPIPEr communicate returncoderdecoderbr8r>rr?rr )rrrrrrrr verbargr r script_name extra_args success_label is_state_verb script_pathcmdrwproc _stdout_bytes stderr_bytesr stderr_text last_linerNr 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*rrcH|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)rrrr s r_missing_media_path_errorz)TelegramAdapter._missing_media_path_errorBsB 11411 ??C D D  = E  r) file_size max_bytesctd|dz} t|pddz }|dd}n#ttf$rd}YnwxYwd|d|d |d S) Nrvrz.1fz MBz unknown sizez [Telegram z skipped: file size z exceeds the z0 MB limit. Ask the user to send a smaller file.])r6rrr)rrrBrClimit_mbsize_mb size_texts r_telegram_media_too_large_notez.TelegramAdapter._telegram_media_too_large_noteQsq) 455 ').q))[9G"++++II:& ' ' '&III ' J J JI J J J J J s0AArpctt|ddpd}t|dd} t|pd}n#ttf$rd}YnwxYw|dkrdS||krdSd||||fS)z.opus.oggr?r]Nr)rvoicerNrrTc.dSNrseek audio_filesrr}z,TelegramAdapter.send_voice..JOOA,>,>r)r>.m4a.mp3)raudiorNrr_c.dSrVrWrYsrr}z,TelegramAdapter.send_voice..r[r))r file_pathrNrrFTrzzJ[%s] Failed to send Telegram voice/audio, falling back to base adapter: %srr)rrsrrr"rAr$splitextrjrrrrr send_voicerrJ send_audio send_documentrrnrrr rr)rrrMrNrrFrext _voice_threadrdvoice_thread_kwargsr _audio_threadaudio_thread_kwargsrrZr8s @rrczTelegramAdapter.send_voiceksHy De?CCC CL g7>>*-- l!%t7U7UV]_i7j7jkkkkj$''? :g&&z2215;;==+++$($<$  2  #77AA !#$>$>$>$>!L!!CC,,,$($<$  2  #77AA !#$>$>$>$>!L!!CC$"&!3!3 '", '!)!) "4""s? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? @ds3>7J7JKKK K g g g LL\      ++GZ(]e+ffffffff f f f f f f gsPAJ"J2G I; J JIJI%J K% AK K% K%r.images 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?|||d|| |||d|d{Vnw#t$rj}td|j| dzt!| |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://)rl)unquoterc*g|]}||zSrjrj)rrCHUNKphotoss rrEz8TelegramAdapter.send_multiple_images..s&LLL!&1u9%LLLr)rz.[%s] Skipping missing image in media group: %srQ)mediarNz5[%s] Sending media group of %d photo(s) (chunk %d/%d)rvr?r]r c^D](} |d#t$rY%wxYwdSrV)rXr)fh opened_filess r_reset_opened_fileszATelegramAdapter.send_multiple_images.._reset_opened_files'sR*!!!GGAJJJJ(!!! D!!!s  **)rrtrz media groupr\zI[%s] send_media_group failed (chunk %d/%d), falling back to per-image: %sTrr0)!rrrnrrrrrsend_multiple_imagesr_is_animation_urlrrrorrrrrrrrr"r$closerrrrrsend_media_grouprrJ)rrrkrFrlrnrN animations image_urlalt_text_unquote_threadr chunk_idxrrtrN local_pathrvrdrerxrrqrwrrr8s @@@rryz$TelegramAdapter.send_multiple_imagessF$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 1K K  IuQ9q==mK000000000!E&(LE +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&kk1! gg22UH+3 'B $,B $OK K s A<A A77A<C'N J J,+J,1CNP* O;A O61P*6O;;P*P P%$P%*Q0QQ Q QQ Q image_pathc K|jstddS tj|s%td|d|S||}||||j}| |||||j} t|d5| |jj t||r |dd nd|d | ||||d fd  d{V} dddn #1swxYwYtdt| jS#t"$r} t| } d| vpd| v} | r"t$d|j|n#t$d|j| d ||||tj|||d{VcYd} ~ S#t"$r^}t$d|j|dt3|||||d{VcYd}~cYd} ~ Sd}~wwxYwd} ~ wwxYw)z5Send a local image file natively as a Telegram photo.FrrImager?r]rQNrrphotorNrrc.dSrVrW) image_filesrr}z1TelegramAdapter.send_image_file..us (:(:r)r\TrzPhoto_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)rrarN file_namerrFzV[%s] Failed to send Telegram local image as document, falling back to base adapter: %sr)rrsrrr"rArrrrr$r send_photorrJrrnrrrrrrebasenamer rsend_image_file)rrrrNrrFrrrdrerr error_str is_dim_errordoc_errrr8s @rrzTelegramAdapter.send_image_fileMsy De?CCC CN p7>>*-- l!%t7U7UV]_i7j7jkkkk..x88G<>$/:  (  33H==  : : : :H                ds3>7J7JKKK K0 p0 p0 pAI+i7;-:   .I 3I!  p!//#(# g..z::%% 0 p p p 7I! #WW44Wj'S[fn4ooooooooooooooooooo pQ0 ps|AE!"A!E!A$D3' E!3D77E!:D7;%E!! I>,AI9 =HI> I6AI1&I6'I9+I>1I66I99I>rarc K|jstddS tj|s%td|d|S|ptj|}||} ||||j } | || || |j } t|d5| |jj t|||r |dd nd| d | |||| d fd  d{V} dddn #1swxYwYtdt!| jS#t$$re} t&d|jt-| t/ ||||||d{VcYd} ~ Sd} ~ wwxYw)z.q r)r\Trzz [%s] Failed to send document: %sr)rrsrrr"rArrrrrr$rrerrJrrnrrrrrr)rrrarNrrrFr display_namerrdrerrr)r8s @rrezTelegramAdapter.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 FEFE%F G2 AG-'G2-G2 video_pathc  K|jstddS tj|s%td|d|S||}||||j}| |||||j} t|d5 | |jj t| |r |dd nd|d | ||||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.FrrVideor?r]rQNr)rvideorNrrc.dSrVrWrsrr}z,TelegramAdapter.send_video..rr)r\Trzz[%s] Failed to send video: %sr)rrsrrr"rArrrrr$r send_videorrJrrnrrrrrr)rrrrNrrFrrrdrerrr)r8s @rrzTelegramAdapter.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$D3' E!3D77E!:D7;%E!! G+AG G Gr~c K|jstddSddlm}||sLtd|jt|||||d{VS | |}| |||j }| |||||j } | |jjt|||r |dd nd|d | ||||d d{V} tdt#| jS#t&$r} td|j| d ddl} | d4d{V} | |d{V}||j}dddd{Vn#1d{VswxYwY| |||||j }| |jjt|||r |dd nd|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)rNr?r]rrz URL photoTrzz8[%s] URL-based send_photo failed, trying file upload: %srr{rzuploaded photoz+[%s] File upload send_photo also failed: %s)rrstools.url_safetyrrrrr send_imagerrrrrrrrJrrnrr AsyncClientr)raise_for_statusrr )rrr~rNrrFr _photo_threadrdphoto_thread_kwargsrrrclientresp image_dataupload_thread_kwargse2r8s rrzTelegramAdapter.send_imagesy De?CCC C000000{9%% f NNLdi X X X++GY\d+eeeeeeee eG j 44X>>M<">$/"1 #?## CC $9'BB&18Bwuu~~d+6  *  //99         Cds3>7J7JKKK K- j- j- j NNJ     % j  ,,T,::.......f!'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 jK- jsu:CE L #L; J7G$J$ G. .J1G. 2B"JL  L$AK=2L3L7L =LLL  animation_urlcK|jstddS ||}||||j}||||||j}||jjt|||r |ddnd|d|| |||d d{V} td t| j  S#t$rM} td |j| d ||||||d{VcYd} ~ Sd} ~ wwxYw)zJSend an animated GIF natively as a Telegram animation (auto-plays inline).Frrr?r]Nr)r animationrNrrTrzzA[%s] Failed to send Telegram animation, falling back to photo: %srr)rrsrrrrrsend_animationrrJrrnrrr rr) rrrrNrrF _anim_threadrdanimation_thread_kwargsrrs rrzTelegramAdapter.send_animationpsy De?CCC C! g33H==L<7J7JKKK K g g g LLS     -(]effffffff f f f f f f gsCC.. E8AE:EEc.K|jr d}d} ||}t|o|d}||}|jt |d|d{VdS#t$rx}|rH|F |jt |dd{VYd}~dS#t$rYnwxYwt d|j |d Yd}~dSd}~wwxYwdS) zSend typing indicator.FNrtyping)ractionr})rrz1[%s] Failed to send Telegram typing indicator: %sTr) rrr'r)rsend_chat_actionrrrrr)rrrF _is_dm_topicr}_typing_threadrs rrzTelegramAdapter.send_typings 9 !&L/3  !%!9!9(!C!C#H$a>`1a1abb $($F$F~$V$V!i006w??#&71     $5$A"i88$>w$G$G#+9$ GI!    s6A>B DD /C C!D  C!!&D  Dc@K|jsdddS |jt|d{V}d}|jtjkrd}n8|jtjkr d}|jrd}n|jtjkrd}|j p|j pt|||j t|dd d S#t$rN}td |j||d t|dt|dcYd}~Sd}~wwxYw)z&Get information about a Telegram chat.UnknownrV)rr|NrrYchannelrF)rr|rxrz0[%s] Failed to get Telegram chat info for %s: %sTr)rr|r )rget_chatrr|raGROUP SUPERGROUPrCHANNELr{ryrrxrLrrr r)rrrvrLrs r get_chat_infozTelegramAdapter.get_chat_infosfy 5%t44 4 I++,Fw,O,OPPPPPPPPDIyHN**# h111# =( 'Ih...%  DdnDG ! M#D*e<<    I I I LLB      LL$QHH H H H H H H IsB4C DADDDc@ |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.zPHrrvrj)rrcounter placeholderss r_phz+TelegramAdapter.format_message.._phs;+71:+++C AJJJ!OJJJ %L Jr)c,|d}d|ddvr|ddznd}|d|}||d}|dd}|dddd }||zd zS) Nrrrlrv\\\`z\`z```)rindexr)rropen_endopeningbody_and_closebodyrs r_protect_fencedz7TelegramAdapter.format_message.._protect_fenceds''!**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..s+cc!''!**,,T6::;;r)ct|d}|ddddd}d|d|dS) Nrvrrrr<z\)[]()rrr)rdisplayurlrs r _convert_linkz5TelegramAdapter.format_message.._convert_linksm"1771::..G''!**$$T622::3FFC3,7,,c,,,-- -r)z-\[([^\]]+)\]\(([^()]*(?:\([^()]*\)[^()]*)*)\)c|d}tjdd|}dt |dS)Nrv \*\*(.+?)\*\*rrg)rrbrrr)rinnerrs r_convert_headerz7TelegramAdapter.format_message.._convert_header$sVGGAJJ$$&&EF+UE::E31<..11122 2r)z^#{1,6}\s+(.+)$)flagsrcbdt|ddS)Nrgrvrrrs rr}z0TelegramAdapter.format_message..1/cc9l1771::66999::r)z \*([^*\n]+)\*cbdt|ddS)NrArvrrs rr}z0TelegramAdapter.format_message..:rr)z ~~(.+?)~~cbdt|ddS)N~rvrrs rr}z0TelegramAdapter.format_message..Arr)z \|\|(.+?)\|\|cbdt|ddS)N||rvrrs rr}z0TelegramAdapter.format_message..Hs/cc;|AGGAJJ77;;;<<r)c 2|d}|d}|dr;|dr&|dt|dddS|dt|S)Nrvrz**r )rrrr)rprefixrrs r_convert_blockquotez;TelegramAdapter.format_message.._convert_blockquoteOsWWQZZFggajjG  && G7+;+;D+A+A GsfEE|GCRCL'A'AEEEFFF3&::<#8#8::;; ;r)z^((?:\*\*)?>{1,3}) (.+)$z(```[\s\S]*?```|`[^`]+`)rrvc|}|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) Nrrvr(]r<z](httprir")r8rrr6)r_segrWchbeforedepthjs r _esc_barez1TelegramAdapter.format_message.._esc_barers1 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 MULTILINErreversedrrrrkrrr)rrrrrrrr _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>rrr^r_TELEGRAM_REQUIRE_MENTIONr rr(r)rrrjr'rrrs 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>rrr^r_+TELEGRAM_OBSERVE_UNMENTIONED_GROUP_MESSAGESrrrs r,_telegram_observe_unmentioned_group_messageszrrr^r_TELEGRAM_GUEST_MODErrrs 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>rrr^r_TELEGRAM_EXCLUSIVE_BOT_MENTIONSr_rrs r _telegram_exclusive_bot_mentionsz0TelegramAdapter._telegram_exclusive_bot_mentionss[&**+CDD  !*c** H!''))-GGG ## #y:FCCIIKKOiiir)c|jjd}|tjdd}t |t r d|DSdt|dDS)Nfree_response_chatsTELEGRAM_FREE_RESPONSE_CHATSr ch|]D}t|#t|ESrjrrparts rrz@TelegramAdapter._telegram_free_response_chats..=KKK$T9J9JKCIIOO%%KKKr)c^h|]*}||+Srjrars rrz@TelegramAdapter._telegram_free_response_chats..-MMM M MMMr)rf rr(r)rrrrrrkrrs r_telegram_free_response_chatsz-TelegramAdapter._telegram_free_response_chatssk##$9:: ;):B??C c4  LKK#KKK KMMS)<)<MMMMr)c|jjd}|tjdd}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_CHATSr ch|]D}t|#t|ESrjrrs rrz:TelegramAdapter._telegram_allowed_chats..rr)c^h|]*}||+Srjrars rrz:TelegramAdapter._telegram_allowed_chats..rr)rfrrs r_telegram_allowed_chatsz'TelegramAdapter._telegram_allowed_chatssk##O44 ;)4b99C c4  LKK#KKK KMMS)<)<MMMMr)c|jjd}|tjdd}t |t r d|DSdt|dDS)z0Return Telegram chats authorized at group scope.group_allowed_chatsNrr ch|]D}t|#t|ESrjrrs rrz@TelegramAdapter._telegram_group_allowed_chats..rr)c^h|]*}||+Srjrars rrz@TelegramAdapter._telegram_group_allowed_chats..rr)rfrrs r_telegram_group_allowed_chatsz-TelegramAdapter._telegram_group_allowed_chatssk##$9:: ;):B??C 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. )r%r$r )r group_allowedresponse_alloweds r_telegram_observe_allowed_chatsz/TelegramAdapter._telegram_observe_allowed_chatssR::<<  55L7799  4 #33 3r)c|jjd}|tjdd}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_TOPICSr ch|]D}t|#t|ESrjrrs rrz;TelegramAdapter._telegram_allowed_topics..rr)c^h|]*}||+Srjrars rrz;TelegramAdapter._telegram_allowed_topics..rr)rfrrs r_telegram_allowed_topicsz(TelegramAdapter._telegram_allowed_topicssk##$455 ;)5r::C c4  LKK#KKK KMMS)<)<MMMMr)c |jjd}|tjdd}t |t r|}n"t|d}t}|D]}t| }|s& | t|J#ttf$r$td|j|Y~wxYw|S)Nignored_threadsTELEGRAM_IGNORED_THREADSr rfz,[%s] Ignoring invalid Telegram thread id: %r)rr(r)rrrrrrkr$rbrrrrrrr)rrrignoredrrs r_telegram_ignored_threadsz)TelegramAdapter._telegram_ignored_threadssk##$566 ;)6;;C c4  )FFXX^^C((FEE a aEu::##%%D  a CII&&&&z* a a aMtyZ_````` as("C  2D?Dc|jjd}|tjdd}|rg t j|}nO#t$rBd| D}|sd| dD}YnwxYw|}|gSt|tr|g}t|ts5td|jt#|jgSg}|D]}t|tr|s, |t)j|t(j`#t(j$r,}td |j||Yd}~d}~wwxYw|r.td |jt3||S) z=Compile optional regex wake-word patterns for group triggers.mention_patternsNTELEGRAM_MENTION_PATTERNSr c^g|]*}||+Srjrars rrEz=TelegramAdapter._compile_mention_patterns..s-XXXt4::<<XdjjllXXXr)c^g|]*}||+Srjrars rrEz=TelegramAdapter._compile_mention_patterns..s-!Z!Z!Z4TZZ\\!Z$**,,!Z!Z!Zr)rfz?[%s] telegram mention_patterns must be a list or string; got %sz,[%s] Invalid Telegram mention pattern %r: %sz*[%s] Loaded %d Telegram mention pattern(s))rr(r)rrrbjsonloadsrr8rkrrrrrrr|rfrrcompiler}r rr)rpatternsrloadedcompiledpatternrNs rrz)TelegramAdapter._compile_mention_patternss;$(();<<  )7<<BBDDC "[!Z__FF [[[XXs~~7G7GXXXF![!Z!Z399S>>!Z!Z!Z["  I h $ $ " zH(D))  NNQ X'    I%' h hGgs++ 7==??  h 7BM B BCCCC8 h h hMtyZacfgggggggg h  ` KKDdiQTU]Q^Q^ _ _ _s+ A!!A B-,B- 2E<<F7 "F22F7ct|dd}|sdStt|dddd}|dvS)NrvFr|r .r">rrX)rLrrkrj)rr?rvrLs r_is_group_chatzTelegramAdapter._is_group_chat7sdw-- 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. rvNr|r rBr"r}r~F)rrXrTrW)rLrrkrjr'r)rr?rvrLrr~rs r_effective_message_thread_idz,TelegramAdapter._effective_message_thread_id>s w--MQYCfb112288==bAGGIIIWY g2D991CU K KLL"&==j'$PZ\aBbBbfjBj ? )/F"F"FK["F3xxI%%*:%3xx4  0/ /tr)c|jrt|ddsdSt|jdd}t|o(t|ddt|jddkS)Nreply_to_messageFrurw)rrLrGr')rr? reply_users r_is_reply_to_botz TelegramAdapter._is_reply_to_botYsmy 1CT J J 5W5{DII Jd7:tT#B#BgdiY]_cFdFd#deeer)c ht}fd}|D]\}}|D]}tt|dddd}|dvrQt t|dd}t t|dd }|d ks|d kr||||z} |d kr^| d } tj d | tj r| | | d } | d kr:| | d zd} tj d | tj r| | |D]\\} }| r|r tj d| D]<}| |d =]|S)a{Extract explicit Telegram bot usernames mentioned in text/captions. Telegram bot usernames are 5-32 characters and must end in "bot". 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. c3KtddpdtddpgfVtddpdtddpgfVdSNrr entitiesrNcaption_entitiesrLr?sr _iter_sourceszETelegramAdapter._extract_bot_mention_usernames.._iter_sourcesjx'64006BUY8Z8Z8`^`` ` ` `'9d339r77L^`d;e;e;kikk k k k k kr)r|r rBr">mention bot_commandoffsetlengthrrS@[a-z0-9_]{2,29}botrvNz1(?i)(?>DDSII"MSSUU &@@@WVXr::;;WVXq99::A::1)&&*@AGGII )++(//44::<._iter_sourcesrRr)r|rBr"rSrUrVrT text_mentionrrTrX) rrLrYrjrrkrrbr[rrZr}re)rr? bot_usernamebot_idexpectedrQr]rMr^r_rUrVr command_textrbs ` r_message_mentions_botz%TelegramAdapter._message_mentions_botsy 5 :t<<BJJ3OOUUWW D$//)5?%|%%%4 l l l l l&3]__! $! $ !K" $ $!'&&""="=>>DDSII"MSSUU )+++ 2!>!>??F 1!=!=>>FzzVq[[ "6&6/#9:@@BBHHJJhVV#tttW N22"66488D$dD 9 9V C C#ttt M11h1!2!>!>??F 1!=!=>>FzzVq[[ #.vfvo/E#FL+0055H!|| #HII.4466<<>>(JJ#tttA $B  PBL)> bm\\ P4#F#Fw#O#OO Our)c|jsdSt|jddpdd}|sdS||}t |o||vS)aReturn 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. The raw-text fallback is intentionally limited to usernames ending in "bot", which Telegram requires for bot accounts. FrxNr rW)rrLrYrjrer')rr?rir\s r#_explicit_bot_mentions_exclude_selfz3TelegramAdapter._explicit_bot_mentions_exclude_selfsy 5 :t<<BJJ3OOUUWW  5"&"E"Eg"N"N+,,\E\1\\r)c|jsdSt|ddt|ddfD](}|s|jD]}||rdS)dS)NFrrNT)rrLr')rr?rr@s r!_message_matches_mention_patternsz1TelegramAdapter._message_matches_mention_patternss% 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. )r rm)rr?s r_is_guest_mentionz!TelegramAdapter._is_guest_mentions) ((**Rt/I/I'/R/RRr)rc|r|jrt|jdds|Stj|jj}tjd|dd|}|p|S)Nrxz(?i)@z \b[,:\-]*\s*r )rrLrrNrxrrb)rrrxrs r_clean_bot_trigger_textz'TelegramAdapter._clean_bot_trigger_textsv 49 GDIz4,P,P K9TY/00&8(888"dCCIIKK$r)c h||rdS|sdS||sdSt|dd}|}|r|t |n|j}||vrdS|? t||vrdSn#ttf$rYdSwxYwt tt|dddd}| r| |rdS| }|r||vrdS||vrdS|sdS||rdS||rdS||rdSdS)zEReturn True when a group message should be stored but not dispatched.Fr}Nrvrwr T)_is_own_messagerrCrLr/rrrr4rrrror)rrrIrmrq)rr?rMr+r chat_id_strrs r)_should_observe_unmentioned_group_messagez9TelegramAdapter._should_observe_unmentioned_group_messages     ( ( 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--// 5   ) ) 5  % %g . . 5  1 1' : : 5ts #B33CCc2tj|dddS)zFReturn a chat/topic-scoped source for observed Telegram group context.N)rOrN user_id_alt) dataclassesr)rrps r%_telegram_group_observe_shared_sourcez5TelegramAdapter._telegram_group_observe_shared_source2s"644UYZZZZr)eventc^|jjpd}|jjp|}d|d|d|jpdS)Nrsr|z] r )rprOrNr)rr~rOsenders r'_telegram_group_observe_attributed_textz7TelegramAdapter._telegram_group_observe_attributed_text6sE,&3)'27:6::G:: (8b:::r)ctt|ddddpd}tt|ddddpd}d|d|dS)NrrxrsrwzIYou 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.rO)rrxrjs r&_telegram_group_observe_channel_promptz6TelegramAdapter._telegram_group_observe_channel_prompt;su7466 DIIVYvt44dDAANY R(. R RPX R R R r)c H|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_messageNrvrwr ra)rpchannel_prompt)rrpr)rrLrCrr)r}rprr message_typerqrr|rr)rr~rrxr shared_sourceobserve_promptrs r)_apply_telegram_group_observe_attributionz9TelegramAdapter._apply_telegram_group_observe_attributionGsO@@BB Le]D99  $"5"5k"B"B L''+vt"D"DdBOOPP 6688 +W44LBB5<PP DDFFJOJ^rE0FFnFFFdr  !4 4 4&$-  " ==eDD )     r)rc|jr tjS|jr tjS|jr tjS|jr tjS|j r tj Stj S)z5Classify a Telegram media message into a MessageType.) stickerrqSTICKERrrrrr_rrTrDOCUMENT)rrs r_media_message_typez#TelegramAdapter._media_message_typebsj ; '& & 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 }|| ||| }n5#t"$r(}td|dYd}~dSd}~wwxYw|"||jd|_dS|jg|_|jg|_|jdkrt.j|_n|jdkrt.j|_||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_bytesNr/rrBrEzB[Observed Telegram attachment too large or unverifiable. Maximum: z MB.]z6[Telegram] Observed group attachment skipped (size=%s)rar r mime_type default_kindz3[Telegram] Failed to cache observed group media: %sTrz=[Observed Telegram attachment could not be read, not cached.]imagerz)[Telegram] Cached observed group %s at %s)gateway.platforms.baser_observed_media_sourcerLrrr_append_observed_noterrrget_filebytesdownload_as_bytearrayrrrrr media_urls media_type media_typesrrqrrr context_note)rrr~rrprmimerrCrBrKrFfile_objrr rNs r_cache_observed_mediaz%TelegramAdapter._cache_observed_mediaps =<<<<<'+'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    NNPRU`dN e e e FFFFF  >33 [EJ F"K=#./ ;' ! !!,!2E   [G # #!,!2E // F FD"24DEE FK66  y~A&&DD:&   DDD D%%%%I%%%% F #__........Hx==????????@@D V7++GHk2,N,N,TRTUU&&th$]abbbFF    NNLc\`N a a a FFFFF  > F  ,,,   !2333 u A % %{g%%%0%6""''%0%6"// J Y6; Y Y&*= Y Y6; Y Y Y     ;V[&+VVVVVs+A11BBBD E)E  Ec6|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.r"r r video/mp4rz voice.ogg audio/oggr_rN)Nr r N) rrrTr_rLrrrrj)rrdocs rrz&TelegramAdapter._observed_media_sources 9 29R="b'1 1 9 79b+w6 6 9 @9k;? ? 9 U9gcibAAGRWT T < Q,C +cm.Ar-H-H-J-JDP P!!r)existingnotec$|s|pdS|s|S|d|S)Nr rarj)rrs rrz%TelegramAdapter._append_observed_notes5 ">r ! K&&&&&r)rrcRK|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). rr<r u⚠️ Couldn't download your z). Please try sending it again.Nz;[Telegram] Failed to notify user about %s cache failure: %sTrz[The user attempted to send a z! but it could not be downloaded (z"); they have been asked to retry.]) reply_textr8rfrrrrr) rrr~rrNrnamed reply_err agent_notes r_surface_media_cache_failurez,TelegramAdapter._surface_media_cache_failuresR,)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.rNrr)tzT)roler timestampobservedrnrrzF[%s] Telegram group message observed (no bot trigger): chat=%s from=%srvrwrsz1[%s] Failed to observe Telegram group message: %s)rL_build_message_eventr}rpget_or_create_sessionrrnowrutc isoformatrnrappend_to_transcript session_idrrrOrr) rr?rrr~rr session_entryr adapter_namerNs r"_observe_unmentioned_group_messagez2TelegramAdapter._observe_unmentioned_group_messages.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. FruNrw)rrL)rr?rurjrOs rrwzTelegramAdapter._is_own_message9sry 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|j jddr:t t!t!|dddd}|s ||jvrdSdSt t!t!|dddd}|r||rdS||}|} | r|| vr|S|rdS||vrdS|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_dmrvrwr )rwrCrEr/rrrr4rrrrrrr(r)rLr.rrorsr rrrIr rmrq) rr?rrMr+rrrx guest_mentionrs r_should_process_messagez'TelegramAdapter._should_process_messageJs4    ( ( 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--// 4   ) ) 4((** t/I/I'/R/R 455g>>>s;#B!!2CCc  K|j4d{V t|dd}|rt|dds dddd{VdSt|j}||jvr dddd{VdSddlm m}ddlm }m }||\}} fd |D} |j | ||  d{V|j |td |jt#| |n8#t$$r+} td |j| 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. NrvrFr)r9BotCommandScopeChatr=r@c.g|]\}}||SrjrjrCs rrEz:TelegramAdapter._ensure_forum_commands..rFr)rrGz2[%s] Lazy-registered %d commands for forum chat %sz/[%s] Forum command lazy-registration failed: %s)r&rLrrwr%rr9rrKr>r?rrMrrrrrrr) rr?rvrrr>r?rOrArQrr9s @r_ensure_forum_commandsz&TelegramAdapter._ensure_forum_commandss.# ` ` ` ` ` ` ` ` `w5574U#C#C  ` ` ` ` ` ` ` ` ` ` ` ` ` ` dg,,d<<< ` ` ` ` ` ` ` ` ` ` ` ` ` `EDDDDDDDbbbbbbbb#9#9GaGaGcGc#d#d#d qWWWWWWW i// DWDW`gDhDhDh/iiiiiiiii.227;;; PRVR[]`am]n]npwxxxx ` ` `PRVR[]^________ ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` `sGE2$D' D'||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 %srurwrvr)rrrrrrLrryrrqrrrr?rrurr_enqueue_text_eventrr{rrr~s rrz$TelegramAdapter._handle_text_messages,,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||}||d{VdS) z!Handle incoming command messages.NTrrrurwrvr)rrrrrrrLrrrqrrrurrhandle_messagers rrzTelegramAdapter._handle_commands,,V44 #(  F++CD+AA  F44S99  NND[$77tDDVT22D$??    F))#.........))#{/BfN^)__11%*== ''U333333333>>uEE!!%(((((((((((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.Nrrurwrvrvenuelocationlatitude longitudez![The user shared a location pin.]r{addresszVenue: z Address: z latitude: z longitude: z5Map: https://www.google.com/maps/search/?api=1&query=rfzSAsk what they'd like to find nearby (restaurants, cafes, etc.) and any preferences.r)rrrrrLrryrrqrrrrrrrr) rr{rrrrlatlonr r{rr~s rrz(TelegramAdapter._handle_location_messages,,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|jjddS)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_userFrr)rir_apply_topic_recoveryrprr(r))rr~rs r_text_batch_keyzTelegramAdapter._text_batch_key,s} 655555 ""5)))  L$(K$5$9$9:SUY$Z$Z%)[%6%:%:;UW\%]%]    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 startedNr r)rErrrrr)rr_last_chunk_lenrextendrrr%r;rr_flush_text_batch)rr~rr chunk_len prior_tasks rrz#TelegramAdapter._enqueue_text_event;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. rrrr Nz=[Telegram] Dropping text batch flush after disconnect startedz,[Telegram] Flushing text batch %s (%d chars))rrLrr)rLr_SPLIT_THRESHOLDr_TEXT_BATCH_FAST_LENrr_TEXT_BATCH_FAST_DELAY_S_TEXT_BATCH_SHORT_LEN_TEXT_BATCH_SHORT_DELAY_SrrrrErrrrr)rrrLrlast_len total_lenrr~s rrz!TelegramAdapter._flush_text_batch_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.rrrTrFrmedia_group_idNz:album:z :photo-burst)rirrprr(r)rL)rr~rrr:rs r_photo_batch_keyz TelegramAdapter._photo_batch_keys555555'' 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))rrLrrrrrr)rErrrrrr)rrrLr~s r_flush_photo_batchz"TelegramAdapter._flush_photo_batchs+--  E- ?@@ @ @ @ @ @ @ @/33ItDDE .229==MM/33ItDDDDDNM 1133  ]^^^.229==MM/33ItDDDDDNM KKMyZ]^c^nZoZo p p p%%e,, , , , , , , ,.229==MM/33ItDDDDDNMt.229==MM/33ItDDDDNs|_|g|_|;d r|nt~.|d2g|_td3|t |dd}|r*|tA||d{Vn,|!||}|"||dS| s?|j4r8d4tYj7D}|.|j4d} | sS|j4rLi}tj7D]\}} |A| ||.|j4d} | tXvr|d{V} | d{V}t[t7|| }|g|_tX| g|_tzjB|_td5|||d{VdS|d{V} | d{V}!t7|!}"t|"|pd6| pd7}tmj.| p|j4pd8}#|g|_|#g|_td9||#d:}$| tvp|pd;d;}%|%rt|"|$krn |"Fd<}&|pd6| pd=}'tjHd>d?|'}'d@|'dA|&}(|j r|(dB|j |_ n|(|_ n#t$rYnwxYwne#tF$rX}t$dC|d|%||dD|t |dEdpdFd{VYd}~nd}~wwxYwt |dd}|r+|tA||d{VdS||d{VdS)GzBHandle incoming media messages, downloading images to local cache.Nz=[Telegram] Blocked media from unauthorized user %s in chat %srurwrvr)rr~r"r)rrrrrrfzimage/rBz"[Telegram] Cached user photo at %srz$[Telegram] Failed to cache photo: %sTrrz voice messager z1[Telegram] Skipped oversized user voice (size=%s)rBrSrz"[Telegram] Cached user voice at %sz$[Telegram] Failed to cache voice: %sz audio filez1[Telegram] Skipped oversized user audio (size=%s)r^z audio/mp3z"[Telegram] Cached user audio at %sz$[Telegram] Failed to cache audio: %sz video filez1[Telegram] Skipped oversized user video (size=%s)z.mp4rarz"[Telegram] Cached user video at %sz$[Telegram] Failed to cache video: %sci|]\}}|| Srjrjrjs rrlz9TelegramAdapter._handle_media_message..bs&Y&Y&Y1q!&Y&Y&Yr)rEzFThe 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 'rsz ' could not be read as an image.rz+[Telegram] Cached user image-document at %sci|]\}}|| Srjrjrjs rrlz9TelegramAdapter._handle_media_message..s(X(X(X$!QA(X(X(Xr)z+[Telegram] Cached user video document at %srz.binzapplication/octet-streamz*[Telegram] Cached user document at %s (%s)iztext/rz.txtz [^\w.\- ]rAz [Content of z]: raz'[Telegram] Failed to cache document: %s attachmentr)r)Jr?rrrrLrryrrrrNrurrrrr_handle_stickerrrrrrrarjrrurrrYr_queue_media_group_eventrrrrrrrTrLrrvr_rrzrwr)rrrrrbr_TELEGRAM_IMAGE_MIME_TO_EXTr{r|rBr/_TELEGRAM_IMAGE_EXTENSIONSrrrqr_TELEGRAM_IMAGE_EXT_TO_MIMEr|rrrxr}rr0rrUnicodeDecodeError))rr{rr _observe_type_eventrrr~rr image_bytesrfr cached_pathrrrrr audio_bytes video_bytesroriginal_filenamerAdoc_mime mime_to_extrF image_extvideo_mime_to_extimage_mime_to_ext_ext_mime doc_bytes raw_bytesrMAX_TEXT_INJECT_BYTES_is_text text_contentr injections) rrz%TelegramAdapter._handle_media_messages~  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 PEqSWXXX77UGQOOOOOOOOOOOOOO P 9A  X $ A A#)_ ] ] !%!;!;EJ PR!S!SEJKK SU\]`]fhsuyUzUz{{{--e444444444F!$!3!3!5!5555555$,$B$B$D$DDDDDDD 4U;5G5GVTTT $/= %0M! @+NNNN X X XEqSWXXX77UOUVWWWWWWWWWWWWWW XYp  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 UEqSWXXX77ULRSTTTTTTTTTTTTTT UY^  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 UEqSWXXX77ULRSTTTTTTTTTTTTTT U \E ,CC $'M$7R!$&W--.?@@FAs))++C M/R6688s)C(DE%)4):E&KK M{[[[--e444444444F"%//////"*"@"@"B"BBBBBBB !),, 7 CTCrXrcfcpjpXrXrss 48==llRl $/= %.K! H+W`aaa)3%"99ahn"=X=XY`=a=a I2G G G '0'7'7'@'@ '8'VC"`"" a2,;a--a2Dx A9xh98x9 jA j xjCx1ExCx!Aw>=x> x x x  x y1Ay,,y1rcJK|rtddS|j|}| ||j|<nj|j|j|j|j|jr%| |j|j|_|j |}|r| tj |||j |<dS)aBuffer Telegram media-group items so albums arrive as one logical event. Telegram delivers albums as multiple updates with a shared media_group_id. If we forward each item immediately, the gateway thinks the second image is a new user message and interrupts the first. We debounce briefly and merge the attachments into a single MessageEvent. z@[Telegram] Dropping media group enqueue after disconnect startedN)rErrrr)rrrrrrr;rr_flush_media_group_event)rrr~rrs rrz(TelegramAdapter._queue_media_group_events  - - / /  LL[ \ \ \ F+//??  7[Telegram] Dropping media group flush after disconnect started) rrLrMEDIA_GROUP_WAIT_SECONDSrrrErrrr)rr)rrrLr~s rr"z(TelegramAdapter._flush_media_group_events+--  B- =>> > > > > > > >,00FFE 5577LL!abbb &**>::lJJ'++NDAAAAAKJ ))%000000000%    &**>::lJJ'++NDAAAAAKJ &**>::lJJ'++NDAAAAAKJt&**>::lJJ'++NDAAAAKs0A*C=CE#D%(E#$D%%E##:Frpc(Kddlm}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$rA}td|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_PROMPTr NrGemojiset_namez [Telegram] Sticker cache hit: %srrz"[Telegram] Analyzing sticker at %s)vision_analyze_tool)r~ user_promptrwanalysisz a stickerza sticker with emoji z%[Telegram] Sticker analysis error: %sTr)gateway.sticker_cacher&r'r(r)r*rr+r, is_animatedis_videorfile_unique_idr)rrrrrurtools.vision_toolsr-r:r;rr)rrr~r&r'r(r)r*rr+r,r rrrr- result_jsonrGrGrs rrzTelegramAdapter._handle_sticker 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     NNBAPTN U U U0038I////kxEJJJJJJJ s?C*G+G H6H  Hc ddlm}|dz }|sdSddl}t |dd5}||pi}dddn #1swxYwY|did id id g}|sg|_t|_ dS||_d |D|_ |D]}|d }|s|dgD]y} | d} | d} | rK| rI|d| } | |j vr9t| |j | <t d|j| | zdS#t$r,} td|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. rrrNrrrrrr(rc@h|]}d|vt|dSrr)rr s rrz@TelegramAdapter._reload_dm_topics_from_config..ks7'''/9)WaJaJaJy)**JaJaJar)rrrMrrz8[%s] Hot-loaded DM topic from config: %s -> thread_id=%sz/[%s] Failed to reload dm_topics from config: %s)r!rr"r#r$r%r)r-r$r.r#rrrrrr)rrr'r(r)rrr cidr.tidrr rs r_reload_dm_topics_from_configz-TelegramAdapter._reload_dm_topics_from_configLs , Z 8 8 8 8 8 8)/++m;K%%''  k3999 2Q++1r 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 ;++Z$$Wb!!["%%   )+&*-%%'&/D "''=F'''D #(    nnY//#"55  A%% ,,C55==Dt'*OOTOO $DO;;9>)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)r#rrrr)rrrMrr s r_cache_dm_topic_from_messagez,TelegramAdapter._cache_dm_topic_from_messagesh---- 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.Nr c3BK|]}|VdSr$)_flatten_rich_inline_text)ritemrs rrz.s1QQ4388>>QQQQQQr)rchildren)rrrrrr)rC)rrrrEs` rrCz)TelegramAdapter._flatten_rich_inline_texts =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.r r|rr|rFrrrrvNrrc3BK|]}||VdSr$)rstripr2s rrz7TelegramAdapter._flatten_rich_blocks..s/AA4DAAAAAAAr)) rrrr)_flatten_rich_blocksr8rbrrrCr) rrFlinesblock block_typerD item_textr item_lines first_liners rrJz$TelegramAdapter._flatten_rich_blockss&$'' 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)rGcN 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.rrNr)rhrF)rLrhrJrbr)rrGrrgetterrh rich_getterrs r_extract_rich_reply_textz(TelegramAdapter._extract_rich_reply_texts  !1<FFJZ55FF## t!6.11L!,t<rrXrrNrskillforum_topic_created group_topicscg|] \}}||d S)rrj)r cfg_chat_idrs rrEz8TelegramAdapter._build_message_event..3 s4%%%+ V!,v>>%%%r)c<g|]}t|t|Srj)rr)rrs rrEz8TelegramAdapter._build_message_event..8 s8%%%#jPT>U>U%%%%r)rrrMry>rVris_botF) r chat_namerLrOrNrM chat_topicrnr\quoterrrx)resolve_channel_prompt) rrrprrnplatform_update_idr reply_to_text auto_skillrr)%rvrurrLrkrjrEr>rwr)rrWrr@rr(rrr|r build_sourcer{ryrnr'rGrrNrTr~rylookuprrr`rpdate)rr?rrrvrtelegram_chat_typerL thread_id_strr^ topic_skill topic_info created_namegroup_topics_configgroup_topics_iterr rrr9rprdrbr_ quote_textryr` _chat_id_str_channel_prompts rrz$TelegramAdapter._build_message_events|  !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_REACTIONSr>rrr)rrrjrs r_reactions_enabledz"TelegramAdapter._reactions_enabled s'y-w77==??G[[[r)r+c K|jsdS |jt|t||d{VdS#t$r-}t d|j||Yd}~dSd}~wwxYw)z2Set a single emoji reaction on a Telegram message.FrrnreactionNTz)[%s] set_message_reaction failed (%s): %srset_message_reactionrrrrrr)rrrnr+rs r _set_reactionzTelegramAdapter._set_reaction sy 5 )0027;;z??1        4    LLDdiQVXY Z Z Z55555 s=A B"A>>Bc K|jsdS |jt|t|dd{VdS#t$r,}t d|j|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. FNruTz[%s] clear reactions failed: %srwr/s r_clear_reactionsz TelegramAdapter._clear_reactions sy 5 )0027;;z??1        4    LL:DIq I I I55555 s=A B!A==BcK|sdSt|jdd}t|dd}|r!|r!|||dd{VdSdSdS)z;Add an in-progress reaction when message processing begins.Nrrnu👀)rsrLrpry)rr~rrns 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. Nrrnu👍u👎)rsrLrprr CANCELLEDr{rySUCCESS)rr~r~rrns ron_processing_completez&TelegramAdapter.on_processing_complete s&&((  F%, 488UL$77  J  F '1 1 1''<< < < < < < < < < <$$ '+<+D D D ,         r)r0)NN)NNNr$r)r r N)rEN)r)r{rQrrr N)Nr.)NNNN)rfrgrh__doc__rsupports_code_blockssplits_long_messagesrRICH_MESSAGE_MAX_BYTESrr$rrr'__annotations__rrrr staticmethodrrrrpropertyrrnrr:r=rCrErr rJrsrSrrr classmethodrrrrrrrrrrrrrrrrrrrrrrr r rrr"rr<r}DOTALLr$r&r+r)r,r9r<r>r@rDrFrHrMrXr[r#rfrsrrrrrrr!rrrrrrrrrrrrrrrr r4r7r6rrNrrr^rrrr r r.r2r7r9rDrUrYrgr}rrrzrrrrr)rrArIrLrcrryrrerrrrrrrrr rr$rr r%r)r/r4PatternrrCrErIrermrorqrsruryr}rprrrrqrrrrrrrrwrrrQrr]rirrrrrrrrrrrr"rr:r>r@rCrJrTrrsryr{r}rrr __classcell__)r8s@rrrs&#4""$(D'''#  $ &*%) E?  E?   \6X[?~[?[?[?[?[?[?z""""""%%%%%%ESE3EdEtEEEEEEFtFFFF . c3h0 . c3h . . . .&"&#'#'#'2G2G2G2G# 2G C= 2G C= 2GC=2G 2G2G2G2Gh: W: : : : x ?t ? ? ? ?B<B:R?W_`cWd???[? ?Xd38n5M?RZ[^R_???[? ST\   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 * * *\ *9\6  d   \ D  c D T    2d38n2222$ ; ; ; ; ; ; WD W W W W"rz"BBMTVT]D]^^)rz N  !   2:   Lcd C3C4CCCCST,cd* c d     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))))V####JS ScSdSSSS444d_cB|0|0t|0|0|0|0|AAAAFdudddddL+@+@+@+@Z= = = = ~Q-IQ-$Q-Q-Q-Q-n%).2 1111SM 1 'sm 1 # 1111f555 # 5555$33S3c3QU3bjknbo3333j          8"' HjHjHjHj Hj  Hj  HjHjHjHjTRRRRh     J/J/J/J/X5:KKKTKdKKKKZ $4:-,-,-,-,^CBCBCBCBJ$Xc]$$QU$$$$0#'-1 EEEE3- E 4S>* E  EEEEZ .2       4S>*      P-1I?I?I?I?I? I?  I?4S>*I? I?I?I?I?V         ,.2H H H H H  H  H 4S>*H  H H H H TCST6$(-1>>C=>4S>*>  >>>>0.2 WAWAWAWA WA 4S>* WA  WAWAWAWAr%%%P9;-1);););$');25););4S>*);  ););););Z/-1F;F;F;%(F;7:F;F;4S>*F;  F;F;F;F;T?C.;.;.;#&.;14.;CF.;.;#+DcN#;.; .;.;.;.;n.2P;P;P;P;$ P;  P;  P;4S>*P; P;P;P;P;t.2F;F;F;F; F;  F;  F;4S>*F; F;F;F;F;PE5E5$E5cE5%E5E5E5E5N'5D'5'5'5'5'5'5RM!M!),M! M!M!M!M!^ 2eSeS)DeS eSeSeSeS^ )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 YgYgYgYg# Yg 3- Yg 4S>* Yg YgYgYgYgYgYg~.2 EEEU E4S>* E  E  EEEEEEV"&"&-1 [p[p[p[p# [p 3- [p 4S>* [p [p[p[p[p[p[pB"&#'"&-14t4t4t4t# 4t C= 4t 3- 4t4S>*4t 4t4t4t4t4t4tt"&"&-1 0g0g0g0g# 0g 3- 0g 4S>* 0g 0g0g0g0g0g0gl"&"&-1 \j\j\j\j# \j 3- \j 4S>* \j \j\j\j\j\j\jD"&"&-1 -g-g-g-g# -g 3- -g 4S>* -g -g-g-g-g^!!!c3h8P!\`!!!!F I3 I4S> I I I IDjcjcjjjj\d4ddddwdwwww"_d____j$jjjjNs3xNNNN NS N N N NNs3xNNNN S     N#c( N N N N3s8*$4 +;$$$$L4g4$44447x}[4ffDffff 3'3'CH3'3'3'\3'j6W66666p]7]t]]]]0  T    SSTSSSSHSMhsm11T1111f[[[;\;c;;;;        | P\    6 $w $; $ $ $ $6[w6[|6[PT6[6[6[6[p,Wc,W,,W4,W,W,W,W\ "' " " " "' 'S'S'''\''+ 'H'H 'H'H 'H  'H sm 'H 'H'H'H'HZ$((, !c!c!c!cC= !c  % !c  !c!c!c!cFPwP4PPPP"OTS?S?S?wS?tS?X\S?S?S?S?j````2^^8G;L^^^^((,B[(`d((((B)F)\=V)[_)))),-)V-)lF_-)dh-)-)-)-)f  \  c     " " $" " " " H->3->4->->->->f ,l , ,S , , , ,E#E$EEEE"mcm,m4mmmm*W)&W)Nr r>rrz[Unknown telegram notifications mode '%s', defaulting to 'important' (valid: all, important)) rrgateway.configr gateway.runrrrbrjrrr)rrr_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).r)rrr4r)radapters 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. rNrTELEGRAM_BOT_TOKENr )rLhermes_cli.gatewayr~ get_env_valuer'rrb)rr gateway_mods r _is_connectedr$!si FGT * *E F000000))*>??E2 E   "" # ##r))rM media_filesforce_documentc Kt|ddptjdd}tt|dio|jd}ddlm}|||||||| 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.rNrr r(rr)_send_telegram)rrMrr)rLrrr'r(r)tools.send_message_toolr) pconfigrr?rMrrrrrs r_standalone_sendr5!s GWd + + Rry9Mr/R/RE "%%T'-*;*;.!s(//a3q66//////r)rrc34K|]}t|VdSr$rrs rrz%_apply_yaml_config..!s(--Q#a&&------r)r+r,c34K|]}t|VdSr$rrs rrz%_apply_yaml_config..!s(%E%Ec!ff%E%E%E%E%E%Er)r1r2c34K|]}t|VdSr$rrs rrz%_apply_yaml_config..!s(&G&G!s1vv&G&G&G&G&G&Gr) reactionsrrrrtr(rTELEGRAM_REPLY_TO_MODEFrrr\c34K|]}t|VdSr$rrs rrz%_apply_yaml_config..!s($C$CSVV$C$C$C$C$C$Cr)group_allow_fromrc34K|]}t|VdSr$rrs rrz%_apply_yaml_config..!(*O*Oa3q66*O*O*O*O*O*Or)r"rc34K|]}t|VdSr$rrs rrz%_apply_yaml_config..!rr))rrr> dm_policyr group_policy reply_prefixrchannel_promptsnotice_deliveryreply_in_threadrallow_admin_fromchannel_skill_bindingsunauthorized_dm_behaviorgateway_restart_notification)r:rr)rrrrjenvirondumpsrrrrbrr|)rr_jsonextras _effective_rmfrcacr+r1_telegram_extra _telegram_rtm_rtm_str allowed_usersgroup_allowed_usersr"_key_GENERIC_MERGE_KEYS_k_vs r_apply_yaml_configr`!sF"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 3K)L)L mT * * DHH$C$C]$C$C$CCCM/2=/A/A +,&**+=>>&ry9W/X/X& )4 0 0 P"%((*O*O;N*O*O*O"O"O 589L5M5M 12&**+@AA&ry9W/X/X& )4 0 0 P"%((*O*O;N*O*O*O"O"O 589L5M5M 12]88 <     dL$6 7 7 7 "''))&&B ( ( (   b" % % % >Tr)c|ddtttdgdtt dddt dd d d S) u:Plugin entry point — called by the Hermes plugin system.rTelegramrz$pip install 'hermes-agent[telegram]'r\rTELEGRAM_HOME_CHANNELru✈️T)rradapter_factorycheck_fn is_connected required_env install_hintsetup_fnapply_yaml_config_fnallowed_users_env allow_all_envcron_deliver_env_varstandalone_sender_fnmax_message_lengthr+allow_update_commandN)register_platformrrrrrr)ctxs rregisterr!s\ &,"*+;"/204-!!r)r0)zrrr|r r:loggingrhtmlrMrr4rrrrrrrr getLoggerrfrobjectrrrrrrCr=rPrrQrRrSrTrUrWrrrYrZr[r\rr]r^rr`rarrcrresyspathlibrkr*rinsert__file__rparentsrrmrnrrorprqrrrsrtrurvrwrxryrzr{r|r}r~'plugins.platforms.telegram.telegram_idsr+plugins.platforms.telegram.telegram_networkrrrutilsrrrr r r r'rr<rrrrrgateway.platforms.helpersrr0rrrrrrrrrrrrrrrrjr)rrs    ''''''''11111111111111  8 $ $ +v +# + + + +Y',Y4YYYYPT555%5555p N N N N#V#V#V#VJ&%YYYYYYYYYYYYYY"/////// """!"76666666------%%% F CGKN LGIH$LLL+%. !!!!!!33uuX..008;<<===33333333$ 5444444444GGG       4T4444r"*<==.s.s.... cc, *rz9   Is Is I I I I*'BJL SSHH}H}H}H}H})H}H}H}tzS4$T$$$$,> ! ! ! !^^T^dTk^^^^Bs64B8B B8 BB8B#B882C-,C-