Vercel AI SDK v7

Vercel AI SDK v7 calls LLMs from TypeScript through helpers like generateText, streamText, and generateObject. Unlike v6 — which wrote OpenTelemetry spans to the global tracer directly — v7 moved telemetry to a pluggable “integrations” model: the SDK emits internal telemetry events, and a registered integration turns them into spans. Vercel ships @ai-sdk/otel as the OpenTelemetry integration. Arize AX then ingests those spans through the @arizeai/openinference-vercel span processor.

If you’re on AI SDK v6 or earlier, use the Vercel AI SDK (v6 and earlier) guide instead — v6 emits OpenTelemetry spans natively and does not need @ai-sdk/otel. The two SDK versions wire telemetry differently, so the setup is not interchangeable.

Prerequisites

Node.js 22+ (required by @arizeai/openinference-vercel@3 and @ai-sdk/otel)
An Arize AX account (sign up)
An OPENAI_API_KEY from the OpenAI Platform
Vercel AI SDK 7 (ai@^7)

Launch Arize AX

Sign in to your Arize AX account.
From Space Settings, copy your Space ID and API Key. You will set them as ARIZE_SPACE_ID and ARIZE_API_KEY below.

Install

Install the AI SDK v7, the @ai-sdk/otel telemetry integration, and the OpenInference processor. Pick the tab for your runtime — they differ only in the OpenTelemetry registration helper.

Node.js
Next.js

npm install ai@^7 @ai-sdk/openai@^4 @ai-sdk/otel \
  @arizeai/openinference-vercel@^3.3.1 \
  @arizeai/openinference-semantic-conventions \
  @opentelemetry/api \
  @opentelemetry/context-async-hooks \
  @opentelemetry/exporter-trace-otlp-proto \
  @opentelemetry/resources \
  @opentelemetry/sdk-trace

npm install ai@^7 @ai-sdk/openai@^4 @ai-sdk/otel \
  @arizeai/openinference-vercel@^3.3.1 \
  @vercel/otel \
  @opentelemetry/api \
  @opentelemetry/exporter-trace-otlp-proto

@ai-sdk/otel is the piece that makes v7 emit spans at all. Without a registered telemetry integration, experimental_telemetry: { isEnabled: true } enables the SDK’s telemetry events but nothing converts them to OpenTelemetry spans, so nothing reaches Arize.

Configure credentials

export ARIZE_SPACE_ID="<your-space-id>"
export ARIZE_API_KEY="<your-api-key>"
export ARIZE_PROJECT_NAME="vercel-ai-sdk-v7-tracing-example"
export OPENAI_API_KEY="<your-openai-api-key>"

Setup tracing

Register the OpenTelemetry provider and the @ai-sdk/otel integration in one startup file. registerTelemetry(new OpenTelemetry()) (from ai and @ai-sdk/otel) installs the integration globally, so individual generateText/streamText calls only need the experimental_telemetry: { isEnabled: true } opt-in. Pick the tab that matches your runtime. The processor’s spanFilter and reparentOrphanedSpans options control which spans reach Arize and how each trace is rooted — see Span filter.

Node.js
Next.js

// instrumentation.ts
import { context, trace } from "@opentelemetry/api";
import {
  AsyncLocalStorageContextManager,
} from "@opentelemetry/context-async-hooks";
import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
import { resourceFromAttributes } from "@opentelemetry/resources";
import { TracerProvider } from "@opentelemetry/sdk-trace";
import {
  isOpenInferenceSpan,
  OpenInferenceSimpleSpanProcessor,
} from "@arizeai/openinference-vercel";
import { SEMRESATTRS_PROJECT_NAME } from "@arizeai/openinference-semantic-conventions";
import { registerTelemetry } from "ai";
import { OpenTelemetry } from "@ai-sdk/otel";
import { enrichSpanWithOpenInference } from "@arizeai/openinference-vercel";

const projectName =
  process.env.ARIZE_PROJECT_NAME ?? "vercel-ai-sdk-v7-tracing-example";

