@sentry/cloudflare 10.70.0 → 11.0.0-alpha.1

package/build/types-ts3.8/instrumentations/agents/types.d.ts

@@ -1,94 +0,0 @@
-import { InstrumentedDurableObjectState } from '../../wrapMethodWithSentry';
-export declare const AGENT_SPAN_ORIGIN = "auto.faas.cloudflare.agents";
-/** DO storage key under which the conversation id is persisted so it survives hibernation. */
-export declare const AGENT_CONVERSATION_ID_STORAGE_KEY = "__SENTRY_AGENT_CONVERSATION_ID__";
-/**
- * Instance keys for our conversation-id bookkeeping, keyed by symbol so the state stays invisible
- * to anything enumerating the user-owned agent instance (`Object.keys`, `JSON.stringify`, spread).
- * Exported because the exported `AgentInternals` interface references them.
- */
-export declare const AGENT_CONVERSATION_ID_SYMBOL: unique symbol;
-export declare const AGENT_APPLIED_CONVERSATION_ID_SYMBOL: unique symbol;
-/**
- * The subset of the `agents` `Agent` instance internals that we instrument. These are runtime
- * implementation details of the `agents` package (v0.13.x) rather than part of its public type
- * surface, so every access is guarded and wrapping degrades gracefully if a name changes upstream.
- */
-export interface AgentInternals {
-    /** Central choke-point through which all `agents:*` observability events are published. */
-    _emit?: (type: string, payload?: Record<string, unknown>) => void;
-    /** WebSocket message handler; dispatches `@callable()` RPC requests. */
-    onMessage?: (...args: unknown[]) => unknown;
-    /**
-     * Chat-turn handler. Only `AIChatAgent` (from `@cloudflare/ai-chat`) defines this; a plain `Agent`
-     * does not, so its presence discriminates a chat agent.
-     */
-    onChatMessage?: (...args: unknown[]) => unknown;
-    /** HTTP request handler; the router sends every non-WebSocket request here. */
-    onRequest?: (...args: unknown[]) => unknown;
-    /** The user's Agent class (used by the SDK for the observability event `agent` field). */
-    _ParentClass?: {
-        name?: string;
-    };
-    /** The Agent instance name, reported as the `cloudflare.agent.name` span attribute. */
-    name?: string;
-    /**
-     * The Durable Object state of the instance. Present on every real Agent; guarded like the other
-     * internals so partially-mocked instances keep working.
-     */
-    ctx?: InstrumentedDurableObjectState;
-    /**
-     * The current conversation id for this agent instance. It is cached in memory after being loaded
-     * from Durable Object storage and updated when the conversation rotates. `undefined` means storage
-     * has not been read yet.
-     */
-    [AGENT_CONVERSATION_ID_SYMBOL]?: string;
-    /**
-     * The conversation id this instrumentation most recently applied to the isolation scope. It lets
-     * subsequent units of work distinguish an SDK-applied id, which may be replaced after rotation,
-     * from an id explicitly set by the user, which must be preserved.
-     */
-    [AGENT_APPLIED_CONVERSATION_ID_SYMBOL]?: string;
-}
-/** Reads best-effort agent identity attributes from the instance, tolerating missing internals. */
-export declare function getAgentAttributes(instance: AgentInternals): Record<string, string>;
-/**
- * Persists the conversation id to Durable Object storage, so it survives hibernation, and updates
- * the in-memory cache synchronously so the current wake is immediately consistent even if the
- * write fails. Uses the async storage API, which exists on KV- and SQLite-backed DOs alike.
- * The write is fire-and-forget: DO storage writes are tracked by the runtime and land without
- * awaiting (`waitUntil` is a no-op in Durable Objects), and the catch keeps a rejection from
- * surfacing as unhandled — a failed write just means the next wake starts a new conversation,
- * which must never throw into user code. Uses the original uninstrumented storage so internal
- * bookkeeping doesn't create spans.
- */
-export declare function storeAgentConversationId(instance: AgentInternals, conversationId: string): void;
-/**
- * Sets the agent instance's conversation id on the active scope for the duration of the
- * surrounding unit of work (chat turn, callable RPC call, HTTP request). In the Agents model one
- * instance is one long-lived conversation, so the id is minted once per instance and persisted to
- * DO storage — for chat and plain agents alike, since plain agents run LLM calls too (e.g. inside
- * `@callable()` methods). The instance `name` is deliberately not used: it is caller-chosen and can
- * be a stable, guessable, or shared value, whereas a conversation id should identify exactly one
- * conversation. Clearing the chat rotates it (see `storeAgentConversationId`) so subsequent LLM
- * calls group under the fresh conversation.
- *
- * Every handler wrapper awaits this before invoking the original, so the id is on the scope before
- * the unit of work — and any `gen_ai` span it creates — starts. Only the first unit of work per wake
- * pays the storage read; the rest resolve from the in-memory cache. Awaiting is safe on all three
- * paths because the `agents` `Agent` constructor already replaces `onMessage` and `onRequest` with
- * `async` wrappers of its own, and `onChatMessage` is async by contract, so every caller upstream
- * already handles a promise.
- *
- * An id the user set explicitly outranks this inferred one, in either order: a `setConversationId()`
- * call that already happened is detected here and left alone, and one made inside the handler lands
- * on the same scope afterwards and therefore wins. That is why the write targets the isolation scope
- * — it is the scope the public `Sentry.setConversationId()` writes to, and `conversationIdIntegration`
- * prefers the current scope over it, so writing there would make a user's call unoverridable.
- *
- * `conversationIdIntegration` reads the id off the scope at `spanStart` and stamps
- * `gen_ai.conversation.id` onto AI spans created within the unit of work, correlating its model and
- * tool calls.
- */
-export declare function setAgentConversationId(instance: AgentInternals): Promise<void>;
-//# sourceMappingURL=types.d.ts.map

