fix(vercel): allow nested executions in parent trace

integration-test/langfuse-integration-vercel.spec.ts

@@ -593,4 +593,72 @@ describe("langfuse-integration-vercel", () => {
       expect(generation.promptVersion).toBe(fetchedPrompt.version);
     }
   }, 10_000);
+
+  it("should nest multiple generateText call under a trace", async () => {
+    const langfuse = new Langfuse();
+    const traceName = "parent_generate_text_multiple";
+
+    // Create parent trace
+    const parentTraceId = randomUUID();
+    langfuse.trace({ id: parentTraceId, name: traceName });
+    const baseRootSpanName = "root-span";
+
+    const NESTED_RUN_COUNT = 3;
+
+    for (let i = 0; i < NESTED_RUN_COUNT; i++) {
+      const testParams = {
+        traceId: parentTraceId,
+        modelName: "gpt-3.5-turbo",
+        maxTokens: 50,
+        prompt: "Invent a new holiday and describe its traditions.",
+        functionId: `${baseRootSpanName}-${i}`,
+        userId: "some-user-id",
+        sessionId: "some-session-id",
+        metadata: {
+          something: "custom",
+          someOtherThing: "other-value",
+        },
+        tags: ["vercel", "openai"],
+      };
+
+      const { traceId, modelName, maxTokens, prompt, functionId, userId, sessionId, metadata, tags } = testParams;
+
+      await generateText({
+        model: openai(modelName),
+        maxTokens,
+        prompt,
+        experimental_telemetry: {
+          isEnabled: true,
+          functionId,
+          metadata: {
+            langfuseTraceId: traceId,
+            userId,
+            sessionId,
+            tags,
+            ...metadata,
+          },
+        },
+      });
+    }
+
+    await langfuse.flushAsync();
+    await sdk.shutdown();
+
+    // Fetch trace
+    const traceFetchResult = await fetchTraceById(parentTraceId);
+    expect(traceFetchResult.status).toBe(200);
+
+    // Validate trace
+    const fetchedTrace = traceFetchResult.data;
+    expect(fetchedTrace.name).toBe(traceName);
+
+    const rootObservations = fetchedTrace.observations
+      .filter((o: any) => !Boolean(o.parentObservationId))
+      .sort((a: any, b: any) => a.name - b.name);
+
+    for (let i = 0; i < NESTED_RUN_COUNT; i++) {
+      const obs = rootObservations[i];
+      expect(obs.name).toBe(`${baseRootSpanName}-${i}`);
+    }
+  }, 15_000);
 });

langfuse-vercel/src/LangfuseExporter.ts

@@ -77,35 +77,58 @@ export class LangfuseExporter implements SpanExporter {
     const finalTraceId = userProvidedTraceId ?? traceId;
     const langfusePrompt = this.parseLangfusePromptTraceAttribute(spans);
 
-    this.langfuse.trace({
+    const traceUpdate = {
       id: finalTraceId,
-      name: this.parseTraceName(spans) ?? rootSpan?.name,
       userId: this.parseUserIdTraceAttribute(spans),
       sessionId: this.parseSessionIdTraceAttribute(spans),
       tags: this.parseTagsTraceAttribute(spans).length > 0 ? this.parseTagsTraceAttribute(spans) : undefined,
+    };
+
+    const traceCreate = {
+      name: this.parseTraceName(spans) ?? rootSpan?.name,
       input: this.parseInput(rootSpan),
       output: this.parseOutput(rootSpan),
       metadata: this.filterTraceAttributes(this.parseMetadataTraceAttribute(spans)),
+    };
+
+    this.langfuse.trace({
+      ...traceUpdate,
+      ...(!userProvidedTraceId ? traceCreate : {}),
     });
 
     for (const span of spans) {
       if (this.isGenerationSpan(span)) {
         this.processSpanAsLangfuseGeneration(finalTraceId, span, this.isRootAiSdkSpan(span, spans), langfusePrompt);
       } else {
-        this.processSpanAsLangfuseSpan(finalTraceId, span, this.isRootAiSdkSpan(span, spans));
+        this.processSpanAsLangfuseSpan(
+          finalTraceId,
+          span,
+          this.isRootAiSdkSpan(span, spans),
+          userProvidedTraceId ? this.parseTraceName(spans) : undefined
+        );
       }
     }
   }
 
-  private processSpanAsLangfuseSpan(traceId: string, span: ReadableSpan, isRootSpan: boolean): void {
+  private processSpanAsLangfuseSpan(
+    traceId: string,
+    span: ReadableSpan,
+    isRootSpan: boolean,
+    rootSpanName?: string
+  ): void {
     const spanContext = span.spanContext();
     const attributes = span.attributes;
 
     this.langfuse.span({
       traceId,
       parentObservationId: isRootSpan ? undefined : span.parentSpanId,
       id: spanContext.spanId,
-      name: "ai.toolCall.name" in attributes ? "ai.toolCall " + attributes["ai.toolCall.name"]?.toString() : span.name,
+      name:
+        isRootSpan && rootSpanName
+          ? rootSpanName
+          : "ai.toolCall.name" in attributes
+            ? "ai.toolCall " + attributes["ai.toolCall.name"]?.toString()
+            : span.name,
       startTime: this.hrTimeToDate(span.startTime),
       endTime: this.hrTimeToDate(span.endTime),