export const provider = new TracerProvider({
  resource: resourceFromAttributes({
    [SEMRESATTRS_PROJECT_NAME]: projectName,
    model_version: "1.0.0",
  }),
  spanProcessors: [
    new OpenInferenceSimpleSpanProcessor({
      exporter: new OTLPTraceExporter({
        url: "https://otlp.arize.com/v1/traces",
        headers: {
          "arize-space-id": process.env.ARIZE_SPACE_ID ?? "",
          "arize-api-key": process.env.ARIZE_API_KEY ?? "",
        },
      }),
      spanFilter: isOpenInferenceSpan,
      reparentOrphanedSpans: true,
    }),
  ],
});

trace.setGlobalTracerProvider(provider);
context.setGlobalContextManager(
  new AsyncLocalStorageContextManager().enable(),
);

// v7: bridge the AI SDK's telemetry events to OpenTelemetry spans. Register
// once, globally — `experimental_telemetry: { isEnabled: true }` on each call
// is then all that's needed.
registerTelemetry(
  new OpenTelemetry({
    experimental_decision: true,
    enrichSpan: enrichSpanWithOpenInference,
  }),
);

console.log("Arize AX tracing initialized for Vercel AI SDK v7.");

In Next.js, use @vercel/otel’s registerOTel from a root-level instrumentation.ts (alongside package.json, or in src/ if you use that layout). Next.js calls the exported register() function once on the server, before any request, so you do not create a TracerProvider or call forceFlush() yourself.

// instrumentation.ts (project root)
import { registerOTel } from "@vercel/otel";
import {
  isOpenInferenceSpan,
  OpenInferenceSimpleSpanProcessor,
} from "@arizeai/openinference-vercel";
import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
import { registerTelemetry } from "ai";
import { OpenTelemetry } from "@ai-sdk/otel";

export function register() {
  registerOTel({
    serviceName:
      process.env.ARIZE_PROJECT_NAME ?? "vercel-ai-sdk-v7-tracing-example",
    spanProcessors: [
      new OpenInferenceSimpleSpanProcessor({
        exporter: new OTLPTraceExporter({
          url: "https://otlp.arize.com/v1/traces",
          headers: {
            "arize-space-id": process.env.ARIZE_SPACE_ID ?? "",
            "arize-api-key": process.env.ARIZE_API_KEY ?? "",
          },
        }),
        spanFilter: isOpenInferenceSpan,
        reparentOrphanedSpans: true,
      }),
    ],
  });

  // v7: bridge the AI SDK's telemetry events to OpenTelemetry spans.
  registerTelemetry(new OpenTelemetry());
}

Serverless flushing. OpenInferenceSimpleSpanProcessor exports each span synchronously as it ends, so it does not depend on a process-exit flush — this is what makes it safe on short-lived serverless routes (Vercel functions, edge) where you can’t call forceFlush(). Keep SimpleSpanProcessor rather than BatchSpanProcessor in those environments; batching can drop spans when the function freezes between invocations.

Run Vercel AI SDK

// example.ts

// Importing instrumentation first ensures the OTel provider and the
// @ai-sdk/otel integration are registered before the AI SDK is used.
import { provider } from "./instrumentation";

import { generateText } from "ai";
import { openai } from "@ai-sdk/openai";

// `experimental_telemetry: { isEnabled: true }` opts this call into the AI
// SDK's telemetry; the integration registered in instrumentation.ts turns
// those events into OpenTelemetry spans.
const { text } = await generateText({
  model: openai("gpt-6.1-sol"),
  prompt: "Why is the ocean salty? Answer in two sentences.",
  experimental_telemetry: { isEnabled: true },
});

console.log(text);

// Flush any pending spans before the process exits.
await provider.forceFlush();

This is a standalone Node script. In Next.js, you don’t import provider or call forceFlush() — the root instrumentation.ts registers tracing automatically. Just add experimental_telemetry: { isEnabled: true } to the generateText/streamText calls inside your route handlers or server actions.

Expected output

Arize AX tracing initialized for Vercel AI SDK v7.
The ocean is salty because rivers continuously dissolve mineral salts from rocks and soil and carry them to the sea, where they accumulate over millions of years. Water leaves the ocean through evaporation but the salts remain, steadily concentrating until reaching today's roughly 3.5% salinity.

Verify in Arize AX

Open your Arize AX space and select project vercel-ai-sdk-v7-tracing-example.
Within ~30 seconds you should see a trace for the call. v7 names its spans with the GenAI convention rather than the v6 ai.generateText names — the OpenInference processor classifies them by span kind, which is what you read in the UI:

