@sentry/cloudflare 10.68.0 → 10.69.0

package/build/types/durableobject.d.ts

@@ -1,5 +1,44 @@
 import type { DurableObject } from 'cloudflare:workers';
 import type { 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
+ * proxy — 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;
+};
+/**
+ * Wraps a constructed (and already handler-instrumented) Durable Object instance with the RPC
+ * prototype-method proxy, when RPC trace propagation is enabled. Returns the object unchanged when
+ * RPC instrumentation is disabled.
+ *
+ * This must be applied last, so that any per-instance instrumentation (own properties such as
+ * `fetch`, `alarm`, or Agent-specific handlers) is excluded from RPC method tracing.
+ *
+ * @internal
+ */
+export declare function finalizeWithRpcInstrumentation<T extends object>(obj: T, options: CloudflareOptions, context: InstrumentedDurableObjectContext): T;
 /**
  * Instruments a Durable Object class to capture errors and performance data.
  *
@@ -34,4 +73,46 @@ import type { CloudflareOptions } from './client';
  * ```
  */
 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/durableobject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"durableobject.d.ts","sourceRoot":"","sources":["../../src/durableobject.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAUlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,iCAAiC,CAC/C,CAAC,EACD,CAAC,SAAS,aAAa,CAAC,CAAC,CAAC,EAC1B,CAAC,SAAS,KAAK,KAAK,EAAE,kBAAkB,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,EACtD,eAAe,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,iBAAiB,EAAE,kBAAkB,EAAE,CAAC,GAAG,CAAC,CAuK1E"}
