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

package/dist/src/hook-replay/marks.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Shared event/mark emission and JSON normalization helpers.
+ *
+ * Hook payloads can contain undefined values, circular objects, errors, and
+ * prototype-sensitive keys. This module normalizes them before they cross the
+ * NeMo Relay NAPI boundary.
+ */
+import type { PluginHookAfterToolCallEvent } from '../openclaw-hook-types.js';
+import type { JsonObject as JsonRecord, JsonValue } from 'nemo-relay-node/typed';
+import type { HookReplayBackendState, SessionState } from './session.js';
+import type { NemoRelayRuntimeModule } from '../modules.js';
+/** Emit a NeMo Relay event under an existing OpenClaw session root span. */
+export declare function emitMark(params: {
+    nf: NemoRelayRuntimeModule;
+    state: HookReplayBackendState;
+    session: SessionState;
+    name: string;
+    data: JsonRecord;
+    timestamp?: number;
+}): void;
+/** Return a blocked-tool event payload when OpenClaw denied the tool call. */
+export declare function blockedToolDetails(event: PluginHookAfterToolCallEvent, context?: {
+    runId?: string | undefined;
+}): JsonRecord | undefined;
+/** Convert an object to a JSON record, dropping undefined fields recursively. */
+export declare function toJsonRecord(input: Record<string, unknown>): JsonRecord;
+/** Convert arbitrary hook payload data into NAPI-safe JSON. */
+export declare function toJsonValue(input: unknown): JsonValue;
+/** Preserve useful error fields in telemetry without requiring Error instances. */
+export declare function errorToJson(error: unknown): JsonRecord;

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

