Workflow timing doesn't include streaming duration (NextJS + App Router + AI SDK)

[chenlevy]

I'm trying to create a workflow that contains tasks and stream back to the client using NextJS app router API.
The span and total workflow time I get only include the sync workflow tasks.
Is it possible to count the stream in total time?

My setup is illustrated below:

traceloop.initialize({
  appName: "builder_app",
  apiKey: process.env.TRACELOOP_API_KEY,
  disableBatch: true,
  traceloopSyncEnabled: false,
});

export const POST = 
  async (
    req: NextRequest & WithAuth,
    { params }: { params: { appId: string } },
  ) => {
    return await traceloop.withWorkflow({ name: "builder_workflow" }, async () => {

      // ...tasks before stream

      const resultStream = streamText({            
        experimental_telemetry: {
          isEnabled: true,
          functionId: "main_code_generation_stream",
        },
        messages,
        model,
        onFinish: async (result) => {

          // ...tasks after stream

        }
      }); 
      
      return Response.stream(resultStream);
  })
})

[rajudandigam]

Hi — I revalidated this on current main (1faf69deed3401593a9e3551130f5fcc2925f60a) with a minimal Node reproduction (no Next.js dependency, in-memory OTel exporter, delayed Web ReadableStream / Response).

Measured behavior

For a withWorkflow handler that returns a Response whose body streams delayed chunks:

Event	Relative time
Response returned / workflow Promise resolved	~102 ms
Workflow span duration	~101 ms
First chunk	~153 ms
Stream close	~255 ms

Same pattern when returning a bare ReadableStream: the workflow span ends when the Promise resolves (stream object returned), not when the stream closes, errors, or is cancelled. After resolve, the workflow span is no longer recording.

Likely root cause

In withEntity (packages/traceloop-sdk/src/lib/tracing/decorators.ts), async callbacks end the span in the Promise .then path as soon as the handler return value is available. Returning a Response / ReadableStream is treated like returning any other value, so streaming duration is excluded from workflow timing. I do not see stream-aware deferred completion in current withWorkflow.

Design question (before coding)

This looks like an API-semantics choice more than a one-line bugfix. Two smallest viable options:

Option A — Transparent wrapping
Detect returned Response / ReadableStream inside withWorkflow and end the span on stream close / error / cancel. Convenient for existing Next.js App Router code; adds Web Streams awareness and wrapping edge cases to the generic helper.

Option B — Explicit streaming helper (my preference for a first PR)
Keep withWorkflow unchanged for BC, and add something like withStreamingWorkflow (or a small deferred-completion helper) that opts into stream-lifetime span ending. Clearer ownership, safer backwards compatibility, easier to test/document.

I can implement whichever approach you prefer, with tests for:

• ordinary sync / Promise returns (unchanged)
• stream normal completion
• stream error
• cancellation
• documented behavior when the body is never read
• single span.end() / no double-end

Which lifecycle semantics do you want for the public SDK?

[rajudandigam]

Friendly bump on the lifecycle-semantics question above.

The Node reproduction on current main still shows workflow span duration ending at Promise resolve (~101 ms) while the stream closes ~255 ms later. I have not opened a PR because this looks like an API design choice rather than a one-line fix.

Before I implement, could maintainers confirm which direction you prefer?

• Option A — transparent wrapping: detect returned Response / ReadableStream inside withWorkflow and end the span on stream close / error / cancel.
• Option B — explicit helper: keep withWorkflow unchanged for BC and add something like withStreamingWorkflow that opts into stream-lifetime span ending.

Happy to follow whichever semantics you want, with tests for sync/Promise returns (unchanged), normal completion, error, cancel, unread body, and single span.end().