@n8n/instance-ai 1.7.0 → 1.8.0

package/dist/tracing/langsmith-tracing.js

@@ -1,36 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializeModelIdForTrace = serializeModelIdForTrace;
+exports.serializeModelIdForTrace = exports.redactLangSmithTelemetrySpan = exports.buildAgentTraceInputs = void 0;
 exports.releaseTraceClient = releaseTraceClient;
 exports.submitLangsmithUserFeedback = submitLangsmithUserFeedback;
-exports.getTraceParentRun = getTraceParentRun;
-exports.setTraceParentOverride = setTraceParentOverride;
+exports.getCurrentOtelSpanContext = getCurrentOtelSpanContext;
+exports.getCurrentTraceToolCallId = getCurrentTraceToolCallId;
 exports.mergeCurrentTraceMetadata = mergeCurrentTraceMetadata;
 exports.appendRootRunMetadata = appendRootRunMetadata;
 exports.appendGeneratedWorkflowIdToRootMetadata = appendGeneratedWorkflowIdToRootMetadata;
 exports.mergeTraceRunInputs = mergeTraceRunInputs;
-exports.buildAgentTraceInputs = buildAgentTraceInputs;
-exports.withTraceParentContext = withTraceParentContext;
 exports.withCurrentTraceSpan = withCurrentTraceSpan;
 exports.createTraceReplayOnlyContext = createTraceReplayOnlyContext;
 exports.createInstanceAiTraceContext = createInstanceAiTraceContext;
 exports.continueInstanceAiTraceContext = continueInstanceAiTraceContext;
 exports.createDetachedSubAgentTraceContext = createDetachedSubAgentTraceContext;
-const tools_1 = require("@mastra/core/tools");
+exports.createInternalOperationTraceContext = createInternalOperationTraceContext;
+const agents_1 = require("@n8n/agents");
+const api_1 = require("@opentelemetry/api");
 const langsmith_1 = require("langsmith");
-const traceable_1 = require("langsmith/traceable");
 const node_async_hooks_1 = require("node:async_hooks");
+const promises_1 = require("node:fs/promises");
+const node_module_1 = require("node:module");
+const node_path_1 = require("node:path");
+const tool_registry_1 = require("../tool-registry");
+const trace_labels_1 = require("./trace-labels");
+const trace_payloads_1 = require("./trace-payloads");
 const trace_replay_1 = require("./trace-replay");
 const stream_helpers_1 = require("../utils/stream-helpers");
+var trace_payloads_2 = require("./trace-payloads");
+Object.defineProperty(exports, "buildAgentTraceInputs", { enumerable: true, get: function () { return trace_payloads_2.buildAgentTraceInputs; } });
+Object.defineProperty(exports, "redactLangSmithTelemetrySpan", { enumerable: true, get: function () { return trace_payloads_2.redactLangSmithTelemetrySpan; } });
+Object.defineProperty(exports, "serializeModelIdForTrace", { enumerable: true, get: function () { return trace_payloads_2.serializeModelIdForTrace; } });
 const DEFAULT_PROJECT_NAME = 'instance-ai';
 const DEFAULT_TAGS = ['instance-ai'];
-const MAX_TRACE_DEPTH = 4;
-const MAX_TRACE_STRING_LENGTH = 2_000;
-const MAX_TRACE_ARRAY_ITEMS = 20;
-const MAX_TRACE_OBJECT_KEYS = 30;
-const traceParentOverrideStorage = new node_async_hooks_1.AsyncLocalStorage();
+const productTraceStorage = new node_async_hooks_1.AsyncLocalStorage();
 const proxyHeaderStore = new node_async_hooks_1.AsyncLocalStorage();
