Vercel AI SDK

1
const result = await generateText({
2
  model: provider("gpt-4o-mini"),
3
  prompt: "Hello",
4
  experimental_telemetry: {
5
    isEnabled: true,
6
    metadata: {
7
      customer_identifier: "user-123",
8
      customer_name: "John Doe",
9
      customer_email: "john@example.com",
10
      thread_identifier: "thread-abc",
11
      trace_group_identifier: "onboarding-flow",
12
    },
13
  },
14
});

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: provider("gpt-4o-mini"),
19
        prompt: message,
20
        experimental_telemetry: { isEnabled: true },
21
      });
22
      return result.text;
23
    }
24
  );
25
}

1
import { createOpenAI } from "@ai-sdk/openai";
2
import { generateText } from "ai";
3
import { Respan, withWorkflow, withTask, propagateAttributes } 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
const provider = createOpenAI({
13
  apiKey: process.env.RESPAN_API_KEY!,
14
  baseURL: "https://api.respan.ai/api",
15
});
16
17
await propagateAttributes(
18
  { customer_identifier: "user-123" },
19
  () =>
20
    withWorkflow({ name: "joke_pipeline" }, async () => {
21
      const intent = await withTask({ name: "classify_intent" }, () =>
22
        generateText({
23
          model: provider("gpt-4o-mini"),
24
          prompt: 'Classify this intent in one word: "Tell me a joke"',
25
          experimental_telemetry: { isEnabled: true },
26
        })
27
      );
28
29
      const joke = await withTask({ name: "generate_joke" }, () =>
30
        generateText({
31
          model: provider("gpt-4o-mini"),
32
          prompt: `The intent is "${intent.text}". Tell a short joke.`,
33
          experimental_telemetry: { isEnabled: true },
34
        })
35
      );
36
37
      console.log(joke.text);
38
    })
39
);
40
41
await respan.flush();

1
import { streamText, tool } from "ai";
2
import { z } from "zod";
3
4
export const maxDuration = 30;
5
6
export async function POST(req: Request) {
7
  const { messages } = await req.json();
8
9
  const result = streamText({
10
    model: provider("gpt-4o-mini"),
11
    messages,
12
    tools: {
13
      getWeather: tool({
14
        description: "Get weather for a city",
15
        parameters: z.object({ city: z.string() }),
16
        execute: async ({ city }) => `${city}: sunny, 72°F`,
17
      }),
18
    },
19
    maxSteps: 5,
20
    experimental_telemetry: {
21
      isEnabled: true,
22
      metadata: { customer_identifier: "user-123" },
23
    },
24
  });
25
26
  return result.toTextStreamResponse();
27
}

1
import { withWorkflow, withTask, withTool, propagateAttributes } from "@respan/respan";
2
3
export async function POST(req: Request) {
4
  const { message } = await req.json();
5
6
  return propagateAttributes(
7
    { customer_identifier: "user-123", thread_identifier: `thread_${Date.now()}` },
8
    () =>
9
      withWorkflow({ name: "support_chatbot" }, async () => {
10
        // Step 1: Classify intent
11
        const intentResult = await withTask({ name: "classify_intent" }, () =>
12
          generateText({
13
            model: provider("gpt-4o-mini"),
14
            prompt: `Classify: "${message}"`,
15
            experimental_telemetry: { isEnabled: true },
16
          })
17
        );
18
19
        // Step 2: Execute tool
20
        const toolResult = await withTool({ name: "lookup" }, async () => {
21
          return { answer: "Found the answer" };
22
        });
23
24
        // Step 3: Generate response
25
        const response = await withTask({ name: "generate_response" }, () =>
26
          generateText({
27
            model: provider("gpt-4o-mini"),
28
            prompt: `Intent: ${intentResult.text}. Data: ${JSON.stringify(toolResult)}. Respond helpfully.`,
29
            experimental_telemetry: { isEnabled: true },
30
          })
31
        );
32
33
        return Response.json({ response: response.text });
34
      })
35
  );
36
}

1
const provider = createOpenAI({
2
  apiKey: process.env.RESPAN_API_KEY!,
3
  baseURL: "https://api.respan.ai/api",
4
});
5
6
// OpenAI
7
const result1 = await generateText({ model: provider("gpt-4o-mini"), prompt: "Hello" });
8
9
// Anthropic (via gateway)
10
const result2 = await generateText({ model: provider("claude-sonnet-4-5-20250929"), prompt: "Hello" });
11
12
// DeepSeek (via gateway)
13
const result3 = await generateText({ model: provider("deepseek/deepseek-chat"), prompt: "Hello" });