§ Ròmjˆ8ãór—dZddlmZmZmZmZmZmZddlm Z ddlm Z ddlm ZddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZ ddlm!Z"ddlm#Z$ddlm%Z&ddlm'Z(ddlm)Z*ddlm+Z,de-de.deddfd„Z/de-de0fd„Z1de-de.deddfd„Z2de-de0fd„Z3de-de.deddfd„Z4de-de0fd„Z5de-de.deddfd „Z6de-de0fd!„Z7de-de.deddfd"„Z8de-de0fd#„Z9de-de.deddfd$„Z:de-de0fd%„Z;de-de.deddfd&„Zde-de0fd)„Z?de-de.deddfd*„Z@de-de0fd+„ZAgd,¢ZBdS)-a4Global guardrail registration for tools and LLMs. Guardrails can either sanitize data recorded on lifecycle events or reject a call before it runs. In managed ``tools.execute()`` and ``llm.execute()`` flows, sanitize guardrails are observability-only: they change the payload written to emitted events, not the value passed to the user callback or returned to the caller. Example:: import nemo_relay def redact(tool_name, args): return {**args, "api_key": "***"} nemo_relay.guardrails.register_tool_sanitize_request("redact", 10, redact) é)ÚEventSanitizeGuardrailÚ LlmConditionalExecutionGuardrailÚLlmSanitizeRequestGuardrailÚLlmSanitizeResponseGuardrailÚ!ToolConditionalExecutionGuardrailÚToolSanitizeGuardrail)Ú.deregister_llm_conditional_execution_guardrail)Ú)deregister_llm_sanitize_request_guardrail)Ú*deregister_llm_sanitize_response_guardrail)Ú"deregister_mark_sanitize_guardrail)Ú'deregister_scope_sanitize_end_guardrail)Ú)deregister_scope_sanitize_start_guardrail)Ú/deregister_tool_conditional_execution_guardrail)Ú*deregister_tool_sanitize_request_guardrail)Ú+deregister_tool_sanitize_response_guardrail)Ú,register_llm_conditional_execution_guardrail)Ú'register_llm_sanitize_request_guardrail)Ú(register_llm_sanitize_response_guardrail)Ú register_mark_sanitize_guardrail)Ú%register_scope_sanitize_end_guardrail)Ú'register_scope_sanitize_start_guardrail)Ú-register_tool_conditional_execution_guardrail)Ú(register_tool_sanitize_request_guardrail)Ú)register_tool_sanitize_response_guardrailÚnameÚpriorityÚ guardrailÚreturnNcó$—t|||¦«S)z9Register a sanitizer for mark event observability fields.)Ú_native_register_mark_sanitize©rrrs ú]/home/thesage/.hermes/hermes-agent/venv/lib/python3.11/site-packages/nemo_relay/guardrails.pyÚregister_mark_sanitizer#Ws€å )¨$°¸)Ñ DÔ DÐDócó —t|¦«S)z-Remove a global mark event sanitizer by name.)Ú _native_deregister_mark_sanitize©rs r"Úderegister_mark_sanitizer(\s€å +¨DÑ 1Ô 1Ð1r$có$—t|||¦«S)z:Register a sanitizer for every scope start event category.)Ú%_native_register_scope_sanitize_startr!s r"Úregister_scope_sanitize_startr+as€å 0°°xÀÑ KÔ KÐKr$có —t|¦«S)z4Remove a global scope-start event sanitizer by name.)Ú'_native_deregister_scope_sanitize_startr's r"Úderegister_scope_sanitize_startr.fs€å 2°4Ñ 8Ô 8Ð8r$có$—t|||¦«S)z8Register a sanitizer for every scope end event category.)Ú#_native_register_scope_sanitize_endr!s r"Úregister_scope_sanitize_endr1ks€å .¨t°X¸yÑ IÔ IÐIr$có —t|¦«S)z2Remove a global scope-end event sanitizer by name.)Ú%_native_deregister_scope_sanitize_endr's r"Úderegister_scope_sanitize_endr4ps€å 0°Ñ 6Ô 6Ð6r$có$—t|||¦«S)a’Register a guardrail that sanitizes tool inputs for emitted start events. Args: name: Unique guardrail name used for later replacement or removal. priority: Execution order for the guardrail. Lower values run first. guardrail: Callable invoked as ``guardrail(tool_name, args)`` that must return the sanitized payload to record on the emitted start event. Returns: None: This function returns after the guardrail is registered. Notes: In managed ``nemo_relay.tools.execute()`` flows, sanitize guardrails are observability-only. They change the payload written to events, not the arguments passed to the tool callback. Example:: import nemo_relay def redact(tool_name, args): return {**args, "api_key": "***"} nemo_relay.guardrails.register_tool_sanitize_request("redact", 10, redact) )Ú&_native_register_tool_sanitize_requestr!s r"Úregister_tool_sanitize_requestr7zs€õ4 2°$¸À)Ñ LÔ LÐLr$có —t|¦«S)a—Remove a previously registered tool sanitize-request guardrail. Args: name: Guardrail name previously passed to ``register_tool_sanitize_request()``. Returns: bool: ``True`` if a guardrail was removed, otherwise ``False``. Notes: Removal affects only future executions. In-flight calls continue using the guardrail chain they already resolved. )Ú(_native_deregister_tool_sanitize_requestr's r"Ú deregister_tool_sanitize_requestr:—ó€õ 4°DÑ 9Ô 9Ð9r$có$—t|||¦«S)a]Register a guardrail that sanitizes tool outputs for emitted end events. Args: name: Unique guardrail name used for later replacement or removal. priority: Execution order for the guardrail. Lower values run first. guardrail: Callable invoked as ``guardrail(tool_name, result)`` that must return the sanitized payload to record on emitted end events. Returns: None: This function returns after the guardrail is registered. Notes: This guardrail affects event payloads only. The caller still receives the original tool result. )Ú'_native_register_tool_sanitize_responser!s r"Úregister_tool_sanitize_responser>¨s€õ 3°4¸À9Ñ MÔ MÐMr$có —t|¦«S)a™Remove a previously registered tool sanitize-response guardrail. Args: name: Guardrail name previously passed to ``register_tool_sanitize_response()``. Returns: bool: ``True`` if a guardrail was removed, otherwise ``False``. Notes: Removal affects only future executions. In-flight calls continue using the guardrail chain they already resolved. )Ú)_native_deregister_tool_sanitize_responser's r"Ú!deregister_tool_sanitize_responserA»s€õ 5°TÑ :Ô :Ð:r$có$—t|||¦«S)a]Register a guardrail that can reject a tool call before execution. Args: name: Unique guardrail name used for later replacement or removal. priority: Execution order for the guardrail. Lower values run first. guardrail: Callable invoked as ``guardrail(tool_name, args)``. Return ``None`` to allow execution or a rejection message to block it. Returns: None: This function returns after the guardrail is registered. Notes: Conditional-execution guardrails run before request intercepts and before the tool callback is invoked. )Ú+_native_register_tool_conditional_executionr!s r"Ú#register_tool_conditional_executionrDÌs€õ 7°t¸XÀyÑ QÔ QÐQr$có —t|¦«S)a¡Remove a previously registered tool conditional-execution guardrail. Args: name: Guardrail name previously passed to ``register_tool_conditional_execution()``. Returns: bool: ``True`` if a guardrail was removed, otherwise ``False``. Notes: Removal affects only future executions. In-flight calls continue using the guardrail chain they already resolved. )Ú-_native_deregister_tool_conditional_executionr's r"Ú%deregister_tool_conditional_executionrGßs€õ 9¸Ñ >Ô >Ð>r$có$—t|||¦«S)aRegister a guardrail that sanitizes LLM requests for emitted start events. Args: name: Unique guardrail name used for later replacement or removal. priority: Execution order for the guardrail. Lower values run first. guardrail: Callable invoked as ``guardrail(request)`` that must return the sanitized request recorded on the emitted start event. Returns: None: This function returns after the guardrail is registered. Notes: In managed ``nemo_relay.llm.execute()`` and ``nemo_relay.llm.stream_execute()`` flows, this is observability-only and does not mutate the request forwarded to the provider callback. Example:: import nemo_relay def strip_auth(request): headers = {k: v for k, v in request.headers.items() if k.lower() != "authorization"} return nemo_relay.LLMRequest(headers, request.content) nemo_relay.guardrails.register_llm_sanitize_request("strip-auth", 10, strip_auth) )Ú%_native_register_llm_sanitize_requestr!s r"Úregister_llm_sanitize_requestrJõs€õ6 1°°xÀÑ KÔ KÐKr$có —t|¦«S)a•Remove a previously registered LLM sanitize-request guardrail. Args: name: Guardrail name previously passed to ``register_llm_sanitize_request()``. Returns: bool: ``True`` if a guardrail was removed, otherwise ``False``. Notes: Removal affects only future executions. In-flight calls continue using the guardrail chain they already resolved. )Ú'_native_deregister_llm_sanitize_requestr's r"Úderegister_llm_sanitize_requestrMs€õ 3°4Ñ 8Ô 8Ð8r$có$—t|||¦«S)aeRegister a guardrail that sanitizes LLM outputs for emitted end events. Args: name: Unique guardrail name used for later replacement or removal. priority: Execution order for the guardrail. Lower values run first. guardrail: Callable invoked as ``guardrail(response)`` that must return the sanitized payload recorded on the emitted end event. Returns: None: This function returns after the guardrail is registered. Notes: This guardrail changes only event payloads. The raw provider response returned to the caller is left unchanged. )Ú&_native_register_llm_sanitize_responser!s r"Úregister_llm_sanitize_responserP$s€õ 2°$¸À)Ñ LÔ LÐLr$có —t|¦«S)a—Remove a previously registered LLM sanitize-response guardrail. Args: name: Guardrail name previously passed to ``register_llm_sanitize_response()``. Returns: bool: ``True`` if a guardrail was removed, otherwise ``False``. Notes: Removal affects only future executions. In-flight calls continue using the guardrail chain they already resolved. )Ú(_native_deregister_llm_sanitize_responser's r"Ú deregister_llm_sanitize_responserS7r;r$có$—t|||¦«S)aSRegister a guardrail that can reject an LLM call before execution. Args: name: Unique guardrail name used for later replacement or removal. priority: Execution order for the guardrail. Lower values run first. guardrail: Callable invoked as ``guardrail(request)``. Return ``None`` to allow execution or a rejection message to block the call. Returns: None: This function returns after the guardrail is registered. Notes: Conditional-execution guardrails run before request intercepts, codecs, and provider execution. )Ú*_native_register_llm_conditional_executionr!s r"Ú"register_llm_conditional_executionrVHs€õ 6°d¸HÀiÑ PÔ PÐPr$có —t|¦«S)aŸRemove a previously registered LLM conditional-execution guardrail. Args: name: Guardrail name previously passed to ``register_llm_conditional_execution()``. Returns: bool: ``True`` if a guardrail was removed, otherwise ``False``. Notes: Removal affects only future executions. In-flight calls continue using the guardrail chain they already resolved. )Ú,_native_deregister_llm_conditional_executionr's r"Ú$deregister_llm_conditional_executionrY[s€õ 8¸Ñ =Ô =Ð=r$)r#r(r+r.r1r4r7r:r>rArDrGrJrMrPrSrVrY)CÚ__doc__Ú nemo_relayrrrrrrÚnemo_relay._nativer rXr rLr rRr r&r r3rr-rrFrr9rr@rrUrrIrrOrr rr0rr*rrCrr6rr=ÚstrÚintr#Úboolr(r+r.r1r4r7r:r>rArDrGrJrMrPrSrVrYÚ__all__©r$r"úrbsºðððð&ððððððððððððððððððððððððððððððððððfÐeÐeÐeÐeÐeðððððððððððððððððððððððððððððððððððððððððððððððððbÐaÐaÐaÐaÐaðððððððððððððððððððððððððððððððE ðE°ðEÐ@VðEÐ[_ðEðEðEðEð 2 3ð2¨4ð2ð2ð2ð2ð L¨ðL°sðLÐG]ðLÐbfðLðLðLðLð 9¨#ð9°$ð9ð9ð9ð9ð J cðJ°SðJÐE[ðJÐ`dðJðJðJðJð 7¨ð7°ð7ð7ð7ð7ðM¨ðM¸ðMÐH]ðMÐbfðMðMðMðMð::¨3ð:°4ð:ð:ð:ð:ð"N¨#ðN¸ðNÐI^ðNÐcgðNðNðNðNð&;¨Cð;°Dð;ð;ð;ð;ð"R¨cðR¸SðRÐMnðRÐswðRðRðRðRð&?°ð?¸ð?ð?ð?ð?ð,L¨ðL°sðLÐGbðLÐgkðLðLðLðLð<9¨#ð9°$ð9ð9ð9ð9ð"M¨ðM¸ðMÐHdðMÐimðMðMðMðMð&:¨3ð:°4ð:ð:ð:ð:ð"Q¨SðQ¸CðQÐLlðQÐquðQðQðQðQð&>¨sð>°tð>ð>ð>ð>ð" ð ð €€€r$