package/build/types-ts3.8/instrumentations/instrumentDurableObjectNamespace.d.ts

@@ -1,13 +0,0 @@
-import { DurableObjectNamespace } from '@cloudflare/workers-types';
-export declare const STUB_NON_RPC_METHODS: Set<string>;
-/**
- * Instruments a DurableObjectNamespace binding to create spans for DO interactions.
- *
- * Wraps:
- * - `namespace.get(id)` / `namespace.getByName(name)` with a span + instruments returned stub
- * - `namespace.idFromName(name)` / `namespace.idFromString(id)` / `namespace.newUniqueId()` with breadcrumbs
- *
- * @param namespace - The DurableObjectNamespace to instrument
- */
-export declare function instrumentDurableObjectNamespace(namespace: DurableObjectNamespace): DurableObjectNamespace;
-//# sourceMappingURL=instrumentDurableObjectNamespace.d.ts.map

package/build/types-ts3.8/instrumentations/instrumentDurableObjectStorage.d.ts

@@ -1,19 +0,0 @@
-import { DurableObjectStorage } from '@cloudflare/workers-types';
-type WaitUntil = (promise: Promise<unknown>) => void;
-/**
- * Instruments DurableObjectStorage methods with Sentry spans.
- *
- * Wraps the following async methods:
- * - get, put, delete, list (KV API)
- * - setAlarm, getAlarm, deleteAlarm (Alarm API)
- *
- * When setAlarm is called, it also stores the current span context so that when
- * the alarm fires later, it can link back to the trace that called setAlarm.
- *
- * @param storage - The DurableObjectStorage instance to instrument
- * @param waitUntil - Optional waitUntil function to defer span context storage
- * @returns An instrumented DurableObjectStorage instance
- */
-export declare function instrumentDurableObjectStorage(storage: DurableObjectStorage, waitUntil?: WaitUntil): DurableObjectStorage;
-export {};
-//# sourceMappingURL=instrumentDurableObjectStorage.d.ts.map

package/build/types-ts3.8/instrumentations/instrumentDurableObjectSyncKvStorage.d.ts

