@nocobase/plugin-ai 1.9.32 → 1.9.34

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

@@ -1,8 +1,10 @@
+import { extractUsageMetadata } from "./utils/vercel.js";
 import { Client, RunTree } from "./index.js";
 import { v5 as uuid5 } from "uuid";
 import { getCurrentRunTree } from "./singletons/traceable.js";
 import { getLangSmithEnvironmentVariable, getEnvironmentVariable, } from "./utils/env.js";
 import { isTracingEnabled } from "./env.js";
+import { LANGSMITH_IS_ROOT, LANGSMITH_TRACEABLE_PARENT_OTEL_SPAN_ID, } from "./experimental/otel/constants.js";
 // Attempt to convert CoreMessage to a LangChain-compatible format
 // which allows us to render messages more nicely in LangSmith
 function convertCoreToSmith(message) {
@@ -14,15 +16,22 @@ function convertCoreToSmith(message) {
                     return {
                         type: "text",
                         text: part.text,
+                        // Backcompat for AI SDK 4
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
                         ...part.experimental_providerMetadata,
                     };
                 }
                 if (part.type === "tool-call") {
+                    // Backcompat for AI SDK 4
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const legacyToolCallInput = part.args;
                     return {
                         type: "tool_use",
                         name: part.toolName,
                         id: part.toolCallId,
-                        input: part.args,
+                        input: legacyToolCallInput ?? part.input,
+                        // Backcompat for AI SDK 4
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
                         ...part.experimental_providerMetadata,
                     };
                 }
@@ -32,13 +41,16 @@ function convertCoreToSmith(message) {
             if (toolCalls.length > 0) {
                 data.additional_kwargs ??= {};
                 data.additional_kwargs.tool_calls = toolCalls.map((part) => {
+                    // Backcompat for AI SDK 4
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const legacyToolCallInput = part.args;
                     return {
                         id: part.toolCallId,
                         type: "function",
                         function: {
                             name: part.toolName,
                             id: part.toolCallId,
-                            arguments: JSON.stringify(part.args),
+                            arguments: JSON.stringify(legacyToolCallInput ?? part.input),
                         },
                     };
                 });
@@ -54,13 +66,44 @@ function convertCoreToSmith(message) {
                     return {
                         type: "text",
                         text: part.text,
+                        // Backcompat for AI SDK 4
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
                         ...part.experimental_providerMetadata,
                     };
                 }
                 if (part.type === "image") {
+                    let imageUrl = part.image;
+                    if (typeof imageUrl !== "string") {
+                        let uint8Array;
+                        if (imageUrl != null &&
+                            typeof imageUrl === "object" &&
+                            "type" in imageUrl &&
+                            "data" in imageUrl) {
+                            // Typing is wrong here if a buffer is passed in
+                            uint8Array = new Uint8Array(imageUrl.data);
+                        }
+                        else if (imageUrl != null &&
+                            typeof imageUrl === "object" &&
+                            Object.keys(imageUrl).every((key) => !isNaN(Number(key)))) {
+                            // ArrayBuffers get turned into objects with numeric keys for some reason
+                            uint8Array = new Uint8Array(Array.from({
+                                ...imageUrl,
+                                length: Object.keys(imageUrl).length,
+                            }));
+                        }
+                        if (uint8Array) {
+                            let binary = "";
+                            for (let i = 0; i < uint8Array.length; i++) {
+                                binary += String.fromCharCode(uint8Array[i]);
+                            }
+                            imageUrl = btoa(binary);
+                        }
+                    }
                     return {
                         type: "image_url",
-                        image_url: part.image,
+                        image_url: imageUrl,
+                        // Backcompat for AI SDK 4
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
                         ...part.experimental_providerMetadata,
                     };
                 }
@@ -74,10 +117,13 @@ function convertCoreToSmith(message) {
     }
     if (message.role === "tool") {
         const res = message.content.map((toolCall) => {
+            // Backcompat for AI SDK 4
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const legacyToolCallResult = toolCall.result;
             return {
                 type: "tool",
                 data: {
-                    content: JSON.stringify(toolCall.result),
+                    content: JSON.stringify(legacyToolCallResult ?? toolCall.output),
                     name: toolCall.toolName,
                     tool_call_id: toolCall.toolCallId,
                 },
@@ -131,6 +177,21 @@ function reparentDotOrder(dotOrder, sourceRunId, parentDotOrder) {
         return dotOrder;
     return joinDotOrder(...parentDotOrder.split("."), ...segments.slice(sourceIndex));
 }
+// Helper function to convert dotted order version of start time to ISO string
+export const parseStrippedIsoTime = (stripped) => {
+    const year = stripped.slice(0, 4);
+    const month = stripped.slice(4, 6);
+    const day = stripped.slice(6, 8);
+    const hour = stripped.slice(9, 11); // Skip 'T'
+    const minute = stripped.slice(11, 13);
+    const second = stripped.slice(13, 15);
+    const ms = stripped.slice(15, 18); // milliseconds
+    const us = stripped.length >= 21 ? stripped.slice(18, 21) : "000"; // microseconds
+    // Create ISO string with microsecond precision only if microseconds are present
+    return us !== "000"
+        ? `${year}-${month}-${day}T${hour}:${minute}:${second}.${ms}${us}Z`
+        : `${year}-${month}-${day}T${hour}:${minute}:${second}.${ms}Z`;
+};
 function getMutableRunCreate(dotOrder) {
     const segments = dotOrder.split(".").map((i) => {
         const [startTime, runId] = i.split("Z");
@@ -139,12 +200,14 @@ function getMutableRunCreate(dotOrder) {
     const traceId = segments[0].runId;
     const parentRunId = segments.at(-2)?.runId;
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const runId = segments.at(-1).runId;
+    const lastSegment = segments.at(-1);
+    const startTime = parseStrippedIsoTime(lastSegment.startTime);
     return {
-        id: runId,
+        id: lastSegment.runId,
         trace_id: traceId,
         dotted_order: dotOrder,
         parent_run_id: parentRunId,
+        start_time: startTime,
     };
 }
 function convertToTimestamp([seconds, nanoseconds]) {
@@ -152,9 +215,21 @@ function convertToTimestamp([seconds, nanoseconds]) {
     return Number(String(seconds) + ms);
 }
 function sortByHr(a, b) {
-    if (a[0] !== b[0])
-        return Math.sign(a[0] - b[0]);
-    return Math.sign(a[1] - b[1]);
+    if (a.startTime[0] !== b.startTime[0]) {
+        return Math.sign(a.startTime[0] - b.startTime[0]);
+    }
+    else if (a.startTime[1] !== b.startTime[1]) {
+        return Math.sign(a.startTime[1] - b.startTime[1]);
+    }
+    else if (getParentSpanId(a) === b.spanContext().spanId) {
+        return -1;
+    }
+    else if (getParentSpanId(b) === a.spanContext().spanId) {
+        return 1;
+    }
+    else {
+        return 0;
+    }
 }
 const ROOT = "$";
 const RUN_ID_NAMESPACE = "5c718b20-9078-11ef-9a3d-325096b39f47";
@@ -180,7 +255,13 @@ const RESERVED_METADATA_KEYS = [
     TRACE_METADATA_KEY.output,
     BAGGAGE_METADATA_KEY.output,
 ];
+function getParentSpanId(span) {
+    // Backcompat shim to support OTEL 1.x and 2.x
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return (span.parentSpanId ?? span.parentSpanContext?.spanId ?? undefined);
+}
 /**
+ * @deprecated Use `wrapAISDK` from `langsmith/experimental/vercel` instead.
  * OpenTelemetry trace exporter for Vercel AI SDK.
  *
  * @example
@@ -234,12 +315,30 @@ export class AISDKExporter {
             writable: true,
             value: {}
         });
+        Object.defineProperty(this, "seenSpanInfo", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "pendingSpans", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
         Object.defineProperty(this, "debug", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "projectName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         /** @internal */
         Object.defineProperty(this, "getSpanAttributeKey", {
             enumerable: true,
@@ -255,6 +354,7 @@ export class AISDKExporter {
         this.client = args?.client ?? new Client();
         this.debug =
             args?.debug ?? getEnvironmentVariable("OTEL_LOG_LEVEL") === "DEBUG";
+        this.projectName = args?.projectName;
         this.logDebug("creating exporter", { tracingEnabled: isTracingEnabled() });
     }
     static getSettings(settings) {
@@ -286,9 +386,12 @@ export class AISDKExporter {
         return { ...rest, isEnabled: rest.isEnabled ?? defaultEnabled, metadata };
     }
     /** @internal */
-    parseInteropFromMetadata(span) {
+    parseInteropFromMetadata(span, parentSpan) {
         if (!this.isRootRun(span))
             return undefined;
+        if (parentSpan?.name === "ai.toolCall") {
+            return undefined;
+        }
         const userTraceId = this.getSpanAttributeKey(span, RUN_ID_METADATA_KEY.output);
         const parentTrace = this.getSpanAttributeKey(span, TRACE_METADATA_KEY.output);
         if (parentTrace && userTraceId) {
@@ -308,7 +411,7 @@ export class AISDKExporter {
         return undefined;
     }
     /** @internal */
-    getRunCreate(span) {
+    getRunCreate(span, projectName) {
         const asRunCreate = (rawConfig) => {
             const aiMetadata = Object.keys(span.attributes)
                 .filter((key) => key.startsWith("ai.telemetry.metadata.") &&
@@ -344,7 +447,9 @@ export class AISDKExporter {
                         "ai.operationId": span.attributes["ai.operationId"],
                     },
                 },
-                session_name: getLangSmithEnvironmentVariable("PROJECT") ??
+                session_name: projectName ??
+                    this.projectName ??
+                    getLangSmithEnvironmentVariable("PROJECT") ??
                     getLangSmithEnvironmentVariable("SESSION"),
                 start_time: Math.min(parsedStart, parsedEnd),
                 end_time: Math.max(parsedStart, parsedEnd),
@@ -402,22 +507,24 @@ export class AISDKExporter {
                             }),
                         };
                     }
-                    if (span.attributes["ai.usage.completionTokens"]) {
-                        result ??= {};
-                        result.llm_output ??= {};
-                        result.llm_output.token_usage ??= {};
-                        result.llm_output.token_usage["completion_tokens"] =
-                            span.attributes["ai.usage.completionTokens"];
-                    }
-                    if (span.attributes["ai.usage.promptTokens"]) {
-                        result ??= {};
-                        result.llm_output ??= {};
-                        result.llm_output.token_usage ??= {};
-                        result.llm_output.token_usage["prompt_tokens"] =
-                            span.attributes["ai.usage.promptTokens"];
-                    }
                     return result;
                 })();
+                const invocationParams = (() => {
+                    if ("ai.prompt.tools" in span.attributes) {
+                        return {
+                            tools: span.attributes["ai.prompt.tools"].flatMap((tool) => {
+                                try {
+                                    return JSON.parse(tool);
+                                }
+                                catch {
+                                    // pass
+                                }
+                                return [];
+                            }),
+                        };
+                    }
+                    return {};
+                })();
                 const events = [];
                 const firstChunkEvent = span.events.find((i) => i.name === "ai.stream.firstChunk");
                 if (firstChunkEvent) {
@@ -426,16 +533,24 @@ export class AISDKExporter {
                         time: convertToTimestamp(firstChunkEvent.time),
                     });
                 }
+                const runType = span.name === "ai.generateText" || span.name === "ai.streamText"
+                    ? "chain"
+                    : "llm";
+                const error = span.status?.code === 2 ? span.status.message : undefined;
+                const usageMetadata = extractUsageMetadata(span);
                 // TODO: add first_token_time
                 return asRunCreate({
-                    run_type: "llm",
+                    run_type: runType,
                     name: span.attributes["ai.model.provider"],
+                    error,
                     inputs,
                     outputs,
                     events,
                     extra: {
+                        invocation_params: invocationParams,
                         batch_size: 1,
                         metadata: {
+                            usage_metadata: usageMetadata,
                             ls_provider: span.attributes["ai.model.provider"]
                                 .split(".")
                                 .at(0),
@@ -448,19 +563,34 @@ export class AISDKExporter {
                 });
             }
             case "ai.toolCall": {
-                const args = tryJson(span.attributes["ai.toolCall.args"]);
+                const args = tryJson(span.attributes["ai.toolCall.input"] ??
+                    span.attributes["ai.toolCall.args"]);
                 let inputs = { args };
                 if (typeof args === "object" && args != null) {
                     inputs = args;
                 }
-                const output = tryJson(span.attributes["ai.toolCall.result"]);
+                const output = tryJson(span.attributes["ai.toolCall.output"] ??
+                    span.attributes["ai.toolCall.result"]);
                 let outputs = { output };
                 if (typeof output === "object" && output != null) {
                     outputs = output;
                 }
+                const error = span.status?.code === 2 ? span.status.message : undefined;
                 return asRunCreate({
                     run_type: "tool",
                     name: span.attributes["ai.toolCall.name"],
+                    error,
+                    extra: error
+                        ? {
+                            metadata: {
+                                usage_metadata: {
+                                    input_tokens: 0,
+                                    output_tokens: 0,
+                                    total_tokens: 0,
+                                },
+                            },
+                        }
+                        : undefined,
                     inputs,
                     outputs,
                 });
@@ -487,20 +617,6 @@ export class AISDKExporter {
                             output: tryJson(span.attributes["ai.response.object"]),
                         };
                     }
-                    if (span.attributes["ai.usage.completionTokens"]) {
-                        result ??= {};
-                        result.llm_output ??= {};
-                        result.llm_output.token_usage ??= {};
-                        result.llm_output.token_usage["completion_tokens"] =
-                            span.attributes["ai.usage.completionTokens"];
-                    }
-                    if (span.attributes["ai.usage.promptTokens"]) {
-                        result ??= {};
-                        result.llm_output ??= {};
-                        result.llm_output.token_usage ??= {};
-                        result.llm_output.token_usage["prompt_tokens"] =
-                            +span.attributes["ai.usage.promptTokens"];
-                    }
                     return result;
                 })();
                 const events = [];
@@ -511,15 +627,22 @@ export class AISDKExporter {
                         time: convertToTimestamp(firstChunkEvent.time),
                     });
                 }
+                const runType = span.name === "ai.generateObject" || span.name === "ai.streamObject"
+                    ? "chain"
+                    : "llm";
+                const error = span.status?.code === 2 ? span.status.message : undefined;
+                const usageMetadata = extractUsageMetadata(span);
                 return asRunCreate({
-                    run_type: "llm",
+                    run_type: runType,
                     name: span.attributes["ai.model.provider"],
+                    error,
                     inputs,
                     outputs,
                     events,
                     extra: {
                         batch_size: 1,
                         metadata: {
+                            usage_metadata: usageMetadata,
                             ls_provider: span.attributes["ai.model.provider"]
                                 .split(".")
                                 .at(0),
@@ -553,35 +676,85 @@ export class AISDKExporter {
                 return false;
         }
     }
-    export(spans, resultCallback) {
+    _export(spans, resultCallback) {
         this.logDebug("exporting spans", spans);
         const typedSpans = spans
+            .concat(Object.values(this.pendingSpans))
             .slice()
-            .sort((a, b) => sortByHr(a.startTime, b.startTime));
+            // Parent spans should go before child spans in the final order,
+            // but may have the same exact start time as their children.
+            // They will end earlier, so break ties by end time.
+            // TODO: Figure out why this happens.
+            .sort((a, b) => sortByHr(a, b));
         for (const span of typedSpans) {
             const { traceId, spanId } = span.spanContext();
-            const parentId = span.parentSpanId ?? undefined;
+            const runId = uuid5(spanId, RUN_ID_NAMESPACE);
+            let parentId = getParentSpanId(span);
+            if (LANGSMITH_IS_ROOT in span.attributes) {
+                parentId = undefined;
+            }
+            else if (LANGSMITH_TRACEABLE_PARENT_OTEL_SPAN_ID in span.attributes &&
+                typeof span.attributes[LANGSMITH_TRACEABLE_PARENT_OTEL_SPAN_ID] ===
+                    "string") {
+                parentId = span.attributes[LANGSMITH_TRACEABLE_PARENT_OTEL_SPAN_ID];
+            }
+            let parentRunId = parentId
+                ? uuid5(parentId, RUN_ID_NAMESPACE)
+                : undefined;
+            let parentSpanInfo = parentRunId
+                ? this.seenSpanInfo[parentRunId]
+                : undefined;
+            // Unrelated, untraced spans should behave as passthroughs from LangSmith's perspective.
+            while (parentSpanInfo != null &&
+                this.getRunCreate(parentSpanInfo.span) == null) {
+                parentId = getParentSpanId(parentSpanInfo.span);
+                if (parentId == null) {
+                    break;
+                }
+                parentRunId = parentId ? uuid5(parentId, RUN_ID_NAMESPACE) : undefined;
+                parentSpanInfo = parentRunId
+                    ? this.seenSpanInfo[parentRunId]
+                    : undefined;
+            }
+            // Export may be called in any order, so we need to queue any spans with missing parents
+            // for retry later in order to determine whether their parents are tool calls
+            // and should not be reparented below.
+            if (parentRunId !== undefined && parentSpanInfo === undefined) {
+                this.pendingSpans[spanId] = span;
+                continue;
+            }
+            else {
+                delete this.pendingSpans[spanId];
+            }
             this.traceByMap[traceId] ??= {
                 childMap: {},
                 nodeMap: {},
                 relativeExecutionOrder: {},
             };
-            const runId = uuid5(spanId, RUN_ID_NAMESPACE);
-            const parentRunId = parentId
-                ? uuid5(parentId, RUN_ID_NAMESPACE)
-                : undefined;
             const traceMap = this.traceByMap[traceId];
-            const run = this.getRunCreate(span);
             traceMap.relativeExecutionOrder[parentRunId ?? ROOT] ??= -1;
             traceMap.relativeExecutionOrder[parentRunId ?? ROOT] += 1;
+            const interop = this.parseInteropFromMetadata(span, parentSpanInfo?.span);
+            const projectName = (interop?.type === "traceable"
+                ? interop.parentRunTree.project_name
+                : undefined) ?? parentSpanInfo?.projectName;
+            const run = this.getRunCreate(span, projectName);
             traceMap.nodeMap[runId] ??= {
                 id: runId,
                 startTime: span.startTime,
                 run,
                 sent: false,
-                interop: this.parseInteropFromMetadata(span),
+                interop,
                 executionOrder: traceMap.relativeExecutionOrder[parentRunId ?? ROOT],
             };
+            if (this.seenSpanInfo[runId] == null) {
+                this.seenSpanInfo[runId] = {
+                    span,
+                    dotOrder: joinDotOrder(parentSpanInfo?.dotOrder, getDotOrder(traceMap.nodeMap[runId])),
+                    projectName,
+                    sent: false,
+                };
+            }
             if (this.debug)
                 console.log(`[${span.name}] ${runId}`, run);
             traceMap.childMap[parentRunId ?? ROOT] ??= [];
@@ -591,64 +764,80 @@ export class AISDKExporter {
         const actions = [];
         for (const traceId of Object.keys(this.traceByMap)) {
             const traceMap = this.traceByMap[traceId];
-            const queue = traceMap.childMap[ROOT]?.map((item) => ({
-                item,
-                dotOrder: getDotOrder(item),
-            })) ?? [];
+            const queue = Object.keys(traceMap.childMap)
+                .map((runId) => {
+                if (runId === ROOT) {
+                    return traceMap.childMap[runId];
+                }
+                return [];
+            })
+                .flat();
             const seen = new Set();
             while (queue.length) {
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 const task = queue.shift();
-                if (seen.has(task.item.id))
+                if (seen.has(task.id))
                     continue;
-                if (!task.item.sent) {
-                    if (task.item.run != null) {
-                        if (task.item.interop?.type === "user") {
+                let taskDotOrder = this.seenSpanInfo[task.id].dotOrder;
+                if (!task.sent) {
+                    if (task.run != null) {
+                        if (task.interop?.type === "user") {
                             actions.push({
                                 type: "rename",
-                                sourceRunId: task.item.id,
-                                targetRunId: task.item.interop.userRunId,
+                                sourceRunId: task.id,
+                                targetRunId: task.interop.userRunId,
                             });
                         }
-                        if (task.item.interop?.type === "traceable") {
+                        if (task.interop?.type === "traceable") {
                             actions.push({
                                 type: "reparent",
-                                runId: task.item.id,
-                                parentDotOrder: task.item.interop.parentRunTree.dotted_order,
+                                runId: task.id,
+                                parentDotOrder: task.interop.parentRunTree.dotted_order,
                             });
                         }
-                        let dotOrder = task.dotOrder;
                         for (const action of actions) {
                             if (action.type === "delete") {
-                                dotOrder = removeDotOrder(dotOrder, action.runId);
+                                taskDotOrder = removeDotOrder(taskDotOrder, action.runId);
                             }
                             if (action.type === "reparent") {
-                                dotOrder = reparentDotOrder(dotOrder, action.runId, action.parentDotOrder);
+                                taskDotOrder = reparentDotOrder(taskDotOrder, action.runId, action.parentDotOrder);
                             }
                             if (action.type === "rename") {
-                                dotOrder = dotOrder.replace(action.sourceRunId, action.targetRunId);
+                                taskDotOrder = taskDotOrder.replace(action.sourceRunId, action.targetRunId);
                             }
                         }
-                        sampled.push({
-                            ...task.item.run,
-                            ...getMutableRunCreate(dotOrder),
-                        });
+                        this.seenSpanInfo[task.id].dotOrder = taskDotOrder;
+                        if (!this.seenSpanInfo[task.id].sent) {
+                            sampled.push({
+                                ...task.run,
+                                ...getMutableRunCreate(taskDotOrder),
+                            });
+                        }
+                        this.seenSpanInfo[task.id].sent = true;
                     }
                     else {
-                        actions.push({ type: "delete", runId: task.item.id });
+                        actions.push({ type: "delete", runId: task.id });
                     }
-                    task.item.sent = true;
+                    task.sent = true;
                 }
-                const children = traceMap.childMap[task.item.id] ?? [];
-                queue.push(...children.map((item) => ({
-                    item,
-                    dotOrder: joinDotOrder(task.dotOrder, getDotOrder(item)),
-                })));
+                const children = traceMap.childMap[task.id] ?? [];
+                queue.push(...children);
             }
         }
         this.logDebug(`sampled runs to be sent to LangSmith`, sampled);
         Promise.all(sampled.map((run) => this.client.createRun(run))).then(() => resultCallback({ code: 0 }), (error) => resultCallback({ code: 1, error }));
     }
+    export(spans, resultCallback) {
+        this._export(spans, (result) => {
+            if (result.code === 0) {
+                // Empty export to try flushing pending spans to rule out any trace order shenanigans
+                this._export([], resultCallback);
+            }
+            else {
+                resultCallback(result);
+            }
+        });
+    }
     async shutdown() {
         // find nodes which are incomplete
         const incompleteNodes = Object.values(this.traceByMap).flatMap((trace) => Object.values(trace.nodeMap).filter((i) => !i.sent && i.run != null));
@@ -656,10 +845,13 @@ export class AISDKExporter {
         if (incompleteNodes.length > 0) {
             console.warn("Some incomplete nodes were found before shutdown and not sent to LangSmith.");
         }
-        await this.client?.awaitPendingTraceBatches();
+        await this.forceFlush();
     }
     async forceFlush() {
-        await this.client?.awaitPendingTraceBatches();
+        await new Promise((resolve) => {
+            this.export([], resolve);
+        });
+        await this.client.awaitPendingTraceBatches();
     }
     logDebug(...args) {
         if (!this.debug)

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/vitest/index.cjs

@@ -16,29 +16,31 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrapEvaluator = exports.logOutputs = exports.logFeedback = exports.expect = exports.describe = exports.it = exports.test = void 0;
+exports.wrapVitest = exports.wrapEvaluator = exports.logOutputs = exports.logFeedback = exports.expect = exports.describe = exports.it = exports.test = void 0;
 const vitest_1 = require("vitest");
 const matchers_js_1 = require("../utils/jestlike/matchers.cjs");
-const evaluatedBy_js_1 = require("../utils/jestlike/vendor/evaluatedBy.cjs");
-Object.defineProperty(exports, "wrapEvaluator", { enumerable: true, get: function () { return evaluatedBy_js_1.wrapEvaluator; } });
-const index_js_1 = require("../utils/jestlike/index.cjs");
-Object.defineProperty(exports, "logFeedback", { enumerable: true, get: function () { return index_js_1.logFeedback; } });
-Object.defineProperty(exports, "logOutputs", { enumerable: true, get: function () { return index_js_1.logOutputs; } });
-const index_js_2 = require("../utils/jestlike/index.cjs");
+const wrapper_js_1 = require("./utils/wrapper.cjs");
+Object.defineProperty(exports, "wrapVitest", { enumerable: true, get: function () { return wrapper_js_1.wrapVitest; } });
 vitest_1.expect.extend({
     toBeRelativeCloseTo: matchers_js_1.toBeRelativeCloseTo,
     toBeAbsoluteCloseTo: matchers_js_1.toBeAbsoluteCloseTo,
     toBeSemanticCloseTo: matchers_js_1.toBeSemanticCloseTo,
 });
-const { test, it, describe, expect } = (0, index_js_2.generateWrapperFromJestlikeMethods)({
+const { test, it, describe, expect, logFeedback, logOutputs, wrapEvaluator } = (0, wrapper_js_1.wrapVitest)({
     expect: vitest_1.expect,
+    it: vitest_1.it,
     test: vitest_1.test,
     describe: vitest_1.describe,
     beforeAll: vitest_1.beforeAll,
     afterAll: vitest_1.afterAll,
-}, "vitest");
+    beforeEach: vitest_1.beforeEach,
+    afterEach: vitest_1.afterEach,
+});
 exports.test = test;
 exports.it = it;
 exports.describe = describe;
 exports.expect = expect;
+exports.logFeedback = logFeedback;
+exports.logOutputs = logOutputs;
+exports.wrapEvaluator = wrapEvaluator;
 __exportStar(require("../utils/jestlike/types.cjs"), exports);