i8 ~dZddlmZddlZddlZddlZddlZddlZddlZddl m Z ddl m Z mZmZmZmZmZ ddlZddlmZddlmZddlmZdd lmZdd lmZdd l m!Z!dd l"m#Z#d Z$n#e%$rdZ$dZdZdZdZdZdZe&Z!dZ#YnwxYwddl'm(Z(m)Z)e(dddl*m+Z+ddl,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5ej6dZ7ej8dZ9ddgZ:dZ;dZdZ?dZ@eAhdZBdd(ZGd?d*ZHd@d-ZIGd.d/ZJGd0d1e-ZKdAd4ZLd=d5ZMdAd6ZNdBd8ZOdCd:ZPdCd;ZQdS)Du Google Chat platform adapter. Uses Google Cloud Pub/Sub (pull subscription) for inbound events and the Google Chat REST API for outbound messages. Pattern parallels Slack Socket Mode and Telegram long-polling: no public endpoint required. Concurrency model ----------------- The Pub/Sub SubscriberClient invokes its message callback in a background thread (managed by the client's internal executor). The adapter's ``handle_message`` coroutine must run on the asyncio event loop, so the callback uses ``asyncio.run_coroutine_threadsafe`` with ``add_done_callback`` (never ``.result()`` — that would block the callback thread and saturate the Pub/Sub executor under load). All outbound Chat REST calls go through ``asyncio.to_thread`` because the googleapiclient is synchronous. This keeps the event loop responsive. Pub/Sub delivery diagram:: Pub/Sub stream -> callback thread -> asyncio loop (streaming_pull) (_on_pubsub_message) (handle_message) | | | | at-least-once | parse + dedup | agent work | delivery | _submit_on_loop | send() response | | message.ack() | v v v Event type routing ------------------ Inbound envelope carries ``type`` in [MESSAGE, ADDED_TO_SPACE, REMOVED_FROM_SPACE, CARD_CLICKED]. Only MESSAGE dispatches to the agent. ADDED_TO_SPACE caches the bot's resource name (belt-and-suspenders on top of eager resolution in connect()). CARD_CLICKED is ACK'd only in v1 (follow-up PR implements interactivity). ) annotationsN)Path)AnyCallableDictListOptionalTuple) pubsub_v1) exceptions)service_account)AuthorizedHttp)build) HttpError)MediaFileUploadTF)PlatformPlatformConfig google_chat)MessageDeduplicator) BasePlatformAdapter MessageEvent MessageTypeProcessingOutcome SendResultcache_audio_from_bytescache_document_from_bytescache_image_from_bytescache_video_from_byteszgateway.platforms.google_chatz:^projects/(?P[^/]+)/subscriptions/(?P[^/]+)$z(https://www.googleapis.com/auth/chat.botz&https://www.googleapis.com/auth/pubsubg?g @g333333?>exc BaseExceptionreturnboolct|dd}t|dd}t|tr |tvSt |}d|vsd|vrdSd|vrd|vsd |vsd |vrdSd |vsd |vrdSd S)uClassify outbound API errors as transient (retryable) vs permanent. Retries are applied to: - HTTP 429 (rate-limited) - HTTP 5xx (server errors) - Network/transport failures (timeout, connection reset, DNS) Authentication errors (401/403), client errors (4xx other than 429), and well-formed non-retryable failures are NOT retried — those indicate a misconfiguration or revoked token, not a hiccup. respNstatustimeoutz timed outT connectionresetrefusedabortedz broken pipezremote disconnectedF)getattr isinstanceint_RETRYABLE_HTTP_STATUSESstrlower)r'r,r-texts J/home/piyush/.hermes/hermes-agent/plugins/platforms/google_chat/adapter.py_is_retryable_errorr;s 3 % %D T8T * *F&#2111 s88>>  DDK4//ttDI4E4EVZIZIZt 5 = =t 5z ctS)z9Check if Google Chat optional dependencies are installed.)GOOGLE_CHAT_AVAILABLEr<r:check_google_chat_requirementsr@s  r<)zgoogleapis.comzchat.google.comzdrive.google.comzdocs.google.comzlh3.googleusercontent.comzlh4.googleusercontent.comzlh5.googleusercontent.comzlh6.googleusercontent.comurlr7c ddlm}||}n#t$rYdSwxYw|jdkrdS|jpdsdSt fdtDS)zAReturn True iff *url* is https and targets a Google-owned domain.r)urlparseFhttpsc3TK|]"}|kpd|zV#dS).N)endswith).0hhosts r: z(_is_google_owned_host..s<VVqtqy2DMM#'22VVVVVVr<) urllib.parserC Exceptionschemehostnamer8any_TRUSTED_ATTACHMENT_HOSTS)rArCparsedrKs @r:_is_google_owned_hostrTs))))))# uu }u O !r ( ( * *D u VVVV/subscriptions/zprojects/[^/\s]+/topics/[^/\s]+z%projects//topics/z9[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.iam\.gserviceaccount\.comz&@.iam.gserviceaccount.com)resub)r9s r:_redact_sensitiverXsj  616   D 6*/   D 6D0   D Kr<mimerc|s tjS|dr tjS|dr tjS|dr tjStjS)zMap a MIME string to a hermes MessageType. Anything not image/audio/video falls through to DOCUMENT so the agent still receives the file. image/audio/video/)rDOCUMENT startswithPHOTOAUDIOVIDEO)rYs r:_mime_for_message_typercsu $## x  !   x  !   x  !   r<c:eZdZdZddZddZdd Zdd ZddZdS)_ThreadCountStoreuRPer-(chat_id, thread_name) inbound message counter, persisted to disk. Drives the DM main-flow vs side-thread heuristic: - prev_count == 0 (first time we see this thread) → "main flow": Google Chat just auto-created a fresh thread for the user's top-level message. Treat it as part of the shared DM session; bot replies at top-level (no thread.name on outbound). - prev_count >= 1 (we've already seen this thread) → "side thread": user explicitly engaged a thread that's been around. Isolate session by thread, route bot reply into the same thread. Persistence is essential: without it, every gateway restart wipes counts and active side-threads silently demote to "main flow", which leaks main-flow context into the user's isolated thread (the bug Ramón reported across 4 iterations of the in-memory version). File format (JSON): {"": {"": , ...}, ...} Failure modes are non-fatal: a missing or corrupt file resets to empty (logged as warning) so the adapter never crashes on disk issues. The next ``incr`` will write a fresh file. Save strategy: write-through after every ``incr``. The file is tiny (a few KB even for very active bots), so the simplicity of write-through outweighs the cost of debouncing for now. path_Pathc0||_i|_d|_dSNF)_path_counts_loaded)selfrfs r:__init__z_ThreadCountStore.__init__(s 24  r<r)NonecLd|_|js i|_dS |j}|rt j|ni}n#t j$r3}t d|j|i|_Yd}~dSd}~wt$r3}t d|j|i|_Yd}~dSd}~wwxYwi}t|tr|D]\}}t|trt|ts0i}|D]4\}} t|trt| t r| ||<5|r|||<||_dS)uLoad counts from disk. Safe to call multiple times. Missing file → empty store. Corrupt JSON → empty store + warn. TNzD[GoogleChat] thread-count store at %s is corrupt; starting fresh: %sz8[GoogleChat] could not read thread-count store at %s: %s)rlrjexistsrk read_textstripjsonloadsJSONDecodeErrorloggerwarningOSErrorr4dictitemsr7r5) rmrawdatar'cleanchat_idthreads clean_threads thread_namecounts r:loadz_ThreadCountStore.load-s  z  "" DL F *&&((C&)iikk94:c???rDD#    NN% C    DL FFFFF    NNJ C   DL FFFFF  ,. dD ! ! 3$(JJLL 3 3 !'3//z'47P7P02 *1--//;;&K!+s33; 5#8N8N;5: k2 3%2E'N s$AA//C,>(B,, C,9(C''C,rr7rr5c`|j|i|dS)z:Return the current count for (chat_id, thread_name), or 0.r)rkget)rmrrs r:rz_ThreadCountStore.getVs*|,,00a@@@r<c|j|i}||d}|dz||<||S)uIncrement count and write through to disk. Returns the PRE-increment value (the heuristic input — "have we seen this thread before this message?").r)rk setdefaultr_save)rmrr chat_countsprevs r:incrz_ThreadCountStore.incrZsNl--gr:: {A..#'!8 K   r<c |jjdd|j|jjdz}|t j|jdtj ||jdS#t$r,}t d|j|Yd}~dSd}~wwxYw)uAtomic write of the counts dict to disk. Failure is non-fatal — log warning and continue. The in-memory counts stay consistent within the running process; only restart recovery is affected. Tparentsexist_okz.tmp),:) separatorsz;[GoogleChat] could not persist thread-count store to %s: %sN)rjparentmkdir with_suffixsuffix write_textrtdumpsrkosreplaceryrwrx)rmtmpr's r:rz_ThreadCountStore._saveds  J  # #D4 # @ @ @*(():V)CDDC NN4:dlzJJJ K K K JsDJ ' ' ' ' '    NNM C          sBB C !CC N)rfrgr)ro)rr7rr7r)r5) __name__ __module__ __qualname____doc__rnrrrrr?r<r:rere s< ''''RAAAAr<rec`eZdZdZeZdZdZdZd}fd Z d~d Z dd Z e ddZ e ddZddZddZddZddZddZddZddZdd Ze ddd&Zdd(Zdd*Z ddd0Zdd2Zdd5Z ddd;Zd +/)++ 02#0257! 4 L L L L L L++--LL#[1 4 4 4 :<<)3LLL 4#4 ; ;$ $  @B" >@$ +Es!K!KLLbi(?EUAVAVWWXXsC'C>=C>r)rc|jjdptjd}|rK|drf tj|}n*#tj $r}td||d}~wwxYwtj |tStj|st#d t%|dd 5}tj|}dddn #1swxYwYn*#tj $r}td ||d}~wwxYwtj |tS d dlm}n#t,$rd}YnwxYw|td  |t\}}n%#t0$r}td||d}~wwxYwt2d|S)uLoad Service Account credentials from env or config.extra, falling back to Application Default Credentials. Priority: 1. Explicit ``extra['service_account_json']`` (path or inline JSON) 2. ``GOOGLE_APPLICATION_CREDENTIALS`` env var (path) 3. Application Default Credentials via ``google.auth.default()`` — works on Cloud Run / GCE / GKE with a workload identity attached, or locally via ``gcloud auth application-default login``. Lets operators run the gateway in GCP without managing SA key files. Pattern lifted from PR #14965. service_account_jsonGOOGLE_APPLICATION_CREDENTIALS{z"Inline SA JSON is not valid JSON: N)scopesz7Service Account JSON file not found at configured path.rutf-8encodingz-Service Account JSON file is not valid JSON: rzNo Service Account credentials configured. Set GOOGLE_CHAT_SERVICE_ACCOUNT_JSON or GOOGLE_APPLICATION_CREDENTIALS, or install google-auth to use Application Default Credentials.zNo Service Account credentials configured and Application Default Credentials are unavailable. Set GOOGLE_CHAT_SERVICE_ACCOUNT_JSON or run ``gcloud auth application-default login``. ADC error: zI[GoogleChat] No SA JSON configured; using Application Default Credentials)rextrarrrlstripr_rtrurv ValueErrorr Credentialsfrom_service_account_info _CHAT_SCOPESrfrqFileNotFoundErroropenr google.authauthrdefaultrNrwinfo)rmsa_pathrr'fh google_auth credentials_projects r:_load_sa_credentialsz&GoogleChatAdapter._load_sa_credentialss K  ! !"8 9 9 ;y9::   ~~**3// :g..DD+$BSBB'2LLM7>>'** 'N '3999)R9R==D)))))))))))))))'    ICII #.HH\I    - - - - - - -   KKK   Q  $/$7$7|$7$L$L !K   $" $$       "   s~A44BBB3D2D& D2&D**D2-D*.D22EEEF FF.G G/G**G/Tuple[str, str]cp|jjd}|jjd}|std|stdt|}|std|d|krtd||fS)zReturn (project_id, subscription_path) after validation. Raises ValueError with a sanitized message on any config problem. project_idsubscription_namez/subscriptions/'.projectzjproject_id in GOOGLE_CHAT_PROJECT_ID does not match the project embedded in GOOGLE_CHAT_SUBSCRIPTION_NAME.)rrrr_SUBSCRIPTION_PATH_REmatchgroup)rmr subscriptionrs r:_validate_configz"GoogleChatAdapter._validate_config.s [&**<88 {(,,-@AA  N  Y &++L99 <  ;;y ! !Z / /E <''r<futureroc |dS#t$rtdYdSwxYw)Nz1[GoogleChat] Background inbound processing failed)resultrNrw exception)rs r:_log_background_failurez)GoogleChatAdapter._log_background_failureMsV R MMOOOOO R R R   P Q Q Q Q Q Q Rs$AAloop#Optional[asyncio.AbstractEventLoop]r*cZ|duo'tt|dd S)N is_closedcdSrir?r?r<r:z;GoogleChatAdapter._loop_accepts_callbacks..VsPUr<)r*r3)rs r:_loop_accepts_callbacksz)GoogleChatAdapter._loop_accepts_callbacksTs44Y-VWT; -V-V-X-X(Y(Y$YYr<coroc.|j}||stddS t j||}n+#t $rtdYdSwxYw||jdS)zHSchedule a coroutine on the adapter loop from a Pub/Sub callback thread.z9[GoogleChat] Loop not accepting callbacks; dropping eventNz1[GoogleChat] Loop closed between check and submit) rrrwrxasynciorun_coroutine_threadsafe RuntimeErroradd_done_callbackr)rmrrrs r:_submit_on_loopz!GoogleChatAdapter._submit_on_loopXsz++D11  NNV W W W F 5dDAAFF    NNN O O O FF    !=>>>>>sA$A87A8rgctjdttjdz }t|dz S)zBLocation where the resolved bot user_id is cached across restarts. HERMES_HOMErzgoogle_chat_bot_id.json)rrr7rgr)rmbases r:_bot_id_cache_pathz$GoogleChatAdapter._bot_id_cache_pathjs8yEJLL9,D(E(EFFT{{666r< Optional[str]c|}|sdS tj|d}|dpdS#t tjf$rYdSwxYw)Nrr bot_user_id)r rqrtrurrrryrv)rmrfr}s r:_load_cached_bot_idz%GoogleChatAdapter._load_cached_bot_idos&&(({{}} 4 :dnngn>>??D88M**2d 2-.   44 s>A++BBr r7c |}|jdd|t jd|iddS#t $r tddYdSwxYw)NTrr rrz0[GoogleChat] Could not persist bot_user_id cacheexc_info) r rrrrtrryrwdebug)rmr rfs r:_save_cached_bot_idz%GoogleChatAdapter._save_cached_bot_idys \**,,D K  dT  : : : OO M;788        \ \ \ LLKVZL [ [ [ [ [ [ \sAA&B B c Kg}jjr5jjjr$|jjjt jdd}|r2|d|dD|D]} tj |ffd d{V}nM#t$r@}t d|tt|Yd}~hd}~wwxYw|dgD]`}|d id d kr1|d id }|r|ccSadS) udResolve ``users/{id}`` via Chat API members.list on a known space. Tries the home channel first, then any space from the allowlist. If no space is known, returns None and self-filter falls back to filtering ``sender.type == 'BOT'`` (which is still safe but less precise — own messages and other bots look alike). GOOGLE_CHAT_BOOTSTRAP_SPACESrEc3fK|],}||V-dSN)rs)rIss r:rLz9GoogleChatAdapter._resolve_bot_user_id..sK$$aggii$ $$$$$$r<rcj|dS)N2)rpageSizehttp)rspacesmemberslistexecute_new_authed_http)rrms r:rz8GoogleChatAdapter._resolve_bot_user_id..sMDN$9$9$;$;WYYTRT00W$"7"7"9"9W::r<Nz*[GoogleChat] members.list failed on %s: %s membershipsmembertypeBOTname)r home_channelrappendrrrsextendsplitr to_threadrrwrrXr7r)rmcandidate_spaces extra_spacesspacerr'r#r&s` r:_resolve_bot_user_idz&GoogleChatAdapter._resolve_bot_user_ids') ; # F (@(H F  # #DK$<$D E E Ey!?DDJJLL    # #$$#/#5#5c#:#:$$$   & $ $E  ' 1";;;;;!!     @%c#hh//   "++mR88 $ $::h++//775@@!::h3377??D$#  $ ts'C D6D  Dc   KtsddddStj_ \} nn#ttf$rZ}tt|}t d|d|dYd}~dSd}~wwxYw|_ __ tjfdd{V_ng#t$$rZ}tt|}t d |d |dYd}~dSd}~wwxYw d d lm}mm}tj|d{V D _tj fd d{V_tdtj|d{V}|r=tdt5|d|n tdnZ#t$$rM}tdtt|d_d_Yd}~nd}~wwxYw tjjjd{Vn,#t$$rtddYnwxYwt?j _! tj fdd{Vn#tDj#$rdddYdStDj$$rdddYdSt$$rZ}tt|}t d|d|dYd}~dSd}~wwxYw%_&j&s['d{V_&j&r(j&ntdtj)*_+,td|j&pd j-j.dS)!zBValidate config, authenticate, start Pub/Sub pull, resolve bot id. missing_depsz.s"  +$) r<z0[GoogleChat] Failed to build Chat API client: %s chat_api_initr)load_user_credentialsbuild_user_chat_servicelist_authorized_emailscSrr?)_build_user_chat user_credssr:rz+GoogleChatAdapter.connect..s,,Z88r<uN[GoogleChat] Legacy user OAuth loaded — fallback attachment delivery enabledz1[GoogleChat] %d per-user OAuth tokens on disk: %sz, u[GoogleChat] No user OAuth tokens at setup — file attachments will degrade to text-only fallback. Each user runs /setup-files once in their own DM to enable native attachments.zX[GoogleChat] User OAuth load failed (attachments will degrade to text-only fallback): %szK[GoogleChat] thread-count store load failed (treating all threads as fresh)Trr<c>jdiS)Nr)request)rget_subscription)rmsubscription_pathsr:rz+GoogleChatAdapter.connect..s((99+->?:r<subscription_not_foundz1Pub/Sub subscription not found at configured pathsubscription_permissionzAService Account lacks roles/pubsub.subscriber on the subscriptionz([GoogleChat] subscription.get failed: %ssubscription_checkz^[GoogleChat] bot_user_id not yet resolved; will resolve on first addedToSpace or member lookupzl[GoogleChat] Connected; project=%s, subscription=, bot_user_id=%s, flow_control(msgs=%s, bytes=%s)z )/r>_set_fatal_errorrget_running_looprrrrrrXr7rwerrorrrrr+rrNoauthr>r?r@rrrlenjoinrxrrr SubscriberClientrgax_exceptionsNotFoundPermissionDeniedr rr/r create_task_run_supervisorr_mark_connectedrr) rmrr'msg_load_user_creds _list_emails authorizedrBrrGrCs ` @@@@r:connectzGoogleChatAdapter.connectsf$   ! !#V "    5-//  ,0,A,A,C,C )J)3355KK-.   #CHH--C LLDc J J J  ! !'7PU ! V V V55555   &"3' #*#4$$DNN   #CHH--C LLKS Q Q Q  ! !u ! U U U55555  $ '           '01ABBBBBBBBJ%)3&,3,=88888--''''''# 2 '0>>>>>>>>J  G OOTYYz%:%:# 4  ' ' ' NN5!#c((++    &*D ""&D       ' #D$<$ABB B B B B B B B B    NN(26       %5+NNN #         &     ! !-K "    55.     ! !.# "   55   #CHH--C LLCS I I I  ! !';STX ! Y Y Y55555  !4466  &*&?&?&A&A A A A A A AD   (():;;;; J!( 3D4H4H4J4J K K   >    /   O    ts+A..C?ACC2"D E9AE44E9=CI J4'AJ//J48$K&LL$M'O9-&O9 O9AO44O9cKd|_|jrv|js]|j t j|jdd{Vn!#tjtjf$rYnwxYw|jW |jt j |jj dd{Vn#t$rYnwxYwd|_|j = t j |j j d{Vn#t$rYnwxYwd|_ |tddS)zKClean shutdown: stop accepting new messages, wait in-flight, close clients.T@r.Ng$@z[GoogleChat] Disconnected)rrdonecancelrwait_forCancelledError TimeoutErrorrr+rrNrclose_mark_disconnectedrwrrms r: disconnectzGoogleChatAdapter.disconnectFs"   )>)C)C)E)E   ! ( ( * * * &t'??????????    #D  !!! /00000s6!A&&BB>C CC-$D DDc0Kd}|js tj|j|j} |j|j|j |}||_ |dkrt d|d}tj|jd{V|jrdSnX#tj$rYdSt"j$r|ddd YdSt"j$r|d d d YdSt*$r}|d z }t-t/|}td ||j|||jkr"|dd|dd Yd}~dSt5|j|jd|d z zz}t;jd|} tj|d{Vn#tj$rYYd}~dSwxYwYd}~nd}~wwxYw|jdSdS)a Run the streaming_pull with exponential backoff; fatal after 10 attempts. ``subscribe()`` returns a concurrent.futures.Future that resolves when the stream dies. We await ``future.result()`` in a worker thread and react to exceptions. r) max_messages max_bytes)callback flow_controlz9[GoogleChat] Pub/Sub stream reconnected after %d attemptsN pubsub_authz6Pub/Sub authentication failed (SA key invalid/revoked)Fr2pubsub_permissionz.SA lacks pubsub.subscriber on the subscriptionrz4[GoogleChat] Pub/Sub stream died (attempt %d/%d): %spubsub_reconnect_exhaustedzPub/Sub reconnect failed z times; giving up) rr types FlowControlrrr subscriber_on_pubsub_messagerrwrrr+rrcrRUnauthenticatedrKrTrNrXr7rx_MAX_RECONNECT_ATTEMPTSmin_RECONNECT_MAX_DELAY_RECONNECT_BASE_DELAYrandomuniformsleep)rmattemptflowrr'rXdelay sleep_fors r:rVz!GoogleChatAdapter._run_supervisorbs%= ?..!///D8 )33+!4!%4 /5+Q;;KK []deee' 666666666&F)   !1   %%&T#& !2   %%,L#&    1 'C11J0  d:::))9 VG V V V"'* FFFFF-.!! 2DE #N1e44 !- 2222222222-FFFFFF32222/ I%= = = = = sUA7B44H &H /&H  H !A*H8H G%$H%G<4H;G<<HH rEenvelopeDict[str, Any]ce_type4Optional[Tuple[Dict[str, Any], Dict[str, Any], str]]c<|dpi}|r|dnd}|rH|dpi}|dp|dpi}||dfSt|dtrU|ddd krdS|d}|dp|dpi}||d fSd |vsd |vr|d d d krdS|d pd}|d p|pd}d|pdddddz}|ddpd} |ddpd|||dd| | d}|dpd} | rd| i|d<|ddpd|ddd }||d!fSdS)"uDetect Pub/Sub envelope format and return ``(message, space, format_name)``. Three known formats are accepted. Returns ``None`` when the envelope is unrecognized, is a non-MESSAGE event, or otherwise should be silently dropped. Format 1 — Workspace Add-ons (canonical, ce-type-driven):: {"chat": {"messagePayload": {"message": {...}, "space": {...}}}} Format 2 — Native Chat API Pub/Sub (alternative configuration where the Chat app publishes events directly without the Workspace Add-ons wrapper):: {"type": "MESSAGE", "message": {...}, "space": {...}} Format 3 — Relay / flat (a custom Cloud Run relay that flattens the Chat event into top-level fields):: {"event_type": "MESSAGE", "sender_email": "...", "text": "...", "space_name": "spaces/X", "thread_name": "spaces/X/threads/Y", "message_name": "spaces/X/messages/M.M"} For format 3 the helper synthesizes a Chat-API-shaped ``message`` dict so downstream code (``_dispatch_message`` → ``_build_message_event``) can consume it without branching. r8messagePayloadNr4r.workspace_addonsr$rEMESSAGEnative_chat_api event_type sender_emailsender_display_nameUnknownz users/relay-unknown@_at_rG_r9 message_nameHUMAN)r&email displayNamer$)r&senderr9 argumentTextrr&thread space_name space_typeSPACE)r& spaceType relay_flat)rr4rzrsr) rr chat_blockmsg_payload_wrapperrXr.rsender_displaysender_name_surrogater9rs r:_extract_message_payloadz*GoogleChatAdapter._extract_message_payloadsH\\&))/R BLVjnn-=>>>RV  2%)))44:C'++G44N8H8HNBE11 1 hll9--t 4 4 1||FB''944t9%CLL))CSWWW-=-=CE00 0 8 # #~'A'A||L)44 AAt$LL88>BEEGGL 233 ,955c6BBJJ3PSTTU "<<++1rD ^R88>B1)#1#   $ # #C#,,}55;K 6!' 5H  \266<"%\\,@@E|+ +tr<r4c |jr|dS tj|jd}n?#t $r2td| YdSwxYwtt|dipi}| dpd}t dt||t!jdrZ d d lm}|tj|}n#t $rd }YnwxYwt d |dd  | dpi}d|vsd|vr(| dpi}| dpi} | dpi} d|vr| dpi} | ddkr:|js3| d} | r| |_|| td| ddn/td| dd| dSd|vsd|vr0td| dS|||} | Qt d|t|| dS| \}} }| dpi}| dpd}|dkr| dS| dpd}|rK|j|r1t d || dSt|}d|vr| r| |d<t|}d|vr| r| |d<||||| dS#t $rEtd! | YdS#t $rYYdSwxYwwxYw)"uPub/Sub callback — parse envelope and dispatch to asyncio loop. Runs in a Pub/Sub SubscriberClient worker thread, NOT the event loop. Never block this function; never raise out of it (that triggers Pub/Sub nack + infinite redelivery). Google Chat Events API uses CloudEvents-style Pub/Sub messages. The event type is carried in Pub/Sub message attributes (``ce-type``), not in the JSON body. The body is wrapped in a ``chat`` object whose keys depend on the event type: - google.workspace.chat.message.v1.created -> envelope["chat"]["messagePayload"] = {space, message} - google.workspace.chat.membership.v1.created -> envelope["chat"]["membershipPayload"] = {space, membership} - google.workspace.chat.membership.v1.deleted -> envelope["chat"]["membershipPayload"] = {space, membership} Nrz-[GoogleChat] Could not parse Pub/Sub envelope attributeszce-typerEz)[GoogleChat] Envelope keys=%s, ce-type=%sGOOGLE_CHAT_DEBUG_RAWr)redact_sensitive_textzz([GoogleChat] RAW envelope (redacted): %sir8 membership MEMBERSHIPmembershipPayloadr.createdr#r$r%r&z[GoogleChat] ADDED_TO_SPACE %s?z"[GoogleChat] REMOVED_FROM_SPACE %swidgetcardz;[GoogleChat] Card/widget event ack'd (v2 feature, deferred)zO[GoogleChat] Envelope did not match a known message format; ce-type=%s, keys=%srz[GoogleChat] Dedup drop for %sz([GoogleChat] Error in _on_pubsub_message)rnackrtrur}decoderNrwrackrzr3rrrkeysrr agent.redactrrrrrr8rr is_duplicater_dispatch_message)rmr4rattrsrrdumprmplr.rr#r& extractedrX_fmtr sender_typemsg_namemsg_with_space enriched_envs r:ruz$GoogleChatAdapter._on_pubsub_message s"&    LLNNN F z',"5"5g">">??HH      L M M M KKMMM FF  WWlB77=2>>))I&&," 7  ! !    9, - - R  5>>>>>>,,TZ-A-ABB 5 5 54 5 LLCT%4%[ Q Q QN !f--3Jw&&,'*A*A nn%899?R((.B WW\228b '''^^H55;Fzz&))U224;L2%zz&11;04D- 44T:::KK8%))FC:P:PKKT>T 7""f &?&? Q 55hHHI  *+2D4I4I ( CWWX&&,"F **V,,2Ke## wwv,"H DK44X>>  =xHHH "#YYNn,,,*/w' >>Ll**u*(- W%  !7!7 !U!U V V V KKMMMMM      G H H H        sq,A 8BB#D66 EE,ER4AR>A'R'AR7A"RA1R$S3S  SSSSrXcK |||d{V}|dS|jpd}|dr_|jX|jr|jjr |jjnd}||jj|jj||d{V}|rdS| |d{VdS#t$rt dYdSwxYw)uTranslate a Chat message payload to a MessageEvent and hand off. Intercepts the ``/setup-files`` admin command BEFORE the agent sees it — that's a bot-local OAuth setup flow, not a prompt. Everything else flows to ``handle_message`` as normal. NrEz /setup-files)r thread_idraw_textrz%[GoogleChat] _dispatch_message failed) _build_message_eventr9rsr_source user_id_alt_handle_setup_files_commandrrhandle_messagerNrwr)rmrXreventr9rhandleds r:rz#GoogleChatAdapter._dispatch_messagesf F33CBBBBBBBBE}J$"++--D~.. 5<3K|(- (@EL,, !% @ @!L0#l4!!- !A!! F%%e,, , , , , , , , , , F F F   D E E E E E E FsCB C3C$C87C8Nrrrrcl Kddlm|r&|nd}|d}t |dkr|dnd}d)fd }|s} |} | } | r |nd} | |pd } |d | d | dd{VdS| s|dd{VdS|dd{VdS|dkr]s|dd{VdS ddl }ddl }| }| |5tjj|d{Vdddn #1swxYwY|d}nd#t&$r|dd{VYdSt($r:}t*d||d|d{VYd}~dSd}~wwxYw|d|dd{VdS|dkrE ddl }ddl }| }| |5tjj|d{Vdddn #1swxYwY|pd}nT#t&$rd}YnFt($r:}t*d||d|d{VYd}~dSd}~wwxYw|r7j|dj|dnd_d_|d |d!d{VdS ddl }ddl }| }| |5tjj||d{Vdddn #1swxYwY|}nd#t&$r|d"d{VYdSt($r:}t*d#||d|d{VYd}~dSd}~wwxYw tjj |d{VVtjfd$d{V}|rj|<|j|<n_|_|d%d{VdSn2#t($r%}t*d&|Yd}~nd}~wwxYw|d'|d(|d!d{VdS)*uPRun the in-chat OAuth setup flow for native attachment delivery. Returns ``True`` if the message was consumed (no agent dispatch), ``False`` if it should fall through. Multi-user mode: ``sender_email`` is the asker's identity, which is also the per-user OAuth key. ``status`` / ``start`` / ``revoke`` / code-exchange all operate on THIS user's token slot. When ``sender_email`` is ``None`` (e.g. tests, or older inbound events without a populated email field) the handler falls back to the legacy single-user path so pre-multi-user installs keep working. Subcommands: /setup-files → show status + next step /setup-files start → print OAuth URL /setup-files revoke → revoke and delete stored token /setup-files → exchange auth code for token Pre-requisite: client_secret.json must already be on the host (one-time terminal step). The status reply tells the user how to do that if it's missing. r)rNN)maxsplitrEr9r7r)rocKd|i}rdi|d< |d{VdS#t$r tddYdSwxYw)Nr9r&rz+[GoogleChat] /setup-files reply send failedTr)_create_messagerNrwr)r9bodyrrmrs r:_replyz=GoogleChatAdapter._handle_setup_files_command.._replys$*D>D 5"()!4X **7D99999999999    A! s0&AAzshared (legacy)u2✅ Native attachment delivery is **active** for `z `. Token: `z(` Send `/setup-files revoke` to disable.Tu🔧 Native attachment delivery is **not configured**. **Step 1 (one-time, on the host):** create OAuth client credentials at https://console.cloud.google.com/apis/credentials → *Create credentials* → *OAuth client ID* → *Desktop app*. Download the JSON. Then on the host run: ``` python -m plugins.platforms.google_chat.oauth --client-secret /path/to/client_secret.json ``` **Step 2:** come back here and send `/setup-files start`.uf🔧 Client credentials are stored but you haven't authorized yet. Send `/setup-files start` to begin.startuf⚠️ No client credentials stored on the host. Send `/setup-files` (no args) for setup instructions.rug❌ Couldn't generate the OAuth URL. Check the gateway logs and verify the client_secret.json is valid.z*[GoogleChat] /setup-files start failed: %su ❌ Error: z01. Open this URL in your browser and authorize: u> 2. After clicking *Allow*, your browser will fail to load `http://localhost:1/?...&code=...`. That's expected. 3. Copy the entire failed URL from the browser's URL bar and paste it back here as: `/setup-files ` (or just the `code=...` value). Tip: the URL contains your access grant — keep it private.revokezRevoked.z4Revoke completed (some steps may have been skipped).z+[GoogleChat] /setup-files revoke failed: %su❌ Error revoking: u✅ Done. ``` z ```u❌ Token exchange failed. The code may have expired or the URL is malformed. Send `/setup-files start` to get a fresh OAuth URL.z-[GoogleChat] /setup-files exchange failed: %sc.Sr)r?) new_creds oauth_helpersr:rz?GoogleChatAdapter._handle_setup_files_command..xsL@@KKr<uZ✅ Authorized! Native attachment delivery is now active. Try asking me to send you a PDF.z0[GoogleChat] post-exchange creds load failed: %suz⚠️ Token exchanged but the gateway couldn't load the new credentials in-memory. Restart the gateway and the token at `z(` will be picked up. Helper output: ``` )r9r7r)ro)rErNrsr8r*rO_client_secret_pathrq _token_pathr>io contextlibStringIOredirect_stdoutrr+ get_auth_urlgetvalue splitlines SystemExitrNrwrxrrpoprrrexchange_auth_code)rmrrrr sender_keypartsargrclient_secret_present token_path token_presentcredswhorrbufauth_urlr'outputnew_apirrs``` @@r:rz-GoogleChatAdapter._handle_setup_files_commands : ,+++++ 6BK\''))//111t **"%e**q..eAhnnb        & 002299;; "&11*==J&--//M!+ 22:>>>&*   5$5f===)=== t( f P         t&F       4 '>>3355<<>> fGt  !!!!kkmm//44!+$1:<<>>//11<<>>rB   fGtt   @#f0300111111111ttttt   &OOOO         4 (??  !!!!kkmm//44MM!+L,?LLLLLLLLLMMMMMMMMMMMMMMM--//=: P P PO   A3f9C99:::::::::ttttt   +)--j$???,00TBBBB)-&&*#&9F999:: : : : : : : :4  III    ++--C++C00  ' 3S*               \\^^))++FF   &%        44    NN?   &,s,,-- - - - - - - -44444   %/2JI$ ' 1KKKKK!!2 J/I<<J#1L5!L5 L5LL5L +L55 N N /NN(1Q9"Q; Q9Q  Q9Q )Q99S S /SSA6U V!VVOptional[MessageEvent]c K|dp|dpi}|dpd}|dp|dpd}|dpi}|dpd}|dpi}|dpd} |d p|d p| } |d pd} | r0|r.| |j|<|d vrd nd } |dp|dpd} | } |dpi}t |}|rUt |dpd}|r/| dsd|d| } g}g}tj }|dpg}|D]} | |d{V\}}n*#t$rt dYHwxYw|sO||||pd|tj kr| st|pd}|r tj}d}|r|r|j||}| d kr;|dk}|r|nd}|r|r |r ||j|<n.|r|j|dn|}|r |r ||j|<|||d p|dpd| | p| | || pd}t-| ||||dpd||S)z4Parse a Chat API message into a hermes MessageEvent.r.r&rEr$rrNrrrDIRECT_MESSAGEDMdmrrr9 slashCommand commandId/z/cmd_ attachmentz'[GoogleChat] attachment download failedapplication/octet-streamr)r chat_name chat_typeuser_id user_namerr)r9 message_typer raw_message message_id media_urls media_types)rupperrsr8rr*r7r_rTEXT_download_attachmentrNrwrr(rcCOMMANDrrrr build_sourcer)rmrXrr.rrrrr sender_namerrrr9slashis_slash command_idrrr attachmentsatt local_pathrYprev_thread_countis_side_threadsession_thread_idrs r:rz&GoogleChatAdapter._build_message_events W%%?)9)9?RYYv&&," ii''G599[+A+AGRNNPP ""(bjj((0D ""(bjj((.B M22Xfjj6I6IX[zz'**0b  QJ Q4@4F4F4H4H4N4N4P4PD %j 1&*BBBDD ww~&&?#''&//?Rzz||''-2;;  ;UYY{339r::J ;$//#"6"6 ;2z22D2288::!# !# "' ggl++1r  B BC )-)B)B3)G)G#G#G#G#G#G#G DD     !JKKK     j ) ) )   tA'A B B B{////5djbAA  /&.L   :  $ 8 = =K!! *   .2N/= G 4  @z @n @8C)*55 @)--j$??? +  Dz D8C)*5""ii ..I%))F2C2CIr"0[$'$,!#  $%wwv.$!#    sI%%$J  J r#Tuple[Optional[str], Optional[str]]c v K|dpd}|dpd}|dpd}|dpi}|dpd|dpd |dkr std d |fSd }rqdfd } tj|d {V}nN#t $rA}tdtt|d }Yd }~nd }~wwxYw| rt stdd |fSd fd } tj| d {V}nP#t$rC}tdtt|d |fcYd }~Sd }~wwxYw|d |fS|r| ddnd} d| vr2d| ddd z} nd} |drt|| pd} nb|drt!|| pd} n9|drt#|| pd} nt%|| } | |fS)u#Download an inbound attachment to the local cache; return (path, mime). Priority for bot Service Accounts: 1. ``attachmentDataRef.resourceName`` via ``chat.media.download`` — the supported bot path. The Service Account bearer token has ``chat.bot`` scope which the Chat API authorises against the space membership. 2. Drive-hosted files (``source == 'DRIVE_FILE'``) require user OAuth and Drive scope; skip with a log. 3. Direct HTTP fetch of ``downloadUri`` only as a last resort — that URL is meant for user OAuth tokens (chat.google.com returns 401 for SA bearer tokens) and is unlikely to work, but we keep the path for forward-compat with Google changes. contentTyperErr&attachmentDataRef resourceName downloadUri DRIVE_FILEzb[GoogleChat] Skipping Drive-picker attachment (no resourceName, would need user-OAuth Drive scope)Nr)bytescj}ddlm}ddl}|}|||}d}|s|\}}||S)N)rr)MediaIoBaseDownloadF) rmediadownload_mediagoogleapiclient.httprrBytesIO next_chunkr) reqrrr downloaderr`_status resource_namerms r: _fetch_mediaz._fetch_media=sn**,,;;!.<EDDDDD jjll00c:: <$.$9$9$;$;MGT<||~~%r<z,[GoogleChat] media.download_media failed: %sz8[GoogleChat] Rejecting attachment fetch: non-Google hostcddlmcmcm}|j}|d}||jS)Nrr_) google.auth.transport.requestsr transportrequestsAuthorizedSessionrrraise_for_statuscontent)garauthed_sessionr, download_urirms r: _fetch_uriz:GoogleChatAdapter._download_attachment.._fetch_uri\so<<<<<<<<<<<*4S]FCCCEE __X & & >*4S]FCCCEE __X & & >*4S]FCCCEE-dH==Ed{s6C D('7D##D($E?? G  8GG G r,reply_tometadataOptional[Dict[str, Any]]rc $K||||}|| |||}|s&t dd||Sd}|j|d}|tkrd}d} t|D]\} } d| i} |r| dks|sd|i| d < | dkr!|r| || d{V} d } n| || d{V} | }b#t$r|}tt|d dd d}|d krR|dddt dt|cYd}~c||S|dkr| dkrB|r@t dd}| || d{V} | }Yd}~3t dt ddcYd}~c||S|dkrc|j|ddz|j|<|j|t(kr&t d|j|d}~wwxYw|&t dd||S| rt|j|<|||S#||wxYw)uSend a text message. Signature matches ``BasePlatformAdapter.send``: ``content`` is the message body, ``reply_to`` is an optional message_id (the inbound message to thread under), and ``metadata`` may carry ``thread_id`` (the resolved Google Chat ``spaces/X/threads/Y`` resource name). If a typing card is tracked for this chat, transform it in-place via ``messages.patch`` — NO delete+create. Google Chat shows a tombstone ("Message deleted by its author") on delete, which is visual noise. Patch rewrites the text of the existing message seamlessly. Also pauses the base class's ``_keep_typing`` loop for this chat so it can't post a racing typing card between the patch and the reply. If ``content`` exceeds MAX_MESSAGE_LENGTH, the first chunk patches the typing card (if any), subsequent chunks are new messages. rFz empty messagesuccessrMNr9rr&rTr,r-chat_forbiddenz6Bot lacks access (removed from space or perms revoked)r2z:[GoogleChat] Typing card disappeared; creating new messagez&[GoogleChat] send target 404; skippingztarget not foundr&rz8[GoogleChat] Rate limit hit %d times on chat; throttling)_resolve_thread_idpause_typing_for_chat _chunk_textformat_messagerresume_typing_for_chatrr_TYPING_CONSUMED_SENTINEL enumerate_patch_messagerrr3rKr7rwrrr_RATE_LIMIT_WARN_THRESHOLDrx)rmrr,r6r7rchunks last_resulttyping_msg_namepatched_typingidxchunkrrr'r-s r:sendzGoogleChatAdapter.sends2++Hh+PP  ""7+++I 1 %%d&9&9'&B&BCCF H!%GGGD  ' ' 0 0 0 0A15K"377FFO";;;"&"N'//- -  U(.9#'''&,i%8DN(axxOx'+':':?D'Q'Q!Q!Q!Q!Q!Q!Q)-'+';';GT'J'J!J!J!J!J!J!J"(KK !!!$WS&$%?%?4PPF}}--!1$\&+. *%s3xxHHHHHHHHHHJ  ' ' 0 0 0 0I}}!888"KK \/3O+/+?+?+N+N%N%N%N%N%N%NF*0K$HHHH $LMMM)%?QRRRRRRRRRR.  ' ' 0 0 0 0-}} 155gqAAAE-g6 09=WWW"NN Z $ 5g >C!D"!%GGG  ' ' 0 0 0 0  K1J%g.  ' ' 0 0 0 0D ' ' 0 0 0 0sp:K8AK8ADK8 J%)AJ J%K8!AJ )K8/*J J%K86A*J  J%%K8K88LF)finalizerrPc xK|stddSt|tkr|dtdz dz} ||d|id{VS#t$r}t t |ddd d}|d kr&|j|d dz|j|<tdtt|cYd}~Sd}~wt$rD}t d d tdt|cYd}~Sd}~wwxYw)uJEdit a previously sent message via ``messages.patch``. Required for the gateway tool-progress + token-streaming pipeline: ``GatewayStreamConsumer`` and ``send_progress_messages`` both gate on this method being overridden (see gateway/run.py:10199 and gateway/stream_consumer.py). Without it, Google Chat shows no tool activity (no "🔍 web_search…", no progressive token edits). ``message_id`` is the Google Chat resource name ``spaces/X/messages/Y``. ``finalize`` is unused here — Google Chat's patch API has no streaming lifecycle state, so the same patch closes the stream and any prior edit. 404 (message gone) and 403 (perms revoked) are reported as non-success; the gateway falls back to ``send()`` for the next edit cycle. Fzmissing message_idr;Nru…r9r,r-r&rz [GoogleChat] edit_message failedTr) rrO_MAX_TEXT_LENGTHrGrr3rrrXr7rNrwr)rmrrr,rPr'r-s r: edit_messagezGoogleChatAdapter.edit_messages2 Ie3GHHH H w<<* * *4 01 445=G =,,Z&'9JKKKKKKKK K   WS&$774HHF}})--gq99A=%g.%6s3xx%@%@       = = = LL;dL K K Ke3s88<<< < < < < < < =s1A"" D9,A6C("D9( D959D4.D94D9c KsdSd fd } tj|d{VdS#t$rj}tt|dddd}|d vrYd}~dStd t t|Yd}~dSd}~wt$r td d YdSwxYw)uDelete a message — used sparingly (deletion creates a tombstone). The base contract returns False on unsupported. We do support it, but most internal code should prefer ``edit_message`` to avoid the "Message deleted by its author" tombstone. Provided so the gateway's stream-consumer fallback paths (e.g. removing an aborted partial preview) work correctly when explicit deletion is the right call. Fr)rocjdSN)r&r)rrmessagesdeleter r!)rrmsr: _do_deletez4GoogleChatAdapter.delete_message.._do_delete&sP%%''Z((d335566666r<NTr,r-)r=r?z&[GoogleChat] delete_message failed: %sz"[GoogleChat] delete_message failedrr) rr+rr3rwrrXr7rN)rmrrrYr'r-s` ` r:delete_messagez GoogleChatAdapter.delete_messages$ 5        #J// / / / / / / /4   WS&$774HHF##uuuuu LL8!#c((++   55555    LL=L M M M55 s - C $B!5B)C C rrcpKg}d|vr|dd|vr|dd|pdd|Dd fd }tj|d{V}t d |d  S) z8Update a message's text (and optionally cards) in-place.r9cardsV2rc"i|] \}}|dv || S))rr?)rIkvs r: z4GoogleChatAdapter._patch_message..Js(LLLtq!q 7K7Ka7K7K7Kr<r)rcjS)N)r& updateMaskrr)rrrWpatchr r!)r patch_bodyrm update_masksr: _do_patchz3GoogleChatAdapter._patch_message.._do_patchLsP%%''L[zRRd335566  r<NTr&r<rr)r)r(rPr{rr+rr)rmrrupdate_mask_fieldsrfr,rdres`` @@r:rGz GoogleChatAdapter._patch_message>s  T>>  % %f - - -     % %i 0 0 0hh122._phs;+71:+++C AJJJ!OJJJ %L Jr<z(```(?:[^\n]*\n)?[\s\S]*?```)c@|dSNrrmrws r:rz2GoogleChatAdapter.format_message..scc!''!**oor<z (`[^`]+`)c@|dSryrzr{s r:rz2GoogleChatAdapter.format_message..scc!''!**oor<z^#{1,6}\s+(.+)$cld|ddSN*r)rrsr{s r:rz2GoogleChatAdapter.format_message..s3cc3aggajj..0033344r<)flagsz\*\*\*(.+?)\*\*\*cHd|ddS)Nz*_rz_*rzr{s r:rz2GoogleChatAdapter.format_message..s'cc-qwwqzz---..r<z \*\*(.+?)\*\*cHd|ddSrrzr{s r:rz2GoogleChatAdapter.format_message..s'cc+aggajj+++,,r<z\[([^\]]+)\]\(([^)]+)\)ctd|dd|ddS)Nrzr{s r:rz2GoogleChatAdapter.format_message..s9cc8aggajj881771::88899r<rEz +r)rqr7r)r7)rVrW MULTILINE _INVISIBLE_REr{r)clsr,r9rtrqrwrurvs @@@r:rCz GoogleChatAdapter.format_messages" N') #       v , % % % %    vl$=$=$=$=tDDv  4 4 4 4 ,    v . . . .   v  , , , ,   v & 9 9 9 9    $$R..vfc4((',,.. , ,JC<<U++DD r<c|r-dD]*}||}|rt|cS+|r d|vrd|vr|S|r|j|}|r|SdS)uPReturn the Google Chat thread resource name to reply under, or None. Priority: 1. ``metadata['thread_id']`` — populated by the gateway's session plumbing from ``SessionSource.thread_id`` (the inbound ``thread.name``). Canonical path for groups. 2. ``metadata['thread_name']`` / ``metadata['thread_ts']`` — Slack precedent aliases that the broader codebase sometimes passes. 3. ``reply_to`` if it already looks like a thread resource name (``spaces/X/threads/Y``). Message names ``spaces/X/messages/Y`` cannot be converted to threads without an extra API call. 4. ``self._last_inbound_thread[chat_id]`` — Google Chat DMs spawn a new thread per top-level user message, and the adapter intentionally drops thread_id from the source so the session key stays stable. Without this fallback, DM replies would land at top-level (a fresh thread separate from the user's), visually disconnected from the user's question. )rr thread_tsz /threads/z /messages/N)rr7r)rmr6r7rrtrqcacheds r:r@z$GoogleChatAdapter._resolve_thread_ids0  &@ & & S))&u::%%%&   x//L4P4PO  .227;;F  tr<cTt|jtjdS)a>Return a fresh AuthorizedHttp. googleapiclient's discovery client is NOT thread-safe because httplib2 shares SSL state between calls. Passing a fresh http= to each ``execute()`` avoids record-layer failures when calls run in ``asyncio.to_thread`` workers. Cheap (~no network). r&r_r)rrhttplib2Httprgs r:r!z"GoogleChatAdapter._new_authed_https'd/hmB6O6O6OPPPPr<z chat-api-callop_namesync_fnCallable[[], Any]rc Kt}d}tdtdzD](} tj|d{VcS#tj$rt $r}|}t|}|r |tkr|tztj z}t||zttz} t d||ttt||  tj| d{Vn#tj$rwxYwt|dzt}Yd}~"d}~wwxYw||t#|d)uRun ``sync_fn`` in a thread with bounded retry + jittered backoff. Wraps a sync Chat API call (typically a ``.execute()``) so transient 429/5xx/timeout failures don't drop user-visible messages. Permanent failures (auth, client errors, validation) bubble up on the first attempt — see :func:`_is_retryable_error`. Cancellation propagates immediately, no extra retries after a CancelledError. Pattern lifted from PR #14965. Nrz<[GoogleChat] %s attempt %d/%d failed (%s); retrying in %.2fsrqz": retry loop exited without result)_RETRY_BASE_DELAYrange_RETRY_MAX_ATTEMPTSrr+rcrNr; _RETRY_JITTERr{rx_RETRY_MAX_DELAYrwrxrXr7r}r) rmrrrlast_excr~r'r5jitterwaits r:_call_with_retryz"GoogleChatAdapter._call_with_retrys ",0Q 3a 788 9 9G 9$.w77777777777)    9 9 9/44  G/B$B$B.@56>+;m+KLL(W&9%c#hh//  !------------EAI'788# 9&  NgIIIJJJs0AE BE9DED%%EE cK||d|dpi}|drdd<dfd }|d d {V}|dpidpd }|rK|rI j||n,#t$rt d dYnwxYwtd|dS)u1POST spaces/{space}/messages via REST, returning SendResult. When ``body`` carries ``thread.name``, we MUST pass ``messageReplyOption=REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD`` — otherwise Google Chat silently ignores ``thread.name`` and creates a new thread anyway. From the official docs: "Default. Starts a new thread. Using this option ignores any thread ID or threadKey that's included." See https://developers.google.com/workspace/chat/api/reference/rest/v1/spaces.messages/create rrrr&$REPLY_MESSAGE_FALLBACK_TO_NEW_THREADmessageReplyOptionr)rcjjdiS)Nrr?)rrrWcreater r!)kwargsrmsr: _do_createz5GoogleChatAdapter._create_message.._do_createEs]%%''"" ""d335566  r<zmessages.createrNrE.[GoogleChat] outbound thread-count incr failedTrrgrh)rrrrrNrwrr)rmrr thread_metarr, resp_threadrs` @r:rz!GoogleChatAdapter._create_message,sb-4T!B!Bhhx((.B ??6 " " R ,RF' (       **:?P*QQQQQQQQxx))/R44V<<B  {  (--g{CCCC    D!  $488F3C3CDDDDsB,,&CCcKjvrdSjvrY tjjdd{Vn#tjt f$rYnwxYwdSd|}ddi|rd|id<tjj<d fd }tj |} tj |d{VdS#tj $rwxYw) uPost a visible 'Hermes is thinking…' marker message. NOT ephemeral (Google Chat has no ephemeral text messages outside slash command responses). ``send()`` PATCHes this marker in-place with the real response (no deletion tombstone). The typing card is either patched by ``send()`` (success) or by ``on_processing_complete`` (failure / cancellation). IMPORTANT — must place the typing card in the user's thread: ``messages.patch`` cannot change a message's ``thread`` (it's immutable on update). If we create the typing card at top-level and the user is replying inside thread T, send() will patch the top-level card in place — leaving the bot's whole response stranded outside the user's thread. We resolve the thread the same way send() does. IMPORTANT — cancellation safety: ``base.py``'s ``_keep_typing`` calls this through ``asyncio.wait_for(send_typing, timeout=1.5)``. When the create-API call takes longer than 1.5s, ``wait_for`` cancels ``send_typing`` mid-flight — but the underlying ``asyncio.to_thread`` keeps running and creates a card in Chat that we have NO way to track (the storage line never runs). Next ``_keep_typing`` tick sees an empty slot and creates a SECOND card. Result: one orphan "Hermes is thinking…" stuck in chat forever, plus one card that gets patched into the reply. Fix: reserve the slot with an in-flight ``Event``, run the create in a background task, and ``await asyncio.shield`` it. Cancellation of THIS coroutine no longer cancels the create — the task runs to completion and the msg_id lands in the slot regardless. Nr^r_)r6r7rr9uHermes is thinking…r&rr)rocK d{V}|jrS|jrLjvr|jj<n3jg|jn,#t$rt ddYnwxYwj d dS#j d wxYw)Nz1[GoogleChat] send_typing background create failedTr) rr<rrrrr(rNrwrrrset)rrr completedrms r:_create_and_recordz9GoogleChatAdapter.send_typing.._create_and_records; #33GTBBBBBBBB> 4f&7 4d&;;;9?9J-g664??#R &!2333    G!  *..w=== *..w=== s*A6A<;C<&B%"C$B%%C1D r) rrrrbrrdKeyErrorr@EventrUshieldrc)rmrr7rrtaskrrs`` @@r: send_typingzGoogleChatAdapter.send_typing`sF d+ + + F d0 0 0  &.w7<<>>((3     F++Hg,  !'(?@  1$i0DNMOO .7"7+         4"#5#5#7#788  .&& & & & & & & & & &%     s9AA/.A/C88D cK|j|}|sdS|tkr|j|ddSdS)u}Stop the typing indicator — NO-OP when a live card is tracked. Google Chat has no separate typing API: the "Hermes is thinking…" marker is a real message that ``send()`` patches in-place with the agent's reply. Deleting the marker creates a "Message deleted by its author" tombstone, which is visual noise. Upstream code (gateway/run.py and gateway/platforms/base.py) calls ``stop_typing`` at three moments per turn — typically BEFORE ``send()`` runs (so deleting the slot would leave ``send()`` nothing to patch, forcing it to create a fresh message and leaving the original card as a tombstone). To fix this without modifying upstream contracts, ``stop_typing`` here is intentionally a NO-OP when the slot holds a real ``message_name``: the card is left in place so ``send()`` can patch it. Three cases: * Slot empty → nothing to do. * Slot holds SENTINEL → ``send()`` already patched the card; pop the sentinel so the next turn starts clean. * Slot holds a real ``message_name`` → leave it for ``send()`` to consume. NO-OP. Stranded cards on error / cancellation paths (where ``send()`` never runs) are reaped by ``on_processing_complete`` — see that hook for the patch-to-final-state cleanup. N)rrrEr)rmrcurrents r: stop_typingzGoogleChatAdapter.stop_typingsZ8'++G44  F / / /  ! % %gt 4 4 4 Fr<rroutcomercxK|jdS|jj} |j|d}|rk|tkr`|t jkrdnd} ||d|id{Vn,#t$rt ddYnwxYw|j |g}|D]N} ||ddid{V"#t$r t d |dYKwxYwdS#t$r t d dYdSwxYw) uReap typing card(s) after the message-handling cycle ends. SUCCESS: ``send()`` set the SENTINEL after patching. Pop it. FAILURE / CANCELLED: ``send()`` may not have run, leaving a real ``message_name`` in the slot. Patching the card to a final state (``"(interrupted)"``) avoids the tombstone that ``messages.delete`` would create. If ``send()`` did run (e.g. base.py error-send branch patched it), the slot holds the SENTINEL — pop and exit. Orphan cards: when a background ``send_typing`` task creates a card AFTER ``send()`` already populated the slot (race window when the API call takes longer than _keep_typing's wait_for timeout), the orphan id is stashed in ``self._orphan_typing_messages``. Patch each orphan with an empty-ish marker so the user doesn't see "Hermes is thinking…" stuck forever. Nz (interrupted)z (no reply)r9z9[GoogleChat] on_processing_complete patch fallback failedTr·z0[GoogleChat] orphan typing-card patch failed: %sz5[GoogleChat] cleanup in on_processing_complete failed) rrrrrEr CANCELLEDrGrNrwrr)rmrrrrlabelorphans orphan_ids r:on_processing_completez(GoogleChatAdapter.on_processing_completes( <  F,& +//>>G 7&???(/2C2M'M'MOO%--gGGGGGGGGGG LLS!%!266wCCG$   --i&$HHHHHHHHHH LLJ!D!      LLGRV        sY>>4 !!'4000 ..wGGGGGGGGF-FD !' *M   WS&$774HHF}}ttttt   s.A77 B3&B.-B..B3 image_urlcaptionc K||||}g}|r||||d|} |||d{V} | | Sd|i} |rd|i| d<||| d{VS#t $r5} t dtt| cYd} ~ Sd} ~ wwxYw) uSend an inline image via attachment URL (no upload). If a typing card is tracked for this chat, patch it in-place with the image (caption + URL) — same anti-tombstone pattern used by ``send()``. Otherwise create a new message. r:rlNr9r&rFr;) r@r(rPrrrrrXr7) rmrrrr6r7r text_partsr9patchedrr's r: send_imagezGoogleChatAdapter.send_imageD s;++Hh+PP "  '   g & & &)$$$yy$$ P ??NNNNNNNNG"$*D>D 5"()!4X--gt<<<<<<<< < P P Pe3DSXX3N3NOOO O O O O O O Ps$B(?(B(( C'2*C"C'"C' image_pathrc K||||d|||d|d{VS)Nzimage/*r7r: mime_hintr _send_filer@r)rmrrrr6rs r:send_image_filez!GoogleChatAdapter.send_image_filed sp__ Z--h :8N8NX_-``%         r< file_path file_namec K||||d|||d||d{VS)Nr7r:)rroverride_filenamer)rmrrrrr6rs r: send_documentzGoogleChatAdapter.send_documentr ss__ Y--h :8N8NX_-``' %         r< audio_pathc K||||d|||d|d{VS)Nz audio/oggr7r:rr)rmrrrr6rs r: send_voicezGoogleChatAdapter.send_voice p__ Z!--h :8N8NX_-``%         r< video_pathc K||||d|||d|d{VS)Nz video/mp4r7r:rr)rmrrrr6rs r: send_videozGoogleChatAdapter.send_video rr< animation_urlcFK||||||d{VS)zBGoogle Chat has no native animation type; fall back to send_image.)rr6r7N)r)rmrrrr6r7s r:send_animationz GoogleChatAdapter.send_animation sM__ ]G%         r<r'rc4t|pd}d|vpd|vS)uDetect Google Chat's media.upload bot-auth rejection. Returns True for the canonical ``"doesn't support app authentication"`` wording (and the legacy ``ACCESS_TOKEN_SCOPE_INSUFFICIENT`` variant some older clients still see). Used to flag a misuse — calling ``media.upload`` through the SA-authed Chat API client instead of the user-authed one. With correct routing this error should never fire in the adapter; it remains as a defensive check. rEz"doesn't support app authenticationACCESS_TOKEN_SCOPE_INSUFFICIENT)r7)r'r9s r:_is_app_auth_attachment_errorz/GoogleChatAdapter._is_app_auth_attachment_error s-3xx~2 0D 8 90D8 r< __legacy__r Optional[Any]c Kddlm}mm}|j|}|j|}|| tj|||d{V}n.#t$r!t ddd}YnwxYw|8|j |d|j |ddS||j|<|S tj||d{V dStj fdd{V}n.#t$r!t d|dYdSwxYw |j|<||j|<|S) aGet (or build + cache) a user-authed Chat client for ``email``. Hits ``self._user_chat_api_by_email`` first; on miss, loads the per-user token from disk, refreshes if needed, builds an API client, and caches both. Refresh failures evict the slot so the next request goes back through the disk path (and ultimately the text-notice fallback if the user has revoked). r)r>r?refresh_or_noneNz+[GoogleChat] cached per-user refresh raisedTrcSrr?)_buildrsr:rz;GoogleChatAdapter._load_per_user_chat_api.. s&&--r<z4[GoogleChat] per-user creds load/build failed for %s) rNr>r?rrrrrr+rNrwrr) rmr_load_refresh cached_api cached_creds refreshedapirrs @@r:_load_per_user_chat_apiz)GoogleChatAdapter._load_per_user_chat_api s          155e<< 044U;;  !l&> !")"3HlE"R"RRRRRRR  ! ! ! AD!  !  ,00===)--eT:::t/8D %e ,  !+E599999999E}t)*?*?*?*?*?@@@@@@@@CC    LLF    44  ,1!%(.1$U+ s*A%%(BBD9D'EE#Tuple[Optional[Any], Optional[str]]cK|r!||d{V}|||fS|j ddlm}t j||jdd{V}n.#t$r!t ddd}YnwxYw|*t dd|_d|_dS||_|j|j fSdS) uQResolve the user-authed Chat client for an outbound attachment. Lookup order: 1. Per-user token for ``sender_email`` — the asker's identity. 2. Legacy single-user fallback (``self._user_chat_api``) for pre-multi-user installs. 3. None — caller posts the setup-instructions text notice. Returns ``(client, identity_label)`` where ``identity_label`` is the sanitized email or the literal ``"__legacy__"`` sentinel. ``_invalidate_user_creds`` uses the label to evict the right slot on auth failure. Nr)rz([GoogleChat] legacy creds refresh raisedTruP[GoogleChat] legacy user-OAuth refresh returned None — evicting fallback credsNN) rrrNrrr+rrNrwrrx_LEGACY_USER_IDENTITY)rmrrrrs r:_acquire_user_chat_apiz(GoogleChatAdapter._acquire_user_chat_api sO  )44\BBBBBBBBCL((   * !#*"3d4d##  ! ! ! >!  !  .*.&&*#!z%.D "&(BB Bzs'A(BBidentityc|sdS||jkrd|_d|_dS|j|d|j|ddS)uDrop creds for ``identity`` after an auth failure. ``identity`` comes from ``_acquire_user_chat_api`` — either the sender email (per-user slot) or ``__legacy__`` for the fallback slot. None is a no-op. N)rrrrrr)rmrs r:_invalidate_user_credsz(GoogleChatAdapter._invalidate_user_creds/ sl  F t1 1 1%)D ""&D  F !%%h555 $((488888r<rfrrc nKtjstddS|p tjpd|pd|j}||d{V\} |||d{VS | |pdd{Vn,#t$rt d d YnwxYwd fd } tj| d{V} n#t$r} t!t!| dddd} | dvrVtd|| |||||d{VcYd} ~ Stdt't)| cYd} ~ Sd} ~ wwxYw| d} | stddSdd| igi}|r||d<|rd|i|d<|d|rdd<d fd } tj|d{V}|dpidpd}rK|rI |j|n,#t$rt dd YnwxYwtd |dS#t$r5} tdt't)| cYd} ~ Sd} ~ wwxYw)!uNative Chat attachment via user-OAuth media.upload. Two-step on the wire: ``media.upload`` then ``spaces.messages.create`` with the returned ``attachmentDataRef``. BOTH calls go through a user-authed Chat API client — the SA-authed client is rejected by ``media.upload`` regardless of scopes. Multi-user routing: the bot looks up the most recent inbound sender for this ``chat_id`` and uses THAT user's stored OAuth token. Falls back to a legacy single-user token when present (for pre-multi-user installs), and to a setup-instructions text notice when neither is available. Google Chat ``messages.patch`` cannot add an attachment to an existing message, so we cannot transform the typing card directly into the file message. Instead we patch the typing card with the caption (or a single space when none) so it retires without a tombstone, then create the attachment message. Fzfile not found: r;z upload.binrN)rrfr4rrrz4[GoogleChat] _send_file pre-patch typing-card failedTrr)rctd}di|S)NF)mimetype resumabler4)rr media_body)rruploadr )rchat_apirr4rYrfs r:_uploadz-GoogleChatAdapter._send_file.._upload{ sV#D45IIIE  "$h/$  r<r,r-)ir=u[GoogleChat] media.upload auth failure for identity=%s (token revoked or scope missing) — falling back to text notice. Status=%srz$upload returned no attachmentDataRefrr9r&rrrrcjdiS)Nr?)rrWrr )r create_kwargssr:_create_with_attachmentz=GoogleChatAdapter._send_file.._create_with_attachment sG!!))'))  r<rErrgrh)rrfrqrbasenamerrr_post_attachment_fallbackrrNrwrrr+rr3rxrrXr7rr)rmrrfrrrrrrr upload_respr'r-attachment_refrrr,rrrr4rYs `` @@@@r:rzGoogleChatAdapter._send_file? s:w~~d## Ne3Ld3L3LMMM M$N(8(8(>(>N,66044W== #'#>#>|#L#LLLLLLL(  77!# 8  55gw~#NN N N N N N N N N    LLF                   ' 1' : :::::::KK   WS&$774HHF##-.6 ++H555!;;#%#' <%6s3xx%@%@      ! (%)<== <  /@A   #"DL  1$i0DN4;D(I(I  6 . /         *+BCCCCCCCCD 88H--388@@FBK ; ,11';GGGG LLH!%! &)9)9    %6s3xx%@%@       s>C&DDD// G(9A4G#-G(3*G#G(#G(>A K5 J%$K5%&K K5 K&K55 L4?*L/)L4/L4r4cpKg}|r|||d|dddd|dgdd|i}|rd |i|d < |||d {Vn,#t$rt d d YnwxYwtddS)aAPost a text notice when native attachment delivery is unavailable. Tells the user that file delivery requires a one-time consent flow (``/setup-files``) and reports the local-host path so the file isn't lost. Returns ``success=False`` so callers know the attachment did not land. u⚠️ No he podido adjuntar **z**.uGoogle Chat sólo permite adjuntar archivos cuando el bot tiene permiso explícito tuyo (OAuth de usuario). Es un consentimiento único que se hace desde este chat.uD**Para activarlo:** envía `/setup-files` y sigue las instrucciones.u-Mientras tanto el archivo está en el host: ``r9rlr&rNz3[GoogleChat] attachment fallback notice send failedTrFuOgoogle_chat: native attachment requires user OAuth — run /setup-files in chatr;)r(r)rPrrNrwrr)rmrrfr4rrlinesrs r:rz+GoogleChatAdapter._post_attachment_fallback s.  " LL ! ! ! ;h ; ; ; 2 S CD C C C     !' %(8(89  1$i0DN &&w55 5 5 5 5 5 5 5 5    LLE        '    sA;;&B$#B$c K tjfdd{V}nR#t$rE}tdt t |ddcYd}~Sd}~wwxYw|dp|dpd}|d p}||d vrd nddS) z)Return {name, type, chat_id} for a space.cjSrV)rrrr r!)rrmsr:rz1GoogleChatAdapter.get_chat_info.. sB--//'""d335566r<Nz%[GoogleChat] get_chat_info failed: %sr)r&r$rrr$rErrr) rr+rrwrrXr7rr)rmrrr'rdisplays`` r: get_chat_infozGoogleChatAdapter.get_chat_info s; J *77777DD  J J J LL79J3s889T9T   $WII I I I I I I  J hh{++Etxx/?/?E2LLNN ((=))4W&*BBBDD   s% A4:A/)A4/A4)rr)r)r)r)r)rrr)ro)rrr)r*)rrr)ro)r)rg)r)r )r r7r)ror)r*r)rE)rrrr7r)r)r4rr)ro)rXrrrr)ror) rr7rr rr7rr r)r*)rXrrrr)r)rrr)rr) rr7r,r7r6r r7r8r)r) rr7rr7r,r7rPr*r)r)rr7rr7r)r*)rr7rrr)r)r9r7r)rj)r,r7r)r7)r6r r7r8rr r)r )rrrr7r)r)rr7rrr)r)rr7r7rr)ro)rr7r)ro)rrrrr)ro)rr7r9r7r)r)NNN) rr7rr7rr r6r r7r8r)r) rr7rr7rr r6r rrr)r)rr7rr7rr rr r6r rrr)r) rr7rr7rr r6r rrr)r) rr7rr7rr r6r rrr)r) rr7rr7rr r6r r7r8r)r)r'rr)r*)rr7r)r)rr r)r)rr r)ro)rr7rfr7rr rr rr rr r)r) rr7rfr7r4r7rr rr r)r)rr7r)r)>rrrrrRMAX_MESSAGE_LENGTHrwrzryrnrr staticmethodrrrr r rr/r\rhrVrrurrrrrOrSrZrGrBrVcompiler classmethodrCr@r!rrrrrrrrrrrrrrrrrrrr  __classcell__)rs@r:rrwsv  *  SYSYSYSYSYSYpGGGGR((((>RRR\R ZZZ\Z ? ? ? ?$7777  \ \ \ \%%%%TVVVVp11118EEEET13\\\\\\|B$F$F$F$FV'+ ^^^^^@| | | | |qqqqt#'-1 d1d1d1d1d1X +=+=+=+=+=+=Z####JSSSS26BJ   MMMM[Mf"& #####JQQQQ' ,K,K,K,K,K,K\2E2E2E2EhaaaaaF####J7777xH"&"&-1 PPPPPH"&"&      $"&#'"&      ("&"&      $"&"&      $"&"&-1      <   \ ")....`----^9999,$(+/TTTTTl( ( ( ( Z        r<rrrct|dipi}t|do|dS)zPlugin-side config gate: require both Pub/Sub project and subscription. Mirrors the legacy dispatch entry in ``gateway/config.py`` so the registry can decide whether the platform is configured without importing the legacy table. rrr)r3r*r)rrs r:rr sM FGR ( ( .BE  ,BEII.A$B$B  r<ctsdStjdptjd}tjdptjd}t|o|S)u ``check_fn`` for the platform registry pass — stricter than the deps-only ``check_google_chat_requirements``. The registry pass at ``gateway/config.py:_apply_env_overrides`` adds the platform to ``cfg.platforms`` whenever ``check_fn`` returns True. For backward compat with the pre-plugin behavior, we ALSO require the minimum Pub/Sub env vars so an unconfigured user doesn't accidentally see ``google_chat`` enabled. This matches the legacy ``if gc_project and gc_subscription`` gate. FGOOGLE_CHAT_PROJECT_IDGOOGLE_CLOUD_PROJECTGOOGLE_CHAT_SUBSCRIPTION_NAMEGOOGLE_CHAT_SUBSCRIPTION)r@rrr*)rrs r:_check_for_registryr* sz * + +u *++ - 9+ , , 122 1 9/ 0 0 (L ) ))r<c\tt|ddot|S)z7``GatewayConfig.get_connected_platforms()`` polls this.enabledF)r*r3r)rs r: _is_connectedrB s*  511 2 2 O7G7O7OOr<r8c|tjdptjd}tjdptjd}|r|sdS||d}tjdptjd}|r||d <tjd }|r|tjd d d |d<|S)uSeed ``PlatformConfig.extra`` from env vars during ``_apply_env_overrides``. The registry's env-enablement hook is called BEFORE the adapter is constructed, so ``gateway status`` and ``get_connected_platforms()`` reflect env-only configuration without instantiating the Pub/Sub client. Returns ``None`` when the required Pub/Sub project/subscription aren't set; the caller then skips auto-enabling the platform. The special ``home_channel`` key in the returned dict is handled by the core hook — it becomes a proper ``HomeChannel`` dataclass on the ``PlatformConfig`` rather than being merged into ``extra``. rrrrN)rr GOOGLE_CHAT_SERVICE_ACCOUNT_JSONrrGOOGLE_CHAT_HOME_CHANNELGOOGLE_CHAT_HOME_CHANNEL_NAMEHome)rr&r')rr)rrseedsa_jsonrs r:_env_enablementr#G s *++ - 9+ , , 122 1 9/ 0 0  t)D 455 7 95 6 6 /'. #$ 9/ 0 0D  I=vFF  ^ Kr<rocddlm}m}m}m}m}m}m}|d}|r|d|d|ddsdS|d |d |d |d |d |d|d|d|d|d|d|d|d|d|d|d|dpd}|s |ddS|d||d|dpd} | s |ddS|d| |d|dpdd } | r|d| |d!drS|d"|d#pd} | r,|d#| d$d|d%n$|d#dn|d&d'|d(|d)|d*pd} | r|d*| t|d+|d,dS)-aWalk the user through Google Chat configuration via ``hermes setup``. The setup wizard at ``hermes_cli/gateway.py`` calls this for plugin platforms instead of using the in-tree ``_PLATFORMS`` data block. The flow mirrors the in-tree built-ins: print the GCP setup instructions, prompt for env vars, persist them to ``~/.hermes/.env`` so the next gateway restart picks them up. r) get_env_valuesave_env_valueprompt prompt_yes_no print_info print_success print_warningrz/Google Chat: already configured (subscription: )zReconfigure Google Chat?FNz@Google Chat needs a GCP project, a Pub/Sub topic + subscription,zBand a Service Account with Pub/Sub Subscriber on the subscription.z Walkthrough:zP 1. Create or select a GCP project; enable Google Chat API + Cloud Pub/Sub API.zA 2. Create a Service Account (no project-level IAM role needed).zN 3. Create a Pub/Sub topic (e.g. hermes-chat-events) and a Pull subscription.zU 4. On the TOPIC: add chat-api-push@system.gserviceaccount.com as Pub/Sub Publisher.zH 5. On the SUBSCRIPTION: grant your Service Account Pub/Sub Subscriber.z+ 6. Download the Service Account JSON key.uK 7. Google Chat API console → Configuration: connection = Cloud Pub/Sub,zA point at the topic, enable 1:1 + group, restrict visibility.zP 8. Install the bot in a space (fires ADDED_TO_SPACE and resolves its user_id).rEz/subscriptions/)u7Subscription is required — skipping Google Chat setupz-Path to Service Account JSON (or inline JSON)rT)rpasswordz0Restrict access to specific users? (recommended)z%Allowed user emails (comma-separated)GOOGLE_CHAT_ALLOWED_USERSrzAllowlist configuredGOOGLE_CHAT_ALLOW_ALL_USERStrueuA⚠️ Open access — anyone who can DM the bot can command it.zFHome space for cron/notification delivery (e.g. spaces/AAAA, or empty)rz1Google Chat configuration saved to ~/.hermes/.envz+Restart the gateway: hermes gateway restart) hermes_cli.configr%r&r'r(r)r*r+rsrprint) r%r&r'r(r)r*r+ existing_subrrrallowedrs r:interactive_setupr5r s!=!@AAL T\TTTUUU}7??  FJQRRRJSTTTJ~JabbbJRSSSJ_```JfgggJYZZZJ<===J\]]]JRSSSJabbbJrNNNJMNNNJrNNNf* 677=2G  MNNNN+W]]__===6D =>>D"L  OPPPN2L4F4F4H4HIIIf7 @AAGRG L97==??KKK}GNN [& 3!M"=>>D"     < N6R8P8P Q Q Q M0 1 1 1 1 N6 ; ; ; ;4f=== YZZZ 6P 899?R   D A14::<<@@@ GGGMEFFFJ<=====r<c|dddtttgddtt dddd d d d dS)uBPlugin entry point — called by the Hermes plugin system at startup. Registers the Google Chat adapter under the ``google_chat`` name. The gateway's ``_create_adapter`` consults the platform registry BEFORE its built-in if/elif chain, so this registration is what drives adapter creation at runtime. rz Google Chatc t|Sr)r)cfgs r:rzregister.. s$5c$:$:r<)rrrz'pip install 'hermes-agent[google_chat]'rr.r/ru💬Tu{You are on Google Chat. Limited markdown subset is rendered: *bold*, _italic_, ~strike~, `code`. No headings or lists. Message size limit: 4000 characters; longer responses are split across multiple messages. You are in a space (DM or group). Images render inline; audio, video, and document attachments render as download cards (no native voice/video UI). To send files, include MEDIA:/absolute/path/to/file in your response. Native file attachments require the user to run /setup-files once in their own DM — until they do, file requests fall back to a text notice with the host path. Do NOT generate interactive Card v2 buttons — Google Chat interactivity is not yet supported by this gateway; ask for typed confirmations instead. While you are generating a response, a 'Hermes is thinking…' marker message appears in the space and is deleted once your response is ready. You do NOT have access to Google Chat-specific APIs — you cannot search space history, list space members, or manage spaces. Do not promise to perform these actions; explain that you can only read messages sent directly to you and respond in the same space/thread.)r&radapter_factorycheck_fnvalidate_config is_connected required_env install_hintsetup_fnenv_enablement_fncron_deliver_env_varallowed_users_env allow_all_envmax_message_lengthemojiallow_update_command platform_hintN)register_platformrrrr5r#)ctxs r:registerrJ sx ::$("   ?"*853 ! E66666r<)r'r(r)r*r )rAr7r)r*)r9r7r)r7)rYr7r)r)rrr)r*)r)r8r)Rr __future__rrrtloggingrr{rVpathlibrrgtypingrrrrr r r google.cloudr google.api_corer rR google.oauth2r google_auth_httplib2rgoogleapiclient.discoveryrr;googleapiclient.errorsrrrr>rrNgateway.configrrgateway.platforms.helpersrgateway.platforms.baserrrrrrrrr getLoggerrwrrrrRrHrrrr frozensetr6r;rEr@rRrTrXrcrerrrrr#r5rJr?r<r:rZs##J#"""""  !!!!!!================OOO&&&&&&<<<<<<------333333@@@@@@000000444444    !HINONMIOOO 43333333 999999                      &  : ; ;# A /,   $9%>%>%>??J)!!!!  W W W W 6    "kkkkkkkk\^& ^& ^& ^& ^& +^& ^& ^& LM    ****0PPPP ((((VZ>Z>Z>Z>z>>>>>>s0A))BB