@@ -1,3 +0,0 @@
-import { SyncKvStorage } from '@cloudflare/workers-types';
-export declare function instrumentDurableObjectSyncKvStorage(syncKv: SyncKvStorage): SyncKvStorage;
-//# sourceMappingURL=instrumentDurableObjectSyncKvStorage.d.ts.map

package/build/types-ts3.8/instrumentations/instrumentSqlStorage.d.ts

@@ -1,9 +0,0 @@
-import { SqlStorage } from '@cloudflare/workers-types';
-/**
- * Instruments the Durable Object SqlStorage `exec` method with Sentry spans.
- *
- * @param sql - The SqlStorage instance to instrument
- * @returns An instrumented SqlStorage instance
- */
-export declare function instrumentSqlStorage(sql: SqlStorage): SqlStorage;
-//# sourceMappingURL=instrumentSqlStorage.d.ts.map

package/build/types-ts3.8/instrumentations/instrumentWorkerEntrypoint.d.ts

@@ -1,42 +0,0 @@
-import { WorkerEntrypoint } from 'cloudflare:workers';
-import { CloudflareOptions } from '../client';
-export type WorkerEntrypointConstructor<Env = unknown, Props = {}> = new (ctx: ExecutionContext, env: any) => InstanceType<typeof WorkerEntrypoint<Env, Props>>;
-/**
- * Instruments a WorkerEntrypoint class to capture errors and performance data.
- *
- * Instruments the following methods (same as `withSentry` for ExportedHandler):
- * - fetch (HTTP requests)
- * - scheduled (cron triggers)
- * - queue (queue consumers)
- * - email (email handlers)
- * - tail (tail workers)
- *
- * as well as any other public RPC methods on the WorkerEntrypoint instance.
- *
- * @param optionsCallback Function that returns the options for the SDK initialization.
- * @param WorkerEntrypointClass The WorkerEntrypoint class to instrument.
- * @returns The instrumented WorkerEntrypoint class.
- *
- * @example
- * ```ts
- * class MyWorkerBase extends WorkerEntrypoint<Env> {
- *   async fetch(request: Request): Promise<Response> {
- *     return new Response('Hello World!');
- *   }
- *
- *   async myRpcMethod(arg: string): Promise<string> {
- *     return `Hello ${arg}!`;
- *   }
- * }
- *
- * export default instrumentWorkerEntrypoint(
- *   env => ({
- *     dsn: env.SENTRY_DSN,
- *     tracesSampleRate: 1.0,
- *   }),
- *   MyWorkerBase,
- * );
- * ```
- */
-export declare function instrumentWorkerEntrypoint<Env, Props, T extends InstanceType<typeof WorkerEntrypoint<Env, Props>>, C extends new (ctx: ExecutionContext, env: Env) => T>(optionsCallback: (env: Env) => CloudflareOptions | undefined, WorkerEntrypointClass: C): C;
-//# sourceMappingURL=instrumentWorkerEntrypoint.d.ts.map

package/build/types-ts3.8/instrumentations/worker/instrumentD1.d.ts

@@ -1,19 +0,0 @@
-import { D1Database } from '@cloudflare/workers-types';
-export declare function instrumentD1(db: D1Database): D1Database;
-/**
- * Instruments Cloudflare D1 bindings with Sentry.
- *
- * @deprecated `withSentry()` automatically instruments all D1 bindings via `env`
- * so this function is not needed anymore. It will be removed in the next major version of the SDK.
- *
- * @example
- *
- * ```js
- * // env.DB is the D1 DB binding configured in your `wrangler.toml`
- * const db = instrumentD1WithSentry(env.DB);
- * // Now you can use the database as usual
- * await db.prepare('SELECT * FROM table WHERE id = ?').bind(1).run();
- * ```
- */
-export declare function instrumentD1WithSentry(db: D1Database): D1Database;
-//# sourceMappingURL=instrumentD1.d.ts.map

package/build/types-ts3.8/instrumentations/worker/instrumentEmail.d.ts

