nemo-relay-instrument-calls

Wrap tool and LLM call sites with NeMo Relay managed execution for lifecycle events and guardrails.

3.2k|370|Updated Feb 25, 2026
One-click install
npx skills add https://github.com/NVIDIA/skills --skill nemo-relay-instrument-calls
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: nemo-relay-instrument-calls
Source: https://github.com/NVIDIA/skills/tree/main/skills/nemo-relay-instrument-calls
Command: npx skills add https://github.com/NVIDIA/skills --skill nemo-relay-instrument-calls

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Applications that already own tool functions or LLM/provider call sites often lack lifecycle events, middleware, and guardrail integration. This Skill guides agents to wrap those existing call sites with NeMo Relay scopes and managed execution APIs without changing the original callable behavior.

Core Features & Use Cases

  • Managed Execution Wrapping: Use language-specific managed APIs such as tools.execute(...) in Python, tool_call_execute(...) in Rust, toolCallExecute(...) in Node.js, and tools.Execute(...) in Go to instrument existing tool and LLM calls.
  • Runtime Semantics Guidance: Explains how conditional-execution guardrails, request intercepts, sanitize guardrails, and execution intercepts interact with the wrapped callback.
  • Scope and Lifecycle Checklist: Helps place scope boundaries around agent or workflow boundaries and ensures every manual start call has a matching end or error path.
  • Use Case: A Node.js support chatbot calls a lookup_order tool and then GPT-4 for summarization; this Skill shows how to route both calls through NeMo Relay for observability and guardrail compliance while keeping business logic intact.

Quick Start

Ask your agent to wrap your existing tool functions and LLM provider calls with NeMo Relay managed execution APIs so they emit lifecycle events and pass through guardrails.

Frequently Asked Questions about nemo-relay-instrument-calls

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I wrap existing Python tool functions with NeMo Relay?

Use the managed execution APIs tools.execute(...) for tool calls and llm.execute(...) for LLM calls, placing a scope around the agent or workflow boundary first. The original callable keeps its business logic while NeMo Relay owns lifecycle events and metadata.

How do I instrument LLM provider calls with NeMo Relay in Rust?

Use llm_call_execute with LlmCallExecuteParams::builder() to wrap provider calls, and tool_call_execute with ToolCallExecuteParams::builder() for tool functions. Pass model names and stable call identifiers when they matter for trace export or diagnostics.

Which languages does NeMo Relay managed execution support?

Managed execution APIs are available for Python (tools.execute, llm.execute), Rust (tool_call_execute, llm_call_execute), Node.js (toolCallExecute, llmCallExecute), and Go (tools.Execute, llm.Execute or top-level wrappers).

Do sanitize guardrails change the data my application receives?

No. Sanitize-request and sanitize-response guardrails affect only the payloads of emitted start and end events. The caller-visible request, arguments, and returned value remain the raw callback or execution-intercept result.

When should I use manual lifecycle APIs instead of managed execution?

Use manual lifecycle APIs only when a host framework already owns execution and cannot be wrapped by the managed execute helpers. Every manual start call then needs a matching end or error path with semantic payloads supplied explicitly.