`gjdZddlmZddlZddlZddlmZddlmZddl m Z ddl m Z ddl mZejeZd ZGd d Zd Zd Zd#dZd$dZd%dZd&dZ d'dZddd d(dZddd d)dZefd*dZd+dZdZd,dZ d-dZ!d.dZ"dddd d/dZ#d0dZ$Gdd Z%Gd!d"Z&y)1a(Mixture-of-Agents runtime helpers for /moa turns. The slash command is deliberately not a model tool. It marks one user turn as MoA-enabled; the normal Hermes agent loop still owns tool calling and turn termination, while this module gathers reference-model context before each model iteration. ) annotationsN)ThreadPoolExecutor)Any)call_llm)flatten_message_text) get_transportcTeZdZdZdZ ddddddd ddZy)_RefAccountingubPer-reference token usage + estimated cost + full trace, carried as the third slot of a reference-output tuple. Kept as a tiny object (not a bare CanonicalUsage) because an advisor may run on a different model/provider than the aggregator, so its cost MUST be priced at its OWN model's rate — folding advisor tokens into the aggregator's usage and pricing the sum at the aggregator's rate would misprice every advisor. ``usage`` feeds accurate token counts; ``cost_usd`` feeds accurate cost. ``messages`` / ``output`` / ``model`` / ``provider`` / ``temperature`` carry the FULL reference input and output for trace persistence (the display ``text`` is a truncated preview and is not enough to audit what an advisor actually saw). They are only populated when tracing is on; they add negligible cost otherwise. usagecost_usd cost_status cost_sourcemessagesoutputmodelprovider temperatureNrrrrrc||_||_||_||_||_||_||_||_| |_yNr ) selfr rrrrrrrrs A/root/.hermes/venv/lib/python3.12/site-packages/agent/moa_loop.py__init__z_RefAccounting.__init__=sF   &&      &)NNN)r rrrr str | Nonerrrrrrrrrrrr)__name__ __module__ __qualname____doc__ __slots__rrrr r s" I"&"& '! #''' '  ''''''rr iu0You are a reference advisor in a Mixture of Agents (MoA) process. You are NOT the acting agent and you do NOT execute anything: you cannot call tools, run commands, browse, or access files, repositories, or URLs, and you should not try to or apologize for being unable to. A separate aggregator/orchestrator model holds those capabilities and will take the actual actions. The conversation below is the current state of a task handled by that acting agent. Your job is to give your most intelligent analysis of that state: understand the goal, reason about the problem, and advise on what to do next. Surface the best approach, concrete next steps and tool-use strategy, likely pitfalls and risks, and anything the acting agent may have missed or gotten wrong. Assume any referenced files, URLs, or systems exist and reason about them from the context given rather than asking for access. Respond with your advice directly — no preamble, no disclaimers about tools or access. Your response is private guidance handed to the aggregator, not an answer shown to the user.c|jdxsdjd|jdxsdj}t|jdxsdj}|r|d|dS|S)Nr:rreasoning_effortz [reasoning=])getstripstr)slotlabelefforts r _slot_labelr/{s~$*1134Atxx7H7NB6U6U6W5X YE ,-3 4 : : >rc`|jd} ddlm}||S#t$rYywxYw)zETranslate optional per-MoA-slot reasoning_effort into runtime config.r'r)parse_reasoning_effortN)r)hermes_constantsr1 Exception)r,r.r1s r_slot_reasoning_configr4s6 XX( )F;%f-- s ! --ct|}||S ddlm}ddlm}||xsit |j dxsdS#t$rYywxYw)aOResolve the aggregator's reasoning config: slot > per-model > global. The aggregator is MoA's ACTING model, so when its slot doesn't pin a reasoning_effort it must resolve exactly like any other acting model: through the shared chokepoint (``resolve_reasoning_config``), which applies ``agent.reasoning_overrides`` for the slot's model first, then the global ``agent.reasoning_effort``. Without this the main loop's reasoning gates (keyed to the virtual ``moa://local`` identity) never fire, so the aggregator silently ran at the backend default (#64187). Reference advisors intentionally do NOT get this fallback: they are side calls (like auxiliary tasks), and inheriting a global ``xhigh`` into every advisor fan-out would silently multiply cost. Their depth is slot-or- provider-default only. Nr load_config)resolve_reasoning_configrr%)r4hermes_cli.configr7r2r8r+r)r3) aggregatorcfgr7r8s r_aggregator_reasoning_configr<sc ! ,C  1=' M RZ^^G%<%B!C   s9A AAct|jdxsdj}t|jdxsdj}||d} ddlm}|||}|jdr|d|d<|jd r|d |d <|jd r|d |d <|S#t $r+}t jd t||Yd }~|Sd }~wwxYw) uResolve a reference/aggregator slot to real runtime call kwargs. A MoA slot is just a model selection — it must be called the same way any model is called elsewhere, not through a bare ``call_llm(provider=..., model=...)`` that leaves base_url/api_key/api_mode unresolved and lets the auxiliary auto-detector guess. We route the slot's provider through ``resolve_runtime_provider`` (the canonical provider→api_mode/base_url/ api_key resolver the CLI, gateway, and delegate_task all use), so the slot gets its provider's real API surface — e.g. MiniMax → anthropic_messages, GPT-5/o-series → max_completion_tokens, custom endpoints → their base_url. Returns the kwargs to pass through to ``call_llm`` (provider/model plus the resolved base_url/api_key when available). Falls back to the bare provider/model on any resolution error so a misconfigured slot still attempts the call rather than aborting the whole MoA turn. rr%r)rrr)resolve_runtime_provider) requested target_modelbase_urlapi_keyapi_modez-MoA slot runtime resolution failed for %s: %sN) r+r)r*hermes_cli.runtime_providerr>r3loggerdebugr/)r,rroutr>rtexcs r _slot_runtimerJs"488J'-2.446H !'R ( . . 0E'/%@C^H %u M 66*  nC O 66)  ]C N 66*  nC O J ^ DkRVFWY\]] J^sAB<< C0 C++C0c p ddlm}ddlm}ddlm}|dddd}|||j dxsd|j dxsd|j d xsd|j d xsd\}}|s|S||| S#t$r"}tjd ||cYd }~Sd }~wwxYw)uuDecorate an advisor or aggregator request with cache_control when its route honors it. Reuses the SAME policy function as the main agent loop (``anthropic_prompt_cache_policy``) resolved against the slot's own provider/base_url/api_mode/model, and the SAME breakpoint layout (``apply_anthropic_cache_control``, system_and_3). This keeps advisor and aggregator calls decorated exactly like an acting agent on that provider would be — no MoA-specific caching logic to drift. Returns the messages unchanged on any resolution error or when the policy says the route doesn't honor markers. r)SimpleNamespace)anthropic_prompt_cache_policy)apply_anthropic_cache_controlr%)rrArCrrrArCr)native_anthropicz(MoA cache_control decoration skipped: %sN) typesrLagent.agent_runtime_helpersrMagent.prompt_cachingrNr)r3rErF) rruntimerLrMrNstub should_cache native_layoutrIs r_maybe_apply_moa_cache_controlrWs")MF R"BO&C [[,2[[,2[[,2++g&," ' # mO, }    ?Es$A=B B B5B0*B50B5r max_tokensc &ddlm}m}m}t |}t |} dt dg|} t| |} tdd| ||t|d|} |} t| dd} | r* || |jd |jd  } d} d}d} ||jd xsd | |jd |jd|jd}|j} |j}|j}t!| xsd}t#| | ||| ||jd |jd xs|jd | }|||fS#t$r |} YwxYw#t$rYzwxYw#t$r}}t$j'd|||d|dt#|dt dg|d|d|jd |jd xs|jd |fcYd}~Sd}~wwxYw)uCall one reference model and return ``(label, text, usage)``. The slot is resolved to its provider's real runtime (via ``_slot_runtime``) and called through the same ``call_llm`` request-building path any model uses, so per-model wire-format handling (anthropic_messages, max_completion_tokens, fixed/forbidden temperature) applies identically to a reference as it would if that model were the acting model. MoA imposes no cap of its own (``max_tokens`` defaults to ``None`` → omitted → the model's real maximum); ``temperature`` is only the user's configured preset value, which call_llm may still override per model. The reference's token usage is normalized with the slot's OWN resolved provider/api_mode (advisors may run on a different provider than the aggregator, with different usage wire shapes) and returned as a ``CanonicalUsage`` so the caller can fold advisor spend into session accounting. Without this, the entire reference fan-out — often the bulk of a MoA turn's token spend — is invisible to cost tracking, which only ever saw the aggregator's usage. Never raises: a failed reference becomes a labelled note so the aggregator can still act with partial context. Designed to run inside a thread pool — ``call_llm`` is synchronous/blocking, so threads (not asyncio) are the right concurrency primitive, mirroring ``delegate_task``'s batch fan-out. r)CanonicalUsageestimate_usage_costnormalize_usagesystemrolecontent moa_referencetaskrrrYreasoning_configr NrrC)rrCrr%rArB)rrArBz(empty response)rz!MoA reference model %s failed: %sz [failed: r(r#)agent.usage_pricingr[r\r]r/rJ_REFERENCE_SYSTEM_PROMPTrWrr4getattrr)r3 amount_usdstatussource _extract_textr rEwarning)r, ref_messagesrrYr[r\r]r-rSrresponser raw_usagerrrcost _output_textacctrIs r_run_referencertsP>YX  ED!GO &2JK[l[2(GD  #!3D9     Hgt4  )'$[[4$[[4   &!'R Z0 Z0 I. DH++K++K%X.D2D     ((7#[[,D0D#  lD((E )&( )(      :E3G #a(.  '4LM]P\]se1%((7#[[,D0D# +     siAF +)E%F A1E; AF %E85F 7E88F ; FF FF HA2H H Hc ddlm}|sgSdgt|z}i}ttt|}ddlm}t|5} t|D]\\} } | jddk(r t| dt|f|| <:| || j|t| ||| <^|jD]\} } | j|| < ddd|D cgc]} | |  c} S#1swYxYwcc} w) aGFan out all reference models in parallel, returning outputs in order. Like ``delegate_task``'s batch mode, every reference is dispatched at once and we block until all of them finish before handing the joined results to the aggregator. Output order matches ``reference_models`` so the ``Reference {idx}`` labelling stays stable. MoA presets that reference another MoA preset are skipped here (recursion guard) with a labelled note. Each element is ``(label, text, usage)`` where usage is a ``CanonicalUsage`` (zeroed for skipped/failed references). rr[N)propagate_context_to_thread) max_workersrmoaz7[skipped: MoA presets cannot recursively reference MoA]rX)rfr[lenmin_MAX_REFERENCE_WORKERStools.thread_contextrwr enumerater)r/r submitrtitemsresult)reference_modelsrnrrYr[resultsfuturesworkersrwexecutoridxr,futurers r_run_references_parallelr}s'$3  26#>N:O1OGG(#.>*?@G A  0+H"#34 ICxx #u,%M">#34   /? +)    &#==? +KFC!==?GCL +)+. 0!!-A 00/++. 1sBC9*D2D9Dct|rt||kr|S|dz}t|d|zz }|d|d|d|| dS)aHead+tail preview of a tool result for the advisory view. Keeps the first and last halves of the budget with a ``[... N chars omitted ...]`` marker between them, so a reference sees both how the result started and how it ended without replaying the whole payload. Nz [... z chars omitted ...] )rz)textbudgethalfomitteds r_truncate_tool_resultrsX 3t9& Q;D$i!d("G5Dk]''*?dUV ~ NNrcg}|xsgD]}t|tr|jdxsini}|jdxs't|tr|jdndxsd}|jd}t|tr|}n| ddl}|j |d }nd}|j|r d |d |d nd |d dj|S#t $rt|}YIwxYw)a$Render an assistant turn's tool_calls as readable text lines. The advisory view cannot carry real ``tool_calls`` payloads (strict providers reject tool_calls the reference never produced), so the agent's actions are flattened to text the reference can read and reason about. functionnamer%tool argumentsNrF) ensure_asciiz[called tool: (z)]r( ) isinstancedictr)r+jsondumpsr3appendjoin) tool_callslinestcfnrargs args_textrs r_render_tool_callsrsEBg+5b$+?bffZ &BRvvf~[Jr44H"&&.b[U[vvk" dC I   & JJt%J@ I i~dV1YKr:~^b]ccdMefg 99U   &I  &sC!!C87C8z[The conversation above is the current state of the task. Give your most intelligent judgement: what is going on, what should happen next, what risks or mistakes you see, and how the acting agent should proceed.]cNg}d}|D]m}|jd}|jd}t|}|dk(r7|dk(rL|jst|tr|rd}|jsq|}|j d|d|dk(rg}|jr|j |jt |jd }|r|j ||s|j dd j|d|d k(st|} d | d } |r-|djddk(r|ddd z| z|dd<Z|j d| dp|r0|djddk(r|j dtdn|r|djddk(r |s_|d|dgSt|D]I}|jddk(st|jd} | jsCd| dgcS|S)u Build an advisory view of the conversation for reference models. A reference gives an INFORMED judgement on the current state, so it must see what the agent actually did — its tool calls AND the tool results that came back — not just the agent's narration. We therefore preserve the whole conversation flow, but flatten it into clean user/assistant *text* turns: - system prompt: dropped (8K of Hermes boilerplate, not advisory signal). - assistant turns: kept; any ``tool_calls`` are rendered inline as ``[called tool: name(args)]`` text lines appended to the turn's text. - ``tool``-role results: NOT dropped. Each is folded (head+tail preview, see ``_truncate_tool_result``) into the *preceding* assistant turn as a ``[tool result: ...]`` block, so the reference sees what came back. This emits ZERO ``tool``-role messages and ZERO ``tool_calls`` arrays — only plain user/assistant text — so strict providers (Mistral, Fireworks) that reject orphan tool messages / unproduced tool_calls don't 400, while the reference still has the full picture. The view MUST end with a ``user`` turn. Anthropic (and OpenRouter→Anthropic) interpret a trailing assistant turn as an assistant *prefill* to continue, and no-prefill models (e.g. Claude Opus 4.8) reject it with ``400 ... must end with a user message``. Rather than DELETE the agent's latest context to satisfy that (which would blind the reference to the current state), we APPEND a synthetic user turn asking the reference to judge the state above. End-on-user is satisfied and no context is lost. The acting aggregator always receives the full, untrimmed transcript; this function only shapes the disposable advisory copy. Nr`rar^userz7[user sent non-text content (e.g. an image attachment)]r_ assistantrrrz[tool result: r() r)rr*rlistrrrr_ADVISORY_INSTRUCTIONreversed) rrenderedlast_user_contentmsgr`rarparts calls_text result_textblock fallback_texts r_reference_messagesrs0>&(H$(GIwwv'')$ $G, 8   6>:: [ !Ezz| TZZ\*+CGGL,ABJ Z(5AQ RS V^05K$[M3EHRL,,V4 C*22,y*AD*H5*P Y' GHOGIZHRL$$V, ;4IJK hrl&&v.&8   (#0ABC CH% HCwwv&( 4SWWY5G H  &&(%+ FGG  H Orc td}| td|j|}|jxsdj }|r|S |j dj}t|tr|jd}n t|d|}t|ts|r t|nd}|j S#t $rYwxYw#t $rYywxYw)Nchat_completionsz&chat_completions transport unavailabler%rra) r RuntimeErrornormalize_responserar*r3choicesmessagerrr)rhr+)ro transport normalizedrrras rrlrljs  !"45  GH H11(; ""(b//1 K  ""1%-- gt $kk),Ggy':G'3'&-c'l2G}}     s%A CA6C CC C! C!c|j|}| t|tr|jsy t |S#t t f$rtjd||YywxYw)u,Read an optional temperature from a preset. Returns None when the key is absent, empty, or explicitly null — meaning "don't send temperature; let the provider default apply", exactly like a single-model Hermes agent (which never sends temperature unless configured). The old coercion ``float(preset.get(key, 0.6) or 0.6)`` made unset impossible: absent, null, and even 0 all collapsed to the hardcoded default, so MoA advisors/aggregator always ran at 0.6/0.4 while the same model running solo used the provider default. Nz(ignoring non-numeric %s=%r in MoA preset) r)rr+r*float TypeError ValueErrorrErm)presetkeyvalues r_preset_temperaturersa JJsOE }E3/ U| z "A3Ns A&A*)A*)raggregator_temperaturerYc g}t|}t||||}djdt|dD} d|d| } t |} t |} t d| d g| } tdd | ||t|d | }t|}|s| }d| ddjd|Dd|jS#t$r#}tjd | |d }Yd}~Zd}~wwxYw)uERun configured reference models and synthesize their advice. Failures are returned as model-specific notes instead of aborting the normal agent loop; the main model can still act with partial context. ``max_tokens`` is ``None`` by default: MoA does not cap reference or aggregator output, so each model uses its own maximum. ``call_llm`` omits the parameter entirely when it is ``None`` (see its docstring), which also sidesteps providers that reject ``max_tokens`` outright. A hardcoded cap here previously truncated long aggregator syntheses. ``temperature`` / ``aggregator_temperature`` are ``None`` by default: like max_tokens, ``call_llm`` omits temperature when None so the provider default applies — matching single-model agent behavior. Presets may still pin explicit values. rX c3@K|]\}\}}}d|d|d|ywz Reference u — z: Nr#.0rr-r_usages r z(aggregate_moa_context..s6 &C&%v SEugS/startauYou are the aggregator in a Mixture of Agents process. Synthesize the reference responses into concise, actionable guidance for the main Hermes agent. Focus on next steps, tool-use strategy, risks, and any disagreements. Do not answer the user directly unless that is all that is needed; produce context the main agent should use in its normal loop. Original user prompt: z Reference responses: rr_moa_aggregatorrcz"MoA aggregator model %s failed: %sr%Nu[Mixture of Agents context — use this as private guidance for the normal Hermes agent loop. You may call tools, continue reasoning, or finish normally.] Aggregator: References: , c32K|]}t|ywrr/)rr,s rrz(aggregate_moa_context..s PtT!2 Pr#)rrrr~r/rJrWrr<rlr3rErmr*) user_prompt api_messagesrr:rrrYreference_outputsrnjoined synth_prompt agg_label agg_runtime agg_messagesro synthesisrIs raggregate_moa_contextrsR457&|4L0 [[*34EQ*OF  " #./!!'  *J'I +K6 6 7  !!.!9*E    "(+   !k"yy P?O PPQQU ??     ;YL s5C C3C..C3c|r|dnd}|a|jddk(rM|jd}t|tr |dz|z|d<yt|trg|dd|zd|d<y|j d|d y) uAttach the per-turn reference block at the END of the aggregator prompt. The reference text differs on every tool-loop iteration. In an agentic loop the most recent ``user`` message is the *original task* sitting near the TOP of the context (everything after it is assistant/tool turns), so merging the turn-varying reference block into it diverges the prompt prefix early — the server's KV cache cannot be reused and the entire conversation re-prefills on every step (full prefill each tool call, dominating latency on long contexts). Appending at the very end keeps the ``[system][task][tool-history]`` prefix stable and cache-reusable (only the new block re-prefills), and gives the aggregator the references with recency. Merge into the last message only when it is already a trailing ``user`` turn (plain chat — still at the end). A trailing user turn's content may be a STRING or a LIST of content parts — Anthropic prompt-cache decoration (which runs before the MoA facade) converts string content to ``[{"type": "text", ..., "cache_control": ...}]``, and multimodal turns are lists natively. Both shapes are merged in place: appending a new text part AFTER the cache_control-marked part keeps the cached prefix byte-stable (the marker still terminates it) while the turn-varying guidance rides outside the cached span. Appending a SEPARATE user message here instead would produce two consecutive user turns — strict providers reject that. rNr`rrarr)typerr_)r)rr+rr)rguidancelast last_contents r_attach_reference_guidancers2 ,< D DHHV,6xx * lC (*V3h>DO  lD )Z ZvvPXGX.YZDO H=>rcHeZdZdZdd dZd dZ d d dZd dZddZy)MoAChatCompletionszGOpenAI-chat-compatible facade where the aggregator is the acting model.Nc|xsd|_||_d|_g|_ddlm}||_d|_d|_d|_ y)Ndefaultrrv) preset_namereference_callback_ref_cache_key_ref_cache_outputsrfr[_pending_reference_usage_pending_reference_costlast_aggregator_slot_pending_trace)rrrr[s rrzMoAChatCompletions.__init__sW&3)#5-1>@ 7-;-=%,0$*.!$(rc~ddlm}|jxs|}|j}||_d|_||fS)aPop pending reference-fan-out usage + cost, resetting both to empty. Returns ``(CanonicalUsage, cost_usd_or_None)`` for the most recent ``create()`` and clears the pending values, so a subsequent read (e.g. a streaming retry re-entering accounting) cannot double-count. Usage is always a ``CanonicalUsage`` (zeroed if none); cost is a summed-dollars float or ``None`` when no advisor could be priced. rrvN)rfr[rr)rr[r rqs rconsume_reference_usagez*MoAChatCompletions.consume_reference_usageCsB 7--A1A++(6(8%'+$d{rc"|j}d|_|rd|vry ddlm}|jdxsi}|jd}||r|}|||jdd|jd g|jd d|jd |jd |jd |jd|t |jd y#t $r }t jd|Yd}~yd}~wwxYw)uFlush the pending full-turn trace to disk, if one is pending. No-op when tracing is off (``save_moa_turn`` checks the config), when there is no pending trace (a cache-HIT iteration ran no references), or when the aggregator input was never recorded. Clears the pending trace so a repeat consume cannot double-write. Best-effort — never raises. ``aggregator_output_fallback`` is the aggregator's resolved acting text as the caller already holds it in memory (the streamed assistant text). On the streaming path the aggregator's output could not be captured inline at ``create()`` time (the raw token stream was handed to the live consumer), so ``pending["aggregator_output"]`` is None; we fold the caller's resolved text in here so the trace is self-contained in BOTH streaming and non-streaming modes. Non-streaming already has the inline output and ignores the fallback. Naggregator_input_messagesr) save_moa_turnaggregator_slotaggregator_outputrr%raggregator_labelrrraggregator_streamed) session_idrrraggregator_modelaggregator_providerrrrrzMoA trace flush failed: %s)ragent.moa_tracerr)boolr3rErF)rraggregator_output_fallbackpendingragg_slot agg_outputrIs rconsume_and_save_tracez)MoAChatCompletions.consume_and_save_traceTs&%%"5WD  < 5{{#45;H!%89J!&@7 %#KK"5")++.A2"F!(-?!D!)g!6$,LL$<'.{{3K'L*1++6Q*R",$(5J)K$L  < LL5s ; ; .s2:;155=/155#3"45s/1zutf-8replacec32K|]}t|ywrr)rss rrz,MoAChatCompletions.create..s3]qKN3]rrX)rrrrrz moa.reference)indexcountr-rzmoa.aggregating)r: ref_countrc3@K|]\}\}}}d|d|d|ywrr#rs rrz,MoAChatCompletions.create...s6!.C.%vSEugS7!rz.[Mixture of Agents reference context] Preset: z Aggregator/acting model: rrc3(K|] \}}}| ywrr#)rr-_s rrz,MoAChatCompletions.create..6s(T;5!Q(Tsz Use the reference responses below as private context. You are the aggregator and acting model: answer the user directly or call tools as needed. rz+MoA aggregator cannot be another MoA presetrrstreamstream_options include_usagetimeoutrrYtools extra_body)rdrrrYr&r'rerrFr#).r9r7hermes_cli.moa_configrr)rrrrrrfr[rr+r*lowerrangerzrhashlibsha256rencode hexdigesttuplerrrrrrrrr r rr~r r/rrrr<rJrlr3)(r api_kwargsr7rrrrr:rrrr[rrn fanout_mode sig_messages last_user_idx_i_m_sig _cache_key_refs_from_cache _ref_usage _ref_cost_lbl_txt_acct _ref_count_idx_label_textrrrrr agg_kwargsr" stream_kwargs _agg_responses( rcreatezMoAChatCompletions.creates1<#KM$5$5e$<$BDDTDTU z28b9!::&89?RZZ -3 9CD$4! &zz*@A*&2IJ !4V=U!V ! )jnn].K.W&0^^M%B " zz)T*! 68:*84 &**X.A/BHHJPPR # + %!MC -12r: !"%66&>V+y0AEZ0Z$&M   (+,?ma.?@ ~~ MM?K fWi(  )+ &&e3]L\3].]^ %)<)<<^dF]F]A^  $T%<%< =  -;,%/%++%= ~~1%.^!u~~$E  F -7D )+4D (**%)*;%<#-*@ #D ./J1:;LTU1V --vuf #$    %*:6( *22AQ2 2 [[!2; >>* % .LM M*% !- :    *?KD   ; <6A*6MD   2 3 jnnX./(* &*M( #/0K_d4K * + ~~i(4+5i+@ i(  !!.!~~l3..)!~~l39*E    J'     *=A##$9:;?##$78 >C##$9:D?L]?[D''(;<}_3Z!D?CD''(;<DsU& U++VVrrr+rr)returnztuple[Any, Any]NNrrrrrGNone)r r+r rrGrJ)r0rrGr) rrr r!rrrr rEr#rrrrsAQ'(R$IM-<->rcDt|jjddS)zResolved aggregator slot ({provider, model, ...}) from the most recent create(), or None. Read by session cost accounting to price the aggregator's acting turn at its real model instead of the virtual preset name.rN)rhrOrPrRs rrzMoAClient.last_aggregator_slots tyy,,.DdKKrcP|jjj||S)a3Flush the pending full-turn MoA trace via the completions facade. No-op unless ``moa.save_traces`` is enabled and a turn is pending. ``aggregator_output_fallback`` supplies the resolved acting text so the streaming path's trace is self-contained (see the facade docstring). )r)rOrPr)rrrs rrz MoAClient.consume_and_save_traces,yy$$;; 3M<  rrrF)rGrrHrI)rrr rrpropertyrrr#rrrLrL~sGg?LLIM    BE    rrL)r,dict[str, Any]rGr+)r,rVrGdict[str, Any] | None)r:rVrGrW)r,rVrGrV)rlist[dict[str, Any]]rSrVrGrX) r,dict[str, str]rnrXr float | NonerY int | NonerGztuple[str, str, Any]) rlist[dict[str, str]]rnrXrrZrYr[rGzlist[tuple[str, str, Any]])rr+rintrGr+)rrrGr+)rrXrGrX)rorrGr+)rrVrr+rGrZ)rr+rrXrr\r:rYrrZrrZrYr[rGr+)rrXrr+rGrJ)'r! __future__rr+loggingconcurrent.futuresrtypingragent.auxiliary_clientragent.message_contentragent.transportsr getLoggerrrEr|r _REFERENCE_TOOL_RESULT_BUDGETrgr/r4r<rJrWrtrrrrrrlrrrrrLr#rrrgs#1+6*   8 $3'3'z!%3,?