@@ -1,8 +0,0 @@
-import { ExportedHandler } from '@cloudflare/workers-types';
-import { env as cloudflareEnv } from 'cloudflare:workers';
-import { CloudflareOptions } from '../../client';
-/**
- * Instruments an email handler for ExportedHandler (env/ctx come from args).
- */
-export declare function instrumentExportedHandlerEmail<T extends ExportedHandler<any, any, any>>(handler: T, optionsCallback: (env: typeof cloudflareEnv) => CloudflareOptions | undefined): void;
-//# sourceMappingURL=instrumentEmail.d.ts.map

package/build/types-ts3.8/instrumentations/worker/instrumentEnv.d.ts

@@ -1,18 +0,0 @@
-import { CloudflareOptions } from '../../client';
-/**
- * Wraps the Cloudflare `env` object in a Proxy that detects binding types
- * on property access and returns instrumented versions.
- *
- * Currently detects:
- * - DurableObjectNamespace (via `idFromName` duck-typing)
- * - Service bindings / JSRPC proxies
- * - 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
- */
-export declare function instrumentEnv<Env extends Record<string, unknown>>(env: Env, options?: CloudflareOptions): Env;
-//# sourceMappingURL=instrumentEnv.d.ts.map

package/build/types-ts3.8/instrumentations/worker/instrumentFetch.d.ts

@@ -1,12 +0,0 @@
-import { ExportedHandler } from '@cloudflare/workers-types';
-import { env as cloudflareEnv, WorkerEntrypoint } from 'cloudflare:workers';
-import { CloudflareOptions } from '../../client';
-/**
- * Instruments a fetch handler for ExportedHandler (env/ctx come from args).
- */
-export declare function instrumentExportedHandlerFetch<T extends ExportedHandler<any, any, any>>(handler: T, optionsCallback: (env: typeof cloudflareEnv) => CloudflareOptions | undefined): void;
-/**
- * Instruments a fetch method for WorkerEntrypoint (options/context already available).
- */
-export declare function instrumentWorkerEntrypointFetch<T extends WorkerEntrypoint>(instance: T, options: CloudflareOptions, context: ExecutionContext): void;
-//# sourceMappingURL=instrumentFetch.d.ts.map

package/build/types-ts3.8/instrumentations/worker/instrumentFetcher.d.ts

@@ -1,10 +0,0 @@
-import { Fetcher } from '@cloudflare/workers-types';
-/**
- * Wraps a fetch-like function to create a span and propagate trace headers
- * (`sentry-trace` and `baggage`) on the outgoing request.
- *
- * Useful for instrumenting Cloudflare bindings that expose a `fetch` method
- * (e.g. Durable Object stubs, Service bindings).
- */
-export declare function instrumentFetcher(fetchFn: Fetcher['fetch']): Fetcher['fetch'];
-//# sourceMappingURL=instrumentFetcher.d.ts.map

package/build/types-ts3.8/instrumentations/worker/instrumentQueue.d.ts

@@ -1,12 +0,0 @@
-import { ExportedHandler } from '@cloudflare/workers-types';
-import { env as cloudflareEnv, WorkerEntrypoint } from 'cloudflare:workers';
-import { CloudflareOptions } from '../../client';
-/**
- * Instruments a queue handler for ExportedHandler (env/ctx come from args).
- */
-export declare function instrumentExportedHandlerQueue<T extends ExportedHandler<any, any, any>>(handler: T, optionsCallback: (env: typeof cloudflareEnv) => CloudflareOptions | undefined): void;
-/**
- * Instruments a queue method for WorkerEntrypoint (options/context already available).
- */
-export declare function instrumentWorkerEntrypointQueue<T extends WorkerEntrypoint>(instance: T, options: CloudflareOptions, context: ExecutionContext): void;
-//# sourceMappingURL=instrumentQueue.d.ts.map

package/build/types-ts3.8/instrumentations/worker/instrumentQueueProducer.d.ts

