Code Examples

Use these examples for implementation surfaces:

• Adding Scopes
• Wrap Tool Calls
• Wrap LLM Calls
• Non-Serializable Data
• Using Codecs
• Provider Codecs
• Provider Response Codecs

Preferred Integration Order

Choose the highest option your framework boundary supports:

1. Managed execution wrappers.
2. Explicit start and end lifecycle calls.
3. Standalone conditional-execution helpers.
4. Standalone request-intercept helpers.
5. Mark events for milestones that are not full tool or LLM calls.

Managed execution wrappers give NeMo Relay the most complete lifecycle: middleware order, parent-child scope relationships, request and response event payloads, execution intercepts, and subscriber visibility. Fallback helpers are useful when the framework owns the real callback internally.

Managed Execution Wrappers

Use managed wrappers when the framework exposes a stable callable boundary.

Fallback: Explicit API Calls

Use explicit API calls when the framework has start and finish hooks but owns the invocation internally.

What you lose from managed execution wrappers:

• Execution intercepts cannot wrap the real callback.
• The framework must preserve the start handle and call the matching end helper.
• Request intercepts and conditional execution must be invoked explicitly if you still need them.
• Error paths need deliberate end-event or mark-event handling.

1
import nemo_relay
2
from nemo_relay import LLMRequest
3
4
def framework_tool_started(name: str, args: dict):
5
    return nemo_relay.tools.call(name, args)
6
7
def framework_tool_finished(handle, result: dict) -> None:
8
    nemo_relay.tools.call_end(handle, result)
9
10
def framework_llm_started(provider: str, payload: dict):
11
    request = LLMRequest({}, payload)
12
    return nemo_relay.llm.call(provider, request, model_name=payload.get("model"))
13
14
def framework_llm_finished(handle, response: dict) -> None:
15
    nemo_relay.llm.call_end(handle, response)

Conditional Execution

Use conditional-execution helpers when the framework needs an allow-or-block decision before it continues down its own invocation path.

1
import nemo_relay
2
from nemo_relay import LLMRequest
3
4
nemo_relay.tools.conditional_execution("search", {"query": "weather"})
5
nemo_relay.llm.conditional_execution(LLMRequest({}, {"messages": []}))

Request Intercepts

Use request-intercept helpers when the framework wants NeMo Relay to rewrite arguments or provider requests before the framework invokes its own downstream code.

1
import nemo_relay
2
from nemo_relay import LLMRequest
3
4
rewritten_args = nemo_relay.tools.request_intercepts("search", {"query": "weather"})
5
rewritten_request = nemo_relay.llm.request_intercepts(
6
    "demo-provider",
7
    LLMRequest({}, {"messages": []}),
8
)

Mark Events

Use mark events when the framework exposes important milestones but not a full lifecycle boundary.

1
import nemo_relay
2
3
nemo_relay.scope.event("scheduler.retry", data={"attempt": 2})

Sample Third-Party Patch Integrations

NeMo Relay keeps sample third-party integrations as patch sets under patches/ and pinned upstream checkouts under third_party/. For the current OpenClaw end-user integration, use the OpenClaw Plugin Guide.

The following table lists maintained patch checkouts:

Quickstart: Apply Maintained Patches

From the repository root, use the wrapper scripts when you want the maintained NeMo Relay patches applied to the pinned third-party checkouts:

The dry run checks that patches apply cleanly before modifying the local checkouts. Use manual git clone, git checkout, and git apply commands only when you need to work on one integration outside the standard wrapper flow.