invoke_agent gpt-6.1-sol    [agent]   the generateText call
  └─ step 1                 [chain]   the step
       └─ chat gpt-6.1-sol  [llm]     model request (prompt, response, tokens)

The top agent span carries the call; the chat LLM span holds the prompt, the model’s response, and token usage. Tool calls appear as additional tool spans under the step.

If no traces appear, see Troubleshooting.

Check from the skill, CLI, or SDK

Confirm spans are actually reaching your Arize AX project. Use whichever fits your workflow — the skill and CLI work for any framework; the SDK check is shown for each language.

Arize skill (agent)
AX CLI
SDK

Install the Arize Skills plugin and let your coding agent check for you:

npx skills add Arize-ai/arize-skills

Then prompt your agent:

Use the arize-trace skill to export and analyze recent traces from my project. Confirm spans are arriving, and summarize any errors or latency issues.

Export recent spans for your project — any rows mean traces are landing:

ax spans export "$ARIZE_PROJECT_NAME" --space "$ARIZE_SPACE_ID" \
  --limit 5 --stdout | jq 'length'

A non-zero count confirms spans reached Arize AX. Run ax auth login first if you have not authenticated. See the ax spans reference.

Query the project’s spans and check that at least one came back.

import os
from arize import ArizeClient

client = ArizeClient(api_key=os.environ["ARIZE_API_KEY"])
resp = client.spans.list(
    project=os.environ["ARIZE_PROJECT_NAME"],
    space=os.environ["ARIZE_SPACE_ID"],
    limit=5,
)
count = len(resp.spans)
print(
    f"{count} span(s) found" if count else "No spans yet — recheck setup"
)

// Reads ARIZE_API_KEY from the environment.
import { listSpans } from "@arizeai/ax-client";

const { data: spans } = await listSpans({
  project: process.env.ARIZE_PROJECT_NAME!,
  space: process.env.ARIZE_SPACE_ID!,
  limit: 5,
});
const count = spans.length;
console.log(
  count ? `${count} span(s) found` : "No spans yet — recheck setup",
);

client, err := arize.NewClient(
    arize.Config{APIKey: os.Getenv("ARIZE_API_KEY")},
)
if err != nil {
    log.Fatal(err)
}
resp, err := client.Spans.List(ctx, spans.ListRequest{
    Project: os.Getenv("ARIZE_PROJECT_NAME"),
    Space:   os.Getenv("ARIZE_SPACE_ID"),
    Limit:   5,
})
if err != nil {
    log.Fatal(err)
}
fmt.Printf("%d span(s) found\n", len(resp.Spans))

SDK span references: Python · TypeScript · Go.

Span filter

Other instrumentations registered alongside the AI SDK (@opentelemetry/instrumentation-http, @vercel/otel, Next.js’s built-in tracing) emit POST / GET spans for every fetch, and the AI SDK’s spans nest under those HTTP roots. Two options on the processor control which spans reach Arize and how they’re rooted:

spanFilter: isOpenInferenceSpan keeps only the AI spans and drops the rest — the raw HTTP/fetch spans those other instrumentations emit.
reparentOrphanedSpans: true re-roots any AI span left orphaned when the filter drops its parent, so the top-level call span becomes a clean trace root instead of pointing at a parent that was never exported.

new OpenInferenceSimpleSpanProcessor({
  exporter,
  spanFilter: isOpenInferenceSpan,
  reparentOrphanedSpans: true, // default: false
});

Trace decisions

Vercel AI SDK decision models answer typed questions about a shared state instead of generating text. Calls through experimental_decide appear as a CHAIN span for the operation with a child DECISION span for the model call. This support requires ai 7.0.128 or later, @ai-sdk/otel 1.0.128 or later, and @arizeai/openinference-vercel 3.3.0 or later. The setup above enables decision tracing. experimental_decision: true records the decision state, questions, and answers. enrichSpan: enrichSpanWithOpenInference identifies the model-call span so the processor exports the outer operation as CHAIN and the model call as DECISION. The helper is exported by the ESM-only @arizeai/openinference-vercel package, which is already installed above. With the integration configured, call experimental_decide as usual:

// decisions_example.ts
import { provider } from "./instrumentation";
import { experimental_decide } from "ai";
import { openai } from "@ai-sdk/openai";

const { answers } = await experimental_decide({
  model: openai.decisionModel("gpt-6-luna"),
  state: "Customer message: My invoice shows a charge I don't recognize.",
  questions: {
    department: {
      type: "choice",
      instructions: "Which team should handle this message?",
      criteria: {
        billing: "Charges, refunds, and invoices",
        technical: "Bugs, outages, and setup problems",
        sales: "Pricing, plans, and upgrades",
      },
    },
  },
});

console.log(answers.department.choice, answers.department.probabilities);
await provider.forceFlush();

Expected output

Arize AX tracing initialized for Vercel AI SDK v7.
billing { billing: 1, technical: 0, sales: 0 }

The CHAIN span carries the state and questions as input and the answers as output. The child DECISION span carries decision.system, decision.provider, decision.request.model_name, decision.model_name, and decision.token_count.input / decision.token_count.output. When the AI SDK reports a response model, the processor records it as decision.response.model_name. In this example, Arize AX recorded gpt-6-luna, matching the requested model. Output token counts are often 0 because the answers are typed values rather than generated tokens. Decision model and usage attributes use decision.* rather than llm.*, so these calls are not included in LLM token and cost reporting. Without experimental_decision: true, the spans include model and token counts but omit the decision input and output. Without enrichSpan, both SDK spans can be exported as DECISION spans.

Troubleshooting

No traces in Arize AX. v7 emits no spans unless a telemetry integration is registered — confirm @ai-sdk/otel is installed and registerTelemetry(new OpenTelemetry(...)) runs in your instrumentation.ts. Each text-generation call also needs experimental_telemetry: { isEnabled: true }. Confirm ARIZE_SPACE_ID and ARIZE_API_KEY are set in the same shell, and enable debug logs with export OTEL_LOG_LEVEL=debug.
401 from OpenAI. Verify OPENAI_API_KEY is set and has access to gpt-6.1-sol. Swap openai("gpt-6.1-sol") for a model your key can call.
Process exits before spans flush. Always await provider.forceFlush() (or provider.shutdown()) before the process exits, otherwise trailing spans are dropped.
Next.js / Vercel runtime. Use @vercel/otel’s registerOTel(...) instead of TracerProvider, and pin versions: @vercel/otel@1.x requires @opentelemetry/* 1.x; @vercel/otel@2.x requires 2.x. Mismatches surface as silent missing traces.
AI SDK spans orphaned on the Traces tab. Set reparentOrphanedSpans: true on the processor as shown in Span filter, and confirm @arizeai/openinference-vercel is 3.0.0 or later — stable v7 telemetry support (and the v7-aware reparenting) landed in the v3 major.
You want the v6 span names. @ai-sdk/otel also exports a LegacyOpenTelemetry integration that emits the older ai.generateText / ai.generateText.doGenerate span names; register it in place of OpenTelemetry if you have dashboards or evaluators keyed on those names.

OpenTelemetry

LLM Providers

Agent Frameworks

Coding Agents

Platforms

Orchestration

Vector Databases

Evaluation

Prerequisites

Launch Arize AX

Install

Configure credentials

Setup tracing

Run Vercel AI SDK

Expected output

Verify in Arize AX

Check from the skill, CLI, or SDK

Span filter

Trace decisions

Expected output

Troubleshooting

Resources

Vercel AI SDK Documentation

@ai-sdk/otel

OpenInference Vercel Span Processor

​Prerequisites

​Launch Arize AX

​Install

​Configure credentials

​Setup tracing

​Run Vercel AI SDK

​Expected output

​Verify in Arize AX

​Check from the skill, CLI, or SDK

​Span filter

​Trace decisions

​Expected output

​Troubleshooting

​Resources

Vercel AI SDK Documentation

@ai-sdk/otel

OpenInference Vercel Span Processor

Prerequisites

Launch Arize AX

Install

Configure credentials

Setup tracing

Run Vercel AI SDK

Expected output

Verify in Arize AX

Check from the skill, CLI, or SDK

Span filter

Trace decisions

Expected output

Troubleshooting

Resources