@@ -0,0 +1,109 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+/** Emit a NeMo Relay event under an existing OpenClaw session root span. */
+export function emitMark(params) {
+    if (!params.session.rootHandle) {
+        params.state.counters.skippedEvents += 1;
+        return;
+    }
+    params.nf.event(params.name, params.session.rootHandle, params.data, null, params.timestamp ?? null);
+    params.state.counters.marksEmitted += 1;
+}
+/** Return a blocked-tool event payload when OpenClaw denied the tool call. */
+export function blockedToolDetails(event, context) {
+    const details = resultDetails(event.result);
+    if (details?.status !== 'blocked') {
+        return undefined;
+    }
+    return toJsonRecord({
+        toolName: event.toolName,
+        toolCallId: event.toolCallId,
+        runId: event.runId ?? context?.runId,
+        blocked: true,
+        deniedReason: typeof details.deniedReason === 'string' ? details.deniedReason : undefined,
+        durationMs: event.durationMs,
+    });
+}
+/** Convert an object to a JSON record, dropping undefined fields recursively. */
+export function toJsonRecord(input) {
+    return stripUndefined(input, new WeakSet());
+}
+/** Convert arbitrary hook payload data into NAPI-safe JSON. */
+export function toJsonValue(input) {
+    return normalizeJsonValue(input, new WeakSet());
+}
+/** Preserve useful error fields in telemetry without requiring Error instances. */
+export function errorToJson(error) {
+    if (error instanceof Error) {
+        return toJsonRecord({
+            name: error.name,
+            message: error.message,
+            stack: error.stack,
+        });
+    }
+    if (isRecord(error)) {
+        return toJsonRecord(error);
+    }
+    return { message: String(error) };
+}
+/** Extract OpenClaw tool result details when the result uses that envelope. */
+function resultDetails(result) {
+    if (!isRecord(result)) {
+        return undefined;
+    }
+    const details = result.details;
+    return isRecord(details) ? details : undefined;
+}
+/** Strip undefined properties and protect prototype-like keys during JSON conversion. */
+function stripUndefined(input, seen) {
+    const output = {};
+    for (const [key, value] of Object.entries(input)) {
+        if (value !== undefined) {
+            const normalized = normalizeJsonValue(value, seen);
+            if (key === '__proto__') {
+                Object.defineProperty(output, key, {
+                    configurable: true,
+                    enumerable: true,
+                    value: normalized,
+                    writable: true,
+                });
+            }
+            else {
+                output[key] = normalized;
+            }
+        }
+    }
+    return output;
+}
+/** Normalize any hook value into JSON, replacing cycles and unsupported primitives. */
+function normalizeJsonValue(value, seen) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : null;
+    }
+    if (Array.isArray(value)) {
+        if (seen.has(value)) {
+            return '[Circular]';
+        }
+        seen.add(value);
+        const out = value.map((item) => normalizeJsonValue(item, seen));
+        seen.delete(value);
+        return out;
+    }
+    if (isRecord(value)) {
+        if (seen.has(value)) {
+            return '[Circular]';
+        }
+        seen.add(value);
+        const out = stripUndefined(value, seen);
+        seen.delete(value);
+        return out;
+    }
+    return String(value);
+}
+/** Narrow unknown values to plain records for payload traversal. */
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/src/hook-replay/session.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Session identity and root-span management for hook replay.
+ *
+ * OpenClaw can reference the same conversation by session id, session key, run id,
+ * requester key, or child key depending on the hook. This module canonicalizes
+ * those identifiers and owns the root `openclaw.session` scope lifecycle.
+ */
+import type { NemoRelayHookBackendConfig } from '../config.js';
+import type { PluginHookAgentContext, PluginHookLlmOutputEvent, PluginHookModelCallEndedEvent } from '../openclaw-hook-types.js';
+import type { PluginLogger } from 'openclaw/plugin-sdk/plugin-entry';
+import type { JsonObject as JsonRecord } from 'nemo-relay-node/typed';
+import type { NemoRelayRuntimeModule } from '../modules.js';
+export type SessionLookupInput = {
+    sessionId?: string | undefined;
+    sessionKey?: string | undefined;
+    runId?: string | undefined;
+    childSessionKey?: string | undefined;
+    requesterSessionKey?: string | undefined;
+};
+export type EnsureSessionInput = SessionLookupInput & {
+    agentId?: string | undefined;
+    source: 'session_start' | 'lazy_session';
+    resumedFrom?: string | undefined;
+    timestamp?: number | undefined;
+};
+export type SessionState = {
+    sessionId: string;
+    sessionKey?: string;
+    agentId?: string;
+    source: 'session_start' | 'lazy_session';
+    resumedFrom?: string;
+    finalOutput?: JsonRecord;
+    trajectoryReplayedRuns?: Set<string>;
+    hookLlmOutputReplayCounts?: Map<string, number>;
+    agentRunInputSnapshots?: Map<string, {
+        historyMessageCount: number;
+        historyMessages: unknown[];
+        observedAtMs: number;
+        prompt: string;
+    }>;
+    messageWrites?: unknown[];
+    assistantMessageWrites?: AssistantMessageRecord[];
+    stack: ReturnType<NemoRelayRuntimeModule['createScopeStack']>;
+    rootHandle?: ReturnType<NemoRelayRuntimeModule['pushScope']>;
+};
+export type PendingLlmOutputRecord = {
+    sessionKey: string;
+    sessionId: string;
+    runId: string;
+    provider: string;
+    model: string;
+    event: PluginHookLlmOutputEvent;
+    ctx: PluginHookAgentContext;
+    observedAtMs: number;
+    timer?: ReturnType<typeof setTimeout> | undefined;
+};
+export type LlmInputRecord = {
+    sessionKey: string;
+    sessionId: string;
+    runId: string;
+    provider: string;
+    model: string;
+    prompt: string;
+    historyMessages: unknown[];
+    imagesCount: number;
+    observedAtMs: number;
+    systemPrompt?: string | undefined;
+    placeholderRequest?: boolean | undefined;
+};
+export type AssistantMessageRecord = {
+    sessionKey: string;
+    provider: string;
+    model: string;
+    assistantTexts: string[];
+    assistantToolCalls: unknown[];
+    historyMessages: unknown[];
+    prompt: string;
+    observedAtMs: number;
+    replayed: boolean;
+    usage?: unknown;
+};
+export type ModelCallRecord = {
+    sessionKey: string;
+    runId: string;
+    callId: string;
+    provider: string;
+    model: string;
+    consumed: boolean;
+    observedAtMs: number;
+    sessionId?: string | undefined;
+    api?: string | undefined;
+    transport?: string | undefined;
+    startedAtMs?: number | undefined;
+    endedAtMs?: number | undefined;
+    durationMs?: number | undefined;
+    outcome?: PluginHookModelCallEndedEvent['outcome'] | undefined;
+    errorCategory?: string | undefined;
+    failureKind?: PluginHookModelCallEndedEvent['failureKind'] | undefined;
+    requestPayloadBytes?: number | undefined;
+    responseStreamBytes?: number | undefined;
+    timeToFirstByteMs?: number | undefined;
+    upstreamRequestIdHash?: string | undefined;
+    ambiguous?: boolean | undefined;
+};
+export type HookReplayCounters = {
+    llmSpansReplayed: number;
+    toolSpansReplayed: number;
+    marksEmitted: number;
+    replayErrors: number;
+    skippedEvents: number;
+};
+export type HookReplayBackendState = {
+    sessions: Map<string, SessionState>;
+    sessionAliases: Map<string, string>;
+    llmInputs: Map<string, LlmInputRecord[]>;
+    llmOutputsPendingInput: Map<string, PendingLlmOutputRecord[]>;
+    modelCallsByCallId: Map<string, ModelCallRecord[]>;
+    modelTimingsByLlmKey: Map<string, ModelCallRecord[]>;
+    counters: HookReplayCounters;
+};
+export type SessionManager = {
+    nf: NemoRelayRuntimeModule;
+    config: NemoRelayHookBackendConfig;
+    logger: PluginLogger;
+    state: HookReplayBackendState;
+    agentVersion: string;
+    emitCapturedUnderSession: (label: string, session: SessionState, emit: () => void) => void;
+    replayPendingLlmOutputsForSession: (session: SessionState, options: {
+        allowPlaceholderRequest: boolean;
+    }) => void;
+    emitUnpairedModelCallTimingMarks: (session: SessionState) => void;
+    logBoundedWarn: (key: string, message: string) => void;
+};
+/** Return all keys that may identify an existing OpenClaw session. */
+export declare function lookupSessionKeys(input: SessionLookupInput): string[];
+/** Return keys that should alias to a canonical session once it is known. */
+export declare function aliasSessionKeys(input: SessionLookupInput): string[];
+/** Resolve a hook's session identity to the canonical session id used in replay state. */
+export declare function resolveSessionKey(state: HookReplayBackendState, input: SessionLookupInput): string | undefined;
+/** Remember equivalent hook identifiers so later events attach to the same root span. */
+export declare function rememberSessionAliases(state: HookReplayBackendState, session: SessionState, input: SessionLookupInput): void;
+/** Create the mutable in-memory state used by the hook replay backend. */
+export declare function createHookReplayState(): HookReplayBackendState;
+/** Return an existing session or lazily create a root session scope for replay. */
+export declare function ensureSession(manager: SessionManager, input: EnsureSessionInput): SessionState | undefined;
+/** Flush pending LLM output/timing state before the root session closes. */
+export declare function drainSession(manager: SessionManager, session: SessionState): void;
+/** Close the root session scope with separate lifecycle summary and user-visible output. */
+export declare function closeSessionRoot(manager: SessionManager, session: SessionState, summary: JsonRecord, rootOutput?: JsonRecord, timestamp?: number): void;
+/** Remove a closed session from active replay state. */
+export declare function deleteSession(state: HookReplayBackendState, session: SessionState): void;
+/** Insert a correlation record while bounding retained entries per key. */
+export declare function insertBoundedRecord<T>(map: Map<string, T[]>, key: string, record: T, maxRecordsPerKey: number): void;
+/** Build a stable tuple key for session alias maps. */
+export declare function tupleKey(parts: Array<string | undefined>): string;
+/** Evict stale cross-hook correlation records across all replay maps. */
+export declare function evictExpiredCorrelationRecords(state: HookReplayBackendState, nowMs: number, ttlMs: number): void;

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

