@n8n/instance-ai 1.0.0

package/dist/tracing/langsmith-tracing.js

@@ -0,0 +1,810 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeModelIdForTrace = serializeModelIdForTrace;
+exports.getTraceParentRun = getTraceParentRun;
+exports.setTraceParentOverride = setTraceParentOverride;
+exports.mergeCurrentTraceMetadata = mergeCurrentTraceMetadata;
+exports.mergeTraceRunInputs = mergeTraceRunInputs;
+exports.buildAgentTraceInputs = buildAgentTraceInputs;
+exports.withTraceParentContext = withTraceParentContext;
+exports.withCurrentTraceSpan = withCurrentTraceSpan;
+exports.createInstanceAiTraceContext = createInstanceAiTraceContext;
+exports.continueInstanceAiTraceContext = continueInstanceAiTraceContext;
+exports.createDetachedSubAgentTraceContext = createDetachedSubAgentTraceContext;
+const tools_1 = require("@mastra/core/tools");
+const langsmith_1 = require("langsmith");
+const traceable_1 = require("langsmith/traceable");
+const node_async_hooks_1 = require("node:async_hooks");
+const stream_helpers_1 = require("../utils/stream-helpers");
+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 proxyHeaderStore = new node_async_hooks_1.AsyncLocalStorage();
+const traceClients = new Map();
+let cachedProxyClient = null;
+function getOrCreateProxyClient(proxyConfig) {
+    if (cachedProxyClient?.apiUrl === proxyConfig.apiUrl)
+        return cachedProxyClient.client;
+    const proxyFetch = async (input, init) => {
+        const contextHeaders = proxyHeaderStore.getStore();
+        if (contextHeaders) {
+            const merged = new Headers(init?.headers);
+            for (const [key, value] of Object.entries(contextHeaders)) {
+                merged.set(key, value);
+            }
+            return await globalThis.fetch(input, { ...init, headers: merged });
+        }
+        return await globalThis.fetch(input, init);
+    };
+    const client = new langsmith_1.Client({
+        apiUrl: proxyConfig.apiUrl,
+        apiKey: '-',
+        autoBatchTracing: false,
+        fetchImplementation: proxyFetch,
+    });
+    cachedProxyClient = { client, apiUrl: proxyConfig.apiUrl };
+    return client;
+}
+function isInternalStateTool(toolId) {
+    return toolId === 'updateWorkingMemory';
+}
+function isLangSmithTracingEnabled(proxyAvailable) {
+    const tracingFlag = process.env.LANGCHAIN_TRACING_V2 ?? process.env.LANGSMITH_TRACING ?? undefined;
+    if (tracingFlag?.toLowerCase() === 'false') {
+        return false;
+    }
+    if (proxyAvailable) {
+        return true;
+    }
+    return Boolean(process.env.LANGSMITH_API_KEY ??
+        process.env.LANGCHAIN_API_KEY ??
+        process.env.LANGSMITH_ENDPOINT ??
+        process.env.LANGCHAIN_ENDPOINT ??
+        tracingFlag?.toLowerCase() === 'true');
+}
+function ensureLangSmithTracingEnv() {
+    process.env.LANGCHAIN_TRACING_V2 ??= 'true';
+    process.env.LANGSMITH_TRACING ??= 'true';
+}
+function normalizeErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function normalizeTags(...tagGroups) {
+    const merged = tagGroups.flatMap((group) => group ?? []).filter(Boolean);
+    if (merged.length === 0)
+        return undefined;
+    return [...new Set(merged)];
+}
+function mergeMetadata(...records) {
+    const merged = {};
+    for (const record of records) {
+        if (!record)
+            continue;
+        for (const [key, value] of Object.entries(record)) {
+            if (value !== undefined) {
+                merged[key] =
+                    key === 'model_id' ? serializeModelIdForTrace(value) : 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 getTraceParentRun() {
+    const overrideRun = traceParentOverrideStorage.getStore()?.current;
+    if (overrideRun) {
+        return overrideRun;
+    }
+    try {
+        return (0, traceable_1.getCurrentRunTree)() ?? undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function setTraceParentOverride(parentRun) {
+    const store = traceParentOverrideStorage.getStore();
+    if (store) {
+        store.current = parentRun ?? null;
+    }
+    else if (parentRun) {
+        traceParentOverrideStorage.enterWith({ current: parentRun });
+    }
+}
+function mergeCurrentTraceMetadata(metadata) {
+    const currentRun = getTraceParentRun();
+    if (!currentRun) {
+        return;
+    }
+    const mergedMetadata = mergeRunTreeMetadata(currentRun.metadata, metadata);
+    if (mergedMetadata) {
+        currentRun.metadata = mergedMetadata;
+    }
+}
+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;
+    }
+}
+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();
+}
+async function withCurrentTraceSpan(options, fn) {
+    const parentRun = getTraceParentRun();
+    if (!parentRun) {
+        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, {
+            ...(options.processOutputs ? { outputs: options.processOutputs(result) } : {}),
+            metadata: { final_status: 'completed' },
+        });
+        return result;
+    }
+    catch (error) {
+        await finishRunTree(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 };
+    }
+    return {
+        tool_name: toolName,
+        ...(typeof suspendPayload.requestId === 'string'
+            ? { request_id: suspendPayload.requestId }
+            : {}),
+        ...(typeof suspendPayload.inputType === 'string'
+            ? { input_type: suspendPayload.inputType }
+            : {}),
+        ...(typeof suspendPayload.severity === 'string' ? { severity: suspendPayload.severity } : {}),
+    };
+}
+function resolveActorParentRun(parentRun) {
+    let current = parentRun;
+    while (current) {
+        if (current.run_type !== 'llm' && current.run_type !== 'tool') {
+            return current;
+        }
+        current = current.parent_run;
+    }
+    return parentRun;
+}
+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 },
+    });
+    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'
+        ? {
+            ...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);
+                },
+            },
+        }
+        : 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' },
+        });
+        throw error;
+    }
+}
+async function traceToolExecute(tool, options, input, context) {
+    const parentRun = getTraceParentRun();
+    if (!parentRun || typeof tool.execute !== 'function') {
+        return await tool.execute?.(input, context);
+    }
+    const actorParentRun = isInternalStateTool(tool.id)
+        ? resolveActorParentRun(parentRun)
+        : parentRun;
+    const internalStateRun = isInternalStateTool(tool.id)
+        ? await postChildRun(actorParentRun, {
+            name: 'internal_state',
+            runType: 'chain',
+            tags: ['internal', 'memory'],
+            metadata: {
+                internal_state: true,
+                tool_name: tool.id,
+            },
+            inputs: { tool_name: tool.id },
+        })
+        : undefined;
+    const toolParentRun = internalStateRun ?? parentRun;
+    const toolRun = await postChildRun(toolParentRun, {
+        name: `tool:${tool.id}`,
+        runType: 'tool',
+        tags: normalizeTags(['tool'], isInternalStateTool(tool.id) ? ['internal', 'memory'] : undefined, options?.tags),
+        metadata: mergeMetadata(options?.metadata, {
+            tool_name: tool.id,
+            ...(isInternalStateTool(tool.id) ? { memory_tool: true } : {}),
+            ...(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' },
+        });
+        if (internalStateRun) {
+            await finishRunTree(internalStateRun, {
+                outputs: { tool_name: tool.id },
+                metadata: { final_status: 'completed', internal_state: true },
+            });
+        }
+        return result;
+    }
+    catch (error) {
+        await finishRunTree(toolRun, {
+            error: normalizeErrorMessage(error),
+            metadata: { final_status: 'error' },
+        });
+        if (internalStateRun) {
+            await finishRunTree(internalStateRun, {
+                error: normalizeErrorMessage(error),
+                metadata: { final_status: 'error', internal_state: true },
+            });
+        }
+        throw error;
+    }
+}
+function createTraceContext(projectName, traceKind, rootRun, actorRun, proxyHeaders) {
+    const withProxy = async (fn) => proxyHeaders ? await proxyHeaderStore.run(proxyHeaders, fn) : await 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));
+    const finishRun = async (run, finishOptions) => {
+        await withProxy(async () => await finishTraceRun(run, finishOptions));
+        if (!run.parentRunId) {
+            traceClients.delete(run.traceId);
+        }
+    };
+    const failRun = async (run, error, metadata) => {
+        await withProxy(async () => await finishTraceRun(run, {
+            error: normalizeErrorMessage(error),
+            metadata,
+        }));
+        if (!run.parentRunId) {
+            traceClients.delete(run.traceId);
+        }
+    };
+    return {
+        projectName,
+        traceKind,
+        rootRun,
+        actorRun,
+        messageRun: rootRun,
+        orchestratorRun: actorRun,
+        startChildRun,
+        withRunTree,
+        finishRun,
+        failRun,
+        toHeaders: (run) => hydrateRunTree(run).toHeaders(),
+        wrapTools: (tools, traceOptions) => wrapTools(tools, traceOptions),
+    };
+}
+function createRunStateFromTree(tree) {
+    const parentRunId = tree.parent_run?.id ?? tree.parent_run_id;
+    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 } : {}),
+    };
+}
+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 } : {}),
+    });
+}
+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 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;
+    }
+    return wrapped;
+}
+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),
+        ...(options.client ? { client: options.client } : {}),
+    });
+    await runTree.postRun();
+    if (options.client) {
+        traceClients.set(runTree.trace_id, options.client);
+    }
+    return createRunStateFromTree(runTree);
+}
+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);
+    try {
+        return await withTraceParentContext(runTree, async () => await (0, traceable_1.withRunTree)(runTree, fn));
+    }
+    finally {
+        syncRunState(runState, runTree);
+    }
+}
+function buildBaseMetadata(options) {
+    return {
+        thread_id: options.threadId,
+        conversation_id: options.conversationId ?? options.threadId,
+        message_group_id: options.messageGroupId,
+        message_id: options.messageId,
+        run_id: options.runId,
+        user_id: options.userId,
+        ...(options.modelId !== undefined
+            ? { model_id: serializeModelIdForTrace(options.modelId) }
+            : {}),
+        ...options.metadata,
+    };
+}
+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 createTraceRuns = async () => {
+        const messageRun = await createRun({
+            projectName,
+            name: 'message_turn',
+            tags: ['message-turn'],
+            metadata: mergeMetadata(baseMetadata, { agent_role: 'message_turn' }),
+            inputs: options.input,
+            client,
+        });
+        const orchestratorRun = await createChildRun(messageRun, {
+            name: 'orchestrator',
+            tags: ['orchestrator'],
+            metadata: mergeMetadata(baseMetadata, { agent_role: 'orchestrator' }),
+            inputs: options.input,
+        });
+        return createTraceContext(projectName, 'message_turn', messageRun, orchestratorRun, options.proxyConfig?.headers);
+    };
+    if (options.proxyConfig) {
+        return await proxyHeaderStore.run(options.proxyConfig.headers, createTraceRuns);
+    }
+    return await createTraceRuns();
+}
+async function continueInstanceAiTraceContext(existingContext, options) {
+    const baseMetadata = buildBaseMetadata(options);
+    const createContinuation = async () => {
+        const orchestratorRun = await createChildRun(existingContext.messageRun, {
+            name: 'orchestrator',
+            tags: ['orchestrator'],
+            metadata: mergeMetadata(baseMetadata, { agent_role: 'orchestrator' }),
+            inputs: options.input,
+        });
+        return createTraceContext(existingContext.projectName, 'message_turn', existingContext.rootRun, orchestratorRun, options.proxyConfig?.headers);
+    };
+    if (options.proxyConfig) {
+        return await proxyHeaderStore.run(options.proxyConfig.headers, createContinuation);
+    }
+    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 createDetachedRuns = async () => {
+        const rootRun = await createRun({
+            projectName,
+            name: `subagent:${options.role}`,
+            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 } : {}),
+            }),
+            inputs: options.input,
+            client,
+        });
+        return createTraceContext(projectName, 'detached_subagent', rootRun, rootRun, options.proxyConfig?.headers);
+    };
+    if (options.proxyConfig) {
+        return await proxyHeaderStore.run(options.proxyConfig.headers, createDetachedRuns);
+    }
+    return await createDetachedRuns();
+}
+//# sourceMappingURL=langsmith-tracing.js.map