@@ -1,10 +0,0 @@
-import { Queue } from '@cloudflare/workers-types';
-/**
- * Wraps a Queue producer binding to create `queue.publish` spans on
- * `send` and `sendBatch` calls.
- *
- * The queue's own name is not available on the binding object, so we use
- * the env binding key (e.g. `MY_QUEUE`) as `messaging.destination.name`.
- */
-export declare function instrumentQueueProducer<T extends Queue>(queue: T, bindingName: string): T;
-//# sourceMappingURL=instrumentQueueProducer.d.ts.map

package/build/types-ts3.8/instrumentations/worker/instrumentR2.d.ts

@@ -1,9 +0,0 @@
-import { R2Bucket } from '@cloudflare/workers-types';
-/**
- * Wraps a Cloudflare R2 Bucket binding to create spans on bucket operations.
- *
- * Instrumented methods: get, head, put, delete, list, createMultipartUpload,
- * resumeMultipartUpload (and the resulting multipart upload operations).
- */
-export declare function instrumentR2Bucket<T extends R2Bucket>(bucket: T, bindingName: string): T;
-//# sourceMappingURL=instrumentR2.d.ts.map

package/build/types-ts3.8/instrumentations/worker/instrumentRateLimit.d.ts

@@ -1,6 +0,0 @@
-import { RateLimit } from '@cloudflare/workers-types';
-/**
- * Wraps a Cloudflare rate limiter binding to create a span on each `limit()` call.
- */
-export declare function instrumentRateLimit<T extends RateLimit>(rateLimit: T, bindingName: string): T;
-//# sourceMappingURL=instrumentRateLimit.d.ts.map

package/build/types-ts3.8/instrumentations/worker/instrumentScheduled.d.ts

@@ -1,12 +0,0 @@
-import { ExportedHandler } from '@cloudflare/workers-types';
-import { env as cloudflareEnv, WorkerEntrypoint } from 'cloudflare:workers';
-import { CloudflareOptions } from '../../client';
-/**
- * Instruments a scheduled handler for ExportedHandler (env/ctx come from args).
- */
-export declare function instrumentExportedHandlerScheduled<T extends ExportedHandler<any, any, any>>(handler: T, optionsCallback: (env: typeof cloudflareEnv) => CloudflareOptions | undefined): void;
-/**
- * Instruments a scheduled method for WorkerEntrypoint (options/context already available).
- */
-export declare function instrumentWorkerEntrypointScheduled<T extends WorkerEntrypoint>(instance: T, options: CloudflareOptions, context: ExecutionContext): void;
-//# sourceMappingURL=instrumentScheduled.d.ts.map

package/build/types-ts3.8/instrumentations/worker/instrumentTail.d.ts

@@ -1,12 +0,0 @@
-import { ExportedHandler } from '@cloudflare/workers-types';
-import { env as cloudflareEnv, WorkerEntrypoint } from 'cloudflare:workers';
-import { CloudflareOptions } from '../../client';
-/**
- * Instruments a tail handler for ExportedHandler (env/ctx come from args).
- */
-export declare function instrumentExportedHandlerTail<T extends ExportedHandler<any, any, any>>(handler: T, optionsCallback: (env: typeof cloudflareEnv) => CloudflareOptions | undefined): void;
-/**
- * Instruments a tail method for WorkerEntrypoint (options/context already available).
- */
-export declare function instrumentWorkerEntrypointTail<T extends WorkerEntrypoint>(instance: T, options: CloudflareOptions, context: ExecutionContext): void;
-//# sourceMappingURL=instrumentTail.d.ts.map

package/build/types-ts3.8/integrations/fetch.d.ts

@@ -1,19 +0,0 @@
-export interface Options {
-    /**
-     * Whether breadcrumbs should be recorded for requests
-     * Defaults to true
-     */
-    breadcrumbs: boolean;
-    /**
-     * Function determining whether or not to create spans to track outgoing requests to the given URL.
-     * By default, spans will be created for all outgoing requests.
-     */
-    shouldCreateSpanForRequest?: (url: string) => boolean;
-}
-/**
- * Creates spans and attaches tracing headers to fetch requests.
- */
-export declare const fetchIntegration: (options?: Partial<Options> | undefined) => import("@sentry/core").Integration & {
-    name: "Fetch";
-};
-//# sourceMappingURL=fetch.d.ts.map

