@sentry/core 10.47.0 → 10.49.0

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,34 +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 name for embedding
- */
-export declare const GEN_AI_EMBED_DO_EMBED_OPERATION_ATTRIBUTE = "gen_ai.embeddings";
-/**
- * The span operation name for embedding many
+ * The span operation for embeddings
  */
-export declare const GEN_AI_EMBED_MANY_DO_EMBED_OPERATION_ATTRIBUTE = "gen_ai.embeddings";
+export declare const GEN_AI_EMBEDDINGS_OPERATION_ATTRIBUTE = "gen_ai.embeddings";
 /**
  * The span operation name for reranking
  */
@@ -226,28 +210,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.
@@ -24,6 +26,12 @@ export type InstrumentedMethodRegistry = Record<string, InstrumentedMethodEntry>
  * Precedence: explicit option > sendDefaultPii > false
  */
 export declare function resolveAIRecordingOptions<T extends AIRecordingOptions>(options?: T): T & Required<AIRecordingOptions>;
+/**
+ * Resolves whether truncation should be enabled.
+ * If the user explicitly set `enableTruncation`, that value is used.
+ * Otherwise, truncation is disabled when span streaming is active.
+ */
+export declare function shouldEnableTruncation(enableTruncation: boolean | undefined): boolean;
 /**
  * Build method path from current traversal
  */
@@ -37,6 +45,28 @@ 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;
+/**
+ * Serialize a value to a JSON string without truncation.
+ * Strings are returned as-is, arrays and objects are JSON-stringified.
+ */
+export declare function getJsonString<T>(value: T | T[]): string;
 /**
  * Get the truncated JSON string for a string or array of strings.
  *

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

@@ -8,6 +8,11 @@ export interface AnthropicAiOptions {
      * Enable or disable output recording.
      */
     recordOutputs?: boolean;
+    /**
+     * Enable or disable truncation of recorded input messages.
+     * Defaults to `true`.
+     */
+    enableTruncation?: boolean;
 }
 export type Message = {
     role: 'user' | 'assistant';

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

@@ -5,7 +5,7 @@ import { AnthropicAiResponse } from './types';
  * Set the messages and messages original length attributes.
  * Extracts system instructions before truncation.
  */
-export declare function setMessagesAttribute(span: Span, messages: unknown): void;
+export declare function setMessagesAttribute(span: Span, messages: unknown, enableTruncation: boolean): void;
 /**
  * Map an Anthropic API error type to a SpanStatusType value.
  * @see https://docs.anthropic.com/en/api/errors#error-shapes

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/google-genai/types.d.ts

@@ -8,6 +8,11 @@ export interface GoogleGenAIOptions {
      * Enable or disable output recording.
      */
     recordOutputs?: boolean;
+    /**
+     * Enable or disable truncation of recorded input messages.
+     * Defaults to `true`.
+     */
+    enableTruncation?: boolean;
 }
 /**
  * Google GenAI Content Part

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/langchain/types.d.ts

@@ -12,6 +12,11 @@ export interface LangChainOptions {
      * @default false (respects sendDefaultPii option)
      */
     recordOutputs?: boolean;
+    /**
+     * Enable or disable truncation of recorded input messages.
+     * Defaults to `true`.
+     */
+    enableTruncation?: boolean;
 }
 /**
  * LangChain Serialized type (compatible with @langchain/core)

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

@@ -36,7 +36,7 @@ export declare function normalizeLangChainMessages(messages: LangChainMessage[])
  * - When `recordInputs` is true, string prompts are wrapped into `{role:"user"}`
  *   messages to align with the chat schema used elsewhere.
  */
-export declare function extractLLMRequestAttributes(llm: LangChainSerialized, prompts: string[], recordInputs: boolean, invocationParams?: Record<string, unknown>, langSmithMetadata?: Record<string, unknown>): Record<string, SpanAttributeValue>;
+export declare function extractLLMRequestAttributes(llm: LangChainSerialized, prompts: string[], recordInputs: boolean, enableTruncation: boolean, invocationParams?: Record<string, unknown>, langSmithMetadata?: Record<string, unknown>): Record<string, SpanAttributeValue>;
 /**
  * Extracts attributes for ChatModel invocations (array-of-arrays of messages).
  *
@@ -46,7 +46,7 @@ export declare function extractLLMRequestAttributes(llm: LangChainSerialized, pr
  *   consistent `{ role, content }` array when `recordInputs` is true.
  * - Provider system value falls back to `serialized.id?.[2]`.
  */
-export declare function extractChatModelRequestAttributes(llm: LangChainSerialized, langChainMessages: LangChainMessage[][], recordInputs: boolean, invocationParams?: Record<string, unknown>, langSmithMetadata?: Record<string, unknown>): Record<string, SpanAttributeValue>;
+export declare function extractChatModelRequestAttributes(llm: LangChainSerialized, langChainMessages: LangChainMessage[][], recordInputs: boolean, enableTruncation: boolean, invocationParams?: Record<string, unknown>, langSmithMetadata?: Record<string, unknown>): Record<string, SpanAttributeValue>;
 /**
  * Extracts response-related attributes based on a `LangChainLLMResult`.
  *

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

@@ -7,6 +7,11 @@ export interface LangGraphOptions {
      * Enable or disable output recording.
      */
     recordOutputs?: boolean;
+    /**
+     * Enable or disable truncation of recorded input messages.
+     * Defaults to `true`.
+     */
+    enableTruncation?: boolean;
 }
 /**
  * LangGraph Tool definition from lc_kwargs

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

@@ -14,6 +14,11 @@ export interface OpenAiOptions {
      * Enable or disable output recording.
      */
     recordOutputs?: boolean;
+    /**
+     * Enable or disable truncation of recorded input messages.
+     * Defaults to `true`.
+     */
+    enableTruncation?: boolean;
 }
 export interface OpenAiClient {
     responses?: {

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/tracing/vercel-ai/constants.d.ts

@@ -1,8 +1,5 @@
 import { ToolCallSpanContext } from './types';
 export declare const toolCallSpanContextMap: Map<string, ToolCallSpanContext>;
-export declare const INVOKE_AGENT_OPS: Set<string>;
-export declare const GENERATE_CONTENT_OPS: Set<string>;
-export declare const EMBEDDINGS_OPS: Set<string>;
-export declare const RERANK_OPS: Set<string>;
-export declare const DO_SPAN_NAME_PREFIX: Record<string, string>;
+/** Maps Vercel AI span names to standardized OpenTelemetry operation names. */
+export declare const SPAN_TO_OPERATION_NAME: Map<string, string>;
 //# sourceMappingURL=constants.d.ts.map

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

@@ -44,9 +44,5 @@ export declare function convertUserInputToMessagesFormat(userInput: string): {
  * Generate a request.messages JSON array from the prompt field in the
  * invoke_agent op
  */
-export declare function requestMessagesFromPrompt(span: Span, attributes: SpanAttributes): void;
-/**
- * Maps a Vercel AI span name to the corresponding Sentry op.
- */
-export declare function getSpanOpFromName(name: string): string | undefined;
+export declare function requestMessagesFromPrompt(span: Span, attributes: SpanAttributes, enableTruncation: boolean): void;
 //# sourceMappingURL=utils.d.ts.map