@n8n/instance-ai 1.7.0 → 1.8.0

package/dist/runtime/resumable-stream-executor.js

@@ -1,1331 +1,129 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createLlmStepTraceHooks = createLlmStepTraceHooks;
+exports.normalizeStreamSource = normalizeStreamSource;
 exports.executeResumableStream = executeResumableStream;
 const map_chunk_1 = require("../stream/map-chunk");
 const work_summary_accumulator_1 = require("../stream/work-summary-accumulator");
-const langsmith_tracing_1 = require("../tracing/langsmith-tracing");
 const stream_helpers_1 = require("../utils/stream-helpers");
-const MAX_TRACE_STRING_LENGTH = 2_000;
-const MAX_TRACE_ARRAY_ITEMS = 20;
-const MAX_TRACE_OBJECT_KEYS = 20;
-const SYNTHETIC_TOOL_TRACE_NAMES = new Set();
 function isRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
-function getFiniteNumber(value) {
-    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+function isAsyncIterable(value) {
+    return (value !== null &&
+        typeof value === 'object' &&
+        typeof Reflect.get(value, Symbol.asyncIterator) === 'function');
 }
-function dedupeTags(tags) {
-    const values = tags.filter((tag) => Boolean(tag));
-    return values.length > 0 ? [...new Set(values)] : undefined;
+function isReadableStream(value) {
+    return (value !== null &&
+        typeof value === 'object' &&
+        typeof Reflect.get(value, 'getReader') === 'function');
 }
-function truncateTraceString(value) {
-    if (value.length <= MAX_TRACE_STRING_LENGTH) {
-        return value;
-    }
-    return `${value.slice(0, MAX_TRACE_STRING_LENGTH)}…`;
-}
-function sanitizeTraceValue(value, depth = 0) {
-    if (value === null || value === undefined) {
-        return value;
-    }
-    if (typeof value === 'string') {
-        return truncateTraceString(value);
-    }
-    if (typeof value === 'number' || typeof value === 'boolean') {
-        return value;
-    }
-    if (typeof value === 'bigint') {
-        return value.toString();
-    }
-    if (value instanceof Date) {
-        return value.toISOString();
-    }
-    if (Array.isArray(value)) {
-        if (depth >= 3) {
-            return `[array(${value.length})]`;
-        }
-        return value
-            .slice(0, MAX_TRACE_ARRAY_ITEMS)
-            .map((entry) => sanitizeTraceValue(entry, depth + 1));
-    }
-    if (isRecord(value)) {
-        if (depth >= 3) {
-            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;
-    }
-    return truncateTraceString(Object.prototype.toString.call(value));
-}
-function sanitizeTracePayload(value) {
-    if (!isRecord(value)) {
-        return { value: sanitizeTraceValue(value) };
-    }
-    const sanitized = {};
-    for (const [key, entryValue] of Object.entries(value)) {
-        sanitized[key] = sanitizeTraceValue(entryValue);
-    }
-    return sanitized;
-}
-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 (isRecord(modelId) && typeof modelId.id === 'string') {
-        return normalizeModelMetadata(modelId.id);
-    }
-    return {};
-}
-function formatLlmRunName(model) {
-    if (model.provider && model.modelName) {
-        return `llm:${model.provider}/${model.modelName}`;
-    }
-    if (model.modelName) {
-        return `llm:${model.modelName}`;
-    }
-    return 'llm';
-}
-function parseMaybeJson(value) {
-    if (typeof value !== 'string') {
-        return value;
-    }
-    try {
-        return JSON.parse(value);
-    }
-    catch {
-        return value;
-    }
-}
-function buildLlmInputPayload(request) {
-    const parsedRequest = isRecord(request) && 'body' in request ? parseMaybeJson(request.body) : request;
-    if (!isRecord(parsedRequest)) {
-        return { request: parsedRequest };
-    }
-    const selected = {};
-    for (const key of [
-        'messages',
-        'prompt',
-        'input',
-        'system',
-        'model',
-        'temperature',
-        'tools',
-        'tool_choice',
-        'toolChoice',
-        'stop',
-        'stop_sequences',
-        'stopSequences',
-        'max_tokens',
-        'max_output_tokens',
-        'max_completion_tokens',
-    ]) {
-        if (parsedRequest[key] !== undefined) {
-            selected[key] =
-                key === 'messages' && Array.isArray(parsedRequest[key])
-                    ? (normalizeTraceMessages(parsedRequest[key]) ?? [])
-                    : parsedRequest[key];
-        }
-    }
-    if (Object.keys(selected).length > 0) {
-        return selected;
-    }
-    return { request: parsedRequest };
-}
-function extractInputTokenCount(usage) {
-    if (isRecord(usage.inputTokenDetails)) {
-        return (getFiniteNumber(usage.inputTokenDetails.noCacheTokens) ??
-            getFiniteNumber(usage.inputTokenDetails.no_cache_tokens) ??
-            undefined);
-    }
-    if (isRecord(usage.inputTokens)) {
-        return (getFiniteNumber(usage.inputTokens.noCache) ??
-            getFiniteNumber(usage.inputTokens.no_cache) ??
-            getFiniteNumber(usage.inputTokens.total) ??
-            undefined);
-    }
-    return getFiniteNumber(usage.inputTokens) ?? getFiniteNumber(usage.promptTokens) ?? undefined;
-}
-function extractOutputTokenCount(usage) {
-    if (isRecord(usage.outputTokens)) {
-        return (getFiniteNumber(usage.outputTokens.total) ??
-            getFiniteNumber(usage.outputTokens.text) ??
-            undefined);
-    }
-    return (getFiniteNumber(usage.outputTokens) ?? getFiniteNumber(usage.completionTokens) ?? undefined);
-}
-function extractReasoningTokenCount(usage) {
-    if (isRecord(usage.outputTokens)) {
-        return getFiniteNumber(usage.outputTokens.reasoning) ?? undefined;
-    }
-    return getFiniteNumber(usage.reasoningTokens) ?? undefined;
-}
-function extractCacheCreationTokens(raw) {
-    if (!isRecord(raw))
-        return undefined;
-    if (isRecord(raw.inputTokenDetails)) {
-        return (getFiniteNumber(raw.inputTokenDetails.cacheWriteTokens) ??
-            getFiniteNumber(raw.inputTokenDetails.cache_write_tokens) ??
-            undefined);
-    }
-    if (isRecord(raw.inputTokens)) {
-        return (getFiniteNumber(raw.inputTokens.cacheWrite) ??
-            getFiniteNumber(raw.inputTokens.cache_write) ??
-            getFiniteNumber(raw.inputTokens.cacheWriteTokens) ??
-            getFiniteNumber(raw.inputTokens.cache_write_tokens) ??
-            undefined);
-    }
-    return (getFiniteNumber(raw.cacheCreationInputTokens) ??
-        getFiniteNumber(raw.cache_creation_input_tokens) ??
-        getFiniteNumber(raw.input_cache_write) ??
-        undefined);
-}
-function extractCacheReadTokens(raw) {
-    if (!isRecord(raw))
-        return undefined;
-    if (isRecord(raw.inputTokenDetails)) {
-        return (getFiniteNumber(raw.inputTokenDetails.cacheReadTokens) ??
-            getFiniteNumber(raw.inputTokenDetails.cache_read_tokens) ??
-            undefined);
-    }
-    if (isRecord(raw.inputTokens)) {
-        return (getFiniteNumber(raw.inputTokens.cacheRead) ??
-            getFiniteNumber(raw.inputTokens.cache_read) ??
-            getFiniteNumber(raw.inputTokens.cacheReadTokens) ??
-            getFiniteNumber(raw.inputTokens.cache_read_tokens) ??
-            undefined);
-    }
-    return (getFiniteNumber(raw.cachedInputTokens) ??
-        getFiniteNumber(raw.cacheRead) ??
-        getFiniteNumber(raw.cache_read_input_tokens) ??
-        getFiniteNumber(raw.input_cache_read) ??
-        undefined);
-}
-function extractUsageFromProviderMetadata(providerMetadata) {
-    if (!isRecord(providerMetadata)) {
-        return undefined;
-    }
-    if (isRecord(providerMetadata.usage)) {
-        return providerMetadata.usage;
-    }
-    for (const value of Object.values(providerMetadata)) {
-        if (!isRecord(value)) {
-            continue;
-        }
-        if (isRecord(value.usage)) {
-            return value.usage;
-        }
-    }
-    return undefined;
-}
-function mergeUsageMetadata(primary, fallback) {
-    if (!primary) {
-        return fallback;
-    }
-    if (!fallback) {
-        return primary;
-    }
-    const merged = { ...primary };
-    for (const key of ['input_tokens', 'output_tokens', 'total_tokens']) {
-        if (merged[key] === undefined && fallback[key] !== undefined) {
-            merged[key] = fallback[key];
-        }
-    }
-    const mergedInputTokenDetails = {};
-    if (isRecord(fallback.input_token_details)) {
-        Object.assign(mergedInputTokenDetails, fallback.input_token_details);
-    }
-    if (isRecord(primary.input_token_details)) {
-        Object.assign(mergedInputTokenDetails, primary.input_token_details);
-    }
-    if (Object.keys(mergedInputTokenDetails).length > 0) {
-        merged.input_token_details = mergedInputTokenDetails;
-    }
-    const mergedOutputTokenDetails = {};
-    if (isRecord(fallback.output_token_details)) {
-        Object.assign(mergedOutputTokenDetails, fallback.output_token_details);
-    }
-    if (isRecord(primary.output_token_details)) {
-        Object.assign(mergedOutputTokenDetails, primary.output_token_details);
-    }
-    if (Object.keys(mergedOutputTokenDetails).length > 0) {
-        merged.output_token_details = mergedOutputTokenDetails;
-    }
-    return merged;
-}
-function buildUsageMetadata(usage, providerMetadata) {
-    const usageRecord = isRecord(usage) ? usage : undefined;
-    const providerUsage = extractUsageFromProviderMetadata(providerMetadata);
-    if (!usageRecord && !providerUsage) {
-        return undefined;
-    }
-    const inputTokens = (usageRecord ? extractInputTokenCount(usageRecord) : undefined) ??
-        (providerUsage ? extractInputTokenCount(providerUsage) : undefined);
-    const outputTokens = (usageRecord ? extractOutputTokenCount(usageRecord) : undefined) ??
-        (providerUsage ? extractOutputTokenCount(providerUsage) : undefined);
-    const totalTokens = inputTokens !== undefined || outputTokens !== undefined
-        ? (inputTokens ?? 0) + (outputTokens ?? 0)
-        : ((usageRecord ? getFiniteNumber(usageRecord.totalTokens) : undefined) ??
-            (providerUsage ? getFiniteNumber(providerUsage.totalTokens) : undefined));
-    const cachedInputTokens = (usageRecord ? getFiniteNumber(usageRecord.cachedInputTokens) : undefined) ??
-        (usageRecord ? extractCacheReadTokens(usageRecord) : undefined) ??
-        (usageRecord ? extractCacheReadTokens(usageRecord.raw) : undefined) ??
-        (providerUsage ? extractCacheReadTokens(providerUsage) : undefined) ??
-        (providerUsage ? extractCacheReadTokens(providerUsage.raw) : undefined);
-    const cacheCreationTokens = (usageRecord ? extractCacheCreationTokens(usageRecord) : undefined) ??
-        (usageRecord ? extractCacheCreationTokens(usageRecord.raw) : undefined) ??
-        (providerUsage ? extractCacheCreationTokens(providerUsage) : undefined) ??
-        (providerUsage ? extractCacheCreationTokens(providerUsage.raw) : undefined);
-    const reasoningTokens = (usageRecord ? extractReasoningTokenCount(usageRecord) : undefined) ??
-        (providerUsage ? extractReasoningTokenCount(providerUsage) : undefined);
-    const usageMetadata = {};
-    if (inputTokens !== undefined) {
-        usageMetadata.input_tokens = inputTokens;
-    }
-    if (outputTokens !== undefined) {
-        usageMetadata.output_tokens = outputTokens;
-    }
-    if (totalTokens !== undefined) {
-        usageMetadata.total_tokens = totalTokens;
-    }
-    const inputTokenDetails = {};
-    if (cachedInputTokens !== undefined) {
-        inputTokenDetails.cache_read = cachedInputTokens;
-    }
-    if (cacheCreationTokens !== undefined) {
-        inputTokenDetails.cache_creation = cacheCreationTokens;
-    }
-    if (Object.keys(inputTokenDetails).length > 0) {
-        usageMetadata.input_token_details = inputTokenDetails;
-    }
-    if (reasoningTokens !== undefined) {
-        usageMetadata.output_token_details = { reasoning: reasoningTokens };
-    }
-    return Object.keys(usageMetadata).length > 0
-        ? mergeUsageMetadata(usageMetadata, providerUsage ? buildUsageMetadata(providerUsage) : undefined)
-        : providerUsage
-            ? buildUsageMetadata(providerUsage)
-            : undefined;
-}
-function summarizeUsageLikeValue(value) {
-    if (!isRecord(value)) {
-        return undefined;
-    }
-    const summary = {};
-    for (const key of [
-        'promptTokens',
-        'completionTokens',
-        'totalTokens',
-        'cachedInputTokens',
-        'reasoningTokens',
-        'inputTokens',
-        'outputTokens',
-        'inputTokenDetails',
-        'outputTokenDetails',
-        'input_tokens',
-        'output_tokens',
-        'cache_creation_input_tokens',
-        'cache_read_input_tokens',
-        'cacheCreationInputTokens',
-        'cacheReadInputTokens',
-        'iterations',
-    ]) {
-        if (value[key] !== undefined) {
-            summary[key] = sanitizeTraceValue(value[key]);
-        }
-    }
-    for (const nestedKey of ['usage', 'raw', 'rawUsage', 'anthropic', 'openai']) {
-        const nestedSummary = summarizeUsageLikeValue(value[nestedKey]);
-        if (nestedSummary) {
-            summary[nestedKey] = nestedSummary;
-        }
-    }
-    return Object.keys(summary).length > 0 ? summary : undefined;
+function isResumableStreamSource(value) {
+    return isRecord(value) && isAsyncIterable(value.fullStream);
 }
-function buildLlmUsageDebug(record, stepResult) {
-    const usageDebug = {};
-    const stepUsage = summarizeUsageLikeValue(stepResult?.usage);
-    if (stepUsage) {
-        usageDebug.step_usage = stepUsage;
-    }
-    const recordUsage = summarizeUsageLikeValue(record.usage);
-    if (recordUsage) {
-        usageDebug.record_usage = recordUsage;
-    }
-    const streamUsage = summarizeUsageLikeValue(record.sourceUsage);
-    if (streamUsage) {
-        usageDebug.stream_usage = streamUsage;
-    }
-    const streamTotalUsage = summarizeUsageLikeValue(record.sourceTotalUsage);
-    if (streamTotalUsage) {
-        usageDebug.stream_total_usage = streamTotalUsage;
-    }
-    const stepProviderMetadata = summarizeUsageLikeValue(stepResult?.providerMetadata);
-    if (stepProviderMetadata) {
-        usageDebug.step_provider_metadata = stepProviderMetadata;
-    }
-    const providerMetadata = summarizeUsageLikeValue(record.providerMetadata);
-    if (providerMetadata) {
-        usageDebug.provider_metadata = providerMetadata;
-    }
-    const stepResponse = summarizeUsageLikeValue(stepResult?.response);
-    if (stepResponse) {
-        usageDebug.step_response = stepResponse;
-    }
-    const response = summarizeUsageLikeValue(record.response);
-    if (response) {
-        usageDebug.response = response;
-    }
-    return Object.keys(usageDebug).length > 0 ? sanitizeTracePayload(usageDebug) : undefined;
-}
-async function resolveUsagePromise(usage) {
-    if (!usage) {
-        return undefined;
-    }
-    return await usage.then((value) => value, () => undefined);
-}
-async function resolveSegmentUsage(source) {
-    const [lastStepUsage, totalUsage] = await Promise.all([
-        resolveUsagePromise(source.usage),
-        resolveUsagePromise(source.totalUsage),
-    ]);
-    return { lastStepUsage, totalUsage };
+function isNativeStreamResult(value) {
+    return isRecord(value) && isReadableStream(value.stream);
 }
-function maybeBackfillRecordUsageFromSegment(record, records, usage) {
-    if (usage.lastStepUsage !== undefined) {
-        record.sourceUsage = usage.lastStepUsage;
+function extractContentText(content) {
+    if (typeof content === 'string') {
+        return content;
     }
-    if (usage.totalUsage !== undefined) {
-        record.sourceTotalUsage = usage.totalUsage;
+    if (!Array.isArray(content)) {
+        return '';
     }
-    if (record.usage !== undefined) {
-        return;
-    }
-    const isLastRecord = records[records.length - 1] === record;
-    if (isLastRecord && usage.lastStepUsage !== undefined) {
-        record.usage = usage.lastStepUsage;
-        return;
-    }
-    if (records.length === 1 && usage.totalUsage !== undefined) {
-        record.usage = usage.totalUsage;
-    }
-}
-function toTraceObject(value) {
-    if (isRecord(value)) {
-        return value;
-    }
-    return { value };
-}
-function extractResponseMessages(value) {
-    return isRecord(value) && Array.isArray(value.messages) ? value.messages : undefined;
-}
-function extractTextParts(value) {
-    if (typeof value === 'string') {
-        return [value];
-    }
-    if (Array.isArray(value)) {
-        return value.flatMap((entry) => extractTextParts(entry));
-    }
-    if (!isRecord(value)) {
-        return [];
-    }
-    if (value.type === 'text') {
-        if (typeof value.text === 'string') {
-            return [value.text];
-        }
-        if (isRecord(value.text) && typeof value.text.value === 'string') {
-            return [value.text.value];
-        }
-    }
-    if ('content' in value) {
-        if (typeof value.content === 'string') {
-            return [value.content];
+    return content
+        .map((part) => {
+        if (!isRecord(part) || part.type !== 'text') {
+            return '';
         }
-        if (Array.isArray(value.content)) {
-            return value.content.flatMap((entry) => extractTextParts(entry));
-        }
-    }
-    if (Array.isArray(value.parts)) {
-        return value.parts.flatMap((entry) => extractTextParts(entry));
-    }
-    return [];
+        return typeof part.text === 'string' ? part.text : '';
+    })
+        .join('');
 }
-function extractTraceToolCallsFromMessage(message) {
-    if (!isRecord(message)) {
-        return [];
-    }
-    const toolCalls = [];
-    const pushToolCall = (value) => {
-        if (!isRecord(value)) {
-            return;
-        }
-        toolCalls.push({
-            ...(typeof value.toolCallId === 'string' ? { toolCallId: value.toolCallId } : {}),
-            ...(typeof value.toolName === 'string' ? { toolName: value.toolName } : {}),
-        });
-    };
-    if (Array.isArray(message.tool_calls)) {
-        for (const toolCall of message.tool_calls) {
-            pushToolCall(toolCall);
-        }
-    }
-    const content = message.content;
-    if (Array.isArray(content)) {
-        for (const part of content) {
-            if (!isRecord(part)) {
+async function collectNativeStreamText(stream) {
+    const reader = stream.getReader();
+    let deltaText = '';
+    let messageText = '';
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                return deltaText || messageText;
+            if (!isRecord(value)) {
                 continue;
             }
-            if (part.type === 'tool-call') {
-                pushToolCall(part);
+            if (value.type === 'text-delta' && typeof value.delta === 'string') {
+                deltaText += value.delta;
+                continue;
             }
-        }
-    }
-    if (isRecord(content) && Array.isArray(content.parts)) {
-        for (const part of content.parts) {
-            if (isRecord(part) && part.type === 'tool-invocation' && isRecord(part.toolInvocation)) {
-                pushToolCall(part.toolInvocation);
+            if (value.type !== 'message' || !isRecord(value.message)) {
+                continue;
             }
-        }
-    }
-    return toolCalls;
-}
-function summarizeRequestedTools(toolCalls) {
-    const summaries = toolCalls
-        .map((toolCall) => ({
-        ...(typeof toolCall.toolCallId === 'string' ? { toolCallId: toolCall.toolCallId } : {}),
-        ...(typeof toolCall.toolName === 'string' ? { toolName: toolCall.toolName } : {}),
-    }))
-        .filter((toolCall) => Object.keys(toolCall).length > 0);
-    return summaries.length > 0 ? summaries : undefined;
-}
-function buildToolSummaryText(toolCalls) {
-    const toolNames = [
-        ...new Set(toolCalls
-            .map((toolCall) => (typeof toolCall.toolName === 'string' ? toolCall.toolName : undefined))
-            .filter((toolName) => toolName !== undefined)),
-    ];
-    if (toolNames.length === 0) {
-        return undefined;
-    }
-    return `Calling tools: ${toolNames.join(', ')}`;
-}
-function normalizeTraceMessage(message) {
-    if (!isRecord(message) || typeof message.role !== 'string') {
-        return undefined;
-    }
-    if (message.role === 'tool') {
-        return undefined;
-    }
-    const textContent = extractTextParts(message.content).join('').trim();
-    const toolSummaryText = buildToolSummaryText(extractTraceToolCallsFromMessage(message));
-    const content = textContent && toolSummaryText
-        ? `${textContent}\n\n[${toolSummaryText}]`
-        : textContent || (toolSummaryText ? `[${toolSummaryText}]` : undefined);
-    if (!content) {
-        return undefined;
-    }
-    return {
-        ...(typeof message.id === 'string' ? { id: message.id } : {}),
-        role: message.role,
-        content,
-    };
-}
-function normalizeTraceMessages(messages) {
-    if (!Array.isArray(messages)) {
-        return undefined;
-    }
-    const normalized = messages
-        .map((message) => normalizeTraceMessage(message))
-        .filter((message) => message !== undefined);
-    return normalized.length > 0 ? normalized : undefined;
-}
-function buildAssistantChoice(responseMessages, record) {
-    const assistantMessage = responseMessages?.find((message) => isRecord(message) && message.role === 'assistant');
-    if (assistantMessage) {
-        return { message: assistantMessage };
-    }
-    const toolSummaryText = buildToolSummaryText(record.toolCalls);
-    const content = record.textParts.join('');
-    if (!content && !toolSummaryText) {
-        return undefined;
-    }
-    const message = { role: 'assistant' };
-    if (content && toolSummaryText) {
-        message.content = `${content}\n\n[${toolSummaryText}]`;
-    }
-    else if (content) {
-        message.content = content;
-    }
-    else if (toolSummaryText) {
-        message.content = `[${toolSummaryText}]`;
-    }
-    return { message };
-}
-function buildLlmOutputs(record, stepResult) {
-    const rawResponseMessages = extractResponseMessages(stepResult?.response) ?? extractResponseMessages(record.response);
-    const responseMessages = normalizeTraceMessages(rawResponseMessages);
-    const usageMetadata = buildUsageMetadata(stepResult?.usage ?? record.usage, stepResult?.providerMetadata ?? record.providerMetadata);
-    const usageDebug = buildLlmUsageDebug(record, stepResult);
-    const outputs = {};
-    const choice = buildAssistantChoice(responseMessages, record);
-    const messages = responseMessages ?? (choice && isRecord(choice.message) ? [choice.message] : undefined);
-    if (choice) {
-        outputs.choices = [choice];
-    }
-    if (messages) {
-        outputs.messages = messages;
-    }
-    const requestedTools = summarizeRequestedTools(record.toolCalls);
-    if (requestedTools) {
-        outputs.requested_tools = requestedTools;
-    }
-    const reasoningText = record.reasoningParts.join('') ||
-        (typeof stepResult?.reasoning === 'string'
-            ? stepResult.reasoning
-            : Array.isArray(stepResult?.reasoning)
-                ? stepResult.reasoning
-                    .map((entry) => isRecord(entry) && typeof entry.text === 'string' ? entry.text : undefined)
-                    .filter((entry) => entry !== undefined)
-                    .join('')
-                : undefined);
-    if (reasoningText) {
-        outputs.reasoning = reasoningText;
-    }
-    if (record.finishReason || stepResult?.finishReason) {
-        outputs.finish_reason = stepResult?.finishReason ?? record.finishReason;
-    }
-    if (usageMetadata) {
-        outputs.usage_metadata = usageMetadata;
-    }
-    if (usageDebug) {
-        outputs.usage_debug = usageDebug;
-    }
-    return outputs;
-}
-function buildLlmMetadata(record, stepResult) {
-    const metadata = {
-        step_message_id: record.messageId,
-        final_status: 'completed',
-        ...(record.model.provider ? { ls_provider: record.model.provider } : {}),
-        ...(record.model.modelName ? { ls_model_name: record.model.modelName } : {}),
-        ...(record.finishReason || stepResult?.finishReason
-            ? { finish_reason: stepResult?.finishReason ?? record.finishReason }
-            : {}),
-    };
-    const usageMetadata = buildUsageMetadata(stepResult?.usage ?? record.usage, stepResult?.providerMetadata ?? record.providerMetadata);
-    if (usageMetadata) {
-        metadata.usage_metadata = usageMetadata;
-    }
-    return metadata;
-}
-async function finishRunTree(runTree, options) {
-    await runTree.end(options.outputs, options.error, options.endTime ?? Date.now(), options.metadata);
-    await runTree.patchRun();
-}
-function getChunkPayload(chunk) {
-    if (!isRecord(chunk)) {
-        return undefined;
-    }
-    return isRecord(chunk.payload) ? chunk.payload : chunk;
-}
-function buildSyntheticToolInputs(toolCallId, _toolName, args) {
-    return sanitizeTracePayload({
-        toolCallId,
-        args,
-    });
-}
-function shouldCreateSyntheticToolTrace(payload) {
-    const toolName = typeof payload.toolName === 'string' ? payload.toolName : '';
-    return (toolName.startsWith('mastra_') ||
-        SYNTHETIC_TOOL_TRACE_NAMES.has(toolName) ||
-        payload.providerExecuted === true ||
-        payload.dynamic === true);
-}
-async function startSyntheticToolTrace(chunk, records) {
-    if (!isRecord(chunk) || chunk.type !== 'tool-call') {
-        return;
-    }
-    const payload = getChunkPayload(chunk);
-    if (!payload || !shouldCreateSyntheticToolTrace(payload)) {
-        return;
-    }
-    const toolCallId = typeof payload.toolCallId === 'string' ? payload.toolCallId : '';
-    const toolName = typeof payload.toolName === 'string' ? payload.toolName : '';
-    if (!toolCallId || !toolName || records.has(toolCallId)) {
-        return;
-    }
-    const parentRun = (0, langsmith_tracing_1.getTraceParentRun)();
-    if (!parentRun) {
-        return;
-    }
-    const runTree = parentRun.createChild({
-        name: `tool:${toolName}`,
-        run_type: 'tool',
-        tags: dedupeTags([
-            ...(parentRun.tags ?? []),
-            'tool',
-            ...(toolName.startsWith('mastra_') ? ['native-tool'] : []),
-        ]),
-        metadata: {
-            ...(parentRun.metadata ?? {}),
-            tool_name: toolName,
-            synthetic_tool_trace: true,
-            ...(payload.providerExecuted === true ? { provider_executed: true } : {}),
-            ...(payload.dynamic === true ? { dynamic_tool: true } : {}),
-        },
-        inputs: buildSyntheticToolInputs(toolCallId, toolName, payload.args),
-    });
-    await runTree.postRun();
-    records.set(toolCallId, {
-        toolCallId,
-        toolName,
-        runTree,
-        finished: false,
-    });
-}
-async function finishSyntheticToolTrace(chunk, records) {
-    if (!isRecord(chunk) || (chunk.type !== 'tool-result' && chunk.type !== 'tool-error')) {
-        return;
-    }
-    const payload = getChunkPayload(chunk);
-    if (!payload) {
-        return;
-    }
-    const toolCallId = typeof payload.toolCallId === 'string' ? payload.toolCallId : '';
-    if (!toolCallId) {
-        return;
-    }
-    if (!records.has(toolCallId)) {
-        if (!shouldCreateSyntheticToolTrace(payload)) {
-            return;
-        }
-        await startSyntheticToolTrace({
-            type: 'tool-call',
-            payload,
-        }, records);
-    }
-    const record = records.get(toolCallId);
-    if (!record || record.finished) {
-        return;
-    }
-    record.finished = true;
-    await finishRunTree(record.runTree, {
-        outputs: sanitizeTracePayload({
-            result: payload.result,
-        }),
-        ...(payload.isError === true
-            ? {
-                error: typeof payload.result === 'string'
-                    ? payload.result
-                    : typeof payload.error === 'string'
-                        ? payload.error
-                        : 'Tool execution failed',
+            if (value.message.role === 'assistant') {
+                messageText += extractContentText(value.message.content);
             }
-            : {}),
-        metadata: {
-            final_status: payload.isError === true ? 'error' : 'completed',
-        },
-    });
-}
-async function finalizeSyntheticToolTraces(records, options) {
-    for (const record of records.values()) {
-        if (record.finished) {
-            continue;
         }
-        record.finished = true;
-        await finishRunTree(record.runTree, {
-            outputs: sanitizeTracePayload({
-                status: options?.status ?? 'completed',
-            }),
-            ...(options?.error ? { error: options.error } : {}),
-            metadata: {
-                final_status: options?.status ?? 'completed',
-            },
-        });
-    }
-}
-async function startLlmStepTrace(parentRun, messageId, request, stepNumber) {
-    const resolvedParentRun = parentRun ?? (0, langsmith_tracing_1.getTraceParentRun)();
-    if (!resolvedParentRun) {
-        return undefined;
-    }
-    const inputs = buildLlmInputPayload(request);
-    const model = normalizeModelMetadata(resolvedParentRun.metadata?.model_id);
-    const runTree = resolvedParentRun.createChild({
-        name: formatLlmRunName(model),
-        run_type: 'llm',
-        tags: dedupeTags([...(resolvedParentRun.tags ?? []), 'llm']),
-        metadata: {
-            ...(resolvedParentRun.metadata ?? {}),
-            step_message_id: messageId,
-            ...(typeof stepNumber === 'number' ? { step_number: stepNumber + 1 } : {}),
-            ...(model.provider ? { ls_provider: model.provider } : {}),
-            ...(model.modelName ? { ls_model_name: model.modelName } : {}),
-        },
-        inputs,
-    });
-    await runTree.postRun();
-    return {
-        messageId,
-        stepNumber,
-        runTree,
-        model,
-        inputs,
-        textParts: [],
-        reasoningParts: [],
-        toolCalls: [],
-        toolResults: [],
-        request,
-        recordedFirstToken: false,
-        finished: false,
-    };
-}
-function findActiveStepRecord(records, messageId) {
-    if (messageId) {
-        return records.find((record) => record.messageId === messageId && !record.finished);
-    }
-    for (let index = records.length - 1; index >= 0; index--) {
-        if (!records[index].finished) {
-            return records[index];
-        }
-    }
-    return undefined;
-}
-function recordFirstTokenEvent(record) {
-    if (record.recordedFirstToken) {
-        return;
-    }
-    record.runTree.addEvent({ name: 'new_token', time: new Date().toISOString() });
-    record.recordedFirstToken = true;
-}
-function updateStepRecordFromChunk(chunk, records) {
-    if (!isRecord(chunk) || typeof chunk.type !== 'string') {
-        return undefined;
-    }
-    if (chunk.type === 'step-start' && typeof chunk.messageId === 'string') {
-        return undefined;
-    }
-    const record = findActiveStepRecord(records);
-    if (!record) {
-        return undefined;
-    }
-    const payload = isRecord(chunk.payload) ? chunk.payload : chunk;
-    if ((chunk.type === 'text-delta' || chunk.type === 'text') && typeof payload.text === 'string') {
-        record.textParts.push(payload.text);
-        recordFirstTokenEvent(record);
-    }
-    if ((chunk.type === 'reasoning-delta' || chunk.type === 'reasoning') &&
-        typeof payload.text === 'string') {
-        record.reasoningParts.push(payload.text);
-    }
-    if (chunk.type === 'tool-call' && isRecord(payload)) {
-        record.toolCalls.push(toTraceObject(payload));
-    }
-    if ((chunk.type === 'tool-result' || chunk.type === 'tool-error') && isRecord(payload)) {
-        record.toolResults.push(toTraceObject(payload));
-    }
-    return record;
-}
-function applyStepFinishChunk(chunk, records) {
-    if (!isRecord(chunk) || chunk.type !== 'step-finish') {
-        return undefined;
-    }
-    const payload = getChunkPayload(chunk);
-    const messageId = typeof payload?.messageId === 'string' ? payload.messageId : undefined;
-    const record = findActiveStepRecord(records, messageId);
-    if (!record) {
-        return undefined;
-    }
-    const output = isRecord(payload?.output) ? payload.output : undefined;
-    const stepResult = isRecord(payload?.stepResult) ? payload.stepResult : undefined;
-    const metadata = isRecord(payload?.metadata) ? payload.metadata : undefined;
-    record.finishReason =
-        (stepResult && typeof stepResult.reason === 'string' ? stepResult.reason : undefined) ??
-            (payload && typeof payload.finishReason === 'string' ? payload.finishReason : undefined) ??
-            record.finishReason;
-    const usage = output?.usage ?? payload?.usage;
-    if (usage !== undefined) {
-        record.usage = usage;
-    }
-    if (payload?.response !== undefined) {
-        record.response = payload.response;
-    }
-    const request = metadata?.request ?? payload?.request;
-    if (request !== undefined) {
-        record.request = request;
-    }
-    const providerMetadata = metadata?.providerMetadata ?? payload?.providerMetadata;
-    if (providerMetadata !== undefined) {
-        record.providerMetadata = providerMetadata;
-    }
-    record.warnings =
-        (stepResult && Array.isArray(stepResult.warnings) ? stepResult.warnings : undefined) ??
-            payload?.warnings ??
-            record.warnings;
-    record.isContinued =
-        stepResult?.isContinued === true ? true : payload?.isContinued === true || record.isContinued;
-    if (output && typeof output.text === 'string') {
-        record.textParts = output.text.length > 0 ? [output.text] : [];
-    }
-    if (output && Array.isArray(output.toolCalls)) {
-        record.toolCalls = output.toolCalls.map((entry) => toTraceObject(entry));
-    }
-    if (output && Array.isArray(output.toolResults)) {
-        record.toolResults = output.toolResults.map((entry) => toTraceObject(entry));
-    }
-    const responseModelId = payload && isRecord(payload.response) && typeof payload.response.modelId === 'string'
-        ? payload.response.modelId
-        : undefined;
-    if (responseModelId) {
-        const model = normalizeModelMetadata(responseModelId);
-        record.model = {
-            provider: model.provider ?? record.model.provider,
-            modelName: model.modelName ?? responseModelId,
-        };
-        record.runTree.name = formatLlmRunName(record.model);
-        record.runTree.metadata = {
-            ...(record.runTree.metadata ?? {}),
-            ...(record.model.provider ? { ls_provider: record.model.provider } : {}),
-            ...(record.model.modelName ? { ls_model_name: record.model.modelName } : {}),
-        };
-    }
-    return record;
-}
-function isStepResultLike(value) {
-    return isRecord(value);
-}
-function toStepResultLike(value) {
-    return isStepResultLike(value) ? value : undefined;
-}
-function toStepStartLike(value) {
-    return isRecord(value) ? value : undefined;
-}
-function getSyntheticStepMessageId(stepResult, index) {
-    const messages = extractResponseMessages(stepResult.response);
-    const messageId = messages?.find((message) => isRecord(message) && typeof message.id === 'string')?.id;
-    return typeof messageId === 'string' ? messageId : `step-${index + 1}`;
-}
-async function createFallbackStepTrace(parentRun, stepResult, index) {
-    const record = await startLlmStepTrace(parentRun, getSyntheticStepMessageId(stepResult, index), stepResult.request, stepResult.stepNumber ?? index);
-    if (!record) {
-        return undefined;
-    }
-    if (typeof stepResult.text === 'string' && stepResult.text.length > 0) {
-        record.textParts.push(stepResult.text);
-        recordFirstTokenEvent(record);
-    }
-    if (typeof stepResult.reasoning === 'string' && stepResult.reasoning.length > 0) {
-        record.reasoningParts.push(stepResult.reasoning);
-    }
-    else if (Array.isArray(stepResult.reasoning)) {
-        record.reasoningParts.push(...stepResult.reasoning
-            .map((entry) => isRecord(entry) && typeof entry.text === 'string' ? entry.text : undefined)
-            .filter((entry) => entry !== undefined));
-    }
-    if (Array.isArray(stepResult.toolCalls)) {
-        record.toolCalls.push(...stepResult.toolCalls.map((entry) => toTraceObject(entry)));
-    }
-    if (Array.isArray(stepResult.toolResults)) {
-        record.toolResults.push(...stepResult.toolResults.map((entry) => toTraceObject(entry)));
-    }
-    record.finishReason = stepResult.finishReason;
-    if (stepResult.usage !== undefined) {
-        record.usage = stepResult.usage;
-    }
-    if (stepResult.request !== undefined) {
-        record.request = stepResult.request;
-    }
-    if (stepResult.response !== undefined) {
-        record.response = stepResult.response;
-    }
-    if (stepResult.providerMetadata !== undefined) {
-        record.providerMetadata = stepResult.providerMetadata;
-    }
-    const responseModelId = isRecord(stepResult.response) && typeof stepResult.response.modelId === 'string'
-        ? stepResult.response.modelId
-        : undefined;
-    if (responseModelId) {
-        const model = normalizeModelMetadata(responseModelId);
-        record.model = {
-            provider: model.provider ?? record.model.provider,
-            modelName: model.modelName ?? responseModelId,
-        };
-        record.runTree.name = formatLlmRunName(record.model);
-    }
-    return record;
-}
-function applyStepResultToRecord(record, stepResult) {
-    if (typeof stepResult.text === 'string') {
-        record.textParts = stepResult.text.length > 0 ? [stepResult.text] : [];
-    }
-    if (typeof stepResult.reasoning === 'string') {
-        record.reasoningParts = stepResult.reasoning.length > 0 ? [stepResult.reasoning] : [];
-    }
-    else if (Array.isArray(stepResult.reasoning)) {
-        record.reasoningParts = stepResult.reasoning
-            .map((entry) => (isRecord(entry) && typeof entry.text === 'string' ? entry.text : undefined))
-            .filter((entry) => entry !== undefined);
-    }
-    if (Array.isArray(stepResult.toolCalls)) {
-        record.toolCalls = stepResult.toolCalls.map((entry) => toTraceObject(entry));
-    }
-    if (Array.isArray(stepResult.toolResults)) {
-        record.toolResults = stepResult.toolResults.map((entry) => toTraceObject(entry));
-    }
-    if (typeof stepResult.finishReason === 'string') {
-        record.finishReason = stepResult.finishReason;
-    }
-    if (stepResult.usage !== undefined) {
-        record.usage = stepResult.usage;
     }
-    if (stepResult.request !== undefined) {
-        record.request = stepResult.request;
-    }
-    if (stepResult.response !== undefined) {
-        record.response = stepResult.response;
-    }
-    if (stepResult.providerMetadata !== undefined) {
-        record.providerMetadata = stepResult.providerMetadata;
-    }
-    const responseModelId = isRecord(stepResult.response) && typeof stepResult.response.modelId === 'string'
-        ? stepResult.response.modelId
-        : undefined;
-    if (responseModelId) {
-        const model = normalizeModelMetadata(responseModelId);
-        record.model = {
-            provider: model.provider ?? record.model.provider,
-            modelName: model.modelName ?? responseModelId,
-        };
-        record.runTree.name = formatLlmRunName(record.model);
+    finally {
+        reader.releaseLock();
     }
 }
-function createLlmStepTraceHooks(explicitParentRun) {
-    const activeParentRun = explicitParentRun ?? (0, langsmith_tracing_1.getTraceParentRun)();
-    if (!activeParentRun) {
-        return undefined;
-    }
-    const records = [];
-    const recordsByStepNumber = new Map();
-    const getActiveRecord = () => {
-        for (let index = records.length - 1; index >= 0; index--) {
-            const record = records[index];
-            if (!record.finished) {
-                return record;
-            }
-        }
-        return undefined;
-    };
-    const restoreTraceParent = () => {
-        (0, langsmith_tracing_1.setTraceParentOverride)(activeParentRun);
-    };
-    restoreTraceParent();
-    const patchFinishedRecordIfNeeded = async (record, stepResult, options) => {
-        const metadata = {
-            ...(record.runTree.metadata ?? {}),
-            ...buildLlmMetadata(record, stepResult),
-            ...(options?.status && options.status !== 'completed'
-                ? { final_status: options.status }
-                : {}),
-        };
-        record.runTree.inputs = record.inputs;
-        record.runTree.name = formatLlmRunName(record.model);
-        record.runTree.metadata = metadata;
-        const endTimeValue = Reflect.get(record.runTree, 'end_time');
-        const endTime = typeof endTimeValue === 'number' ? endTimeValue : undefined;
-        await finishRunTree(record.runTree, {
-            outputs: buildLlmOutputs(record, stepResult),
-            metadata,
-            ...(options?.error ? { error: options.error } : {}),
-            ...(endTime !== undefined ? { endTime } : {}),
-        });
-    };
-    const startStepTrace = async (options) => {
-        const stepStart = toStepStartLike(options);
-        if (typeof stepStart?.stepNumber !== 'number') {
-            return undefined;
-        }
-        const existingRecord = recordsByStepNumber.get(stepStart.stepNumber);
-        if (existingRecord && !existingRecord.finished) {
-            (0, langsmith_tracing_1.setTraceParentOverride)(existingRecord.runTree);
-            return existingRecord;
-        }
-        const record = await startLlmStepTrace(activeParentRun, `step-${stepStart.stepNumber + 1}`, {
-            messages: Array.isArray(stepStart.messages) ? stepStart.messages : [],
-        }, stepStart.stepNumber);
-        if (!record) {
-            return undefined;
-        }
-        const stepModelId = stepStart.model?.modelId;
-        if (typeof stepModelId === 'string' && stepModelId.length > 0) {
-            record.model = {
-                provider: stepStart.model?.provider ?? record.model.provider,
-                modelName: normalizeModelMetadata(stepModelId).modelName ?? stepModelId,
-            };
-            record.runTree.name = formatLlmRunName(record.model);
-            record.runTree.metadata = {
-                ...(record.runTree.metadata ?? {}),
-                ...(record.model.provider ? { ls_provider: record.model.provider } : {}),
-                ...(record.model.modelName ? { ls_model_name: record.model.modelName } : {}),
-            };
-        }
-        recordsByStepNumber.set(stepStart.stepNumber, record);
-        records.push(record);
-        (0, langsmith_tracing_1.setTraceParentOverride)(record.runTree);
-        return record;
-    };
-    const prepareStep = async (options) => {
-        await startStepTrace(options);
-        return undefined;
-    };
-    const onStepStart = async (options) => {
-        await startStepTrace(options);
-    };
-    const onStepFinish = async (stepResultValue) => {
-        const stepResult = toStepResultLike(stepResultValue);
-        if (!stepResult) {
-            return;
-        }
-        const stepNumber = typeof stepResult.stepNumber === 'number' ? stepResult.stepNumber : undefined;
-        const record = stepNumber !== undefined ? recordsByStepNumber.get(stepNumber) : undefined;
-        if (!record || record.finished) {
-            return;
-        }
-        applyStepResultToRecord(record, stepResult);
-        record.runTree.inputs = record.inputs;
-        record.runTree.name = formatLlmRunName(record.model);
-        record.runTree.metadata = {
-            ...(record.runTree.metadata ?? {}),
-            ...buildLlmMetadata(record, stepResult),
-        };
-        await finishRunTree(record.runTree, {
-            outputs: buildLlmOutputs(record, stepResult),
-            metadata: record.runTree.metadata,
-        });
-        record.finished = true;
-        if (stepNumber !== undefined) {
-            recordsByStepNumber.delete(stepNumber);
-        }
-        restoreTraceParent();
-    };
-    return {
-        executionOptions: {
-            prepareStep,
-            experimental_prepareStep: prepareStep,
-            experimental_onStepStart: onStepStart,
-            onStepFinish,
-            experimental_telemetry: { isEnabled: false },
-        },
-        onStreamChunk: (chunk) => {
-            updateStepRecordFromChunk(chunk, records);
-            applyStepFinishChunk(chunk, records);
-        },
-        startSegment: () => {
-            for (const [stepNumber, record] of recordsByStepNumber.entries()) {
-                if (record.finished) {
-                    recordsByStepNumber.delete(stepNumber);
-                }
-            }
-            const activeRecord = getActiveRecord();
-            if (activeRecord) {
-                (0, langsmith_tracing_1.setTraceParentOverride)(activeRecord.runTree);
+async function* readableStreamToAsyncIterable(stream) {
+    const reader = stream.getReader();
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
                 return;
-            }
-            restoreTraceParent();
-        },
-        finalize: async (source, options) => {
-            const resolvedSteps = await source.steps?.then((steps) => steps, () => undefined);
-            const segmentUsage = await resolveSegmentUsage(source);
-            const stepResults = Array.isArray(resolvedSteps)
-                ? resolvedSteps
-                    .map((stepValue) => toStepResultLike(stepValue))
-                    .filter((stepResult) => stepResult !== undefined)
-                : [];
-            const stepResultsByStepNumber = new Map();
-            for (const stepResult of stepResults) {
-                if (typeof stepResult.stepNumber === 'number') {
-                    stepResultsByStepNumber.set(stepResult.stepNumber, stepResult);
-                }
-            }
-            for (const [index, record] of records.entries()) {
-                const stepResult = (typeof record.stepNumber === 'number'
-                    ? stepResultsByStepNumber.get(record.stepNumber)
-                    : undefined) ?? stepResults[index];
-                const hadUsageMetadata = buildUsageMetadata(record.usage, record.providerMetadata);
-                const hadUsageMetadataJson = hadUsageMetadata
-                    ? JSON.stringify(hadUsageMetadata)
-                    : undefined;
-                const hadResponse = record.response !== undefined;
-                const hadFinishReason = record.finishReason !== undefined;
-                if (stepResult) {
-                    applyStepResultToRecord(record, stepResult);
-                }
-                maybeBackfillRecordUsageFromSegment(record, records, segmentUsage);
-                if (record.finished) {
-                    const hasUsageMetadata = buildUsageMetadata(record.usage, record.providerMetadata);
-                    const hasUsageMetadataJson = hasUsageMetadata
-                        ? JSON.stringify(hasUsageMetadata)
-                        : undefined;
-                    const hasResponse = record.response !== undefined;
-                    const hasFinishReason = record.finishReason !== undefined;
-                    if (hadUsageMetadataJson !== hasUsageMetadataJson ||
-                        (!hadResponse && hasResponse) ||
-                        (!hadFinishReason && hasFinishReason)) {
-                        await patchFinishedRecordIfNeeded(record, stepResult, options);
-                    }
-                    continue;
-                }
-                record.runTree.inputs = record.inputs;
-                record.runTree.name = formatLlmRunName(record.model);
-                record.runTree.metadata = {
-                    ...(record.runTree.metadata ?? {}),
-                    ...buildLlmMetadata(record, stepResult),
-                    ...(options?.status && options.status !== 'completed'
-                        ? { final_status: options.status }
-                        : {}),
-                };
-                await finishRunTree(record.runTree, {
-                    outputs: buildLlmOutputs(record, stepResult),
-                    metadata: record.runTree.metadata,
-                    ...(options?.error ? { error: options.error } : {}),
-                });
-                record.finished = true;
-            }
-            restoreTraceParent();
-            recordsByStepNumber.clear();
-        },
-    };
-}
-async function finalizeLlmStepTraces(source, records, options) {
-    const parentRun = (0, langsmith_tracing_1.getTraceParentRun)();
-    const resolvedSteps = await source.steps?.then((steps) => steps, () => undefined);
-    const segmentUsage = await resolveSegmentUsage(source);
-    const stepResults = Array.isArray(resolvedSteps)
-        ? resolvedSteps
-            .map((stepValue) => toStepResultLike(stepValue))
-            .filter((stepResult) => stepResult !== undefined)
-        : [];
-    const stepResultsByStepNumber = new Map();
-    for (const stepResult of stepResults) {
-        if (typeof stepResult.stepNumber === 'number') {
-            stepResultsByStepNumber.set(stepResult.stepNumber, stepResult);
+            yield value;
         }
     }
-    if (records.length === 0 && stepResults.length > 0) {
-        for (const [index, stepResult] of stepResults.entries()) {
-            const fallbackRecord = await createFallbackStepTrace(parentRun, stepResult, index);
-            if (fallbackRecord) {
-                records.push(fallbackRecord);
-            }
-        }
+    finally {
+        reader.releaseLock();
     }
-    if (records.length === 0) {
-        return;
+}
+function normalizeStreamSource(result) {
+    if (isResumableStreamSource(result)) {
+        return result;
     }
-    for (const [index, record] of records.entries()) {
-        if (record.finished) {
-            continue;
-        }
-        const stepResult = (typeof record.stepNumber === 'number'
-            ? stepResultsByStepNumber.get(record.stepNumber)
-            : undefined) ?? stepResults[index];
-        if (stepResult) {
-            applyStepResultToRecord(record, stepResult);
-        }
-        maybeBackfillRecordUsageFromSegment(record, records, segmentUsage);
-        record.runTree.inputs = record.inputs;
-        record.runTree.name = formatLlmRunName(record.model);
-        record.runTree.metadata = {
-            ...(record.runTree.metadata ?? {}),
-            ...buildLlmMetadata(record, stepResult),
-            ...(options?.status && options.status !== 'completed'
-                ? { final_status: options.status }
-                : {}),
+    if (isNativeStreamResult(result)) {
+        const [eventStream, textStream] = result.stream.tee();
+        return {
+            runId: result.runId,
+            fullStream: readableStreamToAsyncIterable(eventStream),
+            text: collectNativeStreamText(textStream),
         };
-        await finishRunTree(record.runTree, {
-            outputs: buildLlmOutputs(record, stepResult),
-            metadata: record.runTree.metadata,
-            ...(options?.error ? { error: options.error } : {}),
-        });
-        record.finished = true;
     }
+    throw new Error('Unsupported agent stream result');
 }
 async function executeResumableStream(options) {
-    let activeSource = options.stream;
     let activeStream = options.stream.fullStream;
-    let activeMastraRunId = options.stream.runId ?? options.initialMastraRunId ?? '';
+    let activeAgentRunId = options.stream.runId ?? options.initialAgentRunId ?? '';
     let text = options.stream.text;
     const workSummaryAccumulator = new work_summary_accumulator_1.WorkSummaryAccumulator();
     let currentResponseId;
+    let nativeStepIndex = 0;
     while (true) {
         let suspension;
         let hasError = false;
         let pendingConfirmation;
         let confirmationEvent;
         let confirmationEventPublished = false;
-        const llmStepRecords = [];
-        const syntheticToolRecords = new Map();
-        options.llmStepTraceHooks?.startSegment();
+        const drainedCorrectionsForResume = [];
         for await (const chunk of activeStream) {
-            options.context.onActivity?.();
             if (options.context.signal.aborted) {
-                if (options.llmStepTraceHooks) {
-                    await options.llmStepTraceHooks.finalize(activeSource, {
-                        status: 'cancelled',
-                        error: 'Run cancelled while streaming',
-                    });
-                }
-                else {
-                    await finalizeLlmStepTraces(activeSource, llmStepRecords, {
-                        status: 'cancelled',
-                        error: 'Run cancelled while streaming',
-                    });
-                }
-                await finalizeSyntheticToolTraces(syntheticToolRecords, {
-                    status: 'cancelled',
-                    error: 'Run cancelled while streaming',
-                });
                 return {
                     status: 'cancelled',
-                    mastraRunId: activeMastraRunId,
+                    agentRunId: activeAgentRunId,
                     text,
                     workSummary: workSummaryAccumulator.toSummary(),
                 };
             }
-            await startSyntheticToolTrace(chunk, syntheticToolRecords);
-            await finishSyntheticToolTrace(chunk, syntheticToolRecords);
-            options.llmStepTraceHooks?.onStreamChunk(chunk);
-            if (isRecord(chunk) && chunk.type === 'step-start') {
-                const stepPayload = getChunkPayload(chunk);
-                const stepMessageId = typeof stepPayload?.messageId === 'string' ? stepPayload.messageId : undefined;
-                currentResponseId = stepMessageId;
-            }
-            if (options.llmStepTraceHooks) {
-            }
-            else if (isRecord(chunk) && chunk.type === 'step-start') {
-                const payload = getChunkPayload(chunk);
-                const messageId = typeof payload?.messageId === 'string' ? payload.messageId : undefined;
-                const request = payload?.request;
-                const stepTrace = typeof messageId === 'string'
-                    ? await startLlmStepTrace(undefined, messageId, request)
-                    : undefined;
-                if (stepTrace) {
-                    llmStepRecords.push(stepTrace);
-                }
-            }
-            else {
-                updateStepRecordFromChunk(chunk, llmStepRecords);
-                applyStepFinishChunk(chunk, llmStepRecords);
+            options.context.onActivity?.();
+            if (isRecord(chunk) && chunk.type === 'start-step') {
+                nativeStepIndex += 1;
+                const responseRunId = activeAgentRunId || options.context.runId;
+                currentResponseId = `${responseRunId}:step:${nativeStepIndex}`;
             }
             const parsedSuspension = (0, stream_helpers_1.parseSuspension)(chunk);
             if (parsedSuspension) {
@@ -1350,16 +148,9 @@ async function executeResumableStream(options) {
             if (isErrorChunk(chunk)) {
                 hasError = true;
             }
-            const event = (0, map_chunk_1.mapMastraChunkToEvent)(options.context.runId, options.context.agentId, chunk, currentResponseId);
+            const event = (0, map_chunk_1.mapAgentChunkToEvent)(options.context.runId, options.context.agentId, chunk, currentResponseId);
             if (event) {
                 workSummaryAccumulator.observe(event);
-                if (options.onStreamEvent) {
-                    try {
-                        options.onStreamEvent(event);
-                    }
-                    catch {
-                    }
-                }
                 let shouldPublishEvent = true;
                 if (event.type === 'confirmation-request') {
                     const isPrimarySuspension = suspension !== undefined &&
@@ -1381,27 +172,15 @@ async function executeResumableStream(options) {
                 }
             }
             if (options.control.mode === 'auto' && options.control.drainCorrections) {
-                publishCorrections(options.context, options.control.drainCorrections());
+                const corrections = options.control.drainCorrections();
+                publishCorrections(options.context, corrections);
+                drainedCorrectionsForResume.push(...corrections);
             }
         }
-        const traceStatus = suspension ? 'suspended' : hasError ? 'errored' : 'completed';
-        if (options.llmStepTraceHooks) {
-            await options.llmStepTraceHooks.finalize(activeSource, {
-                status: traceStatus,
-            });
-        }
-        else {
-            await finalizeLlmStepTraces(activeSource, llmStepRecords, {
-                status: traceStatus,
-            });
-        }
-        await finalizeSyntheticToolTraces(syntheticToolRecords, {
-            status: traceStatus,
-        });
         if (options.context.signal.aborted) {
             return {
                 status: 'cancelled',
-                mastraRunId: activeMastraRunId,
+                agentRunId: activeAgentRunId,
                 text,
                 workSummary: workSummaryAccumulator.toSummary(),
             };
@@ -1409,7 +188,7 @@ async function executeResumableStream(options) {
         if (!suspension) {
             return {
                 status: hasError ? 'errored' : 'completed',
-                mastraRunId: activeMastraRunId,
+                agentRunId: activeAgentRunId,
                 text,
                 workSummary: workSummaryAccumulator.toSummary(),
             };
@@ -1417,7 +196,7 @@ async function executeResumableStream(options) {
         if (options.control.mode === 'manual') {
             return {
                 status: 'suspended',
-                mastraRunId: activeMastraRunId,
+                agentRunId: activeAgentRunId,
                 text,
                 suspension,
                 workSummary: workSummaryAccumulator.toSummary(),
@@ -1425,23 +204,22 @@ async function executeResumableStream(options) {
             };
         }
         const confirmationPromise = pendingConfirmation ?? options.control.waitForConfirmation(suspension.requestId);
-        const resumeData = await waitForConfirmationOrCorrection(options.context.signal, confirmationPromise, options.control, options.context);
+        const resumeData = await waitForConfirmationOrCorrection(options.context.signal, confirmationPromise, options.control, options.context, drainedCorrectionsForResume);
         const resumeOptions = options.control.buildResumeOptions?.({
-            mastraRunId: activeMastraRunId,
+            agentRunId: activeAgentRunId,
             suspension,
         }) ?? {
-            runId: activeMastraRunId,
+            runId: activeAgentRunId,
             toolCallId: suspension.toolCallId,
         };
-        const resumed = await (0, stream_helpers_1.asResumable)(options.agent).resumeStream(resumeData, {
+        const resumed = await (0, stream_helpers_1.resumeAgentStream)(options.agent, resumeData, {
             ...resumeOptions,
-            ...(options.llmStepTraceHooks?.executionOptions ?? {}),
         });
-        activeMastraRunId =
-            (typeof resumed.runId === 'string' ? resumed.runId : '') || activeMastraRunId;
-        activeSource = resumed;
-        activeStream = resumed.fullStream;
-        text = resumed.text;
+        const resumedSource = normalizeStreamSource(resumed);
+        activeAgentRunId =
+            (typeof resumedSource.runId === 'string' ? resumedSource.runId : '') || activeAgentRunId;
+        activeStream = resumedSource.fullStream;
+        text = resumedSource.text;
     }
 }
 function publishCorrections(context, corrections) {
@@ -1454,6 +232,14 @@ function publishCorrections(context, corrections) {
         });
     }
 }
+function buildCorrectionResumeData(corrections) {
+    return {
+        __correctionOverride: true,
+        message: 'The user sent a correction while this run was active. ' +
+            'The confirmation has been skipped. Apply the correction and continue.',
+        corrections,
+    };
+}
 function isErrorChunk(chunk) {
     return (chunk !== null &&
         typeof chunk === 'object' &&
@@ -1479,7 +265,11 @@ async function waitForConfirmation(signal, confirmationPromise) {
         }
     }
 }
-async function waitForConfirmationOrCorrection(signal, confirmationPromise, control, context) {
+async function waitForConfirmationOrCorrection(signal, confirmationPromise, control, context, drainedCorrectionsForResume) {
+    if (drainedCorrectionsForResume.length > 0) {
+        void confirmationPromise.catch(() => undefined);
+        return buildCorrectionResumeData(drainedCorrectionsForResume);
+    }
     if (!control.waitForCorrection) {
         return await waitForConfirmation(signal, confirmationPromise);
     }
@@ -1492,12 +282,7 @@ async function waitForConfirmationOrCorrection(signal, confirmationPromise, cont
     if (result === correctionSentinel) {
         const corrections = control.drainCorrections?.() ?? [];
         publishCorrections(context, corrections);
-        return {
-            __correctionOverride: true,
-            message: 'The user sent a correction while this tool was waiting for confirmation. ' +
-                'The confirmation has been skipped. Apply the correction and continue.',
-            corrections,
-        };
+        return buildCorrectionResumeData(corrections);
     }
     return result;
 }