feat(cloudflare): Auto-instrument Workers AI binding via env instrumentation

.size-limit.js

@@ -460,7 +460,7 @@ module.exports = [
  ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
  gzip: false,
  brotli: false,
- limit: '183 KiB',
+ limit: '193 KiB',
  disablePlugins: ['@size-limit/webpack'],
  webpack: false,
  modifyEsbuildConfig: function (config) {
@@ -480,7 +480,7 @@ module.exports = [
  ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
  gzip: false,
  brotli: false,
- limit: '448 KiB',
+ limit: '475 KiB',
  disablePlugins: ['@size-limit/webpack'],
  webpack: false,
  modifyEsbuildConfig: function (config) {

dev-packages/cloudflare-integration-tests/package.json

@@ -23,6 +23,7 @@
  "@prisma/adapter-d1": "6.15.0",
  "@prisma/client": "6.15.0",
  "@sentry/cloudflare": "10.66.0",
+ "@sentry/core": "10.66.0",
  "@sentry/hono": "10.66.0",
  "hono": "^4.12.25",
  "openai": "5.18.1"

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/index.ts

@@ -0,0 +1,53 @@
+import*asSentryfrom'@sentry/cloudflare';
+import{instrumentWorkersAiClient}from'@sentry/core';
+import{MockAi}from'./mocks';
+
+interfaceEnv{
+SENTRY_DSN: string;
+}
+
+constai=instrumentWorkersAiClient(newMockAi());
+
+exportdefaultSentry.withSentry(
+(env: Env)=>({
+dsn: env.SENTRY_DSN,
+tracesSampleRate: 1.0,
+// Keep gen_ai spans embedded in the transaction (instead of streamed as a
+// separate envelope container) so they can be asserted on `transaction.spans`.
+streamGenAiSpans: false,
+}),
+{
+asyncfetch(request){
+consturl=newURL(request.url);
+
+if(url.pathname==='/error'){
+// The Workers AI integration deliberately does not call `captureException` itself.
+// A failing `run` must bubble up out of the handler so the top-level Cloudflare
+// instrumentation reports it instead — showing up in Sentry exactly once.
+constresult=awaitai.run('error-model',{prompt: 'Hello'});
+returnnewResponse(JSON.stringify(result));
+}
+
+if(url.pathname==='/stream'){
+conststream=(awaitai.run('@cf/meta/llama-3.1-8b-instruct',{
+messages: [{role: 'user',content: 'What is the capital of France?'}],
+stream: true,
+}))asReadableStream;
+
+consttext=awaitnewResponse(stream).text();
+returnnewResponse(text);
+}
+
+constresult=awaitai.run('@cf/meta/llama-3.1-8b-instruct',{
+messages: [
+{role: 'system',content: 'You are a helpful assistant.'},
+{role: 'user',content: 'What is the capital of France?'},
+],
+temperature: 0.7,
+max_tokens: 100,
+});
+
+returnnewResponse(JSON.stringify(result));
+},
+},
+);

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/mocks.ts

@@ -0,0 +1,45 @@
+import { simulateReadableStream } from 'ai';
+
+function createSseStream(events: string[]): ReadableStream<Uint8Array> {
+ const encoder = new TextEncoder();
+ return simulateReadableStream({
+ initialDelayInMs: 0,
+ chunkDelayInMs: 0,
+ chunks: events.map(event => encoder.encode(`data: ${event}\n\n`)),
+ });
+}
+
+/**
+ * Minimal mock of the Cloudflare Workers AI binding (`env.AI`).
+ */
+export class MockAi {
+ public async run(model: string, inputs: Record<string, unknown>): Promise<unknown> {
+ // Simulate processing time
+ await new Promise(resolve => setTimeout(resolve, 10));
+
+ if (model === 'error-model') {
+ const error = new Error('Model not found');
+ (error as unknown as { status: number }).status = 404;
+ throw error;
+ }
+
+ if (inputs?.stream === true) {
+ return createSseStream([
+ '{"response":"The capital "}',
+ '{"response":"of France "}',
+ '{"response":"is Paris."}',
+ '{"response":"","usage":{"prompt_tokens":12,"completion_tokens":7,"total_tokens":19}}',
+ '[DONE]',
+ ]);
+ }
+
+ return {
+ response: 'The capital of France is Paris.',
+ usage: {
+ prompt_tokens: 12,
+ completion_tokens: 7,
+ total_tokens: 19,
+ },
+ };
+ }
+}

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/test.ts

@@ -0,0 +1,148 @@
+import { GEN_AI_PROVIDER_NAME } from '@sentry/conventions/attributes';
+import { expect, it } from 'vitest';
+import {
+ GEN_AI_OPERATION_NAME_ATTRIBUTE,
+ GEN_AI_REQUEST_MAX_TOKENS_ATTRIBUTE,
+ GEN_AI_REQUEST_MODEL_ATTRIBUTE,
+ GEN_AI_REQUEST_STREAM_ATTRIBUTE,
+ GEN_AI_REQUEST_TEMPERATURE_ATTRIBUTE,
+ GEN_AI_RESPONSE_STREAMING_ATTRIBUTE,
+ GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE,
+ GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE,
+ GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE,
+} from '../../../../../packages/core/src/tracing/ai/gen-ai-attributes';
+import { createRunner } from '../../../runner';
+
+// These tests are not exhaustive because the instrumentation is
+// already tested in the core unit tests and we merely want to test
+// that the instrumentation does not break in our cloudflare SDK.
+
+it('traces a basic Workers AI text generation request', async ({ signal }) => {
+ const runner = createRunner(__dirname)
+ .ignore('event')
+ .expect(envelope => {
+ const transactionEvent = envelope[1]?.[0]?.[1] as any;
+
+ // The transaction event is framework-generated and carries non-deterministic fields
+ // (random ports, ids, timestamps, sdk version), so we assert the stable subset.
+ expect(transactionEvent).toEqual(
+ expect.objectContaining({
+ type: 'transaction',
+ transaction: 'GET /',
+ transaction_info: { source: 'route' },
+ contexts: expect.objectContaining({
+ trace: expect.objectContaining({
+ op: 'http.server',
+ origin: 'auto.http.cloudflare',
+ status: 'ok',
+ }),
+ }),
+ spans: [
+ expect.objectContaining({
+ description: 'chat @cf/meta/llama-3.1-8b-instruct',
+ op: 'gen_ai.chat',
+ origin: 'auto.ai.cloudflare.workers_ai',
+ data: {
+ 'sentry.origin': 'auto.ai.cloudflare.workers_ai',
+ 'sentry.op': 'gen_ai.chat',
+ [GEN_AI_PROVIDER_NAME]: 'cloudflare.workers_ai',
+ [GEN_AI_OPERATION_NAME_ATTRIBUTE]: 'chat',
+ [GEN_AI_REQUEST_MODEL_ATTRIBUTE]: '@cf/meta/llama-3.1-8b-instruct',
+ [GEN_AI_REQUEST_TEMPERATURE_ATTRIBUTE]: 0.7,
+ [GEN_AI_REQUEST_MAX_TOKENS_ATTRIBUTE]: 100,
+ [GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE]: 12,
+ [GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE]: 7,
+ [GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE]: 19,
+ },
+ }),
+ ],
+ }),
+ );
+ })
+ .start(signal);
+ await runner.makeRequest('get', '/');
+ await runner.completed();
+});
+
+it('traces a streaming Workers AI text generation request', async ({ signal }) => {
+ const runner = createRunner(__dirname)
+ .ignore('event')
+ .expect(envelope => {
+ const transactionEvent = envelope[1]?.[0]?.[1] as any;
+
+ expect(transactionEvent).toEqual(
+ expect.objectContaining({
+ type: 'transaction',
+ transaction: 'GET /stream',
+ transaction_info: { source: 'url' },
+ contexts: expect.objectContaining({
+ trace: expect.objectContaining({
+ op: 'http.server',
+ origin: 'auto.http.cloudflare',
+ status: 'ok',
+ }),
+ }),
+ spans: [
+ expect.objectContaining({
+ description: 'chat @cf/meta/llama-3.1-8b-instruct',
+ op: 'gen_ai.chat',
+ origin: 'auto.ai.cloudflare.workers_ai',
+ data: {
+ 'sentry.origin': 'auto.ai.cloudflare.workers_ai',
+ 'sentry.op': 'gen_ai.chat',
+ [GEN_AI_PROVIDER_NAME]: 'cloudflare.workers_ai',
+ [GEN_AI_OPERATION_NAME_ATTRIBUTE]: 'chat',
+ [GEN_AI_REQUEST_MODEL_ATTRIBUTE]: '@cf/meta/llama-3.1-8b-instruct',
+ [GEN_AI_REQUEST_STREAM_ATTRIBUTE]: true,
+ [GEN_AI_RESPONSE_STREAMING_ATTRIBUTE]: true,
+ [GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE]: 12,
+ [GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE]: 7,
+ [GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE]: 19,
+ },
+ }),
+ ],
+ }),
+ );
+ })
+ .start(signal);
+ await runner.makeRequest('get', '/stream');
+ await runner.completed();
+});
+
+// The Workers AI integration deliberately does not call `captureException` itself.
+// When a `run` call fails, the error must bubble up out of the fetch handler and be
+// reported by the top-level Cloudflare instrumentation instead — so it shows up in
+// Sentry exactly once, with the `auto.http.cloudflare` mechanism.
+it('bubbles up Workers AI errors to be captured by the top-level handler', async ({ signal }) => {
+ const runner = createRunner(__dirname)
+ // A failing run still produces a (sampled) transaction; we only care about the error event here.
+ .ignore('transaction')
+ .expect(envelope => {
+ const errorEvent = envelope[1]?.[0]?.[1] as any;
+
+ expect(errorEvent).toEqual(
+ expect.objectContaining({
+ level: 'error',
+ exception: {
+ values: [
+ expect.objectContaining({
+ type: 'Error',
+ value: 'Model not found',
+ stacktrace: {
+ frames: expect.any(Array),
+ },
+ mechanism: { type: 'auto.http.cloudflare', handled: false },
+ }),
+ ],
+ },
+ request: expect.objectContaining({
+ method: 'GET',
+ url: expect.any(String),
+ }),
+ }),
+ );
+ })
+ .start(signal);
+ await runner.makeRequest('get', '/error', { expectError: true });
+ await runner.completed();
+});

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/wrangler.jsonc

@@ -0,0 +1,6 @@
+{
+"name": "workers-ai-worker",
+"compatibility_date": "2025-06-17",
+"main": "index.ts",
+"compatibility_flags": ["nodejs_als"],
+}

packages/cloudflare/src/instrumentations/worker/instrumentEnv.ts

@@ -1,6 +1,8 @@
 import { isObjectLike } from '@sentry/core';
+import { instrumentWorkersAiClient } from '@sentry/core';
 import type { CloudflareOptions } from '../../client';
 import {
+ isAiBinding,
  isD1Database,
  isDurableObjectNamespace,
  isJSRPC,
@@ -33,6 +35,7 @@ const instrumentedBindings = new WeakMap<object, unknown>();
  * - Queue producers (via `send` + `sendBatch` duck-typing)
  * - R2 Buckets (via `head` + `put` + `createMultipartUpload` duck-typing)
  * - Rate limiters (via `limit` duck-typing)
+ * - Workers AI (via `run` + `gateway` + `toMarkdown` duck-typing)
  *
  * @param env - The Cloudflare env object to instrument
  * @param options - Optional CloudflareOptions to control RPC trace propagation
@@ -85,6 +88,12 @@ export function instrumentEnv<Env extends Record<string, unknown>>(env: Env, opt
  return instrumented;
  }
 
+ if (isAiBinding(item)) {
+ const instrumented = instrumentWorkersAiClient(item);
+ instrumentedBindings.set(item, instrumented);
+ return instrumented;
+ }
+
  if (!rpcPropagation) {
  return item;
  }

packages/cloudflare/src/utils/isBinding.ts

@@ -31,7 +31,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-import type { D1Database, DurableObjectNamespace, Queue, R2Bucket, RateLimit } from '@cloudflare/workers-types';
+import type { Ai, D1Database, DurableObjectNamespace, Queue, R2Bucket, RateLimit } from '@cloudflare/workers-types';
 
 /**
  * Checks if a value is a JSRPC proxy (service binding).
@@ -82,6 +82,20 @@ export function isD1Database(item: unknown): item is D1Database {
  );
 }
 
+/**
+ * Duck-type check for Workers AI bindings.
+ * The Ai binding has `run`, `gateway`, and `toMarkdown` methods.
+ */
+export function isAiBinding(item: unknown): item is Ai {
+ return (
+ item != null &&
+ isNotJSRPC(item) &&
+ typeof item.run === 'function' &&
+ typeof item.gateway === 'function' &&
+ typeof item.toMarkdown === 'function'
+ );
+}
+
 /**
  * Duck-type check for R2 Bucket bindings.
  * R2Bucket has `head`, `put`, and `createMultipartUpload` methods.

packages/cloudflare/test/instrumentations/instrumentEnv.test.ts

@@ -284,6 +284,49 @@ describe('instrumentEnv', () => {
  expect(instrumented.MY_RATE_LIMITER).toBe(instrumented.MY_RATE_LIMITER);
  });
 
+ describe('Workers AI bindings', () => {
+ function createMockAiBinding() {
+ return {
+ run: vi.fn().mockResolvedValue({ response: 'Paris', usage: { prompt_tokens: 1, completion_tokens: 2 } }),
+ gateway: vi.fn(),
+ toMarkdown: vi.fn(),
+ models: vi.fn(),
+ autorag: vi.fn(),
+ };
+ }
+
+ it('detects and wraps AI bindings, forwarding run calls unchanged', async () => {
+ const ai = createMockAiBinding();
+ const env = { AI: ai };
+ const instrumented = instrumentEnv(env);
+
+ const wrapped = instrumented.AI as typeof ai;
+ expect(wrapped).not.toBe(ai);
+
+ const result = await wrapped.run('@cf/meta/llama-3.1-8b-instruct', { prompt: 'Hello' });
+
+ expect(ai.run).toHaveBeenCalledTimes(1);
+ expect(ai.run).toHaveBeenCalledWith('@cf/meta/llama-3.1-8b-instruct', { prompt: 'Hello' });
+ expect(result).toEqual({ response: 'Paris', usage: { prompt_tokens: 1, completion_tokens: 2 } });
+ });
+
+ it('caches the wrapped AI binding across repeated access', () => {
+ const ai = createMockAiBinding();
+ const env = { AI: ai };
+ const instrumented = instrumentEnv(env);
+
+ expect(instrumented.AI).toBe(instrumented.AI);
+ });
+
+ it('does not treat bindings with only a run method as AI bindings', () => {
+ const notAi = { run: vi.fn() };
+ const env = { RUNNER: notAi };
+ const instrumented = instrumentEnv(env);
+
+ expect(instrumented.RUNNER).toBe(notAi);
+ });
+ });
+
  describe('mTLS Fetcher bindings', () => {
  function createMtlsFetcherProxy(mockFetch: ReturnType<typeof vi.fn>) {
  return new Proxy(

.size-limit.js

@@ -460,7 +460,7 @@ module.exports = [
  ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
  gzip: false,
  brotli: false,
- limit: '183 KiB',
+ limit: '193 KiB',
  disablePlugins: ['@size-limit/webpack'],
  webpack: false,
  modifyEsbuildConfig: function (config) {
@@ -480,7 +480,7 @@ module.exports = [
  ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
  gzip: false,
  brotli: false,
- limit: '448 KiB',
+ limit: '475 KiB',
  disablePlugins: ['@size-limit/webpack'],
  webpack: false,
  modifyEsbuildConfig: function (config) {

dev-packages/cloudflare-integration-tests/package.json

@@ -23,6 +23,7 @@
  "@prisma/adapter-d1": "6.15.0",
  "@prisma/client": "6.15.0",
  "@sentry/cloudflare": "10.66.0",
+ "@sentry/core": "10.66.0",
  "@sentry/hono": "10.66.0",
  "hono": "^4.12.25",
  "openai": "5.18.1"

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/index.ts

@@ -0,0 +1,53 @@
+import*asSentryfrom'@sentry/cloudflare';
+import{instrumentWorkersAiClient}from'@sentry/core';
+import{MockAi}from'./mocks';
+
+interfaceEnv{
+SENTRY_DSN: string;
+}
+
+constai=instrumentWorkersAiClient(newMockAi());
+
+exportdefaultSentry.withSentry(
+(env: Env)=>({
+dsn: env.SENTRY_DSN,
+tracesSampleRate: 1.0,
+// Keep gen_ai spans embedded in the transaction (instead of streamed as a
+// separate envelope container) so they can be asserted on `transaction.spans`.
+streamGenAiSpans: false,
+}),
+{
+asyncfetch(request){
+consturl=newURL(request.url);
+
+if(url.pathname==='/error'){
+// The Workers AI integration deliberately does not call `captureException` itself.
+// A failing `run` must bubble up out of the handler so the top-level Cloudflare
+// instrumentation reports it instead — showing up in Sentry exactly once.
+constresult=awaitai.run('error-model',{prompt: 'Hello'});
+returnnewResponse(JSON.stringify(result));
+}
+
+if(url.pathname==='/stream'){
+conststream=(awaitai.run('@cf/meta/llama-3.1-8b-instruct',{
+messages: [{role: 'user',content: 'What is the capital of France?'}],
+stream: true,
+}))asReadableStream;
+
+consttext=awaitnewResponse(stream).text();
+returnnewResponse(text);
+}
+
+constresult=awaitai.run('@cf/meta/llama-3.1-8b-instruct',{
+messages: [
+{role: 'system',content: 'You are a helpful assistant.'},
+{role: 'user',content: 'What is the capital of France?'},
+],
+temperature: 0.7,
+max_tokens: 100,
+});
+
+returnnewResponse(JSON.stringify(result));
+},
+},
+);

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/mocks.ts

@@ -0,0 +1,45 @@
+import { simulateReadableStream } from 'ai';
+
+function createSseStream(events: string[]): ReadableStream<Uint8Array> {
+ const encoder = new TextEncoder();
+ return simulateReadableStream({
+ initialDelayInMs: 0,
+ chunkDelayInMs: 0,
+ chunks: events.map(event => encoder.encode(`data: ${event}\n\n`)),
+ });
+}
+
+/**
+ * Minimal mock of the Cloudflare Workers AI binding (`env.AI`).
+ */
+export class MockAi {
+ public async run(model: string, inputs: Record<string, unknown>): Promise<unknown> {
+ // Simulate processing time
+ await new Promise(resolve => setTimeout(resolve, 10));
+
+ if (model === 'error-model') {
+ const error = new Error('Model not found');
+ (error as unknown as { status: number }).status = 404;
+ throw error;
+ }
+
+ if (inputs?.stream === true) {
+ return createSseStream([
+ '{"response":"The capital "}',
+ '{"response":"of France "}',
+ '{"response":"is Paris."}',
+ '{"response":"","usage":{"prompt_tokens":12,"completion_tokens":7,"total_tokens":19}}',
+ '[DONE]',
+ ]);
+ }
+
+ return {
+ response: 'The capital of France is Paris.',
+ usage: {
+ prompt_tokens: 12,
+ completion_tokens: 7,
+ total_tokens: 19,
+ },
+ };
+ }
+}

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/test.ts

@@ -0,0 +1,148 @@
+import { GEN_AI_PROVIDER_NAME } from '@sentry/conventions/attributes';
+import { expect, it } from 'vitest';
+import {
+ GEN_AI_OPERATION_NAME_ATTRIBUTE,
+ GEN_AI_REQUEST_MAX_TOKENS_ATTRIBUTE,
+ GEN_AI_REQUEST_MODEL_ATTRIBUTE,
+ GEN_AI_REQUEST_STREAM_ATTRIBUTE,
+ GEN_AI_REQUEST_TEMPERATURE_ATTRIBUTE,
+ GEN_AI_RESPONSE_STREAMING_ATTRIBUTE,
+ GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE,
+ GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE,
+ GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE,
+} from '../../../../../packages/core/src/tracing/ai/gen-ai-attributes';
+import { createRunner } from '../../../runner';
+
+// These tests are not exhaustive because the instrumentation is
+// already tested in the core unit tests and we merely want to test
+// that the instrumentation does not break in our cloudflare SDK.
+
+it('traces a basic Workers AI text generation request', async ({ signal }) => {
+ const runner = createRunner(__dirname)
+ .ignore('event')
+ .expect(envelope => {
+ const transactionEvent = envelope[1]?.[0]?.[1] as any;
+
+ // The transaction event is framework-generated and carries non-deterministic fields
+ // (random ports, ids, timestamps, sdk version), so we assert the stable subset.
+ expect(transactionEvent).toEqual(
+ expect.objectContaining({
+ type: 'transaction',
+ transaction: 'GET /',
+ transaction_info: { source: 'route' },
+ contexts: expect.objectContaining({
+ trace: expect.objectContaining({
+ op: 'http.server',
+ origin: 'auto.http.cloudflare',
+ status: 'ok',
+ }),
+ }),
+ spans: [
+ expect.objectContaining({
+ description: 'chat @cf/meta/llama-3.1-8b-instruct',
+ op: 'gen_ai.chat',
+ origin: 'auto.ai.cloudflare.workers_ai',
+ data: {
+ 'sentry.origin': 'auto.ai.cloudflare.workers_ai',
+ 'sentry.op': 'gen_ai.chat',
+ [GEN_AI_PROVIDER_NAME]: 'cloudflare.workers_ai',
+ [GEN_AI_OPERATION_NAME_ATTRIBUTE]: 'chat',
+ [GEN_AI_REQUEST_MODEL_ATTRIBUTE]: '@cf/meta/llama-3.1-8b-instruct',
+ [GEN_AI_REQUEST_TEMPERATURE_ATTRIBUTE]: 0.7,
+ [GEN_AI_REQUEST_MAX_TOKENS_ATTRIBUTE]: 100,
+ [GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE]: 12,
+ [GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE]: 7,
+ [GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE]: 19,
+ },
+ }),
+ ],
+ }),
+ );
+ })
+ .start(signal);
+ await runner.makeRequest('get', '/');
+ await runner.completed();
+});
+
+it('traces a streaming Workers AI text generation request', async ({ signal }) => {
+ const runner = createRunner(__dirname)
+ .ignore('event')
+ .expect(envelope => {
+ const transactionEvent = envelope[1]?.[0]?.[1] as any;
+
+ expect(transactionEvent).toEqual(
+ expect.objectContaining({
+ type: 'transaction',
+ transaction: 'GET /stream',
+ transaction_info: { source: 'url' },
+ contexts: expect.objectContaining({
+ trace: expect.objectContaining({
+ op: 'http.server',
+ origin: 'auto.http.cloudflare',
+ status: 'ok',
+ }),
+ }),
+ spans: [
+ expect.objectContaining({
+ description: 'chat @cf/meta/llama-3.1-8b-instruct',
+ op: 'gen_ai.chat',
+ origin: 'auto.ai.cloudflare.workers_ai',
+ data: {
+ 'sentry.origin': 'auto.ai.cloudflare.workers_ai',
+ 'sentry.op': 'gen_ai.chat',
+ [GEN_AI_PROVIDER_NAME]: 'cloudflare.workers_ai',
+ [GEN_AI_OPERATION_NAME_ATTRIBUTE]: 'chat',
+ [GEN_AI_REQUEST_MODEL_ATTRIBUTE]: '@cf/meta/llama-3.1-8b-instruct',
+ [GEN_AI_REQUEST_STREAM_ATTRIBUTE]: true,
+ [GEN_AI_RESPONSE_STREAMING_ATTRIBUTE]: true,
+ [GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE]: 12,
+ [GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE]: 7,
+ [GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE]: 19,
+ },
+ }),
+ ],
+ }),
+ );
+ })
+ .start(signal);
+ await runner.makeRequest('get', '/stream');
+ await runner.completed();
+});
+
+// The Workers AI integration deliberately does not call `captureException` itself.
+// When a `run` call fails, the error must bubble up out of the fetch handler and be
+// reported by the top-level Cloudflare instrumentation instead — so it shows up in
+// Sentry exactly once, with the `auto.http.cloudflare` mechanism.
+it('bubbles up Workers AI errors to be captured by the top-level handler', async ({ signal }) => {
+ const runner = createRunner(__dirname)
+ // A failing run still produces a (sampled) transaction; we only care about the error event here.
+ .ignore('transaction')
+ .expect(envelope => {
+ const errorEvent = envelope[1]?.[0]?.[1] as any;
+
+ expect(errorEvent).toEqual(
+ expect.objectContaining({
+ level: 'error',
+ exception: {
+ values: [
+ expect.objectContaining({
+ type: 'Error',
+ value: 'Model not found',
+ stacktrace: {
+ frames: expect.any(Array),
+ },
+ mechanism: { type: 'auto.http.cloudflare', handled: false },
+ }),
+ ],
+ },
+ request: expect.objectContaining({
+ method: 'GET',
+ url: expect.any(String),
+ }),
+ }),
+ );
+ })
+ .start(signal);
+ await runner.makeRequest('get', '/error', { expectError: true });
+ await runner.completed();
+});

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/wrangler.jsonc

@@ -0,0 +1,6 @@
+{
+"name": "workers-ai-worker",
+"compatibility_date": "2025-06-17",
+"main": "index.ts",
+"compatibility_flags": ["nodejs_als"],
+}

packages/cloudflare/src/instrumentations/worker/instrumentEnv.ts

@@ -1,6 +1,8 @@
 import { isObjectLike } from '@sentry/core';
+import { instrumentWorkersAiClient } from '@sentry/core';
 import type { CloudflareOptions } from '../../client';
 import {
+ isAiBinding,
  isD1Database,
  isDurableObjectNamespace,
  isJSRPC,
@@ -33,6 +35,7 @@ const instrumentedBindings = new WeakMap<object, unknown>();
  * - Queue producers (via `send` + `sendBatch` duck-typing)
  * - R2 Buckets (via `head` + `put` + `createMultipartUpload` duck-typing)
  * - Rate limiters (via `limit` duck-typing)
+ * - Workers AI (via `run` + `gateway` + `toMarkdown` duck-typing)
  *
  * @param env - The Cloudflare env object to instrument
  * @param options - Optional CloudflareOptions to control RPC trace propagation
@@ -85,6 +88,12 @@ export function instrumentEnv<Env extends Record<string, unknown>>(env: Env, opt
  return instrumented;
  }
 
+ if (isAiBinding(item)) {
+ const instrumented = instrumentWorkersAiClient(item);
+ instrumentedBindings.set(item, instrumented);
+ return instrumented;
+ }
+
  if (!rpcPropagation) {
  return item;
  }

packages/cloudflare/src/utils/isBinding.ts

@@ -31,7 +31,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-import type { D1Database, DurableObjectNamespace, Queue, R2Bucket, RateLimit } from '@cloudflare/workers-types';
+import type { Ai, D1Database, DurableObjectNamespace, Queue, R2Bucket, RateLimit } from '@cloudflare/workers-types';
 
 /**
  * Checks if a value is a JSRPC proxy (service binding).
@@ -82,6 +82,20 @@ export function isD1Database(item: unknown): item is D1Database {
  );
 }
 
+/**
+ * Duck-type check for Workers AI bindings.
+ * The Ai binding has `run`, `gateway`, and `toMarkdown` methods.
+ */
+export function isAiBinding(item: unknown): item is Ai {
+ return (
+ item != null &&
+ isNotJSRPC(item) &&
+ typeof item.run === 'function' &&
+ typeof item.gateway === 'function' &&
+ typeof item.toMarkdown === 'function'
+ );
+}
+
 /**
  * Duck-type check for R2 Bucket bindings.
  * R2Bucket has `head`, `put`, and `createMultipartUpload` methods.

packages/cloudflare/test/instrumentations/instrumentEnv.test.ts

@@ -284,6 +284,49 @@ describe('instrumentEnv', () => {
  expect(instrumented.MY_RATE_LIMITER).toBe(instrumented.MY_RATE_LIMITER);
  });
 
+ describe('Workers AI bindings', () => {
+ function createMockAiBinding() {
+ return {
+ run: vi.fn().mockResolvedValue({ response: 'Paris', usage: { prompt_tokens: 1, completion_tokens: 2 } }),
+ gateway: vi.fn(),
+ toMarkdown: vi.fn(),
+ models: vi.fn(),
+ autorag: vi.fn(),
+ };
+ }
+
+ it('detects and wraps AI bindings, forwarding run calls unchanged', async () => {
+ const ai = createMockAiBinding();
+ const env = { AI: ai };
+ const instrumented = instrumentEnv(env);
+
+ const wrapped = instrumented.AI as typeof ai;
+ expect(wrapped).not.toBe(ai);
+
+ const result = await wrapped.run('@cf/meta/llama-3.1-8b-instruct', { prompt: 'Hello' });
+
+ expect(ai.run).toHaveBeenCalledTimes(1);
+ expect(ai.run).toHaveBeenCalledWith('@cf/meta/llama-3.1-8b-instruct', { prompt: 'Hello' });
+ expect(result).toEqual({ response: 'Paris', usage: { prompt_tokens: 1, completion_tokens: 2 } });
+ });
+
+ it('caches the wrapped AI binding across repeated access', () => {
+ const ai = createMockAiBinding();
+ const env = { AI: ai };
+ const instrumented = instrumentEnv(env);
+
+ expect(instrumented.AI).toBe(instrumented.AI);
+ });
+
+ it('does not treat bindings with only a run method as AI bindings', () => {
+ const notAi = { run: vi.fn() };
+ const env = { RUNNER: notAi };
+ const instrumented = instrumentEnv(env);
+
+ expect(instrumented.RUNNER).toBe(notAi);
+ });
+ });
+
  describe('mTLS Fetcher bindings', () => {
  function createMtlsFetcherProxy(mockFetch: ReturnType<typeof vi.fn>) {
  return new Proxy(

.size-limit.js

@@ -460,7 +460,7 @@ module.exports = [
  ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
  gzip: false,
  brotli: false,
- limit: '183 KiB',
+ limit: '193 KiB',
  disablePlugins: ['@size-limit/webpack'],
  webpack: false,
  modifyEsbuildConfig: function (config) {
@@ -480,7 +480,7 @@ module.exports = [
  ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
  gzip: false,
  brotli: false,
- limit: '448 KiB',
+ limit: '475 KiB',
  disablePlugins: ['@size-limit/webpack'],
  webpack: false,
  modifyEsbuildConfig: function (config) {

dev-packages/cloudflare-integration-tests/package.json

@@ -23,6 +23,7 @@
  "@prisma/adapter-d1": "6.15.0",
  "@prisma/client": "6.15.0",
  "@sentry/cloudflare": "10.66.0",
+ "@sentry/core": "10.66.0",
  "@sentry/hono": "10.66.0",
  "hono": "^4.12.25",
  "openai": "5.18.1"

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/index.ts

@@ -0,0 +1,53 @@
+import*asSentryfrom'@sentry/cloudflare';
+import{instrumentWorkersAiClient}from'@sentry/core';
+import{MockAi}from'./mocks';
+
+interfaceEnv{
+SENTRY_DSN: string;
+}
+
+constai=instrumentWorkersAiClient(newMockAi());
+
+exportdefaultSentry.withSentry(
+(env: Env)=>({
+dsn: env.SENTRY_DSN,
+tracesSampleRate: 1.0,
+// Keep gen_ai spans embedded in the transaction (instead of streamed as a
+// separate envelope container) so they can be asserted on `transaction.spans`.
+streamGenAiSpans: false,
+}),
+{
+asyncfetch(request){
+consturl=newURL(request.url);
+
+if(url.pathname==='/error'){
+// The Workers AI integration deliberately does not call `captureException` itself.
+// A failing `run` must bubble up out of the handler so the top-level Cloudflare
+// instrumentation reports it instead — showing up in Sentry exactly once.
+constresult=awaitai.run('error-model',{prompt: 'Hello'});
+returnnewResponse(JSON.stringify(result));
+}
+
+if(url.pathname==='/stream'){
+conststream=(awaitai.run('@cf/meta/llama-3.1-8b-instruct',{
+messages: [{role: 'user',content: 'What is the capital of France?'}],
+stream: true,
+}))asReadableStream;
+
+consttext=awaitnewResponse(stream).text();
+returnnewResponse(text);
+}
+
+constresult=awaitai.run('@cf/meta/llama-3.1-8b-instruct',{
+messages: [
+{role: 'system',content: 'You are a helpful assistant.'},
+{role: 'user',content: 'What is the capital of France?'},
+],
+temperature: 0.7,
+max_tokens: 100,
+});
+
+returnnewResponse(JSON.stringify(result));
+},
+},
+);

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/mocks.ts

@@ -0,0 +1,45 @@
+import { simulateReadableStream } from 'ai';
+
+function createSseStream(events: string[]): ReadableStream<Uint8Array> {
+ const encoder = new TextEncoder();
+ return simulateReadableStream({
+ initialDelayInMs: 0,
+ chunkDelayInMs: 0,
+ chunks: events.map(event => encoder.encode(`data: ${event}\n\n`)),
+ });
+}
+
+/**
+ * Minimal mock of the Cloudflare Workers AI binding (`env.AI`).
+ */
+export class MockAi {
+ public async run(model: string, inputs: Record<string, unknown>): Promise<unknown> {
+ // Simulate processing time
+ await new Promise(resolve => setTimeout(resolve, 10));
+
+ if (model === 'error-model') {
+ const error = new Error('Model not found');
+ (error as unknown as { status: number }).status = 404;
+ throw error;
+ }
+
+ if (inputs?.stream === true) {
+ return createSseStream([
+ '{"response":"The capital "}',
+ '{"response":"of France "}',
+ '{"response":"is Paris."}',
+ '{"response":"","usage":{"prompt_tokens":12,"completion_tokens":7,"total_tokens":19}}',
+ '[DONE]',
+ ]);
+ }
+
+ return {
+ response: 'The capital of France is Paris.',
+ usage: {
+ prompt_tokens: 12,
+ completion_tokens: 7,
+ total_tokens: 19,
+ },
+ };
+ }
+}

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/test.ts

@@ -0,0 +1,148 @@
+import { GEN_AI_PROVIDER_NAME } from '@sentry/conventions/attributes';
+import { expect, it } from 'vitest';
+import {
+ GEN_AI_OPERATION_NAME_ATTRIBUTE,
+ GEN_AI_REQUEST_MAX_TOKENS_ATTRIBUTE,
+ GEN_AI_REQUEST_MODEL_ATTRIBUTE,
+ GEN_AI_REQUEST_STREAM_ATTRIBUTE,
+ GEN_AI_REQUEST_TEMPERATURE_ATTRIBUTE,
+ GEN_AI_RESPONSE_STREAMING_ATTRIBUTE,
+ GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE,
+ GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE,
+ GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE,
+} from '../../../../../packages/core/src/tracing/ai/gen-ai-attributes';
+import { createRunner } from '../../../runner';
+
+// These tests are not exhaustive because the instrumentation is
+// already tested in the core unit tests and we merely want to test
+// that the instrumentation does not break in our cloudflare SDK.
+
+it('traces a basic Workers AI text generation request', async ({ signal }) => {
+ const runner = createRunner(__dirname)
+ .ignore('event')
+ .expect(envelope => {
+ const transactionEvent = envelope[1]?.[0]?.[1] as any;
+
+ // The transaction event is framework-generated and carries non-deterministic fields
+ // (random ports, ids, timestamps, sdk version), so we assert the stable subset.
+ expect(transactionEvent).toEqual(
+ expect.objectContaining({
+ type: 'transaction',
+ transaction: 'GET /',
+ transaction_info: { source: 'route' },
+ contexts: expect.objectContaining({
+ trace: expect.objectContaining({
+ op: 'http.server',
+ origin: 'auto.http.cloudflare',
+ status: 'ok',
+ }),
+ }),
+ spans: [
+ expect.objectContaining({
+ description: 'chat @cf/meta/llama-3.1-8b-instruct',
+ op: 'gen_ai.chat',
+ origin: 'auto.ai.cloudflare.workers_ai',
+ data: {
+ 'sentry.origin': 'auto.ai.cloudflare.workers_ai',
+ 'sentry.op': 'gen_ai.chat',
+ [GEN_AI_PROVIDER_NAME]: 'cloudflare.workers_ai',
+ [GEN_AI_OPERATION_NAME_ATTRIBUTE]: 'chat',
+ [GEN_AI_REQUEST_MODEL_ATTRIBUTE]: '@cf/meta/llama-3.1-8b-instruct',
+ [GEN_AI_REQUEST_TEMPERATURE_ATTRIBUTE]: 0.7,
+ [GEN_AI_REQUEST_MAX_TOKENS_ATTRIBUTE]: 100,
+ [GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE]: 12,
+ [GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE]: 7,
+ [GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE]: 19,
+ },
+ }),
+ ],
+ }),
+ );
+ })
+ .start(signal);
+ await runner.makeRequest('get', '/');
+ await runner.completed();
+});
+
+it('traces a streaming Workers AI text generation request', async ({ signal }) => {
+ const runner = createRunner(__dirname)
+ .ignore('event')
+ .expect(envelope => {
+ const transactionEvent = envelope[1]?.[0]?.[1] as any;
+
+ expect(transactionEvent).toEqual(
+ expect.objectContaining({
+ type: 'transaction',
+ transaction: 'GET /stream',
+ transaction_info: { source: 'url' },
+ contexts: expect.objectContaining({
+ trace: expect.objectContaining({
+ op: 'http.server',
+ origin: 'auto.http.cloudflare',
+ status: 'ok',
+ }),
+ }),
+ spans: [
+ expect.objectContaining({
+ description: 'chat @cf/meta/llama-3.1-8b-instruct',
+ op: 'gen_ai.chat',
+ origin: 'auto.ai.cloudflare.workers_ai',
+ data: {
+ 'sentry.origin': 'auto.ai.cloudflare.workers_ai',
+ 'sentry.op': 'gen_ai.chat',
+ [GEN_AI_PROVIDER_NAME]: 'cloudflare.workers_ai',
+ [GEN_AI_OPERATION_NAME_ATTRIBUTE]: 'chat',
+ [GEN_AI_REQUEST_MODEL_ATTRIBUTE]: '@cf/meta/llama-3.1-8b-instruct',
+ [GEN_AI_REQUEST_STREAM_ATTRIBUTE]: true,
+ [GEN_AI_RESPONSE_STREAMING_ATTRIBUTE]: true,
+ [GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE]: 12,
+ [GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE]: 7,
+ [GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE]: 19,
+ },
+ }),
+ ],
+ }),
+ );
+ })
+ .start(signal);
+ await runner.makeRequest('get', '/stream');
+ await runner.completed();
+});
+
+// The Workers AI integration deliberately does not call `captureException` itself.
+// When a `run` call fails, the error must bubble up out of the fetch handler and be
+// reported by the top-level Cloudflare instrumentation instead — so it shows up in
+// Sentry exactly once, with the `auto.http.cloudflare` mechanism.
+it('bubbles up Workers AI errors to be captured by the top-level handler', async ({ signal }) => {
+ const runner = createRunner(__dirname)
+ // A failing run still produces a (sampled) transaction; we only care about the error event here.
+ .ignore('transaction')
+ .expect(envelope => {
+ const errorEvent = envelope[1]?.[0]?.[1] as any;
+
+ expect(errorEvent).toEqual(
+ expect.objectContaining({
+ level: 'error',
+ exception: {
+ values: [
+ expect.objectContaining({
+ type: 'Error',
+ value: 'Model not found',
+ stacktrace: {
+ frames: expect.any(Array),
+ },
+ mechanism: { type: 'auto.http.cloudflare', handled: false },
+ }),
+ ],
+ },
+ request: expect.objectContaining({
+ method: 'GET',
+ url: expect.any(String),
+ }),
+ }),
+ );
+ })
+ .start(signal);
+ await runner.makeRequest('get', '/error', { expectError: true });
+ await runner.completed();
+});

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/wrangler.jsonc

@@ -0,0 +1,6 @@
+{
+"name": "workers-ai-worker",
+"compatibility_date": "2025-06-17",
+"main": "index.ts",
+"compatibility_flags": ["nodejs_als"],
+}

packages/cloudflare/src/instrumentations/worker/instrumentEnv.ts

@@ -1,6 +1,8 @@
 import { isObjectLike } from '@sentry/core';
+import { instrumentWorkersAiClient } from '@sentry/core';
 import type { CloudflareOptions } from '../../client';
 import {
+ isAiBinding,
  isD1Database,
  isDurableObjectNamespace,
  isJSRPC,
@@ -33,6 +35,7 @@ const instrumentedBindings = new WeakMap<object, unknown>();
  * - Queue producers (via `send` + `sendBatch` duck-typing)
  * - R2 Buckets (via `head` + `put` + `createMultipartUpload` duck-typing)
  * - Rate limiters (via `limit` duck-typing)
+ * - Workers AI (via `run` + `gateway` + `toMarkdown` duck-typing)
  *
  * @param env - The Cloudflare env object to instrument
  * @param options - Optional CloudflareOptions to control RPC trace propagation
@@ -85,6 +88,12 @@ export function instrumentEnv<Env extends Record<string, unknown>>(env: Env, opt
  return instrumented;
  }
 
+ if (isAiBinding(item)) {
+ const instrumented = instrumentWorkersAiClient(item);
+ instrumentedBindings.set(item, instrumented);
+ return instrumented;
+ }
+
  if (!rpcPropagation) {
  return item;
  }

packages/cloudflare/src/utils/isBinding.ts

@@ -31,7 +31,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-import type { D1Database, DurableObjectNamespace, Queue, R2Bucket, RateLimit } from '@cloudflare/workers-types';
+import type { Ai, D1Database, DurableObjectNamespace, Queue, R2Bucket, RateLimit } from '@cloudflare/workers-types';
 
 /**
  * Checks if a value is a JSRPC proxy (service binding).
@@ -82,6 +82,20 @@ export function isD1Database(item: unknown): item is D1Database {
  );
 }
 
+/**
+ * Duck-type check for Workers AI bindings.
+ * The Ai binding has `run`, `gateway`, and `toMarkdown` methods.
+ */
+export function isAiBinding(item: unknown): item is Ai {
+ return (
+ item != null &&
+ isNotJSRPC(item) &&
+ typeof item.run === 'function' &&
+ typeof item.gateway === 'function' &&
+ typeof item.toMarkdown === 'function'
+ );
+}
+
 /**
  * Duck-type check for R2 Bucket bindings.
  * R2Bucket has `head`, `put`, and `createMultipartUpload` methods.

packages/cloudflare/test/instrumentations/instrumentEnv.test.ts

@@ -284,6 +284,49 @@ describe('instrumentEnv', () => {
  expect(instrumented.MY_RATE_LIMITER).toBe(instrumented.MY_RATE_LIMITER);
  });
 
+ describe('Workers AI bindings', () => {
+ function createMockAiBinding() {
+ return {
+ run: vi.fn().mockResolvedValue({ response: 'Paris', usage: { prompt_tokens: 1, completion_tokens: 2 } }),
+ gateway: vi.fn(),
+ toMarkdown: vi.fn(),
+ models: vi.fn(),
+ autorag: vi.fn(),
+ };
+ }
+
+ it('detects and wraps AI bindings, forwarding run calls unchanged', async () => {
+ const ai = createMockAiBinding();
+ const env = { AI: ai };
+ const instrumented = instrumentEnv(env);
+
+ const wrapped = instrumented.AI as typeof ai;
+ expect(wrapped).not.toBe(ai);
+
+ const result = await wrapped.run('@cf/meta/llama-3.1-8b-instruct', { prompt: 'Hello' });
+
+ expect(ai.run).toHaveBeenCalledTimes(1);
+ expect(ai.run).toHaveBeenCalledWith('@cf/meta/llama-3.1-8b-instruct', { prompt: 'Hello' });
+ expect(result).toEqual({ response: 'Paris', usage: { prompt_tokens: 1, completion_tokens: 2 } });
+ });
+
+ it('caches the wrapped AI binding across repeated access', () => {
+ const ai = createMockAiBinding();
+ const env = { AI: ai };
+ const instrumented = instrumentEnv(env);
+
+ expect(instrumented.AI).toBe(instrumented.AI);
+ });
+
+ it('does not treat bindings with only a run method as AI bindings', () => {
+ const notAi = { run: vi.fn() };
+ const env = { RUNNER: notAi };
+ const instrumented = instrumentEnv(env);
+
+ expect(instrumented.RUNNER).toBe(notAi);
+ });
+ });
+
  describe('mTLS Fetcher bindings', () => {
  function createMtlsFetcherProxy(mockFetch: ReturnType<typeof vi.fn>) {
  return new Proxy(

.size-limit.js

@@ -460,7 +460,7 @@ module.exports = [
  ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
  gzip: false,
  brotli: false,
- limit: '183 KiB',
+ limit: '193 KiB',
  disablePlugins: ['@size-limit/webpack'],
  webpack: false,
  modifyEsbuildConfig: function (config) {
@@ -480,7 +480,7 @@ module.exports = [
  ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
  gzip: false,
  brotli: false,
- limit: '448 KiB',
+ limit: '475 KiB',
  disablePlugins: ['@size-limit/webpack'],
  webpack: false,
  modifyEsbuildConfig: function (config) {

dev-packages/cloudflare-integration-tests/package.json

@@ -23,6 +23,7 @@
  "@prisma/adapter-d1": "6.15.0",
  "@prisma/client": "6.15.0",
  "@sentry/cloudflare": "10.66.0",
+ "@sentry/core": "10.66.0",
  "@sentry/hono": "10.66.0",
  "hono": "^4.12.25",
  "openai": "5.18.1"

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/index.ts

@@ -0,0 +1,53 @@
+import*asSentryfrom'@sentry/cloudflare';
+import{instrumentWorkersAiClient}from'@sentry/core';
+import{MockAi}from'./mocks';
+
+interfaceEnv{
+SENTRY_DSN: string;
+}
+
+constai=instrumentWorkersAiClient(newMockAi());
+
+exportdefaultSentry.withSentry(
+(env: Env)=>({
+dsn: env.SENTRY_DSN,
+tracesSampleRate: 1.0,
+// Keep gen_ai spans embedded in the transaction (instead of streamed as a
+// separate envelope container) so they can be asserted on `transaction.spans`.
+streamGenAiSpans: false,
+}),
+{
+asyncfetch(request){
+consturl=newURL(request.url);
+
+if(url.pathname==='/error'){
+// The Workers AI integration deliberately does not call `captureException` itself.
+// A failing `run` must bubble up out of the handler so the top-level Cloudflare
+// instrumentation reports it instead — showing up in Sentry exactly once.
+constresult=awaitai.run('error-model',{prompt: 'Hello'});
+returnnewResponse(JSON.stringify(result));
+}
+
+if(url.pathname==='/stream'){
+conststream=(awaitai.run('@cf/meta/llama-3.1-8b-instruct',{
+messages: [{role: 'user',content: 'What is the capital of France?'}],
+stream: true,
+}))asReadableStream;
+
+consttext=awaitnewResponse(stream).text();
+returnnewResponse(text);
+}
+
+constresult=awaitai.run('@cf/meta/llama-3.1-8b-instruct',{
+messages: [
+{role: 'system',content: 'You are a helpful assistant.'},
+{role: 'user',content: 'What is the capital of France?'},
+],
+temperature: 0.7,
+max_tokens: 100,
+});
+
+returnnewResponse(JSON.stringify(result));
+},
+},
+);

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/mocks.ts

@@ -0,0 +1,45 @@
+import { simulateReadableStream } from 'ai';
+
+function createSseStream(events: string[]): ReadableStream<Uint8Array> {
+ const encoder = new TextEncoder();
+ return simulateReadableStream({
+ initialDelayInMs: 0,
+ chunkDelayInMs: 0,
+ chunks: events.map(event => encoder.encode(`data: ${event}\n\n`)),
+ });
+}
+
+/**
+ * Minimal mock of the Cloudflare Workers AI binding (`env.AI`).
+ */
+export class MockAi {
+ public async run(model: string, inputs: Record<string, unknown>): Promise<unknown> {
+ // Simulate processing time
+ await new Promise(resolve => setTimeout(resolve, 10));
+
+ if (model === 'error-model') {
+ const error = new Error('Model not found');
+ (error as unknown as { status: number }).status = 404;
+ throw error;
+ }
+
+ if (inputs?.stream === true) {
+ return createSseStream([
+ '{"response":"The capital "}',
+ '{"response":"of France "}',
+ '{"response":"is Paris."}',
+ '{"response":"","usage":{"prompt_tokens":12,"completion_tokens":7,"total_tokens":19}}',
+ '[DONE]',
+ ]);
+ }
+
+ return {
+ response: 'The capital of France is Paris.',
+ usage: {
+ prompt_tokens: 12,
+ completion_tokens: 7,
+ total_tokens: 19,
+ },
+ };
+ }
+}

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/test.ts

@@ -0,0 +1,148 @@
+import { GEN_AI_PROVIDER_NAME } from '@sentry/conventions/attributes';
+import { expect, it } from 'vitest';
+import {
+ GEN_AI_OPERATION_NAME_ATTRIBUTE,
+ GEN_AI_REQUEST_MAX_TOKENS_ATTRIBUTE,
+ GEN_AI_REQUEST_MODEL_ATTRIBUTE,
+ GEN_AI_REQUEST_STREAM_ATTRIBUTE,
+ GEN_AI_REQUEST_TEMPERATURE_ATTRIBUTE,
+ GEN_AI_RESPONSE_STREAMING_ATTRIBUTE,
+ GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE,
+ GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE,
+ GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE,
+} from '../../../../../packages/core/src/tracing/ai/gen-ai-attributes';
+import { createRunner } from '../../../runner';
+
+// These tests are not exhaustive because the instrumentation is
+// already tested in the core unit tests and we merely want to test
+// that the instrumentation does not break in our cloudflare SDK.
+
+it('traces a basic Workers AI text generation request', async ({ signal }) => {
+ const runner = createRunner(__dirname)
+ .ignore('event')
+ .expect(envelope => {
+ const transactionEvent = envelope[1]?.[0]?.[1] as any;
+
+ // The transaction event is framework-generated and carries non-deterministic fields
+ // (random ports, ids, timestamps, sdk version), so we assert the stable subset.
+ expect(transactionEvent).toEqual(
+ expect.objectContaining({
+ type: 'transaction',
+ transaction: 'GET /',
+ transaction_info: { source: 'route' },
+ contexts: expect.objectContaining({
+ trace: expect.objectContaining({
+ op: 'http.server',
+ origin: 'auto.http.cloudflare',
+ status: 'ok',
+ }),
+ }),
+ spans: [
+ expect.objectContaining({
+ description: 'chat @cf/meta/llama-3.1-8b-instruct',
+ op: 'gen_ai.chat',
+ origin: 'auto.ai.cloudflare.workers_ai',
+ data: {
+ 'sentry.origin': 'auto.ai.cloudflare.workers_ai',
+ 'sentry.op': 'gen_ai.chat',
+ [GEN_AI_PROVIDER_NAME]: 'cloudflare.workers_ai',
+ [GEN_AI_OPERATION_NAME_ATTRIBUTE]: 'chat',
+ [GEN_AI_REQUEST_MODEL_ATTRIBUTE]: '@cf/meta/llama-3.1-8b-instruct',
+ [GEN_AI_REQUEST_TEMPERATURE_ATTRIBUTE]: 0.7,
+ [GEN_AI_REQUEST_MAX_TOKENS_ATTRIBUTE]: 100,
+ [GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE]: 12,
+ [GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE]: 7,
+ [GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE]: 19,
+ },
+ }),
+ ],
+ }),
+ );
+ })
+ .start(signal);
+ await runner.makeRequest('get', '/');
+ await runner.completed();
+});
+
+it('traces a streaming Workers AI text generation request', async ({ signal }) => {
+ const runner = createRunner(__dirname)
+ .ignore('event')
+ .expect(envelope => {
+ const transactionEvent = envelope[1]?.[0]?.[1] as any;
+
+ expect(transactionEvent).toEqual(
+ expect.objectContaining({
+ type: 'transaction',
+ transaction: 'GET /stream',
+ transaction_info: { source: 'url' },
+ contexts: expect.objectContaining({
+ trace: expect.objectContaining({
+ op: 'http.server',
+ origin: 'auto.http.cloudflare',
+ status: 'ok',
+ }),
+ }),
+ spans: [
+ expect.objectContaining({
+ description: 'chat @cf/meta/llama-3.1-8b-instruct',
+ op: 'gen_ai.chat',
+ origin: 'auto.ai.cloudflare.workers_ai',
+ data: {
+ 'sentry.origin': 'auto.ai.cloudflare.workers_ai',
+ 'sentry.op': 'gen_ai.chat',
+ [GEN_AI_PROVIDER_NAME]: 'cloudflare.workers_ai',
+ [GEN_AI_OPERATION_NAME_ATTRIBUTE]: 'chat',
+ [GEN_AI_REQUEST_MODEL_ATTRIBUTE]: '@cf/meta/llama-3.1-8b-instruct',
+ [GEN_AI_REQUEST_STREAM_ATTRIBUTE]: true,
+ [GEN_AI_RESPONSE_STREAMING_ATTRIBUTE]: true,
+ [GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE]: 12,
+ [GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE]: 7,
+ [GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE]: 19,
+ },
+ }),
+ ],
+ }),
+ );
+ })
+ .start(signal);
+ await runner.makeRequest('get', '/stream');
+ await runner.completed();
+});
+
+// The Workers AI integration deliberately does not call `captureException` itself.
+// When a `run` call fails, the error must bubble up out of the fetch handler and be
+// reported by the top-level Cloudflare instrumentation instead — so it shows up in
+// Sentry exactly once, with the `auto.http.cloudflare` mechanism.
+it('bubbles up Workers AI errors to be captured by the top-level handler', async ({ signal }) => {
+ const runner = createRunner(__dirname)
+ // A failing run still produces a (sampled) transaction; we only care about the error event here.
+ .ignore('transaction')
+ .expect(envelope => {
+ const errorEvent = envelope[1]?.[0]?.[1] as any;
+
+ expect(errorEvent).toEqual(
+ expect.objectContaining({
+ level: 'error',
+ exception: {
+ values: [
+ expect.objectContaining({
+ type: 'Error',
+ value: 'Model not found',
+ stacktrace: {
+ frames: expect.any(Array),
+ },
+ mechanism: { type: 'auto.http.cloudflare', handled: false },
+ }),
+ ],
+ },
+ request: expect.objectContaining({
+ method: 'GET',
+ url: expect.any(String),
+ }),
+ }),
+ );
+ })
+ .start(signal);
+ await runner.makeRequest('get', '/error', { expectError: true });
+ await runner.completed();
+});

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/wrangler.jsonc

@@ -0,0 +1,6 @@
+{
+"name": "workers-ai-worker",
+"compatibility_date": "2025-06-17",
+"main": "index.ts",
+"compatibility_flags": ["nodejs_als"],
+}

packages/cloudflare/src/instrumentations/worker/instrumentEnv.ts

@@ -1,6 +1,8 @@
 import { isObjectLike } from '@sentry/core';
+import { instrumentWorkersAiClient } from '@sentry/core';
 import type { CloudflareOptions } from '../../client';
 import {
+ isAiBinding,
  isD1Database,
  isDurableObjectNamespace,
  isJSRPC,
@@ -33,6 +35,7 @@ const instrumentedBindings = new WeakMap<object, unknown>();
  * - Queue producers (via `send` + `sendBatch` duck-typing)
  * - R2 Buckets (via `head` + `put` + `createMultipartUpload` duck-typing)
  * - Rate limiters (via `limit` duck-typing)
+ * - Workers AI (via `run` + `gateway` + `toMarkdown` duck-typing)
  *
  * @param env - The Cloudflare env object to instrument
  * @param options - Optional CloudflareOptions to control RPC trace propagation
@@ -85,6 +88,12 @@ export function instrumentEnv<Env extends Record<string, unknown>>(env: Env, opt
  return instrumented;
  }
 
+ if (isAiBinding(item)) {
+ const instrumented = instrumentWorkersAiClient(item);
+ instrumentedBindings.set(item, instrumented);
+ return instrumented;
+ }
+
  if (!rpcPropagation) {
  return item;
  }

packages/cloudflare/src/utils/isBinding.ts

@@ -31,7 +31,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-import type { D1Database, DurableObjectNamespace, Queue, R2Bucket, RateLimit } from '@cloudflare/workers-types';
+import type { Ai, D1Database, DurableObjectNamespace, Queue, R2Bucket, RateLimit } from '@cloudflare/workers-types';
 
 /**
  * Checks if a value is a JSRPC proxy (service binding).
@@ -82,6 +82,20 @@ export function isD1Database(item: unknown): item is D1Database {
  );
 }
 
+/**
+ * Duck-type check for Workers AI bindings.
+ * The Ai binding has `run`, `gateway`, and `toMarkdown` methods.
+ */
+export function isAiBinding(item: unknown): item is Ai {
+ return (
+ item != null &&
+ isNotJSRPC(item) &&
+ typeof item.run === 'function' &&
+ typeof item.gateway === 'function' &&
+ typeof item.toMarkdown === 'function'
+ );
+}
+
 /**
  * Duck-type check for R2 Bucket bindings.
  * R2Bucket has `head`, `put`, and `createMultipartUpload` methods.

packages/cloudflare/test/instrumentations/instrumentEnv.test.ts

@@ -284,6 +284,49 @@ describe('instrumentEnv', () => {
  expect(instrumented.MY_RATE_LIMITER).toBe(instrumented.MY_RATE_LIMITER);
  });
 
+ describe('Workers AI bindings', () => {
+ function createMockAiBinding() {
+ return {
+ run: vi.fn().mockResolvedValue({ response: 'Paris', usage: { prompt_tokens: 1, completion_tokens: 2 } }),
+ gateway: vi.fn(),
+ toMarkdown: vi.fn(),
+ models: vi.fn(),
+ autorag: vi.fn(),
+ };
+ }
+
+ it('detects and wraps AI bindings, forwarding run calls unchanged', async () => {
+ const ai = createMockAiBinding();
+ const env = { AI: ai };
+ const instrumented = instrumentEnv(env);
+
+ const wrapped = instrumented.AI as typeof ai;
+ expect(wrapped).not.toBe(ai);
+
+ const result = await wrapped.run('@cf/meta/llama-3.1-8b-instruct', { prompt: 'Hello' });
+
+ expect(ai.run).toHaveBeenCalledTimes(1);
+ expect(ai.run).toHaveBeenCalledWith('@cf/meta/llama-3.1-8b-instruct', { prompt: 'Hello' });
+ expect(result).toEqual({ response: 'Paris', usage: { prompt_tokens: 1, completion_tokens: 2 } });
+ });
+
+ it('caches the wrapped AI binding across repeated access', () => {
+ const ai = createMockAiBinding();
+ const env = { AI: ai };
+ const instrumented = instrumentEnv(env);
+
+ expect(instrumented.AI).toBe(instrumented.AI);
+ });
+
+ it('does not treat bindings with only a run method as AI bindings', () => {
+ const notAi = { run: vi.fn() };
+ const env = { RUNNER: notAi };
+ const instrumented = instrumentEnv(env);
+
+ expect(instrumented.RUNNER).toBe(notAi);
+ });
+ });
+
  describe('mTLS Fetcher bindings', () => {
  function createMtlsFetcherProxy(mockFetch: ReturnType<typeof vi.fn>) {
  return new Proxy(

.size-limit.js

@@ -460,7 +460,7 @@ module.exports = [
  ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
  gzip: false,
  brotli: false,
- limit: '183 KiB',
+ limit: '193 KiB',
  disablePlugins: ['@size-limit/webpack'],
  webpack: false,
  modifyEsbuildConfig: function (config) {
@@ -480,7 +480,7 @@ module.exports = [
  ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
  gzip: false,
  brotli: false,
- limit: '448 KiB',
+ limit: '475 KiB',
  disablePlugins: ['@size-limit/webpack'],
  webpack: false,
  modifyEsbuildConfig: function (config) {

dev-packages/cloudflare-integration-tests/package.json

@@ -23,6 +23,7 @@
  "@prisma/adapter-d1": "6.15.0",
  "@prisma/client": "6.15.0",
  "@sentry/cloudflare": "10.66.0",
+ "@sentry/core": "10.66.0",
  "@sentry/hono": "10.66.0",
  "hono": "^4.12.25",
  "openai": "5.18.1"

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/index.ts

@@ -0,0 +1,53 @@
+import*asSentryfrom'@sentry/cloudflare';
+import{instrumentWorkersAiClient}from'@sentry/core';
+import{MockAi}from'./mocks';
+
+interfaceEnv{
+SENTRY_DSN: string;
+}
+
+constai=instrumentWorkersAiClient(newMockAi());
+
+exportdefaultSentry.withSentry(
+(env: Env)=>({
+dsn: env.SENTRY_DSN,
+tracesSampleRate: 1.0,
+// Keep gen_ai spans embedded in the transaction (instead of streamed as a
+// separate envelope container) so they can be asserted on `transaction.spans`.
+streamGenAiSpans: false,
+}),
+{
+asyncfetch(request){
+consturl=newURL(request.url);
+
+if(url.pathname==='/error'){
+// The Workers AI integration deliberately does not call `captureException` itself.
+// A failing `run` must bubble up out of the handler so the top-level Cloudflare
+// instrumentation reports it instead — showing up in Sentry exactly once.
+constresult=awaitai.run('error-model',{prompt: 'Hello'});
+returnnewResponse(JSON.stringify(result));
+}
+
+if(url.pathname==='/stream'){
+conststream=(awaitai.run('@cf/meta/llama-3.1-8b-instruct',{
+messages: [{role: 'user',content: 'What is the capital of France?'}],
+stream: true,
+}))asReadableStream;
+
+consttext=awaitnewResponse(stream).text();
+returnnewResponse(text);
+}
+
+constresult=awaitai.run('@cf/meta/llama-3.1-8b-instruct',{
+messages: [
+{role: 'system',content: 'You are a helpful assistant.'},
+{role: 'user',content: 'What is the capital of France?'},
+],
+temperature: 0.7,
+max_tokens: 100,
+});
+
+returnnewResponse(JSON.stringify(result));
+},
+},
+);

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/mocks.ts

@@ -0,0 +1,45 @@
+import { simulateReadableStream } from 'ai';
+
+function createSseStream(events: string[]): ReadableStream<Uint8Array> {
+ const encoder = new TextEncoder();
+ return simulateReadableStream({
+ initialDelayInMs: 0,
+ chunkDelayInMs: 0,
+ chunks: events.map(event => encoder.encode(`data: ${event}\n\n`)),
+ });
+}
+
+/**
+ * Minimal mock of the Cloudflare Workers AI binding (`env.AI`).
+ */
+export class MockAi {
+ public async run(model: string, inputs: Record<string, unknown>): Promise<unknown> {
+ // Simulate processing time
+ await new Promise(resolve => setTimeout(resolve, 10));
+
+ if (model === 'error-model') {
+ const error = new Error('Model not found');
+ (error as unknown as { status: number }).status = 404;
+ throw error;
+ }
+
+ if (inputs?.stream === true) {
+ return createSseStream([
+ '{"response":"The capital "}',
+ '{"response":"of France "}',
+ '{"response":"is Paris."}',
+ '{"response":"","usage":{"prompt_tokens":12,"completion_tokens":7,"total_tokens":19}}',
+ '[DONE]',
+ ]);
+ }
+
+ return {
+ response: 'The capital of France is Paris.',
+ usage: {
+ prompt_tokens: 12,
+ completion_tokens: 7,
+ total_tokens: 19,
+ },
+ };
+ }
+}

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/test.ts

@@ -0,0 +1,148 @@
+import { GEN_AI_PROVIDER_NAME } from '@sentry/conventions/attributes';
+import { expect, it } from 'vitest';
+import {
+ GEN_AI_OPERATION_NAME_ATTRIBUTE,
+ GEN_AI_REQUEST_MAX_TOKENS_ATTRIBUTE,
+ GEN_AI_REQUEST_MODEL_ATTRIBUTE,
+ GEN_AI_REQUEST_STREAM_ATTRIBUTE,
+ GEN_AI_REQUEST_TEMPERATURE_ATTRIBUTE,
+ GEN_AI_RESPONSE_STREAMING_ATTRIBUTE,
+ GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE,
+ GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE,
+ GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE,
+} from '../../../../../packages/core/src/tracing/ai/gen-ai-attributes';
+import { createRunner } from '../../../runner';
+
+// These tests are not exhaustive because the instrumentation is
+// already tested in the core unit tests and we merely want to test
+// that the instrumentation does not break in our cloudflare SDK.
+
+it('traces a basic Workers AI text generation request', async ({ signal }) => {
+ const runner = createRunner(__dirname)
+ .ignore('event')
+ .expect(envelope => {
+ const transactionEvent = envelope[1]?.[0]?.[1] as any;
+
+ // The transaction event is framework-generated and carries non-deterministic fields
+ // (random ports, ids, timestamps, sdk version), so we assert the stable subset.
+ expect(transactionEvent).toEqual(
+ expect.objectContaining({
+ type: 'transaction',
+ transaction: 'GET /',
+ transaction_info: { source: 'route' },
+ contexts: expect.objectContaining({
+ trace: expect.objectContaining({
+ op: 'http.server',
+ origin: 'auto.http.cloudflare',
+ status: 'ok',
+ }),
+ }),
+ spans: [
+ expect.objectContaining({
+ description: 'chat @cf/meta/llama-3.1-8b-instruct',
+ op: 'gen_ai.chat',
+ origin: 'auto.ai.cloudflare.workers_ai',
+ data: {
+ 'sentry.origin': 'auto.ai.cloudflare.workers_ai',
+ 'sentry.op': 'gen_ai.chat',
+ [GEN_AI_PROVIDER_NAME]: 'cloudflare.workers_ai',
+ [GEN_AI_OPERATION_NAME_ATTRIBUTE]: 'chat',
+ [GEN_AI_REQUEST_MODEL_ATTRIBUTE]: '@cf/meta/llama-3.1-8b-instruct',
+ [GEN_AI_REQUEST_TEMPERATURE_ATTRIBUTE]: 0.7,
+ [GEN_AI_REQUEST_MAX_TOKENS_ATTRIBUTE]: 100,
+ [GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE]: 12,
+ [GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE]: 7,
+ [GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE]: 19,
+ },
+ }),
+ ],
+ }),
+ );
+ })
+ .start(signal);
+ await runner.makeRequest('get', '/');
+ await runner.completed();
+});
+
+it('traces a streaming Workers AI text generation request', async ({ signal }) => {
+ const runner = createRunner(__dirname)
+ .ignore('event')
+ .expect(envelope => {
+ const transactionEvent = envelope[1]?.[0]?.[1] as any;
+
+ expect(transactionEvent).toEqual(
+ expect.objectContaining({
+ type: 'transaction',
+ transaction: 'GET /stream',
+ transaction_info: { source: 'url' },
+ contexts: expect.objectContaining({
+ trace: expect.objectContaining({
+ op: 'http.server',
+ origin: 'auto.http.cloudflare',
+ status: 'ok',
+ }),
+ }),
+ spans: [
+ expect.objectContaining({
+ description: 'chat @cf/meta/llama-3.1-8b-instruct',
+ op: 'gen_ai.chat',
+ origin: 'auto.ai.cloudflare.workers_ai',
+ data: {
+ 'sentry.origin': 'auto.ai.cloudflare.workers_ai',
+ 'sentry.op': 'gen_ai.chat',
+ [GEN_AI_PROVIDER_NAME]: 'cloudflare.workers_ai',
+ [GEN_AI_OPERATION_NAME_ATTRIBUTE]: 'chat',
+ [GEN_AI_REQUEST_MODEL_ATTRIBUTE]: '@cf/meta/llama-3.1-8b-instruct',
+ [GEN_AI_REQUEST_STREAM_ATTRIBUTE]: true,
+ [GEN_AI_RESPONSE_STREAMING_ATTRIBUTE]: true,
+ [GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE]: 12,
+ [GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE]: 7,
+ [GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE]: 19,
+ },
+ }),
+ ],
+ }),
+ );
+ })
+ .start(signal);
+ await runner.makeRequest('get', '/stream');
+ await runner.completed();
+});
+
+// The Workers AI integration deliberately does not call `captureException` itself.
+// When a `run` call fails, the error must bubble up out of the fetch handler and be
+// reported by the top-level Cloudflare instrumentation instead — so it shows up in
+// Sentry exactly once, with the `auto.http.cloudflare` mechanism.
+it('bubbles up Workers AI errors to be captured by the top-level handler', async ({ signal }) => {
+ const runner = createRunner(__dirname)
+ // A failing run still produces a (sampled) transaction; we only care about the error event here.
+ .ignore('transaction')
+ .expect(envelope => {
+ const errorEvent = envelope[1]?.[0]?.[1] as any;
+
+ expect(errorEvent).toEqual(
+ expect.objectContaining({
+ level: 'error',
+ exception: {
+ values: [
+ expect.objectContaining({
+ type: 'Error',
+ value: 'Model not found',
+ stacktrace: {
+ frames: expect.any(Array),
+ },
+ mechanism: { type: 'auto.http.cloudflare', handled: false },
+ }),
+ ],
+ },
+ request: expect.objectContaining({
+ method: 'GET',
+ url: expect.any(String),
+ }),
+ }),
+ );
+ })
+ .start(signal);
+ await runner.makeRequest('get', '/error', { expectError: true });
+ await runner.completed();
+});

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/wrangler.jsonc

@@ -0,0 +1,6 @@
+{
+"name": "workers-ai-worker",
+"compatibility_date": "2025-06-17",
+"main": "index.ts",
+"compatibility_flags": ["nodejs_als"],
+}

packages/cloudflare/src/instrumentations/worker/instrumentEnv.ts

@@ -1,6 +1,8 @@
 import { isObjectLike } from '@sentry/core';
+import { instrumentWorkersAiClient } from '@sentry/core';
 import type { CloudflareOptions } from '../../client';
 import {
+ isAiBinding,
  isD1Database,
  isDurableObjectNamespace,
  isJSRPC,
@@ -33,6 +35,7 @@ const instrumentedBindings = new WeakMap<object, unknown>();
  * - Queue producers (via `send` + `sendBatch` duck-typing)
  * - R2 Buckets (via `head` + `put` + `createMultipartUpload` duck-typing)
  * - Rate limiters (via `limit` duck-typing)
+ * - Workers AI (via `run` + `gateway` + `toMarkdown` duck-typing)
  *
  * @param env - The Cloudflare env object to instrument
  * @param options - Optional CloudflareOptions to control RPC trace propagation
@@ -85,6 +88,12 @@ export function instrumentEnv<Env extends Record<string, unknown>>(env: Env, opt
  return instrumented;
  }
 
+ if (isAiBinding(item)) {
+ const instrumented = instrumentWorkersAiClient(item);
+ instrumentedBindings.set(item, instrumented);
+ return instrumented;
+ }
+
  if (!rpcPropagation) {
  return item;
  }

packages/cloudflare/src/utils/isBinding.ts

@@ -31,7 +31,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-import type { D1Database, DurableObjectNamespace, Queue, R2Bucket, RateLimit } from '@cloudflare/workers-types';
+import type { Ai, D1Database, DurableObjectNamespace, Queue, R2Bucket, RateLimit } from '@cloudflare/workers-types';
 
 /**
  * Checks if a value is a JSRPC proxy (service binding).
@@ -82,6 +82,20 @@ export function isD1Database(item: unknown): item is D1Database {
  );
 }
 
+/**
+ * Duck-type check for Workers AI bindings.
+ * The Ai binding has `run`, `gateway`, and `toMarkdown` methods.
+ */
+export function isAiBinding(item: unknown): item is Ai {
+ return (
+ item != null &&
+ isNotJSRPC(item) &&
+ typeof item.run === 'function' &&
+ typeof item.gateway === 'function' &&
+ typeof item.toMarkdown === 'function'
+ );
+}
+
 /**
  * Duck-type check for R2 Bucket bindings.
  * R2Bucket has `head`, `put`, and `createMultipartUpload` methods.

packages/cloudflare/test/instrumentations/instrumentEnv.test.ts

@@ -284,6 +284,49 @@ describe('instrumentEnv', () => {
  expect(instrumented.MY_RATE_LIMITER).toBe(instrumented.MY_RATE_LIMITER);
  });
 
+ describe('Workers AI bindings', () => {
+ function createMockAiBinding() {
+ return {
+ run: vi.fn().mockResolvedValue({ response: 'Paris', usage: { prompt_tokens: 1, completion_tokens: 2 } }),
+ gateway: vi.fn(),
+ toMarkdown: vi.fn(),
+ models: vi.fn(),
+ autorag: vi.fn(),
+ };
+ }
+
+ it('detects and wraps AI bindings, forwarding run calls unchanged', async () => {
+ const ai = createMockAiBinding();
+ const env = { AI: ai };
+ const instrumented = instrumentEnv(env);
+
+ const wrapped = instrumented.AI as typeof ai;
+ expect(wrapped).not.toBe(ai);
+
+ const result = await wrapped.run('@cf/meta/llama-3.1-8b-instruct', { prompt: 'Hello' });
+
+ expect(ai.run).toHaveBeenCalledTimes(1);
+ expect(ai.run).toHaveBeenCalledWith('@cf/meta/llama-3.1-8b-instruct', { prompt: 'Hello' });
+ expect(result).toEqual({ response: 'Paris', usage: { prompt_tokens: 1, completion_tokens: 2 } });
+ });
+
+ it('caches the wrapped AI binding across repeated access', () => {
+ const ai = createMockAiBinding();
+ const env = { AI: ai };
+ const instrumented = instrumentEnv(env);
+
+ expect(instrumented.AI).toBe(instrumented.AI);
+ });
+
+ it('does not treat bindings with only a run method as AI bindings', () => {
+ const notAi = { run: vi.fn() };
+ const env = { RUNNER: notAi };
+ const instrumented = instrumentEnv(env);
+
+ expect(instrumented.RUNNER).toBe(notAi);
+ });
+ });
+
  describe('mTLS Fetcher bindings', () => {
  function createMtlsFetcherProxy(mockFetch: ReturnType<typeof vi.fn>) {
  return new Proxy(

.size-limit.js

@@ -460,7 +460,7 @@ module.exports = [
  ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
  gzip: false,
  brotli: false,
- limit: '183 KiB',
+ limit: '193 KiB',
  disablePlugins: ['@size-limit/webpack'],
  webpack: false,
  modifyEsbuildConfig: function (config) {
@@ -480,7 +480,7 @@ module.exports = [
  ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
  gzip: false,
  brotli: false,
- limit: '448 KiB',
+ limit: '475 KiB',
  disablePlugins: ['@size-limit/webpack'],
  webpack: false,
  modifyEsbuildConfig: function (config) {

dev-packages/cloudflare-integration-tests/package.json

@@ -23,6 +23,7 @@
  "@prisma/adapter-d1": "6.15.0",
  "@prisma/client": "6.15.0",
  "@sentry/cloudflare": "10.66.0",
+ "@sentry/core": "10.66.0",
  "@sentry/hono": "10.66.0",
  "hono": "^4.12.25",
  "openai": "5.18.1"

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/index.ts

@@ -0,0 +1,53 @@
+import*asSentryfrom'@sentry/cloudflare';
+import{instrumentWorkersAiClient}from'@sentry/core';
+import{MockAi}from'./mocks';
+
+interfaceEnv{
+SENTRY_DSN: string;
+}
+
+constai=instrumentWorkersAiClient(newMockAi());
+
+exportdefaultSentry.withSentry(
+(env: Env)=>({
+dsn: env.SENTRY_DSN,
+tracesSampleRate: 1.0,
+// Keep gen_ai spans embedded in the transaction (instead of streamed as a
+// separate envelope container) so they can be asserted on `transaction.spans`.
+streamGenAiSpans: false,
+}),
+{
+asyncfetch(request){
+consturl=newURL(request.url);
+
+if(url.pathname==='/error'){
+// The Workers AI integration deliberately does not call `captureException` itself.
+// A failing `run` must bubble up out of the handler so the top-level Cloudflare
+// instrumentation reports it instead — showing up in Sentry exactly once.
+constresult=awaitai.run('error-model',{prompt: 'Hello'});
+returnnewResponse(JSON.stringify(result));
+}
+
+if(url.pathname==='/stream'){
+conststream=(awaitai.run('@cf/meta/llama-3.1-8b-instruct',{
+messages: [{role: 'user',content: 'What is the capital of France?'}],
+stream: true,
+}))asReadableStream;
+
+consttext=awaitnewResponse(stream).text();
+returnnewResponse(text);
+}
+
+constresult=awaitai.run('@cf/meta/llama-3.1-8b-instruct',{
+messages: [
+{role: 'system',content: 'You are a helpful assistant.'},
+{role: 'user',content: 'What is the capital of France?'},
+],
+temperature: 0.7,
+max_tokens: 100,
+});
+
+returnnewResponse(JSON.stringify(result));
+},
+},
+);

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/mocks.ts

@@ -0,0 +1,45 @@
+import { simulateReadableStream } from 'ai';
+
+function createSseStream(events: string[]): ReadableStream<Uint8Array> {
+ const encoder = new TextEncoder();
+ return simulateReadableStream({
+ initialDelayInMs: 0,
+ chunkDelayInMs: 0,
+ chunks: events.map(event => encoder.encode(`data: ${event}\n\n`)),
+ });
+}
+
+/**
+ * Minimal mock of the Cloudflare Workers AI binding (`env.AI`).
+ */
+export class MockAi {
+ public async run(model: string, inputs: Record<string, unknown>): Promise<unknown> {
+ // Simulate processing time
+ await new Promise(resolve => setTimeout(resolve, 10));
+
+ if (model === 'error-model') {
+ const error = new Error('Model not found');
+ (error as unknown as { status: number }).status = 404;
+ throw error;
+ }
+
+ if (inputs?.stream === true) {
+ return createSseStream([
+ '{"response":"The capital "}',
+ '{"response":"of France "}',
+ '{"response":"is Paris."}',
+ '{"response":"","usage":{"prompt_tokens":12,"completion_tokens":7,"total_tokens":19}}',
+ '[DONE]',
+ ]);
+ }
+
+ return {
+ response: 'The capital of France is Paris.',
+ usage: {
+ prompt_tokens: 12,
+ completion_tokens: 7,
+ total_tokens: 19,
+ },
+ };
+ }
+}

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/test.ts

@@ -0,0 +1,148 @@
+import { GEN_AI_PROVIDER_NAME } from '@sentry/conventions/attributes';
+import { expect, it } from 'vitest';
+import {
+ GEN_AI_OPERATION_NAME_ATTRIBUTE,
+ GEN_AI_REQUEST_MAX_TOKENS_ATTRIBUTE,
+ GEN_AI_REQUEST_MODEL_ATTRIBUTE,
+ GEN_AI_REQUEST_STREAM_ATTRIBUTE,
+ GEN_AI_REQUEST_TEMPERATURE_ATTRIBUTE,
+ GEN_AI_RESPONSE_STREAMING_ATTRIBUTE,
+ GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE,
+ GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE,
+ GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE,
+} from '../../../../../packages/core/src/tracing/ai/gen-ai-attributes';
+import { createRunner } from '../../../runner';
+
+// These tests are not exhaustive because the instrumentation is
+// already tested in the core unit tests and we merely want to test
+// that the instrumentation does not break in our cloudflare SDK.
+
+it('traces a basic Workers AI text generation request', async ({ signal }) => {
+ const runner = createRunner(__dirname)
+ .ignore('event')
+ .expect(envelope => {
+ const transactionEvent = envelope[1]?.[0]?.[1] as any;
+
+ // The transaction event is framework-generated and carries non-deterministic fields
+ // (random ports, ids, timestamps, sdk version), so we assert the stable subset.
+ expect(transactionEvent).toEqual(
+ expect.objectContaining({
+ type: 'transaction',
+ transaction: 'GET /',
+ transaction_info: { source: 'route' },
+ contexts: expect.objectContaining({
+ trace: expect.objectContaining({
+ op: 'http.server',
+ origin: 'auto.http.cloudflare',
+ status: 'ok',
+ }),
+ }),
+ spans: [
+ expect.objectContaining({
+ description: 'chat @cf/meta/llama-3.1-8b-instruct',
+ op: 'gen_ai.chat',
+ origin: 'auto.ai.cloudflare.workers_ai',
+ data: {
+ 'sentry.origin': 'auto.ai.cloudflare.workers_ai',
+ 'sentry.op': 'gen_ai.chat',
+ [GEN_AI_PROVIDER_NAME]: 'cloudflare.workers_ai',
+ [GEN_AI_OPERATION_NAME_ATTRIBUTE]: 'chat',
+ [GEN_AI_REQUEST_MODEL_ATTRIBUTE]: '@cf/meta/llama-3.1-8b-instruct',
+ [GEN_AI_REQUEST_TEMPERATURE_ATTRIBUTE]: 0.7,
+ [GEN_AI_REQUEST_MAX_TOKENS_ATTRIBUTE]: 100,
+ [GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE]: 12,
+ [GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE]: 7,
+ [GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE]: 19,
+ },
+ }),
+ ],
+ }),
+ );
+ })
+ .start(signal);
+ await runner.makeRequest('get', '/');
+ await runner.completed();
+});
+
+it('traces a streaming Workers AI text generation request', async ({ signal }) => {
+ const runner = createRunner(__dirname)
+ .ignore('event')
+ .expect(envelope => {
+ const transactionEvent = envelope[1]?.[0]?.[1] as any;
+
+ expect(transactionEvent).toEqual(
+ expect.objectContaining({
+ type: 'transaction',
+ transaction: 'GET /stream',
+ transaction_info: { source: 'url' },
+ contexts: expect.objectContaining({
+ trace: expect.objectContaining({
+ op: 'http.server',
+ origin: 'auto.http.cloudflare',
+ status: 'ok',
+ }),
+ }),
+ spans: [
+ expect.objectContaining({
+ description: 'chat @cf/meta/llama-3.1-8b-instruct',
+ op: 'gen_ai.chat',
+ origin: 'auto.ai.cloudflare.workers_ai',
+ data: {
+ 'sentry.origin': 'auto.ai.cloudflare.workers_ai',
+ 'sentry.op': 'gen_ai.chat',
+ [GEN_AI_PROVIDER_NAME]: 'cloudflare.workers_ai',
+ [GEN_AI_OPERATION_NAME_ATTRIBUTE]: 'chat',
+ [GEN_AI_REQUEST_MODEL_ATTRIBUTE]: '@cf/meta/llama-3.1-8b-instruct',
+ [GEN_AI_REQUEST_STREAM_ATTRIBUTE]: true,
+ [GEN_AI_RESPONSE_STREAMING_ATTRIBUTE]: true,
+ [GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE]: 12,
+ [GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE]: 7,
+ [GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE]: 19,
+ },
+ }),
+ ],
+ }),
+ );
+ })
+ .start(signal);
+ await runner.makeRequest('get', '/stream');
+ await runner.completed();
+});
+
+// The Workers AI integration deliberately does not call `captureException` itself.
+// When a `run` call fails, the error must bubble up out of the fetch handler and be
+// reported by the top-level Cloudflare instrumentation instead — so it shows up in
+// Sentry exactly once, with the `auto.http.cloudflare` mechanism.
+it('bubbles up Workers AI errors to be captured by the top-level handler', async ({ signal }) => {
+ const runner = createRunner(__dirname)
+ // A failing run still produces a (sampled) transaction; we only care about the error event here.
+ .ignore('transaction')
+ .expect(envelope => {
+ const errorEvent = envelope[1]?.[0]?.[1] as any;
+
+ expect(errorEvent).toEqual(
+ expect.objectContaining({
+ level: 'error',
+ exception: {
+ values: [
+ expect.objectContaining({
+ type: 'Error',
+ value: 'Model not found',
+ stacktrace: {
+ frames: expect.any(Array),
+ },
+ mechanism: { type: 'auto.http.cloudflare', handled: false },
+ }),
+ ],
+ },
+ request: expect.objectContaining({
+ method: 'GET',
+ url: expect.any(String),
+ }),
+ }),
+ );
+ })
+ .start(signal);
+ await runner.makeRequest('get', '/error', { expectError: true });
+ await runner.completed();
+});

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/wrangler.jsonc

@@ -0,0 +1,6 @@
+{
+"name": "workers-ai-worker",
+"compatibility_date": "2025-06-17",
+"main": "index.ts",
+"compatibility_flags": ["nodejs_als"],
+}

packages/cloudflare/src/instrumentations/worker/instrumentEnv.ts

@@ -1,6 +1,8 @@
 import { isObjectLike } from '@sentry/core';
+import { instrumentWorkersAiClient } from '@sentry/core';
 import type { CloudflareOptions } from '../../client';
 import {
+ isAiBinding,
  isD1Database,
  isDurableObjectNamespace,
  isJSRPC,
@@ -33,6 +35,7 @@ const instrumentedBindings = new WeakMap<object, unknown>();
  * - Queue producers (via `send` + `sendBatch` duck-typing)
  * - R2 Buckets (via `head` + `put` + `createMultipartUpload` duck-typing)
  * - Rate limiters (via `limit` duck-typing)
+ * - Workers AI (via `run` + `gateway` + `toMarkdown` duck-typing)
  *
  * @param env - The Cloudflare env object to instrument
  * @param options - Optional CloudflareOptions to control RPC trace propagation
@@ -85,6 +88,12 @@ export function instrumentEnv<Env extends Record<string, unknown>>(env: Env, opt
  return instrumented;
  }
 
+ if (isAiBinding(item)) {
+ const instrumented = instrumentWorkersAiClient(item);
+ instrumentedBindings.set(item, instrumented);
+ return instrumented;
+ }
+
  if (!rpcPropagation) {
  return item;
  }

packages/cloudflare/src/utils/isBinding.ts

@@ -31,7 +31,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-import type { D1Database, DurableObjectNamespace, Queue, R2Bucket, RateLimit } from '@cloudflare/workers-types';
+import type { Ai, D1Database, DurableObjectNamespace, Queue, R2Bucket, RateLimit } from '@cloudflare/workers-types';
 
 /**
  * Checks if a value is a JSRPC proxy (service binding).
@@ -82,6 +82,20 @@ export function isD1Database(item: unknown): item is D1Database {
  );
 }
 
+/**
+ * Duck-type check for Workers AI bindings.
+ * The Ai binding has `run`, `gateway`, and `toMarkdown` methods.
+ */
+export function isAiBinding(item: unknown): item is Ai {
+ return (
+ item != null &&
+ isNotJSRPC(item) &&
+ typeof item.run === 'function' &&
+ typeof item.gateway === 'function' &&
+ typeof item.toMarkdown === 'function'
+ );
+}
+
 /**
  * Duck-type check for R2 Bucket bindings.
  * R2Bucket has `head`, `put`, and `createMultipartUpload` methods.

packages/cloudflare/test/instrumentations/instrumentEnv.test.ts

@@ -284,6 +284,49 @@ describe('instrumentEnv', () => {
  expect(instrumented.MY_RATE_LIMITER).toBe(instrumented.MY_RATE_LIMITER);
  });
 
+ describe('Workers AI bindings', () => {
+ function createMockAiBinding() {
+ return {
+ run: vi.fn().mockResolvedValue({ response: 'Paris', usage: { prompt_tokens: 1, completion_tokens: 2 } }),
+ gateway: vi.fn(),
+ toMarkdown: vi.fn(),
+ models: vi.fn(),
+ autorag: vi.fn(),
+ };
+ }
+
+ it('detects and wraps AI bindings, forwarding run calls unchanged', async () => {
+ const ai = createMockAiBinding();
+ const env = { AI: ai };
+ const instrumented = instrumentEnv(env);
+
+ const wrapped = instrumented.AI as typeof ai;
+ expect(wrapped).not.toBe(ai);
+
+ const result = await wrapped.run('@cf/meta/llama-3.1-8b-instruct', { prompt: 'Hello' });
+
+ expect(ai.run).toHaveBeenCalledTimes(1);
+ expect(ai.run).toHaveBeenCalledWith('@cf/meta/llama-3.1-8b-instruct', { prompt: 'Hello' });
+ expect(result).toEqual({ response: 'Paris', usage: { prompt_tokens: 1, completion_tokens: 2 } });
+ });
+
+ it('caches the wrapped AI binding across repeated access', () => {
+ const ai = createMockAiBinding();
+ const env = { AI: ai };
+ const instrumented = instrumentEnv(env);
+
+ expect(instrumented.AI).toBe(instrumented.AI);
+ });
+
+ it('does not treat bindings with only a run method as AI bindings', () => {
+ const notAi = { run: vi.fn() };
+ const env = { RUNNER: notAi };
+ const instrumented = instrumentEnv(env);
+
+ expect(instrumented.RUNNER).toBe(notAi);
+ });
+ });
+
  describe('mTLS Fetcher bindings', () => {
  function createMtlsFetcherProxy(mockFetch: ReturnType<typeof vi.fn>) {
  return new Proxy(

.size-limit.js

@@ -460,7 +460,7 @@ module.exports = [
  ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
  gzip: false,
  brotli: false,
- limit: '183 KiB',
+ limit: '193 KiB',
  disablePlugins: ['@size-limit/webpack'],
  webpack: false,
  modifyEsbuildConfig: function (config) {
@@ -480,7 +480,7 @@ module.exports = [
  ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
  gzip: false,
  brotli: false,
- limit: '448 KiB',
+ limit: '475 KiB',
  disablePlugins: ['@size-limit/webpack'],
  webpack: false,
  modifyEsbuildConfig: function (config) {

dev-packages/cloudflare-integration-tests/package.json

@@ -23,6 +23,7 @@
  "@prisma/adapter-d1": "6.15.0",
  "@prisma/client": "6.15.0",
  "@sentry/cloudflare": "10.66.0",
+ "@sentry/core": "10.66.0",
  "@sentry/hono": "10.66.0",
  "hono": "^4.12.25",
  "openai": "5.18.1"

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/index.ts

@@ -0,0 +1,53 @@
+import*asSentryfrom'@sentry/cloudflare';
+import{instrumentWorkersAiClient}from'@sentry/core';
+import{MockAi}from'./mocks';
+
+interfaceEnv{
+SENTRY_DSN: string;
+}
+
+constai=instrumentWorkersAiClient(newMockAi());
+
+exportdefaultSentry.withSentry(
+(env: Env)=>({
+dsn: env.SENTRY_DSN,
+tracesSampleRate: 1.0,
+// Keep gen_ai spans embedded in the transaction (instead of streamed as a
+// separate envelope container) so they can be asserted on `transaction.spans`.
+streamGenAiSpans: false,
+}),
+{
+asyncfetch(request){
+consturl=newURL(request.url);
+
+if(url.pathname==='/error'){
+// The Workers AI integration deliberately does not call `captureException` itself.
+// A failing `run` must bubble up out of the handler so the top-level Cloudflare
+// instrumentation reports it instead — showing up in Sentry exactly once.
+constresult=awaitai.run('error-model',{prompt: 'Hello'});
+returnnewResponse(JSON.stringify(result));
+}
+
+if(url.pathname==='/stream'){
+conststream=(awaitai.run('@cf/meta/llama-3.1-8b-instruct',{
+messages: [{role: 'user',content: 'What is the capital of France?'}],
+stream: true,
+}))asReadableStream;
+
+consttext=awaitnewResponse(stream).text();
+returnnewResponse(text);
+}
+
+constresult=awaitai.run('@cf/meta/llama-3.1-8b-instruct',{
+messages: [
+{role: 'system',content: 'You are a helpful assistant.'},
+{role: 'user',content: 'What is the capital of France?'},
+],
+temperature: 0.7,
+max_tokens: 100,
+});
+
+returnnewResponse(JSON.stringify(result));
+},
+},
+);

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/mocks.ts

@@ -0,0 +1,45 @@
+import { simulateReadableStream } from 'ai';
+
+function createSseStream(events: string[]): ReadableStream<Uint8Array> {
+ const encoder = new TextEncoder();
+ return simulateReadableStream({
+ initialDelayInMs: 0,
+ chunkDelayInMs: 0,
+ chunks: events.map(event => encoder.encode(`data: ${event}\n\n`)),
+ });
+}
+
+/**
+ * Minimal mock of the Cloudflare Workers AI binding (`env.AI`).
+ */
+export class MockAi {
+ public async run(model: string, inputs: Record<string, unknown>): Promise<unknown> {
+ // Simulate processing time
+ await new Promise(resolve => setTimeout(resolve, 10));
+
+ if (model === 'error-model') {
+ const error = new Error('Model not found');
+ (error as unknown as { status: number }).status = 404;
+ throw error;
+ }
+
+ if (inputs?.stream === true) {
+ return createSseStream([
+ '{"response":"The capital "}',
+ '{"response":"of France "}',
+ '{"response":"is Paris."}',
+ '{"response":"","usage":{"prompt_tokens":12,"completion_tokens":7,"total_tokens":19}}',
+ '[DONE]',
+ ]);
+ }
+
+ return {
+ response: 'The capital of France is Paris.',
+ usage: {
+ prompt_tokens: 12,
+ completion_tokens: 7,
+ total_tokens: 19,
+ },
+ };
+ }
+}

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/test.ts

@@ -0,0 +1,148 @@
+import { GEN_AI_PROVIDER_NAME } from '@sentry/conventions/attributes';
+import { expect, it } from 'vitest';
+import {
+ GEN_AI_OPERATION_NAME_ATTRIBUTE,
+ GEN_AI_REQUEST_MAX_TOKENS_ATTRIBUTE,
+ GEN_AI_REQUEST_MODEL_ATTRIBUTE,
+ GEN_AI_REQUEST_STREAM_ATTRIBUTE,
+ GEN_AI_REQUEST_TEMPERATURE_ATTRIBUTE,
+ GEN_AI_RESPONSE_STREAMING_ATTRIBUTE,
+ GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE,
+ GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE,
+ GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE,
+} from '../../../../../packages/core/src/tracing/ai/gen-ai-attributes';
+import { createRunner } from '../../../runner';
+
+// These tests are not exhaustive because the instrumentation is
+// already tested in the core unit tests and we merely want to test
+// that the instrumentation does not break in our cloudflare SDK.
+
+it('traces a basic Workers AI text generation request', async ({ signal }) => {
+ const runner = createRunner(__dirname)
+ .ignore('event')
+ .expect(envelope => {
+ const transactionEvent = envelope[1]?.[0]?.[1] as any;
+
+ // The transaction event is framework-generated and carries non-deterministic fields
+ // (random ports, ids, timestamps, sdk version), so we assert the stable subset.
+ expect(transactionEvent).toEqual(
+ expect.objectContaining({
+ type: 'transaction',
+ transaction: 'GET /',
+ transaction_info: { source: 'route' },
+ contexts: expect.objectContaining({
+ trace: expect.objectContaining({
+ op: 'http.server',
+ origin: 'auto.http.cloudflare',
+ status: 'ok',
+ }),
+ }),
+ spans: [
+ expect.objectContaining({
+ description: 'chat @cf/meta/llama-3.1-8b-instruct',
+ op: 'gen_ai.chat',
+ origin: 'auto.ai.cloudflare.workers_ai',
+ data: {
+ 'sentry.origin': 'auto.ai.cloudflare.workers_ai',
+ 'sentry.op': 'gen_ai.chat',
+ [GEN_AI_PROVIDER_NAME]: 'cloudflare.workers_ai',
+ [GEN_AI_OPERATION_NAME_ATTRIBUTE]: 'chat',
+ [GEN_AI_REQUEST_MODEL_ATTRIBUTE]: '@cf/meta/llama-3.1-8b-instruct',
+ [GEN_AI_REQUEST_TEMPERATURE_ATTRIBUTE]: 0.7,
+ [GEN_AI_REQUEST_MAX_TOKENS_ATTRIBUTE]: 100,
+ [GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE]: 12,
+ [GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE]: 7,
+ [GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE]: 19,
+ },
+ }),
+ ],
+ }),
+ );
+ })
+ .start(signal);
+ await runner.makeRequest('get', '/');
+ await runner.completed();
+});
+
+it('traces a streaming Workers AI text generation request', async ({ signal }) => {
+ const runner = createRunner(__dirname)
+ .ignore('event')
+ .expect(envelope => {
+ const transactionEvent = envelope[1]?.[0]?.[1] as any;
+
+ expect(transactionEvent).toEqual(
+ expect.objectContaining({
+ type: 'transaction',
+ transaction: 'GET /stream',
+ transaction_info: { source: 'url' },
+ contexts: expect.objectContaining({
+ trace: expect.objectContaining({
+ op: 'http.server',
+ origin: 'auto.http.cloudflare',
+ status: 'ok',
+ }),
+ }),
+ spans: [
+ expect.objectContaining({
+ description: 'chat @cf/meta/llama-3.1-8b-instruct',
+ op: 'gen_ai.chat',
+ origin: 'auto.ai.cloudflare.workers_ai',
+ data: {
+ 'sentry.origin': 'auto.ai.cloudflare.workers_ai',
+ 'sentry.op': 'gen_ai.chat',
+ [GEN_AI_PROVIDER_NAME]: 'cloudflare.workers_ai',
+ [GEN_AI_OPERATION_NAME_ATTRIBUTE]: 'chat',
+ [GEN_AI_REQUEST_MODEL_ATTRIBUTE]: '@cf/meta/llama-3.1-8b-instruct',
+ [GEN_AI_REQUEST_STREAM_ATTRIBUTE]: true,
+ [GEN_AI_RESPONSE_STREAMING_ATTRIBUTE]: true,
+ [GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE]: 12,
+ [GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE]: 7,
+ [GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE]: 19,
+ },
+ }),
+ ],
+ }),
+ );
+ })
+ .start(signal);
+ await runner.makeRequest('get', '/stream');
+ await runner.completed();
+});
+
+// The Workers AI integration deliberately does not call `captureException` itself.
+// When a `run` call fails, the error must bubble up out of the fetch handler and be
+// reported by the top-level Cloudflare instrumentation instead — so it shows up in
+// Sentry exactly once, with the `auto.http.cloudflare` mechanism.
+it('bubbles up Workers AI errors to be captured by the top-level handler', async ({ signal }) => {
+ const runner = createRunner(__dirname)
+ // A failing run still produces a (sampled) transaction; we only care about the error event here.
+ .ignore('transaction')
+ .expect(envelope => {
+ const errorEvent = envelope[1]?.[0]?.[1] as any;
+
+ expect(errorEvent).toEqual(
+ expect.objectContaining({
+ level: 'error',
+ exception: {
+ values: [
+ expect.objectContaining({
+ type: 'Error',
+ value: 'Model not found',
+ stacktrace: {
+ frames: expect.any(Array),
+ },
+ mechanism: { type: 'auto.http.cloudflare', handled: false },
+ }),
+ ],
+ },
+ request: expect.objectContaining({
+ method: 'GET',
+ url: expect.any(String),
+ }),
+ }),
+ );
+ })
+ .start(signal);
+ await runner.makeRequest('get', '/error', { expectError: true });
+ await runner.completed();
+});

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/wrangler.jsonc

@@ -0,0 +1,6 @@
+{
+"name": "workers-ai-worker",
+"compatibility_date": "2025-06-17",
+"main": "index.ts",
+"compatibility_flags": ["nodejs_als"],
+}

packages/cloudflare/src/instrumentations/worker/instrumentEnv.ts

@@ -1,6 +1,8 @@
 import { isObjectLike } from '@sentry/core';
+import { instrumentWorkersAiClient } from '@sentry/core';
 import type { CloudflareOptions } from '../../client';
 import {
+ isAiBinding,
  isD1Database,
  isDurableObjectNamespace,
  isJSRPC,
@@ -33,6 +35,7 @@ const instrumentedBindings = new WeakMap<object, unknown>();
  * - Queue producers (via `send` + `sendBatch` duck-typing)
  * - R2 Buckets (via `head` + `put` + `createMultipartUpload` duck-typing)
  * - Rate limiters (via `limit` duck-typing)
+ * - Workers AI (via `run` + `gateway` + `toMarkdown` duck-typing)
  *
  * @param env - The Cloudflare env object to instrument
  * @param options - Optional CloudflareOptions to control RPC trace propagation
@@ -85,6 +88,12 @@ export function instrumentEnv<Env extends Record<string, unknown>>(env: Env, opt
  return instrumented;
  }
 
+ if (isAiBinding(item)) {
+ const instrumented = instrumentWorkersAiClient(item);
+ instrumentedBindings.set(item, instrumented);
+ return instrumented;
+ }
+
  if (!rpcPropagation) {
  return item;
  }

packages/cloudflare/src/utils/isBinding.ts

@@ -31,7 +31,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-import type { D1Database, DurableObjectNamespace, Queue, R2Bucket, RateLimit } from '@cloudflare/workers-types';
+import type { Ai, D1Database, DurableObjectNamespace, Queue, R2Bucket, RateLimit } from '@cloudflare/workers-types';
 
 /**
  * Checks if a value is a JSRPC proxy (service binding).
@@ -82,6 +82,20 @@ export function isD1Database(item: unknown): item is D1Database {
  );
 }
 
+/**
+ * Duck-type check for Workers AI bindings.
+ * The Ai binding has `run`, `gateway`, and `toMarkdown` methods.
+ */
+export function isAiBinding(item: unknown): item is Ai {
+ return (
+ item != null &&
+ isNotJSRPC(item) &&
+ typeof item.run === 'function' &&
+ typeof item.gateway === 'function' &&
+ typeof item.toMarkdown === 'function'
+ );
+}
+
 /**
  * Duck-type check for R2 Bucket bindings.
  * R2Bucket has `head`, `put`, and `createMultipartUpload` methods.

packages/cloudflare/test/instrumentations/instrumentEnv.test.ts

@@ -284,6 +284,49 @@ describe('instrumentEnv', () => {
  expect(instrumented.MY_RATE_LIMITER).toBe(instrumented.MY_RATE_LIMITER);
  });
 
+ describe('Workers AI bindings', () => {
+ function createMockAiBinding() {
+ return {
+ run: vi.fn().mockResolvedValue({ response: 'Paris', usage: { prompt_tokens: 1, completion_tokens: 2 } }),
+ gateway: vi.fn(),
+ toMarkdown: vi.fn(),
+ models: vi.fn(),
+ autorag: vi.fn(),
+ };
+ }
+
+ it('detects and wraps AI bindings, forwarding run calls unchanged', async () => {
+ const ai = createMockAiBinding();
+ const env = { AI: ai };
+ const instrumented = instrumentEnv(env);
+
+ const wrapped = instrumented.AI as typeof ai;
+ expect(wrapped).not.toBe(ai);
+
+ const result = await wrapped.run('@cf/meta/llama-3.1-8b-instruct', { prompt: 'Hello' });
+
+ expect(ai.run).toHaveBeenCalledTimes(1);
+ expect(ai.run).toHaveBeenCalledWith('@cf/meta/llama-3.1-8b-instruct', { prompt: 'Hello' });
+ expect(result).toEqual({ response: 'Paris', usage: { prompt_tokens: 1, completion_tokens: 2 } });
+ });
+
+ it('caches the wrapped AI binding across repeated access', () => {
+ const ai = createMockAiBinding();
+ const env = { AI: ai };
+ const instrumented = instrumentEnv(env);
+
+ expect(instrumented.AI).toBe(instrumented.AI);
+ });
+
+ it('does not treat bindings with only a run method as AI bindings', () => {
+ const notAi = { run: vi.fn() };
+ const env = { RUNNER: notAi };
+ const instrumented = instrumentEnv(env);
+
+ expect(instrumented.RUNNER).toBe(notAi);
+ });
+ });
+
  describe('mTLS Fetcher bindings', () => {
  function createMtlsFetcherProxy(mockFetch: ReturnType<typeof vi.fn>) {
  return new Proxy(

.size-limit.js

@@ -460,7 +460,7 @@ module.exports = [
  ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
  gzip: false,
  brotli: false,
- limit: '183 KiB',
+ limit: '193 KiB',
  disablePlugins: ['@size-limit/webpack'],
  webpack: false,
  modifyEsbuildConfig: function (config) {
@@ -480,7 +480,7 @@ module.exports = [
  ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
  gzip: false,
  brotli: false,
- limit: '448 KiB',
+ limit: '475 KiB',
  disablePlugins: ['@size-limit/webpack'],
  webpack: false,
  modifyEsbuildConfig: function (config) {

dev-packages/cloudflare-integration-tests/package.json

@@ -23,6 +23,7 @@
  "@prisma/adapter-d1": "6.15.0",
  "@prisma/client": "6.15.0",
  "@sentry/cloudflare": "10.66.0",
+ "@sentry/core": "10.66.0",
  "@sentry/hono": "10.66.0",
  "hono": "^4.12.25",
  "openai": "5.18.1"

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/index.ts

@@ -0,0 +1,53 @@
+import*asSentryfrom'@sentry/cloudflare';
+import{instrumentWorkersAiClient}from'@sentry/core';
+import{MockAi}from'./mocks';
+
+interfaceEnv{
+SENTRY_DSN: string;
+}
+
+constai=instrumentWorkersAiClient(newMockAi());
+
+exportdefaultSentry.withSentry(
+(env: Env)=>({
+dsn: env.SENTRY_DSN,
+tracesSampleRate: 1.0,
+// Keep gen_ai spans embedded in the transaction (instead of streamed as a
+// separate envelope container) so they can be asserted on `transaction.spans`.
+streamGenAiSpans: false,
+}),
+{
+asyncfetch(request){
+consturl=newURL(request.url);
+
+if(url.pathname==='/error'){
+// The Workers AI integration deliberately does not call `captureException` itself.
+// A failing `run` must bubble up out of the handler so the top-level Cloudflare
+// instrumentation reports it instead — showing up in Sentry exactly once.
+constresult=awaitai.run('error-model',{prompt: 'Hello'});
+returnnewResponse(JSON.stringify(result));
+}
+
+if(url.pathname==='/stream'){
+conststream=(awaitai.run('@cf/meta/llama-3.1-8b-instruct',{
+messages: [{role: 'user',content: 'What is the capital of France?'}],
+stream: true,
+}))asReadableStream;
+
+consttext=awaitnewResponse(stream).text();
+returnnewResponse(text);
+}
+
+constresult=awaitai.run('@cf/meta/llama-3.1-8b-instruct',{
+messages: [
+{role: 'system',content: 'You are a helpful assistant.'},
+{role: 'user',content: 'What is the capital of France?'},
+],
+temperature: 0.7,
+max_tokens: 100,
+});
+
+returnnewResponse(JSON.stringify(result));
+},
+},
+);

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/mocks.ts

@@ -0,0 +1,45 @@
+import { simulateReadableStream } from 'ai';
+
+function createSseStream(events: string[]): ReadableStream<Uint8Array> {
+ const encoder = new TextEncoder();
+ return simulateReadableStream({
+ initialDelayInMs: 0,
+ chunkDelayInMs: 0,
+ chunks: events.map(event => encoder.encode(`data: ${event}\n\n`)),
+ });
+}
+
+/**
+ * Minimal mock of the Cloudflare Workers AI binding (`env.AI`).
+ */
+export class MockAi {
+ public async run(model: string, inputs: Record<string, unknown>): Promise<unknown> {
+ // Simulate processing time
+ await new Promise(resolve => setTimeout(resolve, 10));
+
+ if (model === 'error-model') {
+ const error = new Error('Model not found');
+ (error as unknown as { status: number }).status = 404;
+ throw error;
+ }
+
+ if (inputs?.stream === true) {
+ return createSseStream([
+ '{"response":"The capital "}',
+ '{"response":"of France "}',
+ '{"response":"is Paris."}',
+ '{"response":"","usage":{"prompt_tokens":12,"completion_tokens":7,"total_tokens":19}}',
+ '[DONE]',
+ ]);
+ }
+
+ return {
+ response: 'The capital of France is Paris.',
+ usage: {
+ prompt_tokens: 12,
+ completion_tokens: 7,
+ total_tokens: 19,
+ },
+ };
+ }
+}

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/test.ts

@@ -0,0 +1,148 @@
+import { GEN_AI_PROVIDER_NAME } from '@sentry/conventions/attributes';
+import { expect, it } from 'vitest';
+import {
+ GEN_AI_OPERATION_NAME_ATTRIBUTE,
+ GEN_AI_REQUEST_MAX_TOKENS_ATTRIBUTE,
+ GEN_AI_REQUEST_MODEL_ATTRIBUTE,
+ GEN_AI_REQUEST_STREAM_ATTRIBUTE,
+ GEN_AI_REQUEST_TEMPERATURE_ATTRIBUTE,
+ GEN_AI_RESPONSE_STREAMING_ATTRIBUTE,
+ GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE,
+ GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE,
+ GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE,
+} from '../../../../../packages/core/src/tracing/ai/gen-ai-attributes';
+import { createRunner } from '../../../runner';
+
+// These tests are not exhaustive because the instrumentation is
+// already tested in the core unit tests and we merely want to test
+// that the instrumentation does not break in our cloudflare SDK.
+
+it('traces a basic Workers AI text generation request', async ({ signal }) => {
+ const runner = createRunner(__dirname)
+ .ignore('event')
+ .expect(envelope => {
+ const transactionEvent = envelope[1]?.[0]?.[1] as any;
+
+ // The transaction event is framework-generated and carries non-deterministic fields
+ // (random ports, ids, timestamps, sdk version), so we assert the stable subset.
+ expect(transactionEvent).toEqual(
+ expect.objectContaining({
+ type: 'transaction',
+ transaction: 'GET /',
+ transaction_info: { source: 'route' },
+ contexts: expect.objectContaining({
+ trace: expect.objectContaining({
+ op: 'http.server',
+ origin: 'auto.http.cloudflare',
+ status: 'ok',
+ }),
+ }),
+ spans: [
+ expect.objectContaining({
+ description: 'chat @cf/meta/llama-3.1-8b-instruct',
+ op: 'gen_ai.chat',
+ origin: 'auto.ai.cloudflare.workers_ai',
+ data: {
+ 'sentry.origin': 'auto.ai.cloudflare.workers_ai',
+ 'sentry.op': 'gen_ai.chat',
+ [GEN_AI_PROVIDER_NAME]: 'cloudflare.workers_ai',
+ [GEN_AI_OPERATION_NAME_ATTRIBUTE]: 'chat',
+ [GEN_AI_REQUEST_MODEL_ATTRIBUTE]: '@cf/meta/llama-3.1-8b-instruct',
+ [GEN_AI_REQUEST_TEMPERATURE_ATTRIBUTE]: 0.7,
+ [GEN_AI_REQUEST_MAX_TOKENS_ATTRIBUTE]: 100,
+ [GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE]: 12,
+ [GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE]: 7,
+ [GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE]: 19,
+ },
+ }),
+ ],
+ }),
+ );
+ })
+ .start(signal);
+ await runner.makeRequest('get', '/');
+ await runner.completed();
+});
+
+it('traces a streaming Workers AI text generation request', async ({ signal }) => {
+ const runner = createRunner(__dirname)
+ .ignore('event')
+ .expect(envelope => {
+ const transactionEvent = envelope[1]?.[0]?.[1] as any;
+
+ expect(transactionEvent).toEqual(
+ expect.objectContaining({
+ type: 'transaction',
+ transaction: 'GET /stream',
+ transaction_info: { source: 'url' },
+ contexts: expect.objectContaining({
+ trace: expect.objectContaining({
+ op: 'http.server',
+ origin: 'auto.http.cloudflare',
+ status: 'ok',
+ }),
+ }),
+ spans: [
+ expect.objectContaining({
+ description: 'chat @cf/meta/llama-3.1-8b-instruct',
+ op: 'gen_ai.chat',
+ origin: 'auto.ai.cloudflare.workers_ai',
+ data: {
+ 'sentry.origin': 'auto.ai.cloudflare.workers_ai',
+ 'sentry.op': 'gen_ai.chat',
+ [GEN_AI_PROVIDER_NAME]: 'cloudflare.workers_ai',
+ [GEN_AI_OPERATION_NAME_ATTRIBUTE]: 'chat',
+ [GEN_AI_REQUEST_MODEL_ATTRIBUTE]: '@cf/meta/llama-3.1-8b-instruct',
+ [GEN_AI_REQUEST_STREAM_ATTRIBUTE]: true,
+ [GEN_AI_RESPONSE_STREAMING_ATTRIBUTE]: true,
+ [GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE]: 12,
+ [GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE]: 7,
+ [GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE]: 19,
+ },
+ }),
+ ],
+ }),
+ );
+ })
+ .start(signal);
+ await runner.makeRequest('get', '/stream');
+ await runner.completed();
+});
+
+// The Workers AI integration deliberately does not call `captureException` itself.
+// When a `run` call fails, the error must bubble up out of the fetch handler and be
+// reported by the top-level Cloudflare instrumentation instead — so it shows up in
+// Sentry exactly once, with the `auto.http.cloudflare` mechanism.
+it('bubbles up Workers AI errors to be captured by the top-level handler', async ({ signal }) => {
+ const runner = createRunner(__dirname)
+ // A failing run still produces a (sampled) transaction; we only care about the error event here.
+ .ignore('transaction')
+ .expect(envelope => {
+ const errorEvent = envelope[1]?.[0]?.[1] as any;
+
+ expect(errorEvent).toEqual(
+ expect.objectContaining({
+ level: 'error',
+ exception: {
+ values: [
+ expect.objectContaining({
+ type: 'Error',
+ value: 'Model not found',
+ stacktrace: {
+ frames: expect.any(Array),
+ },
+ mechanism: { type: 'auto.http.cloudflare', handled: false },
+ }),
+ ],
+ },
+ request: expect.objectContaining({
+ method: 'GET',
+ url: expect.any(String),
+ }),
+ }),
+ );
+ })
+ .start(signal);
+ await runner.makeRequest('get', '/error', { expectError: true });
+ await runner.completed();
+});

dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/wrangler.jsonc

@@ -0,0 +1,6 @@
+{
+"name": "workers-ai-worker",
+"compatibility_date": "2025-06-17",
+"main": "index.ts",
+"compatibility_flags": ["nodejs_als"],
+}

packages/cloudflare/src/instrumentations/worker/instrumentEnv.ts

@@ -1,6 +1,8 @@
 import { isObjectLike } from '@sentry/core';
+import { instrumentWorkersAiClient } from '@sentry/core';
 import type { CloudflareOptions } from '../../client';
 import {
+ isAiBinding,
  isD1Database,
  isDurableObjectNamespace,
  isJSRPC,
@@ -33,6 +35,7 @@ const instrumentedBindings = new WeakMap<object, unknown>();
  * - Queue producers (via `send` + `sendBatch` duck-typing)
  * - R2 Buckets (via `head` + `put` + `createMultipartUpload` duck-typing)
  * - Rate limiters (via `limit` duck-typing)
+ * - Workers AI (via `run` + `gateway` + `toMarkdown` duck-typing)
  *
  * @param env - The Cloudflare env object to instrument
  * @param options - Optional CloudflareOptions to control RPC trace propagation
@@ -85,6 +88,12 @@ export function instrumentEnv<Env extends Record<string, unknown>>(env: Env, opt
  return instrumented;
  }
 
+ if (isAiBinding(item)) {
+ const instrumented = instrumentWorkersAiClient(item);
+ instrumentedBindings.set(item, instrumented);
+ return instrumented;
+ }
+
  if (!rpcPropagation) {
  return item;
  }

packages/cloudflare/src/utils/isBinding.ts

@@ -31,7 +31,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-import type { D1Database, DurableObjectNamespace, Queue, R2Bucket, RateLimit } from '@cloudflare/workers-types';
+import type { Ai, D1Database, DurableObjectNamespace, Queue, R2Bucket, RateLimit } from '@cloudflare/workers-types';
 
 /**
  * Checks if a value is a JSRPC proxy (service binding).
@@ -82,6 +82,20 @@ export function isD1Database(item: unknown): item is D1Database {
  );
 }
 
+/**
+ * Duck-type check for Workers AI bindings.
+ * The Ai binding has `run`, `gateway`, and `toMarkdown` methods.
+ */
+export function isAiBinding(item: unknown): item is Ai {
+ return (
+ item != null &&
+ isNotJSRPC(item) &&
+ typeof item.run === 'function' &&
+ typeof item.gateway === 'function' &&
+ typeof item.toMarkdown === 'function'
+ );
+}
+
 /**
  * Duck-type check for R2 Bucket bindings.
  * R2Bucket has `head`, `put`, and `createMultipartUpload` methods.

packages/cloudflare/test/instrumentations/instrumentEnv.test.ts

@@ -284,6 +284,49 @@ describe('instrumentEnv', () => {
  expect(instrumented.MY_RATE_LIMITER).toBe(instrumented.MY_RATE_LIMITER);
  });
 
+ describe('Workers AI bindings', () => {
+ function createMockAiBinding() {
+ return {
+ run: vi.fn().mockResolvedValue({ response: 'Paris', usage: { prompt_tokens: 1, completion_tokens: 2 } }),
+ gateway: vi.fn(),
+ toMarkdown: vi.fn(),
+ models: vi.fn(),
+ autorag: vi.fn(),
+ };
+ }
+
+ it('detects and wraps AI bindings, forwarding run calls unchanged', async () => {
+ const ai = createMockAiBinding();
+ const env = { AI: ai };
+ const instrumented = instrumentEnv(env);
+
+ const wrapped = instrumented.AI as typeof ai;
+ expect(wrapped).not.toBe(ai);
+
+ const result = await wrapped.run('@cf/meta/llama-3.1-8b-instruct', { prompt: 'Hello' });
+
+ expect(ai.run).toHaveBeenCalledTimes(1);
+ expect(ai.run).toHaveBeenCalledWith('@cf/meta/llama-3.1-8b-instruct', { prompt: 'Hello' });
+ expect(result).toEqual({ response: 'Paris', usage: { prompt_tokens: 1, completion_tokens: 2 } });
+ });
+
+ it('caches the wrapped AI binding across repeated access', () => {
+ const ai = createMockAiBinding();
+ const env = { AI: ai };
+ const instrumented = instrumentEnv(env);
+
+ expect(instrumented.AI).toBe(instrumented.AI);
+ });
+
+ it('does not treat bindings with only a run method as AI bindings', () => {
+ const notAi = { run: vi.fn() };
+ const env = { RUNNER: notAi };
+ const instrumented = instrumentEnv(env);
+
+ expect(instrumented.RUNNER).toBe(notAi);
+ });
+ });
+
  describe('mTLS Fetcher bindings', () => {
  function createMtlsFetcherProxy(mockFetch: ReturnType<typeof vi.fn>) {
  return new Proxy(