i|,xdZddlmZddlZddlZddlmZejeZ ddZ dd Z d d ddZ ddZ dS)uSanitize tool JSON schemas for broad LLM-backend compatibility. Some local inference backends (notably llama.cpp's ``json-schema-to-grammar`` converter used to build GBNF tool-call parsers) are strict about what JSON Schema shapes they accept. Schemas that OpenAI / Anthropic / most cloud providers silently accept can make llama.cpp fail the entire request with: HTTP 400: Unable to generate parser for this template. Automatic parser generation failed: JSON schema conversion failed: Unrecognized schema: "object" The failure modes we've seen in the wild: * ``{"type": "object"}`` with no ``properties`` — rejected as a node the grammar generator can't constrain. * A schema value that is the bare string ``"object"`` instead of a dict (malformed MCP server output, e.g. ``additionalProperties: "object"``). * ``"type": ["string", "null"]`` array types — many converters only accept single-string ``type``. * ``anyOf`` / ``oneOf`` unions whose only purpose is to permit ``null`` for optional fields (common Pydantic/MCP shape). Anthropic rejects these at the top of ``input_schema``; collapse them to the non-null branch. * Unconstrained ``additionalProperties`` on objects with empty properties. This module walks the final tool schema tree (after MCP-level normalization and any per-tool dynamic rebuilds) and fixes the known-hostile constructs in-place on a deep copy. It is intentionally conservative: it only modifies shapes the LLM backend couldn't use anyway. ) annotationsN)Anytools list[dict]returnc`|s|Sg}|D]$}|t|%|S)uAReturn a copy of ``tools`` with each tool's parameter schema sanitized. Input is an OpenAI-format tool list: ``[{"type": "function", "function": {"name": ..., "parameters": {...}}}]`` The returned list is a deep copy — callers can safely mutate it without affecting the original registry entries. )append_sanitize_single_tool)r sanitizedtools ;/home/ubuntu/.hermes/hermes-agent/tools/schema_sanitizer.pysanitize_tool_schemasr(sK  I66.t445555 r dictctj|}t|tr|dnd}t|ts|S|d}t|ts did|d<|St ||dd|d<|d}t|ts did|d<nO|d dkrd|d <d |vs(t|d tsi|d <t |dd |d<|S) z9Deep-copy and sanitize a single OpenAI-format tool entry.functionN parametersobjecttype propertiesnamez)pathrrTkeep_nullable_hint)copydeepcopy isinstancerget_sanitize_nodestrip_nullable_unions)r outfnparamstops r r r :sO -  C *3 5 5 ?   4B b$   VVL ! !F fd # #$,B??< %f266&(3K3KLLLB| \ C c4 #$,B??< 776??h & &"CK s " "*SWW\5J5JD*Q*Q " "C  -R -=RVWWWB| JrTrschemarrboolct|trfd|DSt|ts|Sfd|D}dD]}||}t|ts-d|D}t |dkrt |t |krut|dtrt|dni}r|ddd D]}||vr||vr ||||<t| cS|S) aCollapse ``anyOf`` / ``oneOf`` nullable unions to the non-null branch. MCP / Pydantic optional fields commonly arrive as:: {"anyOf": [{"type": "string"}, {"type": "null"}], "default": null} Anthropic's tool input-schema validator rejects the null branch. Tool optionality is already represented by the parent object's ``required`` array, so we collapse the union to the single non-null variant. Metadata (``title``, ``description``, ``default``, ``examples``) on the outer union node is carried over to the replacement variant. Args: schema: JSON-Schema fragment (dict, list, or scalar). keep_nullable_hint: If True, set ``nullable: true`` on the replacement to preserve the "this field may be None" signal for downstream consumers that care (e.g. runtime argument coercion that maps the literal string ``"null"`` to Python ``None``). Anthropic's validator accepts ``nullable: true`` but strict producers may prefer False. Returns: The schema with nullable unions collapsed. Non-union nodes are returned unchanged. c2g|]}t|Srr!).0itemrs r z)strip_nullable_unions..zs)fffW[%d?QRRRfffrc:i|]\}}|t|Sr*r+)r,kvrs r z)strip_nullable_unions..~s> Aq 7I J J Jr)anyOfoneOfcng|]2}t|tr|ddk0|3S)rnull)rrr)r,r-s r r.z)strip_nullable_unions..sK   tT** /3xx/?/?6/I/I /I/I/IrrnullableT)title descriptiondefaultexamplesr)rlistritemsrlen setdefaultr!)r&rstrippedkeyvariantsnon_null replacementmeta_keys ` r r!r!Zs>&$gffff_effff fd # # LLNNH"]]<<$$(D))    %    x==A  #h--3x=="@"@/9(1+t/L/LT$x{+++RTK! 9&&z4888K ? ?x''HK,G,G,4X,>K)(I[\\\ \ \ \ Ornoderstrct|trQ|dvr,td|||dkrd|indidStd|didSt|trfdt |DSt|t s|Si}|D]\}dkrt|trd|D}t|d krAt|d tr&|d |d<d |vr| d d td|Dd}|r||d<d|d<dvr:t|t r%fd|D|<dvr6t|tr||<t|d|<!dvr6t|tr!fdt |D|<[dvr7t|tt frtj|n||<t|t tfrt|dn||<|ddkr-t|dt si|d<|ddkrt|dtro|dpifd|dD}|s|ddn+t|t|dkr||d<|S)aRecursively sanitize a JSON-Schema fragment. - Replaces bare-string schema values ("object", "string", ...) with ``{"type": }`` so downstream consumers see a dict. - Injects ``properties: {}`` into object-typed nodes missing it. - Normalizes ``type: [X, "null"]`` arrays to single ``type: X`` (keeping ``nullable: true`` as a hint). - Recurses into ``properties``, ``items``, ``additionalProperties``, ``anyOf``, ``oneOf``, ``allOf``, and ``$defs`` / ``definitions``. >r6arraynumberrstringbooleanintegerzGschema_sanitizer[%s]: replacing bare-string schema %r with {'type': %r}rrrzMschema_sanitizer[%s]: replacing non-schema string %r with empty object schemac Bg|]\}}t|d|dS)[]r )r,ir-rs r r.z"_sanitize_node..s3TTTDt^^q^^^44TTTrcg|] }|dk| S)r6r,ts r r.z"_sanitize_node..s888aAKKKKKrr7rr6r8Tc3PK|]!}t|t|dk|V"dS)r6NrrHrVs r z!_sanitize_node..s5UUA*Q2D2DUfaUUrN>$defsr definitionsc Hi|]\}}|t|dd|S).rR)r,sub_ksub_vrBrs r r2z"_sanitize_node..sO E5~e-D-Ds-D-DU-D-DEEr>r>additionalPropertiesr^>allOfr3r4c Hg|]\}}t|dd|dS)r^rPrQrR)r,rSr-rBrs r r.z"_sanitize_node..sPAtt%9%9s%9%9Q%9%9%9::r>enumr<requiredrrecFg|]}t|t|v|SrUrY)r,rpropss r r.z"_sanitize_node..s-QQQqz!S/A/AQa5jjjjjr)rrHloggerdebugr= enumeraterr>r?r@nextr'r rrrpop) rGrr"valuerD first_strvalidrBrhs ` @@r r r s($4 X X X LL$dD    &*X%5%5FD>>  <<    '(,d   !333$UTTTTIdOOTTTT dD ! ! Cjjll0l0l U &==Zt44=885888H8}}!!j!c&B&B!&qkF U??NN:t444UUUUUW[\\I 'F "CK  8 8 8Zt=T=T 8$)KKMMCHH5 5 5%&& B!C)%D3AAC / / /Jud4K4K /(//CHH4 4 40:%$/N/NYt}U+++TYCHHAKETXZ^S_A`A`k~e__s__===fkCHH wwv("":cggl6K6KT+R+R"L  wwv(""z#''*2E2Et'L'L" %%+QQQQC OQQQ $ GGJ % % % % ZZ3s:// / /#C O Jr)rrrr)r rrr)r&rrr'rr)rGrrrHrr)__doc__ __future__rrloggingtypingr getLogger__name__rirr r!r rUrr rws<#"""""   8 $ $$F $;;;;;;|iiiiiir