@langfuse/client 4.2.1 → 4.4.0

package/dist/index.mjs

@@ -150,7 +150,15 @@ var DatasetManager = class {
 };
 
 // src/experiment/ExperimentManager.ts
-import { getGlobalLogger } from "@langfuse/core";
+import {
+  getGlobalLogger,
+  propagateAttributes,
+  serializeValue,
+  createExperimentId,
+  createExperimentItemId,
+  LangfuseOtelSpanAttributes,
+  LANGFUSE_SDK_EXPERIMENT_ENVIRONMENT
+} from "@langfuse/core";
 import { startActiveObservation } from "@langfuse/tracing";
 import { ProxyTracerProvider, trace } from "@opentelemetry/api";
 var ExperimentManager = class {
@@ -380,44 +388,86 @@ var ExperimentManager = class {
    * @internal
    */
   async runItem(params) {
-    const { item, evaluators = [], task, experimentMetadata = {} } = params;
-    const { output, traceId, observationId } = await startActiveObservation(
-      "experiment-item-run",
-      async (span) => {
-        var _a;
-        const output2 = await task(item);
-        span.update({
-          input: item.input,
-          output: output2,
-          metadata: {
-            experiment_name: params.experimentName,
-            experiment_run_name: params.experimentRunName,
-            ...experimentMetadata,
-            ...(_a = item.metadata) != null ? _a : {},
-            ..."id" in item && "datasetId" in item ? {
-              dataset_id: item["datasetId"],
-              dataset_item_id: item["id"]
-            } : {}
-          }
-        });
-        return { output: output2, traceId: span.traceId, observationId: span.id };
+    const { item, evaluators = [], task, experimentMetadata } = params;
+    const { output, traceId, observationId, datasetRunId } = await startActiveObservation("experiment-item-run", async (span) => {
+      const input = item.input;
+      const expectedOutput = item.expectedOutput;
+      const itemMetadata = item.metadata;
+      const datasetId = "datasetId" in item ? item.datasetId : void 0;
+      const datasetItemId = "id" in item ? item.id : void 0;
+      const traceId2 = span.traceId;
+      const observationId2 = span.id;
+      if (input === void 0) {
+        throw new Error("Experiment item is missing input. Skipping item.");
       }
-    );
-    let datasetRunId = void 0;
-    if ("id" in item) {
-      await this.langfuseClient.api.datasetRunItems.create({
-        runName: params.experimentRunName,
-        runDescription: params.experimentDescription,
-        metadata: params.experimentMetadata,
-        datasetItemId: item.id,
-        traceId,
-        observationId
-      }).then((result) => {
-        datasetRunId = result.datasetRunId;
-      }).catch(
-        (err) => this.logger.error("Linking dataset run item failed", err)
+      let datasetRunId2 = void 0;
+      if (datasetItemId) {
+        try {
+          const result = await this.langfuseClient.api.datasetRunItems.create(
+            {
+              runName: params.experimentRunName,
+              runDescription: params.experimentDescription,
+              metadata: params.experimentMetadata,
+              datasetItemId,
+              traceId: traceId2,
+              observationId: observationId2
+            }
+          );
+          datasetRunId2 = result.datasetRunId;
+        } catch (err) {
+          this.logger.error("Linking dataset run item failed", err);
+        }
+      }
+      const experimentItemId = datasetItemId || await createExperimentItemId(input);
+      const experimentId = datasetRunId2 || await createExperimentId();
+      const rootSpanAttributes = {
+        [LangfuseOtelSpanAttributes.ENVIRONMENT]: LANGFUSE_SDK_EXPERIMENT_ENVIRONMENT
+      };
+      if (params.experimentDescription) {
+        rootSpanAttributes[LangfuseOtelSpanAttributes.EXPERIMENT_DESCRIPTION] = params.experimentDescription;
+      }
+      if (expectedOutput !== void 0) {
+        const serialized = serializeValue(expectedOutput);
+        if (serialized) {
+          rootSpanAttributes[LangfuseOtelSpanAttributes.EXPERIMENT_ITEM_EXPECTED_OUTPUT] = serialized;
+        }
+      }
+      span.otelSpan.setAttributes(rootSpanAttributes);
+      const output2 = await propagateAttributes(
+        {
+          _internalExperiment: {
+            experimentId,
+            experimentName: params.experimentRunName,
+            experimentMetadata: serializeValue(experimentMetadata),
+            experimentDatasetId: datasetId,
+            experimentItemId,
+            experimentItemMetadata: serializeValue(itemMetadata),
+            experimentItemRootObservationId: span.id
+          }
+        },
+        async () => await task(item)
       );
-    }
+      span.update({
+        input,
+        output: output2,
+        metadata: {
+          experiment_name: params.experimentName,
+          experiment_run_name: params.experimentRunName,
+          ...experimentMetadata,
+          ...itemMetadata != null ? itemMetadata : {},
+          ...datasetId && datasetItemId ? {
+            dataset_id: datasetId,
+            dataset_item_id: datasetItemId
+          } : {}
+        }
+      });
+      return {
+        output: output2,
+        traceId: traceId2,
+        observationId: observationId2,
+        datasetRunId: datasetRunId2
+      };
+    });
     const evalPromises = evaluators.map(
       async (evaluator) => {
         const params2 = {
@@ -451,6 +501,7 @@ ${JSON.stringify(params2)}
     for (const ev of evals) {
       this.langfuseClient.score.create({
         traceId,
+        observationId,
         ...ev
       });
     }