@nocobase/plugin-ai 1.9.32 → 1.9.34

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/experimental/vercel/index.js

@@ -0,0 +1,435 @@
+import { LangSmithMiddleware, } from "./middleware.js";
+import { convertMessageToTracedFormat } from "./utils.js";
+import { isTraceableFunction, traceable } from "../../traceable.js";
+const _wrapTools = (tools, lsConfig) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const wrappedTools = {};
+    if (tools) {
+        for (const [key, tool] of Object.entries(tools)) {
+            wrappedTools[key] = Object.assign(Object.create(Object.getPrototypeOf(tool)), tool);
+            if (wrappedTools[key] != null &&
+                typeof wrappedTools[key] === "object" &&
+                "execute" in wrappedTools[key] &&
+                typeof wrappedTools[key].execute === "function" &&
+                !isTraceableFunction(wrappedTools[key].execute)) {
+                wrappedTools[key].execute = traceable(wrappedTools[key].execute.bind(wrappedTools[key]), {
+                    ...lsConfig,
+                    name: key,
+                    run_type: "tool",
+                });
+            }
+        }
+    }
+    return wrappedTools;
+};
+const _getModelDisplayName = (model) => {
+    if (typeof model === "string") {
+        return model;
+    }
+    if (model.config != null &&
+        typeof model.config === "object" &&
+        "provider" in model.config &&
+        typeof model.config.provider === "string") {
+        return model.config.provider;
+    }
+    if (model.modelId != null && typeof model.modelId === "string") {
+        return model.modelId;
+    }
+    return "unknown";
+};
+const _getModelId = (model) => {
+    if (typeof model === "string") {
+        return model;
+    }
+    return typeof model.modelId === "string" ? model.modelId : undefined;
+};
+const _formatTracedInputs = (params) => {
+    const { prompt, messages, model, tools, ...rest } = params;
+    if (Array.isArray(prompt)) {
+        return { ...rest, messages: prompt.map(convertMessageToTracedFormat) };
+    }
+    else if (Array.isArray(messages)) {
+        return { ...rest, messages: messages.map(convertMessageToTracedFormat) };
+    }
+    else {
+        return { ...rest, prompt, messages };
+    }
+};
+const _mergeConfig = (baseConfig, runtimeConfig) => {
+    return {
+        ...baseConfig,
+        ...runtimeConfig,
+        metadata: {
+            ...baseConfig?.metadata,
+            ...runtimeConfig?.metadata,
+        },
+    };
+};
+const _extractChildRunConfig = (lsConfig) => {
+    const { id, name, parent_run_id, start_time, end_time, attachments, dotted_order, processInputs, processOutputs, processChildLLMRunInputs, processChildLLMRunOutputs, ...inheritedConfig } = lsConfig ?? {};
+    const childConfig = inheritedConfig;
+    if (processChildLLMRunInputs) {
+        childConfig.processInputs = processChildLLMRunInputs;
+    }
+    if (processChildLLMRunOutputs) {
+        childConfig.processOutputs = processChildLLMRunOutputs;
+    }
+    return childConfig;
+};
+const _resolveConfigs = (baseLsConfig, runtimeLsConfig) => {
+    const baseChildRunConfig = _extractChildRunConfig(baseLsConfig);
+    const runtimeChildLLMRunConfig = _extractChildRunConfig(runtimeLsConfig);
+    const resolvedLsConfig = _mergeConfig(baseLsConfig, runtimeLsConfig);
+    const resolvedChildLLMRunConfig = _mergeConfig(baseChildRunConfig, runtimeChildLLMRunConfig);
+    const { processInputs: _processInputs, processOutputs: _processOutputs, ...resolvedToolConfig } = resolvedChildLLMRunConfig;
+    return {
+        resolvedLsConfig,
+        resolvedChildLLMRunConfig,
+        resolvedToolConfig,
+    };
+};
+/**
+ * Wraps LangSmith config in a way that matches AI SDK provider types.
+ *
+ * ```ts
+ * import { createLangSmithProviderOptions } from "langsmith/experimental/vercel";
+ * import * as ai from "ai";
+ *
+ * const lsConfig = createLangSmithProviderOptions<typeof ai.generateText>({
+ *   // Will have appropriate typing
+ *   processInputs: (inputs) => {
+ *     const { messages } = inputs;
+ *     return {
+ *       messages: messages?.map((message) => ({
+ *         ...message,
+ *         content: "REDACTED",
+ *       })),
+ *       prompt: "REDACTED",
+ *     };
+ *   },
+ * });
+ * ```
+ *
+ * Note: AI SDK expects only JSON values in an object for
+ * provider options, but LangSmith's config may contain non-JSON values.
+ * These are not passed to the underlying AI SDK model, so it is safe to
+ * cast the typing here.
+ */
+export const createLangSmithProviderOptions = (lsConfig) => {
+    return (lsConfig ?? {});
+};
+/**
+ * Wraps Vercel AI SDK 5 functions with LangSmith tracing capabilities.
+ *
+ * @param methods - Object containing AI SDK methods to wrap
+ * @param methods.wrapLanguageModel - AI SDK's wrapLanguageModel function
+ * @param methods.generateText - AI SDK's generateText function
+ * @param methods.streamText - AI SDK's streamText function
+ * @param methods.streamObject - AI SDK's streamObject function
+ * @param methods.generateObject - AI SDK's generateObject function
+ *
+ * @returns Object containing wrapped versions of the AI SDK functions with LangSmith tracing
+ * @returns returns.generateText - Wrapped generateText function that traces calls to LangSmith
+ * @returns returns.generateObject - Wrapped generateObject function that traces calls to LangSmith
+ * @returns returns.streamText - Wrapped streamText function that traces calls to LangSmith
+ * @returns returns.streamObject - Wrapped streamObject function that traces calls to LangSmith
+ */
+const wrapAISDK = ({ wrapLanguageModel, generateText, streamText, streamObject, generateObject, }, baseLsConfig) => {
+    /**
+     * Wrapped version of AI SDK 5's generateText with LangSmith tracing.
+     *
+     * This function has the same signature and behavior as the original generateText,
+     * but adds automatic tracing to LangSmith for observability.
+     *
+     * ```ts
+     * import * as ai from "ai";
+     * import { wrapAISDK } from "langsmith/experimental/vercel";
+     *
+     * const { generateText } = wrapAISDK(ai);
+     * const { text } = await generateText(...);
+     * ```
+     *
+     * @see {@link https://sdk.vercel.ai/docs/ai-sdk-core/generating-text} Original generateText documentation
+     * @param params - Same parameters as the original generateText function
+     * @returns Promise resolving to the same result as generateText, with tracing applied
+     */
+    const wrappedGenerateText = async (...args) => {
+        const params = args[0];
+        const { langsmith: runtimeLsConfig, ...providerOptions } = params.providerOptions ?? {};
+        const { resolvedLsConfig, resolvedChildLLMRunConfig, resolvedToolConfig } = _resolveConfigs(baseLsConfig, runtimeLsConfig);
+        const traceableFunc = traceable(async (...args) => {
+            const [params, ...rest] = args;
+            const wrappedModel = wrapLanguageModel({
+                model: params.model,
+                middleware: LangSmithMiddleware({
+                    name: _getModelDisplayName(params.model),
+                    modelId: _getModelId(params.model),
+                    lsConfig: resolvedChildLLMRunConfig,
+                }),
+            });
+            return generateText({
+                ...params,
+                providerOptions,
+                tools: _wrapTools(params.tools, resolvedToolConfig),
+                model: wrappedModel,
+            }, ...rest);
+        }, {
+            name: _getModelDisplayName(params.model),
+            ...resolvedLsConfig,
+            metadata: {
+                ai_sdk_method: "ai.generateText",
+                ...resolvedLsConfig?.metadata,
+            },
+            processInputs: (inputs) => {
+                const inputFormatter = resolvedLsConfig?.processInputs ?? _formatTracedInputs;
+                return inputFormatter(inputs);
+            },
+            processOutputs: (outputs) => {
+                if (resolvedLsConfig?.processOutputs) {
+                    return resolvedLsConfig.processOutputs(outputs);
+                }
+                if (outputs.outputs == null || typeof outputs.outputs !== "object") {
+                    return outputs;
+                }
+                const { steps } = outputs.outputs;
+                if (Array.isArray(steps)) {
+                    const lastStep = steps.at(-1);
+                    if (lastStep == null || typeof lastStep !== "object") {
+                        return outputs;
+                    }
+                    const { content } = lastStep;
+                    return convertMessageToTracedFormat({
+                        content: content ?? outputs.outputs.text,
+                        role: "assistant",
+                    });
+                }
+                else {
+                    return outputs;
+                }
+            },
+        });
+        return traceableFunc(...args);
+    };
+    /**
+     * Wrapped version of AI SDK 5's generateObject with LangSmith tracing.
+     *
+     * This function has the same signature and behavior as the original generateObject,
+     * but adds automatic tracing to LangSmith for observability.
+     *
+     * ```ts
+     * import * as ai from "ai";
+     * import { wrapAISDK } from "langsmith/experimental/vercel";
+     *
+     * const { generateObject } = wrapAISDK(ai);
+     * const { object } = await generateObject(...);
+     * ```
+     *
+     * @see {@link https://sdk.vercel.ai/docs/ai-sdk-core/generating-structured-data} Original generateObject documentation
+     * @param params - Same parameters as the original generateObject function
+     * @returns Promise resolving to the same result as generateObject, with tracing applied
+     */
+    const wrappedGenerateObject = async (...args) => {
+        const params = args[0];
+        const { langsmith: runtimeLsConfig, ...providerOptions } = params.providerOptions ?? {};
+        const { resolvedLsConfig, resolvedChildLLMRunConfig } = _resolveConfigs(baseLsConfig, runtimeLsConfig);
+        const traceableFunc = traceable(async (...args) => {
+            const [params, ...rest] = args;
+            const wrappedModel = wrapLanguageModel({
+                model: params.model,
+                middleware: LangSmithMiddleware({
+                    name: _getModelDisplayName(params.model),
+                    modelId: _getModelId(params.model),
+                    lsConfig: resolvedChildLLMRunConfig,
+                }),
+            });
+            return generateObject({
+                ...params,
+                providerOptions,
+                model: wrappedModel,
+            }, ...rest);
+        }, {
+            name: _getModelDisplayName(params.model),
+            ...resolvedLsConfig,
+            metadata: {
+                ai_sdk_method: "ai.generateObject",
+                ...resolvedLsConfig?.metadata,
+            },
+            processInputs: (inputs) => {
+                const inputFormatter = resolvedLsConfig?.processInputs ?? _formatTracedInputs;
+                return inputFormatter(inputs);
+            },
+            processOutputs: (outputs) => {
+                if (resolvedLsConfig?.processOutputs) {
+                    return resolvedLsConfig.processOutputs(outputs);
+                }
+                if (outputs.outputs == null || typeof outputs.outputs !== "object") {
+                    return outputs;
+                }
+                return outputs.outputs.object ?? outputs;
+            },
+        });
+        return traceableFunc(...args);
+    };
+    /**
+     * Wrapped version of AI SDK 5's streamText with LangSmith tracing.
+     *
+     * Must be called with `await`, but otherwise behaves the same as the
+     * original streamText and adds adds automatic tracing to LangSmith
+     * for observability.
+     *
+     * ```ts
+     * import * as ai from "ai";
+     * import { wrapAISDK } from "langsmith/experimental/vercel";
+     *
+     * const { streamText } = wrapAISDK(ai);
+     * const { textStream } = await streamText(...);
+     * ```
+     *
+     * @see {@link https://sdk.vercel.ai/docs/ai-sdk-core/generating-text} Original streamText documentation
+     * @param params - Same parameters as the original streamText function
+     * @returns Promise resolving to the same result as streamText, with tracing applied
+     */
+    const wrappedStreamText = (...args) => {
+        const params = args[0];
+        const { langsmith: runtimeLsConfig, ...providerOptions } = params.providerOptions ?? {};
+        const { resolvedLsConfig, resolvedChildLLMRunConfig, resolvedToolConfig } = _resolveConfigs(baseLsConfig, runtimeLsConfig);
+        const traceableFunc = traceable((...args) => {
+            const [params, ...rest] = args;
+            const wrappedModel = wrapLanguageModel({
+                model: params.model,
+                middleware: LangSmithMiddleware({
+                    name: _getModelDisplayName(params.model),
+                    modelId: _getModelId(params.model),
+                    lsConfig: resolvedChildLLMRunConfig,
+                }),
+            });
+            return streamText({
+                ...params,
+                providerOptions,
+                tools: _wrapTools(params.tools, resolvedToolConfig),
+                model: wrappedModel,
+            }, ...rest);
+        }, {
+            name: _getModelDisplayName(params.model),
+            ...resolvedLsConfig,
+            metadata: {
+                ai_sdk_method: "ai.streamText",
+                ...resolvedLsConfig?.metadata,
+            },
+            processInputs: (inputs) => {
+                const inputFormatter = resolvedLsConfig?.processInputs ?? _formatTracedInputs;
+                return inputFormatter(inputs);
+            },
+            processOutputs: async (outputs) => {
+                try {
+                    if (resolvedLsConfig?.processOutputs) {
+                        return resolvedLsConfig.processOutputs(outputs);
+                    }
+                    if (outputs.outputs == null ||
+                        typeof outputs.outputs !== "object") {
+                        return outputs;
+                    }
+                    // Important: Even accessing this property creates a promise.
+                    // This must be awaited.
+                    let content = await outputs.outputs.content;
+                    if (content == null) {
+                        // AI SDK 4 shim
+                        content = await outputs.outputs.text;
+                    }
+                    if (content == null ||
+                        !["object", "string"].includes(typeof content)) {
+                        return outputs;
+                    }
+                    return convertMessageToTracedFormat({
+                        content,
+                        role: "assistant",
+                    });
+                }
+                catch (e) {
+                    // Handle parsing failures without a log
+                    return outputs;
+                }
+            },
+        });
+        return traceableFunc(...args);
+    };
+    /**
+     * Wrapped version of AI SDK 5's streamObject with LangSmith tracing.
+     *
+     * Must be called with `await`, but otherwise behaves the same as the
+     * original streamObject and adds adds automatic tracing to LangSmith
+     * for observability.
+     *
+     * ```ts
+     * import * as ai from "ai";
+     * import { wrapAISDK } from "langsmith/experimental/vercel";
+     *
+     * const { streamObject } = wrapAISDK(ai);
+     * const { partialObjectStream } = await streamObject(...);
+     * ```
+     *
+     * @see {@link https://sdk.vercel.ai/docs/ai-sdk-core/generating-structured-data} Original streamObject documentation
+     * @param params - Same parameters as the original streamObject function
+     * @returns Promise resolving to the same result as streamObject, with tracing applied
+     */
+    const wrappedStreamObject = (...args) => {
+        const params = args[0];
+        const { langsmith: runtimeLsConfig, ...providerOptions } = params.providerOptions ?? {};
+        const { resolvedLsConfig, resolvedChildLLMRunConfig } = _resolveConfigs(baseLsConfig, runtimeLsConfig);
+        const traceableFunc = traceable((...args) => {
+            const [params, ...rest] = args;
+            const wrappedModel = wrapLanguageModel({
+                model: params.model,
+                middleware: LangSmithMiddleware({
+                    name: _getModelDisplayName(params.model),
+                    modelId: _getModelId(params.model),
+                    lsConfig: resolvedChildLLMRunConfig,
+                }),
+            });
+            return streamObject({
+                ...params,
+                providerOptions,
+                model: wrappedModel,
+            }, ...rest);
+        }, {
+            name: _getModelDisplayName(params.model),
+            ...resolvedLsConfig,
+            metadata: {
+                ai_sdk_method: "ai.streamObject",
+                ...resolvedLsConfig?.metadata,
+            },
+            processInputs: (inputs) => {
+                const inputFormatter = resolvedLsConfig?.processInputs ?? _formatTracedInputs;
+                return inputFormatter(inputs);
+            },
+            processOutputs: async (outputs) => {
+                try {
+                    if (resolvedLsConfig?.processOutputs) {
+                        return resolvedLsConfig.processOutputs(outputs);
+                    }
+                    if (outputs.outputs == null ||
+                        typeof outputs.outputs !== "object") {
+                        return outputs;
+                    }
+                    const object = await outputs.outputs.object;
+                    if (object == null || typeof object !== "object") {
+                        return outputs;
+                    }
+                    return object;
+                }
+                catch (e) {
+                    // Handle parsing failures without a log
+                    return outputs;
+                }
+            },
+        });
+        return traceableFunc(...args);
+    };
+    return {
+        generateText: wrappedGenerateText,
+        generateObject: wrappedGenerateObject,
+        streamText: wrappedStreamText,
+        streamObject: wrappedStreamObject,
+    };
+};
+export { wrapAISDK };

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/experimental/vercel/middleware.cjs

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LangSmithMiddleware = LangSmithMiddleware;
+const traceable_js_1 = require("../../traceable.cjs");
+const vercel_js_1 = require("../../utils/vercel.cjs");
+const utils_js_1 = require("./utils.cjs");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const _formatTracedInputs = (params) => {
+    const { prompt, ...rest } = params;
+    if (prompt == null) {
+        return params;
+    }
+    if (Array.isArray(prompt)) {
+        return { ...rest, messages: prompt.map(utils_js_1.convertMessageToTracedFormat) };
+    }
+    return rest;
+};
+const _formatTracedOutputs = (outputs) => {
+    const formattedOutputs = { ...outputs };
+    if (formattedOutputs.role == null) {
+        formattedOutputs.role = formattedOutputs.type ?? "assistant";
+    }
+    return (0, utils_js_1.convertMessageToTracedFormat)(formattedOutputs);
+};
+const setUsageMetadataOnRunTree = (result, runTree) => {
+    if (result.usage == null || typeof result.usage !== "object") {
+        return;
+    }
+    // Shim for AI SDK 4
+    const inputTokens = result.usage?.inputTokens ??
+        result.usage?.promptTokens;
+    const outputTokens = result.usage?.outputTokens ??
+        result.usage?.completionTokens;
+    let totalTokens = result.usage?.totalTokens;
+    if (typeof totalTokens !== "number" &&
+        typeof inputTokens === "number" &&
+        typeof outputTokens === "number") {
+        totalTokens = inputTokens + outputTokens;
+    }
+    const langsmithUsage = {
+        input_tokens: inputTokens,
+        output_tokens: outputTokens,
+        total_tokens: totalTokens,
+    };
+    const inputTokenDetails = (0, vercel_js_1.extractInputTokenDetails)(result.usage, result.providerMetadata);
+    const outputTokenDetails = (0, vercel_js_1.extractOutputTokenDetails)(result.usage, result.providerMetadata);
+    runTree.extra = {
+        ...runTree.extra,
+        metadata: {
+            ...runTree.extra?.metadata,
+            usage_metadata: {
+                ...langsmithUsage,
+                input_token_details: {
+                    ...inputTokenDetails,
+                },
+                output_token_details: {
+                    ...outputTokenDetails,
+                },
+            },
+        },
+    };
+};
+/**
+ * AI SDK middleware that wraps an AI SDK 5 model and adds LangSmith tracing.
+ */
+function LangSmithMiddleware(config) {
+    const { name, modelId, lsConfig } = config ?? {};
+    return {
+        wrapGenerate: async ({ doGenerate, params }) => {
+            const traceableFunc = (0, traceable_js_1.traceable)(async (_params) => {
+                const result = await doGenerate();
+                const currentRunTree = (0, traceable_js_1.getCurrentRunTree)(true);
+                if (currentRunTree !== undefined) {
+                    setUsageMetadataOnRunTree(result, currentRunTree);
+                }
+                return result;
+            }, {
+                ...lsConfig,
+                name: name ?? "ai.doGenerate",
+                run_type: "llm",
+                metadata: {
+                    ls_model_name: modelId,
+                    ai_sdk_method: "ai.doGenerate",
+                    ...lsConfig?.metadata,
+                },
+                processInputs: (inputs) => {
+                    const typedInputs = inputs;
+                    const inputFormatter = lsConfig?.processInputs ?? _formatTracedInputs;
+                    return inputFormatter(typedInputs);
+                },
+                processOutputs: (outputs) => {
+                    const typedOutputs = outputs;
+                    const outputFormatter = lsConfig?.processOutputs ?? _formatTracedOutputs;
+                    return outputFormatter(typedOutputs);
+                },
+            });
+            const res = await traceableFunc(params);
+            return res;
+        },
+        wrapStream: async ({ doStream, params }) => {
+            const parentRunTree = (0, traceable_js_1.getCurrentRunTree)(true);
+            let runTree;
+            if (parentRunTree != null &&
+                typeof parentRunTree === "object" &&
+                typeof parentRunTree.createChild === "function") {
+                const inputFormatter = lsConfig?.processInputs ?? _formatTracedInputs;
+                const formattedInputs = inputFormatter(params);
+                runTree = parentRunTree?.createChild({
+                    ...lsConfig,
+                    name: name ?? "ai.doStream",
+                    run_type: "llm",
+                    metadata: {
+                        ls_model_name: modelId,
+                        ai_sdk_method: "ai.doStream",
+                        ...lsConfig?.metadata,
+                    },
+                    inputs: formattedInputs,
+                });
+            }
+            await runTree?.postRun();
+            try {
+                const { stream, ...rest } = await doStream();
+                const chunks = [];
+                const transformStream = new TransformStream({
+                    async transform(chunk, controller) {
+                        if (chunk.type === "tool-input-start" ||
+                            chunk.type === "text-start") {
+                            // Only necessary to log the first token event
+                            if (runTree?.events == null ||
+                                (Array.isArray(runTree.events) && runTree.events.length === 0)) {
+                                runTree?.addEvent({ name: "new_token" });
+                            }
+                        }
+                        else if (chunk.type === "finish") {
+                            runTree?.addEvent({ name: "end" });
+                        }
+                        chunks.push(chunk);
+                        controller.enqueue(chunk);
+                    },
+                    async flush() {
+                        try {
+                            const output = chunks.reduce((aggregated, chunk) => {
+                                if (chunk.type === "text-delta") {
+                                    if (chunk.delta != null) {
+                                        return {
+                                            ...aggregated,
+                                            content: aggregated.content + chunk.delta,
+                                        };
+                                    }
+                                    else if ("textDelta" in chunk &&
+                                        chunk.textDelta != null) {
+                                        // AI SDK 4 shim
+                                        return {
+                                            ...aggregated,
+                                            content: aggregated.content + chunk.textDelta,
+                                        };
+                                    }
+                                    else {
+                                        return aggregated;
+                                    }
+                                }
+                                else if (chunk.type === "tool-call") {
+                                    const matchingToolCall = aggregated.tool_calls.find((call) => call.id === chunk.toolCallId);
+                                    if (matchingToolCall != null) {
+                                        return aggregated;
+                                    }
+                                    let chunkArgs = chunk.input;
+                                    if (chunkArgs == null &&
+                                        "args" in chunk &&
+                                        typeof chunk.args === "string") {
+                                        chunkArgs = chunk.args;
+                                    }
+                                    return {
+                                        ...aggregated,
+                                        tool_calls: [
+                                            ...aggregated.tool_calls,
+                                            {
+                                                id: chunk.toolCallId,
+                                                type: "function",
+                                                function: {
+                                                    name: chunk.toolName,
+                                                    arguments: chunkArgs,
+                                                },
+                                            },
+                                        ],
+                                    };
+                                }
+                                else if (chunk.type === "finish") {
+                                    if (runTree != null) {
+                                        setUsageMetadataOnRunTree(chunk, runTree);
+                                    }
+                                    return {
+                                        ...aggregated,
+                                        providerMetadata: chunk.providerMetadata,
+                                        finishReason: chunk.finishReason,
+                                    };
+                                }
+                                else {
+                                    return aggregated;
+                                }
+                            }, {
+                                content: "",
+                                role: "assistant",
+                                tool_calls: [],
+                            });
+                            const outputFormatter = lsConfig?.processOutputs ?? utils_js_1.convertMessageToTracedFormat;
+                            const formattedOutputs = await outputFormatter(output);
+                            await runTree?.end(formattedOutputs);
+                        }
+                        catch (error) {
+                            await runTree?.end(undefined, error.message ?? String(error));
+                            throw error;
+                        }
+                        finally {
+                            await runTree?.patchRun({
+                                excludeInputs: true,
+                            });
+                        }
+                    },
+                });
+                return {
+                    stream: stream.pipeThrough(transformStream),
+                    ...rest,
+                };
+            }
+            catch (error) {
+                await runTree?.end(undefined, error.message ?? String(error));
+                await runTree?.patchRun({
+                    excludeInputs: true,
+                });
+                throw error;
+            }
+        },
+    };
+}