From 9854fdeb6582005638efa60ccdbec52c60a6d28b Mon Sep 17 00:00:00 2001 From: Will Killian Date: Mon, 6 Jul 2026 14:11:21 -0400 Subject: [PATCH 1/2] docs: update 0.5 release notes Signed-off-by: Will Killian --- .agents/skills/draft-release-notes/SKILL.md | 65 ++++++ .../scripts/collect_release_evidence.py | 187 ++++++++++++++++++ .../release-notes/highlights.mdx | 129 ++++++------ docs/about-nemo-relay/release-notes/index.mdx | 73 ++++--- .../release-notes/known-issues.mdx | 84 +++++--- 5 files changed, 398 insertions(+), 140 deletions(-) create mode 100644 .agents/skills/draft-release-notes/SKILL.md create mode 100755 .agents/skills/draft-release-notes/scripts/collect_release_evidence.py diff --git a/.agents/skills/draft-release-notes/SKILL.md b/.agents/skills/draft-release-notes/SKILL.md new file mode 100644 index 000000000..7e9e37c74 --- /dev/null +++ b/.agents/skills/draft-release-notes/SKILL.md @@ -0,0 +1,65 @@ +--- +name: draft-release-notes +description: Compare NeMo Relay release branches and draft or update the documentation-site release notes. Use when preparing a release-notes update under docs/about-nemo-relay/release-notes, reviewing release-to-release changes, or gathering evidence for a current release summary. +--- + +# Draft Release Notes + +Draft the three documentation-site release-notes pages from verified repository +evidence. Keep complete, PR-by-PR release history in GitHub Releases. + +## Gather Evidence + +Run the read-only helper with explicit release refs and the target minor version: + +```bash +python3 .agents/skills/draft-release-notes/scripts/collect_release_evidence.py \ + --previous release/. \ + --current HEAD \ + --version . +``` + +The report verifies both refs, compares their release-notes trees, identifies +version text currently present in those pages, and groups commits into review +candidates. Treat the groups as an evidence index, not publication-ready copy. + +## Workflow + +1. Confirm the target release version from the release branch and package + metadata. Preserve unrelated working-tree changes. +2. Run the helper. It reports an absent prior release-notes directory without + failing, which is expected for early release branches. +3. Verify each candidate claim in the changed public docs, API types, command + help, or source before including it. Prioritize breaking changes, migrations, + user-visible features, and ongoing support limitations. +4. Update only these pages unless the release changes their route or entry + points: + - `docs/about-nemo-relay/release-notes/index.mdx` + - `docs/about-nemo-relay/release-notes/highlights.mdx` + - `docs/about-nemo-relay/release-notes/known-issues.mdx` +5. Keep the existing page roles: + - `index.mdx` gives the current-release summary, compatibility notes, scope, + and curated feature links. + - `highlights.mdx` groups notable changes by user-facing theme. + - `known-issues.mdx` records current limitations, compatibility migrations, + current-release fixes, and the complete fixed-item history recorded in + earlier release-note pages. Preserve every prior fixed-item bullet under + release-labelled subsections; do not summarize, deduplicate, or omit it. + GitHub Releases remains the complete PR-by-PR history. +6. Preserve MDX front matter and the JSX SPDX comment. State the full history + is available in GitHub Releases; do not create a changelog or GitHub Release + body from this skill. + +## Validate + +Run the helper for the target release and for an early branch without release +notes when available. Review public claims, then run: + +```bash +git diff --check +just docs +just docs-linkcheck +``` + +Check product names, commands, package names, support claims, and links against +the current repository before handing off the draft. diff --git a/.agents/skills/draft-release-notes/scripts/collect_release_evidence.py b/.agents/skills/draft-release-notes/scripts/collect_release_evidence.py new file mode 100755 index 000000000..f385fdf1a --- /dev/null +++ b/.agents/skills/draft-release-notes/scripts/collect_release_evidence.py @@ -0,0 +1,187 @@ +#!/usr/bin/env python3 +# SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +"""Collect read-only Git evidence for NeMo Relay documentation release notes.""" + +from __future__ import annotations + +import argparse +import re +import subprocess +from dataclasses import dataclass +from pathlib import Path + +RELEASE_NOTES_DIR = "docs/about-nemo-relay/release-notes" +VERSION_PATTERN = re.compile(r"(?:NVIDIA )?NeMo Relay (\d+\.\d+(?:\.\d+)?)") + + +@dataclass(frozen=True) +class Commit: + """One non-merge commit and its changed paths.""" + + sha: str + subject: str + paths: tuple[str, ...] + + +def run_git(repo: Path, *args: str) -> str: + """Run Git without a shell and return stdout or raise a readable error.""" + result = subprocess.run( + ["git", *args], + cwd=repo, + check=False, + capture_output=True, + encoding="utf-8", + ) + if result.returncode: + detail = result.stderr.strip() or result.stdout.strip() + raise RuntimeError(f"git {' '.join(args)} failed: {detail}") + return result.stdout + + +def resolve_ref(repo: Path, ref: str) -> str: + """Return the commit ID for a user-supplied ref.""" + return run_git(repo, "rev-parse", "--verify", "--quiet", f"{ref}^{{commit}}").strip() + + +def note_files(repo: Path, ref: str) -> tuple[str, ...]: + """List release-note files that exist at a ref.""" + output = run_git(repo, "ls-tree", "-r", "--name-only", ref, "--", RELEASE_NOTES_DIR) + return tuple(path for path in output.splitlines() if path) + + +def note_versions(repo: Path, ref: str, paths: tuple[str, ...]) -> tuple[str, ...]: + """Return the NeMo Relay versions mentioned in release-note files.""" + versions: set[str] = set() + for path in paths: + content = run_git(repo, "show", f"{ref}:{path}") + versions.update(VERSION_PATTERN.findall(content)) + return tuple(sorted(versions)) + + +def commits(repo: Path, previous: str, current: str) -> tuple[Commit, ...]: + """Read non-merge commits and their changed paths, newest first.""" + output = run_git(repo, "log", "--no-merges", "--format=%H%x09%s", f"{previous}..{current}") + collected: list[Commit] = [] + for line in output.splitlines(): + sha, subject = line.split("\t", maxsplit=1) + names = run_git(repo, "diff-tree", "--no-commit-id", "--name-status", "-r", sha) + paths = tuple(entry.rsplit("\t", maxsplit=1)[-1] for entry in names.splitlines() if entry) + collected.append(Commit(sha=sha, subject=subject, paths=paths)) + return tuple(collected) + + +def category(commit: Commit) -> str: + """Classify a commit for review without treating the result as a release claim.""" + subject = commit.subject.lower() + if "!" in commit.subject.split(":", maxsplit=1)[0] or re.search( + r"\b(remove|drop|breaking|deprecat|migration)\b", subject + ): + return "Breaking and migration candidates" + if subject.startswith("feat"): + return "Feature candidates" + if subject.startswith(("fix", "perf")): + return "Fix candidates" + return "Documentation and tooling candidates" + + +def public_paths(commits_to_report: tuple[Commit, ...]) -> tuple[str, ...]: + """Return changed paths likely to support public release-note claims.""" + package_paths = { + "Cargo.toml", + "crates/node/package.json", + "integrations/openclaw/package.json", + "python/plugin/pyproject.toml", + } + return tuple( + sorted( + { + path + for commit in commits_to_report + for path in commit.paths + if path == "README.md" + or path.startswith("docs/") + or path.endswith("/README.md") + or path in package_paths + } + ) + ) + + +def print_note_tree(repo: Path, label: str, ref: str) -> None: + """Print structure and version mentions for one release ref.""" + paths = note_files(repo, ref) + print(f"## {label} Release-Notes Tree") + if not paths: + print(f"No files exist under `{RELEASE_NOTES_DIR}` at `{ref}`.\n") + return + print("Files:") + for path in paths: + print(f"- `{path}`") + versions = note_versions(repo, ref, paths) + description = ", ".join(versions) if versions else "no NeMo Relay version text detected" + print(f"Version text: {description}\n") + + +def main() -> int: + """Parse arguments and print the evidence report.""" + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--previous", required=True, help="Previous release branch or commit") + parser.add_argument("--current", required=True, help="Current release branch or commit") + parser.add_argument("--version", required=True, help="Target major.minor release version") + parser.add_argument("--repo", default=".", help="Repository root (default: current directory)") + args = parser.parse_args() + + repo = Path(args.repo).resolve() + try: + previous_sha = resolve_ref(repo, args.previous) + current_sha = resolve_ref(repo, args.current) + run_git(repo, "merge-base", "--is-ancestor", previous_sha, current_sha) + except RuntimeError as error: + parser.error(str(error)) + + print(f"# Release-Note Evidence: {args.version}") + print() + print(f"- Previous: `{args.previous}` ({previous_sha[:12]})") + print(f"- Current: `{args.current}` ({current_sha[:12]})") + print(f"- Merge base: `{run_git(repo, 'merge-base', previous_sha, current_sha).strip()[:12]}`") + print() + print_note_tree(repo, "Previous", args.previous) + print_note_tree(repo, "Current", args.current) + + changes = commits(repo, previous_sha, current_sha) + grouped: dict[str, list[Commit]] = { + "Breaking and migration candidates": [], + "Feature candidates": [], + "Fix candidates": [], + "Documentation and tooling candidates": [], + } + for commit in changes: + grouped[category(commit)].append(commit) + + print("## Commit Candidates") + for heading, entries in grouped.items(): + print(f"### {heading}") + if not entries: + print("- None") + for commit in entries: + paths = ", ".join(f"`{path}`" for path in commit.paths[:4]) + suffix = f" — {paths}" if paths else "" + print(f"- `{commit.sha[:12]}` {commit.subject}{suffix}") + print() + + print("## Changed Public Documentation and Package Surfaces") + paths = public_paths(changes) + if paths: + for path in paths: + print(f"- `{path}`") + else: + print("- None") + print() + print("Review every candidate against current public docs and APIs before drafting prose.") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/docs/about-nemo-relay/release-notes/highlights.mdx b/docs/about-nemo-relay/release-notes/highlights.mdx index c32b5ad24..1d7df947a 100644 --- a/docs/about-nemo-relay/release-notes/highlights.mdx +++ b/docs/about-nemo-relay/release-notes/highlights.mdx @@ -9,75 +9,66 @@ SPDX-License-Identifier: Apache-2.0 */} This page summarizes the notable capabilities in the current release documentation set. -## NVIDIA NeMo Relay 0.4 - -NVIDIA NeMo Relay 0.4 adds host plugin installation, first-party PII redaction, local -Guardrails execution, pricing-aware observability, streaming raw-event export, -and stronger coding-agent trace fidelity. - -### Compatibility Notes - -- The Python-only NeMo Guardrails example plugin was removed. Applications - should use the built-in `nemo_guardrails` component instead. -- Pricing estimates require an inline, file-backed, or embedding-provided - pricing source. NeMo Relay does not ship provider price data by default. -- Local NeMo Guardrails mode requires Python 3.11 or newer and - `nemoguardrails==0.22.0` in the runtime environment. - -### CLI And Plugin Configuration - -- Added `nemo-relay install`, `uninstall`, and `doctor --plugin` flows for - Claude Code and Codex host plugins. -- Added generated local marketplace support so Claude Code and Codex can load - NeMo Relay through native host plugin mechanisms. -- Layered code-driven plugin configuration over materialized global, project, - and user plugin files while preserving documented file precedence. -- Added pricing source management commands for validating catalogs, adding - file-backed sources, and resolving model pricing. - -### Guardrails And Redaction - -- Added a local Python-backed backend for the built-in `nemo_guardrails` - component. -- Expanded Guardrails configuration docs for local and remote backend behavior, - supported codecs, request defaults, tool boundaries, and streaming behavior. -- Added the first-party PII redaction plugin crate with deterministic local - backend support and Python and Node.js helper surfaces. - -### Observability - -- Added ATOF streaming endpoints for HTTP POST, WebSocket, and long-lived - NDJSON uploads. -- Added ATIF HTTP storage export alongside S3-compatible storage destinations. -- Added model-pricing lookup and cost layering for managed LLM responses. -- Propagated normalized LLM cost into ATIF step metrics, OpenInference - attributes, and OpenTelemetry attributes. -- Set OpenTelemetry span status from NeMo Relay execution results. -- Preserved sanitized LLM request payloads in annotations and start-event - output. - -### Integrations - -- Improved Hermes hook injection, routed-provider observability, wrapped ATIF - fidelity, subagent lineage, and error-path export consistency. -- Added Codex observability contract coverage and suppressed noisy Claude Code - lifecycle events. -- Added nested subagent session lineage and more consistent cost, provenance, - replay, placeholder, and hook-only fallback exports for OpenClaw. -- Improved LangChain input serialization and fixed plugin context-manager - deadlock behavior. -- Added flattened OpenInference LLM attributes for annotations and replay. -- Annotated Deep Agents model responses and refreshed LangGraph callback - coverage. - -### Documentation And Tooling - -- Updated installation documentation for 0.4 packages and host plugin setup. -- Clarified Hermes integration paths and coding-agent plugin source manifests. -- Added NVSkills CI request workflow and regenerated NeMo Relay skill eval - datasets. -- Updated dependency attribution files and isolated Rust test behavior for CI - and SonarQube cleanup. +## NVIDIA NeMo Relay 0.5 + +NVIDIA NeMo Relay 0.5 adds dynamic plugin SDKs and controls, verified CLI +installation and diagnostics, clearer runtime contracts, and improved lineage +for managed LLM requests. + +### Compatibility and Migration + +- Move plugin configuration from `config.toml` into `plugins.toml`. The + `--plugin-config` CLI option and hook-forwarding input have been removed. +- Update every registered LLM request and tool execution intercept to return + its canonical outcome. The outcomes can include ordered pending marks while + Relay retains lifecycle ownership. +- Rebuild development native plugins and `grpc-v1` workers against 0.5 because + the native ABI and worker outcome contracts are now finalized. +- Migrate away from the removed experimental `nemo-relay-wasm` package, Cursor + CLI support, and patch-based integrations. + +### Dynamic Plugins and Configuration + +- Added dynamic plugin discovery from `plugins.toml`, host policy and + attestation gates, and lifecycle commands for inspecting, validating, + enabling, and disabling plugins. +- Added the Rust SDK for trusted in-process `rust_dynamic` plugins and the + `grpc-v1` worker protocol with Rust and Python worker SDKs. +- Added schema-aware dynamic-plugin configuration, validation, secret-aware + editing, and merged TOML preview in the CLI. +- Added Python worker-environment management and worker invocation + cancellation. + +### CLI Installation and Diagnostics + +- Added verified Unix and Windows installers that select the release asset, + verify its SHA-256 checksum, and support version pinning. +- Expanded `nemo-relay doctor` with agent-host readiness checks, persistent + host-plugin diagnostics, and discovered `plugins.toml` source and validation + reporting. +- Added gateway status reporting for bind, exporter, and remote ATIF storage + destinations. + +### Runtime and Observability + +- Added canonical LLM request and tool execution outcomes across Rust, Python, + Node.js, Go, C FFI, native plugins, and worker plugins. +- Added ordered pending marks to managed LLM and tool lifecycles without adding + control data to application-visible requests or tool results. +- Added automatic Dynamo session and parent-session headers to managed LLM + requests, plus bounded CLI turn scopes for trace correlation. +- Documented stable normalized token and cost semantics, including provider + mapping and exporter projection behavior. +- Hardened ATOF HTTP output and ensured gateway shutdown flushes queued events. + +### Documentation and Tooling + +- Added public contract references for LLM request and tool execution intercept + outcomes. +- Expanded dynamic plugin, configuration, runtime-contract, installation, and + integration examples. +- Updated package, build, test, and release guidance for the supported Rust, + Python, Node.js, Go, and raw C FFI surfaces. The complete changelog and release artifacts can be viewed on [GitHub Releases](https://github.com/NVIDIA/NeMo-Relay/releases). diff --git a/docs/about-nemo-relay/release-notes/index.mdx b/docs/about-nemo-relay/release-notes/index.mdx index 79ab9d7e7..75c03449e 100644 --- a/docs/about-nemo-relay/release-notes/index.mdx +++ b/docs/about-nemo-relay/release-notes/index.mdx @@ -12,23 +12,21 @@ tag-specific notes. ## Current Release -NeMo Relay 0.4 focuses on host plugin installation, first-party PII redaction, -local NeMo Guardrails execution, pricing-aware LLM response annotations, -streaming raw ATOF export, remote ATIF storage, and stronger coding-agent trace -fidelity. +NVIDIA NeMo Relay 0.5 adds dynamic plugin SDKs and lifecycle controls, verified +CLI installers and readiness diagnostics, stable token and cost field semantics, +and stronger request and trace lineage behavior. The most important compatibility notes are: -- The Python-only NeMo Guardrails example plugin has been removed. Use the - built-in `nemo_guardrails` component for supported Guardrails integration. -- Pricing estimates require configured pricing sources. NeMo Relay does not - ship provider price data by default. -- Local NeMo Guardrails mode depends on Python 3.11 or newer and an available - `nemoguardrails` runtime. -- Node.js 24 or newer remains the minimum supported Node.js version. -- Native subscriber delivery remains asynchronous. Code that depends on - subscriber callback side effects, exporter output, or deterministic test - assertions must call the subscriber flush API. +- Plugin configuration now lives in `plugins.toml`. Move plugin settings out of + `config.toml`; the `--plugin-config` CLI option has been removed. +- Registered LLM request and tool execution intercepts now return canonical + outcomes. Rebuild development native plugins and `grpc-v1` workers against + 0.5. +- The experimental `nemo-relay-wasm` package, Cursor CLI support, and + patch-based integrations have been removed. +- Go and the raw C FFI remain experimental and source-first. Node.js 24 or + newer remains the minimum supported Node.js version. Use the child pages for release highlights and support notes. For the complete PR-by-PR changelog, release artifacts, and tag-specific history, use @@ -38,32 +36,29 @@ PR-by-PR changelog, release artifacts, and tag-specific history, use This release includes: -- Built-in NeMo Guardrails plugin support, including remote and local - Python-backed backends. -- CLI installation, uninstallation, and doctor flows for Claude Code and Codex - host plugins. -- Code-driven plugin configuration layered over materialized global, project, - and user plugin files. -- First-party PII redaction plugin helpers across Rust, Python, and Node.js. -- Model-pricing catalogs and LLM cost annotations that propagate into ATIF, - OpenInference, and OpenTelemetry output. -- ATOF streaming endpoints for HTTP POST, WebSocket, and NDJSON collectors. -- ATIF remote storage support for HTTP endpoints in addition to S3-compatible - storage. -- Trace fidelity fixes for Hermes, OpenClaw, LangChain, LangGraph, and Deep - Agents integrations. +- Dynamic plugin discovery, trust policy and attestation gates, and lifecycle + controls through the `nemo-relay` CLI. +- A Rust native plugin SDK for trusted in-process `rust_dynamic` plugins, plus + `grpc-v1` worker support through Rust and Python SDKs. +- Schema-aware dynamic-plugin configuration and editing through `plugins.toml`. +- Verified Unix and Windows CLI installers, and expanded `nemo-relay doctor` + readiness diagnostics for agent hosts and plugin configuration. +- Canonical LLM request and tool execution intercept outcomes with ordered + pending marks across the runtime and supported bindings. +- Automatic Dynamo session-lineage headers on managed LLM requests and + turn-scoped CLI trace correlation. +- Stable normalized token and cost semantics for provider response codecs and + ATOF, ATIF, OpenInference, and OpenTelemetry projections. ## Feature Documentation -For the major 0.4 additions, start with: +For the major 0.5 additions, start with: -- [Plugin Installation](/nemo-relay-cli/plugin-installation) -- [Observability Plugin](/observability-plugin/about) -- [Agent Trajectory Observability Format (ATOF)](/observability-plugin/atof) -- [Agent Trajectory Interchange Format (ATIF)](/observability-plugin/atif) -- [Provider Response Codecs And Pricing](/integrate-into-frameworks/provider-response-codecs) -- [NeMo Guardrails Plugin](/nemo-guardrails-plugin/about) -- [PII Redaction API Reference](/reference/api/python-library-reference/pii-redaction) -- [OpenClaw Plugin Guide](/supported-integrations/openclaw-plugin) -- [Hermes CLI Guide](/nemo-relay-cli/hermes) -- [LangChain Integration Guide](/supported-integrations/langchain) +- [Build Plugins](/build-plugins/about) +- [Plugin Configuration Files](/build-plugins/plugin-configuration-files) +- [Installation](/getting-started/installation) +- [Plugin Installation and Diagnostics](/nemo-relay-cli/plugin-installation) +- [LLM Request Intercept Outcomes](/reference/llm-request-intercept-outcomes) +- [Tool Execution Intercept Outcomes](/reference/tool-execution-intercept-outcomes) +- [Instrument an LLM Call](/instrument-applications/instrument-llm-call) +- [Provider Response Codecs and Model Pricing](/integrate-into-frameworks/provider-response-codecs) diff --git a/docs/about-nemo-relay/release-notes/known-issues.mdx b/docs/about-nemo-relay/release-notes/known-issues.mdx index 556ea425b..7d1b64a4d 100644 --- a/docs/about-nemo-relay/release-notes/known-issues.mdx +++ b/docs/about-nemo-relay/release-notes/known-issues.mdx @@ -9,20 +9,16 @@ SPDX-License-Identifier: Apache-2.0 */} This page lists current limitations and support notes for the release documentation set. -## NeMo Relay 0.4 +## NVIDIA NeMo Relay 0.5 -These notes apply to the NeMo Relay 0.4 release. The following known issues -and limitations apply to NeMo Relay 0.4: +These notes apply to the NVIDIA NeMo Relay 0.5 release. -- Go and the raw C FFI surface are experimental and source-first. -- Generated API pages cover Rust, Python, and Node.js. Experimental bindings do - not yet have the same generated documentation depth. -- The NeMo Relay CLI is experimental. Coding agent observability support varies - due to capabilities of hooks. Any encountered problems should be filed as - bugs. -- Host plugin mode depends on each coding-agent host's plugin, hook, and - provider-routing behavior. Hooks alone cannot produce complete LLM request - and response spans. +- Go and the raw C FFI surface are experimental and source-first. Generated + API pages cover Rust, Python, and Node.js; experimental bindings do not have + the same generated documentation depth. +- The NeMo Relay CLI is experimental. Coding-agent observability support varies + with host plugin, hook, and provider-routing capabilities. Hooks alone cannot + produce complete LLM request and response spans. - Complete first-request capture in Codex plugin mode depends on Codex firing an installed hook before the first provider request. - Node.js 24 or newer is required for Node.js binding and package workflows. @@ -30,33 +26,53 @@ and limitations apply to NeMo Relay 0.4: optimization support. Security is limited to pre-tool conditional guardrails, and optimization is limited to adaptive telemetry unless the integration owns a managed execution path. -- The NeMo Guardrails plugin remote backend depends on the availability, - latency, and policy behavior of the configured remote service. -- The NeMo Guardrails plugin local backend starts a Python worker subprocess. - That worker environment must provide Python 3.11 or newer and - `nemoguardrails==0.22.0`; `SUPPORTED_NEMOGUARDRAILS_VERSION` in - `crates/core/src/plugins/nemo_guardrails/local_worker.py` is the - authoritative pin. +- The NeMo Guardrails remote backend depends on the availability, latency, and + policy behavior of the configured remote service. Its local backend requires + Python 3.11 or newer and `nemoguardrails==0.22.0`. - The PII redaction plugin currently provides deterministic local backend support. Local-model backend configuration is reserved for future expansion. -- Pricing estimates depend on configured pricing sources and the freshness of - the source catalog. Unknown model pricing and missing token data leave cost - absent instead of defaulting to zero. -- ATOF streaming endpoints depend on collector availability. Failed endpoints - are skipped or retried without blocking file output or other configured - endpoints. -- S3-compatible ATIF export requires valid storage credentials and endpoint - configuration in the runtime environment. -- Remote ATIF storage requires valid destination credentials and endpoint - configuration in the runtime environment. +- Pricing estimates depend on configured model-pricing sources and their + freshness. Unknown model pricing and missing token data leave cost absent + instead of defaulting to zero. +- ATOF streaming endpoints and remote ATIF storage depend on reachable, + correctly configured destinations. Endpoint failures do not block local file + output or other configured endpoints. +- Native dynamic plugins run in-process and are not sandboxed. `grpc-v1` worker + plugins isolate a process but do not provide a security sandbox. - `LLMRequest` objects in the Python binding should be treated as immutable. Request middleware that changes content should return a new request object. - Native subscriber callbacks are delivered asynchronously. Flush subscribers before relying on callback side effects, captured event lists, files, or exporter output. Deregistering a subscriber affects future emissions, but - callbacks from already-queued event snapshots may still run. + callbacks from already-queued event snapshots can still run. -### Fixed in NeMo Relay 0.4 +### Compatibility and Migration Notes + +- Move plugin configuration from `config.toml` to `plugins.toml`. The + `--plugin-config` option is unavailable in 0.5. +- Registered LLM request and tool execution intercepts must return their + canonical outcome types. Rebuild development native plugins and `grpc-v1` + workers against 0.5. +- The experimental `nemo-relay-wasm` package is no longer built, published, or + supported by this repository. +- The `nemo-relay cursor` and `hook-forward cursor` entry points are no longer + available. Patch-based integrations are also no longer maintained. + +### Fixed in NVIDIA NeMo Relay 0.5 + +- Gateway shutdown flushes queued events before it exits. +- Dynamic worker invocations support cancellation, and the CLI manages Python + dynamic-plugin environments. +- ATOF file export creates a missing output directory before opening JSONL + output. +- CLI status output reports daemon binding, exporter status, and remote ATIF + storage destinations more reliably. +- Codex host-plugin discovery uses the supported text output from the Codex + plugin command. + +### Fixed in Prior Releases + +#### NVIDIA NeMo Relay 0.4 - ATIF shutdown no longer deadlocks queued subscribers. - Sanitized LLM requests are resolved from annotations for observability output. @@ -72,11 +88,15 @@ and limitations apply to NeMo Relay 0.4: - Node.js `withScope` callbacks receive a real `ScopeHandle`. - Deep Agents model responses are annotated for downstream observability. -### Fixed in Earlier Releases +#### NVIDIA NeMo Relay 0.3 - Managed LLM start events are emitted before execution intercepts. - Coding-agent trace scopes are aligned with NeMo Relay agent scope semantics. - ATIF tool observations are correlated with their matching tool calls. - OpenClaw tool call replay visibility is preserved. +- LangChain serialization handles wrapped integration payloads more reliably. + +#### Earlier Releases + - Enabled TLS support for OTLP HTTP export. - Preserved Go scope stacks across OS threads. From 4edbd1ed9efdc0d8d577c34e55b00dd53e187eed Mon Sep 17 00:00:00 2001 From: Will Killian <2007799+willkill07@users.noreply.github.com> Date: Mon, 6 Jul 2026 14:22:31 -0400 Subject: [PATCH 2/2] Update docs/about-nemo-relay/release-notes/highlights.mdx Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com> Signed-off-by: Will Killian <2007799+willkill07@users.noreply.github.com> --- docs/about-nemo-relay/release-notes/highlights.mdx | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/docs/about-nemo-relay/release-notes/highlights.mdx b/docs/about-nemo-relay/release-notes/highlights.mdx index 1d7df947a..2da2b67f7 100644 --- a/docs/about-nemo-relay/release-notes/highlights.mdx +++ b/docs/about-nemo-relay/release-notes/highlights.mdx @@ -67,8 +67,7 @@ for managed LLM requests. outcomes. - Expanded dynamic plugin, configuration, runtime-contract, installation, and integration examples. -- Updated package, build, test, and release guidance for the supported Rust, - Python, Node.js, Go, and raw C FFI surfaces. +- Updated package, build, test, and release guidance for the primary Rust, Python, and Node.js surfaces, plus experimental Go and raw C FFI notes. The complete changelog and release artifacts can be viewed on [GitHub Releases](https://github.com/NVIDIA/NeMo-Relay/releases).