package/build/types-ts3.8/integrations/hono.d.ts

@@ -1,42 +0,0 @@
-interface HonoError extends Error {
-    status?: number;
-}
-export interface HonoContext {
-    req: {
-        method: string;
-        path?: string;
-    };
-}
-export interface Options {
-    /**
-     * Callback method deciding whether error should be captured and sent to Sentry
-     * @param error Captured middleware error
-     */
-    shouldHandleError?(this: void, error: HonoError): boolean;
-}
-/** Only exported for internal use */
-export declare function getHonoIntegration(): ReturnType<typeof _honoIntegration> | undefined;
-declare const _honoIntegration: (options?: Partial<Options>) => {
-    name: "Hono";
-    handleHonoException(err: HonoError, context: HonoContext): void;
-};
-/**
- * Automatically captures exceptions caught with the `onError` handler in Hono.
- *
- * The integration is enabled by default.
- *
- * @deprecated Use the `@sentry/hono` package instead. The `sentry()` middleware from `@sentry/hono/cloudflare`
- * handles error capturing automatically without needing this integration.
- *
- * @example
- * integrations: [
- *   honoIntegration({
- *     shouldHandleError: (err) => true; // always capture exceptions in onError
- *   })
- * ]
- */
-export declare const honoIntegration: (options?: Partial<Options> | undefined) => import("@sentry/core").Integration & {
-    name: "Hono";
-};
-export {};
-//# sourceMappingURL=hono.d.ts.map

package/build/types-ts3.8/integrations/httpServer.d.ts

@@ -1,63 +0,0 @@
-import { Client, MaxRequestBodySize } from '@sentry/core';
-export interface HttpServerIntegrationOptions {
-    /**
-     * Controls the maximum size of incoming request bodies attached to events.
-     *
-     * Only applies to requests with textual content types (text/*, application/json,
-     * application/x-www-form-urlencoded, application/xml, application/graphql).
-     * Binary data is not captured.
-     *
-     * Available options:
-     * - `'none'`: No request bodies will be attached
-     * - `'small'`: Request bodies up to 1,000 bytes will be attached
-     * - `'medium'`: Request bodies up to 10,000 bytes will be attached (default)
-     * - `'always'`: Request bodies will always be attached (up to 1MB limit)
-     *
-     * @default 'medium'
-     */
-    maxRequestBodySize?: MaxRequestBodySize;
-    /**
-     * Do not capture the request body for incoming HTTP requests to URLs where the given callback returns `true`.
-     * This can be useful for long running requests where the body is not needed, health check endpoints,
-     * or requests containing sensitive data that should not be captured.
-     *
-     * @param url The full URL of the incoming request, including query string, protocol, host, etc.
-     * @param request The incoming Request object.
-     * @returns `true` to skip body capture for this request, `false` to capture normally.
-     *
-     * @example
-     * ```ts
-     * Sentry.httpServerIntegration({
-     *   ignoreRequestBody: (url) => url.includes('/health') || url.includes('/upload'),
-     * })
-     * ```
-     */
-    ignoreRequestBody?: (url: string, request: Request) => boolean;
-}
-/**
- * Configures incoming HTTP request handling for Cloudflare Workers.
- *
- * This integration controls how incoming HTTP request data is captured,
- * matching the API of `httpServerIntegration` in Node.js.
- *
- * @example
- * ```ts
- * Sentry.init({
- *   integrations: [
- *     Sentry.httpServerIntegration({
- *       maxRequestBodySize: 'medium',
- *       ignoreRequestBody: (url) => url.includes('/health'),
- *     }),
- *   ],
- * });
- * ```
- */
-export declare const httpServerIntegration: (options?: HttpServerIntegrationOptions | undefined) => import("@sentry/core").Integration & {
-    name: string;
-};
-/**
- * Capture the request body based on the HttpServer integration config.
- * Called internally by `wrapRequestHandler`.
- */
-export declare function captureIncomingRequestBody(client: Client, request: Request): Promise<void>;
-//# sourceMappingURL=httpServer.d.ts.map