@@ -0,0 +1,204 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { evictExpiredRecords, tupleKey as tupleKeyFromCorrelation } from './correlation.js';
+/** Return all keys that may identify an existing OpenClaw session. */
+export function lookupSessionKeys(input) {
+    return [input.sessionId, input.sessionKey, input.requesterSessionKey, input.childSessionKey, input.runId].filter((value) => typeof value === 'string' && value.length > 0);
+}
+/** Return keys that should alias to a canonical session once it is known. */
+export function aliasSessionKeys(input) {
+    return [input.sessionId, input.sessionKey, input.requesterSessionKey, input.runId].filter((value) => typeof value === 'string' && value.length > 0);
+}
+/** Resolve a hook's session identity to the canonical session id used in replay state. */
+export function resolveSessionKey(state, input) {
+    for (const key of lookupSessionKeys(input)) {
+        const canonical = state.sessionAliases.get(key);
+        if (canonical) {
+            return canonical;
+        }
+    }
+    return input.sessionId ?? input.sessionKey ?? input.childSessionKey ?? input.runId;
+}
+/** Remember equivalent hook identifiers so later events attach to the same root span. */
+export function rememberSessionAliases(state, session, input) {
+    for (const alias of aliasSessionKeys(input)) {
+        state.sessionAliases.set(alias, session.sessionId);
+    }
+}
+/** Create the mutable in-memory state used by the hook replay backend. */
+export function createHookReplayState() {
+    return {
+        sessions: new Map(),
+        sessionAliases: new Map(),
+        llmInputs: new Map(),
+        llmOutputsPendingInput: new Map(),
+        modelCallsByCallId: new Map(),
+        modelTimingsByLlmKey: new Map(),
+        counters: {
+            llmSpansReplayed: 0,
+            toolSpansReplayed: 0,
+            marksEmitted: 0,
+            replayErrors: 0,
+            skippedEvents: 0,
+        },
+    };
+}
+/** Return an existing session or lazily create a root session scope for replay. */
+export function ensureSession(manager, input) {
+    const key = resolveSessionKey(manager.state, input);
+    if (!key) {
+        manager.state.counters.skippedEvents += 1;
+        manager.logBoundedWarn('missing-session-key', 'nemo-relay skipped replay because no session/run key was available');
+        return undefined;
+    }
+    const existing = manager.state.sessions.get(key);
+    if (existing) {
+        rememberSessionAliases(manager.state, existing, input);
+        return existing;
+    }
+    const canonicalSessionId = input.sessionId ?? key;
+    const aliased = manager.state.sessions.get(canonicalSessionId);
+    if (aliased) {
+        rememberSessionAliases(manager.state, aliased, input);
+        return aliased;
+    }
+    const stack = manager.nf.createScopeStack();
+    const session = {
+        sessionId: canonicalSessionId,
+        source: input.source,
+        stack,
+    };
+    if (input.sessionKey !== undefined) {
+        session.sessionKey = input.sessionKey;
+    }
+    if (input.agentId !== undefined) {
+        session.agentId = input.agentId;
+    }
+    if (input.resumedFrom !== undefined) {
+        session.resumedFrom = input.resumedFrom;
+    }
+    openSessionRoot(manager, session, input);
+    manager.state.sessions.set(session.sessionId, session);
+    rememberSessionAliases(manager.state, session, input);
+    return session;
+}
+/** Flush pending LLM output/timing state before the root session closes. */
+export function drainSession(manager, session) {
+    cancelPendingLlmOutputTimers(manager.state, session);
+    manager.replayPendingLlmOutputsForSession(session, { allowPlaceholderRequest: true });
+    manager.emitUnpairedModelCallTimingMarks(session);
+    evictSessionCorrelationRecords(manager.state, session);
+}
+/** Close the root session scope with separate lifecycle summary and user-visible output. */
+export function closeSessionRoot(manager, session, summary, rootOutput = summary, timestamp) {
+    manager.emitCapturedUnderSession('session_end', session, () => {
+        if (!session.rootHandle) {
+            return;
+        }
+        manager.nf.event('openclaw.session_end', session.rootHandle, summary, null, timestamp ?? null);
+        manager.state.counters.marksEmitted += 1;
+        manager.nf.popScope(session.rootHandle, rootOutput, timestamp ?? null);
+        delete session.rootHandle;
+    });
+}
+/** Remove a closed session from active replay state. */
+export function deleteSession(state, session) {
+    state.sessions.delete(session.sessionId);
+}
+/** Insert a correlation record while bounding retained entries per key. */
+export function insertBoundedRecord(map, key, record, maxRecordsPerKey) {
+    const records = map.get(key) ?? [];
+    records.push(record);
+    while (records.length > maxRecordsPerKey) {
+        records.shift();
+    }
+    map.set(key, records);
+}
+/** Build a stable tuple key for session alias maps. */
+export function tupleKey(parts) {
+    return tupleKeyFromCorrelation(parts);
+}
+/** Evict stale cross-hook correlation records across all replay maps. */
+export function evictExpiredCorrelationRecords(state, nowMs, ttlMs) {
+    evictExpiredRecords(state.llmInputs, nowMs, ttlMs);
+    evictExpiredPendingLlmOutputs(state.llmOutputsPendingInput, nowMs, ttlMs);
+    evictExpiredRecords(state.modelCallsByCallId, nowMs, ttlMs);
+    evictExpiredRecords(state.modelTimingsByLlmKey, nowMs, ttlMs);
+}
+/** Open the root NeMo Relay scope for one OpenClaw session and emit session_start. */
+function openSessionRoot(manager, session, input) {
+    const data = {
+        sessionId: session.sessionId,
+        source: session.source,
+        ...(session.sessionKey === undefined ? {} : { sessionKey: session.sessionKey }),
+        ...(session.agentId === undefined ? {} : { agentId: session.agentId }),
+        ...(input.runId === undefined ? {} : { runId: input.runId }),
+        ...(session.resumedFrom === undefined ? {} : { resumedFrom: session.resumedFrom }),
+    };
+    manager.emitCapturedUnderSession('session_start', session, () => {
+        session.rootHandle = manager.nf.pushScope('openclaw.session', agentScopeType(manager.nf), null, null, data, null, null, input.timestamp ?? null);
+        manager.nf.event('openclaw.session_start', session.rootHandle, data, null, input.timestamp ?? null);
+        manager.state.counters.marksEmitted += 1;
+    });
+}
+/** Cancel timers that would otherwise replay late LLM outputs after session close. */
+function cancelPendingLlmOutputTimers(state, session) {
+    for (const records of state.llmOutputsPendingInput.values()) {
+        for (const record of records) {
+            if (record.sessionKey === session.sessionId && record.timer) {
+                clearTimeout(record.timer);
+                record.timer = undefined;
+            }
+        }
+    }
+}
+/** Remove all correlation records and aliases owned by a closed session. */
+function evictSessionCorrelationRecords(state, session) {
+    evictFromRecordMap(state.llmInputs, session.sessionId);
+    evictFromRecordMap(state.llmOutputsPendingInput, session.sessionId);
+    evictFromRecordMap(state.modelCallsByCallId, session.sessionId);
+    evictFromRecordMap(state.modelTimingsByLlmKey, session.sessionId);
+    for (const [alias, canonical] of state.sessionAliases) {
+        if (canonical === session.sessionId || alias === session.sessionId) {
+            state.sessionAliases.delete(alias);
+        }
+    }
+}
+/** Drop records for one session from a single keyed correlation map. */
+function evictFromRecordMap(map, sessionKey) {
+    for (const [key, records] of map) {
+        const retained = records.filter((record) => record.sessionKey !== sessionKey);
+        if (retained.length === 0) {
+            map.delete(key);
+        }
+        else {
+            map.set(key, retained);
+        }
+    }
+}
+/** Evict pending LLM outputs and clear their grace timers when their TTL expires. */
+function evictExpiredPendingLlmOutputs(map, nowMs, ttlMs) {
+    for (const [key, records] of map) {
+        const retained = [];
+        for (const record of records) {
+            if (nowMs - record.observedAtMs <= ttlMs) {
+                retained.push(record);
+                continue;
+            }
+            if (record.timer) {
+                clearTimeout(record.timer);
+                record.timer = undefined;
+            }
+        }
+        if (retained.length === 0) {
+            map.delete(key);
+        }
+        else {
+            map.set(key, retained);
+        }
+    }
+}
+/** Resolve the runtime's Agent scope enum while tolerating older Node bindings. */
+function agentScopeType(nf) {
+    return (nf.ScopeType?.Agent ?? 0);
+}

