Run reports

Every assistant response is a run. When a run finishes, the SDK sends one run report to the project: what happened, how long it took, which model and tools were involved, and how it ended. Reports never carry the user's messages, but they do carry the assistant's output text and the tool arguments and results, each cut at 50,000 characters, the error message, cut at 2,048, and whatever metadata the integration or your beforeReport hook attaches, so they can contain sensitive content; beforeReport can redact or drop a report and telemetry: false turns reporting off, see Enriching or filtering reports. Reports are the source of the Runs, Models, Users and Overview pages in the dashboard.

Reporting is on by default for every integration that persists messages. This page describes the report, the fields each integration can fill, and the telemetry configuration on AssistantCloud.

The run report

A report is one POST /v1/runs with the fields below. The SDK builds it with createRunReport, so every integration sends the same shape.

Field limits: error is cut at 2,048 characters and error_code at 64, output_text at 50,000, environment at 64, release at 255, tags at 64 characters each and 20 per report, and duration_ms and first_token_ms are rounded to whole milliseconds. The endpoint is append only: a report may also carry cost_usd or cost_details to override the catalog price, and any key it does not know is kept in the run's attributes rather than rejected, so an older cloud accepts a newer SDK and the other way round.

What each integration reports

The integrations observe runs differently, so they do not all fill every field.

The assistant-ui runtime rows apply to useLocalRuntime and useChatRuntime, whose history adapter persists and reports every run. The LangGraph, LangChain and Google ADK runtimes keep their own transcripts, so with them the cloud provides the thread list, titles and feedback but no run report; see LangGraph.

Route configuration

Usage, model and provider only exist on the server, so the route has to put them into the message metadata the SDK reads. With the AI SDK, add a messageMetadata callback to the stream response:

import { convertToModelMessages, streamText } from "ai";
import { openai } from "@ai-sdk/openai";

export async function POST(req: Request) {
  const { messages } = await req.json();

  const model = openai("gpt-5.6-luna");
  const result = streamText({
    model,
    messages: await convertToModelMessages(messages),
  });

  return result.toUIMessageStreamResponse({
    messageMetadata: ({ part }) => {
      if (part.type === "finish") {
        return { usage: part.totalUsage, finishReason: part.finishReason };
      }
      if (part.type === "finish-step") {
        return { modelId: part.response.modelId, provider: model.provider };
      }
      return undefined;
    },
  });
}

The SDK reads these metadata keys:

Without this configuration the report still arrives, without model, provider and usage. The dashboard shows such runs under "No model reported" and cannot price them.

Outcomes

The browser reports four outcomes. Runs the cloud executes itself, through assistants, add the server side ones.

A failed run has status: "error" and, when the cause is known, an outcome from the second group. The Overview and the Runs page turn these into the completion rate and the outcome facets.

Deployment dimensions

environment, release and tags on the telemetry configuration are stamped onto every report the client sends. They become facets on the Runs page, so a regression can be narrowed to one release or one environment.

const cloud = new AssistantCloud({
  baseUrl: process.env.NEXT_PUBLIC_ASSISTANT_BASE_URL!,
  anonymous: true,
  telemetry: {
    environment: "production",
    release: "2026.09.1",
    tags: ["web", "eu"],
  },
});

release is your application's version, not the SDK's. The SDK identifies itself separately: every request carries an Aui-Sdk header naming the assistant-cloud version and the integration packages on it, and Settings › Telemetry lists the versions a project has seen.

Enriching or filtering reports

beforeReport runs last, with the assembled report. Return a modified report to add attributes, or null to drop it.

const cloud = new AssistantCloud({
  baseUrl: process.env.NEXT_PUBLIC_ASSISTANT_BASE_URL!,
  authToken: getToken,
  telemetry: {
    beforeReport: (report) => {
      if (report.thread_id === internalTestThread) return null;
      return { ...report, metadata: { ...report.metadata, plan: "pro" } };
    },
  },
});

metadata is stored as the run's attributes and shown on the run's page; keep it to a few short keys.

Turning telemetry off

Where reports appear

• Runs lists every report with facets for status, outcome, model, provider, environment, release, tags and user, and an Analysis view over the same range.
• A run's page shows its steps, tool calls and usage as a timeline, and the server spans when a trace was correlated.
• Models aggregates runs and cost per model and provider, Users per end user, and the Overview carries the completion rate, latency percentiles and daily volume.

The demo project shows each of them on synthetic data.