nemo-relay-openclaw 0.3.0-beta.2 → 0.3.0

package/README.md

@@ -12,10 +12,11 @@ observability component can export as ATIF JSON, OpenTelemetry spans, and
 OpenInference/Phoenix spans. The same generic plugin config path can initialize
 Adaptive components for hook-backed telemetry learning.
 
-This public OpenClaw plugin package uses OpenClaw public hooks. It does not
-rewrite OpenClaw tool execution, provider routing, policy decisions, or model
-requests. For middleware-backed behavior that changes execution, use the
-patch-based OpenClaw integration from the NeMo Relay repository.
+This public OpenClaw plugin package uses OpenClaw public hooks. It can run
+pre-tool conditional guardrails when OpenClaw invokes the before-tool hook, but
+it does not rewrite provider routing or model requests. For middleware-backed
+behavior that changes execution, use the patch-based OpenClaw integration from
+the NeMo Relay repository.
 
 ## Why Use It?
 
@@ -175,7 +176,7 @@ do not use, or set their `enabled` fields to `false`.
 Fields inside `config.plugins` are NeMo Relay generic plugin configuration, so
 they use `snake_case` regardless of language. For the full exporter field list,
 see the NeMo Relay Observability Plugin schema in the top-level NeMo Relay
-documentation at [nvidia.github.io/NeMo-Relay](https://nvidia.github.io/NeMo-Relay/).
+documentation at [docs.nvidia.com/nemo/relay](https://docs.nvidia.com/nemo/relay).
 
 ## Verify the Integration
 
@@ -204,11 +205,10 @@ openclaw gateway call nemoRelay.status --json
 
 ## Current Limits
 
-The plugin maps supported OpenClaw hook events into NeMo Relay telemetry without
-changing OpenClaw execution behavior.
+The plugin maps supported OpenClaw hook events into NeMo Relay telemetry and can
+run pre-tool conditional guardrail checks.
 
-It does not change OpenClaw tool execution, provider routing, policy decisions,
-or provider request payloads.
+It does not rewrite provider routing or provider request payloads.
 
 Current OpenClaw public hooks expose request, response, message-write, and
 provider timing details through separate event streams. The plugin correlates

package/dist/src/hook-replay/llm.js

@@ -324,12 +324,14 @@ export function buildReplayLlmRequest(input, output, config, source = 'openclaw.
 /** Build the response payload passed to NeMo Relay for a replayed LLM span. */
 export function buildReplayLlmResponse(event, timing, config) {
     const usage = mapUsage(event.usage);
-    const assistantToolCallNames = toolCallNames(event.assistantToolCalls);
+    const assistantToolCalls = assistantToolCallsForOutput(event, config);
+    const assistantToolCallNames = toolCallNames(assistantToolCalls);
     return toJsonValue({
         role: 'assistant',
         content: config.capture.includeResponses
             ? responseContent(event.assistantTexts, assistantToolCallNames)
             : undefined,
+        tool_calls: assistantToolCalls.length > 0 ? assistantToolCalls : undefined,
         assistant_texts_count: event.assistantTexts.length,
         resolved_ref: event.resolvedRef,
         harness_id: event.harnessId,
@@ -347,6 +349,13 @@ export function buildReplayLlmResponse(event, timing, config) {
         },
     });
 }
+/** Return assistant tool calls from the current OpenClaw llm_output contract. */
+function assistantToolCallsForOutput(event, config) {
+    const explicit = Array.isArray(event.assistantToolCalls) ? event.assistantToolCalls : [];
+    const inferred = explicit.length > 0 || !isRecord(event.lastAssistant) ? explicit : extractToolCalls(event.lastAssistant);
+    const snapshot = snapshotMessages(inferred);
+    return config.capture.stripToolArgs ? snapshot.map(stripToolCallArgs) : snapshot;
+}
 /** Replay an output whose matching input never arrived before the grace timeout. */
 function replayExpiredPendingOutput(manager, key, record) {
     try {
@@ -658,6 +667,9 @@ function stripToolCallArgs(value) {
             stripped[key] = { stripped: true };
         }
     }
+    if (isRecord(stripped.function) && stripped.function.arguments !== undefined) {
+        stripped.function = { ...stripped.function, arguments: { stripped: true } };
+    }
     return stripped;
 }
 /** Strip provider thinking/signature payloads that are noisy in trace UIs. */
@@ -761,6 +773,8 @@ function extractToolCalls(message) {
 function isToolCallLike(value) {
     return (isRecord(value) &&
         (value.type === 'toolCall' ||
+            value.type === 'toolcall' ||
+            value.type === 'function_call' ||
             value.type === 'tool_use' ||
             value.type === 'tool-call' ||
             value.toolName !== undefined ||
@@ -776,13 +790,21 @@ function toolCallNames(toolCalls) {
         if (!isRecord(toolCall)) {
             continue;
         }
-        const name = stringField(toolCall, 'name') ?? stringField(toolCall, 'toolName') ?? stringField(toolCall, 'functionName');
+        const name = stringField(toolCall, 'name') ??
+            stringField(toolCall, 'toolName') ??
+            stringField(toolCall, 'functionName') ??
+            functionToolCallName(toolCall);
         if (name) {
             names.push(name);
         }
     }
     return names;
 }
+/** Read OpenAI-style nested function tool-call names. */
+function functionToolCallName(toolCall) {
+    const fn = toolCall.function;
+    return isRecord(fn) ? stringField(fn, 'name') : undefined;
+}
 /** Convert stored message-write usage back into the llm_output usage contract. */
 function mapHookUsage(usage) {
     const mapped = mapUsage(usage);

package/dist/src/hooks-backend.d.ts

@@ -84,6 +84,8 @@ export declare class HookReplayBackend {
     private emitSessionMark;
     /** Close every active session with the same lifecycle summary. */
     private closeAllSessions;
+    /** Wait for native subscriber/exporter delivery after a replay closure boundary. */
+    private flushSubscriberDelivery;
     /** Build the narrow manager interface consumed by focused replay modules. */
     private sessionManager;
     /** Log one warning per key to avoid noisy repeated hook failures. */

package/dist/src/hooks-backend.js

@@ -253,6 +253,7 @@ export class HookReplayBackend {
     async closeSession(session, summary) {
         drainSession(this.sessionManager(), session);
         closeSessionRoot(this.sessionManager(), session, summary, session.finalOutput ?? summary);
+        this.flushSubscriberDelivery('session_close');
         deleteSession(this.stateValue, session);
     }
     /** Emit a session-level OpenClaw lifecycle mark. */
@@ -273,6 +274,15 @@ export class HookReplayBackend {
             await this.closeSession(session, summary);
         }
     }
+    /** Wait for native subscriber/exporter delivery after a replay closure boundary. */
+    flushSubscriberDelivery(label) {
+        try {
+            this.nf.flushSubscribers?.();
+        }
+        catch (error) {
+            this.logBoundedWarn(`flush-subscribers:${label}`, `nemo-relay subscriber flush failed: label=${label} error=${toMessage(error)}`);
+        }
+    }
     /** Build the narrow manager interface consumed by focused replay modules. */
     sessionManager() {
         return {

package/dist/src/modules.d.ts

@@ -20,6 +20,7 @@ export type NemoRelayRuntimeModule = Omit<Pick<typeof NemoRelayRuntime, NemoRela
     ScopeType: {
         Agent?: Parameters<typeof NemoRelayRuntime.pushScope>[1];
     } | undefined;
+    flushSubscribers?: typeof NemoRelayRuntime.flushSubscribers;
 };
 /**
  * @internal Package-owned subset of the dynamically imported

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nemo-relay-openclaw",
-  "version": "0.3.0-beta.2",
+  "version": "0.3.0",
   "description": "NeMo Relay-authored observability plugin for OpenClaw.",
   "type": "module",
   "repository": {
@@ -42,12 +42,12 @@
       "./dist/index.js"
     ],
     "compat": {
-      "pluginApi": ">=2026.5.12",
-      "minGatewayVersion": "2026.5.12"
+      "pluginApi": ">=2026.5.26",
+      "minGatewayVersion": "2026.5.26"
     },
     "build": {
-      "openclawVersion": "2026.5.12",
-      "pluginSdkVersion": "2026.5.12"
+      "openclawVersion": "2026.5.26",
+      "pluginSdkVersion": "2026.5.26"
     }
   },
   "scripts": {
@@ -60,10 +60,10 @@
     "test:live": "npm run build:test && node scripts/test-live.mjs"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.5.12"
+    "openclaw": "^2026.5.26"
   },
   "dependencies": {
-    "nemo-relay-node": "0.3.0-beta.2"
+    "nemo-relay-node": "0.3.0"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",

package/src/hook-replay/llm.ts

@@ -451,12 +451,14 @@ export function buildReplayLlmResponse(
   config: NemoRelayHookBackendConfig,
 ): JsonValue {
   const usage = mapUsage(event.usage);
-  const assistantToolCallNames = toolCallNames(event.assistantToolCalls);
+  const assistantToolCalls = assistantToolCallsForOutput(event, config);
+  const assistantToolCallNames = toolCallNames(assistantToolCalls);
   return toJsonValue({
     role: 'assistant',
     content: config.capture.includeResponses
       ? responseContent(event.assistantTexts, assistantToolCallNames)
       : undefined,
+    tool_calls: assistantToolCalls.length > 0 ? assistantToolCalls : undefined,
     assistant_texts_count: event.assistantTexts.length,
     resolved_ref: event.resolvedRef,
     harness_id: event.harnessId,
@@ -475,6 +477,17 @@ export function buildReplayLlmResponse(
   });
 }
 
+/** Return assistant tool calls from the current OpenClaw llm_output contract. */
+function assistantToolCallsForOutput(
+  event: PluginHookLlmOutputEvent,
+  config: NemoRelayHookBackendConfig,
+): unknown[] {
+  const explicit = Array.isArray(event.assistantToolCalls) ? event.assistantToolCalls : [];
+  const inferred = explicit.length > 0 || !isRecord(event.lastAssistant) ? explicit : extractToolCalls(event.lastAssistant);
+  const snapshot = snapshotMessages(inferred);
+  return config.capture.stripToolArgs ? snapshot.map(stripToolCallArgs) : snapshot;
+}
+
 /** Replay an output whose matching input never arrived before the grace timeout. */
 function replayExpiredPendingOutput(manager: SessionManager, key: string, record: PendingLlmOutputRecord): void {
   try {
@@ -855,6 +868,9 @@ function stripToolCallArgs(value: unknown): unknown {
       stripped[key] = { stripped: true };
     }
   }
+  if (isRecord(stripped.function) && stripped.function.arguments !== undefined) {
+    stripped.function = { ...stripped.function, arguments: { stripped: true } };
+  }
   return stripped;
 }
 
@@ -969,6 +985,8 @@ function isToolCallLike(value: unknown): boolean {
   return (
     isRecord(value) &&
     (value.type === 'toolCall' ||
+      value.type === 'toolcall' ||
+      value.type === 'function_call' ||
       value.type === 'tool_use' ||
       value.type === 'tool-call' ||
       value.toolName !== undefined ||
@@ -987,7 +1005,10 @@ function toolCallNames(toolCalls: unknown[] | undefined): string[] {
       continue;
     }
     const name =
-      stringField(toolCall, 'name') ?? stringField(toolCall, 'toolName') ?? stringField(toolCall, 'functionName');
+      stringField(toolCall, 'name') ??
+      stringField(toolCall, 'toolName') ??
+      stringField(toolCall, 'functionName') ??
+      functionToolCallName(toolCall);
     if (name) {
       names.push(name);
     }
@@ -995,6 +1016,12 @@ function toolCallNames(toolCalls: unknown[] | undefined): string[] {
   return names;
 }
 
+/** Read OpenAI-style nested function tool-call names. */
+function functionToolCallName(toolCall: Record<string, unknown>): string | undefined {
+  const fn = toolCall.function;
+  return isRecord(fn) ? stringField(fn, 'name') : undefined;
+}
+
 /** Convert stored message-write usage back into the llm_output usage contract. */
 function mapHookUsage(usage: unknown): PluginHookLlmOutputEvent['usage'] | undefined {
   const mapped = mapUsage(usage);

package/src/hooks-backend.ts

@@ -376,6 +376,7 @@ export class HookReplayBackend {
   private async closeSession(session: SessionState, summary: JsonRecord): Promise<void> {
     drainSession(this.sessionManager(), session);
     closeSessionRoot(this.sessionManager(), session, summary, session.finalOutput ?? summary);
+    this.flushSubscriberDelivery('session_close');
     deleteSession(this.stateValue, session);
   }
 
@@ -399,6 +400,18 @@ export class HookReplayBackend {
     }
   }
 
+  /** Wait for native subscriber/exporter delivery after a replay closure boundary. */
+  private flushSubscriberDelivery(label: string): void {
+    try {
+      this.nf.flushSubscribers?.();
+    } catch (error) {
+      this.logBoundedWarn(
+        `flush-subscribers:${label}`,
+        `nemo-relay subscriber flush failed: label=${label} error=${toMessage(error)}`,
+      );
+    }
+  }
+
   /** Build the narrow manager interface consumed by focused replay modules. */
   private sessionManager() {
     return {

package/src/modules.ts

@@ -41,6 +41,7 @@ export type NemoRelayRuntimeModule = Omit<Pick<typeof NemoRelayRuntime, NemoRela
         Agent?: Parameters<typeof NemoRelayRuntime.pushScope>[1];
       }
     | undefined;
+  flushSubscribers?: typeof NemoRelayRuntime.flushSubscribers;
 };
 
 /**