test(cloudflare): Add e2e test app for @cloudflare/think (#24660)

Adds a `cloudflare-think` e2e app that records what a Think agent
produces with the SDK as it stands today, before any Think-specific code
exists. Same shape as `node-eve` and `cloudflare-mastra`.

The setup is the whole point: the worker imports no Sentry API at all.

```ts
// vite.config.mts
export default defineConfig({
  plugins: [cloudflare(), sentryCloudflareVitePlugin()],
});
```

```ts
// src/index.ts
export class ThinkAgent extends Think<Env> {
  getModel() { return openrouter('openai/gpt-4o-mini'); }
  getSystemPrompt() { /* ... */ }
  getTools() { /* get_weather, fail_now */ }
}
```

`sentryCloudflareVitePlugin()` detects `extends Think` and wraps the
export at build time, and `ai` publishes the telemetry
`vercelAIIntegration` already consumes. Options come from
`src/instrument.server.ts` by convention.

## What works today

Five checks, the same set the other AI apps cover:

1. **The gen_ai hierarchy.** `gen_ai.invoke_agent`, one
`gen_ai.generate_content` per step, and `gen_ai.execute_tool`, correctly
nested and all with origin `auto.vercelai.channel`. Token usage is right
per step and rolls up onto the agent span; prompts, tool arguments and
results, tool definitions and finish reasons are all present.
2. **Tool errors.** A throw becomes an issue with mechanism
`auto.vercelai.channel` and marks only its own span errored, leaving the
model calls `ok`.
3. **Manual spans.** A `Sentry.startSpan` raised inside a tool nests
under that tool's span, so Think runs tools inside the async context the
SDK opened.
4. **The provider request.** The outgoing model call joins the turn's
trace rather than running beside it.
5. **Other instrumented libraries.** `dataloader` spans land in the same
trace, so the orchestrion module transform reaches a bundled Think
worker with no `--import` bootstrap, unlike the Node apps.

## What does not

The provider HTTP call nests under `gen_ai.generate_content` on `ai` v7
but is a sibling of it on v4 to v6. That difference is ours: only v7's
native channel binds the model-call span into async context. Asserted
per lane so the gap is recorded rather than hidden.

The agent span is named from `this.constructor.name`, which the Vite
plugin's class rename currently mangles into `invoke_agent
__SENTRY_ORIGINAL_ThinkAgent__`. Not asserted here. A follow-up fixes it
and adds the assertion.

There is no `gen_ai.agent.name`, and none of the
`cloudflare.agents.turn.*` context Think supplies (agent id, Durable
Object conversation id, turn trigger, continuation) reaches a span.
Think sends all of it, as `runtimeContext` on v7 and
`experimental_telemetry.metadata` on v6, and neither subscriber reads
either field.

## Notes

`sentryTest.optional: true` keeps this in the optional matrix like
`node-eve`, since it makes real OpenRouter calls. The v6 lane rides
along as an `optionalVariants` entry rather than a second app.
`E2E_OPENROUTER_API_KEY` is already wired in `build.yml` from the eve
PR, so CI needs no change.

ref JS-3568

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 5 <noreply@anthropic.com>

Author: RulaKhaled

dev-packages/e2e-tests/test-applications/cloudflare-think/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "cloudflare-think",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "dev": "vite dev",
+    "build": "vite build",
+    "preview": "vite preview --port 38788",
+    "typecheck": "tsc --noEmit",
+    "test:build": "pnpm install && pnpm build",
+    "test:assert": "pnpm test:prod",
+    "test:prod": "TEST_ENV=production playwright test",
+    "test:dev": "TEST_ENV=development playwright test",
+    "test:build-ai-v6": "pnpm install && pnpm add ai@^6.0.0 @openrouter/ai-sdk-provider@^2.9.1 && pnpm build",
+    "test:assert-ai-v6": "AI_SDK_MAJOR=6 pnpm test:prod"
+  },
+  "dependencies": {
+    "@cloudflare/think": "^0.19.0",
+    "@openrouter/ai-sdk-provider": "^3.1.0",
+    "@sentry/cloudflare": "file:../../packed/sentry-cloudflare-packed.tgz",
+    "agents": "^0.24.0",
+    "ai": "^7.0.112",
+    "dataloader": "^2.2.3",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@cloudflare/vite-plugin": "1.57.2",
+    "@cloudflare/workers-types": "^4.20260426.0",
+    "@playwright/test": "~1.63.0",
+    "@sentry-internal/test-utils": "link:../../../test-utils",
+    "typescript": "^5.5.2",
+    "vite": "7.3.5",
+    "wrangler": "^4.136.2",
+    "ws": "^8.18.3"
+  },
+  "volta": {
+    "node": "24.15.0",
+    "extends": "../../package.json"
+  },
+  "sentryTest": {
+    "optional": true,
+    "optionalVariants": [
+      {
+        "build-command": "pnpm test:build-ai-v6",
+        "assert-command": "pnpm test:assert-ai-v6",
+        "label": "cloudflare-think (ai v6)"
+      }
+    ]
+  }
+}

dev-packages/e2e-tests/test-applications/cloudflare-think/playwright.config.ts

@@ -0,0 +1,23 @@
+import { getPlaywrightConfig } from '@sentry-internal/test-utils';
+
+const testEnv = process.env.TEST_ENV;
+
+if (!testEnv) {
+  throw new Error('No test env defined');
+}
+
+const APP_PORT = 38788;
+
+const config = getPlaywrightConfig(
+  {
+    startCommand: `pnpm preview`,
+    port: APP_PORT,
+  },
+  // Each test drives a real OpenRouter tool-calling turn (up to two model calls) and then waits for
+  // the spans to flush, which does not fit the default 30s timeout when the provider is slow. The
+  // serial default from `getPlaywrightConfig` is kept: these turns share one worker and one event
+  // proxy, so running them in parallel only makes traces harder to tell apart.
+  { timeout: 90_000 },
+);
+
+export default config;

dev-packages/e2e-tests/test-applications/cloudflare-think/src/env.d.ts

@@ -0,0 +1,9 @@
+declare namespace Cloudflare {
+  interface Env {
+    E2E_TEST_DSN: string;
+    E2E_OPENROUTER_API_KEY: string;
+    ThinkAgent: DurableObjectNamespace;
+  }
+}
+
+interface Env extends Cloudflare.Env {}

dev-packages/e2e-tests/test-applications/cloudflare-think/src/index.ts

@@ -0,0 +1,11 @@
+import { routeAgentRequest } from 'agents';
+
+// Re-exported rather than declared here so the build-time wrapper has to cross a module boundary
+// to find and wrap the class. See the note on the class itself.
+export { ThinkAgent } from './think-agent';
+
+export default {
+  async fetch(request, env): Promise<Response> {
+    return (await routeAgentRequest(request, env)) ?? new Response('Not found', { status: 404 });
+  },
+} satisfies ExportedHandler<Env>;

dev-packages/e2e-tests/test-applications/cloudflare-think/src/instrument.server.ts

@@ -0,0 +1,10 @@
+import { defineCloudflareOptions } from '@sentry/cloudflare';
+
+// The Sentry Vite plugin picks this file up by convention, next to the worker entry named in
+// wrangler's `main`, and hands its default export to `withSentry`.
+export default defineCloudflareOptions((env: Env) => ({
+  dsn: env.E2E_TEST_DSN,
+  environment: 'qa',
+  tunnel: 'http://localhost:3031/',
+  tracesSampleRate: 1.0,
+}));

dev-packages/e2e-tests/test-applications/cloudflare-think/src/think-agent.ts

@@ -0,0 +1,76 @@
+import { createOpenRouter } from '@openrouter/ai-sdk-provider';
+import { Think } from '@cloudflare/think';
+import * as Sentry from '@sentry/cloudflare';
+import type { LanguageModel, ToolSet } from 'ai';
+import { tool } from 'ai';
+import DataLoader from 'dataloader';
+import { z } from 'zod';
+
+/**
+ * Not wrapped by hand: `@sentry/cloudflare/vite` detects `extends Think` and rewrites the worker
+ * entry's export of this class into `instrumentAgentWithSentry(...)` at build time. Wrapping it
+ * here would prove nothing about the zero-config path.
+ *
+ * The class deliberately lives outside the worker entry, which only re-exports it. That is the
+ * harder case for the plugin: the entry never binds the class, so detection has to follow the
+ * re-export into this module and the wrapper has to import the class under a private name.
+ */
+export class ThinkAgent extends Think<Env> {
+  public getModel(): LanguageModel {
+    // Call OpenRouter directly (rather than the default Vercel AI Gateway) so the e2e test needs
+    // only a single OpenRouter key, reusing `E2E_OPENROUTER_API_KEY` like the other AI apps. A real
+    // provider is also what makes the outgoing model request observable as an `http.client` span.
+    const openrouter = createOpenRouter({ apiKey: this.env.E2E_OPENROUTER_API_KEY ?? '' });
+
+    return openrouter('openai/gpt-4o-mini');
+  }
+
+  public getSystemPrompt(): string {
+    return [
+      'You are a concise assistant used by an automated end-to-end test.',
+      'When the user asks about the weather in a place, call the `get_weather` tool for that place and answer in one short sentence using its result.',
+      'When the user asks you to trigger a failure, call the `fail_now` tool.',
+      'Do not ask follow-up questions.',
+    ].join('\n');
+  }
+
+  public getTools(): ToolSet {
+    return {
+      get_weather: tool({
+        description: 'Get the current weather for a location',
+        inputSchema: z.object({ location: z.string() }),
+        execute: async ({ location }: { location: string }) => {
+          // A manual span raised inside a tool must nest under that tool's `gen_ai.execute_tool`
+          // span, which only holds if Think runs the tool inside the SDK's async context.
+          return Sentry.startSpan({ name: 'lookup-forecast', op: 'gen_ai.tool.manual' }, async () => {
+            // `dataloader` is instrumented through the orchestrion module transform rather than by
+            // patching a global, so its spans are the probe for whether channel injection reached
+            // this bundled worker at all.
+            const loader = new DataLoader<string, string>(async keys => keys.map(key => `forecast:${key}`));
+            await Promise.all([loader.load(location), loader.load(location)]);
+
+            return { city: location, condition: 'Sunny', temperatureC: 22 };
+          });
+        },
+      }),
+      fail_now: tool({
+        description: 'Always throws an error. Call this when the user asks to trigger a failure.',
+        // A nominal argument rather than `z.object({})`, and an explicit return type: the AI SDK
+        // infers `never` for an empty input schema, and a body that only throws infers
+        // `Promise<never>`. Either one alone makes the `tool()` overload unresolvable.
+        inputSchema: z.object({ reason: z.string() }),
+        execute: async (_input: { reason: string }): Promise<string> => {
+          throw new Error('Think tool failed on purpose');
+        },
+      }),
+    };
+  }
+
+  public async onRequest(request: Request): Promise<Response> {
+    const message = new URL(request.url).searchParams.get('message') ?? 'What is the weather in Paris?';
+
+    const result = await this.runTurn({ input: message });
+
+    return Response.json({ continuation: result.continuation });
+  }
+}

dev-packages/e2e-tests/test-applications/cloudflare-think/start-event-proxy.mjs

@@ -0,0 +1,7 @@
+import { startEventProxyServer } from '@sentry-internal/test-utils';
+
+startEventProxyServer({
+  port: 3031,
+  proxyServerName: 'cloudflare-think',
+  envelopeDumpPath: process.env.SENTRY_ENVELOPE_DUMP_PATH,
+});

dev-packages/e2e-tests/test-applications/cloudflare-think/tests/dataloader.test.ts

@@ -0,0 +1,44 @@
+import { expect, test } from '@playwright/test';
+import { collectStreamedSpans, getSpanOp } from '@sentry-internal/test-utils';
+import { attr, isTurnOf, newAgentId, runAgentTurn, type StreamedSpan } from './utils';
+
+const APP = 'cloudflare-think';
+
+const isDataloaderSpan = (span: { attributes?: Record<string, { value?: unknown }> }): boolean =>
+  span.attributes?.['sentry.origin']?.value === 'auto.db.dataloader';
+
+/**
+ * `dataloader` is instrumented by the orchestrion module transform rather than by patching anything
+ * at runtime, so its spans are the probe for whether channel injection reached the worker at all.
+ * Libraries that do not need the transform (`node:http`, and the AI spans themselves) would pass
+ * even if injection were broken.
+ *
+ * On Cloudflare the injection is done at build time by `sentryCloudflareVitePlugin()`, so unlike the
+ * Node apps this needs no `--import` bootstrap. A Think worker is heavily bundled, which is exactly
+ * the situation where a transform can silently stop applying, so this is the test that catches it.
+ *
+ * The loader runs inside a tool so its spans land in the turn's trace rather than one of their own.
+ */
+test('captures orchestrion-instrumented dataloader spans in the same trace as the AI spans', async ({ baseURL }) => {
+  const agentId = newAgentId('dataloader');
+  const ofThisTurn = isTurnOf(agentId);
+
+  const spansPromise = collectStreamedSpans(
+    APP,
+    spansOfTrace =>
+      ofThisTurn(spansOfTrace as StreamedSpan[]) &&
+      spansOfTrace.some(span => attr(span as StreamedSpan, 'gen_ai.tool.name') === 'get_weather') &&
+      spansOfTrace.some(isDataloaderSpan),
+  );
+
+  await runAgentTurn(baseURL!, agentId, 'What is the weather in Paris?');
+
+  const spans = await spansPromise;
+  const dataloaderSpan = spans.find(isDataloaderSpan);
+  const toolSpan = spans.find(span => span.attributes?.['gen_ai.tool.name']?.value === 'get_weather');
+
+  // Sharing the trace is the point. Not asserting the exact parent: the model may call the tool more
+  // than once, so the tool span found here is not reliably the one that ran this loader.
+  expect(getSpanOp(dataloaderSpan!)).toBe('cache.get');
+  expect(dataloaderSpan?.trace_id).toBe(toolSpan?.trace_id);
+});

dev-packages/e2e-tests/test-applications/cloudflare-think/tests/errors.test.ts

@@ -0,0 +1,51 @@
+import { expect, test } from '@playwright/test';
+import { collectStreamedSpans, getSpanOp, waitForError } from '@sentry-internal/test-utils';
+import { attr, isTurnOf, newAgentId, runAgentTurn, type StreamedSpan } from './utils';
+
+const APP = 'cloudflare-think';
+
+/**
+ * A tool throw is not an agent failure: the AI SDK catches it, hands the error back to the model as
+ * a tool result, and the turn carries on and usually answers. So the error has to reach Sentry from
+ * the tool span itself, and the spans above it stay `ok` — the model calls did succeed.
+ */
+test('captures an error thrown inside a Think tool and marks its span errored', async ({ baseURL }) => {
+  const agentId = newAgentId('tool-error');
+  const ofThisTurn = isTurnOf(agentId);
+
+  const errorPromise = waitForError(
+    APP,
+    event => event.exception?.values?.[0]?.value === 'Think tool failed on purpose',
+  );
+
+  const spansPromise = collectStreamedSpans(
+    APP,
+    spansOfTrace =>
+      ofThisTurn(spansOfTrace as StreamedSpan[]) &&
+      spansOfTrace.some(span => attr(span as StreamedSpan, 'gen_ai.tool.name') === 'fail_now'),
+  );
+
+  await runAgentTurn(baseURL!, agentId, 'Please trigger a failure now.');
+
+  const error = await errorPromise;
+  const spans = await spansPromise;
+
+  const exception = error.exception?.values?.[0];
+  expect(exception?.type).toBe('Error');
+  expect(exception?.value).toBe('Think tool failed on purpose');
+  expect(exception?.mechanism?.type).toBe('auto.vercelai.channel');
+
+  const toolSpan = spans.find(span => span.attributes?.['gen_ai.tool.name']?.value === 'fail_now');
+  expect(getSpanOp(toolSpan!)).toBe('gen_ai.execute_tool');
+  expect(toolSpan?.status).toBe('error');
+
+  // The issue belongs to the same trace as the turn that produced it.
+  expect(error.contexts?.trace?.trace_id).toBe(toolSpan?.trace_id);
+
+  // The model calls around the failing tool succeeded, so only the tool span is errored.
+  const modelCalls = spans.filter(span => getSpanOp(span) === 'gen_ai.generate_content');
+  expect(modelCalls.length).toBeGreaterThan(0);
+  for (const modelCall of modelCalls) {
+    expect(modelCall.status).toBe('ok');
+  }
+});