| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820 |
- """Yuanbao platform adapter: WebSocket gateway client (AUTH_BIND, ping/pong heartbeat, reconnect),
- inbound middleware pipeline (T05 push → MessageEvent) and outbound sender (T06 text/media).
- Config under ``platforms.yuanbao.extra`` (or env): app_id/YUANBAO_APP_ID, app_secret/YUANBAO_APP_SECRET,
- bot_id/YUANBAO_BOT_ID (optional, returned by sign-token), ws_url/YUANBAO_WS_URL, api_domain/YUANBAO_API_DOMAIN.
- """
- from __future__ import annotations
- import asyncio
- import base64
- import binascii
- import collections
- import contextlib
- import dataclasses
- import hashlib
- import hmac
- import json
- import logging
- import os
- import re
- import secrets
- import sys
- import time
- import urllib.parse
- import uuid
- from abc import ABC, abstractmethod
- from dataclasses import dataclass, field as dc_field
- from datetime import datetime, timezone, timedelta, UTC
- from enum import Enum
- from pathlib import Path
- from typing import Any, Callable, ClassVar, Dict, Iterator, List, Optional, Tuple
- import httpx
- try:
- import websockets
- import websockets.exceptions
- WEBSOCKETS_AVAILABLE = True
- except ImportError:
- WEBSOCKETS_AVAILABLE = False
- websockets = None # type: ignore[assignment]
- from gateway.config import Platform, PlatformConfig
- from agent.i18n import t
- from gateway.platforms.base import (
- BasePlatformAdapter, SendResult,
- cache_document_from_bytes_async, cache_image_from_bytes_async, cache_video_from_bytes_async,
- )
- from gateway.platforms.event import MessageEvent, MessageType
- from gateway.platforms import helpers as _mdchunk
- from gateway.platforms._shared import get_scoped_secret as _yb_secret, profile_scoped as _profile_scoped
- from gateway.platforms.helpers import MessageDeduplicator, cancel_task
- from gateway.platforms.access_policy_mixin import OwnAccessPolicyMixin
- from plugins.platforms.yuanbao.yuanbao_media import (
- download_url as media_download_url, get_cos_credentials, upload_to_cos,
- build_image_msg_body, build_file_msg_body, guess_mime_type, md5_hex,
- )
- from plugins.platforms.yuanbao.yuanbao_proto import (
- CMD_TYPE, WS_HEARTBEAT_RUNNING, WS_HEARTBEAT_FINISH, HERMES_INSTANCE_ID,
- _fields_to_dict, _get_string, _get_varint, _parse_fields,
- decode_conn_msg, decode_inbound_push, decode_forward_msg_data,
- decode_query_group_info_rsp, decode_get_group_member_list_rsp,
- encode_auth_bind, encode_ping, encode_push_ack, encode_send_c2c_message, encode_send_group_message,
- encode_send_private_heartbeat, encode_send_group_heartbeat, encode_query_group_info,
- encode_get_group_member_list, next_seq_no,
- )
- from gateway.session_transcript import TranscriptReadError
- logger = logging.getLogger(__name__)
- # AUTH_BIND / sign-token header values
- from hermes_cli.version_info import get_version_info
- _YUANBAO_INSTANCE_ID = str(HERMES_INSTANCE_ID)
- _OPERATION_SYSTEM = sys.platform
- DEFAULT_WS_GATEWAY_URL = "wss://bot-wss.yuanbao.tencent.com/wss/connection"
- DEFAULT_API_DOMAIN = "https://bot.yuanbao.tencent.com"
- HEARTBEAT_INTERVAL_SECONDS = 30.0
- CONNECT_TIMEOUT_SECONDS = 15.0
- AUTH_TIMEOUT_SECONDS = 10.0
- MAX_RECONNECT_ATTEMPTS = 100
- DEFAULT_SEND_TIMEOUT = 30.0 # WS biz request timeout
- # Caps the WS close handshake: websockets' own 5s close_timeout waits for a close echo an idle
- # server never sends, stalling shutdown; a responsive server finishes well under 1s.
- # Upper bound on the WS close handshake during teardown (#40383). The websockets connection's own
- # close_timeout (5s) blocks until the server echoes the close frame; an idle/unresponsive server never
- # replies, stalling gateway shutdown by the full timeout. Bounding the close await here keeps teardown fast
- # — a responsive server completes the handshake in well under a second, so this only caps the pathological
- # hang. Also bounds the reconnect / connect-failure cleanup paths that reuse _cleanup_ws(), where a graceful
- # close is unnecessary anyway (the socket is being discarded to redial).
- WS_CLOSE_TIMEOUT_S = 1.0
- NO_RECONNECT_CLOSE_CODES = {4012, 4013, 4014, 4018, 4019, 4021} # permanent errors — never reconnect
- HEARTBEAT_TIMEOUT_THRESHOLD = 2 # consecutive missed pongs before reconnect
- REPLY_HEARTBEAT_INTERVAL_S = 2.0 # RUNNING cadence
- REPLY_HEARTBEAT_TIMEOUT_S = 30.0 # auto-FINISH after this much inactivity
- SLOW_RESPONSE_TIMEOUT_S = 120.0 # push slow_response_message() when the agent is silent this long
- def slow_response_message() -> str:
- """Patience notice pushed after SLOW_RESPONSE_TIMEOUT_S of agent silence (localized; the
- Chinese wording Yuanbao users historically saw lives in locales/zh.yaml)."""
- return t("platform.yuanbao.slow_response_notice")
- # Cron wrapper markers, mirrored from cron/scheduler_delivery.py (``wrap_response``). The wrapper
- # is not keyed yet; when it is, import the same key here so ``strip_cron_wrapper`` keeps matching.
- CRON_WRAPPER_HEADER_PREFIX = "Cronjob Response: "
- CRON_WRAPPER_DIVIDER = "\n-------------\n\n"
- CRON_WRAPPER_FOOTER_PREFIX = '\n\nTo stop or manage this job, send me a new message (e.g. "stop reminder '
- # Transcript anchors: [image|ybres:abc] [file:report.pdf|ybres:xyz] [voice|ybres:…]
- _YB_RES_REF_RE = re.compile(r"\[(image|voice|video|file(?::[^|\]]*)?)\|ybres:([A-Za-z0-9_\-]+)\]")
- # Anchors after local download: [image: /path] [file: report.pdf → /path] [video: /path]
- _YB_LOCAL_MEDIA_RE = re.compile(r"\[(\w+):[^\]]*?(/[^\]]+?)\s*\]")
- _RESOLVABLE_MEDIA_KINDS = frozenset({"image", "file", "video"}) # kinds injected into model context
- _INDICATOR_RE = re.compile(r'\s*\(\d+/\d+\)$') # "(1/3)" page indicators from BasePlatformAdapter
- _TEXT_ELEM_TYPE = "TIMTextElem"
- OBSERVED_MEDIA_BACKFILL_LOOKBACK = 50 # recent transcript messages scanned for observed media
- OBSERVED_MEDIA_BACKFILL_MAX_RESOLVE_PER_TURN = 12
- # platforms.yuanbao.extra.media_resolve_concurrency: 1 = sequential rollback knob;
- # 6 = browser per-origin HTTP/1.1 ceiling; 12 = backfill cap.
- _DEFAULT_RESOLVE_CONCURRENCY = 6
- _MIN_RESOLVE_CONCURRENCY = 1
- _MAX_RESOLVE_CONCURRENCY = 12
- def _iter_ybres_refs(matches) -> Iterator[tuple[str, str, str]]:
- """Turn ``_YB_RES_REF_RE`` matches into ``(rid, kind, filename)`` for resolvable kinds only."""
- for m in matches:
- kind, _, filename = m.group(1).partition(":")
- if kind.strip() in _RESOLVABLE_MEDIA_KINDS:
- yield m.group(2), kind.strip(), filename.strip()
- def _text_elem(text: str) -> dict:
- """A TIMTextElem msg_body entry."""
- return {"msg_type": _TEXT_ELEM_TYPE, "msg_content": {"text": text}}
- def _cancel_all(tasks: dict[str, asyncio.Task]) -> None:
- """Cancel every unfinished task in *tasks* and clear the dict."""
- for task in list(tasks.values()):
- if not task.done():
- task.cancel()
- tasks.clear()
- class MarkdownProcessor:
- """Yuanbao's fence/table-aware chunking policy over the shared chunker in gateway.platforms.helpers."""
- @classmethod
- def chunk_markdown_text(cls, text: str, max_chars: int = 4000, len_fn: Optional[Callable[[str], int]] = None) -> list[str]:
- """<= max_chars chunks at paragraph boundaries, never inside a fence or table (an oversized
- single block may exceed the limit)."""
- return _mdchunk.split_text_fence_aware(text, max_chars, len_fn, prefer_paragraphs=True, balance_fences=False)
- class SignManager:
- """Sign-token acquisition, caching, signing and retry. All state is class-level so one
- shared client serves the whole process."""
- TOKEN_PATH = "/api/v5/robotLogic/sign-token"
- RETRYABLE_CODE = 10099
- MAX_RETRIES = 3
- RETRY_DELAY_S = 1.0
- CACHE_REFRESH_MARGIN_S = 60 # treat as expiring this many seconds early
- HTTP_TIMEOUT_S = 10.0
- _cache: dict[str, dict[str, Any]] = {} # app_key → {"token", "bot_id", "expire_ts", ...}
- # Per-app_key refresh locks, created lazily from async context so they bind to the running
- # loop; disconnect() clears them to avoid stale locks across reconnects.
- _locks: dict[str, asyncio.Lock] = {}
- @classmethod
- def get_refresh_lock(cls, app_key: str) -> asyncio.Lock:
- """Per-app_key refresh lock (create on demand). Call only from a running event loop."""
- if app_key not in cls._locks:
- cls._locks[app_key] = asyncio.Lock()
- return cls._locks[app_key]
- @staticmethod
- def compute_signature(nonce: str, timestamp: str, app_key: str, app_secret: str) -> str:
- """HMAC-SHA256(key=app_secret, msg=nonce+timestamp+app_key+app_secret).hexdigest()."""
- plain = nonce + timestamp + app_key + app_secret
- return hmac.new(app_secret.encode(), plain.encode(), hashlib.sha256).hexdigest()
- @staticmethod
- def build_timestamp() -> str:
- """Beijing-time ISO-8601 timestamp without milliseconds (2006-01-02T15:04:05+08:00)."""
- return datetime.now(tz=timezone(timedelta(hours=8))).strftime("%Y-%m-%dT%H:%M:%S+08:00")
- @classmethod
- def is_cache_valid(cls, entry: dict[str, Any]) -> bool:
- return entry["expire_ts"] - time.time() > cls.CACHE_REFRESH_MARGIN_S
- @classmethod
- def clear_locks(cls) -> None:
- cls._locks.clear()
- @classmethod
- def purge_expired(cls) -> int:
- """Drop expired token-cache entries; returns count purged."""
- now = time.time()
- expired_keys = [k for k, v in cls._cache.items() if now - v.get("expire_ts", 0) > 0]
- for k in expired_keys:
- cls._cache.pop(k, None)
- return len(expired_keys)
- @classmethod
- async def fetch(cls, app_key: str, app_secret: str, api_domain: str, route_env: str = "") -> dict[str, Any]:
- """POST sign-token, retrying RETRYABLE_CODE up to MAX_RETRIES times."""
- url = f"{api_domain.rstrip('/')}{cls.TOKEN_PATH}"
- async with httpx.AsyncClient(timeout=cls.HTTP_TIMEOUT_S) as client:
- for attempt in range(cls.MAX_RETRIES + 1):
- nonce = secrets.token_hex(16)
- timestamp = cls.build_timestamp()
- payload = {"app_key": app_key, "nonce": nonce,
- "signature": cls.compute_signature(nonce, timestamp, app_key, app_secret), "timestamp": timestamp}
- version = get_version_info().base_version
- headers = {"Content-Type": "application/json", "X-AppVersion": version, "X-OperationSystem": _OPERATION_SYSTEM,
- "X-Instance-Id": _YUANBAO_INSTANCE_ID, "X-Bot-Version": version}
- if route_env:
- headers["X-Route-Env"] = route_env
- logger.info("Sign token request: url=%s%s", url, f" (retry {attempt}/{cls.MAX_RETRIES})" if attempt > 0 else "")
- response = await client.post(url, json=payload, headers=headers)
- if response.status_code != 200:
- raise RuntimeError(f"Sign token API returned {response.status_code}: {response.text[:200]}")
- try:
- result_data: dict[str, Any] = response.json()
- except Exception as exc:
- raise ValueError(f"Sign token response parse error: {exc}") from exc
- code = result_data.get("code")
- if code == 0:
- data = result_data.get("data")
- if not isinstance(data, dict):
- raise ValueError(f"Sign token response missing 'data' field: {result_data}")
- logger.info("Sign token success: bot_id=%s", data.get("bot_id"))
- return data
- if code != cls.RETRYABLE_CODE or attempt >= cls.MAX_RETRIES:
- raise RuntimeError(f"Sign token error: code={code}, msg={result_data.get('msg', '')}")
- logger.warning("Sign token retryable: code=%s, retrying in %ss (attempt=%d/%d)",
- code, cls.RETRY_DELAY_S, attempt + 1, cls.MAX_RETRIES)
- await asyncio.sleep(cls.RETRY_DELAY_S)
- raise RuntimeError("Sign token failed: max retries exceeded")
- @classmethod
- async def _fetch_into_cache(cls, app_key: str, app_secret: str, api_domain: str, route_env: str) -> None:
- data = await cls.fetch(app_key, app_secret, api_domain, route_env)
- duration: int = data.get("duration", 0)
- cls._cache[app_key] = {
- "token": data.get("token", ""), "bot_id": data.get("bot_id", ""), "duration": duration,
- "product": data.get("product", ""), "source": data.get("source", ""),
- "expire_ts": time.time() + (duration if duration > 0 else 3600),
- }
- @classmethod
- async def get_token(cls, app_key: str, app_secret: str, api_domain: str, route_env: str = "") -> dict[str, Any]:
- """WS auth token, served from cache while valid (with CACHE_REFRESH_MARGIN_S)."""
- cls.purge_expired()
- cached = cls._cache.get(app_key)
- if cached and cls.is_cache_valid(cached):
- logger.info("Using cached token (%ds remaining)", int(cached["expire_ts"] - time.time()))
- return dict(cached)
- async with cls.get_refresh_lock(app_key):
- cached = cls._cache.get(app_key)
- if cached and cls.is_cache_valid(cached):
- return dict(cached)
- await cls._fetch_into_cache(app_key, app_secret, api_domain, route_env)
- return dict(cls._cache[app_key])
- @classmethod
- async def force_refresh(cls, app_key: str, app_secret: str, api_domain: str, route_env: str = "") -> dict[str, Any]:
- """Clear the cached token and re-sign."""
- logger.warning("[force-refresh] Clearing cache and re-signing token: app_key=****%s", app_key[-4:])
- async with cls.get_refresh_lock(app_key):
- cls._cache.pop(app_key, None)
- await cls._fetch_into_cache(app_key, app_secret, api_domain, route_env)
- return dict(cls._cache[app_key])
- @dataclass
- class InboundContext:
- """Mutable context passed through every inbound middleware in registration order."""
- adapter: Any # YuanbaoAdapter (forward-ref avoids circular import)
- raw_frames: list = dc_field(default_factory=list) # debounce-aggregated raw frames
- push: Optional[dict] = None # DecodeMiddleware
- decoded_via: str = "" # "json" | "protobuf"
- from_account: str = "" # ExtractFieldsMiddleware …
- group_code: str = ""
- group_name: str = ""
- sender_nickname: str = ""
- msg_body: list = dc_field(default_factory=list)
- msg_id: str = ""
- cloud_custom_data: str = ""
- chat_id: str = "" # ChatRoutingMiddleware …
- chat_type: str = "" # "dm" | "group"
- chat_name: str = ""
- raw_text: str = "" # ExtractContentMiddleware …
- media_refs: list = dc_field(default_factory=list)
- forwarded_records: Optional[dict] = None # parsed ForwardMsgData for elem_type 1009
- owner_command: Optional[str] = None # OwnerCommandMiddleware
- source: Optional[Any] = None # SessionSource, BuildSourceMiddleware
- msg_type: Optional[Any] = None # MessageType | YuanbaoMessageType, ClassifyMessageTypeMiddleware
- reply_to_message_id: Optional[str] = None # QuoteContextMiddleware …
- reply_to_text: Optional[str] = None
- quote_media_refs: list = dc_field(default_factory=list) # (rid, kind, filename)
- # MediaResolveMiddleware: deduped local paths — own media, then quoted media, else group-observed media
- media_urls: list = dc_field(default_factory=list)
- media_types: list = dc_field(default_factory=list)
- channel_prompt: Optional[str] = None # GroupAttributionMiddleware
- class InboundMiddleware(ABC):
- """Set class-level ``name`` and implement ``handle(ctx, next_fn)``; ``await next_fn()``
- continues the pipeline, returning without it stops."""
- name: str = ""
- @abstractmethod
- async def handle(self, ctx: InboundContext, next_fn: Callable) -> None: ...
- async def __call__(self, ctx: InboundContext, next_fn: Callable) -> None:
- return await self.handle(ctx, next_fn)
- def __repr__(self) -> str:
- return f"<{self.__class__.__name__} name={self.name!r}>"
- class InboundPipeline:
- """Onion-model middleware pipeline: named middlewares, ``when`` guards, use_before/use_after/
- remove. Accepts ``InboundMiddleware`` instances or plain ``async def(ctx, next_fn)`` callables."""
- def __init__(self) -> None:
- self._middlewares: list = [] # (name, handler, when_fn | None)
- @staticmethod
- def _normalize(name_or_mw, handler=None):
- if isinstance(name_or_mw, InboundMiddleware):
- return name_or_mw.name, name_or_mw
- return name_or_mw, handler
- def use(self, name_or_mw, handler=None, when=None) -> InboundPipeline:
- """Append ``pipeline.use(SomeMiddleware())`` or ``pipeline.use("name", fn)``."""
- return self._insert_relative(None, 0, name_or_mw, handler, when)
- def _insert_relative(self, target: Optional[str], offset: int, name_or_mw, handler, when) -> InboundPipeline:
- """Insert at index(target)+offset; appends when *target* is None or not registered."""
- name, h = self._normalize(name_or_mw, handler)
- idx = next((i for i, (n, _, _) in enumerate(self._middlewares) if n == target), None)
- self._middlewares.insert(len(self._middlewares) if idx is None else idx + offset, (name, h, when))
- return self
- def use_before(self, target: str, name_or_mw, handler=None, when=None) -> InboundPipeline:
- return self._insert_relative(target, 0, name_or_mw, handler, when)
- def use_after(self, target: str, name_or_mw, handler=None, when=None) -> InboundPipeline:
- return self._insert_relative(target, 1, name_or_mw, handler, when)
- def remove(self, name: str) -> InboundPipeline:
- self._middlewares = [(n, h, w) for n, h, w in self._middlewares if n != name]
- return self
- @property
- def middleware_names(self) -> list:
- return [n for n, _, _ in self._middlewares]
- async def execute(self, ctx: InboundContext) -> None:
- """Run the chain; each middleware receives ``(ctx, next_fn)``."""
- chain = self._middlewares
- index = 0
- async def next_fn() -> None:
- nonlocal index
- while index < len(chain):
- name, handler, when_fn = chain[index]
- index += 1
- if when_fn is not None and not when_fn(ctx):
- continue
- try:
- await handler(ctx, next_fn)
- except Exception:
- logger.error("[InboundPipeline] middleware [%s] error", name, exc_info=True)
- raise
- return
- await next_fn()
- class DecodeMiddleware(InboundMiddleware):
- """Decode raw inbound frames (JSON or protobuf via ``decode_inbound_push``) into ctx.push."""
- name = "decode"
- @staticmethod
- def convert_json_msg_body(raw_body: list) -> list:
- """Normalize JSON msg_body (PascalCase or snake_case keys) to [{"msg_type", "msg_content"}]."""
- result = []
- for item in raw_body or []:
- if not isinstance(item, dict):
- continue
- msg_type = item.get("msg_type") or item.get("MsgType", "")
- msg_content = item.get("msg_content") or item.get("MsgContent", {})
- if isinstance(msg_content, str):
- try:
- msg_content = json.loads(msg_content)
- except Exception:
- msg_content = {"text": msg_content}
- result.append({"msg_type": msg_type, "msg_content": msg_content or {}})
- return result
- @staticmethod
- def json_sender_fields(raw_json: dict) -> tuple[str, str]:
- """(from_account, group_code) accepting both Tencent IM PascalCase and internal snake_case keys."""
- from_account = raw_json.get("from_account", "") or raw_json.get("From_Account", "")
- group_code = raw_json.get("group_code", "") or raw_json.get("GroupId", "") or raw_json.get("group_id", "")
- return from_account, group_code
- @staticmethod
- def parse_json_push(raw_json: dict) -> dict | None:
- """JSON push → dict shaped like ``decode_inbound_push`` output; accepts both the callback
- format (callback_command/from_account/msg_body) and legacy keys (GroupId/MsgSeq/MsgKey/MsgBody)."""
- if not raw_json:
- return None
- from_account, group_code = DecodeMiddleware.json_sender_fields(raw_json)
- msg_body = DecodeMiddleware.convert_json_msg_body(raw_json.get("msg_body", []) or raw_json.get("MsgBody", []))
- # Recall callbacks may have neither from_account nor msg_body.
- if not from_account and not msg_body and not raw_json.get("callback_command"):
- return None
- return {
- "callback_command": raw_json.get("callback_command", ""),
- "from_account": from_account,
- "to_account": raw_json.get("to_account", "") or raw_json.get("To_Account", ""),
- "sender_nickname": raw_json.get("sender_nickname", "") or raw_json.get("nick_name", ""),
- "group_code": group_code,
- "group_name": raw_json.get("group_name", ""),
- "msg_seq": raw_json.get("msg_seq", 0) or raw_json.get("MsgSeq", 0),
- "msg_id": raw_json.get("msg_id", "") or raw_json.get("msg_key", "") or raw_json.get("MsgKey", ""),
- "msg_body": msg_body,
- "cloud_custom_data": raw_json.get("cloud_custom_data", "") or raw_json.get("CloudCustomData", ""),
- "bot_owner_id": raw_json.get("bot_owner_id", "") or raw_json.get("botOwnerId", ""),
- "recall_msg_seq_list": raw_json.get("recall_msg_seq_list") or None,
- "trace_id": (raw_json.get("log_ext") or {}).get("trace_id", "") if isinstance(raw_json.get("log_ext"), dict) else "",
- }
- def _decode_single(self, adapter, data: bytes) -> tuple:
- """One raw frame → (push_dict, decoded_via) or (None, '')."""
- try:
- conn_json = json.loads(data.decode("utf-8"))
- except Exception:
- conn_json = None
- if isinstance(conn_json, dict):
- push = self.parse_json_push(conn_json)
- return (push, "json") if push else (None, "")
- try:
- push = decode_inbound_push(data)
- except Exception:
- push = None
- return (push, "protobuf") if push else (None, "")
- async def handle(self, ctx: InboundContext, next_fn) -> None:
- if not ctx.raw_frames:
- return # Stop pipeline — nothing to decode
- merged: Optional[dict] = None
- for data in ctx.raw_frames:
- push, via = self._decode_single(ctx.adapter, data)
- if not push:
- logger.info("[%s] Push decoded but no valid message. raw hex(first64)=%s",
- ctx.adapter.name, data.hex()[:128] if data else "(empty)")
- elif merged is None:
- merged, ctx.decoded_via = push, via
- logger.info("[%s] Frame decoded (via=%s): len=%d", ctx.adapter.name, via, len(data))
- elif push.get("msg_body", []): # subsequent pushes: append msg_body, newline-separated
- merged["msg_body"] = merged.get("msg_body", []) + [_text_elem("\n")] + push["msg_body"]
- logger.info("[%s] Merged %d extra msg_body elements from aggregated push", ctx.adapter.name, len(push["msg_body"]))
- if not merged:
- return # Stop pipeline
- ctx.push = merged
- logger.info(
- "[%s] Push decoded (via=%s): from=%s group=%s msg_id=%s msg_types=%s",
- ctx.adapter.name, ctx.decoded_via, merged.get("from_account", ""), merged.get("group_code", ""),
- merged.get("msg_id", ""), [e.get("msg_type", "") for e in merged.get("msg_body", [])],
- )
- logger.debug("[%s] Push payload: %s", ctx.adapter.name, ctx.push)
- await next_fn()
- class ExtractFieldsMiddleware(InboundMiddleware):
- """Copy common push fields onto ctx."""
- name = "extract-fields"
- async def handle(self, ctx: InboundContext, next_fn) -> None:
- for f in ("from_account", "group_code", "group_name", "sender_nickname", "msg_id", "cloud_custom_data"):
- setattr(ctx, f, ctx.push.get(f, ""))
- ctx.msg_body = ctx.push.get("msg_body", [])
- await next_fn()
- class DedupMiddleware(InboundMiddleware):
- name = "dedup"
- async def handle(self, ctx: InboundContext, next_fn) -> None:
- if ctx.msg_id and ctx.adapter._dedup.is_duplicate(ctx.msg_id):
- logger.debug("[%s] Duplicate message ignored: msg_id=%s", ctx.adapter.name, ctx.msg_id)
- return # Stop pipeline
- await next_fn()
- def _session_store(adapter):
- """Adapter's SessionStore, or None before ``set_session_store`` ran."""
- return getattr(adapter, "_session_store", None)
- class RecallGuardMiddleware(InboundMiddleware):
- """Recall callbacks (Group.CallbackAfterRecallMsg / C2C.CallbackAfterMsgWithDraw).
- A: in transcript → redact; B: not in transcript → system note; C: being processed → interrupt + delayed redact."""
- name = "recall_guard"
- _RECALL_COMMANDS = frozenset({"Group.CallbackAfterRecallMsg", "C2C.CallbackAfterMsgWithDraw"})
- _REDACTED = "[This message was recalled/withdrawn by the sender; original content removed]"
- async def handle(self, ctx: InboundContext, next_fn) -> None:
- cmd = (ctx.push or {}).get("callback_command", "")
- if cmd in self._RECALL_COMMANDS:
- self._handle_recall(ctx, cmd) # terminal: recalls never dispatch
- else:
- await next_fn()
- @staticmethod
- def _build_source(adapter, group_code: str, from_account: str):
- return adapter.build_source(
- chat_id=(f"group:{group_code}" if group_code else f"direct:{from_account}"),
- chat_type="group" if group_code else "dm",
- user_id=from_account or None,
- thread_id="main" if group_code else None,
- )
- @classmethod
- def _resolve_sid(cls, store, adapter, group_code: str, from_account: str) -> str:
- return store.get_or_create_session(cls._build_source(adapter, group_code, from_account)).session_id
- @classmethod
- def _redact(cls, adapter, store, sid: str, transcript: list, entry: dict, ok_msg: str, fail_msg: str, *ok_args) -> None:
- """Blank *entry* in place and persist *transcript* (warns, never raises)."""
- entry["content"] = cls._REDACTED
- try:
- store.rewrite_transcript(sid, transcript, active_only=True)
- logger.info(ok_msg, adapter.name, *ok_args)
- except Exception as exc:
- logger.warning(fail_msg, adapter.name, exc)
- def _handle_recall(self, ctx: InboundContext, cmd: str) -> None:
- adapter = ctx.adapter
- push = ctx.push or {}
- if cmd == "Group.CallbackAfterRecallMsg":
- seq_list = push.get("recall_msg_seq_list") or []
- else:
- mid, seq = push.get("msg_id") or "", push.get("msg_seq")
- seq_list = [{"msg_id": mid, "msg_seq": seq}] if (mid or seq) else []
- if not seq_list:
- logger.debug("[%s] Recall callback with empty seq_list, skipping", adapter.name)
- return
- group_code = (push.get("group_code") or "").strip()
- from_account = (push.get("from_account") or "").strip()
- for seq_entry in seq_list:
- recalled_id = seq_entry.get("msg_id") or str(seq_entry.get("msg_seq") or "")
- if not recalled_id:
- continue
- matched_sk = self._find_processing_session(adapter, recalled_id)
- if matched_sk is not None:
- self._interrupt_for_recall(adapter, matched_sk, recalled_id, group_code, from_account)
- else:
- self._patch_transcript(adapter, recalled_id, group_code, from_account, adapter._msg_content_cache.get(recalled_id))
- # -- Branch C: interrupt currently-processing message ---------------
- @staticmethod
- def _find_processing_session(adapter, recalled_id: str) -> Optional[str]:
- return next((sk for sk, mid in adapter._processing_msg_ids.items()
- if mid == recalled_id and sk in adapter._active_sessions), None)
- @classmethod
- def _interrupt_for_recall(cls, adapter, session_key: str, recalled_id: str, group_code: str, from_account: str) -> None:
- where = f"group {group_code}" if group_code else f"direct chat with {from_account}"
- recall_text = (
- f"[CRITICAL — MESSAGE RECALLED] The user message that triggered your current task "
- f"(message_id=\"{recalled_id}\") in {where} has been recalled/withdrawn by the sender. "
- "IGNORE any prior system note asking you to finish processing tool results — the original request is void. "
- "Do NOT continue the task, do NOT call more tools, do NOT reference the recalled content. "
- "Reply only with a brief acknowledgment such as \"The message has been recalled.\" in the "
- "language the user was using."
- )
- # Set pending + signal directly (bypass handle_message to avoid busy-ack).
- # May overwrite a user message pending in the same ~200ms window — acceptable.
- adapter._pending_messages[session_key] = MessageEvent(
- text=recall_text, message_type=MessageType.TEXT, source=cls._build_source(adapter, group_code, from_account), internal=True)
- active_event = adapter._active_sessions.get(session_key)
- if active_event is not None:
- active_event.set()
- logger.info("[%s] Recall interrupt: msg_id=%s session=%s", adapter.name, recalled_id, session_key[:30])
- # The interrupted turn persists the recalled content *after* our interrupt — redact later.
- recalled_text = adapter._processing_msg_texts.get(session_key, "")
- if recalled_text:
- cls._schedule_content_redact(adapter, session_key, recalled_text, group_code, from_account)
- @classmethod
- def _schedule_content_redact(cls, adapter, session_key: str, recalled_text: str, group_code: str, from_account: str) -> None:
- async def _redact() -> None:
- store = _session_store(adapter)
- if not store:
- return
- try:
- sid = cls._resolve_sid(store, adapter, group_code, from_account)
- except Exception:
- return
- # Poll until the recalled content appears — the interrupted turn hasn't finished writing yet.
- for _ in range(30):
- await asyncio.sleep(0.5)
- try:
- transcript = store.load_transcript(sid)
- except TranscriptReadError as exc:
- # No readable rows means nothing to redact; polling on
- # would just re-log the same failure (#100788).
- logger.warning(
- "[%s] Recall redact: transcript unreadable for "
- "session %s: %s", adapter.name, sid, exc,
- )
- return
- except Exception:
- continue
- for entry in transcript:
- if entry.get("role") == "user" and entry.get("content") == recalled_text:
- cls._redact(adapter, store, sid, transcript, entry, "[%s] Recall redact: session %s",
- "[%s] Recall redact failed: %s", session_key[:30])
- return
- logger.debug("[%s] Recall redact: content not found after polling, session %s", adapter.name, session_key[:30])
- adapter._track_task(asyncio.create_task(_redact()))
- # -- Branch A/B: patch transcript (session idle) --------------------
- @classmethod
- def _patch_transcript(cls, adapter, recalled_id: str, group_code: str,
- from_account: str, recalled_content: Optional[str] = None) -> None:
- store = _session_store(adapter)
- if not store:
- return
- try:
- sid = cls._resolve_sid(store, adapter, group_code, from_account)
- except Exception as exc:
- logger.warning("[%s] Recall: failed to resolve session: %s", adapter.name, exc)
- return
- try:
- # Load transcript from canonical store (state.db). Since PR #29278 added a
- # ``platform_message_id`` column to the messages table and ``append_to_transcript`` wires the
- # incoming dict's ``message_id`` into it, ``load_transcript`` returns rows with ``message_id``
- # set for any message that was observed with one — Branch A1 (exact id match) is the canonical
- # path again.
- transcript = store.load_transcript(sid)
- except TranscriptReadError as exc:
- # Not an empty transcript — the rows are unreadable, so recall has
- # nothing to match against (#100788).
- logger.warning("[%s] Recall: transcript unreadable: %s", adapter.name, exc)
- return
- except Exception as exc:
- logger.warning("[%s] Recall: failed to load transcript: %s", adapter.name, exc)
- return
- # A1: exact platform message_id match; A2: content-match fallback for rows without a
- # platform id (agent-processed @bot messages — run.py doesn't carry msg_id — or pre-column rows).
- target = next((e for e in transcript if e.get("message_id") == recalled_id), None)
- branch_label = "branch A1: id match"
- if target is None and recalled_content:
- target = next((e for e in transcript if e.get("role") == "user" and e.get("content") == recalled_content), None)
- branch_label = "branch A2: content match"
- if target is not None:
- cls._redact(adapter, store, sid, transcript, target, "[%s] Recall: redacted msg_id=%s (%s)",
- "[%s] Recall: rewrite_transcript failed: %s", recalled_id, branch_label)
- return
- # Branch B: not found in transcript → append system note
- store.append_to_transcript(sid, {
- "role": "system", "timestamp": datetime.now(tz=UTC).isoformat(),
- "content": f'[recall] message_id="{recalled_id}" has been recalled; do not quote or reference it.',
- })
- logger.info("[%s] Recall: system note for msg_id=%s (branch B)", adapter.name, recalled_id)
- class SkipSelfMiddleware(InboundMiddleware):
- """Drop the bot's own messages."""
- name = "skip-self"
- @staticmethod
- def _is_self_reference(from_account: str, bot_id: Optional[str]) -> bool:
- return bool(from_account) and from_account == bot_id
- async def handle(self, ctx: InboundContext, next_fn) -> None:
- if self._is_self_reference(ctx.from_account, ctx.adapter._bot_id):
- logger.debug("[%s] Ignoring self-sent message from %s", ctx.adapter.name, ctx.from_account)
- return # Stop pipeline
- await next_fn()
- class ChatRoutingMiddleware(InboundMiddleware):
- """Derive chat_id / chat_type / chat_name from push fields."""
- name = "chat-routing"
- async def handle(self, ctx: InboundContext, next_fn) -> None:
- if ctx.group_code:
- ctx.chat_id, ctx.chat_type, ctx.chat_name = f"group:{ctx.group_code}", "group", ctx.group_name or ctx.group_code
- else:
- ctx.chat_id, ctx.chat_type, ctx.chat_name = f"direct:{ctx.from_account}", "dm", ctx.sender_nickname or ctx.from_account
- await next_fn()
- class AccessPolicy(OwnAccessPolicyMixin):
- """DM / group access rules shared by inbound middleware and outbound ``send_dm``."""
- ALLOW_ALL_ENV_PREFIX = "YUANBAO"
- def __init__(self, dm_policy: str, dm_allow_from: list[str], group_policy: str, group_allow_from: list[str]) -> None:
- self._dm_policy = dm_policy
- self._allow_from = dm_allow_from
- self._group_policy = group_policy
- self._group_allow_from = group_allow_from
- def is_dm_allowed(self, sender_id: str) -> bool:
- """Strict DM authorization — pairing does not imply access."""
- return self._is_dm_allowed(sender_id.strip())
- def is_dm_intake_allowed(self, sender_id: str) -> bool:
- """Whether a DM may reach gateway intake (pairing handshake path)."""
- return self._is_dm_intake_allowed(sender_id)
- def is_group_allowed(self, group_code: str) -> bool:
- """Unlike the shared rule, an ``open`` group still needs the allow-all opt-in: Yuanbao groups
- have no runner-side mention gate, so open-without-opt-in would forward every member."""
- if self._group_policy == "open":
- return self._open_dm_opted_in()
- return self._is_group_allowed(group_code.strip())
- @property
- def dm_policy(self) -> str:
- return self._dm_policy
- @property
- def group_policy(self) -> str:
- return self._group_policy
- class AccessGuardMiddleware(InboundMiddleware):
- """Platform-level DM/group access filter."""
- name = "access-guard"
- async def handle(self, ctx: InboundContext, next_fn) -> None:
- policy: AccessPolicy = ctx.adapter._access_policy
- if ctx.chat_type == "dm" and not policy.is_dm_intake_allowed(ctx.from_account):
- logger.debug("[%s] DM from %s blocked by dm_policy=%s", ctx.adapter.name, ctx.from_account, policy.dm_policy)
- return # Stop pipeline
- if ctx.chat_type == "group" and not policy.is_group_allowed(ctx.group_code):
- logger.debug("[%s] Group %s blocked by group_policy=%s", ctx.adapter.name, ctx.group_code, policy.group_policy)
- return # Stop pipeline
- await next_fn()
- class AutoSetHomeMiddleware(InboundMiddleware):
- """Silently designate the first inbound conversation as home channel (config.yaml + env);
- a group home is upgraded by the first DM. Runs after GroupAtGuard so unaddressed group traffic
- never claims it; only strictly-authorized senders (allowlist / open opt-in / pairing-approved)
- may — intake-only pairing forwards must not."""
- name = "auto-sethome"
- async def handle(self, ctx: InboundContext, next_fn) -> None:
- adapter = ctx.adapter
- if not adapter._auto_sethome_done and adapter._sender_may_designate_home(ctx):
- _cur_home = _yb_secret("YUANBAO_HOME_CHANNEL", "") or ""
- _should_set = not _cur_home or (_cur_home.startswith("group:") and ctx.chat_type == "dm")
- if ctx.chat_type == "dm":
- adapter._auto_sethome_done = True # DM seen — no further upgrades needed
- if _should_set:
- self._persist_home(adapter, ctx)
- await next_fn()
- @staticmethod
- def _persist_home(adapter, ctx: InboundContext) -> None:
- try:
- from gateway.config import HomeChannel, persist_home_channel
- home = HomeChannel(platform=Platform.YUANBAO, chat_id=str(ctx.chat_id), name=str(ctx.chat_name or "Home"))
- # ``platforms.yuanbao.home_channel`` in the owning profile's config.yaml is the durable record
- # ``load_gateway_config`` reads back; the live PlatformConfig is updated so cron/home-channel
- # delivery in THIS process has a target without a restart.
- persist_home_channel(home)
- adapter.config.home_channel = home
- # Under a multiplexed secondary's scope the process env is the DEFAULT profile's; writing there
- # would make this tenant's chat the default profile's cron/notification home.
- if not _profile_scoped():
- os.environ["YUANBAO_HOME_CHANNEL"] = str(ctx.chat_id)
- logger.info("[%s] Auto-sethome: designated %s (%s) as Yuanbao home channel", adapter.name, ctx.chat_id, ctx.chat_name)
- except Exception as e:
- logger.warning("[%s] Auto-sethome failed: %s", adapter.name, e)
- def _iter_custom_elems(msg_body: list) -> Iterator[tuple[Any, dict]]:
- """Yield ``(custom, content)`` for each TIMCustomElem whose ``data`` parses as JSON (any type)."""
- for elem in msg_body or []:
- if not isinstance(elem, dict) or elem.get("msg_type") != "TIMCustomElem":
- continue
- content = elem.get("msg_content", {}) or {}
- data_str = content.get("data", "") if isinstance(content, dict) else ""
- if data_str:
- with contextlib.suppress(json.JSONDecodeError, TypeError):
- yield json.loads(data_str), content
- def _file_name(content: dict) -> str:
- """First non-empty of file_name / fileName / filename, stripped."""
- return (str(content.get("file_name") or "").strip() or str(content.get("fileName") or "").strip()
- or str(content.get("filename") or "").strip())
- def _media_ref(kind: str, url: str, name: str = "") -> dict[str, str]:
- """media_refs entry; ``name`` is only emitted when non-empty."""
- ref: dict[str, str] = {"kind": kind, "url": url}
- if name:
- ref["name"] = name
- return ref
- class ExtractContentMiddleware(InboundMiddleware):
- """Extract raw text, media refs and forwarded records from msg_body."""
- name = "extract-content"
- _CARD_CONTENT_MAX_LENGTH = 1000
- _UNSUPPORTED = "[unsupported message type]"
- @staticmethod
- def _format_shared_link(custom: dict) -> str:
- """elem_type 1010 (share card) → bracket-placeholder text."""
- title, link = custom.get("title", ""), custom.get("link", "")
- lines = [f"[share_card: {title} | {link}]" if link else f"[share_card: {title}]"]
- max_len = ExtractContentMiddleware._CARD_CONTENT_MAX_LENGTH
- preview = next((v for v in (custom.get("card_content"), custom.get("wechat_des")) if v and isinstance(v, str)), None)
- if preview:
- lines.append(f"Preview: {preview[:max_len] + '...(truncated)' if len(preview) > max_len else preview}")
- if link:
- lines.append("[visit link for full content]")
- return "\n".join(lines)
- @staticmethod
- def _format_link_understanding(custom: dict) -> Optional[str]:
- """elem_type 1007 (link understanding card) → bracket-placeholder text."""
- content = custom.get("content")
- if not content:
- return None
- try:
- parsed = json.loads(content)
- link = parsed.get("link") if isinstance(parsed, dict) else None
- except (json.JSONDecodeError, TypeError):
- link = None
- return f"[link: {link} | visit link for full content]" if link and isinstance(link, str) else None
- @staticmethod
- def _parse_resource_id(url: str) -> str:
- """resourceId from a Yuanbao resource URL's query string, or ""."""
- try:
- query = urllib.parse.parse_qs(urllib.parse.urlparse(url).query) if url else {}
- ids = query.get("resourceId") or query.get("resourceid") or []
- return str(ids[0]).strip() if ids else ""
- except Exception:
- return ""
- @staticmethod
- def _pick_image_url(content: dict) -> str:
- """URL of the medium image (index 1), falling back to index 0, else ""."""
- arr = content.get("image_info_array")
- arr = arr if isinstance(arr, list) else []
- image_info = arr[1] if len(arr) > 1 and isinstance(arr[1], dict) else arr[0] if arr and isinstance(arr[0], dict) else None
- return str((image_info or {}).get("url") or "").strip()
- @classmethod
- def _extract_text(cls, msg_body: list) -> str:
- """Plain text from MsgBody: text elems verbatim; media as ``[kind|ybres:RID]`` / ``[kind]``
- (file: ``[file:{name}|ybres:RID]``); TIMFaceElem ``[emoji: name]``; custom elems by
- elem_type. Parts are space-joined."""
- parts: list[str] = []
- for elem in msg_body:
- elem_type: str = elem.get("msg_type", "")
- content: dict = elem.get("msg_content", {})
- if elem_type == _TEXT_ELEM_TYPE:
- if content.get("text", ""):
- parts.append(content["text"])
- elif elem_type in ("TIMImageElem", "TIMSoundElem", "TIMVideoFileElem"):
- kind = {"TIMImageElem": "image", "TIMSoundElem": "voice", "TIMVideoFileElem": "video"}[elem_type]
- url = cls._pick_image_url(content) if kind == "image" else str(content.get("url") or "").strip()
- rid = cls._parse_resource_id(url)
- parts.append(f"[{kind}|ybres:{rid}]" if rid else f"[{kind}]")
- elif elem_type == "TIMFileElem":
- filename = content.get("file_name", content.get("fileName", content.get("filename", "")))
- rid = cls._parse_resource_id(str(content.get("url") or "").strip())
- if rid:
- parts.append(f"[file:{filename}|ybres:{rid}]" if filename else f"[file|ybres:{rid}]")
- else:
- parts.append(f"[file: {filename}]" if filename else "[file]")
- elif elem_type == "TIMCustomElem":
- parts.append(cls._custom_elem_text(content.get("data", "")))
- elif elem_type == "TIMFaceElem":
- face_name = ""
- if content.get("data", ""):
- try:
- face_name = (json.loads(content["data"]).get("name") or "").strip()
- except (json.JSONDecodeError, TypeError, AttributeError):
- pass
- parts.append(f"[emoji: {face_name}]" if face_name else "[emoji]")
- elif elem_type:
- parts.append(f"[{elem_type}]") # unknown element type — keep as placeholder
- return " ".join(parts)
- @classmethod
- def _custom_elem_text(cls, data_val: str) -> str:
- """Text for a TIMCustomElem by elem_type: 1002 mention, 1010 share card, 1007 link card,
- 1009 forwarded chat-record summary; malformed JSON is passed through verbatim."""
- if not data_val:
- return cls._UNSUPPORTED
- try:
- custom = json.loads(data_val)
- except (json.JSONDecodeError, TypeError):
- return data_val
- if not isinstance(custom, dict):
- return cls._UNSUPPORTED
- ctype = custom.get("elem_type")
- if ctype == 1002:
- return custom.get("text", "[mention]")
- if ctype == 1009:
- return custom.get("text", "[chat record]")
- if ctype == 1010:
- return cls._format_shared_link(custom)
- return (cls._format_link_understanding(custom) if ctype == 1007 else None) or cls._UNSUPPORTED
- @staticmethod
- def _rewrite_slash_command(text: str) -> str:
- """Strip; convert a leading full-width slash (Chinese IME) to ASCII so commands match."""
- text = text.strip()
- return '/' + text[1:] if text.startswith('\uff0f') else text
- @staticmethod
- def _extract_inbound_media_refs(msg_body: list) -> list[dict[str, str]]:
- """Inbound image/file refs: ``[{"kind": "image", "url": ...}, {"kind": "file", "url": ..., "name": ...}]``."""
- refs: list[dict[str, str]] = []
- for elem in msg_body or []:
- if not isinstance(elem, dict):
- continue
- msg_type = elem.get("msg_type", "")
- content = elem.get("msg_content", {}) or {}
- if not isinstance(content, dict):
- continue
- if msg_type == "TIMImageElem":
- image_url = ExtractContentMiddleware._pick_image_url(content)
- if image_url:
- refs.append(_media_ref("image", image_url))
- elif msg_type == "TIMFileElem":
- file_url = str(content.get("url") or "").strip()
- if file_url:
- refs.append(_media_ref("file", file_url, _file_name(content)))
- return refs
- @staticmethod
- def _extract_forwarded_records(msg_body: list, user_id: str = "") -> Optional[dict]:
- """ForwardMsgData for elem_type 1009 (WeChat forward), or None. Payload lives in
- ``msg_content.ext_map`` (pb field 999) under ``wexin_forward_msg_[id]_[userid]`` keys as
- base64 protobuf (NOT JSON); the first entry decoding to ``sub_type == 1`` wins."""
- for custom, content in _iter_custom_elems(msg_body):
- if not (isinstance(custom, dict) and custom.get("elem_type") == 1009):
- continue
- ext_map = content.get("ext_map") or {}
- if not isinstance(ext_map, dict) or not ext_map:
- return None
- for key, value in ext_map.items():
- if not key.startswith("wexin_forward_msg_") or not isinstance(value, str) or not value:
- continue
- with contextlib.suppress(binascii.Error, ValueError):
- data = decode_forward_msg_data(base64.b64decode(value))
- if isinstance(data, dict) and data.get("sub_type") == 1:
- return data
- return None
- async def handle(self, ctx: InboundContext, next_fn) -> None:
- ctx.raw_text = self._rewrite_slash_command(self._extract_text(ctx.msg_body))
- ctx.media_refs = self._extract_inbound_media_refs(ctx.msg_body)
- ctx.forwarded_records = self._extract_forwarded_records(ctx.msg_body, ctx.from_account)
- await next_fn()
- class PlaceholderFilterMiddleware(InboundMiddleware):
- """Skip pure placeholder messages (e.g. '[image]' with no media)."""
- name = "placeholder-filter"
- SKIPPABLE_PLACEHOLDERS: frozenset = frozenset({"[image]", "[图片]", "[file]", "[文件]", "[video]", "[视频]", "[voice]", "[语音]"})
- @classmethod
- def is_skippable_placeholder(cls, text: str, media_count: int = 0) -> bool:
- return media_count <= 0 and text.strip() in cls.SKIPPABLE_PLACEHOLDERS
- async def handle(self, ctx: InboundContext, next_fn) -> None:
- if self.is_skippable_placeholder(ctx.raw_text, len(ctx.media_refs)):
- logger.debug("[%s] Skipping placeholder message: %r", ctx.adapter.name, ctx.raw_text)
- return # Stop pipeline
- await next_fn()
- class OwnerCommandMiddleware(InboundMiddleware):
- """Bot-owner slash commands in groups: allowlisted commands skip @Bot; non-owner attempts are rejected."""
- name = "owner-command"
- ALLOWLIST: frozenset = frozenset({"/new", "/reset", "/retry", "/undo", "/stop", "/approve", "/deny", "/bg", "/btw", "/queue", "/q"})
- _rewrite_slash_command = staticmethod(ExtractContentMiddleware._rewrite_slash_command)
- @classmethod
- def _detect_owner_command(cls, *, push: dict, msg_body: list, chat_type: str, from_account: str) -> tuple[Optional[str], Optional[str], bool]:
- """→ (cmd, cmd_line, is_owner); (None, None, False) when not an allowlisted command."""
- if chat_type != "group" or not cls.ALLOWLIST:
- return None, None, False
- # Only recognise commands when there is exactly one text segment.
- text_elems = [e for e in (msg_body or []) if e.get("msg_type") == _TEXT_ELEM_TYPE]
- if len(text_elems) != 1:
- return None, None, False
- cmd_line = cls._rewrite_slash_command((text_elems[0].get("msg_content") or {}).get("text", ""))
- if not cmd_line.startswith("/"):
- return None, None, False
- cmd = cmd_line.split(maxsplit=1)[0].lower()
- if cmd not in cls.ALLOWLIST:
- return None, None, False
- # Owner ⇔ push.from_account == push.bot_owner_id; these commands are privileged
- # (/approve, /stop, /reset…) so a non-owner must never run them.
- owner_id = str((push or {}).get("bot_owner_id") or "").strip()
- return cmd, cmd_line, bool(owner_id) and owner_id == from_account
- async def handle(self, ctx: InboundContext, next_fn) -> None:
- adapter = ctx.adapter
- matched_cmd, cmd_line, is_owner = self._detect_owner_command(
- push=ctx.push, msg_body=ctx.msg_body, chat_type=ctx.chat_type, from_account=ctx.from_account,
- )
- if matched_cmd and not is_owner:
- logger.info("[%s] Reject non-owner slash command: chat=%s from=%s cmd=%s", adapter.name, ctx.chat_id, ctx.from_account, matched_cmd)
- adapter._track_task(asyncio.create_task(
- adapter.send(ctx.chat_id, t("platform.yuanbao.owner_command_denied", command=matched_cmd)),
- name=f"yuanbao-owner-cmd-denial-{matched_cmd}"))
- return # Stop pipeline
- if matched_cmd and is_owner and cmd_line:
- logger.info("[%s] Bot owner slash command: chat=%s from=%s cmd=%s", adapter.name, ctx.chat_id, ctx.from_account, matched_cmd)
- ctx.owner_command = matched_cmd
- ctx.raw_text = cmd_line # clean command text
- await next_fn()
- class BuildSourceMiddleware(InboundMiddleware):
- name = "build-source"
- async def handle(self, ctx: InboundContext, next_fn) -> None:
- ctx.source = ctx.adapter.build_source(
- chat_id=ctx.chat_id, chat_type=ctx.chat_type, chat_name=ctx.chat_name,
- user_id=ctx.from_account or None, user_name=ctx.sender_nickname or ctx.from_account,
- thread_id="main" if ctx.chat_type == "group" else None,
- )
- await next_fn()
- class GroupAtGuardMiddleware(InboundMiddleware):
- """Group chat: observe non-@bot messages into the transcript; only @Bot (or owner commands) proceed."""
- name = "group-at-guard"
- @staticmethod
- def _iter_bot_mentions(msg_body: list, bot_id: Optional[str]) -> Iterator[dict]:
- """Yield @bot elems: TIMCustomElem whose data JSON has elem_type 1002 and user_id == bot_id."""
- if not bot_id:
- return
- for custom, _content in _iter_custom_elems(msg_body):
- if custom.get("elem_type") == 1002 and custom.get("user_id") == bot_id:
- yield custom
- @classmethod
- def _is_at_bot(cls, msg_body: list, bot_id: Optional[str]) -> bool:
- return any(True for _ in cls._iter_bot_mentions(msg_body, bot_id))
- @classmethod
- def _extract_bot_mention_text(cls, msg_body: list, bot_id: Optional[str]) -> str:
- """Display text used to @-mention this bot (e.g. ``@yuanbao-bot``), or ""."""
- return next((t for t in (str(c.get("text") or "").strip() for c in cls._iter_bot_mentions(msg_body, bot_id)) if t), "")
- @staticmethod
- def _build_group_channel_prompt(msg_body: list, bot_id: Optional[str]) -> str:
- """Per-turn group-chat prompt that highlights which message to respond to."""
- bot_mention = GroupAtGuardMiddleware._extract_bot_mention_text(msg_body, bot_id) or "unknown"
- return (
- "You are handling a Yuanbao group chat message.\n"
- f"- Your identity: user_id={bot_id or 'unknown'}, @-mention name in this group={bot_mention}\n"
- "- Lines in history prefixed with `[nickname|user_id]` are observed group context "
- "and are not necessarily addressed to you.\n"
- "- Treat only the current new message as a request explicitly directed at you, "
- "and answer it directly."
- )
- @classmethod
- def _observe_group_message(cls, adapter, source, sender_display: str, text: str, *, ctx: InboundContext,
- msg_id: Optional[str] = None, forwarded_records: Optional[dict] = None) -> None:
- """Record a group message as ``role: user`` ``[nickname|user_id]\\n<content>`` without
- invoking the agent, so later @bot turns see the full conversation."""
- store = _session_store(adapter)
- if not store:
- return
- try:
- session_entry = store.get_or_create_session(source)
- body_text = text
- if forwarded_records:
- summary = ForwardedRecordsParseMiddleware.build_forward_text(forwarded_records, ctx=ctx, is_dispatch=False)
- if summary:
- body_text = f"{text}\n{summary}" if text else summary
- entry: dict = {
- "role": "user", "content": f"[{sender_display}|{source.user_id or 'unknown'}]\n{body_text}",
- "timestamp": datetime.now(tz=UTC).isoformat(), "observed": True,
- }
- if msg_id:
- entry["message_id"] = msg_id
- store.append_to_transcript(session_entry.session_id, entry)
- except Exception as exc:
- logger.warning("[%s] Failed to observe group message: %s", adapter.name, exc)
- async def handle(self, ctx: InboundContext, next_fn) -> None:
- adapter = ctx.adapter
- if ctx.chat_type == "group" and not ctx.owner_command and not self._is_at_bot(ctx.msg_body, adapter._bot_id):
- self._observe_group_message(
- adapter, ctx.source, ctx.sender_nickname or ctx.from_account, ctx.raw_text,
- msg_id=ctx.msg_id or None, forwarded_records=ctx.forwarded_records, ctx=ctx,
- )
- logger.info("[%s] Group message observed (no @bot): chat=%s from=%s", adapter.name, ctx.chat_id, ctx.from_account)
- return # Stop pipeline — message observed but not dispatched
- await next_fn()
- class GroupAttributionMiddleware(InboundMiddleware):
- """Group @bot turns: build channel_prompt, rewrite raw_text to ``[nickname|user_id]\\n<content>``
- (matches observed-history format) and clear ``source.user_name`` to suppress the runner's
- ``[user_name]`` prefix."""
- name = "group-attribution"
- async def handle(self, ctx: InboundContext, next_fn) -> None:
- if ctx.chat_type == "group" and not ctx.owner_command:
- ctx.channel_prompt = GroupAtGuardMiddleware._build_group_channel_prompt(ctx.msg_body, ctx.adapter._bot_id)
- ctx.raw_text = f"[{ctx.sender_nickname or ctx.from_account or 'unknown'}|{ctx.from_account or 'unknown'}]\n{ctx.raw_text}"
- if ctx.source is not None:
- ctx.source = dataclasses.replace(ctx.source, user_name=None)
- await next_fn()
- class YuanbaoMessageType(Enum):
- CHAT_RECORD = "chat_record" # yuanbao-local subtype; coerced back to MessageType in DispatchMiddleware
- _ELEM_MESSAGE_TYPES = {"TIMImageElem": MessageType.PHOTO, "TIMSoundElem": MessageType.VOICE,
- "TIMVideoFileElem": MessageType.VIDEO, "TIMFileElem": MessageType.DOCUMENT}
- class ClassifyMessageTypeMiddleware(InboundMiddleware):
- """MessageType (or yuanbao-local YuanbaoMessageType) from text and msg_body elements."""
- name = "classify-msg-type"
- @staticmethod
- def _classify(text: str, msg_body: list):
- if text.startswith("/"):
- return MessageType.COMMAND
- for elem in msg_body:
- etype = elem.get("msg_type", "")
- mapped = _ELEM_MESSAGE_TYPES.get(etype)
- if mapped is not None:
- return mapped
- if etype == "TIMCustomElem":
- try:
- custom = json.loads((elem.get("msg_content") or {}).get("data", ""))
- except (json.JSONDecodeError, TypeError):
- custom = None
- if isinstance(custom, dict) and custom.get("elem_type") == 1009:
- return YuanbaoMessageType.CHAT_RECORD
- return MessageType.TEXT
- async def handle(self, ctx: InboundContext, next_fn) -> None:
- ctx.msg_type = self._classify(ctx.raw_text, ctx.msg_body)
- await next_fn()
- class QuoteContextMiddleware(InboundMiddleware):
- """Extract quote/reply context from cloud_custom_data."""
- name = "quote-context"
- def _extract_quote_context(self, cloud_custom_data: str) -> tuple[Optional[str], Optional[str]]:
- """(quote_id, quote_text) from cloud_custom_data → MessageEvent.reply_to_*."""
- try:
- parsed = json.loads(cloud_custom_data) if cloud_custom_data else None
- except (json.JSONDecodeError, TypeError):
- parsed = None
- quote = parsed.get("quote") if isinstance(parsed, dict) else None
- if not isinstance(quote, dict):
- return None, None
- quote_id = str(quote.get("id") or "").strip() or None
- desc = str(quote.get("desc") or "").strip()
- sender = str(quote.get("sender_nickname") or quote.get("sender_id") or "").strip()
- return quote_id, (f"{sender}: {desc}" if sender else desc) if desc else None
- async def _extract_media_refs_from_transcript(self, ctx: InboundContext) -> list[tuple[str, str, str]]:
- """``(rid, kind, filename)`` for ybres anchors in the quoted transcript message; [] when
- there is no reply_to id, no store/source, or no resolvable anchors."""
- if ctx.reply_to_message_id is None:
- return []
- adapter = ctx.adapter
- media_refs: list[tuple[str, str, str]] = []
- try:
- store = _session_store(adapter)
- if not store or ctx.source is None:
- return []
- history = store.load_transcript(store.get_or_create_session(ctx.source).session_id)
- for msg in reversed(history or []):
- mid = msg.get("message_id", "")
- if not mid or mid != ctx.reply_to_message_id:
- continue
- _content = msg.get("content", "")
- if isinstance(_content, str) and "|ybres:" in _content:
- media_refs.extend(_iter_ybres_refs(_YB_RES_REF_RE.finditer(_content)))
- break
- except TranscriptReadError as exc:
- # Quote resolution degrades to "no refs" rather than pretending
- # the quoted message was never seen (#100788).
- logger.warning(
- "[%s] quote transcript lookup: transcript unreadable: %s",
- getattr(adapter, "name", "yuanbao"), exc,
- )
- except Exception as exc:
- logger.warning("[%s] quote transcript lookup failed: %s", getattr(adapter, "name", "yuanbao"), exc)
- return media_refs
- async def handle(self, ctx: InboundContext, next_fn) -> None:
- ctx.reply_to_message_id, ctx.reply_to_text = self._extract_quote_context(ctx.cloud_custom_data)
- ctx.quote_media_refs = await self._extract_media_refs_from_transcript(ctx)
- await next_fn()
- class ForwardedRecordsParseMiddleware(InboundMiddleware):
- """Deep-parse WeChat forwarded chat records (elem_type 1009) on ``ctx.forwarded_records``:
- render media as ``[kind|ybres:RID]``, append refs to ``ctx.media_refs`` and rewrite raw_text.
- No run-time fallback for earlier forwards — GroupAtGuard already rendered summaries at observe
- time. On any failure raw_text is left untouched."""
- name = "forwarded-records-parse"
- FORWARD_MSG_TEXT_MAX_CHARS = 1000 # per-record text cap; record count is NOT capped
- async def handle(self, ctx: InboundContext, next_fn) -> None:
- try:
- if ctx.forwarded_records:
- await self._send_loading_heartbeat(ctx)
- ctx.raw_text = self.build_forward_text(ctx.forwarded_records, ctx=ctx, is_dispatch=True)
- except Exception as exc:
- logger.warning("[%s] forwarded-records deep parse failed: %s", getattr(ctx.adapter, "name", "yuanbao"), exc)
- await next_fn()
- @staticmethod
- async def _send_loading_heartbeat(ctx: InboundContext) -> None:
- """Best-effort RUNNING heartbeat so the user sees a loading bubble."""
- with contextlib.suppress(Exception):
- await ctx.adapter._outbound.heartbeat.send_heartbeat_once(ctx.chat_id, WS_HEARTBEAT_RUNNING)
- @classmethod
- def _media_marker(cls, media: dict, plain_text: str = "") -> tuple[str, Optional[dict[str, str]]]:
- """One ``multimedia`` entry → ``(marker, ref)``: ``[kind|ybres:RID]`` + media_refs dict when a
- RID/URL is usable, else a plain ``[kind] name`` marker and ``ref=None``."""
- media_type = (media.get("type", "") or media.get("doc_type", "")).strip().lower()
- url = str(media.get("url") or "").strip()
- file_name = str(media.get("file_name") or "").strip()
- # media_id is directly usable as a ybres RID; else parse resourceId from the URL.
- rid = str(media.get("media_id") or "").strip() or ExtractContentMiddleware._parse_resource_id(url)
- kind = {"image": "image", "file": "file", "document": "file", "code": "file", "video": "video"}.get(media_type)
- if kind and url and rid:
- return f"[{kind}|ybres:{rid}] {file_name}".rstrip(), _media_ref(kind, url, file_name if kind == "file" else "")
- if kind == "image":
- return f"[image] {file_name or plain_text}".rstrip(), None
- if kind == "file":
- return f"[file] {file_name}".rstrip(), None
- if kind == "video":
- return f"[video] {file_name or url}".rstrip(), None
- if media_type == "url": # link share (e.g. WeChat article) — keep URL for the agent
- return f"[link] {file_name or str(media.get('title') or '')} {url}".rstrip(), None
- return f"[{media_type or 'media'}] {url or file_name}".rstrip(), None
- @classmethod
- def _walk_forward_msgs(cls, forward_data: dict) -> Iterator[tuple[str, str, list[dict[str, str]]]]:
- """Yield ``(sender, body, refs)`` per ``ForwardMsgData['msg']`` record; body capped at
- FORWARD_MSG_TEXT_MAX_CHARS. ``refs`` keeps textual order — PatchAnchorsMiddleware relies on it."""
- for msg in (forward_data.get("msg") if isinstance(forward_data, dict) else None) or []:
- if not isinstance(msg, dict):
- continue
- plain_text = msg.get("plainText", "")
- refs: list[dict[str, str]] = []
- parts: list[str] = []
- for mc in msg.get("msgContent", []) or []:
- if not isinstance(mc, dict):
- continue
- mc_type = mc.get("type", 0) # EnumMsgContentType: 1 TEXT, 2 MULTIMEDIA, 3 nested FORWARD
- if mc_type == 1:
- parts.append(mc.get("text", ""))
- elif mc_type == 2:
- for media in mc.get("multimedia", []) or []:
- if isinstance(media, dict):
- marker, ref = cls._media_marker(media, plain_text)
- parts.append(marker)
- if ref is not None:
- refs.append(ref)
- elif mc_type == 3:
- parts.append("[嵌套聊天记录]")
- elif plain_text:
- parts.append(plain_text)
- rendered = " ".join(p for p in parts if p) or plain_text
- if len(rendered) > cls.FORWARD_MSG_TEXT_MAX_CHARS:
- rendered = rendered[: cls.FORWARD_MSG_TEXT_MAX_CHARS] + "…(已截断)"
- yield msg.get("sender", ""), rendered, refs
- @classmethod
- def build_forward_text(cls, forward_data: dict, *, ctx: InboundContext, is_dispatch: bool) -> str:
- """Render ``ForwardMsgData`` as ``发送人:正文`` lines with media markers. When ``is_dispatch``,
- refs go to ``ctx.media_refs`` and a ``用户附言:`` footer is added (observe-time callers skip both)."""
- lines = [f"当前用户的昵称为{ctx.sender_nickname or '用户'}", "以下为用户的聊天记录"]
- for sender, body, refs in cls._walk_forward_msgs(forward_data):
- lines.append(f"{sender}:{body}")
- if is_dispatch:
- ctx.media_refs.extend(refs)
- text = "\n".join(lines)
- if is_dispatch and ctx.raw_text.strip():
- text += f"\n\n用户附言:{ctx.raw_text.strip()}"
- return text
- class MediaResolveMiddleware(InboundMiddleware):
- """Resolve inbound media references to local cached files. Yuanbao COS hostnames resolve to
- private IPs (tripping vision_tools' SSRF guard), so we download ourselves and hand the model
- local paths."""
- name = "media-resolve"
- # Resource download cache keyed by resourceId: rid -> (local_path, mime, ts)
- _resource_cache: ClassVar[dict[str, tuple[str, str, float]]] = {}
- _RESOURCE_CACHE_TTL_S: ClassVar[int] = 24 * 60 * 60
- _RESOURCE_CACHE_MAX_SIZE: ClassVar[int] = 256
- @classmethod
- def _get_cached_resource(cls, resource_id: str) -> Optional[tuple[str, str]]:
- """Cached ``(local_path, mime)`` if unexpired and the file still exists (cache dir may be swept)."""
- entry = cls._resource_cache.get(resource_id) if resource_id else None
- if entry is None:
- return None
- local_path, mime, ts = entry
- if time.time() - ts > cls._RESOURCE_CACHE_TTL_S or not os.path.isfile(local_path):
- cls._resource_cache.pop(resource_id, None)
- return None
- return local_path, mime
- @classmethod
- def _put_cached_resource(cls, resource_id: str, local_path: str, mime: str) -> None:
- """Cache a download result; evicts the oldest 25% when at capacity."""
- if not resource_id:
- return
- if len(cls._resource_cache) >= cls._RESOURCE_CACHE_MAX_SIZE:
- sorted_keys = sorted(cls._resource_cache, key=lambda k: cls._resource_cache[k][2])
- for k in sorted_keys[: cls._RESOURCE_CACHE_MAX_SIZE // 4]:
- cls._resource_cache.pop(k, None)
- cls._resource_cache[resource_id] = (local_path, mime, time.time())
- @classmethod
- def _append_cached_resource(cls, adapter, resource_id: str, media_paths: list[str], mimes: list[str]) -> bool:
- """Append a cached resource to the output lists; False on miss."""
- hit = cls._get_cached_resource(resource_id)
- if hit is None:
- return False
- logger.debug("[%s] resource cache hit: rid=%s path=%s", adapter.name, resource_id, hit[0])
- media_paths.append(hit[0])
- mimes.append(hit[1])
- return True
- @staticmethod
- def _guess_image_ext_from_url(url: str) -> str:
- ext = os.path.splitext(urllib.parse.urlparse(url).path)[1].lower()
- return ext if ext in {".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp", ".heic", ".tiff"} else ".jpg"
- @staticmethod
- async def _fetch_resource_url(adapter, resource_id: str) -> str:
- """Exchange a ``resourceId`` for a direct download URL via ``/api/resource/v1/download``,
- with a single 401-retry after token force-refresh. Raises on failure."""
- resource_id = resource_id.strip()
- if not resource_id:
- raise RuntimeError("missing resource_id")
- def _auth_headers(token_data: dict, fallback_source: str) -> Optional[dict]:
- token = str(token_data.get("token") or "").strip()
- bot_id = str(token_data.get("bot_id") or adapter._bot_id or adapter._app_key).strip()
- if not token or not bot_id:
- return None
- source = str(token_data.get("source") or fallback_source).strip() or "web"
- return {"Content-Type": "application/json", "X-ID": bot_id, "X-Token": token, "X-Source": source}
- headers = _auth_headers(await adapter._get_cached_token(), "web")
- if headers is None:
- raise RuntimeError("missing token or bot_id for resource download")
- api_url = f"{adapter._api_domain}/api/resource/v1/download"
- async with httpx.AsyncClient(timeout=15.0, follow_redirects=True) as client:
- for attempt in range(2):
- resp = await client.get(api_url, params={"resourceId": resource_id}, headers=headers)
- if resp.status_code == 401 and attempt == 0:
- token_data = await SignManager.force_refresh(adapter._app_key, adapter._app_secret, adapter._api_domain)
- headers = _auth_headers(token_data, headers["X-Source"] or "web")
- if headers is None:
- break
- continue
- resp.raise_for_status()
- payload = resp.json()
- code = payload.get("code")
- if code not in {None, 0}:
- raise RuntimeError(f"resource/v1/download failed: code={code}, msg={payload.get('msg', '')}")
- data = payload.get("data") if isinstance(payload.get("data"), dict) else payload
- real_url = str((data or {}).get("url") or (data or {}).get("realUrl") or "").strip()
- if real_url:
- return real_url
- raise RuntimeError("resource/v1/download missing url/realUrl")
- raise RuntimeError("resource/v1/download did not return a URL")
- @staticmethod
- async def _resolve_download_url(adapter, url: str) -> str:
- """Resolve a Yuanbao resource placeholder URL (``…/api/resource/download?resourceId=…``,
- which 401s on direct GET) to a fetchable URL via the business API; passthrough otherwise."""
- resource_id = ExtractContentMiddleware._parse_resource_id(url)
- if not resource_id:
- return url
- try:
- return await MediaResolveMiddleware._fetch_resource_url(adapter, resource_id)
- except Exception:
- return url
- @classmethod
- async def _download_and_cache(
- cls, adapter, *, fetch_url: str, kind: str,
- file_name: Optional[str] = None, log_tag: str = "", resource_id: str = "",
- ) -> Optional[tuple[str, str]]:
- """Download a Yuanbao resource into the local media cache → ``(local_path, mime)`` or None.
- A *resource_id* is checked against the in-memory cache first."""
- if resource_id:
- hit = cls._get_cached_resource(resource_id)
- if hit is not None:
- logger.debug("[%s] resource cache hit: rid=%s path=%s", adapter.name, resource_id, hit[0])
- return hit
- try:
- file_bytes, content_type = await media_download_url(fetch_url, max_size_mb=adapter.MEDIA_MAX_SIZE_MB)
- except Exception as exc:
- logger.warning("[%s] inbound media download failed: kind=%s %s err=%s", adapter.name, kind, log_tag, exc)
- return None
- if kind == "image":
- ext = cls._guess_image_ext_from_url(fetch_url)
- try:
- local_path = await cache_image_from_bytes_async(file_bytes, ext=ext)
- except ValueError as exc:
- logger.warning("[%s] inbound image cache rejected: %s err=%s", adapter.name, log_tag, exc)
- return None
- mime = guess_mime_type(f"image{ext}")
- if not mime.startswith("image/"):
- mime = content_type if content_type.startswith("image/") else "image/jpeg"
- elif kind == "video":
- # Yuanbao video resources carry no reliable extension; default to mp4.
- local_path = await cache_video_from_bytes_async(file_bytes)
- mime = guess_mime_type(local_path) or (content_type if content_type.startswith("video/") else "video/mp4")
- else: # file
- file_name = file_name or os.path.basename(urllib.parse.urlparse(fetch_url).path) or "file"
- try:
- local_path = await cache_document_from_bytes_async(file_bytes, file_name)
- except Exception as exc:
- logger.warning("[%s] inbound file cache failed: %s err=%s", adapter.name, log_tag, exc)
- return None
- mime = guess_mime_type(file_name) or content_type or "application/octet-stream"
- cls._put_cached_resource(resource_id, local_path, mime)
- return local_path, mime
- @classmethod
- async def _resolve_media_urls(cls, adapter, media_refs: list[dict[str, str]]) -> tuple[list[str], list[str]]:
- """Resolve inbound media refs → (local_paths, mime_types); same bounded-concurrency,
- order-preserving, exception-isolated contract as :meth:`_resolve_ybres_refs`."""
- media_urls: list[str] = []
- media_types: list[str] = []
- active: list[tuple[str, str, str, str]] = [] # (kind, filename, rid, url)
- for ref in media_refs:
- kind = str(ref.get("kind") or "").strip().lower()
- url = str(ref.get("url") or "").strip()
- if kind not in _RESOLVABLE_MEDIA_KINDS or not url:
- continue
- rid = ExtractContentMiddleware._parse_resource_id(url)
- if rid and cls._append_cached_resource(adapter, rid, media_urls, media_types):
- continue
- active.append((kind, str(ref.get("name") or "").strip(), rid or "", url))
- if active:
- await cls._gather_resolve(
- adapter, active, "media", media_urls, media_types,
- get_url=lambda url: cls._resolve_download_url(adapter, url),
- fail_fmt="[%s] inbound media resolve failed: kind=%s url=%s err=%s", fail_args=lambda kind, url: (kind, url),
- crash_fmt="[%s] inbound media resolve crashed: kind=%s url=%s err=%s", crash_args=lambda kind, url: (kind, url[:80]),
- log_tag=lambda url: f"placeholder_url={url[:80]}",
- )
- return media_urls, media_types
- @classmethod
- async def _gather_resolve(cls, adapter, active, scope, out_paths, out_mimes, *,
- get_url, fail_fmt, fail_args, crash_fmt, crash_args, log_tag) -> None:
- """Resolve ``(kind, filename, rid, key)`` items under bounded concurrency — ``await get_url(key)``
- then download+cache — appending successes in input order. ``return_exceptions=True`` isolates
- per-item failures; the batch summary line keeps stable fields (concurrency vs elapsed_ms) for
- offline aggregation."""
- semaphore = asyncio.Semaphore(adapter.media_resolve_concurrency)
- async def _one(kind: str, filename: str, rid: str, key: str) -> Optional[tuple[str, str]]:
- async with semaphore:
- try:
- fetch_url = await get_url(key)
- except Exception as exc:
- logger.warning(fail_fmt, adapter.name, *fail_args(kind, key), exc)
- return None
- return await cls._download_and_cache(
- adapter, fetch_url=fetch_url, kind=kind, file_name=filename or None, log_tag=log_tag(key), resource_id=rid,
- )
- _t0 = time.monotonic()
- results = await asyncio.gather(*(_one(*item) for item in active), return_exceptions=True)
- _elapsed_ms = int((time.monotonic() - _t0) * 1000)
- _failed = 0
- for (kind, _filename, _rid, key), result in zip(active, results):
- if isinstance(result, BaseException):
- logger.warning(crash_fmt, adapter.name, *crash_args(kind, key), result)
- if result is None or isinstance(result, BaseException):
- _failed += 1
- else:
- out_paths.append(result[0])
- out_mimes.append(result[1])
- logger.info(
- "[%s] media resolve batch: scope=%s concurrency=%d total=%d ok=%d failed=%d elapsed_ms=%d",
- adapter.name, scope, adapter.media_resolve_concurrency, len(active), len(out_paths), _failed, _elapsed_ms,
- )
- @classmethod
- async def _resolve_ybres_refs(cls, adapter, refs: list[tuple[str, str, str]], *, log_prefix: str) -> tuple[list[str], list[str]]:
- """Resolve ``(rid, kind, filename)`` ybres tuples to local paths (bounded concurrency,
- input order preserved, per-rid failures isolated). Cache hits are served without a fetch."""
- media_paths: list[str] = []
- mimes: list[str] = []
- active = [(kind, filename, rid, rid) for rid, kind, filename in refs
- if kind in _RESOLVABLE_MEDIA_KINDS and not cls._append_cached_resource(adapter, rid, media_paths, mimes)]
- if active:
- await cls._gather_resolve(
- adapter, active, "ybres", media_paths, mimes,
- get_url=lambda rid: cls._fetch_resource_url(adapter, rid),
- fail_fmt="[%s] %s resolve failed: rid=%s kind=%s err=%s", fail_args=lambda kind, rid: (log_prefix, rid, kind),
- crash_fmt="[%s] %s resolve crashed: rid=%s kind=%s err=%s", crash_args=lambda kind, rid: (log_prefix, rid, kind),
- log_tag=lambda rid: f"{log_prefix} rid={rid}",
- )
- return media_paths, mimes
- @classmethod
- async def _collect_observed_media(cls, adapter, source) -> tuple[list[str], list[str]]:
- """Resolve recent observed image/file anchors from the transcript into ``(local_paths, mimes)``."""
- store = _session_store(adapter)
- if not store:
- return [], []
- try:
- history = store.load_transcript(store.get_or_create_session(source).session_id)
- except TranscriptReadError as exc:
- # Hydrate nothing rather than silently acting as if the session had no observed media.
- logger.warning("[%s] Observed-media hydration: transcript unreadable: %s", adapter.name, exc)
- return [], []
- except Exception as exc:
- logger.warning("[%s] Observed-media hydration setup failed: %s", adapter.name, exc)
- return [], []
- # Walk newest→oldest (matches within a message too) so the per-turn cap keeps the
- # *latest* refs; ``order`` is reversed back to chronological before resolving.
- order: list[tuple[str, str, str]] = [] # (rid, kind, filename)
- seen: set = set()
- for msg in reversed((history or [])[-OBSERVED_MEDIA_BACKFILL_LOOKBACK:]):
- content = msg.get("content")
- if not isinstance(content, str) or "|ybres:" not in content:
- continue
- for rid, kind, filename in _iter_ybres_refs(reversed(list(_YB_RES_REF_RE.finditer(content)))):
- if rid not in seen:
- seen.add(rid)
- order.append((rid, kind, filename))
- if len(order) >= OBSERVED_MEDIA_BACKFILL_MAX_RESOLVE_PER_TURN:
- break
- if len(order) >= OBSERVED_MEDIA_BACKFILL_MAX_RESOLVE_PER_TURN:
- break
- if not order:
- return [], []
- return await cls._resolve_ybres_refs(adapter, order[::-1], log_prefix="observed-media")
- @classmethod
- async def _resolve_quote_media(cls, adapter, quote_media_refs: list[tuple[str, str, str]]) -> tuple[list[str], list[str]]:
- """Resolve ybres anchors of the quoted message (from QuoteContextMiddleware)."""
- return await cls._resolve_ybres_refs(adapter, quote_media_refs, log_prefix="quote")
- @staticmethod
- def _collect_quote_local_media(ctx: InboundContext) -> tuple[list[str], list[str]]:
- """DM quote fallback: ``(local_paths, mimes)`` for media PatchAnchorsMiddleware already
- rewrote to ``[image: /path]`` / ``[file: name → /path]`` on the original turn. Unresolved
- anchors were that turn's failure — no re-download here."""
- paths: list[str] = []
- mimes: list[str] = []
- cache = getattr(ctx.adapter, "_msg_content_cache", None)
- text = cache.get(ctx.reply_to_message_id) if ctx.reply_to_message_id and cache else None
- for m in _YB_LOCAL_MEDIA_RE.finditer(text if isinstance(text, str) else ""):
- kind = (m.group(1) or "").strip().lower()
- path = (m.group(2) or "").strip()
- if not path or path in paths or not os.path.exists(path):
- continue
- paths.append(path)
- mimes.append(guess_mime_type(os.path.basename(path)) or ("image/jpeg" if kind == "image" else "application/octet-stream"))
- return paths, mimes
- async def handle(self, ctx: InboundContext, next_fn) -> None:
- # In groups only @bot / owner-command turns reach here (GroupAtGuard short-circuits the
- # rest), so media download and observed-media hydration need no @bot re-check.
- adapter = ctx.adapter
- urls: list[str] = []
- types: list[str] = []
- def _add_unique_pairs(pair_lists: tuple[list[str], list[str]]) -> None:
- for u, m in zip(*pair_lists):
- if u and u not in urls:
- urls.append(u)
- types.append(m)
- own_pairs = await self._resolve_media_urls(adapter, ctx.media_refs) # 1) media carried by this message
- own_count = sum(1 for u in own_pairs[0] if u)
- _add_unique_pairs(own_pairs)
- # 2) Quoted media takes priority; else observed-media backfill in groups only (DM media
- # was already resolved on its own turn).
- if ctx.reply_to_message_id is not None:
- if ctx.quote_media_refs:
- _add_unique_pairs(await self._resolve_quote_media(adapter, ctx.quote_media_refs))
- else: # DM rows carry no platform message_id → recover already-local media from the msg cache.
- _add_unique_pairs(self._collect_quote_local_media(ctx))
- elif ctx.chat_type == "group":
- try:
- _add_unique_pairs(await self._collect_observed_media(adapter, ctx.source))
- except Exception as exc:
- logger.warning("[%s] observed-image hydration raised, continuing anyway: %s", adapter.name, exc)
- ctx.media_urls = urls
- ctx.media_types = types
- # Re-check placeholder using ``own_count``: placeholder text with only quote/observed
- # media (no fresh attachment of its own) is still skippable.
- if PlaceholderFilterMiddleware.is_skippable_placeholder(ctx.raw_text, own_count):
- logger.debug("[%s] Skip placeholder after media download: %r", adapter.name, ctx.raw_text)
- return # Stop pipeline
- await next_fn()
- class PatchAnchorsMiddleware(InboundMiddleware):
- """Replace ``[kind|ybres:RID]`` anchors in raw_text with the local paths MediaResolveMiddleware
- produced, so the transcript records usable paths. Only resolved media (paths starting with
- ``/``) are substituted; other anchors stay untouched."""
- name = "patch-anchors"
- @staticmethod
- def _patch(text: str, urls: list[str], types: list[str]) -> str:
- patched = text
- for u, m in zip(urls, types):
- if not u.startswith("/"):
- continue
- anchor_match = _YB_RES_REF_RE.search(patched)
- if not anchor_match:
- break
- kind, _, filename = anchor_match.group(1).partition(":")
- kind = kind.strip()
- if kind == "image" and m.startswith("image/"):
- replacement = f"[image: {u}]"
- elif kind == "file":
- replacement = f"[file: {filename.strip() or os.path.basename(u)} → {u}]"
- elif kind == "video":
- replacement = f"[video: {u}]"
- else:
- continue
- patched = patched[: anchor_match.start()] + replacement + patched[anchor_match.end():]
- return patched
- async def handle(self, ctx: InboundContext, next_fn) -> None:
- ctx.raw_text = self._patch(ctx.raw_text, ctx.media_urls, ctx.media_types)
- await next_fn()
- class DispatchMiddleware(InboundMiddleware):
- """Build the MessageEvent and dispatch it (groups: serialised per session via a queue)."""
- name = "dispatch"
- async def handle(self, ctx: InboundContext, next_fn) -> None:
- adapter = ctx.adapter
- # The adapter seam: keyed in the owner profile's namespace, same as ``handle_message``.
- _sk = adapter._source_session_key(ctx.source)
- async def _dispatch_inbound_event() -> None:
- if any(mt.startswith(("application/", "text/")) for mt in ctx.media_types):
- # Classification: DOCUMENT wins over PHOTO/VIDEO/AUDIO for mixed attachments — run.py's
- # image handling keys off the per-path image/* mime types regardless of message_type, but
- # document-context injection gates strictly on MessageType.DOCUMENT (same precedence as
- # Email/Signal, PR #44695).
- msg_type = MessageType.DOCUMENT
- else: # yuanbao-local subtypes (CHAT_RECORD) are deep-parsed into text → TEXT downstream
- msg_type = ctx.msg_type if isinstance(ctx.msg_type, MessageType) else MessageType.TEXT
- event = MessageEvent(
- text=ctx.raw_text, message_type=msg_type, source=ctx.source, message_id=ctx.msg_id or None,
- raw_message=ctx.push, media_urls=list(ctx.media_urls), media_types=list(ctx.media_types),
- reply_to_message_id=ctx.reply_to_message_id, reply_to_text=ctx.reply_to_text,
- channel_prompt=ctx.channel_prompt,
- )
- if _sk and ctx.msg_id:
- adapter._processing_msg_ids[_sk] = ctx.msg_id
- adapter._processing_msg_texts[_sk] = ctx.raw_text or ""
- if ctx.msg_id and ctx.raw_text:
- cache = adapter._msg_content_cache
- cache[ctx.msg_id] = ctx.raw_text
- for k in list(cache)[:max(0, len(cache) - 200)]: # bounded: drop oldest
- del cache[k]
- await adapter.handle_message(event)
- if ctx.chat_type == "group":
- is_new = _sk not in adapter._group_queues
- queue = adapter._group_queues.setdefault(_sk, asyncio.Queue())
- queue.put_nowait(_dispatch_inbound_event)
- logger.info("[%s] Group message enqueued (qsize=%d) for %s", adapter.name, queue.qsize(), (_sk or "")[:50])
- if is_new:
- self._track_inbound(adapter, self._consume_group_queue(adapter, _sk), f"yuanbao-group-consumer-{(_sk or '')[:30]}")
- else:
- self._track_inbound(adapter, _dispatch_inbound_event(), f"yuanbao-inbound-{ctx.msg_id or 'unknown'}")
- await next_fn()
- @staticmethod
- def _track_inbound(adapter, coro, name: str) -> None:
- task = asyncio.create_task(coro, name=name)
- adapter._inbound_tasks.add(task)
- task.add_done_callback(adapter._inbound_tasks.discard)
- @staticmethod
- async def _consume_group_queue(adapter: YuanbaoAdapter, session_key: str) -> None:
- """Drain the group queue one dispatch at a time, waiting for each to finish; exits after 2s idle."""
- queue = adapter._group_queues.get(session_key)
- if not queue:
- return
- try:
- while True:
- try:
- dispatch_fn = await asyncio.wait_for(queue.get(), timeout=2.0)
- except TimeoutError:
- break
- logger.debug("[%s] Group queue: dispatching for %s (remaining=%d)", adapter.name, (session_key or "")[:50], queue.qsize())
- try:
- await dispatch_fn()
- while session_key in adapter._active_sessions:
- await asyncio.sleep(0.1)
- except Exception:
- logger.exception("[%s] Group queue consumer error", adapter.name)
- finally:
- adapter._group_queues.pop(session_key, None)
- class InboundPipelineBuilder:
- """Assembles the default Yuanbao inbound pipeline (order matters)."""
- _DEFAULT_MIDDLEWARES: list[type] = [
- DecodeMiddleware, ExtractFieldsMiddleware, RecallGuardMiddleware, DedupMiddleware, SkipSelfMiddleware,
- ChatRoutingMiddleware, AccessGuardMiddleware, ExtractContentMiddleware, PlaceholderFilterMiddleware,
- OwnerCommandMiddleware, BuildSourceMiddleware, GroupAtGuardMiddleware, AutoSetHomeMiddleware,
- GroupAttributionMiddleware, ClassifyMessageTypeMiddleware, QuoteContextMiddleware,
- ForwardedRecordsParseMiddleware, MediaResolveMiddleware, PatchAnchorsMiddleware, DispatchMiddleware,
- ]
- @classmethod
- def build(cls) -> InboundPipeline:
- pipeline = InboundPipeline()
- for mw_cls in cls._DEFAULT_MIDDLEWARES:
- pipeline.use(mw_cls())
- return pipeline
- class ConnectionManager:
- """WebSocket lifecycle: open/close, AUTH_BIND, ping/pong heartbeat, receive loop, backoff reconnect."""
- _DEBOUNCE_WINDOW: float = 1.5 # seconds to wait for companion frames of a multi-part message
- _LOOPS = (("_heartbeat_task", "_heartbeat_loop", "heartbeat"), ("_recv_task", "_receive_loop", "recv"))
- def __init__(self, adapter: YuanbaoAdapter) -> None:
- self._adapter = adapter
- self._ws = None # websockets connection
- self._connect_id: Optional[str] = None
- self._heartbeat_task: Optional[asyncio.Task] = None
- self._recv_task: Optional[asyncio.Task] = None
- self._pending_acks: dict[str, asyncio.Future] = {}
- self._pending_pong: Optional[asyncio.Future] = None
- self._consecutive_hb_timeouts = self._reconnect_attempts = 0
- self._reconnecting: bool = False
- # Debounce buffer aggregating multi-part inbound messages: sender key -> frames / timer
- self._inbound_buffer: dict[str, list] = {}
- self._inbound_timers: dict[str, asyncio.TimerHandle] = {}
- @property
- def ws(self):
- return self._ws
- @property
- def is_connected(self) -> bool:
- """``ws.open`` may be a bool (websockets <14) or a method (>=14)."""
- if self._ws is None:
- return False
- open_attr = getattr(self._ws, "open", None)
- try:
- return open_attr is True or (callable(open_attr) and bool(open_attr()))
- except Exception:
- return False
- async def open(self) -> bool:
- """sign-token → WS connect → AUTH_BIND → start loops. Returns True on success."""
- adapter = self._adapter
- if not WEBSOCKETS_AVAILABLE:
- msg = "Yuanbao startup failed: 'websockets' package not installed"
- adapter._set_fatal_error("yuanbao_missing_dependency", msg, retryable=True)
- logger.warning("[%s] %s. Run: hermes pm repair", adapter.name, msg)
- return False
- if not adapter._app_key or not adapter._app_secret:
- msg = "Yuanbao startup failed: YUANBAO_APP_ID and YUANBAO_APP_SECRET are required"
- adapter._set_fatal_error("yuanbao_missing_credentials", msg, retryable=False)
- logger.error("[%s] %s", adapter.name, msg)
- return False
- if self.is_connected:
- logger.debug("[%s] Already connected, skipping connect()", adapter.name)
- return True
- if not adapter._acquire_platform_lock('yuanbao-app-key', adapter._app_key, 'Yuanbao app key'):
- return False
- try:
- logger.info("[%s] Fetching sign token from %s", adapter.name, adapter._api_domain)
- token_data = await adapter._get_cached_token()
- logger.info("[%s] Connecting to %s", adapter.name, adapter._ws_url)
- if not await self._dial(token_data):
- return False
- adapter._loop = asyncio.get_running_loop()
- self._connected(cancel_existing=False)
- logger.info("[%s] Connected. connectId=%s botId=%s", adapter.name, self._connect_id, adapter._bot_id)
- return True
- except TimeoutError:
- logger.error("[%s] Connection timed out", adapter.name)
- except Exception as exc:
- logger.error("[%s] connect() failed: %s", adapter.name, exc, exc_info=True)
- await self._cleanup_ws()
- adapter._release_platform_lock()
- return False
- async def _dial(self, token_data: dict) -> bool:
- """Adopt the sign-token bot_id, open the WS (built-in ping/pong disabled) and run AUTH_BIND;
- cleans up on auth failure."""
- if token_data.get("bot_id"):
- self._adapter._bot_id = str(token_data["bot_id"])
- self._ws = await asyncio.wait_for(
- websockets.connect( # type: ignore[attr-defined]
- self._adapter._ws_url, ping_interval=None, ping_timeout=None, close_timeout=5,
- happy_eyeballs_delay=0.25, # race IPv6/IPv4 in loop.create_connection (#114265)
- ),
- timeout=CONNECT_TIMEOUT_SECONDS,
- )
- if not await self._authenticate(token_data):
- await self._cleanup_ws()
- return False
- return True
- def _connected(self, *, cancel_existing: bool) -> None:
- """Post-AUTH bookkeeping shared by open() and reconnect: mark connected, (re)start loops,
- register as the active adapter."""
- self._reconnect_attempts = 0
- self._adapter._mark_connected()
- self._start_loops(cancel_existing=cancel_existing)
- YuanbaoAdapter.set_active(self._adapter)
- def _start_loops(self, *, cancel_existing: bool) -> None:
- """(Re)start the heartbeat and receive loops for the current connect_id."""
- for attr, coro_name, tag in self._LOOPS:
- old = getattr(self, attr)
- if cancel_existing and old and not old.done():
- old.cancel()
- setattr(self, attr, asyncio.create_task(getattr(self, coro_name)(), name=f"yuanbao-{tag}-{self._connect_id}"))
- async def close(self) -> None:
- """Cancel background tasks, fail pending futures, and close the WebSocket."""
- for attr, _coro_name, _tag in self._LOOPS:
- task = getattr(self, attr)
- if task:
- await cancel_task(task)
- setattr(self, attr, None)
- disc_exc = RuntimeError("YuanbaoAdapter disconnected")
- for fut in self._pending_acks.values():
- if not fut.done():
- fut.set_exception(disc_exc)
- self._pending_acks.clear()
- SignManager.clear_locks() # avoid stale locks bound to a previous event loop
- await self._cleanup_ws()
- async def _authenticate(self, token_data: dict) -> bool:
- """Send AUTH_BIND and read frames until BIND_ACK; False on failure/timeout."""
- adapter = self._adapter
- if self._ws is None:
- return False
- uid = adapter._bot_id or token_data.get("bot_id", "")
- msg_id, version = str(uuid.uuid4()), get_version_info().base_version
- await self._ws.send(encode_auth_bind(
- biz_id="ybBot", uid=uid, source=token_data.get("source") or "bot", token=token_data.get("token", ""),
- msg_id=msg_id, app_version=version, operation_system=_OPERATION_SYSTEM, bot_version=version,
- route_env=adapter._route_env or token_data.get("route_env", "") or "",
- ))
- logger.debug("[%s] AUTH_BIND sent (msg_id=%s uid=%s)", adapter.name, msg_id, uid)
- try:
- deadline = asyncio.get_running_loop().time() + AUTH_TIMEOUT_SECONDS
- while True:
- remaining = deadline - asyncio.get_running_loop().time()
- if remaining <= 0:
- logger.error("[%s] AUTH_BIND timeout waiting for BIND_ACK", adapter.name)
- return False
- raw = await asyncio.wait_for(self._ws.recv(), timeout=remaining)
- if not isinstance(raw, (bytes, bytearray)):
- continue
- try:
- msg = decode_conn_msg(bytes(raw))
- except Exception:
- continue
- head = msg.get("head", {})
- if head.get("cmd_type", -1) != CMD_TYPE["Response"] or head.get("cmd", "") != "auth-bind":
- continue
- self._connect_id = self._extract_connect_id(msg)
- if not self._connect_id:
- logger.error("[%s] BIND_ACK missing connectId", adapter.name)
- return False
- logger.info("[%s] BIND_ACK received: connectId=%s", adapter.name, self._connect_id)
- return True
- except TimeoutError:
- logger.error("[%s] AUTH_BIND timeout", adapter.name)
- except Exception as exc:
- logger.error("[%s] AUTH_BIND error: %s", adapter.name, exc, exc_info=True)
- return False
- def _pop_pending(self, msg_id: str) -> Optional[asyncio.Future]:
- """Pop the not-yet-done future registered for *msg_id*, if any."""
- fut = self._pending_acks.pop(msg_id, None) if msg_id else None
- return fut if fut is not None and not fut.done() else None
- def _extract_connect_id(self, decoded_msg: dict) -> Optional[str]:
- """connectId from a decoded BIND_ACK, or None (logs AuthBindRsp errors)."""
- data: bytes = decoded_msg.get("data", b"")
- if not data:
- return None
- try:
- fdict = _fields_to_dict(_parse_fields(data))
- code = _get_varint(fdict, 1)
- if code != 0:
- logger.error("[%s] AuthBindRsp error: code=%d message=%r", self._adapter.name, code, _get_string(fdict, 2))
- return None
- return _get_string(fdict, 3) or None
- except Exception as exc:
- logger.warning("[%s] Failed to extract connectId: %s", self._adapter.name, exc)
- return None
- async def _heartbeat_loop(self) -> None:
- """Send PING every HEARTBEAT_INTERVAL_SECONDS; reconnect after HEARTBEAT_TIMEOUT_THRESHOLD misses."""
- adapter = self._adapter
- try:
- while adapter._running:
- await asyncio.sleep(HEARTBEAT_INTERVAL_SECONDS)
- if self._ws is None:
- continue
- try:
- msg_id = str(uuid.uuid4())
- self._pending_pong = pong_future = asyncio.get_running_loop().create_future()
- self._pending_acks[msg_id] = pong_future
- await self._ws.send(encode_ping(msg_id))
- logger.debug("[%s] PING sent (msg_id=%s)", adapter.name, msg_id)
- try:
- await asyncio.wait_for(pong_future, timeout=10.0)
- self._consecutive_hb_timeouts = 0
- except TimeoutError:
- self._pending_acks.pop(msg_id, None)
- self._consecutive_hb_timeouts += 1
- logger.warning("[%s] PONG timeout (%d/%d)", adapter.name, self._consecutive_hb_timeouts, HEARTBEAT_TIMEOUT_THRESHOLD)
- if self._consecutive_hb_timeouts >= HEARTBEAT_TIMEOUT_THRESHOLD:
- logger.warning("[%s] Heartbeat threshold exceeded, triggering reconnect", adapter.name)
- self.schedule_reconnect()
- return
- finally:
- self._pending_acks.pop(msg_id, None)
- self._pending_pong = None
- except Exception as exc:
- logger.debug("[%s] Heartbeat send failed: %s", adapter.name, exc)
- except asyncio.CancelledError:
- pass
- async def _receive_loop(self) -> None:
- """Read WS frames and dispatch by cmd_type; schedule reconnect unless the close code is permanent."""
- adapter = self._adapter
- try:
- async for raw in self._ws: # type: ignore[union-attr]
- if isinstance(raw, (bytes, bytearray)):
- await self._handle_frame(bytes(raw))
- except asyncio.CancelledError:
- pass
- except websockets.exceptions.ConnectionClosed as close_exc: # type: ignore[union-attr]
- close_code = getattr(close_exc, 'code', None)
- logger.warning("[%s] WebSocket connection closed: code=%s reason=%s", adapter.name, close_code, getattr(close_exc, 'reason', ''))
- if close_code and close_code in NO_RECONNECT_CLOSE_CODES:
- logger.error("[%s] Close code %d is non-recoverable, NOT reconnecting", adapter.name, close_code)
- adapter._mark_disconnected()
- else:
- self.schedule_reconnect()
- except Exception as exc:
- logger.warning("[%s] receive_loop exited: %s", adapter.name, exc)
- self.schedule_reconnect()
- async def _handle_frame(self, raw: bytes) -> None:
- adapter = self._adapter
- try:
- msg = decode_conn_msg(raw)
- except Exception as exc:
- logger.debug("[%s] Failed to decode frame: %s", adapter.name, exc)
- return
- head = msg.get("head", {})
- cmd_type = head.get("cmd_type", -1)
- cmd = head.get("cmd", "")
- msg_id = head.get("msg_id", "")
- data: bytes = msg.get("data", b"")
- if cmd_type == CMD_TYPE["Response"]:
- if cmd == "ping": # HEARTBEAT_ACK
- logger.debug("[%s] HEARTBEAT_ACK received (msg_id=%s)", adapter.name, msg_id)
- pong = self._pending_pong if self._pending_pong is not None and not self._pending_pong.done() else self._pop_pending(msg_id)
- if pong is not None:
- pong.set_result(True)
- elif cmd in {"send_group_heartbeat", "send_private_heartbeat"}:
- # Fire-and-forget heartbeat ACKs: nobody awaits them; discard to avoid "Unmatched" noise.
- logger.debug("[%s] Heartbeat ACK received: cmd=%s msg_id=%s", adapter.name, cmd, msg_id)
- elif msg_id and msg_id in self._pending_acks: # response to an outbound RPC
- fut = self._pop_pending(msg_id)
- if fut is not None:
- result = {"head": head}
- if data:
- result["data"] = data
- fut.set_result(result)
- else:
- logger.debug("[%s] Unmatched Response: cmd=%s msg_id=%s", adapter.name, cmd, msg_id)
- return
- if cmd_type == CMD_TYPE["Push"]:
- logger.info("[%s] Push received: cmd=%s msg_id=%s data_len=%d", adapter.name, cmd, msg_id, len(data))
- if head.get("need_ack", False) and self._ws is not None:
- try:
- await self._ws.send(encode_push_ack(head))
- except Exception as ack_exc:
- logger.debug("[%s] Failed to send PushAck: %s", adapter.name, ack_exc)
- if msg_id and msg_id in self._pending_acks:
- fut = self._pop_pending(msg_id)
- if fut is not None:
- try:
- fut.set_result(decode_inbound_push(data) if data else {"head": head})
- except Exception as exc:
- fut.set_exception(exc)
- return
- if data: # genuine inbound message — dispatch to AI
- logger.info("[%s] WS received inbound push, decoding and dispatching: cmd=%s, data_len=%d", adapter.name, cmd, len(data))
- self._push_to_inbound(data)
- return
- logger.debug("[%s] Ignoring frame: cmd_type=%d cmd=%s msg_id=%s", adapter.name, cmd_type, cmd, msg_id)
- def _extract_sender_key(self, raw_data: bytes) -> str:
- """Debounce key 'from_account:group_code' (JSON or protobuf), else a unique fallback."""
- with contextlib.suppress(Exception):
- parsed = json.loads(raw_data.decode("utf-8"))
- if isinstance(parsed, dict):
- from_account, group_code = DecodeMiddleware.json_sender_fields(parsed)
- if from_account:
- return f"{from_account}:{group_code}"
- with contextlib.suppress(Exception):
- push = decode_inbound_push(raw_data)
- if push:
- return f"{push.get('from_account', '')}:{push.get('group_code', '')}"
- return f"__unknown_{id(raw_data)}"
- def _push_to_inbound(self, raw_data: bytes) -> None:
- """Debounced dispatch: frames from one sender within _DEBOUNCE_WINDOW run as ONE pipeline
- execution, merging multi-part messages (e.g. image + text pushed separately)."""
- key = self._extract_sender_key(raw_data)
- existing_timer = self._inbound_timers.pop(key, None)
- if existing_timer:
- existing_timer.cancel()
- self._inbound_buffer.setdefault(key, []).append(raw_data)
- logger.debug("[%s] Debounce: buffered frame for key=%s, count=%d", self._adapter.name, key, len(self._inbound_buffer[key]))
- self._inbound_timers[key] = asyncio.get_running_loop().call_later(self._DEBOUNCE_WINDOW, self._flush_inbound_buffer, key)
- def _flush_inbound_buffer(self, key: str) -> None:
- """Run the pipeline over the buffered frames for *key*."""
- self._inbound_timers.pop(key, None)
- data_list = self._inbound_buffer.pop(key, [])
- if not data_list:
- return
- adapter = self._adapter
- logger.info("[%s] Debounce flush: key=%s, aggregated %d frames", adapter.name, key, len(data_list))
- adapter._track_task(asyncio.create_task(
- adapter._inbound_pipeline.execute(InboundContext(adapter=adapter, raw_frames=data_list)), name=f"yuanbao-pipeline-{key}"))
- async def send_biz_request(self, encoded_conn_msg: bytes, req_id: str, timeout: float = DEFAULT_SEND_TIMEOUT) -> dict:
- """Send a business request and await its response future (pending_acks[req_id]), cleaning up on exit."""
- if self._ws is None:
- raise RuntimeError("Not connected")
- future: asyncio.Future = asyncio.get_running_loop().create_future()
- self._pending_acks[req_id] = future
- try:
- await self._ws.send(encoded_conn_msg)
- return await asyncio.wait_for(asyncio.shield(future), timeout=timeout)
- finally:
- self._pending_acks.pop(req_id, None)
- def schedule_reconnect(self) -> None:
- """Schedule a reconnect only if running and not already reconnecting."""
- if self._adapter._running and not self._reconnecting:
- asyncio.create_task(self._reconnect_with_backoff())
- async def _reconnect_with_backoff(self) -> bool:
- if self._reconnecting:
- logger.debug("[%s] Reconnect already in progress, skipping", self._adapter.name)
- return False
- self._reconnecting = True
- try:
- return await self._do_reconnect()
- finally:
- self._reconnecting = False
- async def _do_reconnect(self) -> bool:
- """Reconnect loop (under the _reconnecting guard) with exponential backoff 1s, 2s, 4s, … capped at 60s."""
- adapter = self._adapter
- for attempt in range(MAX_RECONNECT_ATTEMPTS):
- self._reconnect_attempts = attempt + 1
- wait = min(2 ** attempt, 60)
- logger.info("[%s] Reconnect attempt %d/%d in %ds", adapter.name, attempt + 1, MAX_RECONNECT_ATTEMPTS, wait)
- await asyncio.sleep(wait)
- await self._cleanup_ws()
- try:
- token_data = await SignManager.force_refresh(
- adapter._app_key, adapter._app_secret, adapter._api_domain, route_env=adapter._route_env,
- )
- if not await self._dial(token_data):
- logger.warning("[%s] Re-auth failed on attempt %d", adapter.name, attempt + 1)
- continue
- self._consecutive_hb_timeouts = 0
- self._connected(cancel_existing=True)
- logger.info("[%s] Reconnected on attempt %d. connectId=%s", adapter.name, attempt + 1, self._connect_id)
- return True
- except TimeoutError:
- logger.warning("[%s] Reconnect attempt %d timed out", adapter.name, attempt + 1)
- except Exception as exc:
- logger.warning("[%s] Reconnect attempt %d failed: %s", adapter.name, attempt + 1, exc)
- logger.error("[%s] Giving up after %d reconnect attempts", adapter.name, MAX_RECONNECT_ATTEMPTS)
- adapter._mark_disconnected()
- return False
- async def _cleanup_ws(self) -> None:
- """Close and clear the WS, bounded by WS_CLOSE_TIMEOUT_S so an unresponsive server can't stall teardown."""
- ws = self._ws
- self._ws = None
- if ws is not None:
- try:
- await asyncio.wait_for(ws.close(), timeout=WS_CLOSE_TIMEOUT_S)
- except TimeoutError:
- # No close-frame echo in time; websockets force-closes the transport on cancel.
- logger.debug("[%s] WS close handshake exceeded %.1fs — dropping connection", self._adapter.name, WS_CLOSE_TIMEOUT_S)
- except Exception:
- pass
- def _read_local_file(adapter, label: str, path: str, default_name: str, default_mime: str,
- filename: Optional[str] = None) -> tuple[bytes, str, str]:
- """(bytes, filename, content_type) for a local file; ValueError when missing."""
- if not os.path.isfile(path):
- raise ValueError(f"File not found: {path}")
- logger.info("[%s] %s: reading %s", adapter.name, label, path)
- with open(path, "rb") as f:
- file_bytes = f.read()
- filename = filename or os.path.basename(path) or default_name
- return file_bytes, filename, guess_mime_type(filename) or default_mime
- class MediaSendHandler(ABC):
- """Media send strategy: subclasses provide acquire_file() and build_msg_body(); handle() runs
- the shared flow (check ws → cancel notifier → validate → COS upload → lock → dispatch)."""
- def needs_cos_upload(self) -> bool:
- """Override to return False for non-COS media (sticker)."""
- return True
- @abstractmethod
- async def acquire_file(self, adapter: YuanbaoAdapter, **kwargs: Any) -> tuple[bytes, str, str]:
- """(file_bytes, filename, content_type); raise ValueError when unobtainable."""
- @abstractmethod
- def build_msg_body(self, upload_result: dict, **kwargs: Any) -> list:
- """Platform-specific MsgBody list from the COS upload result."""
- async def handle(self, adapter: YuanbaoAdapter, chat_id: str, reply_to: Optional[str] = None,
- caption: Optional[str] = None, **kwargs: Any) -> SendResult:
- if adapter._connection.ws is None:
- return SendResult(success=False, error="Not connected", retryable=True)
- adapter._outbound.slow_notifier.cancel(chat_id)
- try:
- file_bytes, filename, content_type = await self.acquire_file(adapter, **kwargs)
- if self.needs_cos_upload():
- # Stickers (TIMFaceElem) carry no bytes — validating them would yield "Empty file".
- validation_err = MessageSender.validate_media(file_bytes, filename, adapter.MEDIA_MAX_SIZE_MB)
- if validation_err:
- return SendResult(success=False, error=validation_err)
- token_data = await adapter._get_cached_token()
- credentials = await get_cos_credentials(
- app_key=adapter._app_key, api_domain=adapter._api_domain, token=token_data.get("token", ""),
- filename=filename, bot_id=token_data.get("bot_id", "") or adapter._bot_id or "", route_env=adapter._route_env,
- )
- upload_result = await upload_to_cos(
- file_bytes=file_bytes, filename=filename, content_type=content_type, credentials=credentials,
- bucket=credentials["bucketName"], region=credentials["region"],
- )
- # Explicit keys win over caller kwargs (avoids "multiple values" TypeError).
- msg_body = self.build_msg_body(upload_result, **{
- **kwargs, "file_uuid": md5_hex(file_bytes), "filename": filename, "content_type": content_type})
- else:
- msg_body = self.build_msg_body({}, **kwargs)
- if caption:
- msg_body.append(_text_elem(caption))
- return await adapter._outbound.sender.dispatch_msg_body(chat_id, msg_body, reply_to, group_code=kwargs.get("group_code", ""))
- except ValueError as ve:
- return SendResult(success=False, error=str(ve))
- except Exception as exc:
- logger.error("[%s] %s.handle() failed: %s", adapter.name, type(self).__name__, exc, exc_info=True)
- return SendResult(success=False, error=str(exc) or type(exc).__name__)
- class _ImageHandler(MediaSendHandler):
- """Shared TIMImageElem body builder for image handlers."""
- def build_msg_body(self, upload_result, **kwargs):
- return build_image_msg_body(
- url=upload_result["url"], uuid=kwargs["file_uuid"], filename=kwargs["filename"], size=upload_result["size"],
- width=upload_result.get("width", 0), height=upload_result.get("height", 0), mime_type=kwargs["content_type"],
- )
- class ImageUrlHandler(_ImageHandler):
- """Image from a URL (download → COS → TIMImageElem)."""
- async def acquire_file(self, adapter, **kwargs):
- image_url: str = kwargs["image_url"]
- logger.info("[%s] ImageUrlHandler: downloading %s", adapter.name, image_url)
- file_bytes, content_type = await media_download_url(image_url, max_size_mb=adapter.MEDIA_MAX_SIZE_MB)
- path_part = image_url.split("?")[0]
- if not content_type or content_type == "application/octet-stream":
- content_type = guess_mime_type(path_part) or "image/jpeg"
- return file_bytes, os.path.basename(path_part) or "image.jpg", content_type
- class ImageFileHandler(_ImageHandler):
- """Image from a local path (read → COS → TIMImageElem)."""
- async def acquire_file(self, adapter, **kwargs):
- return _read_local_file(adapter, "ImageFileHandler", kwargs["image_path"], "image.jpg", "image/jpeg")
- class DocumentHandler(MediaSendHandler):
- """Local file/document (read → COS → TIMFileElem)."""
- async def acquire_file(self, adapter, **kwargs):
- return _read_local_file(adapter, "DocumentHandler", kwargs["file_path"], "document", "application/octet-stream", kwargs.get("filename"))
- def build_msg_body(self, upload_result, **kwargs):
- return build_file_msg_body(url=upload_result["url"], filename=kwargs["filename"], uuid=kwargs["file_uuid"], size=upload_result["size"])
- class StickerHandler(MediaSendHandler):
- """Sticker/emoji (TIMFaceElem, no COS upload)."""
- def needs_cos_upload(self) -> bool:
- return False
- async def acquire_file(self, adapter, **kwargs):
- return b"", "sticker", "application/octet-stream" # no file bytes needed
- def build_msg_body(self, upload_result, **kwargs):
- from plugins.platforms.yuanbao.yuanbao_sticker import (
- get_sticker_by_name, get_random_sticker, build_face_msg_body, build_sticker_msg_body,
- )
- sticker_name = kwargs.get("sticker_name")
- if sticker_name is not None:
- sticker = get_sticker_by_name(sticker_name)
- if sticker is None:
- raise ValueError(f"Sticker not found: {sticker_name!r}")
- return build_sticker_msg_body(sticker)
- if kwargs.get("face_index") is not None:
- return build_face_msg_body(face_index=kwargs["face_index"])
- return build_sticker_msg_body(get_random_sticker())
- class HeartbeatManager:
- """Reply heartbeat lifecycle: RUNNING every 2s, auto-FINISH after 30s idle, explicit stop."""
- def __init__(self, adapter: YuanbaoAdapter) -> None:
- self._adapter = adapter
- self._reply_heartbeat_tasks: dict[str, asyncio.Task] = {}
- self._reply_hb_last_active: dict[str, float] = {}
- def _ready(self) -> bool:
- return self._adapter._connection.ws is not None and bool(self._adapter._bot_id)
- async def send_heartbeat_once(self, chat_id: str, heartbeat_val: int) -> None:
- """Send a single heartbeat (RUNNING or FINISH), best effort."""
- adapter = self._adapter
- if not self._ready():
- return
- try:
- if chat_id.startswith("group:"):
- encoded = encode_send_group_heartbeat(from_account=adapter._bot_id, group_code=chat_id[len("group:"):], heartbeat=heartbeat_val)
- else:
- encoded = encode_send_private_heartbeat(from_account=adapter._bot_id, to_account=chat_id.removeprefix("direct:"), heartbeat=heartbeat_val)
- await adapter._connection.ws.send(encoded)
- logger.debug("[%s] Reply heartbeat %s sent: chat=%s", adapter.name,
- "RUNNING" if heartbeat_val == WS_HEARTBEAT_RUNNING else "FINISH", chat_id)
- except Exception as exc:
- logger.debug("[%s] send_heartbeat_once failed: %s", adapter.name, exc)
- async def start(self, chat_id: str) -> None:
- """Start or renew the periodic RUNNING sender."""
- if not self._ready():
- return
- self._reply_hb_last_active[chat_id] = time.time()
- existing = self._reply_heartbeat_tasks.get(chat_id)
- if not existing or existing.done():
- self._reply_heartbeat_tasks[chat_id] = asyncio.create_task(self._worker(chat_id), name=f"yuanbao-reply-hb-{chat_id}")
- async def _worker(self, chat_id: str) -> None:
- """Send RUNNING every 2s; after 30s without renewal (or WS loss) send FINISH and exit.
- A cancelled worker sends no FINISH — stop() decides that."""
- cancelled = False
- try:
- await self.send_heartbeat_once(chat_id, WS_HEARTBEAT_RUNNING)
- while True:
- await asyncio.sleep(REPLY_HEARTBEAT_INTERVAL_S)
- if (time.time() - self._reply_hb_last_active.get(chat_id, 0) > REPLY_HEARTBEAT_TIMEOUT_S
- or self._adapter._connection.ws is None):
- break
- await self.send_heartbeat_once(chat_id, WS_HEARTBEAT_RUNNING)
- except asyncio.CancelledError:
- cancelled = True
- except Exception:
- pass
- finally:
- if not cancelled:
- await self.send_heartbeat_once(chat_id, WS_HEARTBEAT_FINISH)
- self._reply_heartbeat_tasks.pop(chat_id, None)
- self._reply_hb_last_active.pop(chat_id, None)
- async def stop(self, chat_id: str, send_finish: bool = True) -> None:
- """Stop the RUNNING sender and optionally send FINISH."""
- task = self._reply_heartbeat_tasks.pop(chat_id, None)
- if task and not task.done():
- await cancel_task(task)
- if send_finish:
- await self.send_heartbeat_once(chat_id, WS_HEARTBEAT_FINISH)
- async def close(self) -> None:
- _cancel_all(self._reply_heartbeat_tasks)
- self._reply_hb_last_active.clear()
- class SlowResponseNotifier:
- """Per-chat timer that sends a courtesy 'please wait' after SLOW_RESPONSE_TIMEOUT_S without a reply."""
- def __init__(self, adapter: YuanbaoAdapter, sender: MessageSender) -> None:
- self._adapter = adapter
- self._sender = sender
- self._tasks: dict[str, asyncio.Task] = {}
- async def start(self, chat_id: str) -> None:
- self.cancel(chat_id)
- self._tasks[chat_id] = asyncio.create_task(self._notifier(chat_id), name=f"yuanbao-slow-resp-{chat_id}")
- async def _notifier(self, chat_id: str) -> None:
- try:
- await asyncio.sleep(SLOW_RESPONSE_TIMEOUT_S)
- logger.info("[%s] Agent response exceeded %ds for %s, sending wait notice", self._adapter.name, int(SLOW_RESPONSE_TIMEOUT_S), chat_id)
- await self._sender.send_text_chunk(chat_id, slow_response_message())
- except asyncio.CancelledError:
- pass
- except Exception as exc:
- logger.debug("[%s] Slow-response notifier failed: %s", self._adapter.name, exc)
- def cancel(self, chat_id: str) -> None:
- task = self._tasks.pop(chat_id, None)
- if task and not task.done():
- task.cancel()
- async def close(self) -> None:
- _cancel_all(self._tasks)
- class MessageSender:
- """Outbound dispatcher: per-chat locks (serial ordering), chunked text with retry, C2C/group
- encoding, media handler strategies, and send_direct for the send_message tool."""
- IMAGE_EXTS: ClassVar[frozenset] = frozenset({".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp"})
- CHAT_DICT_MAX_SIZE: ClassVar[int] = 1000 # Max distinct chat IDs in _chat_locks
- # @nickname bounded by whitespace / line edges
- _AT_USER_RE = re.compile(r'(?:(?<=\s)|(?<=^))@(\S+?)(?=\s|$)', re.MULTILINE)
- def __init__(self, adapter: YuanbaoAdapter) -> None:
- self._adapter = adapter
- self._chat_locks: collections.OrderedDict[str, asyncio.Lock] = collections.OrderedDict()
- self._media_handlers: dict[str, MediaSendHandler] = {
- "image_url": ImageUrlHandler(), "image_file": ImageFileHandler(), "document": DocumentHandler(), "sticker": StickerHandler(),
- }
- def get_chat_lock(self, chat_id: str) -> asyncio.Lock:
- """Per-chat-id lock with LRU eviction (prefers evicting an unlocked entry)."""
- if chat_id in self._chat_locks:
- self._chat_locks.move_to_end(chat_id)
- else:
- if len(self._chat_locks) >= self.CHAT_DICT_MAX_SIZE:
- self._chat_locks.pop(next((k for k in self._chat_locks if not self._chat_locks[k].locked()), next(iter(self._chat_locks))))
- self._chat_locks[chat_id] = asyncio.Lock()
- return self._chat_locks[chat_id]
- async def send_text(self, chat_id: str, content: str, reply_to: Optional[str] = None, group_code: str = "") -> SendResult:
- """Send text with auto-chunking and per-chat-id ordering guarantee."""
- adapter = self._adapter
- if adapter._connection.ws is None:
- return SendResult(success=False, error="Not connected", retryable=True)
- adapter._outbound.slow_notifier.cancel(chat_id)
- async with self.get_chat_lock(chat_id):
- content_to_send = self.strip_cron_wrapper(content)
- chunks = self.truncate_message(content_to_send, adapter.MAX_TEXT_CHUNK)
- logger.info("[%s] truncate_message: input=%d chars, max=%d, output=%d chunk(s) sizes=%s",
- adapter.name, len(content_to_send), adapter.MAX_TEXT_CHUNK, len(chunks), [len(c) for c in chunks])
- for i, chunk in enumerate(chunks):
- result = await self.send_text_chunk(chat_id, chunk, reply_to if i == 0 else None, group_code=group_code)
- if not result.success:
- return result
- with contextlib.suppress(Exception): # delivery done → FINISH heartbeat (RUNNING… → message → FINISH)
- await adapter._outbound.heartbeat.send_heartbeat_once(chat_id, WS_HEARTBEAT_FINISH)
- return SendResult(success=True)
- async def send_media(self, chat_id: str, handler_name: str, reply_to: Optional[str] = None,
- caption: Optional[str] = None, **kwargs: Any) -> SendResult:
- handler = self._media_handlers.get(handler_name)
- if handler is None:
- return SendResult(success=False, error=f"Unknown media handler: {handler_name!r}")
- return await handler.handle(self._adapter, chat_id, reply_to=reply_to, caption=caption, **kwargs)
- async def send_direct(self, chat_id: str, message: str, media_files: Optional[list[tuple[str, bool]]] = None) -> dict[str, Any]:
- """send_message tool entry: text first, then each media file by extension, on the running adapter."""
- adapter = self._adapter
- last_result: Optional[SendResult] = None
- if message.strip():
- last_result = await adapter.send(chat_id, message)
- if not last_result.success:
- return {"error": f"Yuanbao send failed: {last_result.error}"}
- for media_path, _is_voice in media_files or []:
- send = adapter.send_image_file if Path(media_path).suffix.lower() in self.IMAGE_EXTS else adapter.send_document
- last_result = await send(chat_id, media_path)
- if not last_result.success:
- return {"error": f"Yuanbao media send failed: {last_result.error}"}
- if last_result is None:
- return {"error": "No deliverable text or media remained after processing"}
- return {"success": True, "platform": "yuanbao", "chat_id": chat_id, "message_id": last_result.message_id}
- async def dispatch_msg_body(self, chat_id: str, msg_body: list, reply_to: Optional[str] = None, group_code: str = "") -> SendResult:
- """Lock + dispatch an arbitrary MsgBody to C2C or group."""
- async with self.get_chat_lock(chat_id):
- result = await self._send_msg_body(chat_id, msg_body, reply_to, group_code)
- return self._to_send_result(result)
- @staticmethod
- def _to_send_result(raw: dict) -> SendResult:
- if raw.get("success"):
- return SendResult(success=True, message_id=raw.get("msg_key"))
- return SendResult(success=False, error=raw.get("error", "Unknown error"))
- async def send_text_chunk(self, chat_id: str, text: str, reply_to: Optional[str] = None, retry: int = 3, group_code: str = "") -> SendResult:
- """Send a single text chunk with retry (exponential backoff: 1s, 2s, 4s)."""
- adapter = self._adapter
- last_error: str = "Unknown error"
- for attempt in range(retry):
- try:
- if chat_id.startswith("group:"):
- msg_body = self._build_msg_body_with_mentions(text, chat_id[len("group:"):])
- else:
- msg_body = [_text_elem(text)]
- raw = await self._send_msg_body(chat_id, msg_body, reply_to, group_code)
- if raw.get("success"):
- return self._to_send_result(raw)
- last_error = raw.get("error", "Unknown error")
- logger.warning("[%s] send_text_chunk attempt %d/%d failed: %s", adapter.name, attempt + 1, retry, last_error)
- except Exception as exc:
- last_error = str(exc)
- logger.warning("[%s] send_text_chunk attempt %d/%d exception: %s", adapter.name, attempt + 1, retry, last_error)
- if attempt < retry - 1:
- await asyncio.sleep(2 ** attempt)
- logger.error("[%s] send_text_chunk max retries (%d) exceeded. Last error: %s", adapter.name, retry, last_error)
- return SendResult(success=False, error=f"Max retries exceeded: {last_error}")
- async def _send_msg_body(self, chat_id: str, msg_body: list, reply_to: Optional[str], group_code: str) -> dict:
- """Route a MsgBody to group (``group:<code>``) or C2C (``direct:<account>`` / bare account)."""
- if chat_id.startswith("group:"):
- return await self.send_group_msg_body(chat_id[len("group:"):], msg_body, reply_to)
- return await self.send_c2c_msg_body(chat_id.removeprefix("direct:"), msg_body, group_code=group_code)
- def _build_msg_body_with_mentions(self, text: str, group_code: str) -> list:
- """Parse @nickname patterns against the (unexpired) member cache into mixed TIMTextElem +
- TIMCustomElem(elem_type 1002) msg_body; plain text when no members are cached."""
- cached = self._adapter._member_cache.get(group_code)
- if cached and time.time() - cached[0] >= self._adapter.MEMBER_CACHE_TTL_S:
- del self._adapter._member_cache[group_code]
- cached = None
- if not cached or not cached[1]:
- return [_text_elem(text)]
- nickname_to_uid = {}
- for m in cached[1]:
- nick = m.get("nickname") or m.get("nick_name") or ""
- uid = m.get("user_id") or ""
- if nick and uid:
- nickname_to_uid[nick.lower()] = (nick, uid)
- msg_body: list = []
- last_idx = 0
- for match in self._AT_USER_RE.finditer(text):
- seg = text[last_idx:match.start()].strip()
- if seg:
- msg_body.append(_text_elem(seg))
- nickname = match.group(1)
- entry = nickname_to_uid.get(nickname.lower())
- if entry:
- real_nick, uid = entry
- msg_body.append({"msg_type": "TIMCustomElem",
- "msg_content": {"data": json.dumps({"elem_type": 1002, "text": f"@{real_nick}", "user_id": uid})}})
- else:
- msg_body.append(_text_elem(f"@{nickname}"))
- last_idx = match.end()
- tail = text[last_idx:].strip()
- if tail:
- msg_body.append(_text_elem(tail))
- return msg_body or [_text_elem(text)]
- async def send_c2c_msg_body(self, to_account: str, msg_body: list, group_code: str = "") -> dict:
- req_id = f"c2c_{next_seq_no()}"
- return await self._dispatch_encoded(self._adapter, encode_send_c2c_message(
- to_account=to_account, msg_body=msg_body, from_account=self._adapter._bot_id or "", msg_id=req_id, group_code=group_code,
- ), req_id)
- async def send_group_msg_body(self, group_code: str, msg_body: list, reply_to: Optional[str] = None) -> dict:
- req_id = f"grp_{next_seq_no()}"
- return await self._dispatch_encoded(self._adapter, encode_send_group_message(
- group_code=group_code, msg_body=msg_body, from_account=self._adapter._bot_id or "", msg_id=req_id, ref_msg_id=reply_to or "",
- ), req_id)
- @staticmethod
- async def _dispatch_encoded(adapter: YuanbaoAdapter, encoded: bytes, req_id: str) -> dict:
- """Send pre-encoded bytes via WS → ``{"success", "msg_key" | "error"}``."""
- try:
- response = await adapter._connection.send_biz_request(encoded, req_id=req_id)
- return {"success": True, "msg_key": response.get("msg_id", "")}
- except TimeoutError:
- return {"success": False, "error": f"Request timeout after {DEFAULT_SEND_TIMEOUT}s"}
- except Exception as exc:
- return {"success": False, "error": str(exc)}
- @staticmethod
- def validate_media(file_bytes: Optional[bytes], filename: str, max_size_mb: int = 20) -> Optional[str]:
- """Pre-upload check; error description or None."""
- if not file_bytes:
- return f"Empty file: {filename}"
- if len(file_bytes) > max_size_mb * 1024 * 1024:
- return f"File too large: {filename} ({len(file_bytes) / 1024 / 1024:.1f}MB > {max_size_mb}MB)"
- return None
- @staticmethod
- def truncate_message(content: str, max_length: int = 4000, len_fn: Optional[Callable[[str], int]] = None) -> list[str]:
- """Table/fence-aware chunking via MarkdownProcessor, stripping ``(1/3)`` page indicators."""
- if (len_fn or len)(content) <= max_length:
- return [content]
- chunks = [_INDICATOR_RE.sub('', c) for c in MarkdownProcessor.chunk_markdown_text(content, max_length, len_fn=len_fn)]
- return chunks or [content]
- @staticmethod
- def strip_cron_wrapper(content: str) -> str:
- """Strip the scheduler's cron header/footer wrapper; unchanged when the shape doesn't match."""
- if not content.startswith(CRON_WRAPPER_HEADER_PREFIX):
- return content
- divider = CRON_WRAPPER_DIVIDER
- footer_prefix = CRON_WRAPPER_FOOTER_PREFIX
- divider_pos = content.find(divider)
- footer_pos = content.rfind(footer_prefix)
- if divider_pos < 0 or footer_pos < 0 or footer_pos <= divider_pos or "\n(job_id: " not in content[:divider_pos]:
- return content
- return content[divider_pos + len(divider):footer_pos].strip() or content
- async def close(self) -> None:
- self._chat_locks.clear()
- class OutboundManager:
- """Composes MessageSender, HeartbeatManager and SlowResponseNotifier (sender cancels the notifier
- before a send and emits the FINISH heartbeat after)."""
- def __init__(self, adapter: YuanbaoAdapter) -> None:
- self._adapter = adapter
- self.sender: MessageSender = MessageSender(adapter)
- self.heartbeat: HeartbeatManager = HeartbeatManager(adapter)
- self.slow_notifier: SlowResponseNotifier = SlowResponseNotifier(adapter, self.sender)
- async def close(self) -> None:
- await self.sender.close()
- await self.heartbeat.close()
- await self.slow_notifier.close()
- class YuanbaoAdapter(BasePlatformAdapter):
- """Yuanbao AI Bot adapter backed by a persistent WebSocket connection."""
- PLATFORM = Platform.YUANBAO
- MAX_TEXT_CHUNK: int = 4000 # Yuanbao single message character limit
- splits_long_messages = True # send() auto-chunks via truncate_message(MAX_TEXT_CHUNK)
- MEDIA_MAX_SIZE_MB: int = 50
- DM_MAX_CHARS = 10000
- _active_instance: ClassVar[Optional[YuanbaoAdapter]] = None
- # Per Hermes home: a multiplexed gateway runs one Yuanbao adapter per profile, and the tools /
- # send_message read "the" adapter from inside a profile-scoped turn, so last-wins would route
- # profile B's sends through profile A's bot. Registration and lookup both key on the ambient
- # override (connect/reconnect tasks inherit the profile's Context); the slot above serves the
- # unscoped path.
- _active_instances: ClassVar[dict[str, YuanbaoAdapter]] = {}
- @classmethod
- def get_active(cls) -> Optional[YuanbaoAdapter]:
- from hermes_constants import get_hermes_home_override, hermes_home_key
- if get_hermes_home_override() is None:
- return cls._active_instance
- return cls._active_instances.get(hermes_home_key())
- @classmethod
- def set_active(cls, adapter: Optional[YuanbaoAdapter]) -> None:
- from hermes_constants import get_hermes_home_override, hermes_home_key
- if get_hermes_home_override() is None:
- cls._active_instance = adapter
- elif adapter is None:
- cls._active_instances.pop(hermes_home_key(), None)
- else:
- cls._active_instances[hermes_home_key()] = adapter
- def __init__(self, config: PlatformConfig, **kwargs: Any) -> None:
- super().__init__(config, Platform.YUANBAO)
- _extra = config.extra or {}
- self._app_key: str = (_extra.get("app_id") or "").strip()
- self._app_secret: str = (_extra.get("app_secret") or "").strip()
- self._bot_id: Optional[str] = _extra.get("bot_id") or None
- self._ws_url: str = (_extra.get("ws_url") or DEFAULT_WS_GATEWAY_URL).strip()
- self._api_domain: str = (_extra.get("api_domain") or DEFAULT_API_DOMAIN).rstrip("/")
- self._route_env: str = (_extra.get("route_env") or "").strip()
- # Media resolve concurrency clamped to [min, max] so a bad config can't hammer the backend.
- try:
- _raw_concurrency = int(_extra.get("media_resolve_concurrency", _DEFAULT_RESOLVE_CONCURRENCY))
- except (TypeError, ValueError):
- _raw_concurrency = _DEFAULT_RESOLVE_CONCURRENCY
- self.media_resolve_concurrency: int = max(_MIN_RESOLVE_CONCURRENCY, min(_MAX_RESOLVE_CONCURRENCY, _raw_concurrency))
- self._connection: ConnectionManager = ConnectionManager(self)
- self._outbound: OutboundManager = OutboundManager(self)
- self._inbound_tasks: set[asyncio.Task] = set() # cancelled by disconnect()
- self._background_tasks: set[asyncio.Task] = set() # keeps fire-and-forget tasks alive
- # group_code -> (updated_ts, members); used by @mention resolution, stale after MEMBER_CACHE_TTL_S
- self._member_cache: dict[str, tuple[float, list]] = {}
- self.MEMBER_CACHE_TTL_S: float = 300.0
- self._dedup = MessageDeduplicator(ttl_seconds=300) # WS reconnect / network jitter
- self._group_queues: dict[str, asyncio.Queue] = {} # session_key → sequential dispatch queue
- # Recall support: msg_id/text being processed per session_key (RecallGuardMiddleware), plus a
- # bounded msg_id → content cache for content-match redaction when rows lack a message_id.
- self._processing_msg_ids: dict[str, str] = {}
- self._processing_msg_texts: dict[str, str] = {}
- self._msg_content_cache: dict[str, str] = {}
- def _policy(kind: str) -> tuple[str, list[str]]:
- policy = (_extra.get(f"{kind}_policy") or _yb_secret(f"YUANBAO_{kind.upper()}_POLICY") or "pairing").strip().lower()
- raw = _extra.get(f"{kind}_allow_from") or _yb_secret(f"YUANBAO_{kind.upper()}_ALLOW_FROM", "")
- return policy, [x.strip() for x in raw.split(",") if x.strip()]
- self._access_policy = AccessPolicy(*_policy("dm"), *_policy("group"))
- self._inbound_pipeline: InboundPipeline = InboundPipelineBuilder.build()
- # Auto-sethome stays open when no home is set or the home is a group (upgradable by first DM).
- _existing_home = _yb_secret("YUANBAO_HOME_CHANNEL", "") or (config.home_channel.chat_id if config.home_channel else "")
- self._auto_sethome_done: bool = bool(_existing_home) and not _existing_home.startswith("group:")
- def _track_task(self, task: asyncio.Task) -> asyncio.Task:
- """Register a fire-and-forget task so it won't be GC'd prematurely."""
- self._background_tasks.add(task)
- task.add_done_callback(self._background_tasks.discard)
- return task
- @property
- def enforces_own_access_policy(self) -> bool:
- """Intake gating lives in ``AccessPolicy`` (composed, not inherited), so the flag stays here."""
- return True
- def _sender_may_designate_home(self, ctx: InboundContext) -> bool:
- """Sender may persist YUANBAO_HOME_CHANNEL: strict allowlist, open opt-in, or pairing-approved
- (intake-only pairing forwards are excluded)."""
- policy: AccessPolicy = self._access_policy
- sender = str(ctx.from_account or "").strip()
- if not sender:
- return False
- if ctx.chat_type == "dm":
- if policy.is_dm_allowed(sender):
- return True
- if policy.dm_policy == "pairing":
- from gateway.pairing import PairingStore
- return PairingStore().is_approved(Platform.YUANBAO.value, sender)
- return False
- group_code = str(ctx.group_code or "").strip()
- if ctx.chat_type != "group" or not group_code:
- return False
- if policy.group_policy == "allowlist":
- return policy.is_group_allowed(group_code)
- return policy.group_policy == "open" and policy._open_dm_opted_in()
- async def connect(self, *, is_reconnect: bool = False) -> bool:
- ok = await self._connection.open()
- if ok:
- self._wire_plugin_handlers(None) # plugin-registered native handlers
- return ok
- async def disconnect(self) -> None:
- """Cancel background tasks and close the WebSocket connection."""
- if YuanbaoAdapter._active_instance is self:
- YuanbaoAdapter._active_instance = None
- for home_key, active in list(YuanbaoAdapter._active_instances.items()):
- if active is self:
- del YuanbaoAdapter._active_instances[home_key]
- self._running = False
- self._mark_disconnected()
- self._release_platform_lock()
- await self._connection.close()
- await self._outbound.close()
- for task in list(self._inbound_tasks):
- if not task.done():
- task.cancel()
- self._inbound_tasks.clear()
- self._group_queues.clear()
- logger.info("[%s] Disconnected", self.name)
- async def send(self, chat_id: str, content: str, reply_to: Optional[str] = None,
- metadata: Optional[dict[str, Any]] = None, group_code: str = "") -> SendResult:
- return await self._outbound.sender.send_text(chat_id, content, reply_to, group_code=group_code)
- async def get_chat_info(self, chat_id: str) -> dict[str, Any]:
- return {"name": chat_id, "type": "group" if chat_id.startswith("group:") else "dm"}
- async def send_typing(self, chat_id: str, metadata: Optional[dict] = None) -> None:
- """Start the RUNNING heartbeat (best effort)."""
- with contextlib.suppress(Exception):
- await self._outbound.heartbeat.start(chat_id)
- async def stop_typing(self, chat_id: str) -> None:
- """Stop RUNNING without FINISH — send() emits FINISH after delivery so ordering is
- RUNNING… → message → FINISH."""
- with contextlib.suppress(Exception):
- await self._outbound.heartbeat.stop(chat_id, send_finish=False)
- async def _process_message_background(self, event, session_key: str) -> None:
- """Wrap base class processing with a slow-response notifier."""
- chat_id = event.source.chat_id
- await self._outbound.slow_notifier.start(chat_id)
- try:
- await super()._process_message_background(event, session_key)
- finally:
- self._outbound.slow_notifier.cancel(chat_id)
- # Clear RecallGuard tracking only if our msg_id is still current: a concurrent message may have
- # overwritten it (the drain task then owns it); id-less events never wrote one and must not pop.
- msg_id = event.message_id
- if msg_id and self._processing_msg_ids.get(session_key) == msg_id:
- self._processing_msg_ids.pop(session_key, None)
- self._processing_msg_texts.pop(session_key, None)
- async def _ws_query(self, label: str, group_code: str, encoded: bytes, decode_rsp, empty: dict) -> Optional[dict]:
- """Send an encoded group query over WS; return decoded biz payload, *empty* when none, None on failure."""
- if self._connection.ws is None:
- return None
- try:
- response = await self._connection.send_biz_request(encoded, req_id=decode_conn_msg(encoded)["head"]["msg_id"])
- status = response.get("head", {}).get("status", 0)
- if status != 0:
- logger.warning("[%s] %s failed: status=%d", self.name, label, status)
- return None
- biz_data = response.get("data", b"") or response.get("body", b"")
- return decode_rsp(biz_data) if biz_data and isinstance(biz_data, bytes) else empty
- except TimeoutError:
- logger.warning("[%s] %s timeout: group=%s", self.name, label, group_code)
- except Exception as exc:
- logger.warning("[%s] %s failed: %s", self.name, label, exc)
- return None
- async def query_group_info(self, group_code: str) -> Optional[dict]:
- """Group info (name, owner, member count…); None on failure."""
- return await self._ws_query("query_group_info", group_code, encode_query_group_info(group_code),
- decode_query_group_info_rsp, {"group_code": group_code})
- async def get_group_member_list(self, group_code: str, offset: int = 0, limit: int = 200) -> Optional[dict]:
- """Group member list; None on failure. Populates ``_member_cache`` for @mention resolution."""
- result = await self._ws_query(
- "get_group_member_list", group_code, encode_get_group_member_list(group_code, offset=offset, limit=limit),
- decode_get_group_member_list_rsp, {"members": [], "next_offset": 0, "is_complete": True},
- )
- if result and result.get("members"):
- self._member_cache[group_code] = (time.time(), result["members"])
- return result
- async def send_dm(self, user_id: str, text: str, group_code: str = "") -> SendResult:
- """Proactive C2C DM (text capped at DM_MAX_CHARS); group_code marks a group-originated DM."""
- if not self._access_policy.is_dm_allowed(user_id):
- return SendResult(success=False, error="DM access denied for this user")
- if len(text) > self.DM_MAX_CHARS:
- text = text[:self.DM_MAX_CHARS] + t("platform.shared.truncated_suffix")
- return await self.send(f"direct:{user_id}", text, group_code=group_code)
- # Media sends delegate to MessageSender.send_media via the named handler strategy.
- async def send_image(self, chat_id: str, image_url: str, caption: Optional[str] = None,
- reply_to: Optional[str] = None, metadata: Optional[dict] = None, **kwargs: Any) -> SendResult:
- return await self._outbound.sender.send_media(chat_id, "image_url", reply_to=reply_to, caption=caption, image_url=image_url, **kwargs)
- async def send_image_file(self, chat_id: str, image_path: str, caption: Optional[str] = None,
- reply_to: Optional[str] = None, metadata: Optional[dict] = None, **kwargs: Any) -> SendResult:
- return await self._outbound.sender.send_media(chat_id, "image_file", reply_to=reply_to, caption=caption, image_path=image_path, **kwargs)
- async def send_sticker(self, chat_id: str, sticker_name: Optional[str] = None, face_index: Optional[int] = None,
- reply_to: Optional[str] = None, **kwargs: Any) -> SendResult:
- return await self._outbound.sender.send_media(chat_id, "sticker", reply_to=reply_to, sticker_name=sticker_name, face_index=face_index, **kwargs)
- async def send_document(self, chat_id: str, file_path: str, filename: Optional[str] = None, caption: Optional[str] = None,
- reply_to: Optional[str] = None, metadata: Optional[dict] = None, **kwargs: Any) -> SendResult:
- return await self._outbound.sender.send_media(
- chat_id, "document", reply_to=reply_to, caption=caption, file_path=file_path, filename=filename, **kwargs,
- )
- async def _get_cached_token(self) -> dict:
- """Current valid sign token (module-level cache)."""
- return await SignManager.get_token(self._app_key, self._app_secret, self._api_domain, route_env=self._route_env)
|