@sentry/core 10.46.0 → 10.48.0

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

@@ -6,22 +6,27 @@
  */
 import { MCPServerInstance } from './types';
 /**
- * Wraps tool handlers to associate them with request spans
+ * Wraps tool handlers to associate them with request spans.
+ * Instruments both `tool` (legacy API) and `registerTool` (new API) if present.
  * @param serverInstance - MCP server instance
  */
 export declare function wrapToolHandlers(serverInstance: MCPServerInstance): void;
 /**
- * Wraps resource handlers to associate them with request spans
+ * Wraps resource handlers to associate them with request spans.
+ * Instruments both `resource` (legacy API) and `registerResource` (new API) if present.
  * @param serverInstance - MCP server instance
  */
 export declare function wrapResourceHandlers(serverInstance: MCPServerInstance): void;
 /**
- * Wraps prompt handlers to associate them with request spans
+ * Wraps prompt handlers to associate them with request spans.
+ * Instruments both `prompt` (legacy API) and `registerPrompt` (new API) if present.
  * @param serverInstance - MCP server instance
  */
 export declare function wrapPromptHandlers(serverInstance: MCPServerInstance): void;
 /**
- * Wraps all MCP handler types (tool, resource, prompt) for span correlation
+ * Wraps all MCP handler types for span correlation.
+ * Supports both the legacy API (`tool`, `resource`, `prompt`) and the newer API
+ * (`registerTool`, `registerResource`, `registerPrompt`), instrumenting whichever methods are present.
  * @param serverInstance - MCP server instance
  */
 export declare function wrapAllMCPHandlers(serverInstance: MCPServerInstance): void;

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

@@ -2,7 +2,8 @@ import { McpServerWrapperOptions } from './types';
 /**
  * Wraps a MCP Server instance from the `@modelcontextprotocol/sdk` package with Sentry instrumentation.
  *
- * Compatible with versions `^1.9.0` of the `@modelcontextprotocol/sdk` package.
+ * Compatible with versions `^1.9.0` of the `@modelcontextprotocol/sdk` package (legacy `tool`/`resource`/`prompt` API)
+ * and versions that expose the newer `registerTool`/`registerResource`/`registerPrompt` API (introduced in 1.x, sole API in 2.x).
  * Automatically instruments transport methods and handler functions for comprehensive monitoring.
  *
  * @example

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,36 +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";
-/**
- * OpenAI API operations following OpenTelemetry semantic conventions
- * @see https://opentelemetry.io/docs/specs/semconv/gen-ai/gen-ai-spans/#llm-request-spans
- */
-export declare const OPENAI_OPERATIONS: {
-    readonly CHAT: "chat";
-    readonly EMBEDDINGS: "embeddings";
-};
-/**
- * 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

@@ -4,20 +4,28 @@ export interface AIRecordingOptions {
     recordOutputs?: boolean;
 }
 /**
- * Resolves AI recording options by falling back to the client's `sendDefaultPii` setting.
- * Precedence: explicit option > sendDefaultPii > false
+ * A method registry entry describes a single instrumented method:
+ * which gen_ai operation it maps to and whether it is intrinsically streaming.
  */