+{"version":3,"file":"durableobject.d.ts","sourceRoot":"","sources":["../../src/durableobject.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAWlD;;;;;;;;;;GAUG;AAEH,KAAK,gCAAgC,GAAG,GAAG,CAAC;AAE5C;;;;;;;;;;GAUG;AACH,wBAAgB,kCAAkC,CAAC,CAAC,EAAE,CAAC,SAAS,aAAa,CAAC,CAAC,CAAC,EAC9E,MAAM,EAAE,KAAK,KAAK,EAAE,kBAAkB,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,EACpD,GAAG,EAAE,kBAAkB,EACvB,GAAG,EAAE,CAAC,EACN,SAAS,EAAE,eAAe,EAC1B,eAAe,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,iBAAiB,GAC7C;IAAE,GAAG,EAAE,CAAC,CAAC;IAAC,OAAO,EAAE,iBAAiB,CAAC;IAAC,OAAO,EAAE,gCAAgC,CAAA;CAAE,CAiBnF;AAgFD;;;;;;;;;GASG;AACH,wBAAgB,8BAA8B,CAAC,CAAC,SAAS,MAAM,EAC7D,GAAG,EAAE,CAAC,EACN,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,gCAAgC,GACxC,CAAC,CAoFH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,iCAAiC,CAC/C,CAAC,EACD,CAAC,SAAS,aAAa,CAAC,CAAC,CAAC,EAC1B,CAAC,SAAS,KAAK,KAAK,EAAE,kBAAkB,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,EACtD,eAAe,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,iBAAiB,EAAE,kBAAkB,EAAE,CAAC,GAAG,CAAC,CAc1E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,yBAAyB,CACvC,CAAC,EACD,CAAC,SAAS,aAAa,CAAC,CAAC,CAAC,EAC1B,CAAC,SAAS,KAAK,KAAK,EAAE,kBAAkB,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,EACtD,eAAe,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,iBAAiB,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC,CAkBlE"}

package/build/types/index.d.ts

@@ -3,13 +3,14 @@ export type { 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 { instrumentDurableObjectWithSentry } from './durableobject';
+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';

package/build/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,UAAU,EACV,cAAc,EACd,kBAAkB,EAClB,gBAAgB,EAChB,OAAO,EACP,KAAK,EACL,SAAS,EACT,UAAU,EACV,SAAS,EACT,uBAAuB,EACvB,OAAO,EACP,aAAa,EACb,IAAI,EACJ,UAAU,EACV,UAAU,EACV,MAAM,EACN,IAAI,EACJ,MAAM,EACN,kCAAkC,EAClC,cAAc,GACf,MAAM,cAAc,CAAC;AAEtB,YAAY,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAElD,OAAO,EACL,iBAAiB,EACjB,aAAa,EACb,cAAc,EACd,gBAAgB,EAChB,YAAY,EACZ,cAAc,EACd,eAAe,EACf,KAAK,EACL,eAAe,EACf,WAAW,EACX,KAAK,EACL,SAAS,EACT,aAAa,EACb,SAAS,EACT,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,EACL,WAAW,EACX,UAAU,EACV,QAAQ,EACR,SAAS,EACT,MAAM,EACN,OAAO,EACP,YAAY,EACZ,aAAa,EACb,OAAO,EACP,iBAAiB,EACjB,yBAAyB,EACzB,aAAa,EACb,SAAS,EACT,kBAAkB,EAClB,cAAc,EACd,WAAW,EACX,cAAc,EACd,aAAa,EACb,WAAW,EACX,YAAY,EACZ,gBAAgB,EAChB,SAAS,EACT,iBAAiB,EACjB,eAAe,EACf,aAAa,EACb,kBAAkB,EAClB,eAAe,EACf,cAAc,EACd,kBAAkB,EAClB,aAAa,EACb,2BAA2B,EAE3B,yBAAyB,EACzB,sBAAsB,EACtB,2BAA2B,EAC3B,2BAA2B,EAC3B,uBAAuB,EACvB,uBAAuB,EACvB,sBAAsB,EACtB,yBAAyB,EACzB,iBAAiB,EACjB,wBAAwB,EACxB,yBAAyB,EACzB,yBAAyB,EACzB,mBAAmB,EACnB,wBAAwB,EACxB,uBAAuB,EACvB,oBAAoB,EACpB,kBAAkB,EAClB,4BAA4B,EAC5B,gCAAgC,EAChC,gCAAgC,EAChC,qCAAqC,EACrC,cAAc,EACd,UAAU,EACV,iBAAiB,EACjB,mBAAmB,EACnB,cAAc,EACd,uBAAuB,EACvB,yBAAyB,EACzB,qBAAqB,EACrB,8BAA8B,EAC9B,6BAA6B,EAC7B,uBAAuB,EACvB,qBAAqB,EACrB,MAAM,EACN,OAAO,EACP,gBAAgB,EAChB,wBAAwB,EACxB,oBAAoB,EAEpB,mBAAmB,EACnB,0BAA0B,GAC3B,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAAE,iCAAiC,EAAE,MAAM,iBAAiB,CAAC;AACpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAEnD,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAE/C,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,sBAAsB,EAAE,MAAM,OAAO,CAAC;AAE/C,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAEtE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAGtD,OAAO,EAAE,sBAAsB,EAAE,MAAM,wCAAwC,CAAC;AAEhF,OAAO,EAAE,4BAA4B,EAAE,MAAM,aAAa,CAAC;AAE3D,OAAO,EAAE,wCAAwC,EAAE,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}

package/build/types/instrumentations/agents/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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 or callable RPC call — so `gen_ai` spans created within it are correlated, for
+ *   chat and plain agents alike. Defaults to the instance `name` and is rotated when the chat is
+ *   cleared (the `message:clear` observability event).
+ *
+ * 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/instrumentations/agents/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/instrumentations/agents/index.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAOvE"}

package/build/types/instrumentations/agents/instrumentAgentCallableRpc.d.ts

@@ -0,0 +1,11 @@
+import { type 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.
+ */
+export declare function instrumentAgentCallableRpc(obj: AgentInternals): void;
+//# sourceMappingURL=instrumentAgentCallableRpc.d.ts.map

package/build/types/instrumentations/agents/instrumentAgentCallableRpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentAgentCallableRpc.d.ts","sourceRoot":"","sources":["../../../../src/instrumentations/agents/instrumentAgentCallableRpc.ts"],"names":[],"mappings":"AAEA,OAAO,EAAqB,KAAK,cAAc,EAA8C,MAAM,SAAS,CAAC;AAE7G;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI,CA+BpE"}

package/build/types/instrumentations/agents/instrumentChatAgentConversation.d.ts

@@ -0,0 +1,22 @@
+import { type 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 instance `name` is
+ * the base conversation id. 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 an
+ * in-memory id on the instance when the SDK reports a cleared chat, and stamp that (falling back to
+ * the instance `name` before the first clear).
+ *
+ * The id itself is not attached to spans here — the SDK's `conversationIdIntegration` reads it off
+ * the scope at `spanStart` and stamps `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

package/build/types/instrumentations/agents/instrumentChatAgentConversation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentChatAgentConversation.d.ts","sourceRoot":"","sources":["../../../../src/instrumentations/agents/instrumentChatAgentConversation.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,cAAc,EAA0B,MAAM,SAAS,CAAC;AAEtE;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,+BAA+B,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI,CAgCzE"}

package/build/types/instrumentations/agents/types.d.ts

@@ -0,0 +1,49 @@
+export declare const AGENT_SPAN_ORIGIN = "auto.faas.cloudflare.agents";
+export declare const AGENT_CLASS_ATTRIBUTE = "cloudflare.agent.class";
+export declare const AGENT_NAME_ATTRIBUTE = "cloudflare.agent.name";
+/**
+ * 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;
+    /** The user's Agent class (used by the SDK for the observability event `agent` field). */
+    _ParentClass?: {
+        name?: string;
+    };
+    /** The Agent instance name, which in the Agents model identifies the conversation/thread. */
+    name?: string;
+    /**
+     * Internal: the active conversation id, rotated when the chat is cleared (the `message:clear`
+     * observability event) so a reset chat groups as a fresh conversation while the instance (and its
+     * MCP/OAuth state) stays put. Set by `instrumentChatAgentConversation`; falls back to `name`
+     * before the first clear.
+     */
+    __sentryConversationId?: string;
+}
+/** Reads best-effort agent identity attributes from the instance, tolerating missing internals. */
+export declare function getAgentAttributes(instance: AgentInternals): Record<string, string>;
+/**
+ * Sets the agent instance's conversation id on the current scope for the duration of the
+ * surrounding unit of work (chat turn, callable RPC call). In the Agents model one instance is one
+ * conversation, so the instance `name` is the natural conversation id — for chat and plain agents
+ * alike, since plain agents run LLM calls too (e.g. inside `@callable()` methods). Once the chat
+ * has been cleared, the rotated `__sentryConversationId` takes precedence so LLM calls from any
+ * unit of work group under the fresh conversation.
+ *
+ * `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. Callers run inside a per-event forked scope (`wrapMethodWithSentry`), so the id
+ * does not leak into unrelated events.
+ */
+export declare function setAgentConversationId(instance: AgentInternals): void;
+//# sourceMappingURL=types.d.ts.map

package/build/types/instrumentations/agents/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/instrumentations/agents/types.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iBAAiB,gCAAgC,CAAC;AAC/D,eAAO,MAAM,qBAAqB,2BAA2B,CAAC;AAC9D,eAAO,MAAM,oBAAoB,0BAA0B,CAAC;AAE5D;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,2FAA2F;IAC3F,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IAClE,wEAAwE;IACxE,SAAS,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;IAC5C;;;OAGG;IACH,aAAa,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;IAChD,0FAA0F;IAC1F,YAAY,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACjC,6FAA6F;IAC7F,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAC;CACjC;AAED,mGAAmG;AACnG,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAcnF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI,CAMrE"}

package/build/types/instrumentations/instrumentDurableObjectStorage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instrumentDurableObjectStorage.d.ts","sourceRoot":"","sources":["../../../src/instrumentations/instrumentDurableObjectStorage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAA6B,MAAM,2BAA2B,CAAC;AAUjG,KAAK,SAAS,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,IAAI,CAAC;AAErD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,oBAAoB,EAC7B,SAAS,CAAC,EAAE,SAAS,GACpB,oBAAoB,CAwEtB"}
+{"version":3,"file":"instrumentDurableObjectStorage.d.ts","sourceRoot":"","sources":["../../../src/instrumentations/instrumentDurableObjectStorage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAA6B,MAAM,2BAA2B,CAAC;AAYjG,KAAK,SAAS,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,IAAI,CAAC;AAErD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,oBAAoB,EAC7B,SAAS,CAAC,EAAE,SAAS,GACpB,oBAAoB,CAiFtB"}

package/build/types/integrations/spotlight.d.ts

@@ -0,0 +1,22 @@
+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/integrations/spotlight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spotlight.d.ts","sourceRoot":"","sources":["../../../src/integrations/spotlight.ts"],"names":[],"mappings":"AAIA,KAAK,0BAA0B,GAAG;IAChC;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAG,WAAoB,CAAC;AAcrD;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB;;CAA2C,CAAC"}

package/build/types/options.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../src/options.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAyBlD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,iBAAiB,YAAK,EAAE,GAAG,EAAE,OAAO,GAAG,iBAAiB,CAyBpG"}
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../src/options.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAyBlD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,iBAAiB,YAAK,EAAE,GAAG,EAAE,OAAO,GAAG,iBAAiB,CAgCpG"}

package/build/types/sdk.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sdk.d.ts","sourceRoot":"","sources":["../../src/sdk.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAchD,OAAO,KAAK,EAA2B,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC3E,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AA0B5C,2DAA2D;AAC3D,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,iBAAiB,GAAG,WAAW,EAAE,CA8BhF;AAED;;GAEG;AACH,wBAAgB,IAAI,CAAC,OAAO,EAAE,iBAAiB,GAAG,gBAAgB,GAAG,SAAS,CA4B7E"}
+{"version":3,"file":"sdk.d.ts","sourceRoot":"","sources":["../../src/sdk.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAchD,OAAO,KAAK,EAA2B,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC3E,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AA2B5C,2DAA2D;AAC3D,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,iBAAiB,GAAG,WAAW,EAAE,CA8BhF;AAED;;GAEG;AACH,wBAAgB,IAAI,CAAC,OAAO,EAAE,iBAAiB,GAAG,gBAAgB,GAAG,SAAS,CAoC7E"}

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

@@ -12,7 +12,9 @@
  *
  * The check operates on the query summary produced by `getSqlQuerySummary` (`{operation} {table} ...`,
  * the same value used as the span name), so table targets are already isolated from the rest of the
- * query.
+ * query. The one exception is `CREATE INDEX`: its summary carries the index name, not the indexed
+ * table (upstream OTel convention), so the `cf_` target only appears in the ON clause of the full
+ * statement, which `queryText` is needed for.
  */
-export declare function targetsCloudflareInternalTable(querySummary: string | undefined, allowlist?: Array<string | RegExp>): boolean;
+export declare function targetsCloudflareInternalTable(querySummary: string | undefined, allowlist?: Array<string | RegExp>, queryText?: string): boolean;
 //# sourceMappingURL=internalSqlQuery.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"internalSqlQuery.d.ts","sourceRoot":"","sources":["../../../src/utils/internalSqlQuery.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,8BAA8B,CAC5C,YAAY,EAAE,MAAM,GAAG,SAAS,EAChC,SAAS,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,GACjC,OAAO,CAgBT"}
+{"version":3,"file":"internalSqlQuery.d.ts","sourceRoot":"","sources":["../../../src/utils/internalSqlQuery.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,8BAA8B,CAC5C,YAAY,EAAE,MAAM,GAAG,SAAS,EAChC,SAAS,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,EAClC,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAaT"}

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

@@ -0,0 +1,22 @@
+/**
+ * Cloudflare frameworks that build on Durable Objects (`agents`, `partyserver`, ...) also manage
+ * their own internal KV entries alongside their internal SQLite tables, namespaced with a reserved
+ * prefix — e.g. `cf_agents_state`, `cf_agents_mcp_servers`, `__ps_name`. Reads/writes of these
+ * (message persistence, MCP connection bookkeeping, name hydration) are framework implementation
+ * details that otherwise flood traces with dozens of zero-signal `durable_object_storage_*` spans
+ * per request, so we match the reserved prefixes rather than an enumerated list. This mirrors the
+ * `cf_` convention used for internal SQL tables (see `targetsCloudflareInternalTable`).
+ *
+ * The prefixes are a reserved convention for framework-managed entries, so user keys should not use
+ * them. In case a user key does collide, the `durableObjectStorageSpanAllowlist` option lets them
+ * opt those keys back into instrumentation.
+ */
+export declare function targetsCloudflareInternalKey(key: string | undefined, allowlist?: Array<string | RegExp>): boolean;
+/**
+ * Extracts the KV keys a Durable Object storage call targets, so the caller can decide whether the
+ * operation only touches framework-internal entries. Returns `undefined` when the keys can't be
+ * determined from the arguments (e.g. `list()` without a prefix), in which case the call is treated
+ * as user work and stays instrumented.
+ */
+export declare function getStorageKeys(methodName: string, args: unknown[]): string[] | undefined;
+//# sourceMappingURL=internalStorageKey.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"internalStorageKey.d.ts","sourceRoot":"","sources":["../../../src/utils/internalStorageKey.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,OAAO,CAsBjH;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,MAAM,EAAE,GAAG,SAAS,CAgCxF"}

package/build/types/vite/agentClass.d.ts

@@ -0,0 +1,41 @@
+import type { ProgramBody } from './transform';
+/**
+ * The subset of the Vite/Rollup plugin context needed to walk the module graph.
+ *
+ * `resolve` is optional: without it detection still works, but only for base-class chains declared
+ * inside the entry module itself. `readFile` is injectable for tests and defaults to reading disk.
+ *
+ * Deliberately **no `load`**: awaiting the plugin context's `load()` from inside a `transform` hook
+ * deadlocks the build — the module cannot finish loading while its own transform is still pending
+ * (Rollup documents this hazard, and Vite's Rolldown pipeline is stricter still). Sibling modules
+ * are therefore read straight off disk; see {@link getModuleShape}.
+ */
+export interface ModuleResolver {
+    parse(code: string): ProgramBody;
+    resolve?(source: string, importer: string): Promise<{
+        id: string;
+    } | null | undefined>;
+    readFile?(id: string): string | undefined;
+}
+/**
+ * Find which of `candidates` (top-level class names in the entry module) are Cloudflare
+ * [`agents`](https://www.npmjs.com/package/agents) Agents.
+ *
+ * An Agent is a Durable Object under the hood, so wrangler configures it as one and the transform
+ * would otherwise reach for `instrumentDurableObjectWithSentry`. Detecting the Agent base chain lets
+ * it pick `instrumentAgentWithSentry` instead, which adds the Agent-specific telemetry on top.
+ *
+ * Unlike `WorkerEntrypoint` detection, the chain is followed *across* modules: base classes commonly
+ * live in their own file (`import { MyBase } from './base'`), and there is no runtime fallback that
+ * would catch a missed one. Resolution stops at package boundaries — a base class imported from
+ * `node_modules` is only recognized when it is one of {@link AGENT_BASE_CLASSES}.
+ */
+export declare function detectAgentClasses(ast: ProgramBody, entryId: string, candidates: Iterable<string>, resolver: ModuleResolver): Promise<Set<string>>;
+/**
+ * The local class names in the entry that a configured class name could refer to — either declared
+ * under that name directly, or aliased to it by an `export { Local as Configured }` specifier.
+ *
+ * Keeps detection (which reads and scans other modules) off classes that no binding points at.
+ */
+export declare function collectAgentCandidates(ast: ProgramBody, configuredNames: Iterable<string>): Set<string>;
+//# sourceMappingURL=agentClass.d.ts.map

package/build/types/vite/agentClass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentClass.d.ts","sourceRoot":"","sources":["../../../src/vite/agentClass.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAuB/C;;;;;;;;;;GAUG;AACH,MAAM,WAAW,cAAc;IAC7B,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IACjC,OAAO,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC;IACvF,QAAQ,CAAC,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;CAC3C;AAOD;;;;;;;;;;;;GAYG;AACH,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,WAAW,EAChB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,EAC5B,QAAQ,EAAE,cAAc,GACvB,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CActB;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,WAAW,EAAE,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAevG"}

package/build/types/vite/autoInstrument.d.ts

@@ -1,5 +1,7 @@
-import { type ProgramBody } from './transform';
-export declare function sentryCloudflareAutoInstrumentPlugin(): {
+import { type ModuleResolver } from './agentClass';
+export declare function sentryCloudflareAutoInstrumentPlugin(options?: {
+    wranglerConfigPath?: string;
+}): {
     name: string;
     configResolved(config: {
         root: string;
@@ -7,15 +9,14 @@ export declare function sentryCloudflareAutoInstrumentPlugin(): {
             warn(msg: string): void;
         };
     }): void;
-    transform(this: {
-        parse(code: string): ProgramBody;
+    transform(this: ModuleResolver & {
         warn?(msg: string): void;
         environment?: {
             name?: string;
         };
-    }, code: string, id: string): {
+    }, code: string, id: string): Promise<{
         code: string;
         map: unknown;
-    } | undefined;
+    } | undefined>;
 };
 //# sourceMappingURL=autoInstrument.d.ts.map

package/build/types/vite/autoInstrument.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"autoInstrument.d.ts","sourceRoot":"","sources":["../../../src/vite/autoInstrument.ts"],"names":[],"mappings":"AACA,OAAO,EAAwD,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAcrG,wBAAgB,oCAAoC;;2BAUzB;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE;YAAE,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;SAAE,CAAA;KAAE,GAAG,IAAI;oBAyB5E;QAAE,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;QAAC,IAAI,CAAC,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,WAAW,CAAC,EAAE;YAAE,IAAI,CAAC,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,QAC/F,MAAM,MACR,MAAM,GACT;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,OAAO,CAAA;KAAE,GAAG,SAAS;EA6DhD"}
+{"version":3,"file":"autoInstrument.d.ts","sourceRoot":"","sources":["../../../src/vite/autoInstrument.ts"],"names":[],"mappings":"AACA,OAAO,EAA8C,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAgB/F,wBAAgB,oCAAoC,CAAC,OAAO,GAAE;IAAE,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAAO;;2BAUvE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE;YAAE,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;SAAE,CAAA;KAAE,GAAG,IAAI;oBAkC5E,cAAc,GAAG;QAAE,IAAI,CAAC,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,WAAW,CAAC,EAAE;YAAE,IAAI,CAAC,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,QAC9E,MAAM,MACR,MAAM,GACT,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,OAAO,CAAA;KAAE,GAAG,SAAS,CAAC;EAiFzD"}

package/build/types/vite/index.d.ts

@@ -2,6 +2,17 @@
  * Options for {@link sentryCloudflareVitePlugin}.
  */
 export interface SentryCloudflareVitePluginOptions {
+    /**
+     * Path to the wrangler config, relative to the Vite root (or absolute).
+     * Set this when your config doesn't use a default name — e.g. when you
+     * pass `configPath: './wrangler.agent.jsonc'` to `@cloudflare/vite-plugin`,
+     * which the Sentry plugin cannot see. When set, only this file is read
+     * (no default-name probing), and a warning is emitted if it is missing or
+     * unparseable.
+     *
+     * @default undefined (probes `wrangler.json`, `wrangler.jsonc`, `wrangler.toml` at the Vite root)
+     */
+    wranglerConfigPath?: string;
     /**
      * Experimental options that may change or be removed without notice.
      */
@@ -74,15 +85,14 @@ export declare function sentryCloudflareVitePlugin(options?: SentryCloudflareVit
             warn(msg: string): void;
         };
     }): void;
-    transform(this: {
-        parse(code: string): import("./transform").ProgramBody;
+    transform(this: import("./agentClass").ModuleResolver & {
         warn?(msg: string): void;
         environment?: {
             name?: string;
         };
-    }, code: string, id: string): {
+    }, code: string, id: string): Promise<{
         code: string;
         map: unknown;
-    } | undefined;
+    } | undefined>;
 } | import("vite").Plugin<any>)[];
 //# sourceMappingURL=index.d.ts.map

package/build/types/vite/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/vite/index.ts"],"names":[],"mappings":"AAQA;;GAEG;AACH,MAAM,WAAW,iCAAiC;IAChD;;OAEG;IACH,aAAa,CAAC,EAAE;QACd;;;;;;;;;;;;;WAaG;QACH,8BAA8B,CAAC,EAAE,OAAO,CAAC;QACzC;;;;;;;;;;WAUG;QACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;KAC/B,CAAC;CACH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,GAAE,iCAAsC;;;;cAvDpC,CAAC;;;;;;YAoB7B,CAAA;mBAKf,CAAC;gBAAQ,CAAC;;;;;;kCAqCpB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/vite/index.ts"],"names":[],"mappings":"AAQA;;GAEG;AACH,MAAM,WAAW,iCAAiC;IAChD;;;;;;;;;OASG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;OAEG;IACH,aAAa,CAAC,EAAE;QACd;;;;;;;;;;;;;WAaG;QACH,8BAA8B,CAAC,EAAE,OAAO,CAAC;QACzC;;;;;;;;;;WAUG;QACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;KAC/B,CAAC;CACH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,GAAE,iCAAsC;;;;cA5DlF,CAAC;;;;;YAiCgE,CAAC;mBAChD,CAAC;gBAAS,CAAA;;;;;;kCAmCnC"}

package/build/types/vite/moduleShape.d.ts

@@ -0,0 +1,52 @@
+import type { ProgramBody } from './transform';
+/** Binding name used for a module's default export. */
+export declare const DEFAULT_EXPORT = "default";
+/** A resolved superclass reference: a bare identifier or a `ns.Member` expression. */
+export type SuperRef = {
+    kind: 'identifier';
+    name: string;
+} | {
+    kind: 'member';
+    object: string;
+    property: string;
+};
+/** The declarations of a single module that binding resolution needs. */
+export interface ModuleShape {
+    /** Top-level class names → their superclass reference (absent when the class has no `extends`). */
+    classes: Map<string, SuperRef | undefined>;
+    /** Local binding name → the import it came from (`imported` is `default` for a default import). */
+    imports: Map<string, {
+        source: string;
+        imported: string;
+    }>;
+    /** Local binding name → module specifier, for `import * as ns from '...'`. */
+    namespaces: Map<string, string>;
+    /** Exported name → the re-export it came from, for `export { x as y } from '...'`. */
+    reexports: Map<string, {
+        source: string;
+        imported: string;
+    }>;
+    /** Exported name → local binding name, for `export { x as y }` without a source. */
+    localExports: Map<string, string>;
+    /** Module specifiers of bare `export * from '...'` declarations. */
+    starExports: string[];
+    /** `export default <Identifier>` — the local name it refers to. */
+    defaultExportName?: string;
+    /** True when the module's default export is a class declaration/expression. */
+    defaultExportIsClass?: boolean;
+    /** Superclass of an anonymous `export default class extends X`. */
+    defaultExportSuper?: SuperRef;
+}
+/** Collect the shape of a module from its parsed AST — used for the already-parsed entry module. */
+export declare function shapeFromAst(ast: ProgramBody): ModuleShape;
+/**
+ * Extract the module shape from **unprocessed source**.
+ *
+ * Sibling modules are read straight from disk (the plugin context's `load()` would deadlock inside a
+ * transform hook), so they may still be TypeScript — which no JS parser will accept. Only
+ * import/export statements and `class X extends Y` headers matter here, and those are
+ * declaration-level syntax a scan can pick out reliably; class bodies, type annotations and generics
+ * are irrelevant and simply skipped.
+ */
+export declare function shapeFromSource(rawCode: string): ModuleShape;
+//# sourceMappingURL=moduleShape.d.ts.map

package/build/types/vite/moduleShape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"moduleShape.d.ts","sourceRoot":"","sources":["../../../src/vite/moduleShape.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAY,WAAW,EAAE,MAAM,aAAa,CAAC;AAoDzD,uDAAuD;AACvD,eAAO,MAAM,cAAc,YAAY,CAAC;AAExC,sFAAsF;AACtF,MAAM,MAAM,QAAQ,GAAG;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnH,yEAAyE;AACzE,MAAM,WAAW,WAAW;IAC1B,mGAAmG;IACnG,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,GAAG,SAAS,CAAC,CAAC;IAC3C,mGAAmG;IACnG,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC3D,8EAA8E;IAC9E,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,sFAAsF;IACtF,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC7D,oFAAoF;IACpF,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,oEAAoE;IACpE,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,mEAAmE;IACnE,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,+EAA+E;IAC/E,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,mEAAmE;IACnE,kBAAkB,CAAC,EAAE,QAAQ,CAAC;CAC/B;AAiBD,oGAAoG;AACpG,wBAAgB,YAAY,CAAC,GAAG,EAAE,WAAW,GAAG,WAAW,CAqC1D;AAiED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,CAgD5D"}

package/build/types/vite/transform.d.ts

@@ -18,7 +18,7 @@ export interface ProgramBody {
  * config providing only a fallback for self-bound entrypoints whose base class
  * lives in another module.
  */
-export type ClassWrapperKind = 'durableObject' | 'workflow' | 'workerEntrypoint';
+export type ClassWrapperKind = 'durableObject' | 'agent' | 'workflow' | 'workerEntrypoint';
 export interface TransformContext {
     /**
      * Exported class name → the kind of Sentry wrapper to apply. Populated from
@@ -26,6 +26,11 @@ export interface TransformContext {
      * each class's base type.
      */
     classWrappers: Map<string, ClassWrapperKind>;
+    /**
+     * Local class names detected as `agents` Agents. An Agent is configured as a Durable Object in
+     * wrangler, so this upgrades those entries from `durableObject` to `agent`.
+     */
+    agentClasses?: ReadonlySet<string>;
     optionsFn: string;
     /** Import statement prepended when `optionsFn` references a separate module. */
     optionsImport?: string;

package/build/types/vite/transform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../src/vite/transform.ts"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,cAAc,CAAC;AAOvC,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,QAAQ,EAAE,CAAC;CAClB;AAuDD;;;;;;;;;;GAUG;AACH,MAAM,MAAM,gBAAgB,GAAG,eAAe,GAAG,UAAU,GAAG,kBAAkB,CAAC;AAajF,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC7C,SAAS,EAAE,MAAM,CAAC;IAClB,gFAAgF;IAChF,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,UAAU,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC;IAC5C;;;;OAIG;IACH,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,WAAW,EAChB,GAAG,EAAE,gBAAgB,GACpB,eAAe,GAAG,SAAS,CA6C7B"}
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../src/vite/transform.ts"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,cAAc,CAAC;AAOvC,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,QAAQ,EAAE,CAAC;CAClB;AAuDD;;;;;;;;;;GAUG;AACH,MAAM,MAAM,gBAAgB,GAAG,eAAe,GAAG,OAAO,GAAG,UAAU,GAAG,kBAAkB,CAAC;AAc3F,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC7C;;;OAGG;IACH,YAAY,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,gFAAgF;IAChF,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,UAAU,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC;IAC5C;;;;OAIG;IACH,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,WAAW,EAChB,GAAG,EAAE,gBAAgB,GACpB,eAAe,GAAG,SAAS,CA8C7B"}

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

@@ -41,6 +41,8 @@ export declare class CloudflareClient extends ServerRuntimeClient {
      * After calling dispose(), the client should not be used anymore.
      */
     dispose(): void;
+    /** @inheritDoc */
+    protected _setupIntegrations(): void;
     /**
      * Resets the span completion promise and resolve function.
      */
@@ -132,6 +134,30 @@ interface BaseCloudflareOptions {
      * ```
      */
     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.
      *
@@ -145,6 +171,17 @@ interface BaseCloudflareOptions {
      * @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