Vercel AI SDK

Integration Overview

Pass the Asymptote tracer into AI SDK telemetry so model calls and tool loops stay in the same trace.

Overview

AI SDK exposes OpenTelemetry hooks through experimental_telemetry. Asymptote Observe is OpenTelemetry-first, so you can trace generateText, streamText, tool loops, and custom orchestration by passing Observe.getTracer() to each AI SDK call you want captured. This page covers Node.js usage. For framework placement and serverless flushing, see Next.js and serverless.

What Asymptote Captures

AI SDK spans emitted when experimental_telemetry.isEnabled is true.
Model call spans for supported generate* and stream* operations.
Tool call spans emitted by AI SDK telemetry.
Provider and model metadata where AI SDK and provider adapters emit it.
Parent spans you add with Observe.observe() for route or workflow grouping.

Prerequisites

Node.js 20 or newer.
@asymptote/sdk installed.
ai and an AI SDK model provider package installed.
ASYMPTOTE_API_KEY set for Asymptote Managed hosted Observe, or OTEL_EXPORTER_OTLP_ENDPOINT set for customer-managed OTLP export. To get an Asymptote Managed API key, reach out for a demo.

Install the SDK and Vercel AI SDK

npm install @asymptote/sdk ai @ai-sdk/openai

Set environment variables for Asymptote and your provider:

Set Asymptote Managed and OpenAI environment variables

export ASYMPTOTE_API_KEY=...
export OPENAI_API_KEY=...

Getting Started

Initialize Observe once at application startup, then pass the tracer to AI SDK calls.

Trace an AI SDK generateText call

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

Observe.initialize({
  apiKey: process.env.ASYMPTOTE_API_KEY,
});

await generateText({
  model: openai("gpt-4.1-mini"),
  prompt: "Review this pull request",
  experimental_telemetry: {
    isEnabled: true,
    tracer: Observe.getTracer(),
  },
});

await Observe.flush();

The same pattern applies anywhere AI SDK accepts experimental_telemetry.

Reuse The Tracer

Use Observe.getTracer() anywhere AI SDK accepts an OpenTelemetry tracer. This lets generated spans share the same exporter, resource attributes, and Beacon compatibility path as the rest of your application.

Reuse the Observe tracer

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

const tracer = Observe.getTracer();

await generateText({
  model: openai("gpt-4.1-mini"),
  prompt: "Find risky shell commands in this agent transcript.",
  experimental_telemetry: {
    isEnabled: true,
    tracer,
  },
});

Trace A Tool Loop

Pass the tracer into tool-calling AI SDK flows as well.

Trace an AI SDK tool loop

import { openai } from "@ai-sdk/openai";
import { generateText, stepCountIs, tool } from "ai";
import { z } from "zod";
import { Observe } from "@asymptote/sdk";

const result = await generateText({
  model: openai("gpt-4.1-mini"),
  prompt: "Look up the security owner for the repository and summarize next steps.",
  tools: {
    repoOwner: tool({
      description: "Look up the owner for a repository.",
      inputSchema: z.object({ repo: z.string() }),
      execute: async ({ repo }) => ({ repo, owner: "security-platform" }),
    }),
  },
  stopWhen: stepCountIs(3),
  experimental_telemetry: {
    isEnabled: true,
    tracer: Observe.getTracer(),
    functionId: "repo-security-owner",
  },
});

Group Calls With Custom Steps

Wrap orchestration code around AI SDK calls when you need spans for planning, policy checks, retrieval, or handoffs that are not covered by model telemetry.

Group AI SDK calls with a parent span

import { openai } from "@ai-sdk/openai";
import { generateText } from "ai";
import {
  ATTR_BEACON_EVENT_ACTION,
  ATTR_BEACON_HARNESS_NAME,
  Observe,
} from "@asymptote/sdk";

const runAgentTurn = Observe.observe(
  {
    name: "agent.turn",
    attributes: {
      [ATTR_BEACON_HARNESS_NAME]: "vercel_ai_sdk",
      [ATTR_BEACON_EVENT_ACTION]: "prompt.submitted",
    },
  },
  async (prompt: string) => {
    return generateText({
      model: openai("gpt-4.1-mini"),
      prompt,
      experimental_telemetry: {
        isEnabled: true,
        tracer: Observe.getTracer(),
      },
    });
  },
);

For serverless handlers, call Observe.flush() before returning if the invocation may terminate immediately after the model call.

Troubleshooting

Confirm ASYMPTOTE_API_KEY or OTEL_EXPORTER_OTLP_ENDPOINT is set in the runtime process.
Make sure every AI SDK call you want traced has experimental_telemetry.isEnabled=true.
Pass tracer: Observe.getTracer() on each traced AI SDK call.
In short-lived scripts or jobs, call Observe.flush() before exit.
In Next.js, initialize from instrumentation.ts in the Node.js runtime.

What’s Next

Next.js And Serverless

Place initialization correctly in Next.js and flush traces in short-lived runtimes.

Observe

Group AI SDK calls under custom parent spans.

Get Started

Deploy Asymptote

How Asymptote Works

Manage Asymptote

Agent Harness Integrations

For Security & IT Teams

Integration Overview

Overview

What Asymptote Captures

Prerequisites

Getting Started

Reuse The Tracer

Trace A Tool Loop

Group Calls With Custom Steps

Troubleshooting

What’s Next

Next.js And Serverless

Observe

​Integration Overview

​Overview

​What Asymptote Captures

​Prerequisites

​Getting Started

​Reuse The Tracer

​Trace A Tool Loop

​Group Calls With Custom Steps

​Troubleshooting

​What’s Next

Next.js And Serverless

Observe

Integration Overview

Overview

What Asymptote Captures

Prerequisites

Getting Started

Reuse The Tracer

Trace A Tool Loop

Group Calls With Custom Steps

Troubleshooting

What’s Next