-export declare function resolveAIRecordingOptions<T extends AIRecordingOptions>(options?: T): T & Required<AIRecordingOptions>;
+export interface InstrumentedMethodEntry {
+    /** 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 AI method paths to OpenTelemetry semantic convention operation names
- * @see https://opentelemetry.io/docs/specs/semconv/gen-ai/gen-ai-spans/#llm-request-spans
+ * Maps method paths to their registry entries.
+ * Used by proxy-based AI client instrumentations to determine which methods
+ * to instrument, what operation name to use, and whether they stream.
  */
-export declare function getFinalOperationName(methodPath: string): string;
+export type InstrumentedMethodRegistry = Record<string, InstrumentedMethodEntry>;
 /**
- * Get the span operation for AI methods
- * Following Sentry's convention: "gen_ai.{operation_name}"
+ * Resolves AI recording options by falling back to the client's `sendDefaultPii` setting.
+ * Precedence: explicit option > sendDefaultPii > false
  */
-export declare function getSpanOperation(methodPath: string): string;
+export declare function resolveAIRecordingOptions<T extends AIRecordingOptions>(options?: T): T & Required<AIRecordingOptions>;
 /**
  * Build method path from current traversal
  */
@@ -31,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/anthropic-ai/constants.d.ts

@@ -1,11 +1,26 @@
 export declare const ANTHROPIC_AI_INTEGRATION_NAME = "Anthropic_AI";
-export declare const ANTHROPIC_AI_INSTRUMENTED_METHODS: readonly [
-    "messages.create",
-    "messages.stream",
-    "messages.countTokens",
-    "models.get",
-    "completions.create",
-    "models.retrieve",
-    "beta.messages.create"
-];
+export declare const ANTHROPIC_METHOD_REGISTRY: {
+    readonly 'messages.create': {
+        readonly operation: "chat";
+    };
+    readonly 'messages.stream': {
+        readonly operation: "chat";
+        readonly streaming: true;
+    };
+    readonly 'messages.countTokens': {
+        readonly operation: "chat";
+    };
+    readonly 'models.get': {
+        readonly operation: "models";
+    };
+    readonly 'completions.create': {
+        readonly operation: "chat";
+    };
+    readonly 'models.retrieve': {
+        readonly operation: "models";
+    };
+    readonly 'beta.messages.create': {
+        readonly operation: "chat";
+    };
+};
 //# sourceMappingURL=constants.d.ts.map

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

@@ -1,4 +1,4 @@
-import { ANTHROPIC_AI_INSTRUMENTED_METHODS } from './constants';
+import { ANTHROPIC_METHOD_REGISTRY } from './constants';
 export interface AnthropicAiOptions {
     /**
      * Enable or disable input recording.
@@ -74,7 +74,10 @@ export interface AnthropicAiIntegration {
     name: string;
     options: AnthropicAiOptions;
 }
-export type AnthropicAiInstrumentedMethod = (typeof ANTHROPIC_AI_INSTRUMENTED_METHODS)[number];
+/**
+ * @deprecated This type is no longer used and will be removed in the next major version.
+ */
+export type AnthropicAiInstrumentedMethod = keyof typeof ANTHROPIC_METHOD_REGISTRY;
 /**
  * Message type for Anthropic AI
  */

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

@@ -1,10 +1,6 @@
 import { Span } from '../../types-hoist/span';
 import { SpanStatusType } from '../../types-hoist/spanStatus';
-import { AnthropicAiInstrumentedMethod, AnthropicAiResponse } from './types';
-/**
- * Check if a method path should be instrumented
- */
-export declare function shouldInstrument(methodPath: string): methodPath is AnthropicAiInstrumentedMethod;
+import { AnthropicAiResponse } from './types';
 /**
  * Set the messages and messages original length attributes.
  * Extracts system instructions before truncation.

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

@@ -1,12 +1,25 @@
 export declare const GOOGLE_GENAI_INTEGRATION_NAME = "Google_GenAI";
-export declare const GOOGLE_GENAI_INSTRUMENTED_METHODS: readonly [
-    "models.generateContent",
-    "models.generateContentStream",
-    "chats.create",
-    "sendMessage",
-    "sendMessageStream"
-];
+export declare const GOOGLE_GENAI_METHOD_REGISTRY: {
+    readonly 'models.generateContent': {
+        readonly operation: "generate_content";
+    };
+    readonly 'models.generateContentStream': {
+        readonly operation: "generate_content";
+        readonly streaming: true;
+    };
+    readonly 'models.embedContent': {
+        readonly operation: "embeddings";
+    };
+    readonly 'chats.create': {
+        readonly proxyResultPath: "chat";
+    };
+    readonly 'chat.sendMessage': {
+        readonly operation: "chat";
+    };
+    readonly 'chat.sendMessageStream': {
+        readonly operation: "chat";
+        readonly streaming: true;
+    };
+};
 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

@@ -1,4 +1,4 @@
-import { GOOGLE_GENAI_INSTRUMENTED_METHODS } from './constants';
+import { GOOGLE_GENAI_METHOD_REGISTRY } from './constants';
 export interface GoogleGenAIOptions {
     /**
      * Enable or disable input recording.
@@ -152,6 +152,7 @@ export interface GoogleGenAIClient {
     models: {
         generateContent: (...args: unknown[]) => Promise<GenerateContentResponse>;
         generateContentStream: (...args: unknown[]) => Promise<AsyncGenerator<GenerateContentResponse, any, unknown>>;
+        embedContent: (...args: unknown[]) => Promise<unknown>;
     };
     chats: {
         create: (...args: unknown[]) => GoogleGenAIChat;
@@ -164,7 +165,10 @@ export interface GoogleGenAIChat {
     sendMessage: (...args: unknown[]) => Promise<GenerateContentResponse>;
     sendMessageStream: (...args: unknown[]) => Promise<AsyncGenerator<GenerateContentResponse, any, unknown>>;
 }
-export type GoogleGenAIIstrumentedMethod = (typeof GOOGLE_GENAI_INSTRUMENTED_METHODS)[number];
+/**
+ * @deprecated This type is no longer used and will be removed in the next major version.
+ */
+export type GoogleGenAIIstrumentedMethod = keyof typeof GOOGLE_GENAI_METHOD_REGISTRY;
 export type GoogleGenAIResponse = GenerateContentResponse;
 export {};
 //# sourceMappingURL=types.d.ts.map

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

@@ -1,12 +1,3 @@
-import { GoogleGenAIIstrumentedMethod } from './types';
-/**
- * Check if a method path should be instrumented
- */
-export declare function shouldInstrument(methodPath: string): methodPath is GoogleGenAIIstrumentedMethod;
-/**
- * Check if a method is a streaming method
- */
-export declare function isStreamingMethod(methodPath: string): boolean;
 export type ContentListUnion = Content | Content[] | PartListUnion;
 export type ContentUnion = Content | PartUnion[] | PartUnion;
 export type Content = {

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

@@ -1,10 +1,18 @@
 export declare const OPENAI_INTEGRATION_NAME = "OpenAI";
-export declare const INSTRUMENTED_METHODS: readonly [
-    "responses.create",
-    "chat.completions.create",
-    "embeddings.create",
-    "conversations.create"
-];
+export declare const OPENAI_METHOD_REGISTRY: {
+    readonly 'responses.create': {
+        readonly operation: "chat";
+    };
+    readonly 'chat.completions.create': {
+        readonly operation: "chat";
+    };
+    readonly 'embeddings.create': {
+        readonly operation: "embeddings";
+    };
+    readonly 'conversations.create': {
+        readonly operation: "chat";
+    };
+};
 export declare const RESPONSES_TOOL_CALL_EVENT_TYPES: readonly [
     "response.output_item.added",
     "response.function_call_arguments.delta",

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

@@ -1,4 +1,4 @@
-import { INSTRUMENTED_METHODS } from './constants';
+import { OPENAI_METHOD_REGISTRY } from './constants';
 /**
  * Attribute values may be any non-nullish primitive value except an object.
  *
@@ -313,6 +313,9 @@ export interface OpenAiIntegration {
     name: string;
     options: OpenAiOptions;
 }
-export type InstrumentedMethod = (typeof INSTRUMENTED_METHODS)[number];
+/**
+ * @deprecated This type is no longer used and will be removed in the next major version.
+ */
+export type InstrumentedMethod = keyof typeof OPENAI_METHOD_REGISTRY;
 export {};
 //# sourceMappingURL=types.d.ts.map

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

@@ -1,36 +1,5 @@
 import { Span } from '../../types-hoist/span';
-import { ChatCompletionChunk, InstrumentedMethod, OpenAiChatCompletionObject, OpenAIConversationObject, OpenAICreateEmbeddingsObject, OpenAIResponseObject, ResponseStreamingEvent } from './types';
-/**
- * Maps OpenAI method paths to OpenTelemetry semantic convention operation names
- * @see https://opentelemetry.io/docs/specs/semconv/gen-ai/gen-ai-spans/#llm-request-spans
- */
-export declare function getOperationName(methodPath: string): string;
-/**
- * Get the span operation for OpenAI methods
- * Following Sentry's convention: "gen_ai.{operation_name}"
- */
-export declare function getSpanOperation(methodPath: string): string;
-/**
- * Check if a method path should be instrumented
- */
-export declare function shouldInstrument(methodPath: string): methodPath is InstrumentedMethod;
-/**
- * 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
  */
@@ -40,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