@sentry/cloudflare 10.70.0 → 11.0.0-alpha.1

package/build/types/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/nodejs_compat/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/nodejs_compat/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC"}

package/build/types/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 { type 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/nodejs_compat/integrations/tracing/vercelai.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vercelai.d.ts","sourceRoot":"","sources":["../../../../../src/nodejs_compat/integrations/tracing/vercelai.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,EAAyD,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAanH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,mBAAmB;;CAA0C,CAAC"}

package/build/types/utils/rpcOptions.d.ts

@@ -1,13 +0,0 @@
-import type { CloudflareOptions } from '../client';
-/**
- * Gets the effective RPC propagation setting, handling deprecation of `instrumentPrototypeMethods`.
- *
- * Priority:
- * 1. If `enableRpcTracePropagation` is set, use it (ignore `instrumentPrototypeMethods`)
- * 2. If only `instrumentPrototypeMethods` is set, use it with deprecation warning
- * 3. If neither is set, return `false`
- *
- * @returns The effective setting for RPC trace propagation
- */
-export declare function getEffectiveRpcPropagation(options: CloudflareOptions): boolean;
-//# sourceMappingURL=rpcOptions.d.ts.map

package/build/types/utils/rpcOptions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rpcOptions.d.ts","sourceRoot":"","sources":["../../../src/utils/rpcOptions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAGnD;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CA+B9E"}

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

@@ -1,11 +0,0 @@
-/**
- * Sets the async context strategy to use AsyncLocalStorage.
- *
- * AsyncLocalStorage is only available in the cloudflare workers runtime if you set
- * compatibility_flags = ["nodejs_compat"]
- *
- * @internal Only exported to be used in higher-level Sentry packages
- * @hidden Only exported to be used in higher-level Sentry packages
- */
-export declare function setAsyncLocalStorageAsyncContextStrategy(): void;
-//# sourceMappingURL=async.d.ts.map

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

@@ -1,203 +0,0 @@
-import { ClientOptions, Options } from '@sentry/core';
-import { ServerRuntimeClient } from '@sentry/core';
-import { ExecutionContextCompat } from './executionContext';
-import { makeFlushLock } from './flush';
-import { CloudflareTransportOptions } from './transport';
-/**
- * The Sentry Cloudflare SDK Client.
- *
- * @see CloudflareClientOptions for documentation on configuration options.
- * @see ServerRuntimeClient for usage documentation.
- */
-export declare class CloudflareClient extends ServerRuntimeClient {
-    private readonly _flushLock;
-    private _pendingSpans;
-    private _spanCompletionPromise;
-    private _resolveSpanCompletion;
-    private _unsubscribeSpanStart;
-    private _unsubscribeSpanEnd;
-    /**
-     * Creates a new Cloudflare SDK instance.
-     * @param options Configuration options for this SDK.
-     */
-    constructor(options: CloudflareClientOptions);
-    /**
-     * Flushes pending operations and ensures all data is processed.
-     * If a timeout is provided, the operation will be completed within the specified time limit.
-     *
-     * It will wait for all pending spans to complete before flushing.
-     *
-     * @param {number} [timeout] - Optional timeout in milliseconds to force the completion of the flush operation.
-     * @return {Promise<boolean>} A promise that resolves to a boolean indicating whether the flush operation was successful.
-     */
-    flush(timeout?: number): Promise<boolean>;
-    /**
-     * Disposes of the client and releases all resources.
-     *
-     * This method clears all Cloudflare-specific state in addition to the base client cleanup.
-     * It unsubscribes from span lifecycle events and clears pending span tracking.
-     *
-     * Call this method after flushing to allow the client to be garbage collected.
-     * After calling dispose(), the client should not be used anymore.
-     */
-    dispose(): void;
-    /** @inheritDoc */
-    protected _setupIntegrations(): void;
-    /**
-     * Resets the span completion promise and resolve function.
-     */
-    private _resetSpanCompletionPromise;
-}
-interface BaseCloudflareOptions {
-    /**
-     * @ignore Used internally to disable the deDupeIntegration for workflows.
-     * @hidden Used internally to disable the deDupeIntegration for workflows.
-     * @default true
-     */
-    enableDedupe?: boolean;
-    /**
-     * The Cloudflare SDK is not OpenTelemetry native, however, we set up some OpenTelemetry compatibility
-     * via a custom trace provider.
-     * This ensures that any spans emitted via `@opentelemetry/api` will be captured by Sentry.
-     * HOWEVER, big caveat: This does not handle custom context handling, it will always work off the current scope.
-     * This should be good enough for many, but not all integrations.
-     *
-     * If you want to opt-out of setting up the OpenTelemetry compatibility tracer, set this to `true`.
-     *
-     * @default false
-     */
-    skipOpenTelemetrySetup?: boolean;
-    /**
-     * Enable trace propagation for RPC calls between Workers, Durable Objects, and Service Bindings.
-     *
-     * When enabled, trace context (sentry-trace + baggage) is propagated across:
-     * - `stub.fetch()` calls to Durable Objects (via HTTP headers)
-     * - Service binding `fetch()` calls (via HTTP headers)
-     * - RPC method calls to Durable Objects and WorkerEntrypoints (via trailing argument)
-     *
-     * When enabled on the **receiver side** (DurableObject or WorkerEntrypoint), the SDK will also:
-     * - Extract and continue traces from incoming RPC calls
-     * - Create spans for each RPC method invocation
-     * - Capture errors thrown by RPC methods
-     *
-     * **Important:** This option should be enabled on **both sides** for full trace propagation.
-     *
-     * @default false
-     * @example
-     * ```ts
-     * // Worker side (caller)
-     * export default Sentry.withSentry(
-     *   (env) => ({
-     *     dsn: env.SENTRY_DSN,
-     *     enableRpcTracePropagation: true,
-     *   }),
-     *   handler,
-     * );
-     *
-     * // Durable Object side (receiver)
-     * export const MyDO = Sentry.instrumentDurableObjectWithSentry(
-     *   (env) => ({
-     *     dsn: env.SENTRY_DSN,
-     *     enableRpcTracePropagation: true,
-     *   }),
-     *   MyDOBase,
-     * );
-     *
-     * // WorkerEntrypoint side (receiver)
-     * export const MyEntrypoint = Sentry.withSentry(
-     *   env => ({ dsn: env.SENTRY_DSN, enableRpcTracePropagation: true }),
-     *   MyEntrypointBase,
-     * );
-     * ```
-     */
-    enableRpcTracePropagation?: boolean;
-    /**
-     * Table names that should stay instrumented even though they match the reserved `cf_` prefix used
-     * by Durable Object frameworks (`agents`, `partyserver`, ...) for their internal SQLite tables.
-     *
-     * By default, `exec` queries against `cf_`-prefixed tables are treated as framework noise and no
-     * `db.query` span is created for them. If one of your own tables happens to use this prefix, add it
-     * here to opt it back into instrumentation. Entries are matched against each table name in the
-     * query summary — strings must match exactly, while regular expressions give you prefix/pattern
-     * matching.
-     *
-     * @default []
-     * @example
-     * ```ts
-     * export default Sentry.withSentry(
-     *   (env) => ({
-     *     dsn: env.SENTRY_DSN,
-     *     durableObjectSqlSpanAllowlist: ['cf_my_table', /^cf_reports_/],
-     *   }),
-     *   handler,
-     * );
-     * ```
-     */
-    durableObjectSqlSpanAllowlist?: Array<string | RegExp>;
-    /**
-     * KV keys that should stay instrumented even though they match a reserved prefix used by Durable
-     * Object frameworks (`agents`, `partyserver`, ...) for their internal storage entries.
-     *
-     * By default, KV reads/writes (`get`, `put`, `delete`, `list`) of `cf_`- or `__ps_`-prefixed keys
-     * are treated as framework noise and no `durable_object_storage_*` span is created for them,
-     * mirroring how `cf_`-prefixed SQL tables are handled (see {@link durableObjectSqlSpanAllowlist}).
-     * If one of your own keys happens to use such a prefix, add it here to opt it back into
-     * instrumentation. Strings must match exactly, while regular expressions give you prefix/pattern
-     * matching.
-     *
-     * @default []
-     * @example
-     * ```ts
-     * export default Sentry.withSentry(
-     *   (env) => ({
-     *     dsn: env.SENTRY_DSN,
-     *     durableObjectStorageSpanAllowlist: ['cf_my_key', /^cf_reports_/],
-     *   }),
-     *   handler,
-     * );
-     * ```
-     */
-    durableObjectStorageSpanAllowlist?: Array<string | RegExp>;
-    /**
-     * @deprecated Use `enableRpcTracePropagation` instead. This option will be removed in a future major version.
-     *
-     * Enable instrumentation of prototype methods for DurableObjects.
-     *
-     * When `true`, the SDK will wrap all methods on the DurableObject prototype chain
-     * to automatically create spans and capture errors for RPC method calls.
-     *
-     * When an array of strings is provided, only the specified method names will be instrumented.
-     *
-     * @default false
-     */
-    instrumentPrototypeMethods?: boolean | string[];
-    /**
-     * If you use Spotlight by Sentry during development, use
-     * this option to forward captured Sentry events to Spotlight.
-     *
-     * Either set it to true, or provide a specific Spotlight Sidecar URL.
-     *
-     * More details: https://spotlightjs.com/
-     *
-     * IMPORTANT: Only set this option to `true` while developing, not in production!
-     */
-    spotlight?: boolean | string;
-}
-/**
- * Configuration options for the Sentry Cloudflare SDK
- *
- * @see @sentry/core Options for more information.
- */
-export interface CloudflareOptions extends Options<CloudflareTransportOptions>, BaseCloudflareOptions {
-    ctx?: ExecutionContextCompat;
-}
-/**
- * Configuration options for the Sentry Cloudflare SDK Client class
- *
- * @see CloudflareClient for more information.
- */
-export interface CloudflareClientOptions extends ClientOptions<CloudflareTransportOptions>, BaseCloudflareOptions {
-    flushLock?: ReturnType<typeof makeFlushLock>;
-}
-export {};
-//# sourceMappingURL=client.d.ts.map

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

@@ -1,7 +0,0 @@
-/**
- * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.
- *
- * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.
- */
-export declare const DEBUG_BUILD: boolean;
-//# sourceMappingURL=debug-build.d.ts.map

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

@@ -1,38 +0,0 @@
-import { env as cloudflareEnv } from 'cloudflare:workers';
-import { CloudflareOptions } from './client';
-/**
- * Define the Sentry options for a Cloudflare Worker in a dedicated module.
- *
- * This is the recommended way to configure the SDK when using the Vite plugin's
- * auto-instrumentation: place an `instrument.server.{ts,js,mjs}` file next to
- * the worker entry whose **default export** is the result of this function. The
- * plugin picks it up automatically and hands it to `withSentry`.
- *
- * Unlike Node's `Sentry.init(...)`, the options cannot be applied at module
- * load time on Cloudflare: the DSN and other settings typically come from the
- * per-request `env`, which only exists inside the handler. Pass a callback to
- * read from `env`, or a static object when no `env` access is needed — either
- * way you get full type-checking and autocomplete on {@link CloudflareOptions}.
- *
- * At runtime this is a thin pass-through; it only normalizes a static object
- * into a callback so the plugin always imports a `(env) => options` function.
- *
- * @example
- * ```ts
- * // src/instrument.server.ts
- * import { defineCloudflareOptions } from '@sentry/cloudflare';
- *
- * export default defineCloudflareOptions((env) => ({
- *   dsn: env.SENTRY_DSN,
- *   tracesSampleRate: 1.0,
- * }));
- * ```
- *
- * @example
- * ```ts
- * // Static options — no `env` access needed
- * export default defineCloudflareOptions({ tracesSampleRate: 1.0 });
- * ```
- */
-export declare function defineCloudflareOptions<Env = typeof cloudflareEnv>(optionsOrCallback: CloudflareOptions | ((env: Env) => CloudflareOptions | undefined)): (env: Env) => CloudflareOptions | undefined;
-//# sourceMappingURL=defineCloudflareOptions.d.ts.map

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

@@ -1,127 +0,0 @@
-import { DurableObject } from 'cloudflare:workers';
-import { CloudflareOptions } from './client';
-/**
- * The instrumented context passed between the shared construction helpers.
- *
- * This is intentionally `any` rather than `ReturnType<typeof instrumentContext<DurableObjectState>>`.
- * A concrete `DurableObjectState` here forces `tsc` to structurally relate its `storage: SqlStorage`
- * graph against the `ExecutionContext | InstrumentedDurableObjectState` parameter of
- * `wrapMethodWithSentry`, while the RPC-branded `DurableObject` from `cloudflare:workers` is also in
- * scope. That union comparison explodes (1296×1296) and hangs the type build. The original inline
- * implementation avoided this only incidentally, because `ctx` reached it as `any` through the Proxy
- * `construct` trap. Keeping the shared context `any` preserves that behavior.
- */
-type InstrumentedDurableObjectContext = any;
-/**
- * Constructs a Durable Object instance and instruments its built-in handler methods
- * (`fetch`, `alarm`, `webSocketMessage`, `webSocketClose`, `webSocketError`).
- *
- * This is the shared construction path used by both {@link instrumentDurableObjectWithSentry}
- * and {@link instrumentAgentWithSentry}. It intentionally does NOT apply the RPC prototype-method
- * instrumentation — callers apply that last via {@link finalizeWithRpcInstrumentation}, after any
- * additional per-instance instrumentation has been layered onto the returned object.
- *
- * @internal
- */
-export declare function constructInstrumentedDurableObject<E, T extends DurableObject<E>>(target: new (state: DurableObjectState, env: E) => T, ctx: DurableObjectState, env: E, newTarget: NewableFunction, optionsCallback: (env: E) => CloudflareOptions): {
-    obj: T;
-    options: CloudflareOptions;
-    context: InstrumentedDurableObjectContext;
-    frameworkManagedMethods: ReadonlySet<string>;
-};
-/**
- * Adds trace propagation to a constructed Durable Object's RPC methods.
- *
- * RPC methods are wrapped on the prototype because Cloudflare dispatches them with the Durable
- * Object instance as the receiver. This preserves native private-field access and keeps the methods
- * visible to Cloudflare's RPC dispatcher. Built-in handlers, Agent handlers, and methods managed by
- * another framework are left untouched.
- *
- * Call this after all per-instance instrumentation has been applied. If RPC trace propagation is
- * disabled, the object is returned unchanged.
- *
- * @param obj The constructed Durable Object instance.
- * @param options The resolved SDK options for this instance.
- * @param context The instrumented execution context for this instance.
- * @param excludedMethods Method names owned by another framework and therefore not safe to wrap.
- * @returns The same Durable Object instance, with eligible prototype methods instrumented.
- * @internal
- */
-export declare function finalizeWithRpcInstrumentation<T extends object>(obj: T, options: CloudflareOptions, context: InstrumentedDurableObjectContext, excludedMethods?: ReadonlySet<string>): T;
-/**
- * Instruments a Durable Object class to capture errors and performance data.
- *
- * Instruments the following methods by default:
- * - fetch
- * - alarm
- * - webSocketMessage
- * - webSocketClose
- * - webSocketError
- *
- * To instrument RPC methods (prototype methods), enable the `enableRpcTracePropagation` option.
- *
- * @param optionsCallback Function that returns the options for the SDK initialization.
- * @param DurableObjectClass The Durable Object class to instrument.
- * @returns The instrumented Durable Object class.
- *
- * @example
- * ```ts
- * class MyDurableObjectBase extends DurableObject {
- *   constructor(ctx: DurableObjectState, env: Env) {
- *     super(ctx, env);
- *   }
- * }
- *
- * export const MyDurableObject = instrumentDurableObjectWithSentry(
- *   env => ({
- *     dsn: env.SENTRY_DSN,
- *     tracesSampleRate: 1.0,
- *   }),
- *   MyDurableObjectBase,
- * );
- * ```
- */
-export declare function instrumentDurableObjectWithSentry<E, T extends DurableObject<E>, C extends new (state: DurableObjectState, env: E) => T>(optionsCallback: (env: E) => CloudflareOptions, DurableObjectClass: C): C;
-/**
- * Instruments a Cloudflare [`agents`](https://www.npmjs.com/package/agents) Agent class with Sentry.
- *
- * An `Agent` is a Durable Object under the hood, so this applies the same instrumentation as
- * {@link instrumentDurableObjectWithSentry} (request transactions, `alarm`, WebSocket handlers, RPC
- * trace propagation, SQL spans) and additionally captures Agent-specific telemetry via
- * `instrumentCloudflareAgent`:
- *
- * - **Callable RPC spans** — a span (op `rpc`) for each `@callable()` method invoked over WebSocket.
- * - **Breadcrumbs** — for every Agent observability event (`rpc`, `state:update`, `connect`,
- *   `disconnect`, `schedule:*`, `queue:*`, `workflow:*`, `email:*`, `mcp:*`, ...).
- *
- * Cloudflare Workers cannot auto-instrument, so the Agent class must be wrapped manually.
- *
- * @param optionsCallback Function that returns the options for the SDK initialization.
- * @param AgentClass The Agent class to instrument.
- * @returns The instrumented Agent class.
- *
- * @example
- * ```ts
- * import { Agent, callable, routeAgentRequest } from 'agents';
- * import * as Sentry from '@sentry/cloudflare';
- *
- * class MyAgentBase extends Agent<Env> {
- *   @callable()
- *   async greet(name: string): Promise<string> {
- *     return `Hello, ${name}!`;
- *   }
- * }
- *
- * export const MyAgent = Sentry.instrumentAgentWithSentry(
- *   env => ({
- *     dsn: env.SENTRY_DSN,
- *     tracesSampleRate: 1.0,
- *     enableRpcTracePropagation: true,
- *   }),
- *   MyAgentBase,
- * );
- * ```
- */
-export declare function instrumentAgentWithSentry<E, T extends DurableObject<E>, C extends new (state: DurableObjectState, env: E) => T>(optionsCallback: (env: E) => CloudflareOptions, AgentClass: C): C;
-export {};
-//# sourceMappingURL=durableobject.d.ts.map

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

@@ -1,13 +0,0 @@
-import { ExecutionContext } from '@cloudflare/workers-types';
-/**
- * A structural subset of `ExecutionContext` that is compatible with both `@cloudflare/workers-types`
- * v4 and v5.
- *
- * v5 added `exports` and `tracing` as required members. Referencing the full `ExecutionContext` in
- * public input positions would force consumers on v4 (still allowed by our `peerDependencies` range)
- * to provide members their types don't have. We only ever use `waitUntil` (plus a runtime
- * `'storage' in ctx` check), so picking the members that exist in both majors keeps a context
- * constructed against either version assignable here.
- */
-export type ExecutionContextCompat = Pick<ExecutionContext, 'waitUntil' | 'passThroughOnException'> | ExecutionContext;
-//# sourceMappingURL=executionContext.d.ts.map

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

@@ -1,47 +0,0 @@
-import { ExecutionContext } from '@cloudflare/workers-types';
-import { Client } from '@sentry/core';
-import { ExecutionContextCompat } from './executionContext';
-type FlushLock = {
-    readonly ready: Promise<void>;
-    readonly finalize: () => Promise<void>;
-};
-/**
- * Returns the original (un-instrumented) waitUntil function for a context.
- * This should be used when calling waitUntil with flushAndDispose to avoid deadlock.
- *
- * The flush lock mechanism wraps context.waitUntil to track pending tasks.
- * If we call waitUntil(flushAndDispose(client)) through the instrumented version,
- * it creates a deadlock because:
- * 1. The instrumented waitUntil acquires the flush lock
- * 2. flushAndDispose calls client.flush() which waits for the lock to be released
- * 3. The lock won't be released until the waitUntil promise completes
- * 4. The waitUntil promise won't complete until flush() returns
- *
- * By using the original waitUntil for flush operations, we bypass this issue.
- */
-export declare function getOriginalWaitUntil(context: ExecutionContextCompat): ExecutionContext['waitUntil'];
-/**
- * Enhances the given execution context by wrapping its `waitUntil` method with a proxy
- * to monitor pending tasks, and provides a flusher function to ensure all tasks
- * have been completed before executing any subsequent logic.
- *
- * @param {ExecutionContext} context - The execution context to be enhanced. If no context is provided, the function returns undefined.
- * @return {FlushLock} Returns a flusher function if a valid context is provided, otherwise undefined.
- */
-export declare function makeFlushLock(context: ExecutionContextCompat): FlushLock;
-/**
- * Flushes the client and then disposes of it to allow garbage collection.
- * This should be called at the end of each request to prevent memory leaks.
- *
- * This function never rejects. On Workers, a rejected promise passed to
- * `ctx.waitUntil` marks the whole invocation as `outcome: exception` even when
- * the handler itself completed successfully. Since flush/dispose is internal
- * SDK housekeeping, a failure here must not fail the user's invocation.
- *
- * @param client - The CloudflareClient instance to flush and dispose
- * @param timeout - Timeout in milliseconds for the flush operation
- * @returns A promise that resolves when flush and dispose are complete
- */
-export declare function flushAndDispose(client: Client | undefined, timeout?: number): Promise<void>;
-export {};
-//# sourceMappingURL=flush.d.ts.map

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

@@ -1,19 +0,0 @@
-export { Breadcrumb, BreadcrumbHint, PolymorphicRequest, RequestEventData, SdkInfo, Event, EventHint, ErrorEvent, Exception, FeatureFlagsIntegration, Session, SeverityLevel, Span, StackFrame, Stacktrace, Thread, User, Metric, ExclusiveEventHintOrCaptureContext, CaptureContext, } from '@sentry/core';
-export { CloudflareOptions } from './client';
-export { addEventProcessor, addBreadcrumb, addIntegration, captureException, captureEvent, captureMessage, captureFeedback, close, createTransport, lastEventId, flush, getClient, isInitialized, isEnabled, getCurrentScope, getGlobalScope, getIsolationScope, setCurrentClient, Scope, SDK_VERSION, setContext, setExtra, setExtras, setTag, setTags, setAttribute, setAttributes, setUser, setConversationId, getSpanStatusFromHttpCode, setHttpStatus, withScope, withIsolationScope, captureCheckIn, withMonitor, setMeasurement, getActiveSpan, getRootSpan, getTraceData, getTraceMetaTags, startSpan, startInactiveSpan, startSpanManual, startNewTrace, bindScopeToEmitter, suppressTracing, withActiveSpan, getSpanDescendants, continueTrace, functionToStringIntegration, inboundFiltersIntegration, instrumentOpenAiClient, instrumentGoogleGenAIClient, instrumentAnthropicAiClient, eventFiltersIntegration, linkedErrorsIntegration, requestDataIntegration, extraErrorDataIntegration, dedupeIntegration, rewriteFramesIntegration, captureConsoleIntegration, moduleMetadataIntegration, supabaseIntegration, instrumentSupabaseClient, instrumentPostgresJsSql, zodErrorsIntegration, consoleIntegration, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, trpcMiddleware, spanToJSON, spanToTraceHeader, spanToBaggageHeader, updateSpanName, wrapMcpServerWithSentry, consoleLoggingIntegration, createConsolaReporter, createLangChainCallbackHandler, instrumentLangChainEmbeddings, featureFlagsIntegration, growthbookIntegration, logger, metrics, withStreamedSpan, spanStreamingIntegration, instrumentStateGraph, instrumentLangGraph, instrumentCreateReactAgent, } from '@sentry/core';
-export { withSentry } from './withSentry';
-export { defineCloudflareOptions } from './defineCloudflareOptions';
-export { instrumentAgentWithSentry, instrumentDurableObjectWithSentry } from './durableobject';
-export { sentryPagesPlugin } from './pages-plugin';
-export { wrapRequestHandler } from './request';
-export { CloudflareClient } from './client';
-export { getDefaultIntegrations } from './sdk';
-export { httpServerIntegration } from './integrations/httpServer';
-export { fetchIntegration } from './integrations/fetch';
-export { spotlightIntegration } from './integrations/spotlight';
-export { vercelAIIntegration } from './integrations/tracing/vercelai';
-export { honoIntegration } from './integrations/hono';
-export { instrumentD1WithSentry } from './instrumentations/worker/instrumentD1';
-export { instrumentWorkflowWithSentry } from './workflows';
-export { setAsyncLocalStorageAsyncContextStrategy } from './async';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,20 +0,0 @@
-/**
- * Mark an object as instrumented, storing the instrumented version.
- * @param original The original uninstrumented object
- * @param instrumented The instrumented version (defaults to original if not provided)
- */
-export declare function markAsInstrumented<T>(original: T, instrumented?: T): void;
-/**
- * Get the instrumented version of an object, if available.
- * Returns the instrumented version if the object was previously instrumented,
- * or undefined if not found.
- */
-export declare function getInstrumented<T>(obj: T): T | undefined;
-/**
- * Returns the already-instrumented version of `original` if one exists,
- * otherwise calls `instrumentFn` to create it, marks the mapping, and returns it.
- *
- * @param noMark - If true, skips storing the original→instrumented mapping.
- */
-export declare function ensureInstrumented<T>(original: T, instrumentFn: (original: T) => T, noMark?: boolean): T;
-//# sourceMappingURL=instrument.d.ts.map

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

@@ -1,25 +0,0 @@
-/**
- * Instruments an instance of a Cloudflare [`agents`](https://www.npmjs.com/package/agents) `Agent`
- * with Sentry, adding telemetry that is specific to the Agent's runtime behavior:
- *
- * - **Callable RPC spans** — a span (op `rpc`) for each `@callable()` method invoked over WebSocket.
- * - **Conversation correlation** — sets the conversation id on the scope for each unit of agent
- *   work — chat turn, callable RPC call, or HTTP request — so `gen_ai` spans created within it are
- *   correlated, for chat and plain agents alike. The id is minted once per agent instance and
- *   rotated when the chat is cleared (the `message:clear` observability event); it is persisted to
- *   Durable Object storage so it survives hibernation.
- *
- * It only hooks the `agents` package internals and uses Sentry's tracing primitives. On Cloudflare
- * Workers, prefer `instrumentAgentWithSentry`, which additionally instruments the Durable Object
- * handlers and initializes the SDK; that function calls this one internally.
- *
- * The hooks replace own-properties on the instance and defer to the original implementation, so
- * they compose with any other instrumentation applied to the same instance.
- *
- * @param agent The `agents` `Agent` instance to instrument.
- * @returns The same instance, instrumented.
- *
- * @internal Use `instrumentAgentWithSentry` instead — this is called internally by it.
- */
-export declare function instrumentCloudflareAgent<T extends object>(agent: T): T;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,14 +0,0 @@
-import { AgentInternals } from './types';
-/**
- * Wraps the Agent's `onMessage` handler to create a span for each `@callable()` RPC invocation.
- * RPC requests arrive as WebSocket messages, so this span nests under the active transaction for
- * the WebSocket message (on Cloudflare, the instrumented Durable Object `webSocketMessage` hook).
- *
- * Also sets the conversation id on the scope for the duration of the call: callable methods are the
- * unit of work for plain (non-chat) agents, which run LLM calls just like chat turns do. It is
- * awaited so the id is on the scope before the method body creates any span; the `agents`
- * `onMessage` own property this wraps is already `async`, so the promise return is nothing new to
- * the WebSocket dispatch upstream.
- */
-export declare function instrumentAgentCallableRpc(obj: AgentInternals): void;
-//# sourceMappingURL=instrumentAgentCallableRpc.d.ts.map

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

@@ -1,16 +0,0 @@
-import { AgentInternals } from './types';
-/**
- * Correlates the AI spans of an HTTP-driven agent turn with a conversation id on the active scope.
- *
- * `onRequest` is the third unit of agent work, alongside chat turns and `@callable()` RPC: the
- * `agents` router sends every non-WebSocket request to it, which is how REST endpoints and webhooks
- * reach an agent.
- *
- * `agents` installs `onRequest` as an own property in the `Agent` constructor (as it does
- * `onMessage`), and we instrument after construction, so wrapping the own property is what the
- * router ends up calling. That own property is already `async`, and partyserver's `fetch` awaits it,
- * so returning a promise from this wrapper — to get the conversation id onto the scope before the
- * request handler creates any span — keeps the existing contract.
- */
-export declare function instrumentAgentRequestConversation(obj: AgentInternals): void;
-//# sourceMappingURL=instrumentAgentRequestConversation.d.ts.map

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

@@ -1,23 +0,0 @@
-import { AgentInternals } from './types';
-/**
- * For chat agents (`AIChatAgent` from `@cloudflare/ai-chat`), correlates each chat turn's AI spans
- * with a conversation id on the active scope.
- *
- * In the Agents model one agent instance is one long-lived conversation, so the conversation id is
- * minted once per instance and persisted to Durable Object storage, which is what carries it across
- * hibernation (that destroys the in-memory instance). When the user clears the chat, they expect a
- * fresh conversation — but recreating the Durable Object for that would also drop the MCP/OAuth
- * state stored per instance (GitHub/Sentry sign-in). To get a fresh conversation id *without*
- * losing that state, we rotate the persisted id when the SDK reports a cleared chat.
- *
- * The id itself is not attached to spans here — `setAgentConversationId` resolves it, and the SDK's
- * `conversationIdIntegration` picks it off the scope at `spanStart` to stamp
- * `gen_ai.conversation.id` onto the AI spans created inside the turn (e.g. by the Workers AI
- * instrumentation), which correlates a turn's model and tool calls.
- *
- * Plain (non-chat) `Agent`s do not define `onChatMessage`, so they are skipped here — their unit
- * of work is the callable RPC method, where `instrumentAgentCallableRpc` sets the conversation id
- * instead.
- */
-export declare function instrumentChatAgentConversation(obj: AgentInternals): void;
-//# sourceMappingURL=instrumentChatAgentConversation.d.ts.map