Vercel AI SDK (tracing)

1
import { OpenTelemetry } from "@ai-sdk/otel";
2
import { VercelAIInstrumentor } from "@respan/instrumentation-vercel";
3
import { Respan } from "@respan/respan";
4
import { registerTelemetry } from "ai";
5
6
registerTelemetry(
7
  new OpenTelemetry({
8
    enrichSpan: () => ({
9
      "ai.telemetry.metadata.customer_identifier": "user-123",
10
      "ai.telemetry.metadata.thread_identifier": "thread-abc",
11
      "ai.telemetry.metadata.trace_group_identifier": "onboarding-flow",
12
    }),
13
  })
14
);
15
16
const respan = new Respan({
17
  instrumentations: [
18
    new VercelAIInstrumentor({ autoRegisterAISDKTelemetry: false }),
19
  ],
20
});
21
await respan.initialize();

1
import { Respan } from "@respan/respan";
2
import { VercelAIInstrumentor } from "@respan/instrumentation-vercel";
3
4
const respan = new Respan({
5
  instrumentations: [new VercelAIInstrumentor()],
6
});
7
await respan.initialize();
8
9
async function handleRequest(userId: string, message: string) {
10
  return respan.propagateAttributes(
11
    {
12
      customer_identifier: userId,
13
      thread_identifier: "conv_abc_123",
14
      metadata: { plan: "pro" },
15
    },
16
    async () => {
17
      const result = await generateText({
18
        model: openai("gpt-4.1-nano"),
19
        prompt: message,
20
        telemetry: { isEnabled: true },
21
      });
22
      return result.text;
23
    }
24
  );
25
}

1
import { generateText } from "ai";
2
import { openai } from "@ai-sdk/openai";
3
import { Respan, withWorkflow, withTask } from "@respan/respan";
4
import { VercelAIInstrumentor } from "@respan/instrumentation-vercel";
5
6
const respan = new Respan({
7
  apiKey: process.env.RESPAN_API_KEY,
8
  instrumentations: [new VercelAIInstrumentor()],
9
});
10
await respan.initialize();
11
12
await withWorkflow({ name: "joke_pipeline" }, async () => {
13
  const intent = await withTask({ name: "classify_intent" }, () =>
14
    generateText({
15
      model: openai("gpt-4.1-nano"),
16
      prompt: 'Classify this intent in one word: "Tell me a joke"',
17
      telemetry: { isEnabled: true },
18
    })
19
  );
20
21
  const joke = await withTask({ name: "generate_joke" }, () =>
22
    generateText({
23
      model: openai("gpt-4.1-nano"),
24
      prompt: `The intent is "${intent.text}". Tell a short joke.`,
25
      telemetry: { isEnabled: true },
26
    })
27
  );
28
29
  console.log(joke.text);
30
});

1
import { stepCountIs, streamText, tool } from "ai";
2
import { openai } from "@ai-sdk/openai";
3
import { z } from "zod";
4
5
const result = streamText({
6
  model: openai("gpt-4.1-nano"),
7
  messages: [{ role: "user", content: "What's the weather in Paris?" }],
8
  tools: {
9
    getWeather: tool({
10
      description: "Get weather for a city",
11
      inputSchema: z.object({ city: z.string() }),
12
      execute: async ({ city }) => `${city}: sunny, 72F`,
13
    }),
14
  },
15
  stopWhen: stepCountIs(5),
16
  telemetry: { isEnabled: true },
17
});
18
19
for await (const chunk of result.textStream) {
20
  process.stdout.write(chunk);
21
}

1
const result = await generateText({
2
  model: openai("gpt-4.1-nano"),
3
  prompt: "Tell me a joke about AI",
4
  experimental_telemetry: {
5
    isEnabled: true,
6
    metadata: { customer_identifier: "user-123" },
7
  },
8
});