@sentry/core 10.47.0 → 10.48.0

package/build/types-ts3.8/integrations/mcp-server/types.d.ts

@@ -74,15 +74,48 @@ export interface MCPTransport {
 export type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcResponse;
 /**
  * MCP server instance interface
- * @description MCP server methods for registering handlers
+ * @description MCP server methods for registering handlers.
+ * Supports both the legacy API (`tool`, `resource`, `prompt`) used in SDK 1.x
+ * and the newer API (`registerTool`, `registerResource`, `registerPrompt`) introduced in SDK 1.x
+ * and made the only option in SDK 2.x.
  */
 export interface MCPServerInstance {
-    /** Register a resource handler */
-    resource: (name: string, ...args: unknown[]) => void;
-    /** Register a tool handler */
-    tool: (name: string, ...args: unknown[]) => void;
-    /** Register a prompt handler */
-    prompt: (name: string, ...args: unknown[]) => void;
+    /**
+     * Register a resource handler.
+     * Supported in `@modelcontextprotocol/sdk` v1.x alongside `registerResource`.
+     * @deprecated Removed in `@modelcontextprotocol/sdk` v2.0.0 — use `registerResource` instead.
+     */
+    resource?: (name: string, ...args: unknown[]) => void;
+    /**
+     * Register a tool handler.
+     * Supported in `@modelcontextprotocol/sdk` v1.x alongside `registerTool`.
+     * @deprecated Removed in `@modelcontextprotocol/sdk` v2.0.0 — use `registerTool` instead.
+     */
+    tool?: (name: string, ...args: unknown[]) => void;
+    /**
+     * Register a prompt handler.
+     * Supported in `@modelcontextprotocol/sdk` v1.x alongside `registerPrompt`.
+     * @deprecated Removed in `@modelcontextprotocol/sdk` v2.0.0 — use `registerPrompt` instead.
+     */
+    prompt?: (name: string, ...args: unknown[]) => void;
+    /**
+     * Register a resource handler.
+     * Available in `@modelcontextprotocol/sdk` v1.x (alongside the legacy `resource` method)
+     * and the only supported form in v2.0.0+.
+     */
+    registerResource?: (name: string, ...args: unknown[]) => void;
+    /**
+     * Register a tool handler.
+     * Available in `@modelcontextprotocol/sdk` v1.x (alongside the legacy `tool` method)
+     * and the only supported form in v2.0.0+.
+     */
+    registerTool?: (name: string, ...args: unknown[]) => void;
+    /**
+     * Register a prompt handler.
+     * Available in `@modelcontextprotocol/sdk` v1.x (alongside the legacy `prompt` method)
+     * and the only supported form in v2.0.0+.
+     */
+    registerPrompt?: (name: string, ...args: unknown[]) => void;
     /** Connect the server to a transport */
     connect(transport: MCPTransport): Promise<void>;
 }

package/build/types-ts3.8/integrations/mcp-server/validation.d.ts

@@ -23,7 +23,10 @@ export declare function isJsonRpcNotification(message: unknown): message is Json
  */
 export declare function isJsonRpcResponse(message: unknown): message is JsonRpcResponse;
 /**
- * Validates MCP server instance with type checking
+ * Validates MCP server instance with type checking.
+ * Accepts both the legacy API (`tool`, `resource`, `prompt`) used in SDK 1.x
+ * and the newer API (`registerTool`, `registerResource`, `registerPrompt`) introduced
+ * alongside the legacy API in SDK 1.x and made the only option in SDK 2.x.
  * @param instance - Object to validate as MCP server instance
  * @returns True if instance has required MCP server methods
  */

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

@@ -0,0 +1,2 @@
+export declare const spanStreamingIntegration: () => import("../types-hoist/integration").Integration;
+//# sourceMappingURL=spanStreaming.d.ts.map

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

@@ -1,7 +1,7 @@
 /**
- * Use this attribute to represent the source of a span.
- * Should be one of: custom, url, route, view, component, task, unknown
- *
+ * Use this attribute to represent the source of a span name.
+ * Must be one of: custom, url, route, view, component, task
+ * TODO(v11): rename this to sentry.span.source'
  */
 export declare const SEMANTIC_ATTRIBUTE_SENTRY_SOURCE = "sentry.source";
 /**
@@ -32,6 +32,26 @@ export declare const SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON = "sentry
 export declare const SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT = "sentry.measurement_unit";
 /** The value of a measurement, which may be stored as a TimedEvent. */
 export declare const SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE = "sentry.measurement_value";
+/** The release version of the application */
+export declare const SEMANTIC_ATTRIBUTE_SENTRY_RELEASE = "sentry.release";
+/** The environment name (e.g., "production", "staging", "development") */
+export declare const SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT = "sentry.environment";
+/** The segment name (e.g., "GET /users") */
+export declare const SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_NAME = "sentry.segment.name";
+/** The id of the segment that this span belongs to. */
+export declare const SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_ID = "sentry.segment.id";
+/** The name of the Sentry SDK (e.g., "sentry.php", "sentry.javascript") */
+export declare const SEMANTIC_ATTRIBUTE_SENTRY_SDK_NAME = "sentry.sdk.name";
+/** The version of the Sentry SDK */
+export declare const SEMANTIC_ATTRIBUTE_SENTRY_SDK_VERSION = "sentry.sdk.version";
+/** The user ID (gated by sendDefaultPii) */
+export declare const SEMANTIC_ATTRIBUTE_USER_ID = "user.id";
+/** The user email (gated by sendDefaultPii) */
+export declare const SEMANTIC_ATTRIBUTE_USER_EMAIL = "user.email";
+/** The user IP address (gated by sendDefaultPii) */
+export declare const SEMANTIC_ATTRIBUTE_USER_IP_ADDRESS = "user.ip_address";
+/** The user username (gated by sendDefaultPii) */
+export declare const SEMANTIC_ATTRIBUTE_USER_USERNAME = "user.name";
 /**
  * A custom span name set by users guaranteed to be taken over any automatically
  * inferred name. This attribute is removed before the span is sent.

package/build/types-ts3.8/tracing/ai/gen-ai-attributes.d.ts

@@ -165,26 +165,18 @@ export declare const GEN_AI_USAGE_INPUT_TOKENS_CACHED_ATTRIBUTE = "gen_ai.usage.
  */
 export declare const GEN_AI_INVOKE_AGENT_OPERATION_ATTRIBUTE = "gen_ai.invoke_agent";
 /**
- * The span operation name for generating text
+ * The span operation name for generating content
  */
-export declare const GEN_AI_GENERATE_TEXT_DO_GENERATE_OPERATION_ATTRIBUTE = "gen_ai.generate_text";
-/**
- * The span operation name for streaming text
- */
-export declare const GEN_AI_STREAM_TEXT_DO_STREAM_OPERATION_ATTRIBUTE = "gen_ai.stream_text";
-/**
- * The span operation name for generating object
- */
-export declare const GEN_AI_GENERATE_OBJECT_DO_GENERATE_OPERATION_ATTRIBUTE = "gen_ai.generate_object";
-/**
- * The span operation name for streaming object
- */
-export declare const GEN_AI_STREAM_OBJECT_DO_STREAM_OPERATION_ATTRIBUTE = "gen_ai.stream_object";
+export declare const GEN_AI_GENERATE_CONTENT_OPERATION_ATTRIBUTE = "gen_ai.generate_content";
 /**
  * The embeddings input
  * Only recorded when recordInputs is enabled
  */
 export declare const GEN_AI_EMBEDDINGS_INPUT_ATTRIBUTE = "gen_ai.embeddings.input";
+/**
+ * The span operation for embeddings
+ */
+export declare const GEN_AI_EMBEDDINGS_OPERATION_ATTRIBUTE = "gen_ai.embeddings";
 /**
  * The span operation name for embedding
  */
@@ -226,28 +218,4 @@ export declare const GEN_AI_TOOL_OUTPUT_ATTRIBUTE = "gen_ai.tool.output";
  * @see https://opentelemetry.io/docs/specs/semconv/registry/attributes/gen-ai/#gen-ai-tool-description
  */
 export declare const GEN_AI_TOOL_DESCRIPTION_ATTRIBUTE = "gen_ai.tool.description";
-/**
- * The response ID from OpenAI
- */
-export declare const OPENAI_RESPONSE_ID_ATTRIBUTE = "openai.response.id";
-/**
- * The response model from OpenAI
- */
-export declare const OPENAI_RESPONSE_MODEL_ATTRIBUTE = "openai.response.model";
-/**
- * The response timestamp from OpenAI (ISO string)
- */
-export declare const OPENAI_RESPONSE_TIMESTAMP_ATTRIBUTE = "openai.response.timestamp";
-/**
- * The number of completion tokens used
- */
-export declare const OPENAI_USAGE_COMPLETION_TOKENS_ATTRIBUTE = "openai.usage.completion_tokens";
-/**
- * The number of prompt tokens used
- */
-export declare const OPENAI_USAGE_PROMPT_TOKENS_ATTRIBUTE = "openai.usage.prompt_tokens";
-/**
- * The response timestamp from Anthropic AI (ISO string)
- */
-export declare const ANTHROPIC_AI_RESPONSE_TIMESTAMP_ATTRIBUTE = "anthropic.response.timestamp";
 //# sourceMappingURL=gen-ai-attributes.d.ts.map

package/build/types-ts3.8/tracing/ai/utils.d.ts

@@ -8,10 +8,12 @@ export interface AIRecordingOptions {
  * which gen_ai operation it maps to and whether it is intrinsically streaming.
  */
 export interface InstrumentedMethodEntry {
-    /** Operation name (e.g. 'chat', 'embeddings', 'generate_content') */
-    operation: string;
+    /** Operation name (e.g. 'chat', 'embeddings', 'generate_content'). Omit for factory methods that only need result proxying. */
+    operation?: string;
     /** True if the method itself is always streaming (not param-based) */
     streaming?: boolean;
+    /** When set, the method's return value is re-proxied with this as the base path */
+    proxyResultPath?: string;
 }
 /**
  * Maps method paths to their registry entries.
@@ -37,6 +39,23 @@ export declare function buildMethodPath(currentPath: string, prop: string): stri
  * @param cachedOutputTokens - The number of cached output tokens
  */
 export declare function setTokenUsageAttributes(span: Span, promptTokens?: number, completionTokens?: number, cachedInputTokens?: number, cachedOutputTokens?: number): void;
+export interface StreamResponseState {
+    responseId?: string;
+    responseModel?: string;
+    finishReasons: string[];
+    responseTexts: string[];
+    toolCalls: unknown[];
+    promptTokens?: number;
+    completionTokens?: number;
+    totalTokens?: number;
+    cacheCreationInputTokens?: number;
+    cacheReadInputTokens?: number;
+}
+/**
+ * Ends a streaming span by setting all accumulated response attributes and ending the span.
+ * Shared across OpenAI, Anthropic, and Google GenAI streaming implementations.
+ */
+export declare function endStreamSpan(span: Span, state: StreamResponseState, recordOutputs: boolean): void;
 /**
  * Get the truncated JSON string for a string or array of strings.
  *

package/build/types-ts3.8/tracing/google-genai/constants.d.ts

@@ -11,7 +11,7 @@ export declare const GOOGLE_GENAI_METHOD_REGISTRY: {
         readonly operation: "embeddings";
     };
     readonly 'chats.create': {
-        readonly operation: "chat";
+        readonly proxyResultPath: "chat";
     };
     readonly 'chat.sendMessage': {
         readonly operation: "chat";
@@ -22,6 +22,4 @@ export declare const GOOGLE_GENAI_METHOD_REGISTRY: {
     };
 };
 export declare const GOOGLE_GENAI_SYSTEM_NAME = "google_genai";
-export declare const CHATS_CREATE_METHOD = "chats.create";
-export declare const CHAT_PATH = "chat";
 //# sourceMappingURL=constants.d.ts.map

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

@@ -10,4 +10,5 @@ export { getDynamicSamplingContextFromClient, getDynamicSamplingContextFromSpan,
 export { setMeasurement, timedEventsToMeasurements } from './measurement';
 export { sampleSpan } from './sampling';
 export { logSpanEnd, logSpanStart } from './logSpans';
+export { captureSpan } from './spans/captureSpan';
 //# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/tracing/langchain/embeddings.d.ts

@@ -0,0 +1,27 @@
+import { LangChainOptions } from './types';
+/**
+ * Wraps a LangChain embedding method (embedQuery or embedDocuments) to create Sentry spans.
+ *
+ * Used internally by the Node.js auto-instrumentation to patch embedding class prototypes.
+ */
+export declare function instrumentEmbeddingMethod(originalMethod: (...args: unknown[]) => Promise<unknown>, options?: LangChainOptions): (...args: unknown[]) => Promise<unknown>;
+/**
+ * Wraps a LangChain embeddings instance to create Sentry spans for `embedQuery` and `embedDocuments` calls.
+ *
+ * Use this in non-Node runtimes (Cloudflare, browser, etc.) where auto-instrumentation is not available.
+ *
+ * @example
+ * ```javascript
+ * import * as Sentry from '@sentry/cloudflare';
+ * import { OpenAIEmbeddings } from '@langchain/openai';
+ *
+ * const embeddings = Sentry.instrumentLangChainEmbeddings(
+ *   new OpenAIEmbeddings({ model: 'text-embedding-3-small' })
+ * );
+ *
+ * await embeddings.embedQuery('Hello world');
+ * await embeddings.embedDocuments(['doc1', 'doc2']);
+ * ```
+ */
+export declare function instrumentLangChainEmbeddings<T extends object>(instance: T, options?: LangChainOptions): T;
+//# sourceMappingURL=embeddings.d.ts.map

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

@@ -6,4 +6,5 @@ import { LangChainCallbackHandler, LangChainOptions } from './types';
  * This is a stateful handler that tracks spans across multiple LangChain executions.
  */
 export declare function createLangChainCallbackHandler(options?: LangChainOptions): LangChainCallbackHandler;
+export { instrumentLangChainEmbeddings } from './embeddings';
 //# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/tracing/openai/utils.d.ts

@@ -1,22 +1,5 @@
 import { Span } from '../../types-hoist/span';
-import { ChatCompletionChunk, OpenAiChatCompletionObject, OpenAIConversationObject, OpenAICreateEmbeddingsObject, OpenAIResponseObject, ResponseStreamingEvent } from './types';
-/**
- * Check if response is a Chat Completion object
- */
-export declare function isChatCompletionResponse(response: unknown): response is OpenAiChatCompletionObject;
-/**
- * Check if response is a Responses API object
- */
-export declare function isResponsesApiResponse(response: unknown): response is OpenAIResponseObject;
-/**
- * Check if response is an Embeddings API object
- */
-export declare function isEmbeddingsResponse(response: unknown): response is OpenAICreateEmbeddingsObject;
-/**
- * Check if response is a Conversations API object
- * @see https://platform.openai.com/docs/api-reference/conversations
- */
-export declare function isConversationResponse(response: unknown): response is OpenAIConversationObject;
+import { ChatCompletionChunk, ResponseStreamingEvent } from './types';
 /**
  * Check if streaming event is from the Responses API
  */
@@ -26,38 +9,10 @@ export declare function isResponsesApiStreamEvent(event: unknown): event is Resp
  */
 export declare function isChatCompletionChunk(event: unknown): event is ChatCompletionChunk;
 /**
- * Add attributes for Chat Completion responses
- */
-export declare function addChatCompletionAttributes(span: Span, response: OpenAiChatCompletionObject, recordOutputs?: boolean): void;
-/**
- * Add attributes for Responses API responses
- */
-export declare function addResponsesApiAttributes(span: Span, response: OpenAIResponseObject, recordOutputs?: boolean): void;
-/**
- * Add attributes for Embeddings API responses
- */
-export declare function addEmbeddingsAttributes(span: Span, response: OpenAICreateEmbeddingsObject): void;
-/**
- * Add attributes for Conversations API responses
- * @see https://platform.openai.com/docs/api-reference/conversations
- */
-export declare function addConversationAttributes(span: Span, response: OpenAIConversationObject): void;
-/**
- * Set token usage attributes
- * @param span - The span to add attributes to
- * @param promptTokens - The number of prompt tokens
- * @param completionTokens - The number of completion tokens
- * @param totalTokens - The number of total tokens
- */
-export declare function setTokenUsageAttributes(span: Span, promptTokens?: number, completionTokens?: number, totalTokens?: number): void;
-/**
- * Set common response attributes
- * @param span - The span to add attributes to
- * @param id - The response id
- * @param model - The response model
- * @param timestamp - The response timestamp
+ * Add response attributes to a span using duck-typing.
+ * Works for Chat Completions, Responses API, Embeddings, and Conversations API responses.
  */
-export declare function setCommonResponseAttributes(span: Span, id: string, model: string, timestamp: number): void;
+export declare function addResponseAttributes(span: Span, result: unknown, recordOutputs?: boolean): void;
 /**
  * Extract request parameters including model settings and conversation context
  */

package/build/types-ts3.8/tracing/sentryNonRecordingSpan.d.ts

@@ -1,12 +1,22 @@
+import { EventDropReason } from '../types-hoist/clientreport';
 import { SentrySpanArguments, Span, SpanAttributes, SpanAttributeValue, SpanContextData, SpanTimeInput } from '../types-hoist/span';
 import { SpanStatus } from '../types-hoist/spanStatus';
+interface SentryNonRecordingSpanArguments extends SentrySpanArguments {
+    dropReason?: EventDropReason;
+}
 /**
  * A Sentry Span that is non-recording, meaning it will not be sent to Sentry.
  */
 export declare class SentryNonRecordingSpan implements Span {
     private _traceId;
     private _spanId;
-    constructor(spanContext?: SentrySpanArguments);
+    /**
+     * Reason why this span was dropped, if applicable ('ignored' or 'sample_rate').
+     * Used to propagate the correct client report outcome to descendant spans
+     * when span streaming is enabled.
+     */
+    dropReason?: EventDropReason;
+    constructor(spanContext?: SentryNonRecordingSpanArguments);
     /** @inheritdoc */
     spanContext(): SpanContextData;
     /** @inheritdoc */
@@ -36,4 +46,5 @@ export declare class SentryNonRecordingSpan implements Span {
      */
     recordException(_exception: unknown, _time?: number | undefined): void;
 }
+export {};
 //# sourceMappingURL=sentryNonRecordingSpan.d.ts.map

package/build/types-ts3.8/tracing/sentrySpan.d.ts

@@ -1,5 +1,5 @@
 import { SpanLink } from '../types-hoist/link';
-import { SentrySpanArguments, Span, SpanAttributes, SpanAttributeValue, SpanContextData, SpanJSON, SpanTimeInput } from '../types-hoist/span';
+import { SentrySpanArguments, Span, SpanAttributes, SpanAttributeValue, SpanContextData, SpanJSON, SpanTimeInput, StreamedSpanJSON } from '../types-hoist/span';
 import { SpanStatus } from '../types-hoist/spanStatus';
 import { TimedEvent } from '../types-hoist/timedEvent';
 /**
@@ -77,6 +77,15 @@ export declare class SentrySpan implements Span {
      * use `spanToJSON(span)` instead.
      */
     getSpanJSON(): SpanJSON;
+    /**
+     * Get {@link StreamedSpanJSON} representation of this span.
+     *
+     * @hidden
+     * @internal This method is purely for internal purposes and should not be used outside
+     * of SDK code. If you need to get a JSON representation of a span,
+     * use `spanToStreamedSpanJSON(span)` instead.
+     */
+    getStreamedSpanJSON(): StreamedSpanJSON;
     /** @inheritdoc */
     isRecording(): boolean;
     /**

package/build/types-ts3.8/tracing/spans/beforeSendSpan.d.ts

@@ -0,0 +1,35 @@
+import { CoreOptions } from '../../types-hoist/options';
+import { BeforeSendStreamedSpanCallback } from '../../types-hoist/options';
+import { StreamedSpanJSON } from '../../types-hoist/span';
+type StaticBeforeSendSpanCallback = CoreOptions['beforeSendSpan'];
+/**
+ * A wrapper to use the new span format in your `beforeSendSpan` callback.
+ *
+ * When using `traceLifecycle: 'stream'`, wrap your callback with this function
+ * to receive and return {@link StreamedSpanJSON} instead of the standard {@link SpanJSON}.
+ *
+ * @example
+ *
+ * Sentry.init({
+ *   traceLifecycle: 'stream',
+ *   beforeSendSpan: withStreamedSpan((span) => {
+ *     // span is of type StreamedSpanJSON
+ *     return span;
+ *   }),
+ * });
+ *
+ * @param callback - The callback function that receives and returns a {@link StreamedSpanJSON}.
+ * @returns A callback that is compatible with the `beforeSendSpan` option when using `traceLifecycle: 'stream'`.
+ */
+export declare function withStreamedSpan(callback: (span: StreamedSpanJSON) => StreamedSpanJSON): StaticBeforeSendSpanCallback & {
+    _streamed: true;
+};
+/**
+ * Typesafe check to identify if a `beforeSendSpan` callback expects the streamed span JSON format.
+ *
+ * @param callback - The `beforeSendSpan` callback to check.
+ * @returns `true` if the callback was wrapped with {@link withStreamedSpan}.
+ */
+export declare function isStreamedBeforeSendSpanCallback(callback: unknown): callback is BeforeSendStreamedSpanCallback;
+export {};
+//# sourceMappingURL=beforeSendSpan.d.ts.map

package/build/types-ts3.8/tracing/spans/captureSpan.d.ts

@@ -0,0 +1,26 @@
+import { RawAttributes } from '../../attributes';
+import { Client } from '../../client';
+import { SerializedStreamedSpan, Span, StreamedSpanJSON } from '../../types-hoist/span';
+export type SerializedStreamedSpanWithSegmentSpan = SerializedStreamedSpan & {
+    _segmentSpan: Span;
+};
+/**
+ * Captures a span and returns a JSON representation to be enqueued for sending.
+ *
+ * IMPORTANT: This function converts the span to JSON immediately to avoid writing
+ * to an already-ended OTel span instance (which is blocked by the OTel Span class).
+ *
+ * @returns the final serialized span with a reference to its segment span. This reference
+ * is needed later on to compute the DSC for the span envelope.
+ */
+export declare function captureSpan(span: Span, client: Client): SerializedStreamedSpanWithSegmentSpan;
+/**
+ * Apply a user-provided beforeSendSpan callback to a span JSON.
+ */
+export declare function applyBeforeSendSpanCallback(span: StreamedSpanJSON, beforeSendSpan: (span: StreamedSpanJSON) => StreamedSpanJSON): StreamedSpanJSON;
+/**
+ * Safely set attributes on a span JSON.
+ * If an attribute already exists, it will not be overwritten.
+ */
+export declare function safeSetSpanJSONAttributes(spanJSON: StreamedSpanJSON, newAttributes: RawAttributes<Record<string, unknown>>): void;
+//# sourceMappingURL=captureSpan.d.ts.map

package/build/types-ts3.8/tracing/spans/envelope.d.ts

@@ -0,0 +1,8 @@
+import { Client } from '../../client';
+import { DynamicSamplingContext, StreamedSpanEnvelope } from '../../types-hoist/envelope';
+import { SerializedStreamedSpan } from '../../types-hoist/span';
+/**
+ * Creates a span v2 span streaming envelope
+ */
+export declare function createStreamedSpanEnvelope(serializedSpans: Array<SerializedStreamedSpan>, dsc: Partial<DynamicSamplingContext>, client: Client): StreamedSpanEnvelope;
+//# sourceMappingURL=envelope.d.ts.map

package/build/types-ts3.8/tracing/spans/estimateSize.d.ts

@@ -0,0 +1,12 @@
+import { SerializedStreamedSpan } from '../../types-hoist/span';
+/**
+ * Estimates the serialized byte size of a {@link SerializedStreamedSpan}.
+ *
+ * Uses 2 bytes per character as a UTF-16 approximation, and 8 bytes per number.
+ * The estimate is intentionally conservative and may be slightly lower than the
+ * actual byte size on the wire.
+ * We compensate for this by setting the span buffers internal limit well below the limit
+ * of how large an actual span v2 envelope may be.
+ */
+export declare function estimateSerializedSpanSizeInBytes(span: SerializedStreamedSpan): number;
+//# sourceMappingURL=estimateSize.d.ts.map

package/build/types-ts3.8/tracing/spans/hasSpanStreamingEnabled.d.ts

@@ -0,0 +1,6 @@
+import { Client } from '../../client';
+/**
+ * Determines if span streaming is enabled for the given client
+ */
+export declare function hasSpanStreamingEnabled(client: Client): boolean;
+//# sourceMappingURL=hasSpanStreamingEnabled.d.ts.map

package/build/types-ts3.8/tracing/spans/spanBuffer.d.ts

@@ -0,0 +1,60 @@
+import { Client } from '../../client';
+import { SerializedStreamedSpanWithSegmentSpan } from './captureSpan';
+export interface SpanBufferOptions {
+    /**
+     * Max spans per trace before auto-flush
+     * Must not exceed 1000.
+     *
+     * @default 1_000
+     */
+    maxSpanLimit?: number;
+    /**
+     * Per-trace flush timeout in ms. A timeout is started when a trace bucket is first created
+     * and fires flush() for that specific trace when it expires.
+     * Must be greater than 0.
+     *
+     * @default 5_000
+     */
+    flushInterval?: number;
+    /**
+     * Max accumulated byte weight of spans per trace before auto-flush.
+     * Size is estimated, not exact. Uses 2 bytes per character for strings (UTF-16).
+     *
+     * @default 5_000_000 (5 MB)
+     */
+    maxTraceWeightInBytes?: number;
+}
+/**
+ * A buffer for serialized streamed span JSON objects that flushes them to Sentry in Span v2 envelopes.
+ * Handles per-trace timeout-based flushing, size thresholds, and graceful shutdown.
+ * Also handles computation of the Dynamic Sampling Context (DSC) for the trace, if it wasn't yet
+ * frozen onto the segment span.
+ *
+ * For this, we need the reference to the segment span instance, from
+ * which we compute the DSC. Doing this in the buffer ensures that we compute the DSC as late as possible,
+ * allowing span name and data updates up to this point. Worth noting here that the segment span is likely
+ * still active and modifyable when child spans are added to the buffer.
+ */
+export declare class SpanBuffer {
+    private _traceBuckets;
+    private _client;
+    private _maxSpanLimit;
+    private _flushInterval;
+    private _maxTraceWeight;
+    constructor(client: Client, options?: SpanBufferOptions);
+    /**
+     * Add a span to the buffer.
+     */
+    add(spanJSON: SerializedStreamedSpanWithSegmentSpan): void;
+    /**
+     * Drain and flush all buffered traces.
+     */
+    drain(): void;
+    /**
+     * Flush spans of a specific trace.
+     * In contrast to {@link SpanBuffer.drain}, this method does not flush all traces, but only the one with the given traceId.
+     */
+    flush(traceId: string): void;
+    private _removeTrace;
+}
+//# sourceMappingURL=spanBuffer.d.ts.map

package/build/types-ts3.8/types-hoist/envelope.d.ts

@@ -11,7 +11,7 @@ import { Profile, ProfileChunk } from './profiling';
 import { ReplayEvent, ReplayRecordingData } from './replay';
 import { SdkInfo } from './sdkinfo';
 import { SerializedSession, SessionAggregates } from './session';
-import { SpanJSON } from './span';
+import { SerializedStreamedSpanContainer, SpanJSON } from './span';
 export type DynamicSamplingContext = {
     trace_id: string;
     public_key: DsnComponents['publicKey'];
@@ -87,6 +87,21 @@ type ProfileChunkItemHeaders = {
 type SpanItemHeaders = {
     type: 'span';
 };
+type SpanContainerItemHeaders = {
+    /**
+     * Same as v1 span item type but this envelope is distinguished by {@link SpanContainerItemHeaders.content_type}.
+     */
+    type: 'span';
+    /**
+     * The number of span items in the container. This must be the same as the number of span items in the payload.
+     */
+    item_count: number;
+    /**
+     * The content type of the span items. This must be `application/vnd.sentry.items.span.v2+json`.
+     * (the presence of this field also distinguishes the span item from the v1 span item)
+     */
+    content_type: 'application/vnd.sentry.items.span.v2+json';
+};
 type LogContainerItemHeaders = {
     type: 'log';
     /**
@@ -120,6 +135,7 @@ export type FeedbackItem = BaseEnvelopeItem<FeedbackItemHeaders, FeedbackEvent>;
 export type ProfileItem = BaseEnvelopeItem<ProfileItemHeaders, Profile>;
 export type ProfileChunkItem = BaseEnvelopeItem<ProfileChunkItemHeaders, ProfileChunk>;
 export type SpanItem = BaseEnvelopeItem<SpanItemHeaders, Partial<SpanJSON>>;
+export type SpanContainerItem = BaseEnvelopeItem<SpanContainerItemHeaders, SerializedStreamedSpanContainer>;
 export type LogContainerItem = BaseEnvelopeItem<LogContainerItemHeaders, SerializedLogContainer>;
 export type MetricContainerItem = BaseEnvelopeItem<MetricContainerItemHeaders, SerializedMetricContainer>;
 export type RawSecurityItem = BaseEnvelopeItem<RawSecurityHeaders, LegacyCSPReport>;
@@ -139,6 +155,9 @@ type ReplayEnvelopeHeaders = BaseEnvelopeHeaders;
 type SpanEnvelopeHeaders = BaseEnvelopeHeaders & {
     trace?: DynamicSamplingContext;
 };
+type StreamedSpanEnvelopeHeaders = BaseEnvelopeHeaders & {
+    trace?: DynamicSamplingContext;
+};
 type LogEnvelopeHeaders = BaseEnvelopeHeaders;
 type MetricEnvelopeHeaders = BaseEnvelopeHeaders;
 export type EventEnvelope = BaseEnvelope<EventEnvelopeHeaders, EventItem | AttachmentItem | UserFeedbackItem | FeedbackItem | ProfileItem>;
@@ -153,11 +172,12 @@ export type ReplayEnvelope = [
 ];
 export type CheckInEnvelope = BaseEnvelope<CheckInEnvelopeHeaders, CheckInItem>;
 export type SpanEnvelope = BaseEnvelope<SpanEnvelopeHeaders, SpanItem>;
+export type StreamedSpanEnvelope = BaseEnvelope<StreamedSpanEnvelopeHeaders, SpanContainerItem>;
 export type ProfileChunkEnvelope = BaseEnvelope<BaseEnvelopeHeaders, ProfileChunkItem>;
 export type RawSecurityEnvelope = BaseEnvelope<BaseEnvelopeHeaders, RawSecurityItem>;
 export type LogEnvelope = BaseEnvelope<LogEnvelopeHeaders, LogContainerItem>;
 export type MetricEnvelope = BaseEnvelope<MetricEnvelopeHeaders, MetricContainerItem>;
-export type Envelope = EventEnvelope | SessionEnvelope | ClientReportEnvelope | ProfileChunkEnvelope | ReplayEnvelope | CheckInEnvelope | SpanEnvelope | RawSecurityEnvelope | LogEnvelope | MetricEnvelope;
+export type Envelope = EventEnvelope | SessionEnvelope | ClientReportEnvelope | ProfileChunkEnvelope | ReplayEnvelope | CheckInEnvelope | SpanEnvelope | StreamedSpanEnvelope | RawSecurityEnvelope | LogEnvelope | MetricEnvelope;
 export type EnvelopeItem = Envelope[1][number];
 export {};
 //# sourceMappingURL=envelope.d.ts.map

package/build/types-ts3.8/types-hoist/integration.d.ts

@@ -11,6 +11,14 @@ export interface Integration {
      * It does not receives any arguments, and should only use for e.g. global monkey patching and similar things.
      */
     setupOnce?(): void;
+    /**
+     * Called before the `setup` hook of any integration is called.
+     * This is useful if an integration needs to e.g. modify client options prior to other integrations
+     * reading client options.
+     *
+     * @param client
+     */
+    beforeSetup?(client: Client): void;
     /**
      * Set up an integration for the given client.
      * Receives the client as argument.

package/build/types-ts3.8/types-hoist/link.d.ts

@@ -19,11 +19,11 @@ export interface SpanLink {
  * Link interface for the event envelope item. It's a flattened representation of `SpanLink`.
  * Can include additional fields defined by OTel.
  */
-export interface SpanLinkJSON extends Record<string, unknown> {
+export interface SpanLinkJSON<TAttributes = SpanLinkAttributes> extends Record<string, unknown> {
     span_id: string;
     trace_id: string;
     sampled?: boolean;
-    attributes?: SpanLinkAttributes;
+    attributes?: TAttributes;
 }
 export {};
 //# sourceMappingURL=link.d.ts.map