package/dist/src/hook-replay/tool.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Tool-call replay from OpenClaw hooks into NeMo Relay spans.
+ *
+ * Tool payloads can be large or sensitive, so this module applies capture policy
+ * before exporting arguments/results while keeping enough metadata for debugging.
+ */
+import type { PluginHookAfterToolCallEvent, PluginHookBeforeToolCallEvent, PluginHookToolContext } from '../openclaw-hook-types.js';
+import { type SessionManager } from './session.js';
+/** Run NeMo Relay tool conditional-execution guardrails before OpenClaw executes a tool. */
+export declare function guardBeforeToolCall(manager: SessionManager, event: PluginHookBeforeToolCallEvent, ctx: PluginHookToolContext): Promise<void>;
+/** Convert one OpenClaw after_tool_call event into a NeMo Relay tool span or blocked-tool mark. */
+export declare function replayAfterToolCall(manager: SessionManager, event: PluginHookAfterToolCallEvent, ctx: PluginHookToolContext): void;

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

@@ -0,0 +1,101 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { blockedToolDetails, emitMark, errorToJson, toJsonRecord, toJsonValue } from './marks.js';
+import { ensureSession } from './session.js';
+import { nowMicros, startMicrosFromDuration } from './correlation.js';
+/** Run NeMo Relay tool conditional-execution guardrails before OpenClaw executes a tool. */
+export async function guardBeforeToolCall(manager, event, ctx) {
+    const session = ensureSession(manager, {
+        sessionId: ctx.sessionId,
+        sessionKey: ctx.sessionKey,
+        runId: event.runId ?? ctx.runId,
+        agentId: ctx.agentId,
+        source: 'lazy_session',
+    });
+    const args = toJsonValue(event.params ?? {});
+    if (session) {
+        const previousStack = manager.nf.currentScopeStack();
+        try {
+            manager.nf.setThreadScopeStack(session.stack);
+            await manager.nf.toolConditionalExecution(event.toolName, args);
+        }
+        finally {
+            manager.nf.setThreadScopeStack(previousStack);
+        }
+    }
+    else {
+        await manager.nf.toolConditionalExecution(event.toolName, args);
+    }
+}
+/** Convert one OpenClaw after_tool_call event into a NeMo Relay tool span or blocked-tool mark. */
+export function replayAfterToolCall(manager, event, ctx) {
+    const session = ensureSession(manager, {
+        sessionId: ctx.sessionId,
+        sessionKey: ctx.sessionKey,
+        runId: event.runId ?? ctx.runId,
+        agentId: ctx.agentId,
+        source: 'lazy_session',
+    });
+    const blockedDetails = blockedToolDetails(event, { runId: event.runId ?? ctx.runId });
+    if (session && blockedDetails) {
+        manager.emitCapturedUnderSession('openclaw.tool_blocked', session, () => {
+            emitMark({
+                nf: manager.nf,
+                state: manager.state,
+                session,
+                name: 'openclaw.tool_blocked',
+                data: blockedDetails,
+            });
+        });
+        return;
+    }
+    if (!session) {
+        return;
+    }
+    const endMicros = nowMicros();
+    const metadata = toJsonRecord({
+        source: 'openclaw.after_tool_call',
+        runId: event.runId ?? ctx.runId,
+        sessionId: ctx.sessionId,
+        sessionKey: ctx.sessionKey,
+        toolCallId: event.toolCallId ?? ctx.toolCallId,
+        durationMs: event.durationMs,
+    });
+    const argsPayload = toJsonValue(manager.config.capture.stripToolArgs
+        ? {
+            stripped: true,
+            argKeys: event.params && typeof event.params === 'object' && !Array.isArray(event.params)
+                ? Object.keys(event.params)
+                : undefined,
+        }
+        : (event.params ?? {}));
+    const endPayload = toJsonValue(manager.config.capture.stripToolResults
+        ? toolDisplayPayload(event, true)
+        : event.error
+            ? { ...toolDisplayPayload(event, false), error: errorToJson(event.error), result: event.result ?? null }
+            : { ...toolDisplayPayload(event, false), result: event.result ?? null });
+    manager.emitCapturedUnderSession('after_tool_call', session, () => {
+        const handle = manager.nf.toolCall(event.toolName, argsPayload, session.rootHandle, null, null, metadata, event.toolCallId ?? ctx.toolCallId ?? null, startMicrosFromDuration(endMicros, event.durationMs));
+        manager.nf.toolCallEnd(handle, endPayload, null, metadata, endMicros);
+        manager.state.counters.toolSpansReplayed += 1;
+    });
+}
+/** Build the compact default tool output shown in trace UIs. */
+function toolDisplayPayload(event, stripped) {
+    const hasError = Boolean(event.error);
+    return {
+        content: `Tool ${event.toolName} ${hasError ? 'failed' : 'completed'}.`,
+        openclaw: {
+            toolName: event.toolName,
+            toolCallId: event.toolCallId,
+            durationMs: event.durationMs,
+            hasError,
+            stripped,
+            resultKeys: resultKeys(event.result),
+        },
+    };
+}
+/** Include result keys as a low-noise hint when full tool results are stripped. */
+function resultKeys(result) {
+    return result && typeof result === 'object' && !Array.isArray(result) ? Object.keys(result) : undefined;
+}