߲jPdZddlmZddlZddlZddlZddlZddlZddlZddl m Z m Z m Z ddl mZddlmZmZmZmZmZddlmZmZmZmZddlmZdd lmZmZdd lm Z ejBe"Z#d Z$d Z%d Z&d#dZ'd$dZ(d%dZ)d&dZ*d'dd d(dZ+d)dZ,d*dZ-d+dZ.ej^dej`Z1ej^dej`Z2ej^dej`Z3d,dZ4GddZ5ej^dZ6d,dZ7d-d Z8Gd!d"Z9y).uMemoryManager — fans the agent's memory hooks out to registered providers. The builtin provider is always allowed; only ONE external plugin provider may be registered at a time (tool-schema bloat, conflicting backends). ) annotationsN)FutureThreadPoolExecutorwait)partial)AnyCallableDictListOptional)MemoryProvider#PRE_COMPRESS_CHECKPOINT_API_VERSION ctx_boundspawn_context_thread)+extract_user_instruction_from_skill_message)get_spill_configspill_if_oversized) tool_errorg@g @cl tj|jS#ttf$rYywxYw)zU``fn``'s parameter mapping, or None when uninspectable (C callables, exotic proxies).N)inspect signature parameters TypeError ValueError)fns 9/home/ubuntu/.hermes/hermes-agent/agent/memory_manager.py_signature_paramsr%s5  $/// z "s !33cBtd|jDS)Nc3hK|]*}|jtjju,ywN)kindr Parameter VAR_KEYWORD.0ps r z"_has_var_kwargs...s%P1qvv**666P02)anyvalues)paramss r_has_var_kwargsr--s P P PPct|}|yt|jddd}t|xs6|tj j tj jfvS)a#True if ``fn`` can receive the ``require_checkpoint`` keyword (unreadable signatures -> False). Bare-shape v2 providers (``on_pre_compress(self, messages)``) would raise TypeError on the keyword, which the host would re-raise as a checkpoint failure despite a successful write. NFrequire_checkpointr")rgetattrgetr-rr# KEYWORD_ONLYPOSITIONAL_OR_KEYWORD)rr,r"s r_accepts_require_checkpointr51s` r "F ~ 6::23VT BD 6 " wdw/@/@/M/MwO`O`OvOv.w&wwr.ct|tsy|jddk(r$t|jdtr|d}|jdd}|rt|tr|SdS)a`Return a bare function-tool dict with a resolvable top-level ``name``, else None. Providers should return ``{"name", "description", "parameters"}`` but some return the wrapped OpenAI form; wrapping that twice yields a nameless ``function`` and strict providers (DeepSeek) reject the ENTIRE request, so both shapes are normalized here. Ntypefunctionname) isinstancedictr2str)schemar9s rnormalize_tool_schemar?@sd fd # zz&Z'Jvzz*7Mt,T # ::fb !Djs36==r.Fmemory_tool_presentc|rd|vry|s|y|syd|vry ddlmtfd|DS#t$rtj ddYywxYw) z@Return whether external memory-provider tools should be exposed.memoryFTr)resolve_toolsetc32K|]}d|vywrCN)r&r9rDs rr(z0memory_provider_tools_enabled..]sR8t44Rsz.ns6`UVz!}7P6`srNrOr@)r1r;listtupler*rP)agentrUpresentenableddisableds rmemory_provider_tools_exposedr^gsa E7D )Eu .`36`Z_6`3`G'94@'%QdfjBkXG ((PW XXr.c $t|dd}t|dd}|r|yt|sst|ddxsgDcgc]}t|dddk7r|}}|rBtjd |Dcgc]"}t|dt |j $c}yt|d d}t |syt|d dt|_|Dchc]}t|tst| }}d}|D]y} t| } | tjd | '| d|vs/|jd | d|jj| d|j| d|dz }{|Scc}wcc}wcc}w)zZAppend external memory-provider tool schemas to an agent tool surface; return count added._memory_managerNrUr providersr9r:builtinuMemory provider(s) %s configured but the 'memory' toolset is gated off for this session (platform_toolsets / agent.disabled_toolsets) — provider tools and system-prompt block are both withheld.get_all_tool_schemasvalid_tool_nameszlMemory provider returned a tool schema with no resolvable name; skipping to avoid poisoning the request (%r)r8)r7r8r)r1r^rLinfor7__name__callablesetrdr;r<rSr?warningappendadd) rZmemory_managerrUr' _providers get_schemasrRexisting_tool_namesadded raw_schemar>s rinject_memory_provider_toolsrrssU$5tA FB/9<> >  KK+@JJ!FDG$4$45J  .*@$GK K u($/7!$8=XDRVAW:d+XX E!m  &z2 > NNEFP F^#6 6 LL*&A B  " " & &vf~ 6  # #F6N 3 QJE  LA>KYsF/'F F - F zz5<\s*memory-context\s*>[\s\S]*?z\[System note:\s*The following is recalled memory context,\s*NOT new user input\.\s*Treat as (?:informational background data|authoritative reference data[^\]]*)\.\]\s*cVtttfD]}|jd|}|S)zQStrip fence tags, injected context blocks, and system notes from provider output.r:)_INTERNAL_CONTEXT_RE_INTERNAL_NOTE_RE _FENCE_TAG_REsub)textpatterns rsanitize_contextrzs.(*;]K%{{2t$% Kr.cbeZdZdZdZdZd dZd dZddZddZ e ddZ dd Z dd Z dd Zy )StreamingContextScrubberanStateful scrubber for streaming text whose memory-context spans may straddle deltas. ``sanitize_context`` needs both tags in one string, so a split span would leak to the UI; this holds back partial-tag tails between ``feed()`` calls and drops span interiors. One scrubber (or ``reset()``) per top-level response; call ``flush()`` at end of stream. zzc$|jyr!)resetselfs r__init__z!StreamingContextScrubber.__init__s  r.c.d|_d|_d|_y)NFr:T)_in_span_buf_at_block_boundaryrs rr~zStreamingContextScrubber.resets#  (,r.c|sy|j|z}d|_g}|rC|jr>|j}|jj |}|j ||}nv|j }|j|}t|}|jj|r|j|d| r|nd}|xs|j ||}|dk(r6|js|j||r|d| n||r|| dnd|_nH|js|j||d|||t|zd}|j |_|rCdj|S)z^Return the visible portion of ``text``; a possible partial tag tail is held for the next call.r:Nr) rr _CLOSE_TAGlowerfind_max_partial_suffix _OPEN_TAG_find_boundary_open_taglenendswith_ends_at_block_boundary_append_visiblejoin) rrxbufouttagidxheldnpendings rfeedzStreamingContextScrubber.feeds_ii$ }}ooiik&&s+//S9nn2237H"yy{33C8T=Y=YZ]^a`a_aZb=c!ijD$":":3"Dby}}((Tc&D5ksK+/CKR ==$$S#ds)4cCHno&C $ -DM+,wws|r.cV|jrdn |j}d|_d|_|S)zEmit the held-back tail at end-of-stream; inside an unterminated span it is discarded (leaking partial memory context is worse than a truncated answer).r:F)rr)rtails rflushzStreamingContextScrubber.flushs(]]r    r.c|j|jcttttdz dd}t fd|DdS)zXLength of the longest buf-suffix that is a (case-insensitive) prefix of ``tag``, else 0.rrrc3NK|]}j| ds|ywr!) startswith)r&i buf_lower tag_lowers rr(z?StreamingContextScrubber._max_partial_suffix..s&M1 (<( only whitespace and already at a boundary). r:) rpartitionstripboolr)rrxheadseprs rrz0StreamingContextScrubber._ends_at_block_boundarys=//$/c4zz|r!LtCy'KD4K4KLr.cX|r(|j||j||_yyr!)rjrr)rrrxs rrz(StreamingContextScrubber._append_visibles)  JJt &*&B&B4&HD # r.NreturnNonerxr=rr=rr=)rr=rr=rint)rr=rr)rxr=rr)rz list[str]rxr=rr)rf __module__ __qualname____doc__rrrr~rr staticmethodrrrrrGr.rr|r|sN#I$J- >RR M Ir.r|z [-*+]\s+\Sc>|jd}t}g}t|D]\}}|j}|r%|dj r|j |=t tj|}|r|s|j|ra|dzt|kr||dznd}t |jxr|dj } | s||vr|j||j |dj|S)uDrop a recalled bullet that an EARLIER line of this same block already states. Providers merge several stores (and this merges several providers), so one prefetch routinely surfaces the same fact two or three times. A byte-identical repeat inside one block tells the model nothing the block has not already said, and it is not free: the composed block is stamped into the user row's ``api_content`` sidecar and replayed verbatim on every later request for as long as that row is in context, so each duplicate is paid once per turn, forever. The ``seen`` set is scoped per section — every non-bullet line at column 0 (a heading of any style, a ``---`` rule, prose) starts a new one — so a repeat is only dropped when the SAME section already states it. Only a SELF-CONTAINED bullet is considered — a marker, whitespace, content, and no continuation line indented beneath it. A bullet that carries continuation lines is never dropped and never suppresses a later one, because two entries can share a headline and differ underneath it (``- prefers draft PRs`` / `` (logged 12 Jan, builtin)`` vs the same headline logged elsewhere): dropping one would re-parent its provenance under the other and invent a record neither provider reported. Headings — including ``**bold**`` ones — prose, blank lines, separators and numbered items are left exactly as written. rrrr:) splitrh enumeraterisspacerjr_RECALL_BULLET_REmatchclearrrkr) rxlinesseenkeptindexlinestripped is_bullet followingcarries_continuations r_drop_repeated_recall_linesrs* JJt EUDD ' t::< Q) KK  *00:; I JJL ,1AIE ,Beai(I#' (9#:#Uy|?S?S?U 't#" D%& 99T?r.c|r|jsyt|}||k7rtjdt |}d|dS)z:Wrap prefetched memory in a fenced block with system note.r:z6memory provider returned pre-wrapped context; strippedu [System note: The following is recalled memory context, NOT new user input. Treat as authoritative reference data — this is the agent's persistent memory and should inform all responses.] z )rrzrLrir) raw_context sanitizedcleans rbuild_memory_context_blockr=sX k//1 -IKOP ' 2E V '  r.c2eZdZdZddd5dZej ddd d6dZd7dZe d8d Z d9d Z d:d Z e eZd d d;dZd d ddZd ddd d?dZddd@dZdAdZdBdCdZdDdZdEdZdFdZdGdZdHdZdIdZd d d! dJd"Zd ddd# dKd$Z e dLd%Z!e"fdMd&Z#dde"d' dNd(Z$e dOd)Z% dB dPd*Z&hd+Z'e dQd,Z(dd- dRd.Z)d d/dSd0Z*dTd1Z+e dUd2Z,dTd3Z-dVd4Z.y)W MemoryManagerzBuiltin provider (always first) plus at most one external provider. Failures in one provider never block the other: every fan-out hook logs and swallows per-provider exceptions. N)external_prefetch_timeoutcHg|_i|_d|_d|_|}|tn t |}|dkr t d||_i|_tj|_ d|_ tj|_ i|_d|_ddddd|_y)NFrz*external_prefetch_timeout must be positive not_startedstatusabandoned_writesabandoned_prefetches active_tasks)rm_tool_to_provider_external_prefetch_spill_config _has_external_EXTERNAL_PREFETCH_TIMEOUT_Sfloatr_external_prefetch_timeout_external_prefetch_threads threadingLock_external_prefetch_lock_sync_executor_sync_executor_lock_background_futures_shutting_down_shutdown_drain_state)rrtimeouts rrzMemoryManager.__init__Ws02<>IM,#(+29/.uW~ a<IJ J*1'GI''0~~'7$=A#,>>#3 79 ##TUgh6 "r.F)levelrarIc g}| |jn|D]} |j|||S#t$r/}tj |d|j |||Yd}~Rd}~wwxYw)zCall ``call(provider)`` per provider, logging+swallowing failures; returns successes in order. ``label`` completes the log line ``Memory provider ''