-const traceClients = new Map();
+const otelTraceRuntimes = new Map();
+const hostRequire = (0, node_module_1.createRequire)(__filename);
 const gzipFetch = async (input, init) => {
     const headers = new Headers(init?.headers);
     if (!headers.has('Accept-Encoding')) {
@@ -44,6 +50,343 @@ const gzipFetch = async (input, init) => {
 };
 let cachedProxyClient = null;
 let cachedDirectClient = null;
+const OTEL_TRACE_VERSION = 'otel-v2';
+const LANGSMITH_TRACEABLE = 'langsmith.traceable';
+const LANGSMITH_TRACE_NAME = 'langsmith.trace.name';
+const LANGSMITH_SPAN_KIND = 'langsmith.span.kind';
+const LANGSMITH_SPAN_TAGS = 'langsmith.span.tags';
+function isOtelTracer(value) {
+    return (value !== null &&
+        typeof value === 'object' &&
+        typeof Reflect.get(value, 'startSpan') === 'function');
+}
+function langsmithTraceIdFromOtelTraceId(traceId) {
+    return `${traceId.substring(0, 8)}-${traceId.substring(8, 12)}-${traceId.substring(12, 16)}-${traceId.substring(16, 20)}-${traceId.substring(20, 32)}`;
+}
+function langsmithRunIdFromOtelSpanId(spanId) {
+    const paddedHex = spanId.padStart(16, '0');
+    return `00000000-0000-0000-${paddedHex.substring(0, 4)}-${paddedHex.substring(4, 16)}`;
+}
+function stableDottedOrder(parentRun, runId) {
+    return parentRun?.dottedOrder ? `${parentRun.dottedOrder}.${runId}` : runId;
+}
+function inferDisplayKind(name) {
+    if (name === 'turn')
+        return 'turn';
+    if (name.startsWith('agent:'))
+        return 'agent';
+    if (name.startsWith('llm:'))
+        return 'llm';
+    if (name.startsWith('tool:'))
+        return 'tool';
+    if (name.startsWith('prepare:'))
+        return 'prepare';
+    if (name.startsWith('resume:'))
+        return 'resume';
+    if (name.startsWith('background task:'))
+        return 'background_task';
+    if (name.startsWith('hitl:'))
+        return 'hitl';
+    if (name.startsWith('internal:'))
+        return 'internal';
+    return 'operation';
+}
+function inferDisplayGroup(metadata, name) {
+    const role = typeof metadata?.agent_role === 'string'
+        ? metadata.agent_role
+        : typeof metadata?.subagent_role === 'string'
+            ? metadata.subagent_role
+            : undefined;
+    if (role) {
+        return (0, trace_labels_1.formatAgentRoleLabel)(role);
+    }
+    if (name.startsWith('prepare:'))
+        return 'preparation';
+    if (name.startsWith('hitl:'))
+        return 'human-in-the-loop';
+    if (name === 'turn')
+        return 'conversation';
+    return undefined;
+}
+function inferDisplayPhase(metadata) {
+    return typeof metadata?.execution_mode === 'string'
+        ? (0, trace_labels_1.formatTraceLabel)(metadata.execution_mode)
+        : undefined;
+}
+function buildProductSpanMetadata(options) {
+    const canonicalName = options.canonicalName ?? options.name;
+    const displayGroup = inferDisplayGroup(options.metadata, options.name);
+    const displayPhase = inferDisplayPhase(options.metadata);
+    const displayDefaults = {
+        trace_version: OTEL_TRACE_VERSION,
+        'instance_ai.trace_version': OTEL_TRACE_VERSION,
+        display_kind: inferDisplayKind(options.name),
+        ...(displayGroup ? { display_group: displayGroup } : {}),
+        ...(displayPhase ? { display_phase: displayPhase } : {}),
+    };
+    return (mergeMetadata(displayDefaults, options.metadata, {
+        display_name: options.name,
+        'instance_ai.display_name': options.name,
+        'instance_ai.canonical_name': canonicalName,
+        'instance_ai.run_name': canonicalName,
+    }) ?? {});
+}
+function buildProductSpanAttributes(options) {
+    const attributes = {
+        [LANGSMITH_TRACEABLE]: 'true',
+        [LANGSMITH_TRACE_NAME]: options.name,
+        [LANGSMITH_SPAN_KIND]: options.runType ?? 'chain',
+        'instance_ai.trace_version': OTEL_TRACE_VERSION,
+    };
+    const tags = normalizeTags(DEFAULT_TAGS, options.tags);
+    if (tags?.length) {
+        attributes[LANGSMITH_SPAN_TAGS] = tags;
+    }
+    const metadata = buildProductSpanMetadata(options);
+    for (const [key, value] of Object.entries(metadata ?? {})) {
+        const attributeValue = (0, trace_payloads_1.toTelemetryAttributeValue)(value);
+        if (attributeValue === undefined)
+            continue;
+        attributes[key] = attributeValue;
+        if (!key.startsWith('langsmith.metadata.')) {
+            attributes[`langsmith.metadata.${key}`] = attributeValue;
+        }
+    }
+    const inputs = options.inputs === undefined ? undefined : stringifyTracePayload(options.inputs);
+    if (inputs !== undefined) {
+        attributes[trace_payloads_1.GEN_AI_PROMPT] = inputs;
+    }
+    return attributes;
+}
+function stringifyTracePayload(value) {
+    try {
+        return JSON.stringify((0, trace_payloads_1.sanitizeTracePayload)(value));
+    }
+    catch {
+        return undefined;
+    }
+}
+function startProductSpan(runtime, options) {
+    if (!isOtelTracer(runtime.telemetry.tracer)) {
+        throw new Error('Instance AI tracing requires an OpenTelemetry tracer');
+    }
+    const spanMetadata = buildProductSpanMetadata(options);
+    const parentContext = options.root
+        ? api_1.ROOT_CONTEXT
+        : (options.parentContext ??
+            (options.parentRun ? runtime.contexts.get(options.parentRun.id) : undefined) ??
+            api_1.context.active());
+    const span = runtime.telemetry.tracer.startSpan(options.name, {
+        attributes: buildProductSpanAttributes(options),
+    }, parentContext);
+    const spanContext = span.spanContext();
+    const traceId = langsmithTraceIdFromOtelTraceId(spanContext.traceId);
+    const runId = langsmithRunIdFromOtelSpanId(spanContext.spanId);
+    const spanContextWithSpan = api_1.trace.setSpan(parentContext ?? api_1.context.active(), span);
+    const parentRun = options.parentRun;
+    const runMetadata = mergeMetadata(parentRun?.metadata, spanMetadata);
+    const run = {
+        id: runId,
+        name: options.name,
+        runType: options.runType ?? 'chain',
+        projectName: options.projectName,
+        startTime: Date.now(),
+        traceId,
+        otelTraceId: spanContext.traceId,
+        otelSpanId: spanContext.spanId,
+        dottedOrder: stableDottedOrder(parentRun, runId),
+        executionOrder: parentRun ? parentRun.childExecutionOrder + 1 : 0,
+        childExecutionOrder: 0,
+        ...(parentRun ? { parentRunId: parentRun.id } : {}),
+        ...(options.tags ? { tags: normalizeTags(DEFAULT_TAGS, parentRun?.tags, options.tags) } : {}),
+        ...(runMetadata ? { metadata: runMetadata } : {}),
+        ...(options.inputs !== undefined ? { inputs: (0, trace_payloads_1.sanitizeTracePayload)(options.inputs) } : {}),
+    };
+    if (parentRun) {
+        parentRun.childExecutionOrder += 1;
+    }
+    runtime.spans.set(run.id, span);
+    runtime.contexts.set(run.id, spanContextWithSpan);
+    return run;
+}
+async function finishProductSpan(runtime, run, options) {
+    const span = runtime.spans.get(run.id);
+    if (!span)
+        return;
+    const metadata = mergeMetadata(options?.metadata);
+    const attributes = {};
+    for (const [key, value] of Object.entries(metadata ?? {})) {
+        const attributeValue = (0, trace_payloads_1.toTelemetryAttributeValue)(value);
+        if (attributeValue === undefined)
+            continue;
+        attributes[key] = attributeValue;
+        attributes[`langsmith.metadata.${key}`] = attributeValue;
+    }
+    if (options?.outputs !== undefined) {
+        const completion = stringifyTracePayload(options.outputs);
+        if (completion !== undefined) {
+            attributes[trace_payloads_1.GEN_AI_COMPLETION] = completion;
+        }
+        run.outputs = (0, trace_payloads_1.sanitizeTracePayload)(options.outputs);
+    }
+    run.endTime = Date.now();
+    run.metadata = mergeMetadata(run.metadata, metadata);
+    try {
+        if (Object.keys(attributes).length > 0) {
+            span.setAttributes(attributes);
+        }
+        if (options?.error) {
+            span.recordException(new Error(options.error));
+            span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: options.error });
+            run.error = options.error;
+        }
+        else {
+            span.setStatus({ code: api_1.SpanStatusCode.OK });
+        }
+        span.end();
+    }
+    finally {
+        runtime.spans.delete(run.id);
+        runtime.contexts.delete(run.id);
+    }
+    if (options?.forceFlush === true) {
+        await agents_1.Telemetry.forceFlush(runtime.telemetry);
+    }
+}
+async function finishProductSpanBestEffort(runtime, run, options) {
+    try {
+        await finishProductSpan(runtime, run, options);
+    }
+    catch {
+    }
+}
+async function shutdownProductOtelRuntime(runtime, traceId) {
+    if (runtime.shutdown)
+        return;
+    runtime.shutdown = true;
+    runtime.spans.clear();
+    runtime.contexts.clear();
+    otelTraceRuntimes.delete(traceId);
+    try {
+        await agents_1.Telemetry.shutdown(runtime.telemetry);
+    }
+    catch {
+    }
+}
+async function withProxyHeaders(proxyConfig, fn) {
+    if (!proxyConfig)
+        return await fn();
+    const headers = await proxyConfig.getAuthHeaders();
+    return await proxyHeaderStore.run(headers, fn);
+}
+async function withProxyHeadersBestEffort(proxyConfig, fn) {
+    if (!proxyConfig)
+        return await fn();
+    let headers;
+    try {
+        headers = await proxyConfig.getAuthHeaders();
+    }
+    catch {
+        return await fn();
+    }
+    return await proxyHeaderStore.run(headers, fn);
+}
+async function withProductSpanContext(runtime, run, fn) {
+    const spanContext = runtime.contexts.get(run.id);
+    if (!spanContext) {
+        return await fn();
+    }
+    return await productTraceStorage.run({ runtime, currentRun: run }, async () => await api_1.context.with(spanContext, fn));
+}
+async function withProductSpanContextBestEffort(runtime, run, fn) {
+    let callbackStarted = false;
+    try {
+        return await withProductSpanContext(runtime, run, async () => {
+            callbackStarted = true;
+            return await fn();
+        });
+    }
+    catch (error) {
+        if (!callbackStarted) {
+            return await fn();
+        }
+        throw error;
+    }
+}
+function createFallbackChildRun(projectName, parentRun, init) {
+    const executionOrder = parentRun.childExecutionOrder + 1;
+    const id = `${parentRun.id}:child:${executionOrder}`;
+    const metadata = mergeMetadata(parentRun.metadata, init.metadata);
+    parentRun.childExecutionOrder = executionOrder;
+    return {
+        id,
+        name: init.name,
+        runType: init.runType ?? 'chain',
+        projectName,
+        startTime: Date.now(),
+        traceId: parentRun.traceId,
+        dottedOrder: stableDottedOrder(parentRun, id),
+        executionOrder,
+        childExecutionOrder: 0,
+        parentRunId: parentRun.id,
+        ...(init.tags ? { tags: normalizeTags(DEFAULT_TAGS, parentRun.tags, init.tags) } : {}),
+        ...(metadata ? { metadata } : {}),
+        ...(init.inputs !== undefined ? { inputs: (0, trace_payloads_1.sanitizeTracePayload)(init.inputs) } : {}),
+    };
+}
+function getCurrentProductTrace() {
+    return productTraceStorage.getStore();
+}
+function getActiveOtelContextWithSpan(expectedTraceId) {
+    const activeContext = api_1.context.active();
+    const activeSpanContext = api_1.trace.getSpan(activeContext)?.spanContext();
+    if (!activeSpanContext) {
+        return undefined;
+    }
+    if (expectedTraceId && activeSpanContext.traceId !== expectedTraceId) {
+        return undefined;
+    }
+    return activeContext;
+}
+function spanMetadataAttributes(metadata) {
+    const attributes = {};
+    for (const [key, value] of Object.entries(metadata ?? {})) {
+        const attributeValue = (0, trace_payloads_1.toTelemetryAttributeValue)(value);
+        if (attributeValue === undefined)
+            continue;
+        attributes[key] = attributeValue;
+        if (!key.startsWith('langsmith.metadata.')) {
+            attributes[`langsmith.metadata.${key}`] = attributeValue;
+        }
+    }
+    return attributes;
+}
+function updateProductRunMetadata(runtime, run, metadata) {
+    const mergedMetadata = mergeMetadata(run.metadata, metadata);
+    if (!mergedMetadata)
+        return;
+    run.metadata = mergedMetadata;
+    const attributes = spanMetadataAttributes(metadata);
+    if (Object.keys(attributes).length > 0) {
+        try {
+            runtime.spans.get(run.id)?.setAttributes(attributes);
+        }
+        catch {
+        }
+    }
+}
+function updateProductRunInputs(runtime, run, inputs) {
+    const mergedInputs = (0, trace_payloads_1.sanitizeTracePayload)((0, trace_payloads_1.mergeTraceInputs)(run.inputs, inputs));
+    run.inputs = mergedInputs;
+    const prompt = stringifyTracePayload(mergedInputs);
+    if (prompt !== undefined) {
+        try {
+            runtime.spans.get(run.id)?.setAttributes({ [trace_payloads_1.GEN_AI_PROMPT]: prompt });
+        }
+        catch {
+        }
+    }
+}
 function getOrCreateDirectClient() {
     if (cachedDirectClient)
         return cachedDirectClient;
@@ -75,9 +418,20 @@ function getOrCreateProxyClient(proxyConfig) {
     cachedProxyClient = { client, apiUrl: proxyConfig.apiUrl };
     return client;
 }
-function isLangSmithTracingEnabled(proxyAvailable) {
-    const tracingFlag = process.env.LANGCHAIN_TRACING_V2 ?? process.env.LANGSMITH_TRACING ?? undefined;
-    if (tracingFlag?.toLowerCase() === 'false') {
+function readBooleanEnvFlag(value) {
+    const normalized = value?.toLowerCase();
+    if (normalized === 'true')
+        return true;
+    if (normalized === 'false')
+        return false;
+    return undefined;
+}
+function isLangSmithTracingEnabled(proxyAvailable = false) {
+    if (readBooleanEnvFlag(process.env.N8N_DIAGNOSTICS_ENABLED) === false) {
+        return false;
+    }
+    const tracingFlag = readBooleanEnvFlag(process.env.LANGCHAIN_TRACING_V2 ?? process.env.LANGSMITH_TRACING);
+    if (tracingFlag === false) {
         return false;
     }
     if (proxyAvailable) {
@@ -87,11 +441,11 @@ function isLangSmithTracingEnabled(proxyAvailable) {
         process.env.LANGCHAIN_API_KEY ??
         process.env.LANGSMITH_ENDPOINT ??
         process.env.LANGCHAIN_ENDPOINT ??
-        tracingFlag?.toLowerCase() === 'true');
+        tracingFlag === true);
 }
-function ensureLangSmithTracingEnv() {
-    process.env.LANGCHAIN_TRACING_V2 ??= 'true';
-    process.env.LANGSMITH_TRACING ??= 'true';
+function isInternalOperationTracingEnabled() {
+    return (process.env.N8N_INSTANCE_AI_TRACE_INTERNAL === 'true' ||
+        process.env.N8N_INSTANCE_AI_TRACE_INCLUDE_INTERNAL === 'true');
 }
 function normalizeErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
@@ -110,177 +464,18 @@ function mergeMetadata(...records) {
         for (const [key, value] of Object.entries(record)) {
             if (value !== undefined) {
                 merged[key] =
-                    key === 'model_id' ? serializeModelIdForTrace(value) : sanitizeTraceValue(value);
+                    key === 'model_id' ? (0, trace_payloads_1.serializeModelIdForTrace)(value) : (0, trace_payloads_1.sanitizeTraceValue)(value);
             }
         }
     }
     return Object.keys(merged).length > 0 ? merged : undefined;
 }
-function truncateString(value) {
-    if (value.length <= MAX_TRACE_STRING_LENGTH) {
-        return value;
-    }
-    return `${value.slice(0, MAX_TRACE_STRING_LENGTH)}…`;
-}
-function splitTraceText(value) {
-    if (value.length <= MAX_TRACE_STRING_LENGTH) {
-        return [value];
-    }
-    const chunks = [];
-    let remaining = value;
-    while (remaining.length > MAX_TRACE_STRING_LENGTH) {
-        const candidate = remaining.slice(0, MAX_TRACE_STRING_LENGTH);
-        const splitIndex = candidate.lastIndexOf('\n');
-        const chunkEnd = splitIndex >= MAX_TRACE_STRING_LENGTH / 2 ? splitIndex + 1 : MAX_TRACE_STRING_LENGTH;
-        chunks.push(remaining.slice(0, chunkEnd));
-        remaining = remaining.slice(chunkEnd);
-    }
-    if (remaining.length > 0) {
-        chunks.push(remaining);
-    }
-    return chunks;
-}
-function serializeTraceText(value) {
-    const chunks = splitTraceText(value);
-    if (chunks.length === 1) {
-        return chunks[0];
-    }
-    return Object.fromEntries(chunks.map((chunk, index) => [`part_${String(index + 1).padStart(2, '0')}`, chunk]));
-}
-function summarizeToolDescription(tool) {
-    if (!(0, stream_helpers_1.isRecord)(tool)) {
-        return undefined;
-    }
-    return typeof tool.description === 'string' ? tool.description : undefined;
-}
-function summarizeToolSet(fieldPrefix, tools) {
-    if (!tools || Object.keys(tools).length === 0) {
-        return {};
-    }
-    const summaries = Object.entries(tools).map(([name, tool]) => ({
-        name,
-        ...(summarizeToolDescription(tool) ? { description: summarizeToolDescription(tool) } : {}),
-    }));
-    const catalogText = summaries
-        .map((tool) => typeof tool.description === 'string' ? `${tool.name}: ${tool.description}` : tool.name)
-        .join('\n');
-    return {
-        [`${fieldPrefix}_tool_count`]: summaries.length,
-        [`${fieldPrefix}_tools`]: summaries,
-        [`${fieldPrefix}_tool_catalog`]: serializeTraceText(catalogText),
-    };
-}
-function summarizeMemoryBinding(memory) {
-    if (!(0, stream_helpers_1.isRecord)(memory)) {
-        return {};
-    }
-    return {
-        memory_enabled: true,
-        ...(typeof memory.resource === 'string' ? { memory_resource_id: memory.resource } : {}),
-        ...(typeof memory.thread === 'string' ? { memory_thread_id: memory.thread } : {}),
-    };
-}
-function sanitizeTraceValue(value, depth = 0) {
-    if (value === null || value === undefined) {
-        return value;
-    }
-    if (typeof value === 'string') {
-        return truncateString(value);
-    }
-    if (typeof value === 'number' || typeof value === 'boolean') {
-        return value;
-    }
-    if (typeof value === 'bigint') {
-        return value.toString();
-    }
-    if (typeof value === 'function') {
-        return `[function ${value.name || 'anonymous'}]`;
-    }
-    if (value instanceof Date) {
-        return value.toISOString();
-    }
-    if (value instanceof Error) {
-        return {
-            name: value.name,
-            message: truncateString(value.message),
-        };
-    }
-    if (value instanceof Uint8Array) {
-        return `[binary ${value.byteLength} bytes]`;
-    }
-    if (Array.isArray(value)) {
-        if (depth >= MAX_TRACE_DEPTH) {
-            return `[array(${value.length})]`;
-        }
-        return value
-            .slice(0, MAX_TRACE_ARRAY_ITEMS)
-            .map((entry) => sanitizeTraceValue(entry, depth + 1));
-    }
-    if ((0, stream_helpers_1.isRecord)(value)) {
-        if (depth >= MAX_TRACE_DEPTH) {
-            return `[object ${Object.keys(value).length} keys]`;
-        }
-        const entries = Object.entries(value).slice(0, MAX_TRACE_OBJECT_KEYS);
-        const sanitized = {};
-        for (const [key, entryValue] of entries) {
-            sanitized[key] = sanitizeTraceValue(entryValue, depth + 1);
-        }
-        if (Object.keys(value).length > entries.length) {
-            sanitized.__truncatedKeys = Object.keys(value).length - entries.length;
-        }
-        return sanitized;
-    }
-    if (typeof value === 'symbol') {
-        return value.toString();
-    }
-    return truncateString(Object.prototype.toString.call(value));
-}
-function sanitizeTracePayload(value) {
-    if ((0, stream_helpers_1.isRecord)(value)) {
-        const sanitized = {};
-        for (const [key, entryValue] of Object.entries(value)) {
-            sanitized[key] = sanitizeTraceValue(entryValue);
-        }
-        return sanitized;
-    }
-    if (value === undefined) {
-        return {};
-    }
-    return { value: sanitizeTraceValue(value) };
-}
-function normalizeModelMetadata(modelId) {
-    if (typeof modelId === 'string' && modelId.length > 0) {
-        const [provider, ...modelParts] = modelId.split('/');
-        return modelParts.length > 0
-            ? { provider, modelName: modelParts.join('/') }
-            : { modelName: modelId };
-    }
-    if ((0, stream_helpers_1.isRecord)(modelId) && typeof modelId.id === 'string') {
-        return normalizeModelMetadata(modelId.id);
-    }
-    return {};
-}
-function serializeModelIdForTrace(modelId) {
-    if (typeof modelId === 'string' && modelId.length > 0) {
-        return truncateString(modelId);
-    }
-    if ((0, stream_helpers_1.isRecord)(modelId) && typeof modelId.id === 'string') {
-        return truncateString(modelId.id);
-    }
-    return sanitizeTraceValue(modelId);
-}
-function mergeRunTreeMetadata(baseMetadata, metadata) {
-    return mergeMetadata(baseMetadata, metadata);
-}
-function mergeRunTreeInputs(baseInputs, inputs) {
-    const existingInputs = (0, stream_helpers_1.isRecord)(baseInputs) && !Array.isArray(baseInputs) ? { ...baseInputs } : {};
-    return {
-        ...existingInputs,
-        ...(inputs ?? {}),
-    };
-}
 function releaseTraceClient(traceId) {
-    traceClients.delete(traceId);
+    const runtime = otelTraceRuntimes.get(traceId);
+    if (!runtime) {
+        return;
+    }
+    void shutdownProductOtelRuntime(runtime, traceId);
 }
 async function submitLangsmithUserFeedback(options) {
     if (!isLangSmithTracingEnabled(!!options.proxyConfig)) {
@@ -299,65 +494,49 @@ async function submitLangsmithUserFeedback(options) {
             feedbackSourceType: 'api',
         });
     };
-    if (options.proxyConfig) {
-        const headers = await options.proxyConfig.getAuthHeaders();
-        await proxyHeaderStore.run(headers, call);
-    }
-    else {
-        await call();
-    }
+    await withProxyHeaders(options.proxyConfig, call);
     return true;
 }
-function getTraceParentRun() {
-    const overrideRun = traceParentOverrideStorage.getStore()?.current;
-    if (overrideRun) {
-        return overrideRun;
-    }
-    try {
-        return (0, traceable_1.getCurrentRunTree)() ?? undefined;
+function getCurrentOtelSpanContext() {
+    const activeSpanContext = api_1.trace.getSpan(api_1.context.active())?.spanContext();
+    if (activeSpanContext) {
+        return {
+            traceId: activeSpanContext.traceId,
+            spanId: activeSpanContext.spanId,
+        };
     }
-    catch {
-        return undefined;
+    const currentRun = getCurrentProductTrace()?.currentRun;
+    if (currentRun?.otelTraceId && currentRun.otelSpanId) {
+        return {
+            traceId: currentRun.otelTraceId,
+            spanId: currentRun.otelSpanId,
+        };
     }
+    return undefined;
 }
-function setTraceParentOverride(parentRun) {
-    const store = traceParentOverrideStorage.getStore();
-    if (store) {
-        store.current = parentRun ?? null;
-    }
-    else if (parentRun) {
-        traceParentOverrideStorage.enterWith({ current: parentRun });
-    }
+function getCurrentTraceToolCallId() {
+    const metadata = getCurrentProductTrace()?.currentRun.metadata;
+    return typeof metadata?.tool_call_id === 'string' ? metadata.tool_call_id : undefined;
 }
 function mergeCurrentTraceMetadata(metadata) {
-    const currentRun = getTraceParentRun();
-    if (!currentRun) {
-        return;
-    }
-    const mergedMetadata = mergeRunTreeMetadata(currentRun.metadata, metadata);
-    if (mergedMetadata) {
-        currentRun.metadata = mergedMetadata;
+    const currentProductTrace = getCurrentProductTrace();
+    if (currentProductTrace) {
+        updateProductRunMetadata(currentProductTrace.runtime, currentProductTrace.currentRun, metadata);
     }
 }
 function appendRootRunMetadata(root, patch) {
-    const currentRun = getTraceParentRun();
-    const baseMetadata = currentRun?.id === root.id
-        ? mergeRunTreeMetadata(root.metadata, currentRun.metadata)
-        : root.metadata;
-    const merged = mergeRunTreeMetadata(baseMetadata, patch);
-    if (merged) {
-        root.metadata = merged;
-        if (currentRun?.id === root.id) {
-            currentRun.metadata = merged;
-        }
+    const runtime = getCurrentProductTrace()?.runtime ?? otelTraceRuntimes.get(root.traceId);
+    if (runtime) {
+        updateProductRunMetadata(runtime, root, patch);
+        return;
+    }
+    const mergedMetadata = mergeMetadata(root.metadata, patch);
+    if (mergedMetadata) {
+        root.metadata = mergedMetadata;
     }
 }
 function appendGeneratedWorkflowIdToRootMetadata(root, workflowId) {
-    const currentRun = getTraceParentRun();
-    const metadata = currentRun?.id === root.id
-        ? mergeRunTreeMetadata(root.metadata, currentRun.metadata)
-        : root.metadata;
-    const generatedWorkflowIds = metadata?.generated_workflow_ids;
+    const generatedWorkflowIds = root.metadata?.generated_workflow_ids;
     const existing = Array.isArray(generatedWorkflowIds)
         ? generatedWorkflowIds.filter((value) => typeof value === 'string')
         : [];
@@ -370,86 +549,52 @@ function mergeTraceRunInputs(run, inputs) {
     if (!run) {
         return;
     }
-    const mergedInputs = sanitizeTracePayload(mergeRunTreeInputs(run.inputs, inputs));
-    run.inputs = mergedInputs;
-    const currentRun = getTraceParentRun();
-    if (currentRun?.id === run.id) {
-        currentRun.inputs = mergedInputs;
+    const runtime = getCurrentProductTrace()?.runtime ?? otelTraceRuntimes.get(run.traceId);
+    if (runtime) {
+        updateProductRunInputs(runtime, run, inputs);
+        return;
     }
-}
-function buildAgentTraceInputs(options) {
-    return sanitizeTracePayload({
-        ...(options.systemPrompt ? { system_prompt: serializeTraceText(options.systemPrompt) } : {}),
-        ...(options.modelId !== undefined ? { model: serializeModelIdForTrace(options.modelId) } : {}),
-        ...(options.toolSearchEnabled !== undefined
-            ? { tool_search_enabled: options.toolSearchEnabled }
-            : {}),
-        ...(options.inputProcessors?.length ? { input_processors: options.inputProcessors } : {}),
-        ...summarizeMemoryBinding(options.memory),
-        ...summarizeToolSet('loaded', options.tools),
-        ...summarizeToolSet('deferred', options.deferredTools),
-    });
-}
-async function withTraceParentContext(parentRun, fn) {
-    return await traceParentOverrideStorage.run({ current: parentRun ?? null }, fn);
-}
-async function postChildRun(parentRun, options) {
-    const childRun = parentRun.createChild({
-        name: options.name,
-        run_type: options.runType ?? 'chain',
-        tags: normalizeTags(DEFAULT_TAGS, parentRun.tags, options.tags),
-        metadata: mergeRunTreeMetadata(parentRun.metadata, options.metadata),
-        inputs: sanitizeTracePayload(options.inputs),
-    });
-    childRun.parent_run_id ??= parentRun.id;
-    await childRun.postRun();
-    return childRun;
-}
-async function finishRunTree(runTree, options) {
-    await runTree.end(options?.outputs !== undefined ? sanitizeTracePayload(options.outputs) : undefined, options?.error, Date.now(), mergeMetadata(options?.metadata));
-    await runTree.patchRun();
+    run.inputs = (0, trace_payloads_1.sanitizeTracePayload)((0, trace_payloads_1.mergeTraceInputs)(run.inputs, inputs));
 }
 async function withCurrentTraceSpan(options, fn) {
-    const parentRun = getTraceParentRun();
-    if (!parentRun) {
+    const currentProductTrace = getCurrentProductTrace();
+    if (!currentProductTrace) {
+        return await fn();
+    }
+    const activeParentContext = getActiveOtelContextWithSpan(currentProductTrace.currentRun.otelTraceId);
+    let spanRun;
+    try {
+        spanRun = startProductSpan(currentProductTrace.runtime, {
+            projectName: currentProductTrace.currentRun.projectName,
+            name: options.name,
+            canonicalName: options.canonicalName,
+            runType: options.runType ?? 'chain',
+            tags: options.tags,
+            metadata: options.metadata,
+            inputs: options.inputs,
+            parentRun: currentProductTrace.currentRun,
+            ...(activeParentContext ? { parentContext: activeParentContext } : {}),
+        });
+    }
+    catch {
         return await fn();
     }
-    const spanRun = await postChildRun(parentRun, {
-        name: options.name,
-        runType: options.runType ?? 'chain',
-        tags: options.tags,
-        metadata: options.metadata,
-        inputs: options.inputs,
-    });
     try {
-        const result = await (0, traceable_1.withRunTree)(spanRun, fn);
-        await finishRunTree(spanRun, {
+        const result = await withProductSpanContextBestEffort(currentProductTrace.runtime, spanRun, fn);
+        await finishProductSpanBestEffort(currentProductTrace.runtime, spanRun, {
             ...(options.processOutputs ? { outputs: options.processOutputs(result) } : {}),
             metadata: { final_status: 'completed' },
         });
         return result;
     }
     catch (error) {
-        await finishRunTree(spanRun, {
+        await finishProductSpanBestEffort(currentProductTrace.runtime, spanRun, {
             error: normalizeErrorMessage(error),
             metadata: { final_status: 'error' },
         });
         throw error;
     }
 }
-async function startHitlChildRun(parentRun, name, inputs, metadata) {
-    const hitlRun = await postChildRun(parentRun, {
-        name,
-        runType: 'chain',
-        tags: ['hitl'],
-        metadata,
-        inputs,
-    });
-    await finishRunTree(hitlRun, {
-        outputs: inputs,
-        metadata: { final_status: 'completed' },
-    });
-}
 function buildSuspendMetadata(toolName, suspendPayload) {
     if (!(0, stream_helpers_1.isRecord)(suspendPayload)) {
         return { tool_name: toolName };
@@ -465,145 +610,149 @@ function buildSuspendMetadata(toolName, suspendPayload) {
         ...(typeof suspendPayload.severity === 'string' ? { severity: suspendPayload.severity } : {}),
     };
 }
-async function traceSuspendableToolExecute(tool, options, input, context) {
-    const parentRun = getTraceParentRun();
-    if (!parentRun || typeof tool.execute !== 'function') {
-        return await tool.execute?.(input, context);
-    }
-    const resumeData = context.agent?.resumeData;
-    const toolRun = await postChildRun(parentRun, {
-        name: resumeData !== undefined && resumeData !== null
-            ? `tool:${tool.id}:resume`
-            : `tool:${tool.id}`,
-        runType: 'tool',
-        tags: normalizeTags(['tool'], options?.tags),
-        metadata: mergeMetadata(options?.metadata, {
-            tool_name: tool.id,
-            ...(options?.agentRole ? { agent_role: options.agentRole } : {}),
-            phase: resumeData !== undefined && resumeData !== null ? 'resume' : 'initial',
-            ...(resumeData !== undefined && resumeData !== null
-                ? mergeMetadata(buildSuspendMetadata(tool.id, resumeData), {
-                    approved: (0, stream_helpers_1.isRecord)(resumeData) ? resumeData.approved : undefined,
-                })
-                : {}),
-        }),
-        inputs: { input },
+function isInterruptibleToolContext(context) {
+    return (0, stream_helpers_1.isRecord)(context) && typeof context.suspend === 'function';
+}
+function getToolCallId(context) {
+    return (0, stream_helpers_1.isRecord)(context) && typeof context.toolCallId === 'string'
+        ? context.toolCallId
+        : undefined;
+}
+async function startAndFinishProductChildSpan(currentTrace, options) {
+    const activeParentContext = getActiveOtelContextWithSpan(currentTrace.currentRun.otelTraceId);
+    let childRun;
+    try {
+        childRun = startProductSpan(currentTrace.runtime, {
+            projectName: currentTrace.currentRun.projectName,
+            name: options.name,
+            canonicalName: options.canonicalName,
+            runType: options.runType ?? 'chain',
+            tags: options.tags,
+            metadata: mergeMetadata(currentTrace.currentRun.metadata, options.metadata),
+            inputs: options.inputs,
+            parentRun: currentTrace.currentRun,
+            ...(activeParentContext ? { parentContext: activeParentContext } : {}),
+        });
+    }
+    catch {
+        return;
+    }
+    await finishProductSpanBestEffort(currentTrace.runtime, childRun, {
+        ...(options.outputs !== undefined ? { outputs: options.outputs } : {}),
+        ...(options.error ? { error: options.error } : {}),
+        metadata: {
+            final_status: options.error ? 'error' : 'completed',
+        },
+        forceFlush: options.forceFlush,
     });
-    let toolRunFinished = false;
-    const finishToolRun = async (finishOptions) => {
-        if (toolRunFinished)
-            return;
-        toolRunFinished = true;
-        await finishRunTree(toolRun, finishOptions);
-    };
-    const originalSuspend = context.agent?.suspend;
-    const wrappedContext = context.agent && typeof originalSuspend === 'function'
+}
+async function traceProductSuspendableToolExecute(tool, input, context, currentTrace) {
+    const resumeData = isInterruptibleToolContext(context) ? context.resumeData : undefined;
+    const isResume = resumeData !== undefined && resumeData !== null;
+    const toolCallId = getToolCallId(context);
+    const originalSuspend = isInterruptibleToolContext(context) ? context.suspend : undefined;
+    const wrappedContext = typeof originalSuspend === 'function'
         ? {
             ...context,
-            agent: {
-                ...context.agent,
-                suspend: async (suspendPayload) => {
-                    await startHitlChildRun(toolRun, 'hitl:suspend', suspendPayload, buildSuspendMetadata(tool.id, suspendPayload));
-                    await finishToolRun({
-                        outputs: {
-                            status: 'suspended',
-                            suspendPayload,
-                        },
-                        metadata: mergeMetadata(buildSuspendMetadata(tool.id, suspendPayload), {
-                            final_status: 'suspended',
-                        }),
-                    });
-                    return await originalSuspend(suspendPayload);
-                },
+            suspend: async (suspendPayload) => {
+                await startAndFinishProductChildSpan(currentTrace, {
+                    name: 'hitl: suspend',
+                    canonicalName: 'instance-ai.hitl.suspend',
+                    runType: 'chain',
+                    tags: ['hitl'],
+                    metadata: mergeMetadata(buildSuspendMetadata(tool.name, suspendPayload), {
+                        ...(toolCallId ? { tool_call_id: toolCallId } : {}),
+                    }),
+                    inputs: suspendPayload,
+                    outputs: suspendPayload,
+                    forceFlush: true,
+                });
+                return await originalSuspend(suspendPayload);
             },
         }
         : context;
-    try {
-        const result = await (0, traceable_1.withRunTree)(toolRun, async () => {
-            return await tool.execute(input, wrappedContext);
-        });
-        await finishToolRun({
-            outputs: result,
-            metadata: { final_status: 'completed' },
-        });
-        return result;
-    }
-    catch (error) {
-        await finishToolRun({
-            error: normalizeErrorMessage(error),
-            metadata: { final_status: 'error' },
+    if (isResume) {
+        await startAndFinishProductChildSpan(currentTrace, {
+            name: 'hitl: resume',
+            canonicalName: 'instance-ai.hitl.resume',
+            runType: 'chain',
+            tags: ['hitl', 'resume'],
+            metadata: mergeMetadata(buildSuspendMetadata(tool.name, resumeData), {
+                approved: (0, stream_helpers_1.isRecord)(resumeData) ? resumeData.approved : undefined,
+                ...(toolCallId ? { tool_call_id: toolCallId } : {}),
+            }),
+            inputs: resumeData,
+            outputs: {
+                status: 'resumed',
+            },
+            forceFlush: true,
         });
-        throw error;
     }
+    return await tool.handler(input, wrappedContext);
 }
-async function traceToolExecute(tool, options, input, context) {
-    const parentRun = getTraceParentRun();
-    if (!parentRun || typeof tool.execute !== 'function') {
-        return await tool.execute?.(input, context);
-    }
-    const toolRun = await postChildRun(parentRun, {
-        name: `tool:${tool.id}`,
-        runType: 'tool',
-        tags: normalizeTags(['tool'], options?.tags),
-        metadata: mergeMetadata(options?.metadata, {
-            tool_name: tool.id,
-            ...(options?.agentRole ? { agent_role: options.agentRole } : {}),
-            ...normalizeModelMetadata(options?.metadata?.model_id),
-        }),
-        inputs: { input },
-    });
-    try {
-        const result = await (0, traceable_1.withRunTree)(toolRun, async () => await tool.execute(input, context));
-        await finishRunTree(toolRun, {
-            outputs: result,
-            metadata: { final_status: 'completed' },
-        });
-        return result;
-    }
-    catch (error) {
-        await finishRunTree(toolRun, {
-            error: normalizeErrorMessage(error),
-            metadata: { final_status: 'error' },
-        });
-        throw error;
+async function traceSuspendableToolExecute(tool, input, context) {
+    const currentProductTrace = getCurrentProductTrace();
+    if (!currentProductTrace) {
+        return await tool.handler(input, context);
     }
+    return await traceProductSuspendableToolExecute(tool, input, context, currentProductTrace);
 }
-function createTraceContext(projectName, traceKind, rootRun, actorRun, getProxyHeaders) {
-    const withProxy = async (fn) => {
-        if (!getProxyHeaders)
-            return await fn();
-        const headers = await getProxyHeaders();
-        return await proxyHeaderStore.run(headers, fn);
-    };
-    const startChildRun = async (parentRun, init) => await withProxy(async () => await createChildRun(parentRun, init));
-    const withRunTree = async (run, fn) => await withProxy(async () => await withSerializedRunTree(run, fn));
+function createTraceContext(projectName, traceKind, rootRun, actorRun, otelRuntime, proxyConfig, telemetryFactory) {
+    otelTraceRuntimes.set(rootRun.traceId, otelRuntime);
+    const startChildRun = async (parentRun, init) => await withProxyHeadersBestEffort(proxyConfig, () => {
+        const activeParentContext = getActiveOtelContextWithSpan(parentRun.otelTraceId);
+        try {
+            return startProductSpan(otelRuntime, {
+                projectName,
+                name: init.name,
+                canonicalName: init.canonicalName,
+                runType: init.runType,
+                tags: init.tags,
+                metadata: mergeMetadata(parentRun.metadata, init.metadata),
+                inputs: init.inputs,
+                parentRun,
+                ...(activeParentContext ? { parentContext: activeParentContext } : {}),
+            });
+        }
+        catch {
+            return createFallbackChildRun(projectName, parentRun, init);
+        }
+    });
+    const withActiveSpan = async (run, fn) => await withProxyHeadersBestEffort(proxyConfig, async () => await withProductSpanContextBestEffort(otelRuntime, run, fn));
+    const withRunTree = withActiveSpan;
     const finishRun = async (run, finishOptions) => {
-        await withProxy(async () => await finishTraceRun(run, finishOptions));
-        if (!run.parentRunId) {
-            traceClients.delete(run.traceId);
+        const isRootRun = !run.parentRunId;
+        await withProxyHeadersBestEffort(proxyConfig, async () => await finishProductSpanBestEffort(otelRuntime, run, isRootRun ? { ...finishOptions, forceFlush: true } : finishOptions));
+        if (isRootRun) {
+            await withProxyHeadersBestEffort(proxyConfig, async () => await shutdownProductOtelRuntime(otelRuntime, run.traceId));
         }
     };
     const failRun = async (run, error, metadata) => {
-        await withProxy(async () => await finishTraceRun(run, {
+        const isRootRun = !run.parentRunId;
+        await withProxyHeadersBestEffort(proxyConfig, async () => await finishProductSpanBestEffort(otelRuntime, run, {
             error: normalizeErrorMessage(error),
             metadata,
+            forceFlush: isRootRun,
         }));
-        if (!run.parentRunId) {
-            traceClients.delete(run.traceId);
+        if (isRootRun) {
+            await withProxyHeadersBestEffort(proxyConfig, async () => await shutdownProductOtelRuntime(otelRuntime, run.traceId));
         }
     };
     const ctx = {
         projectName,
         traceKind,
+        ...(proxyConfig ? { proxyConfig } : {}),
         rootRun,
         actorRun,
         messageRun: rootRun,
         orchestratorRun: actorRun,
         startChildRun,
         withRunTree,
+        withActiveSpan,
+        toHeaders: () => ({}),
         finishRun,
         failRun,
-        toHeaders: (run) => hydrateRunTree(run).toHeaders(),
+        ...(telemetryFactory ? { getTelemetry: telemetryFactory } : {}),
         wrapTools: (tools, traceOptions) => {
             if (ctx.replayMode === 'replay' && ctx.traceIndex && ctx.idRemapper) {
                 return replayWrapTools(tools, ctx.traceIndex, ctx.idRemapper, traceOptions);
@@ -617,234 +766,113 @@ function createTraceContext(projectName, traceKind, rootRun, actorRun, getProxyH
     };
     return ctx;
 }
-function createRunStateFromTree(tree) {
-    const parentRunId = tree.parent_run?.id ?? tree.parent_run_id;
+function isTraceableNativeTool(value) {
+    return ((0, stream_helpers_1.isRecord)(value) &&
+        typeof value.name === 'string' &&
+        typeof value.description === 'string' &&
+        typeof value.handler === 'function');
+}
+function wrapToolHandler(tool) {
     return {
-        id: tree.id,
-        name: tree.name,
-        runType: tree.run_type,
-        projectName: tree.project_name,
-        startTime: tree.start_time,
-        ...(tree.end_time ? { endTime: tree.end_time } : {}),
-        traceId: tree.trace_id,
-        dottedOrder: tree.dotted_order,
-        executionOrder: tree.execution_order,
-        childExecutionOrder: tree.child_execution_order,
-        ...(parentRunId ? { parentRunId } : {}),
-        ...(tree.tags ? { tags: [...tree.tags] } : {}),
-        ...(tree.metadata ? { metadata: { ...tree.metadata } } : {}),
-        ...(tree.inputs ? { inputs: sanitizeTracePayload(tree.inputs) } : {}),
-        ...(tree.outputs ? { outputs: sanitizeTracePayload(tree.outputs) } : {}),
-        ...(tree.error ? { error: tree.error } : {}),
+        ...tool,
+        handler: async (input, context) => await traceSuspendableToolExecute(tool, input, context),
     };
 }
-function syncRunState(state, tree) {
-    Object.assign(state, createRunStateFromTree(tree));
-}
-function hydrateRunTree(state) {
-    const client = traceClients.get(state.traceId);
-    return new langsmith_1.RunTree({
-        id: state.id,
-        name: state.name,
-        run_type: state.runType,
-        project_name: state.projectName,
-        start_time: state.startTime,
-        end_time: state.endTime,
-        parent_run_id: state.parentRunId,
-        execution_order: state.executionOrder,
-        child_execution_order: state.childExecutionOrder,
-        trace_id: state.traceId,
-        dotted_order: state.dottedOrder,
-        tags: state.tags,
-        metadata: state.metadata,
-        inputs: state.inputs,
-        outputs: state.outputs,
-        error: state.error,
-        serialized: {},
-        client: client ?? getOrCreateDirectClient(),
-    });
-}
-function isTraceableMastraTool(value) {
-    return ((0, stream_helpers_1.isRecord)(value) &&
-        typeof value.id === 'string' &&
-        typeof value.description === 'string' &&
-        (!('execute' in value) || typeof value.execute === 'function'));
-}
-function wrapToolExecute(tool, options) {
-    if (typeof tool.execute !== 'function') {
-        return tool;
-    }
-    if (tool.suspendSchema !== undefined || tool.resumeSchema !== undefined) {
-        return (0, tools_1.createTool)({
-            id: tool.id,
-            description: tool.description,
-            inputSchema: tool.inputSchema,
-            outputSchema: tool.outputSchema,
-            suspendSchema: tool.suspendSchema,
-            resumeSchema: tool.resumeSchema,
-            requestContextSchema: tool.requestContextSchema,
-            execute: async (input, context) => await traceSuspendableToolExecute(tool, options, input, context),
-            mastra: tool.mastra,
-            requireApproval: tool.requireApproval,
-            providerOptions: tool.providerOptions,
-            toModelOutput: tool.toModelOutput,
-            mcp: tool.mcp,
-            onInputStart: tool.onInputStart,
-            onInputDelta: tool.onInputDelta,
-            onInputAvailable: tool.onInputAvailable,
-            onOutput: tool.onOutput,
-        });
-    }
-    return (0, tools_1.createTool)({
-        id: tool.id,
-        description: tool.description,
-        inputSchema: tool.inputSchema,
-        outputSchema: tool.outputSchema,
-        suspendSchema: tool.suspendSchema,
-        resumeSchema: tool.resumeSchema,
-        requestContextSchema: tool.requestContextSchema,
-        execute: async (input, context) => await traceToolExecute(tool, options, input, context),
-        mastra: tool.mastra,
-        requireApproval: tool.requireApproval,
-        providerOptions: tool.providerOptions,
-        toModelOutput: tool.toModelOutput,
-        mcp: tool.mcp,
-        onInputStart: tool.onInputStart,
-        onInputDelta: tool.onInputDelta,
-        onInputAvailable: tool.onInputAvailable,
-        onOutput: tool.onOutput,
-    });
+function shouldTraceLocalToolExecution(tool) {
+    return tool.suspendSchema !== undefined || tool.resumeSchema !== undefined;
 }
-function wrapTools(tools, options) {
-    const wrapped = {};
-    const entries = Object.entries(tools);
-    for (const [name, tool] of entries) {
-        const originalTool = tools[name];
-        wrapped[name] = isTraceableMastraTool(tool) ? wrapToolExecute(tool, options) : originalTool;
+function wrapTools(tools, _options) {
+    const wrapped = (0, tool_registry_1.createToolRegistry)();
+    for (const [name, tool] of tools) {
+        wrapped.set(name, isTraceableNativeTool(tool) && shouldTraceLocalToolExecution(tool)
+            ? wrapToolHandler(tool)
+            : tool);
     }
     return wrapped;
 }
 function replayWrapTool(tool, traceIndex, idRemapper, agentRole) {
-    return (0, tools_1.createTool)({
-        id: tool.id,
-        description: tool.description,
-        inputSchema: tool.inputSchema,
-        outputSchema: tool.outputSchema,
-        suspendSchema: tool.suspendSchema,
-        resumeSchema: tool.resumeSchema,
-        requestContextSchema: tool.requestContextSchema,
-        execute: async (input, context) => {
-            const event = traceIndex.nextMatching(agentRole, tool.id);
+    return {
+        ...tool,
+        handler: async (input, context) => {
+            const event = traceIndex.nextMatching(agentRole, tool.name);
             const remappedInput = idRemapper.remapInput(input);
-            const realOutput = await tool.execute(remappedInput, context);
+            const realOutput = await tool.handler(remappedInput, context);
             if (event) {
                 idRemapper.learn(event.output, realOutput);
             }
             return realOutput;
         },
-        mastra: tool.mastra,
-        requireApproval: tool.requireApproval,
-        providerOptions: tool.providerOptions,
-        toModelOutput: tool.toModelOutput,
-        mcp: tool.mcp,
-        onInputStart: tool.onInputStart,
-        onInputDelta: tool.onInputDelta,
-        onInputAvailable: tool.onInputAvailable,
-        onOutput: tool.onOutput,
-    });
+    };
 }
 function pureReplayWrapTool(tool, traceIndex, idRemapper, agentRole) {
-    return (0, tools_1.createTool)({
-        id: tool.id,
-        description: tool.description,
-        inputSchema: tool.inputSchema,
-        outputSchema: tool.outputSchema,
-        suspendSchema: tool.suspendSchema,
-        resumeSchema: tool.resumeSchema,
-        requestContextSchema: tool.requestContextSchema,
-        execute: async (_input, _context) => {
-            const event = traceIndex.nextMatching(agentRole, tool.id);
+    return {
+        ...tool,
+        handler: async (_input, _context) => {
+            const event = traceIndex.nextMatching(agentRole, tool.name);
             if (!event) {
-                throw new Error(`No recorded output for pure-replay tool "${tool.id}" in role "${agentRole}"`);
+                throw new Error(`No recorded output for pure-replay tool "${tool.name}" in role "${agentRole}"`);
             }
             return await Promise.resolve(idRemapper.remapOutput(event.output));
         },
-        mastra: tool.mastra,
-        requireApproval: tool.requireApproval,
-        providerOptions: tool.providerOptions,
-        toModelOutput: tool.toModelOutput,
-        mcp: tool.mcp,
-        onInputStart: tool.onInputStart,
-        onInputDelta: tool.onInputDelta,
-        onInputAvailable: tool.onInputAvailable,
-        onOutput: tool.onOutput,
-    });
+    };
 }
 function replayWrapTools(tools, traceIndex, idRemapper, options) {
     const agentRole = options?.agentRole ?? 'orchestrator';
-    const wrapped = {};
-    const entries = Object.entries(tools);
-    for (const [name, tool] of entries) {
-        if (!isTraceableMastraTool(tool)) {
-            wrapped[name] = tools[name];
+    const wrapped = (0, tool_registry_1.createToolRegistry)();
+    for (const [name, tool] of tools) {
+        if (!isTraceableNativeTool(tool)) {
+            wrapped.set(name, tool);
             continue;
         }
-        if (trace_replay_1.PURE_REPLAY_TOOLS.has(tool.id)) {
-            wrapped[name] = pureReplayWrapTool(tool, traceIndex, idRemapper, agentRole);
+        if (trace_replay_1.PURE_REPLAY_TOOLS.has(tool.name)) {
+            wrapped.set(name, pureReplayWrapTool(tool, traceIndex, idRemapper, agentRole));
         }
         else {
-            wrapped[name] = replayWrapTool(tool, traceIndex, idRemapper, agentRole);
+            wrapped.set(name, replayWrapTool(tool, traceIndex, idRemapper, agentRole));
         }
     }
     return wrapped;
 }
-function recordWrapTool(tool, traceWriter, agentRole, traceOptions) {
-    const traced = wrapToolExecute(tool, traceOptions);
-    return (0, tools_1.createTool)({
-        id: traced.id,
-        description: traced.description,
-        inputSchema: traced.inputSchema,
-        outputSchema: traced.outputSchema,
-        suspendSchema: traced.suspendSchema,
-        resumeSchema: traced.resumeSchema,
-        requestContextSchema: traced.requestContextSchema,
-        execute: async (input, context) => {
-            const resumeData = context?.agent?.resumeData;
+function recordWrapTool(tool, traceWriter, agentRole) {
+    return {
+        ...tool,
+        handler: async (input, context) => {
+            const resumeData = isInterruptibleToolContext(context) ? context.resumeData : undefined;
             const inputRecord = (input ?? {});
-            const result = await traced.execute(input, context);
+            let capturedSuspendPayload;
+            const wrappedContext = isInterruptibleToolContext(context)
+                ? {
+                    ...context,
+                    suspend: async (suspendPayload) => {
+                        capturedSuspendPayload = (0, stream_helpers_1.isRecord)(suspendPayload) ? suspendPayload : {};
+                        return await context.suspend(suspendPayload);
+                    },
+                }
+                : context;
+            const result = await tool.handler(input, wrappedContext);
             const outputRecord = (result ?? {});
             if (resumeData !== undefined && resumeData !== null) {
-                traceWriter.recordToolResume(agentRole, tool.id, inputRecord, outputRecord, resumeData);
+                traceWriter.recordToolResume(agentRole, tool.name, inputRecord, outputRecord, resumeData);
             }
-            else if (context?.agent?.suspend && outputRecord.denied === true) {
-                traceWriter.recordToolSuspend(agentRole, tool.id, inputRecord, outputRecord, {});
+            else if (capturedSuspendPayload) {
+                traceWriter.recordToolSuspend(agentRole, tool.name, inputRecord, {}, capturedSuspendPayload);
             }
             else {
-                traceWriter.recordToolCall(agentRole, tool.id, inputRecord, outputRecord);
+                traceWriter.recordToolCall(agentRole, tool.name, inputRecord, outputRecord);
             }
             return result;
         },
-        mastra: traced.mastra,
-        requireApproval: traced.requireApproval,
-        providerOptions: traced.providerOptions,
-        toModelOutput: traced.toModelOutput,
-        mcp: traced.mcp,
-        onInputStart: traced.onInputStart,
-        onInputDelta: traced.onInputDelta,
-        onInputAvailable: traced.onInputAvailable,
-        onOutput: traced.onOutput,
-    });
+    };
 }
 function recordWrapTools(tools, traceWriter, options) {
     const agentRole = options?.agentRole ?? 'orchestrator';
-    const wrapped = {};
-    const entries = Object.entries(tools);
-    for (const [name, tool] of entries) {
-        if (!isTraceableMastraTool(tool)) {
-            wrapped[name] = tools[name];
+    const wrapped = (0, tool_registry_1.createToolRegistry)();
+    for (const [name, tool] of tools) {
+        if (!isTraceableNativeTool(tool)) {
+            wrapped.set(name, tool);
             continue;
         }
-        wrapped[name] = recordWrapTool(tool, traceWriter, agentRole, options);
+        wrapped.set(name, recordWrapTool(tool, traceWriter, agentRole));
     }
     return wrapped;
 }
@@ -869,9 +897,10 @@ function createTraceReplayOnlyContext() {
         orchestratorRun: stubRun,
         startChildRun: async () => await Promise.resolve(stubRun),
         withRunTree: async (_run, fn) => await fn(),
+        withActiveSpan: async (_run, fn) => await fn(),
+        toHeaders: () => ({}),
         finishRun: async () => { },
         failRun: async () => { },
-        toHeaders: () => ({}),
         wrapTools: (tools, traceOptions) => {
             if (ctx.replayMode === 'replay' && ctx.traceIndex && ctx.idRemapper) {
                 return replayWrapTools(tools, ctx.traceIndex, ctx.idRemapper, traceOptions);
@@ -885,149 +914,384 @@ function createTraceReplayOnlyContext() {
     };
     return ctx;
 }
-async function createRun(options) {
-    const runTree = new langsmith_1.RunTree({
-        name: options.name,
-        run_type: options.runType ?? 'chain',
-        project_name: options.projectName,
-        tags: normalizeTags(DEFAULT_TAGS, options.tags),
-        metadata: mergeMetadata(options.metadata),
-        inputs: sanitizeTracePayload(options.inputs),
-        client: options.client ?? getOrCreateDirectClient(),
-    });
-    await runTree.postRun();
-    if (options.client) {
-        traceClients.set(runTree.trace_id, options.client);
-    }
-    return createRunStateFromTree(runTree);
+let traceRuntimeVersions;
+function extractPackageVersion(packageJson) {
+    if (!packageJson || typeof packageJson !== 'object')
+        return undefined;
+    if (!('version' in packageJson))
+        return undefined;
+    const { version } = packageJson;
+    return typeof version === 'string' ? version : undefined;
 }
-async function createChildRun(parentState, options) {
-    const parentRun = hydrateRunTree(parentState);
-    const childRun = parentRun.createChild({
-        name: options.name,
-        run_type: options.runType ?? 'chain',
-        tags: normalizeTags(DEFAULT_TAGS, parentState.tags, options.tags),
-        metadata: mergeMetadata(parentRun.metadata, options.metadata),
-        inputs: sanitizeTracePayload(options.inputs),
-    });
-    syncRunState(parentState, parentRun);
-    await childRun.postRun();
-    return createRunStateFromTree(childRun);
-}
-async function finishTraceRun(runState, options) {
-    const runTree = hydrateRunTree(runState);
-    await runTree.end(options?.outputs !== undefined ? sanitizeTracePayload(options.outputs) : undefined, options?.error, Date.now(), mergeMetadata(options?.metadata));
-    await runTree.patchRun();
-    syncRunState(runState, runTree);
-}
-async function withSerializedRunTree(runState, fn) {
-    const runTree = hydrateRunTree(runState);
+async function readPackageVersion(packageName) {
     try {
-        return await withTraceParentContext(runTree, async () => await (0, traceable_1.withRunTree)(runTree, fn));
+        return extractPackageVersion(hostRequire(`${packageName}/package.json`));
     }
-    finally {
-        syncRunState(runState, runTree);
+    catch {
+    }
+    try {
+        let current = (0, node_path_1.dirname)(hostRequire.resolve(packageName));
+        const { root } = (0, node_path_1.parse)(current);
+        while (current !== root) {
+            const packageJsonPath = (0, node_path_1.join)(current, 'package.json');
+            try {
+                return extractPackageVersion(JSON.parse(await (0, promises_1.readFile)(packageJsonPath, 'utf8')));
+            }
+            catch {
+                current = (0, node_path_1.dirname)(current);
+            }
+        }
+    }
+    catch {
     }
+    return undefined;
+}
+async function getTraceRuntimeVersions() {
+    traceRuntimeVersions ??= (async () => {
+        const [agentsVersion, workflowSdkVersion] = await Promise.all([
+            readPackageVersion('@n8n/agents'),
+            readPackageVersion('@n8n/workflow-sdk'),
+        ]);
+        return {
+            ...(agentsVersion ? { agents_version: agentsVersion } : {}),
+            ...(workflowSdkVersion ? { workflow_sdk_version: workflowSdkVersion } : {}),
+        };
+    })();
+    return await traceRuntimeVersions;
 }
-function buildBaseMetadata(options) {
+async function buildBaseMetadata(options) {
     return {
         thread_id: options.threadId,
+        'langsmith.metadata.thread_id': options.threadId,
         conversation_id: options.conversationId ?? options.threadId,
         message_group_id: options.messageGroupId,
         message_id: options.messageId,
         run_id: options.runId,
+        activation_id: options.runId,
         user_id: options.userId,
-        ...(options.modelId !== undefined
-            ? { model_id: serializeModelIdForTrace(options.modelId) }
-            : {}),
+        'instance_ai.trace_version': OTEL_TRACE_VERSION,
+        ...(await getTraceRuntimeVersions()),
         ...(options.n8nVersion !== undefined ? { n8n_version: options.n8nVersion } : {}),
         ...(options.workflowSdkVersion !== undefined
             ? { workflow_sdk_version: options.workflowSdkVersion }
             : {}),
+        ...(options.modelId !== undefined
+            ? { model_id: (0, trace_payloads_1.serializeModelIdForTrace)(options.modelId) }
+            : {}),
         ...options.metadata,
     };
 }
+function buildDetachedSubAgentMetadata(options, includeSpawnMetadata) {
+    return {
+        agent_role: options.role,
+        agent_id: options.agentId,
+        execution_mode: 'background_subagent',
+        trace_kind: 'background_subagent',
+        task_kind: options.kind,
+        ...(options.taskId ? { task_id: options.taskId } : {}),
+        ...(options.plannedTaskId ? { planned_task_id: options.plannedTaskId } : {}),
+        ...(options.workItemId ? { work_item_id: options.workItemId } : {}),
+        ...(includeSpawnMetadata && options.spawnedByTraceId
+            ? { spawned_by_trace_id: options.spawnedByTraceId }
+            : {}),
+        ...(includeSpawnMetadata && options.spawnedBySpanId
+            ? { spawned_by_span_id: options.spawnedBySpanId }
+            : {}),
+        ...(includeSpawnMetadata && options.spawnedByRunId
+            ? { spawned_by_run_id: options.spawnedByRunId }
+            : {}),
+        ...(includeSpawnMetadata && options.spawnedByAgentId
+            ? { spawned_by_agent_id: options.spawnedByAgentId }
+            : {}),
+        ...(includeSpawnMetadata && options.spawnedByAgentRole
+            ? { spawned_by_agent_role: options.spawnedByAgentRole }
+            : {}),
+        ...(includeSpawnMetadata && options.spawnedByToolCallId
+            ? { spawned_by_tool_call_id: options.spawnedByToolCallId }
+            : {}),
+        subagent_role: options.role,
+    };
+}
+function buildInternalOperationMetadata(operationName) {
+    return {
+        agent_role: operationName,
+        execution_mode: 'internal',
+        trace_kind: 'internal_operation',
+        operation_name: operationName,
+    };
+}
+function createTelemetryFactory(options) {
+    return (telemetryOptions) => {
+        const actorRun = options.getActorRun?.() ?? options.actorRun;
+        const agentRole = telemetryOptions.agentRole;
+        const executionMode = telemetryOptions.executionMode ??
+            (options.traceKind === 'background_subagent' ? 'background_subagent' : 'foreground');
+        const metadata = (0, trace_payloads_1.toTelemetryMetadata)(options.baseMetadata, telemetryOptions.metadata, {
+            agent_role: agentRole,
+            execution_mode: executionMode,
+            trace_kind: options.traceKind,
+            langsmith_trace_id: options.rootRun.traceId,
+            langsmith_root_run_id: options.rootRun.id,
+            langsmith_actor_run_id: actorRun.id,
+        });
+        const functionId = telemetryOptions.functionId ?? (0, trace_labels_1.formatTelemetryFunctionId)(agentRole);
+        if (options.baseTelemetry) {
+            return {
+                ...options.baseTelemetry,
+                functionId,
+                metadata,
+                recordInputs: true,
+                recordOutputs: true,
+                runtimeRootSpanEnabled: false,
+            };
+        }
+        return createLangSmithTelemetryBuilder(options.projectName, options.proxyConfig)
+            .functionId(functionId)
+            .metadata(metadata)
+            .recordInputs(true)
+            .recordOutputs(true)
+            .runtimeRootSpan(false);
+    };
+}
+function createLangSmithTelemetryBuilder(projectName, proxyConfig) {
+    return new agents_1.LangSmithTelemetry({
+        project: projectName,
+        transformExportedSpan: trace_payloads_1.redactLangSmithTelemetrySpan,
+        ...(proxyConfig
+            ? {
+                apiKey: '-',
+                endpoint: proxyConfig.apiUrl,
+                headers: proxyConfig.getAuthHeaders,
+            }
+            : {}),
+    });
+}
+async function createProductOtelRuntime(projectName, proxyConfig) {
+    const telemetry = await createLangSmithTelemetryBuilder(projectName, proxyConfig)
+        .functionId('instance-ai.product')
+        .metadata({})
+        .recordInputs(true)
+        .recordOutputs(true)
+        .build();
+    return {
+        telemetry,
+        spans: new Map(),
+        contexts: new Map(),
+        shutdown: false,
+    };
+}
+function createProductTraceContext(options) {
+    return createTraceContext(options.projectName, options.traceKind, options.rootRun, options.actorRun, options.otelRuntime, options.proxyConfig, createTelemetryFactory({
+        projectName: options.projectName,
+        traceKind: options.traceKind,
+        rootRun: options.rootRun,
+        actorRun: options.actorRun,
+        ...(options.getActorRun ? { getActorRun: options.getActorRun } : {}),
+        baseMetadata: options.baseMetadata,
+        baseTelemetry: options.otelRuntime.telemetry,
+        ...(options.proxyConfig ? { proxyConfig: options.proxyConfig } : {}),
+    }));
+}
 async function createInstanceAiTraceContext(options) {
     if (!isLangSmithTracingEnabled(!!options.proxyConfig)) {
         return undefined;
     }
-    ensureLangSmithTracingEnv();
-    const client = options.proxyConfig ? getOrCreateProxyClient(options.proxyConfig) : undefined;
     const projectName = options.projectName ?? DEFAULT_PROJECT_NAME;
-    const baseMetadata = buildBaseMetadata(options);
+    const baseMetadata = await buildBaseMetadata(options);
     const createTraceRuns = async () => {
-        const messageRun = await createRun({
+        const otelRuntime = await createProductOtelRuntime(projectName, options.proxyConfig);
+        const traceContextRef = {};
+        const messageRun = startProductSpan(otelRuntime, {
             projectName,
-            name: 'message_turn',
+            name: 'turn',
+            canonicalName: 'instance-ai.message_turn',
+            runType: 'chain',
             tags: ['message-turn'],
-            metadata: mergeMetadata(baseMetadata, { agent_role: 'message_turn' }),
+            metadata: mergeMetadata(baseMetadata, {
+                agent_role: 'message_turn',
+                execution_mode: 'foreground',
+                trace_kind: 'message_turn',
+            }),
             inputs: options.input,
-            client,
+            root: true,
         });
-        const orchestratorRun = await createChildRun(messageRun, {
-            name: 'orchestrator',
-            tags: ['orchestrator'],
-            metadata: mergeMetadata(baseMetadata, { agent_role: 'orchestrator' }),
-            inputs: options.input,
+        const tracing = createProductTraceContext({
+            projectName,
+            traceKind: 'message_turn',
+            rootRun: messageRun,
+            actorRun: messageRun,
+            otelRuntime,
+            baseMetadata,
+            getActorRun: () => traceContextRef.current?.actorRun ?? messageRun,
+            ...(options.proxyConfig ? { proxyConfig: options.proxyConfig } : {}),
         });
-        return createTraceContext(projectName, 'message_turn', messageRun, orchestratorRun, options.proxyConfig?.getAuthHeaders);
+        traceContextRef.current = tracing;
+        return tracing;
     };
-    if (options.proxyConfig) {
-        const headers = await options.proxyConfig.getAuthHeaders();
-        return await proxyHeaderStore.run(headers, createTraceRuns);
+    try {
+        return await withProxyHeaders(options.proxyConfig, createTraceRuns);
+    }
+    catch {
+        return undefined;
     }
-    return await createTraceRuns();
 }
 async function continueInstanceAiTraceContext(existingContext, options) {
-    const baseMetadata = buildBaseMetadata(options);
+    const proxyConfig = options.proxyConfig ?? existingContext?.proxyConfig;
+    if (!existingContext && !isLangSmithTracingEnabled(!!proxyConfig)) {
+        return undefined;
+    }
+    if (existingContext?.rootRun.traceId === 'stub' && !isLangSmithTracingEnabled(!!proxyConfig)) {
+        return existingContext;
+    }
+    const baseMetadata = await buildBaseMetadata(options);
+    const projectName = existingContext?.projectName ?? options.projectName ?? DEFAULT_PROJECT_NAME;
+    const continuedMetadata = existingContext && existingContext.rootRun.traceId !== 'stub'
+        ? {
+            continued_from_trace_id: existingContext.rootRun.otelTraceId ?? existingContext.rootRun.traceId,
+            continued_from_run_id: existingContext.rootRun.id,
+            resumed_from_trace_id: existingContext.rootRun.otelTraceId ?? existingContext.rootRun.traceId,
+            ...(existingContext.actorRun.otelSpanId
+                ? { resumed_from_span_id: existingContext.actorRun.otelSpanId }
+                : {}),
+            resumed_from_activation_id: existingContext.actorRun.id,
+        }
+        : {};
     const createContinuation = async () => {
-        const orchestratorRun = await createChildRun(existingContext.messageRun, {
-            name: 'orchestrator',
-            tags: ['orchestrator'],
-            metadata: mergeMetadata(baseMetadata, { agent_role: 'orchestrator' }),
+        const otelRuntime = await createProductOtelRuntime(projectName, proxyConfig);
+        const rootRun = startProductSpan(otelRuntime, {
+            projectName,
+            name: `resume: ${(0, trace_labels_1.formatResumeReasonLabel)(options.metadata?.resume_reason)}`,
+            canonicalName: 'instance-ai.orchestrator_resume',
+            runType: 'chain',
+            tags: ['orchestrator-resume'],
+            metadata: mergeMetadata(baseMetadata, {
+                agent_role: 'orchestrator_resume',
+                execution_mode: 'resume',
+                trace_kind: 'orchestrator_resume',
+                ...continuedMetadata,
+            }),
             inputs: options.input,
+            root: true,
+        });
+        const orchestratorRun = startProductSpan(otelRuntime, {
+            projectName,
+            name: 'agent: orchestrator',
+            canonicalName: 'instance-ai.agent.orchestrator',
+            runType: 'chain',
+            tags: ['orchestrator', 'resume'],
+            metadata: mergeMetadata(baseMetadata, {
+                agent_role: 'orchestrator',
+                execution_mode: 'resume',
+                trace_kind: 'orchestrator_resume',
+                ...continuedMetadata,
+            }),
+            inputs: options.input,
+            parentRun: rootRun,
+        });
+        return createProductTraceContext({
+            projectName,
+            traceKind: 'orchestrator_resume',
+            rootRun,
+            actorRun: orchestratorRun,
+            otelRuntime,
+            baseMetadata,
+            ...(proxyConfig ? { proxyConfig } : {}),
         });
-        return createTraceContext(existingContext.projectName, 'message_turn', existingContext.rootRun, orchestratorRun, options.proxyConfig?.getAuthHeaders);
     };
-    if (options.proxyConfig) {
-        const headers = await options.proxyConfig.getAuthHeaders();
-        return await proxyHeaderStore.run(headers, createContinuation);
+    try {
+        return await withProxyHeaders(proxyConfig, createContinuation);
+    }
+    catch {
+        return undefined;
     }
-    return await createContinuation();
 }
 async function createDetachedSubAgentTraceContext(options) {
     if (!isLangSmithTracingEnabled(!!options.proxyConfig)) {
         return undefined;
     }
-    ensureLangSmithTracingEnv();
-    const client = options.proxyConfig ? getOrCreateProxyClient(options.proxyConfig) : undefined;
     const projectName = options.projectName ?? DEFAULT_PROJECT_NAME;
-    const baseMetadata = buildBaseMetadata(options);
+    const baseMetadata = await buildBaseMetadata(options);
     const createDetachedRuns = async () => {
-        const rootRun = await createRun({
+        const otelRuntime = await createProductOtelRuntime(projectName, options.proxyConfig);
+        const rootMetadata = buildDetachedSubAgentMetadata(options, true);
+        const actorMetadata = buildDetachedSubAgentMetadata(options, false);
+        const rootRun = startProductSpan(otelRuntime, {
             projectName,
-            name: `subagent:${options.role}`,
+            name: `background task: ${(0, trace_labels_1.formatAgentRoleLabel)(options.role)}`,
+            canonicalName: 'instance-ai.background_subagent',
+            runType: 'chain',
             tags: normalizeTags(['sub-agent', 'background'], options.plannedTaskId ? ['planned'] : undefined),
-            metadata: mergeMetadata(baseMetadata, {
-                agent_role: options.role,
-                agent_id: options.agentId,
-                task_kind: options.kind,
-                ...(options.taskId ? { task_id: options.taskId } : {}),
-                ...(options.plannedTaskId ? { planned_task_id: options.plannedTaskId } : {}),
-                ...(options.workItemId ? { work_item_id: options.workItemId } : {}),
-                ...(options.spawnedByTraceId ? { spawned_by_trace_id: options.spawnedByTraceId } : {}),
-                ...(options.spawnedByRunId ? { spawned_by_run_id: options.spawnedByRunId } : {}),
-                ...(options.spawnedByAgentId ? { spawned_by_agent_id: options.spawnedByAgentId } : {}),
-            }),
+            metadata: mergeMetadata(baseMetadata, rootMetadata),
+            inputs: options.input,
+            root: true,
+        });
+        const actorRun = startProductSpan(otelRuntime, {
+            projectName,
+            name: `agent: ${(0, trace_labels_1.formatAgentRoleLabel)(options.role)}`,
+            canonicalName: `instance-ai.agent.${options.role}`,
+            runType: 'chain',
+            tags: normalizeTags(['sub-agent', 'background'], options.plannedTaskId ? ['planned'] : undefined),
+            metadata: mergeMetadata(baseMetadata, actorMetadata),
             inputs: options.input,
-            client,
+            parentRun: rootRun,
+        });
+        return createProductTraceContext({
+            projectName,
+            traceKind: 'background_subagent',
+            rootRun,
+            actorRun,
+            otelRuntime,
+            baseMetadata: mergeMetadata(baseMetadata, rootMetadata) ?? baseMetadata,
+            ...(options.proxyConfig ? { proxyConfig: options.proxyConfig } : {}),
         });
-        return createTraceContext(projectName, 'detached_subagent', rootRun, rootRun, options.proxyConfig?.getAuthHeaders);
     };
-    if (options.proxyConfig) {
-        const headers = await options.proxyConfig.getAuthHeaders();
-        return await proxyHeaderStore.run(headers, createDetachedRuns);
+    try {
+        return await withProxyHeaders(options.proxyConfig, createDetachedRuns);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function createInternalOperationTraceContext(options) {
+    if (!isInternalOperationTracingEnabled() || !isLangSmithTracingEnabled(!!options.proxyConfig)) {
+        return undefined;
+    }
+    const projectName = options.projectName ?? DEFAULT_PROJECT_NAME;
+    const baseMetadata = await buildBaseMetadata({
+        ...options,
+        messageId: options.messageId ?? `internal:${options.operationName}:${options.runId}`,
+        metadata: mergeMetadata(options.metadata, {
+            operation_name: options.operationName,
+        }),
+    });
+    const createInternalRuns = async () => {
+        const otelRuntime = await createProductOtelRuntime(projectName, options.proxyConfig);
+        const internalMetadata = buildInternalOperationMetadata(options.operationName);
+        const rootRun = startProductSpan(otelRuntime, {
+            projectName,
+            name: `internal: ${(0, trace_labels_1.formatInternalOperationLabel)(options.operationName)}`,
+            canonicalName: `instance-ai.internal.${options.operationName}`,
+            runType: 'chain',
+            tags: ['internal-operation'],
+            metadata: mergeMetadata(baseMetadata, internalMetadata),
+            inputs: options.input,
+            root: true,
+        });
+        return createProductTraceContext({
+            projectName,
+            traceKind: 'internal_operation',
+            rootRun,
+            actorRun: rootRun,
+            otelRuntime,
+            baseMetadata: mergeMetadata(baseMetadata, internalMetadata) ?? baseMetadata,
+            ...(options.proxyConfig ? { proxyConfig: options.proxyConfig } : {}),
+        });
+    };
+    try {
+        return await withProxyHeaders(options.proxyConfig, createInternalRuns);
+    }
+    catch {
+        return undefined;
     }
-    return await createDetachedRuns();
 }
 //# sourceMappingURL=langsmith-tracing.js.map