package/build/types-ts3.8/integrations/spotlight.d.ts

@@ -1,22 +0,0 @@
-type SpotlightConnectionOptions = {
-    /**
-     * Set this if the Spotlight Sidecar is not running on localhost:8969.
-     * By default, the URL is set to http://localhost:8969/stream
-     */
-    sidecarUrl?: string;
-};
-export declare const INTEGRATION_NAME: "Spotlight";
-/**
- * Use this integration to send errors and transactions to Spotlight.
- *
- * Learn more about spotlight at https://spotlightjs.com
- *
- * Important: This integration is intended for local development only.
- * Each forwarded envelope counts as a Worker subrequest (50 free / 1000 paid
- * per invocation), so it should not be enabled in production.
- */
-export declare const spotlightIntegration: (options?: Partial<SpotlightConnectionOptions> | undefined) => import("@sentry/core").Integration & {
-    name: "Spotlight";
-};
-export {};
-//# sourceMappingURL=spotlight.d.ts.map

package/build/types-ts3.8/integrations/tracing/vercelai.d.ts

@@ -1,47 +0,0 @@
-/**
- * This is a copy of the Vercel AI integration from the node SDK.
- *
- * The only difference is that it does not use `@opentelemetry/instrumentation`
- * because Cloudflare Workers do not support it.
- *
- * Therefore, we cannot automatically patch setting `experimental_telemetry: { isEnabled: true }`
- * and users have to manually set this to get spans.
- */
-interface VercelAiOptions {
-    /**
-     * Enable or disable truncation of recorded input messages.
-     * Defaults to `true`.
-     */
-    enableTruncation?: boolean;
-}
-/**
- * Adds Sentry tracing instrumentation for the [ai](https://www.npmjs.com/package/ai) library.
- * This integration is not enabled by default, you need to manually add it.
- *
- * For more information, see the [`ai` documentation](https://sdk.vercel.ai/docs/ai-sdk-core/telemetry).
- *
- *  You need to enable collecting spans for a specific call by setting
- * `experimental_telemetry.isEnabled` to `true` in the first argument of the function call.
- *
- * ```javascript
- * const result = await generateText({
- *   model: openai('gpt-4-turbo'),
- *   experimental_telemetry: { isEnabled: true },
- * });
- * ```
- *
- * If you want to collect inputs and outputs for a specific call, you must specifically opt-in to each
- * function call by setting `experimental_telemetry.recordInputs` and `experimental_telemetry.recordOutputs`
- * to `true`.
- *
- * ```javascript
- * const result = await generateText({
- *  model: openai('gpt-4-turbo'),
- *  experimental_telemetry: { isEnabled: true, recordInputs: true, recordOutputs: true },
- * });
- */
-export declare const vercelAIIntegration: (options?: VercelAiOptions | undefined) => import("@sentry/core").Integration & {
-    name: string;
-};
-export {};
-//# sourceMappingURL=vercelai.d.ts.map

package/build/types-ts3.8/nodejs_compat/index.d.ts

@@ -1,4 +0,0 @@
-export * from '../index';
-export { prismaIntegration } from '@sentry/server-utils';
-export { vercelAIIntegration } from './integrations/tracing/vercelai';
-//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/nodejs_compat/integrations/tracing/vercelai.d.ts

@@ -1,37 +0,0 @@
-/*
-* This is a copy of the Vercel AI integration from the Cloudflare SDK (src/integrations/tracing/vercelai.ts).
-*
-* The only difference is that it includes tracing channel support
-* because the default Vercel AI integration needs `nodejs_als`, while this one uses `nodejs_compat`.
-*/
-import { VercelAiOptions } from '@sentry/server-utils';
-/**
- * Adds Sentry tracing instrumentation for the [ai](https://www.npmjs.com/package/ai) library.
- * This integration is not enabled by default, you need to manually add it.
- *
- * For more information, see the [`ai` documentation](https://sdk.vercel.ai/docs/ai-sdk-core/telemetry).
- *
- *  You need to enable collecting spans for a specific call by setting
- * `experimental_telemetry.isEnabled` to `true` in the first argument of the function call.
- *
- * ```javascript
- * const result = await generateText({
- *   model: openai('gpt-4-turbo'),
- *   experimental_telemetry: { isEnabled: true },
- * });
- * ```
- *
- * If you want to collect inputs and outputs for a specific call, you must specifically opt-in to each
- * function call by setting `experimental_telemetry.recordInputs` and `experimental_telemetry.recordOutputs`
- * to `true`.
- *
- * ```javascript
- * const result = await generateText({
- *  model: openai('gpt-4-turbo'),
- *  experimental_telemetry: { isEnabled: true, recordInputs: true, recordOutputs: true },
- * });
- */
-export declare const vercelAIIntegration: (options?: VercelAiOptions | undefined) => import("@sentry/core").Integration & {
-    name: string;
-};
-//# sourceMappingURL=vercelai.d.ts.map

package/build/types-ts3.8/opentelemetry/tracer.d.ts

@@ -1,6 +0,0 @@
-/**
- * Set up a mock OTEL tracer to allow inter-op with OpenTelemetry emitted spans.
- * This is not perfect but handles easy/common use cases.
- */
-export declare function setupOpenTelemetryTracer(): void;
-//# sourceMappingURL=tracer.d.ts.map

package/build/types-ts3.8/options.d.ts

@@ -1,17 +0,0 @@
-import { CloudflareOptions } from './client';
-/**
- * Merges the options passed in from the user with the options we read from
- * the Cloudflare `env` environment variable object.
- *
- * Release is determined with the following priority (highest to lowest):
- * 1. User-provided release option
- * 2. SENTRY_RELEASE environment variable
- * 3. CF_VERSION_METADATA.id binding (if configured in the wrangler config)
- *
- * @param userOptions - The options passed in from the user.
- * @param env - The environment variables.
- *
- * @returns The final options.
- */
-export declare function getFinalOptions(userOptions: CloudflareOptions | undefined, env: unknown): CloudflareOptions;
-//# sourceMappingURL=options.d.ts.map

package/build/types-ts3.8/pages-plugin.d.ts

@@ -1,34 +0,0 @@
-import { CloudflareOptions } from './client';
-/**
- * Plugin middleware for Cloudflare Pages.
- *
- * Initializes the SDK and wraps cloudflare pages requests with SDK instrumentation.
- *
- * @example Simple usage
- *
- * ```javascript
- * // functions/_middleware.js
- * import * as Sentry from '@sentry/cloudflare';
- *
- * export const onRequest = Sentry.sentryPagesPlugin({
- *   dsn: process.env.SENTRY_DSN,
- *   tracesSampleRate: 1.0,
- * });
- * ```
- *
- * @example Usage with handler function to access context for environmental variables
- *
- * ```javascript
- * import * as Sentry from '@sentry/cloudflare';
- *
- * const const onRequest = Sentry.sentryPagesPlugin((context) => ({
- *   dsn: context.env.SENTRY_DSN,
- *   tracesSampleRate: 1.0,
- * })
- * ```
- *
- * @param handlerOrOptions Configuration options or a function that returns configuration options.
- * @returns A plugin function that can be used in Cloudflare Pages.
- */
-export declare function sentryPagesPlugin<Env = unknown, Params extends string = any, Data extends Record<string, unknown> = Record<string, unknown>, PluginParams = any>(handlerOrOptions: CloudflareOptions | ((context: EventPluginContext<Env, Params, Data, PluginParams>) => CloudflareOptions)): PagesPluginFunction<Env, Params, Data, PluginParams>;
-//# sourceMappingURL=pages-plugin.d.ts.map