{"version":3,"sources":["webpack:///../../../src/utils/isBrowser.ts","webpack:///../../../src/utils/lru.ts","webpack:///../../../src/utils/node-stack-trace.ts","webpack:///../../../src/utils/object.ts","webpack:///../../../src/utils/ipAddress.ts","webpack:///../../../src/utils/misc.ts","webpack:///../../../../src/utils/openai/index.ts","webpack:///../../../src/utils/meta.ts","webpack:///../../../../src/utils/openai/constants.ts","webpack:///../../../src/utils/isSentryRequestUrl.ts","webpack:///../../../src/utils/node.ts","webpack:///../../../src/utils/path.ts","webpack:///../../../../src/utils/openai/streaming.ts","webpack:///../../../src/utils/is.ts","webpack:///../../../src/utils/parameterize.ts","webpack:///../../../src/utils/normalize.ts","webpack:///../../../../src/utils/openai/utils.ts","webpack:///../../../src/utils/merge.ts","webpack:///../../../src/utils/parseSampleRate.ts"],"names":["isBrowser","window","isNodeEnv","isElectronNodeRenderer","process","GLOBAL_OBJ","type","LRUMap","constructor","_maxSize","_cache","Map","size","get","key","value","undefined","delete","set","keys","next","remove","clear","Array","from","values","forEach","push","filenameIsInApp","filename","isNative","arguments","length","isInternal","startsWith","match","includes","node","getModule","FILENAME_MATCH","FULL_MATCH","DATA_URI_MATCH","line","dataUriMatch","concat","function","lineMatch","_lineMatch$","_filename","object","method","functionName","typeName","methodName","methodStart","lastIndexOf","slice","objectEnd","indexOf","UNKNOWN_FUNCTION","decodeURI","module","lineno","_parseIntOrUndefined","colno","in_app","nodeStackLineParser","input","parseInt","fill","source","name","replacementFactory","original","wrapped","markFunctionWrapped","_unused","DEBUG_BUILD","debug","log","addNonEnumerableProperty","obj","Object","defineProperty","writable","configurable","_unused2","proto","prototype","_unused3","getOriginalFunction","func","__sentry_original__","convertToPlainObject","isError","_objectSpread","message","stack","getOwnProperties","isEvent","newObj","target","serializeEventTarget","currentTarget","CustomEvent","isInstanceOf","detail","isElement","htmlTreeAsString","toString","call","_unused4","extractedProps","property","hasOwnProperty","extractExceptionKeysForMessage","exception","maxLength","sort","firstKey","truncate","includedKeys","serialized","join","dropUndefinedKeys","inputValue","memoizationMap","_dropUndefinedKeys","memoVal","isArray","returnValue","isPojo","val","objectify","wat","objectified","String","isPrimitive","addAutoIpAddressToUser","objWithMaybeUser","_objWithMaybeUser$use","user","ip_address","addAutoIpAddressToSession","session","_session$attrs","attrs","ipAddress","getCrypto","gbl","crypto","msCrypto","uuid4","getRandomByte","Math","random","randomUUID","replace","getRandomValues","typedArray","Uint8Array","c","getFirstException","event","_event$exception","getEventDescription","event_id","eventId","firstException","addExceptionTypeValue","addExceptionMechanism","newMechanism","defaultMechanism","handled","currentMechanism","mechanism","mergedData","data","SEMVER_REGEXP","_parseInt","parseSemver","major","minor","patch","buildmetadata","isNaN","prerelease","addContextToFrame","lines","frame","linesOfContext","maxLines","sourceLine","max","min","pre_context","map","snipLine","lineIndex","context_line","post_context","checkOrSetAlreadyCaught","isAlreadyCaptured","__sentry_captured__","extractRequestAttributes","args","methodPath","attributes","GEN_AI_SYSTEM_ATTRIBUTE","GEN_AI_OPERATION_NAME_ATTRIBUTE","getOperationName","SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN","params","tools","hasWebSearchOptions","web_search_options","webSearchOptions","availableTools","GEN_AI_REQUEST_AVAILABLE_TOOLS_ATTRIBUTE","JSON","stringify","_params$model","GEN_AI_REQUEST_MODEL_ATTRIBUTE","model","GEN_AI_REQUEST_TEMPERATURE_ATTRIBUTE","temperature","GEN_AI_REQUEST_TOP_P_ATTRIBUTE","top_p","GEN_AI_REQUEST_FREQUENCY_PENALTY_ATTRIBUTE","frequency_penalty","GEN_AI_REQUEST_PRESENCE_PENALTY_ATTRIBUTE","presence_penalty","GEN_AI_REQUEST_STREAM_ATTRIBUTE","stream","addChatCompletionAttributes","span","response","recordOutputs","setCommonResponseAttributes","id","created","usage","setTokenUsageAttributes","prompt_tokens","completion_tokens","total_tokens","choices","finishReasons","choice","finish_reason","filter","reason","setAttributes","GEN_AI_RESPONSE_FINISH_REASONS_ATTRIBUTE","toolCalls","_choice$message","tool_calls","calls","flat","GEN_AI_RESPONSE_TOOL_CALLS_ATTRIBUTE","addResponsesApiAttributes","created_at","status","input_tokens","output_tokens","responseWithOutput","output","functionCalls","item","addResponseAttributes","result","isChatCompletionResponse","_response$choices","responseTexts","_choice$message2","content","GEN_AI_RESPONSE_TEXT_ATTRIBUTE","isResponsesApiResponse","output_text","addRequestAttributes","GEN_AI_REQUEST_MESSAGES_ATTRIBUTE","messages","getOptionsFromIntegration","_integration$options$","_integration$options","_integration$options$2","_integration$options2","scope","getCurrentScope","client","getClient","integration","getIntegrationByName","OPENAI_INTEGRATION_NAME","shouldRecordInputsAndOutputs","Boolean","getOptions","sendDefaultPii","recordInputs","options","instrumentMethod","originalMethod","context","instrumentedMethod","_len","_key","finalOptions","requestAttributes","operationName","isStreamRequested","startSpanManual","op","getSpanOperation","_finalOptions$recordO","apply","instrumentStream","error","setStatus","code","SPAN_STATUS_ERROR","captureException","end","startSpan","createDeepProxy","currentPath","Proxy","prop","buildMethodPath","shouldInstrument","bind","instrumentOpenAiClient","getTraceMetaTags","traceData","entries","getTraceData","_ref","INSTRUMENTED_METHODS","RESPONSES_TOOL_CALL_EVENT_TYPES","RESPONSE_EVENT_TYPES","isSentryRequestUrl","url","dsn","getDsn","tunnel","checkDsn","checkTunnel","removeTrailingSlash","urlParts","parseStringToURLObject","isURLObjectRelative","host","test","search","str","isBrowserBundle","dynamicRequire","mod","request","require","loadModule","moduleName","existingModule","cwd","normalizeArray","parts","allowAboveRoot","up","i","last","splice","unshift","splitPathRe","splitPath","truncated","exec","resolve","resolvedPath","resolvedAbsolute","path","charAt","split","p","trim","arr","start","relative","to","fromParts","toParts","samePartsLength","outputParts","normalizePath","isPathAbsolute","isAbsolute","trailingSlash","normalizedPath","dirname","root","dir","basename","ext","f","processChatCompletionToolCalls","state","toolCall","index","chatCompletionToolCalls","existingToolCall","processChatCompletionChunk","chunk","_chunk$id","_chunk$model","_chunk$created","responseId","responseModel","responseTimestamp","promptTokens","completionTokens","totalTokens","_chunk$choices","_choice$delta","_choice$delta2","delta","processResponsesApiEvent","streamEvent","eventTypes","Error","responsesApiToolCalls","_response$id","_response$model","_response$created_at","_x","_x2","_x3","_instrumentStream","_wrapAsyncGenerator","_iteratorAbruptCompletion","_didIteratorError","_iteratorError","_iterator","_asyncIterator","_step","_awaitAsyncGenerator","done","isChatCompletionChunk","isResponsesApiStreamEvent","err","return","GEN_AI_RESPONSE_STREAMING_ATTRIBUTE","chatCompletionToolCallsArray","allToolCalls","objectToString","isBuiltin","className","isErrorEvent","isDOMError","isDOMException","isString","isParameterizedString","isPlainObject","Event","Element","isRegExp","isThenable","then","isSyntheticEvent","base","isVueViewModel","__isVue","_isVue","isRequest","Request","parameterize","strings","formatted","raw","__sentry_template_string__","__sentry_template_values__","fmt","normalize","depth","maxProperties","Infinity","visit","ERROR","normalizeToSize","maxSize","normalized","jsonSize","memo","memoBuilder","memoize","unmemoize","Number","isFinite","stringified","stringifyValue","remainingDepth","valueWithToJSON","toJSON","jsonValue","numAdded","visitable","visitKey","visitValue","_events","global","document","getFunctionName","objName","getConstructorName","getPrototypeOf","utf8Length","encodeURI","normalizeUrlToBase","basePath","escapedBase","newUrl","RegExp","inner","WeakSet","has","add","OPENAI_OPERATIONS","CHAT","RESPONSES","pop","OPENAI_USAGE_PROMPT_TOKENS_ATTRIBUTE","GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE","OPENAI_USAGE_COMPLETION_TOKENS_ATTRIBUTE","GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE","GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE","timestamp","OPENAI_RESPONSE_ID_ATTRIBUTE","GEN_AI_RESPONSE_ID_ATTRIBUTE","OPENAI_RESPONSE_MODEL_ATTRIBUTE","GEN_AI_RESPONSE_MODEL_ATTRIBUTE","OPENAI_RESPONSE_TIMESTAMP_ATTRIBUTE","Date","toISOString","merge","initialObj","mergeObj","levels","parseSampleRate","sampleRate","rate","parseFloat"],"mappings":"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","file":"vendors~ba8fd8f4.71ff2c0ad52d6c797d15.chunk.js","sourcesContent":["import { isNodeEnv } from './node';\nimport { GLOBAL_OBJ } from './worldwide';\n\n/**\n * Returns true if we are in the browser.\n */\nexport function isBrowser(): boolean {\n // eslint-disable-next-line no-restricted-globals\n return typeof window !== 'undefined' && (!isNodeEnv() || isElectronNodeRenderer());\n}\n\ntype ElectronProcess = { type?: string };\n\n// Electron renderers with nodeIntegration enabled are detected as Node.js so we specifically test for them\nfunction isElectronNodeRenderer(): boolean {\n const process = (GLOBAL_OBJ as typeof GLOBAL_OBJ & { process?: ElectronProcess }).process;\n return process?.type === 'renderer';\n}\n","/** A simple Least Recently Used map */\nexport class LRUMap {\n private readonly _cache: Map;\n\n public constructor(private readonly _maxSize: number) {\n this._cache = new Map();\n }\n\n /** Get the current size of the cache */\n public get size(): number {\n return this._cache.size;\n }\n\n /** Get an entry or undefined if it was not in the cache. Re-inserts to update the recently used order */\n public get(key: K): V | undefined {\n const value = this._cache.get(key);\n if (value === undefined) {\n return undefined;\n }\n // Remove and re-insert to update the order\n this._cache.delete(key);\n this._cache.set(key, value);\n return value;\n }\n\n /** Insert an entry and evict an older entry if we've reached maxSize */\n public set(key: K, value: V): void {\n if (this._cache.size >= this._maxSize) {\n // keys() returns an iterator in insertion order so keys().next() gives us the oldest key\n this._cache.delete(this._cache.keys().next().value);\n }\n this._cache.set(key, value);\n }\n\n /** Remove an entry and return the entry if it was in the cache */\n public remove(key: K): V | undefined {\n const value = this._cache.get(key);\n if (value) {\n this._cache.delete(key);\n }\n return value;\n }\n\n /** Clear all entries */\n public clear(): void {\n this._cache.clear();\n }\n\n /** Get all the keys */\n public keys(): Array {\n return Array.from(this._cache.keys());\n }\n\n /** Get all the values */\n public values(): Array {\n const values: V[] = [];\n this._cache.forEach(value => values.push(value));\n return values;\n }\n}\n","// This code was originally forked from https://github.com/felixge/node-stack-trace\n// Since then it has been highly modified to fit our needs.\n\n// Copyright (c) 2011 Felix Geisendörfer (felix@debuggable.com)//\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions://\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.//\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport type { StackLineParser, StackLineParserFn } from '../types-hoist/stacktrace';\nimport { UNKNOWN_FUNCTION } from './stacktrace';\n\nexport type GetModuleFn = (filename: string | undefined) => string | undefined;\n\n/**\n * Does this filename look like it's part of the app code?\n */\nexport function filenameIsInApp(filename: string, isNative: boolean = false): boolean {\n const isInternal =\n isNative ||\n (filename &&\n // It's not internal if it's an absolute linux path\n !filename.startsWith('/') &&\n // It's not internal if it's an absolute windows path\n !filename.match(/^[A-Z]:/) &&\n // It's not internal if the path is starting with a dot\n !filename.startsWith('.') &&\n // It's not internal if the frame has a protocol. In node, this is usually the case if the file got pre-processed with a bundler like webpack\n !filename.match(/^[a-zA-Z]([a-zA-Z0-9.\\-+])*:\\/\\//)); // Schema from: https://stackoverflow.com/a/3641782\n\n // in_app is all that's not an internal Node function or a module within node_modules\n // note that isNative appears to return true even for node core libraries\n // see https://github.com/getsentry/raven-node/issues/176\n\n return !isInternal && filename !== undefined && !filename.includes('node_modules/');\n}\n\n/** Node Stack line parser */\nexport function node(getModule?: GetModuleFn): StackLineParserFn {\n const FILENAME_MATCH = /^\\s*[-]{4,}$/;\n const FULL_MATCH = /at (?:async )?(?:(.+?)\\s+\\()?(?:(.+):(\\d+):(\\d+)?|([^)]+))\\)?/;\n const DATA_URI_MATCH = /at (?:async )?(.+?) \\(data:(.*?),/;\n\n // eslint-disable-next-line complexity\n return (line: string) => {\n const dataUriMatch = line.match(DATA_URI_MATCH);\n if (dataUriMatch) {\n return {\n filename: ``,\n function: dataUriMatch[1],\n };\n }\n\n const lineMatch = line.match(FULL_MATCH);\n\n if (lineMatch) {\n let object: string | undefined;\n let method: string | undefined;\n let functionName: string | undefined;\n let typeName: string | undefined;\n let methodName: string | undefined;\n\n if (lineMatch[1]) {\n functionName = lineMatch[1];\n\n let methodStart = functionName.lastIndexOf('.');\n if (functionName[methodStart - 1] === '.') {\n methodStart--;\n }\n\n if (methodStart > 0) {\n object = functionName.slice(0, methodStart);\n method = functionName.slice(methodStart + 1);\n const objectEnd = object.indexOf('.Module');\n if (objectEnd > 0) {\n functionName = functionName.slice(objectEnd + 1);\n object = object.slice(0, objectEnd);\n }\n }\n typeName = undefined;\n }\n\n if (method) {\n typeName = object;\n methodName = method;\n }\n\n if (method === '') {\n methodName = undefined;\n functionName = undefined;\n }\n\n if (functionName === undefined) {\n methodName = methodName || UNKNOWN_FUNCTION;\n functionName = typeName ? `${typeName}.${methodName}` : methodName;\n }\n\n let filename = lineMatch[2]?.startsWith('file://') ? lineMatch[2].slice(7) : lineMatch[2];\n const isNative = lineMatch[5] === 'native';\n\n // If it's a Windows path, trim the leading slash so that `/C:/foo` becomes `C:/foo`\n if (filename?.match(/\\/[A-Z]:/)) {\n filename = filename.slice(1);\n }\n\n if (!filename && lineMatch[5] && !isNative) {\n filename = lineMatch[5];\n }\n\n return {\n filename: filename ? decodeURI(filename) : undefined,\n module: getModule ? getModule(filename) : undefined,\n function: functionName,\n lineno: _parseIntOrUndefined(lineMatch[3]),\n colno: _parseIntOrUndefined(lineMatch[4]),\n in_app: filenameIsInApp(filename || '', isNative),\n };\n }\n\n if (line.match(FILENAME_MATCH)) {\n return {\n filename: line,\n };\n }\n\n return undefined;\n };\n}\n\n/**\n * Node.js stack line parser\n *\n * This is in @sentry/core so it can be used from the Electron SDK in the browser for when `nodeIntegration == true`.\n * This allows it to be used without referencing or importing any node specific code which causes bundlers to complain\n */\nexport function nodeStackLineParser(getModule?: GetModuleFn): StackLineParser {\n return [90, node(getModule)];\n}\n\nfunction _parseIntOrUndefined(input: string | undefined): number | undefined {\n return parseInt(input || '', 10) || undefined;\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { DEBUG_BUILD } from '../debug-build';\nimport type { WrappedFunction } from '../types-hoist/wrappedfunction';\nimport { htmlTreeAsString } from './browser';\nimport { debug } from './debug-logger';\nimport { isElement, isError, isEvent, isInstanceOf, isPrimitive } from './is';\nimport { truncate } from './string';\n\n/**\n * Replace a method in an object with a wrapped version of itself.\n *\n * If the method on the passed object is not a function, the wrapper will not be applied.\n *\n * @param source An object that contains a method to be wrapped.\n * @param name The name of the method to be wrapped.\n * @param replacementFactory A higher-order function that takes the original version of the given method and returns a\n * wrapped version. Note: The function returned by `replacementFactory` needs to be a non-arrow function, in order to\n * preserve the correct value of `this`, and the original method must be called using `origMethod.call(this, )` or `origMethod.apply(this, [])` (rather than being called directly), again to preserve `this`.\n * @returns void\n */\nexport function fill(source: { [key: string]: any }, name: string, replacementFactory: (...args: any[]) => any): void {\n if (!(name in source)) {\n return;\n }\n\n // explicitly casting to unknown because we don't know the type of the method initially at all\n const original = source[name] as unknown;\n\n if (typeof original !== 'function') {\n return;\n }\n\n const wrapped = replacementFactory(original) as WrappedFunction;\n\n // Make sure it's a function first, as we need to attach an empty prototype for `defineProperties` to work\n // otherwise it'll throw \"TypeError: Object.defineProperties called on non-object\"\n if (typeof wrapped === 'function') {\n markFunctionWrapped(wrapped, original);\n }\n\n try {\n source[name] = wrapped;\n } catch {\n DEBUG_BUILD && debug.log(`Failed to replace method \"${name}\" in object`, source);\n }\n}\n\n/**\n * Defines a non-enumerable property on the given object.\n *\n * @param obj The object on which to set the property\n * @param name The name of the property to be set\n * @param value The value to which to set the property\n */\nexport function addNonEnumerableProperty(obj: object, name: string, value: unknown): void {\n try {\n Object.defineProperty(obj, name, {\n // enumerable: false, // the default, so we can save on bundle size by not explicitly setting it\n value: value,\n writable: true,\n configurable: true,\n });\n } catch {\n DEBUG_BUILD && debug.log(`Failed to add non-enumerable property \"${name}\" to object`, obj);\n }\n}\n\n/**\n * Remembers the original function on the wrapped function and\n * patches up the prototype.\n *\n * @param wrapped the wrapper function\n * @param original the original function that gets wrapped\n */\nexport function markFunctionWrapped(wrapped: WrappedFunction, original: WrappedFunction): void {\n try {\n const proto = original.prototype || {};\n wrapped.prototype = original.prototype = proto;\n addNonEnumerableProperty(wrapped, '__sentry_original__', original);\n } catch {} // eslint-disable-line no-empty\n}\n\n/**\n * This extracts the original function if available. See\n * `markFunctionWrapped` for more information.\n *\n * @param func the function to unwrap\n * @returns the unwrapped version of the function if available.\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nexport function getOriginalFunction(func: WrappedFunction): T | undefined {\n return func.__sentry_original__;\n}\n\n/**\n * Transforms any `Error` or `Event` into a plain object with all of their enumerable properties, and some of their\n * non-enumerable properties attached.\n *\n * @param value Initial source that we have to transform in order for it to be usable by the serializer\n * @returns An Event or Error turned into an object - or the value argument itself, when value is neither an Event nor\n * an Error.\n */\nexport function convertToPlainObject(value: V):\n | {\n [ownProps: string]: unknown;\n type: string;\n target: string;\n currentTarget: string;\n detail?: unknown;\n }\n | {\n [ownProps: string]: unknown;\n message: string;\n name: string;\n stack?: string;\n }\n | V {\n if (isError(value)) {\n return {\n message: value.message,\n name: value.name,\n stack: value.stack,\n ...getOwnProperties(value),\n };\n } else if (isEvent(value)) {\n const newObj: {\n [ownProps: string]: unknown;\n type: string;\n target: string;\n currentTarget: string;\n detail?: unknown;\n } = {\n type: value.type,\n target: serializeEventTarget(value.target),\n currentTarget: serializeEventTarget(value.currentTarget),\n ...getOwnProperties(value),\n };\n\n if (typeof CustomEvent !== 'undefined' && isInstanceOf(value, CustomEvent)) {\n newObj.detail = value.detail;\n }\n\n return newObj;\n } else {\n return value;\n }\n}\n\n/** Creates a string representation of the target of an `Event` object */\nfunction serializeEventTarget(target: unknown): string {\n try {\n return isElement(target) ? htmlTreeAsString(target) : Object.prototype.toString.call(target);\n } catch {\n return '';\n }\n}\n\n/** Filters out all but an object's own properties */\nfunction getOwnProperties(obj: unknown): { [key: string]: unknown } {\n if (typeof obj === 'object' && obj !== null) {\n const extractedProps: { [key: string]: unknown } = {};\n for (const property in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, property)) {\n extractedProps[property] = (obj as Record)[property];\n }\n }\n return extractedProps;\n } else {\n return {};\n }\n}\n\n/**\n * Given any captured exception, extract its keys and create a sorted\n * and truncated list that will be used inside the event message.\n * eg. `Non-error exception captured with keys: foo, bar, baz`\n */\nexport function extractExceptionKeysForMessage(exception: Record, maxLength: number = 40): string {\n const keys = Object.keys(convertToPlainObject(exception));\n keys.sort();\n\n const firstKey = keys[0];\n\n if (!firstKey) {\n return '[object has no keys]';\n }\n\n if (firstKey.length >= maxLength) {\n return truncate(firstKey, maxLength);\n }\n\n for (let includedKeys = keys.length; includedKeys > 0; includedKeys--) {\n const serialized = keys.slice(0, includedKeys).join(', ');\n if (serialized.length > maxLength) {\n continue;\n }\n if (includedKeys === keys.length) {\n return serialized;\n }\n return truncate(serialized, maxLength);\n }\n\n return '';\n}\n\n/**\n * Given any object, return a new object having removed all fields whose value was `undefined`.\n * Works recursively on objects and arrays.\n *\n * Attention: This function keeps circular references in the returned object.\n *\n * @deprecated This function is no longer used by the SDK and will be removed in a future major version.\n */\nexport function dropUndefinedKeys(inputValue: T): T {\n // This map keeps track of what already visited nodes map to.\n // Our Set - based memoBuilder doesn't work here because we want to the output object to have the same circular\n // references as the input object.\n const memoizationMap = new Map();\n\n // This function just proxies `_dropUndefinedKeys` to keep the `memoBuilder` out of this function's API\n return _dropUndefinedKeys(inputValue, memoizationMap);\n}\n\nfunction _dropUndefinedKeys(inputValue: T, memoizationMap: Map): T {\n // Early return for primitive values\n if (inputValue === null || typeof inputValue !== 'object') {\n return inputValue;\n }\n\n // Check memo map first for all object types\n const memoVal = memoizationMap.get(inputValue);\n if (memoVal !== undefined) {\n return memoVal as T;\n }\n\n // handle arrays\n if (Array.isArray(inputValue)) {\n const returnValue: unknown[] = [];\n // Store mapping to handle circular references\n memoizationMap.set(inputValue, returnValue);\n\n inputValue.forEach(value => {\n returnValue.push(_dropUndefinedKeys(value, memoizationMap));\n });\n\n return returnValue as unknown as T;\n }\n\n if (isPojo(inputValue)) {\n const returnValue: { [key: string]: unknown } = {};\n // Store mapping to handle circular references\n memoizationMap.set(inputValue, returnValue);\n\n const keys = Object.keys(inputValue);\n\n keys.forEach(key => {\n const val = inputValue[key];\n if (val !== undefined) {\n returnValue[key] = _dropUndefinedKeys(val, memoizationMap);\n }\n });\n\n return returnValue as T;\n }\n\n // For other object types, return as is\n return inputValue;\n}\n\nfunction isPojo(input: unknown): input is Record {\n // Plain objects have Object as constructor or no constructor\n const constructor = (input as object).constructor;\n return constructor === Object || constructor === undefined;\n}\n\n/**\n * Ensure that something is an object.\n *\n * Turns `undefined` and `null` into `String`s and all other primitives into instances of their respective wrapper\n * classes (String, Boolean, Number, etc.). Acts as the identity function on non-primitives.\n *\n * @param wat The subject of the objectification\n * @returns A version of `wat` which can safely be used with `Object` class methods\n */\nexport function objectify(wat: unknown): typeof Object {\n let objectified;\n switch (true) {\n // this will catch both undefined and null\n case wat == undefined:\n objectified = new String(wat);\n break;\n\n // Though symbols and bigints do have wrapper classes (`Symbol` and `BigInt`, respectively), for whatever reason\n // those classes don't have constructors which can be used with the `new` keyword. We therefore need to cast each as\n // an object in order to wrap it.\n case typeof wat === 'symbol' || typeof wat === 'bigint':\n objectified = Object(wat);\n break;\n\n // this will catch the remaining primitives: `String`, `Number`, and `Boolean`\n case isPrimitive(wat):\n // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n objectified = new (wat as any).constructor(wat);\n break;\n\n // by process of elimination, at this point we know that `wat` must already be an object\n default:\n objectified = wat;\n break;\n }\n return objectified;\n}\n","import type { Session, SessionAggregates } from '../types-hoist/session';\nimport type { User } from '../types-hoist/user';\n\n// By default, we want to infer the IP address, unless this is explicitly set to `null`\n// We do this after all other processing is done\n// If `ip_address` is explicitly set to `null` or a value, we leave it as is\n\n/**\n * @internal\n * @deprecated -- set ip inferral via via SDK metadata options on client instead.\n */\nexport function addAutoIpAddressToUser(objWithMaybeUser: { user?: User | null }): void {\n if (objWithMaybeUser.user?.ip_address === undefined) {\n objWithMaybeUser.user = {\n ...objWithMaybeUser.user,\n ip_address: '{{auto}}',\n };\n }\n}\n\n/**\n * @internal\n */\nexport function addAutoIpAddressToSession(session: Session | SessionAggregates): void {\n if ('aggregates' in session) {\n if (session.attrs?.['ip_address'] === undefined) {\n session.attrs = {\n ...session.attrs,\n ip_address: '{{auto}}',\n };\n }\n } else {\n if (session.ipAddress === undefined) {\n session.ipAddress = '{{auto}}';\n }\n }\n}\n","import type { Event } from '../types-hoist/event';\nimport type { Exception } from '../types-hoist/exception';\nimport type { Mechanism } from '../types-hoist/mechanism';\nimport type { StackFrame } from '../types-hoist/stackframe';\nimport { addNonEnumerableProperty } from './object';\nimport { snipLine } from './string';\nimport { GLOBAL_OBJ } from './worldwide';\n\ninterface CryptoInternal {\n getRandomValues(array: Uint8Array): Uint8Array;\n randomUUID?(): string;\n}\n\n/** An interface for common properties on global */\ninterface CryptoGlobal {\n msCrypto?: CryptoInternal;\n crypto?: CryptoInternal;\n}\n\nfunction getCrypto(): CryptoInternal | undefined {\n const gbl = GLOBAL_OBJ as typeof GLOBAL_OBJ & CryptoGlobal;\n return gbl.crypto || gbl.msCrypto;\n}\n\n/**\n * UUID4 generator\n * @param crypto Object that provides the crypto API.\n * @returns string Generated UUID4.\n */\nexport function uuid4(crypto = getCrypto()): string {\n let getRandomByte = (): number => Math.random() * 16;\n try {\n if (crypto?.randomUUID) {\n return crypto.randomUUID().replace(/-/g, '');\n }\n if (crypto?.getRandomValues) {\n getRandomByte = () => {\n // crypto.getRandomValues might return undefined instead of the typed array\n // in old Chromium versions (e.g. 23.0.1235.0 (151422))\n // However, `typedArray` is still filled in-place.\n // @see https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues#typedarray\n const typedArray = new Uint8Array(1);\n crypto.getRandomValues(typedArray);\n // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n return typedArray[0]!;\n };\n }\n } catch {\n // some runtimes can crash invoking crypto\n // https://github.com/getsentry/sentry-javascript/issues/8935\n }\n\n // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523\n // Concatenating the following numbers as strings results in '10000000100040008000100000000000'\n return (([1e7] as unknown as string) + 1e3 + 4e3 + 8e3 + 1e11).replace(/[018]/g, c =>\n // eslint-disable-next-line no-bitwise\n ((c as unknown as number) ^ ((getRandomByte() & 15) >> ((c as unknown as number) / 4))).toString(16),\n );\n}\n\nfunction getFirstException(event: Event): Exception | undefined {\n return event.exception?.values?.[0];\n}\n\n/**\n * Extracts either message or type+value from an event that can be used for user-facing logs\n * @returns event's description\n */\nexport function getEventDescription(event: Event): string {\n const { message, event_id: eventId } = event;\n if (message) {\n return message;\n }\n\n const firstException = getFirstException(event);\n if (firstException) {\n if (firstException.type && firstException.value) {\n return `${firstException.type}: ${firstException.value}`;\n }\n return firstException.type || firstException.value || eventId || '';\n }\n return eventId || '';\n}\n\n/**\n * Adds exception values, type and value to an synthetic Exception.\n * @param event The event to modify.\n * @param value Value of the exception.\n * @param type Type of the exception.\n * @hidden\n */\nexport function addExceptionTypeValue(event: Event, value?: string, type?: string): void {\n const exception = (event.exception = event.exception || {});\n const values = (exception.values = exception.values || []);\n const firstException = (values[0] = values[0] || {});\n if (!firstException.value) {\n firstException.value = value || '';\n }\n if (!firstException.type) {\n firstException.type = type || 'Error';\n }\n}\n\n/**\n * Adds exception mechanism data to a given event. Uses defaults if the second parameter is not passed.\n *\n * @param event The event to modify.\n * @param newMechanism Mechanism data to add to the event.\n * @hidden\n */\nexport function addExceptionMechanism(event: Event, newMechanism?: Partial): void {\n const firstException = getFirstException(event);\n if (!firstException) {\n return;\n }\n\n const defaultMechanism = { type: 'generic', handled: true };\n const currentMechanism = firstException.mechanism;\n firstException.mechanism = { ...defaultMechanism, ...currentMechanism, ...newMechanism };\n\n if (newMechanism && 'data' in newMechanism) {\n const mergedData = { ...currentMechanism?.data, ...newMechanism.data };\n firstException.mechanism.data = mergedData;\n }\n}\n\n// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nconst SEMVER_REGEXP =\n /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/;\n\n/**\n * Represents Semantic Versioning object\n */\ninterface SemVer {\n major?: number;\n minor?: number;\n patch?: number;\n prerelease?: string;\n buildmetadata?: string;\n}\n\nfunction _parseInt(input: string | undefined): number {\n return parseInt(input || '', 10);\n}\n\n/**\n * Parses input into a SemVer interface\n * @param input string representation of a semver version\n */\nexport function parseSemver(input: string): SemVer {\n const match = input.match(SEMVER_REGEXP) || [];\n const major = _parseInt(match[1]);\n const minor = _parseInt(match[2]);\n const patch = _parseInt(match[3]);\n return {\n buildmetadata: match[5],\n major: isNaN(major) ? undefined : major,\n minor: isNaN(minor) ? undefined : minor,\n patch: isNaN(patch) ? undefined : patch,\n prerelease: match[4],\n };\n}\n\n/**\n * This function adds context (pre/post/line) lines to the provided frame\n *\n * @param lines string[] containing all lines\n * @param frame StackFrame that will be mutated\n * @param linesOfContext number of context lines we want to add pre/post\n */\nexport function addContextToFrame(lines: string[], frame: StackFrame, linesOfContext: number = 5): void {\n // When there is no line number in the frame, attaching context is nonsensical and will even break grouping\n if (frame.lineno === undefined) {\n return;\n }\n\n const maxLines = lines.length;\n const sourceLine = Math.max(Math.min(maxLines - 1, frame.lineno - 1), 0);\n\n frame.pre_context = lines\n .slice(Math.max(0, sourceLine - linesOfContext), sourceLine)\n .map((line: string) => snipLine(line, 0));\n\n // We guard here to ensure this is not larger than the existing number of lines\n const lineIndex = Math.min(maxLines - 1, sourceLine);\n\n // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n frame.context_line = snipLine(lines[lineIndex]!, frame.colno || 0);\n\n frame.post_context = lines\n .slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext)\n .map((line: string) => snipLine(line, 0));\n}\n\n/**\n * Checks whether or not we've already captured the given exception (note: not an identical exception - the very object\n * in question), and marks it captured if not.\n *\n * This is useful because it's possible for an error to get captured by more than one mechanism. After we intercept and\n * record an error, we rethrow it (assuming we've intercepted it before it's reached the top-level global handlers), so\n * that we don't interfere with whatever effects the error might have had were the SDK not there. At that point, because\n * the error has been rethrown, it's possible for it to bubble up to some other code we've instrumented. If it's not\n * caught after that, it will bubble all the way up to the global handlers (which of course we also instrument). This\n * function helps us ensure that even if we encounter the same error more than once, we only record it the first time we\n * see it.\n *\n * Note: It will ignore primitives (always return `false` and not mark them as seen), as properties can't be set on\n * them. {@link: Object.objectify} can be used on exceptions to convert any that are primitives into their equivalent\n * object wrapper forms so that this check will always work. However, because we need to flag the exact object which\n * will get rethrown, and because that rethrowing happens outside of the event processing pipeline, the objectification\n * must be done before the exception captured.\n *\n * @param A thrown exception to check or flag as having been seen\n * @returns `true` if the exception has already been captured, `false` if not (with the side effect of marking it seen)\n */\nexport function checkOrSetAlreadyCaught(exception: unknown): boolean {\n if (isAlreadyCaptured(exception)) {\n return true;\n }\n\n try {\n // set it this way rather than by assignment so that it's not ennumerable and therefore isn't recorded by the\n // `ExtraErrorData` integration\n addNonEnumerableProperty(exception as { [key: string]: unknown }, '__sentry_captured__', true);\n } catch {\n // `exception` is a primitive, so we can't mark it seen\n }\n\n return false;\n}\n\nfunction isAlreadyCaptured(exception: unknown): boolean | void {\n try {\n return (exception as { __sentry_captured__?: boolean }).__sentry_captured__;\n } catch {} // eslint-disable-line no-empty\n}\n","import { getCurrentScope } from '../../currentScopes';\nimport { captureException } from '../../exports';\nimport { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '../../semanticAttributes';\nimport { SPAN_STATUS_ERROR } from '../../tracing';\nimport { startSpan, startSpanManual } from '../../tracing/trace';\nimport type { Span, SpanAttributeValue } from '../../types-hoist/span';\nimport {\n GEN_AI_OPERATION_NAME_ATTRIBUTE,\n GEN_AI_REQUEST_AVAILABLE_TOOLS_ATTRIBUTE,\n GEN_AI_REQUEST_FREQUENCY_PENALTY_ATTRIBUTE,\n GEN_AI_REQUEST_MESSAGES_ATTRIBUTE,\n GEN_AI_REQUEST_MODEL_ATTRIBUTE,\n GEN_AI_REQUEST_PRESENCE_PENALTY_ATTRIBUTE,\n GEN_AI_REQUEST_STREAM_ATTRIBUTE,\n GEN_AI_REQUEST_TEMPERATURE_ATTRIBUTE,\n GEN_AI_REQUEST_TOP_P_ATTRIBUTE,\n GEN_AI_RESPONSE_FINISH_REASONS_ATTRIBUTE,\n GEN_AI_RESPONSE_TEXT_ATTRIBUTE,\n GEN_AI_RESPONSE_TOOL_CALLS_ATTRIBUTE,\n GEN_AI_SYSTEM_ATTRIBUTE,\n} from '../ai/gen-ai-attributes';\nimport { OPENAI_INTEGRATION_NAME } from './constants';\nimport { instrumentStream } from './streaming';\nimport type {\n ChatCompletionChunk,\n InstrumentedMethod,\n OpenAiChatCompletionObject,\n OpenAiIntegration,\n OpenAiOptions,\n OpenAiResponse,\n OpenAIResponseObject,\n OpenAIStream,\n ResponseStreamingEvent,\n} from './types';\nimport {\n buildMethodPath,\n getOperationName,\n getSpanOperation,\n isChatCompletionResponse,\n isResponsesApiResponse,\n setCommonResponseAttributes,\n setTokenUsageAttributes,\n shouldInstrument,\n} from './utils';\n\n/**\n * Extract request attributes from method arguments\n */\nfunction extractRequestAttributes(args: unknown[], methodPath: string): Record {\n const attributes: Record = {\n [GEN_AI_SYSTEM_ATTRIBUTE]: 'openai',\n [GEN_AI_OPERATION_NAME_ATTRIBUTE]: getOperationName(methodPath),\n [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ai.openai',\n };\n\n // Chat completion API accepts web_search_options and tools as parameters\n // we append web search options to the available tools to capture all tool calls\n if (args.length > 0 && typeof args[0] === 'object' && args[0] !== null) {\n const params = args[0] as Record;\n\n const tools = Array.isArray(params.tools) ? params.tools : [];\n const hasWebSearchOptions = params.web_search_options && typeof params.web_search_options === 'object';\n const webSearchOptions = hasWebSearchOptions\n ? [{ type: 'web_search_options', ...(params.web_search_options as Record) }]\n : [];\n\n const availableTools = [...tools, ...webSearchOptions];\n\n if (availableTools.length > 0) {\n attributes[GEN_AI_REQUEST_AVAILABLE_TOOLS_ATTRIBUTE] = JSON.stringify(availableTools);\n }\n }\n\n if (args.length > 0 && typeof args[0] === 'object' && args[0] !== null) {\n const params = args[0] as Record;\n\n attributes[GEN_AI_REQUEST_MODEL_ATTRIBUTE] = params.model ?? 'unknown';\n if ('temperature' in params) attributes[GEN_AI_REQUEST_TEMPERATURE_ATTRIBUTE] = params.temperature;\n if ('top_p' in params) attributes[GEN_AI_REQUEST_TOP_P_ATTRIBUTE] = params.top_p;\n if ('frequency_penalty' in params)\n attributes[GEN_AI_REQUEST_FREQUENCY_PENALTY_ATTRIBUTE] = params.frequency_penalty;\n if ('presence_penalty' in params) attributes[GEN_AI_REQUEST_PRESENCE_PENALTY_ATTRIBUTE] = params.presence_penalty;\n if ('stream' in params) attributes[GEN_AI_REQUEST_STREAM_ATTRIBUTE] = params.stream;\n } else {\n attributes[GEN_AI_REQUEST_MODEL_ATTRIBUTE] = 'unknown';\n }\n\n return attributes;\n}\n\n/**\n * Add attributes for Chat Completion responses\n */\nfunction addChatCompletionAttributes(span: Span, response: OpenAiChatCompletionObject, recordOutputs?: boolean): void {\n setCommonResponseAttributes(span, response.id, response.model, response.created);\n if (response.usage) {\n setTokenUsageAttributes(\n span,\n response.usage.prompt_tokens,\n response.usage.completion_tokens,\n response.usage.total_tokens,\n );\n }\n if (Array.isArray(response.choices)) {\n const finishReasons = response.choices\n .map(choice => choice.finish_reason)\n .filter((reason): reason is string => reason !== null);\n if (finishReasons.length > 0) {\n span.setAttributes({\n [GEN_AI_RESPONSE_FINISH_REASONS_ATTRIBUTE]: JSON.stringify(finishReasons),\n });\n }\n\n // Extract tool calls from all choices (only if recordOutputs is true)\n if (recordOutputs) {\n const toolCalls = response.choices\n .map(choice => choice.message?.tool_calls)\n .filter(calls => Array.isArray(calls) && calls.length > 0)\n .flat();\n\n if (toolCalls.length > 0) {\n span.setAttributes({\n [GEN_AI_RESPONSE_TOOL_CALLS_ATTRIBUTE]: JSON.stringify(toolCalls),\n });\n }\n }\n }\n}\n\n/**\n * Add attributes for Responses API responses\n */\nfunction addResponsesApiAttributes(span: Span, response: OpenAIResponseObject, recordOutputs?: boolean): void {\n setCommonResponseAttributes(span, response.id, response.model, response.created_at);\n if (response.status) {\n span.setAttributes({\n [GEN_AI_RESPONSE_FINISH_REASONS_ATTRIBUTE]: JSON.stringify([response.status]),\n });\n }\n if (response.usage) {\n setTokenUsageAttributes(\n span,\n response.usage.input_tokens,\n response.usage.output_tokens,\n response.usage.total_tokens,\n );\n }\n\n // Extract function calls from output (only if recordOutputs is true)\n if (recordOutputs) {\n const responseWithOutput = response as OpenAIResponseObject & { output?: unknown[] };\n if (Array.isArray(responseWithOutput.output) && responseWithOutput.output.length > 0) {\n // Filter for function_call type objects in the output array\n const functionCalls = responseWithOutput.output.filter(\n (item): unknown =>\n typeof item === 'object' && item !== null && (item as Record).type === 'function_call',\n );\n\n if (functionCalls.length > 0) {\n span.setAttributes({\n [GEN_AI_RESPONSE_TOOL_CALLS_ATTRIBUTE]: JSON.stringify(functionCalls),\n });\n }\n }\n }\n}\n\n/**\n * Add response attributes to spans\n * This currently supports both Chat Completion and Responses API responses\n */\nfunction addResponseAttributes(span: Span, result: unknown, recordOutputs?: boolean): void {\n if (!result || typeof result !== 'object') return;\n\n const response = result as OpenAiResponse;\n\n if (isChatCompletionResponse(response)) {\n addChatCompletionAttributes(span, response, recordOutputs);\n if (recordOutputs && response.choices?.length) {\n const responseTexts = response.choices.map(choice => choice.message?.content || '');\n span.setAttributes({ [GEN_AI_RESPONSE_TEXT_ATTRIBUTE]: JSON.stringify(responseTexts) });\n }\n } else if (isResponsesApiResponse(response)) {\n addResponsesApiAttributes(span, response, recordOutputs);\n if (recordOutputs && response.output_text) {\n span.setAttributes({ [GEN_AI_RESPONSE_TEXT_ATTRIBUTE]: response.output_text });\n }\n }\n}\n\n// Extract and record AI request inputs, if present. This is intentionally separate from response attributes.\nfunction addRequestAttributes(span: Span, params: Record): void {\n if ('messages' in params) {\n span.setAttributes({ [GEN_AI_REQUEST_MESSAGES_ATTRIBUTE]: JSON.stringify(params.messages) });\n }\n if ('input' in params) {\n span.setAttributes({ [GEN_AI_REQUEST_MESSAGES_ATTRIBUTE]: JSON.stringify(params.input) });\n }\n}\n\nfunction getOptionsFromIntegration(): OpenAiOptions {\n const scope = getCurrentScope();\n const client = scope.getClient();\n const integration = client?.getIntegrationByName(OPENAI_INTEGRATION_NAME);\n const shouldRecordInputsAndOutputs = integration ? Boolean(client?.getOptions().sendDefaultPii) : false;\n\n return {\n recordInputs: integration?.options?.recordInputs ?? shouldRecordInputsAndOutputs,\n recordOutputs: integration?.options?.recordOutputs ?? shouldRecordInputsAndOutputs,\n };\n}\n\n/**\n * Instrument a method with Sentry spans\n * Following Sentry AI Agents Manual Instrumentation conventions\n * @see https://docs.sentry.io/platforms/javascript/guides/node/tracing/instrumentation/ai-agents-module/#manual-instrumentation\n */\nfunction instrumentMethod(\n originalMethod: (...args: T) => Promise,\n methodPath: InstrumentedMethod,\n context: unknown,\n options?: OpenAiOptions,\n): (...args: T) => Promise {\n return async function instrumentedMethod(...args: T): Promise {\n const finalOptions = options || getOptionsFromIntegration();\n const requestAttributes = extractRequestAttributes(args, methodPath);\n const model = (requestAttributes[GEN_AI_REQUEST_MODEL_ATTRIBUTE] as string) || 'unknown';\n const operationName = getOperationName(methodPath);\n\n const params = args[0] as Record | undefined;\n const isStreamRequested = params && typeof params === 'object' && params.stream === true;\n\n if (isStreamRequested) {\n // For streaming responses, use manual span management to properly handle the async generator lifecycle\n return startSpanManual(\n {\n name: `${operationName} ${model} stream-response`,\n op: getSpanOperation(methodPath),\n attributes: requestAttributes as Record,\n },\n async (span: Span) => {\n try {\n if (finalOptions.recordInputs && args[0] && typeof args[0] === 'object') {\n addRequestAttributes(span, args[0] as Record);\n }\n\n const result = await originalMethod.apply(context, args);\n\n return instrumentStream(\n result as OpenAIStream,\n span,\n finalOptions.recordOutputs ?? false,\n ) as unknown as R;\n } catch (error) {\n // For streaming requests that fail before stream creation, we still want to record\n // them as streaming requests but end the span gracefully\n span.setStatus({ code: SPAN_STATUS_ERROR, message: 'internal_error' });\n captureException(error, {\n mechanism: {\n handled: false,\n type: 'auto.ai.openai.stream',\n data: {\n function: methodPath,\n },\n },\n });\n span.end();\n throw error;\n }\n },\n );\n } else {\n // Non-streaming responses\n return startSpan(\n {\n name: `${operationName} ${model}`,\n op: getSpanOperation(methodPath),\n attributes: requestAttributes as Record,\n },\n async (span: Span) => {\n try {\n if (finalOptions.recordInputs && args[0] && typeof args[0] === 'object') {\n addRequestAttributes(span, args[0] as Record);\n }\n\n const result = await originalMethod.apply(context, args);\n addResponseAttributes(span, result, finalOptions.recordOutputs);\n return result;\n } catch (error) {\n captureException(error, {\n mechanism: {\n handled: false,\n type: 'auto.ai.openai',\n data: {\n function: methodPath,\n },\n },\n });\n throw error;\n }\n },\n );\n }\n };\n}\n\n/**\n * Create a deep proxy for OpenAI client instrumentation\n */\nfunction createDeepProxy(target: T, currentPath = '', options?: OpenAiOptions): T {\n return new Proxy(target, {\n get(obj: object, prop: string): unknown {\n const value = (obj as Record)[prop];\n const methodPath = buildMethodPath(currentPath, String(prop));\n\n if (typeof value === 'function' && shouldInstrument(methodPath)) {\n return instrumentMethod(value as (...args: unknown[]) => Promise, methodPath, obj, options);\n }\n\n if (typeof value === 'function') {\n // Bind non-instrumented functions to preserve the original `this` context,\n // which is required for accessing private class fields (e.g. #baseURL) in OpenAI SDK v5.\n return value.bind(obj);\n }\n\n if (value && typeof value === 'object') {\n return createDeepProxy(value, methodPath, options);\n }\n\n return value;\n },\n }) as T;\n}\n\n/**\n * Instrument an OpenAI client with Sentry tracing\n * Can be used across Node.js, Cloudflare Workers, and Vercel Edge\n */\nexport function instrumentOpenAiClient(client: T, options?: OpenAiOptions): T {\n return createDeepProxy(client, '', options);\n}\n","import type { SerializedTraceData } from '../types-hoist/tracing';\nimport { getTraceData } from './traceData';\n\n/**\n * Returns a string of meta tags that represent the current trace data.\n *\n * You can use this to propagate a trace from your server-side rendered Html to the browser.\n * This function returns up to two meta tags, `sentry-trace` and `baggage`, depending on the\n * current trace data state.\n *\n * @example\n * Usage example:\n *\n * ```js\n * function renderHtml() {\n * return `\n * \n * ${getTraceMetaTags()}\n * \n * `;\n * }\n * ```\n *\n */\nexport function getTraceMetaTags(traceData?: SerializedTraceData): string {\n return Object.entries(traceData || getTraceData())\n .map(([key, value]) => ``)\n .join('\\n');\n}\n","export const OPENAI_INTEGRATION_NAME = 'OpenAI';\n\n// https://platform.openai.com/docs/quickstart?api-mode=responses\n// https://platform.openai.com/docs/quickstart?api-mode=chat\nexport const INSTRUMENTED_METHODS = ['responses.create', 'chat.completions.create'] as const;\nexport const RESPONSES_TOOL_CALL_EVENT_TYPES = [\n 'response.output_item.added',\n 'response.function_call_arguments.delta',\n 'response.function_call_arguments.done',\n 'response.output_item.done',\n] as const;\nexport const RESPONSE_EVENT_TYPES = [\n 'response.created',\n 'response.in_progress',\n 'response.failed',\n 'response.completed',\n 'response.incomplete',\n 'response.queued',\n 'response.output_text.delta',\n ...RESPONSES_TOOL_CALL_EVENT_TYPES,\n] as const;\n","import type { Client } from '../client';\nimport type { DsnComponents } from '../types-hoist/dsn';\nimport { isURLObjectRelative, parseStringToURLObject } from './url';\n\n/**\n * Checks whether given url points to Sentry server\n *\n * @param url url to verify\n */\nexport function isSentryRequestUrl(url: string, client: Client | undefined): boolean {\n const dsn = client?.getDsn();\n const tunnel = client?.getOptions().tunnel;\n return checkDsn(url, dsn) || checkTunnel(url, tunnel);\n}\n\nfunction checkTunnel(url: string, tunnel: string | undefined): boolean {\n if (!tunnel) {\n return false;\n }\n\n return removeTrailingSlash(url) === removeTrailingSlash(tunnel);\n}\n\nfunction checkDsn(url: string, dsn: DsnComponents | undefined): boolean {\n // Requests to Sentry's ingest endpoint must have a `sentry_key` in the query string\n // This is equivalent to the public_key which is required in the DSN\n // see https://develop.sentry.dev/sdk/overview/#parsing-the-dsn\n // Therefore, a request to the same host and with a `sentry_key` in the query string\n // can be considered a request to the ingest endpoint.\n const urlParts = parseStringToURLObject(url);\n if (!urlParts || isURLObjectRelative(urlParts)) {\n return false;\n }\n\n return dsn ? urlParts.host.includes(dsn.host) && /(^|&|\\?)sentry_key=/.test(urlParts.search) : false;\n}\n\nfunction removeTrailingSlash(str: string): string {\n return str[str.length - 1] === '/' ? str.slice(0, -1) : str;\n}\n","/**\n * NOTE: In order to avoid circular dependencies, if you add a function to this module and it needs to print something,\n * you must either a) use `console.log` rather than the `debug` singleton, or b) put your function elsewhere.\n */\n\nimport { isBrowserBundle } from './env';\n\n/**\n * Checks whether we're in the Node.js or Browser environment\n *\n * @returns Answer to given question\n */\nexport function isNodeEnv(): boolean {\n // explicitly check for browser bundles as those can be optimized statically\n // by terser/rollup.\n return (\n !isBrowserBundle() &&\n Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]'\n );\n}\n\n/**\n * Requires a module which is protected against bundler minification.\n *\n * @param request The module path to resolve\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction dynamicRequire(mod: any, request: string): any {\n // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n return mod.require(request);\n}\n\n/**\n * Helper for dynamically loading module that should work with linked dependencies.\n * The problem is that we _should_ be using `require(require.resolve(moduleName, { paths: [cwd()] }))`\n * However it's _not possible_ to do that with Webpack, as it has to know all the dependencies during\n * build time. `require.resolve` is also not available in any other way, so we cannot create,\n * a fake helper like we do with `dynamicRequire`.\n *\n * We always prefer to use local package, thus the value is not returned early from each `try/catch` block.\n * That is to mimic the behavior of `require.resolve` exactly.\n *\n * @param moduleName module name to require\n * @param existingModule module to use for requiring\n * @returns possibly required module\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function loadModule(moduleName: string, existingModule: any = module): T | undefined {\n let mod: T | undefined;\n\n try {\n mod = dynamicRequire(existingModule, moduleName);\n } catch {\n // no-empty\n }\n\n if (!mod) {\n try {\n const { cwd } = dynamicRequire(existingModule, 'process');\n mod = dynamicRequire(existingModule, `${cwd()}/node_modules/${moduleName}`) as T;\n } catch {\n // no-empty\n }\n }\n\n return mod;\n}\n","// Slightly modified (no IE8 support, ES6) and transcribed to TypeScript\n// https://github.com/calvinmetcalf/rollup-plugin-node-builtins/blob/63ab8aacd013767445ca299e468d9a60a95328d7/src/es6/path.js\n//\n// Copyright Joyent, Inc.and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n/** JSDoc */\nfunction normalizeArray(parts: string[], allowAboveRoot?: boolean): string[] {\n // if the path tries to go above the root, `up` ends up > 0\n let up = 0;\n for (let i = parts.length - 1; i >= 0; i--) {\n const last = parts[i];\n if (last === '.') {\n parts.splice(i, 1);\n } else if (last === '..') {\n parts.splice(i, 1);\n up++;\n } else if (up) {\n parts.splice(i, 1);\n up--;\n }\n }\n\n // if the path is allowed to go above the root, restore leading ..s\n if (allowAboveRoot) {\n for (; up--; up) {\n parts.unshift('..');\n }\n }\n\n return parts;\n}\n\n// Split a filename into [root, dir, basename, ext], unix version\n// 'root' is just a slash, or nothing.\nconst splitPathRe = /^(\\S+:\\\\|\\/?)([\\s\\S]*?)((?:\\.{1,2}|[^/\\\\]+?|)(\\.[^./\\\\]*|))(?:[/\\\\]*)$/;\n/** JSDoc */\nfunction splitPath(filename: string): string[] {\n // Truncate files names greater than 1024 characters to avoid regex dos\n // https://github.com/getsentry/sentry-javascript/pull/8737#discussion_r1285719172\n const truncated = filename.length > 1024 ? `${filename.slice(-1024)}` : filename;\n const parts = splitPathRe.exec(truncated);\n return parts ? parts.slice(1) : [];\n}\n\n// path.resolve([from ...], to)\n// posix version\n/** JSDoc */\nexport function resolve(...args: string[]): string {\n let resolvedPath = '';\n let resolvedAbsolute = false;\n\n for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n const path = i >= 0 ? args[i] : '/';\n\n // Skip empty entries\n if (!path) {\n continue;\n }\n\n resolvedPath = `${path}/${resolvedPath}`;\n resolvedAbsolute = path.charAt(0) === '/';\n }\n\n // At this point the path should be resolved to a full absolute path, but\n // handle relative paths to be safe (might happen when process.cwd() fails)\n\n // Normalize the path\n resolvedPath = normalizeArray(\n resolvedPath.split('/').filter(p => !!p),\n !resolvedAbsolute,\n ).join('/');\n\n return (resolvedAbsolute ? '/' : '') + resolvedPath || '.';\n}\n\n/** JSDoc */\nfunction trim(arr: string[]): string[] {\n let start = 0;\n for (; start < arr.length; start++) {\n if (arr[start] !== '') {\n break;\n }\n }\n\n let end = arr.length - 1;\n for (; end >= 0; end--) {\n if (arr[end] !== '') {\n break;\n }\n }\n\n if (start > end) {\n return [];\n }\n return arr.slice(start, end - start + 1);\n}\n\n// path.relative(from, to)\n// posix version\n/** JSDoc */\nexport function relative(from: string, to: string): string {\n /* eslint-disable no-param-reassign */\n from = resolve(from).slice(1);\n to = resolve(to).slice(1);\n /* eslint-enable no-param-reassign */\n\n const fromParts = trim(from.split('/'));\n const toParts = trim(to.split('/'));\n\n const length = Math.min(fromParts.length, toParts.length);\n let samePartsLength = length;\n for (let i = 0; i < length; i++) {\n if (fromParts[i] !== toParts[i]) {\n samePartsLength = i;\n break;\n }\n }\n\n let outputParts = [];\n for (let i = samePartsLength; i < fromParts.length; i++) {\n outputParts.push('..');\n }\n\n outputParts = outputParts.concat(toParts.slice(samePartsLength));\n\n return outputParts.join('/');\n}\n\n// path.normalize(path)\n// posix version\n/** JSDoc */\nexport function normalizePath(path: string): string {\n const isPathAbsolute = isAbsolute(path);\n const trailingSlash = path.slice(-1) === '/';\n\n // Normalize the path\n let normalizedPath = normalizeArray(\n path.split('/').filter(p => !!p),\n !isPathAbsolute,\n ).join('/');\n\n if (!normalizedPath && !isPathAbsolute) {\n normalizedPath = '.';\n }\n if (normalizedPath && trailingSlash) {\n normalizedPath += '/';\n }\n\n return (isPathAbsolute ? '/' : '') + normalizedPath;\n}\n\n// posix version\n/** JSDoc */\nexport function isAbsolute(path: string): boolean {\n return path.charAt(0) === '/';\n}\n\n// posix version\n/** JSDoc */\nexport function join(...args: string[]): string {\n return normalizePath(args.join('/'));\n}\n\n/** JSDoc */\nexport function dirname(path: string): string {\n const result = splitPath(path);\n const root = result[0] || '';\n let dir = result[1];\n\n if (!root && !dir) {\n // No dirname whatsoever\n return '.';\n }\n\n if (dir) {\n // It has a dirname, strip trailing slash\n dir = dir.slice(0, dir.length - 1);\n }\n\n return root + dir;\n}\n\n/** JSDoc */\nexport function basename(path: string, ext?: string): string {\n let f = splitPath(path)[2] || '';\n if (ext && f.slice(ext.length * -1) === ext) {\n f = f.slice(0, f.length - ext.length);\n }\n return f;\n}\n","import { captureException } from '../../exports';\nimport { SPAN_STATUS_ERROR } from '../../tracing';\nimport type { Span } from '../../types-hoist/span';\nimport {\n GEN_AI_RESPONSE_FINISH_REASONS_ATTRIBUTE,\n GEN_AI_RESPONSE_STREAMING_ATTRIBUTE,\n GEN_AI_RESPONSE_TEXT_ATTRIBUTE,\n GEN_AI_RESPONSE_TOOL_CALLS_ATTRIBUTE,\n} from '../ai/gen-ai-attributes';\nimport { RESPONSE_EVENT_TYPES } from './constants';\nimport type { OpenAIResponseObject } from './types';\nimport {\n type ChatCompletionChunk,\n type ChatCompletionToolCall,\n type ResponseFunctionCall,\n type ResponseStreamingEvent,\n} from './types';\nimport {\n isChatCompletionChunk,\n isResponsesApiStreamEvent,\n setCommonResponseAttributes,\n setTokenUsageAttributes,\n} from './utils';\n\n/**\n * State object used to accumulate information from a stream of OpenAI events/chunks.\n */\ninterface StreamingState {\n /** Types of events encountered in the stream. */\n eventTypes: string[];\n /** Collected response text fragments (for output recording). */\n responseTexts: string[];\n /** Reasons for finishing the response, as reported by the API. */\n finishReasons: string[];\n /** The response ID. */\n responseId: string;\n /** The model name. */\n responseModel: string;\n /** The timestamp of the response. */\n responseTimestamp: number;\n /** Number of prompt/input tokens used. */\n promptTokens: number | undefined;\n /** Number of completion/output tokens used. */\n completionTokens: number | undefined;\n /** Total number of tokens used (prompt + completion). */\n totalTokens: number | undefined;\n /**\n * Accumulated tool calls from Chat Completion streaming, indexed by tool call index.\n * @see https://platform.openai.com/docs/guides/function-calling?api-mode=chat#streaming\n */\n chatCompletionToolCalls: Record;\n /**\n * Accumulated function calls from Responses API streaming.\n * @see https://platform.openai.com/docs/guides/function-calling?api-mode=responses#streaming\n */\n responsesApiToolCalls: Array;\n}\n\n/**\n * Processes tool calls from a chat completion chunk delta.\n * Follows the pattern: accumulate by index, then convert to array at the end.\n *\n * @param toolCalls - Array of tool calls from the delta.\n * @param state - The current streaming state to update.\n *\n * @see https://platform.openai.com/docs/guides/function-calling#streaming\n */\nfunction processChatCompletionToolCalls(toolCalls: ChatCompletionToolCall[], state: StreamingState): void {\n for (const toolCall of toolCalls) {\n const index = toolCall.index;\n if (index === undefined || !toolCall.function) continue;\n\n // Initialize tool call if this is the first chunk for this index\n if (!(index in state.chatCompletionToolCalls)) {\n state.chatCompletionToolCalls[index] = {\n ...toolCall,\n function: {\n name: toolCall.function.name,\n arguments: toolCall.function.arguments || '',\n },\n };\n } else {\n // Accumulate function arguments from subsequent chunks\n const existingToolCall = state.chatCompletionToolCalls[index];\n if (toolCall.function.arguments && existingToolCall?.function) {\n existingToolCall.function.arguments += toolCall.function.arguments;\n }\n }\n }\n}\n\n/**\n * Processes a single OpenAI ChatCompletionChunk event, updating the streaming state.\n *\n * @param chunk - The ChatCompletionChunk event to process.\n * @param state - The current streaming state to update.\n * @param recordOutputs - Whether to record output text fragments.\n */\nfunction processChatCompletionChunk(chunk: ChatCompletionChunk, state: StreamingState, recordOutputs: boolean): void {\n state.responseId = chunk.id ?? state.responseId;\n state.responseModel = chunk.model ?? state.responseModel;\n state.responseTimestamp = chunk.created ?? state.responseTimestamp;\n\n if (chunk.usage) {\n // For stream responses, the input tokens remain constant across all events in the stream.\n // Output tokens, however, are only finalized in the last event.\n // Since we can't guarantee that the last event will include usage data or even be a typed event,\n // we update the output token values on every event that includes them.\n // This ensures that output token usage is always set, even if the final event lacks it.\n state.promptTokens = chunk.usage.prompt_tokens;\n state.completionTokens = chunk.usage.completion_tokens;\n state.totalTokens = chunk.usage.total_tokens;\n }\n\n for (const choice of chunk.choices ?? []) {\n if (recordOutputs) {\n if (choice.delta?.content) {\n state.responseTexts.push(choice.delta.content);\n }\n\n // Handle tool calls from delta\n if (choice.delta?.tool_calls) {\n processChatCompletionToolCalls(choice.delta.tool_calls, state);\n }\n }\n if (choice.finish_reason) {\n state.finishReasons.push(choice.finish_reason);\n }\n }\n}\n\n/**\n * Processes a single OpenAI Responses API streaming event, updating the streaming state and span.\n *\n * @param streamEvent - The event to process (may be an error or unknown object).\n * @param state - The current streaming state to update.\n * @param recordOutputs - Whether to record output text fragments.\n * @param span - The span to update with error status if needed.\n */\nfunction processResponsesApiEvent(\n streamEvent: ResponseStreamingEvent | unknown | Error,\n state: StreamingState,\n recordOutputs: boolean,\n span: Span,\n): void {\n if (!(streamEvent && typeof streamEvent === 'object')) {\n state.eventTypes.push('unknown:non-object');\n return;\n }\n if (streamEvent instanceof Error) {\n span.setStatus({ code: SPAN_STATUS_ERROR, message: 'internal_error' });\n captureException(streamEvent, {\n mechanism: {\n handled: false,\n type: 'auto.ai.openai.stream-response',\n },\n });\n return;\n }\n\n if (!('type' in streamEvent)) return;\n const event = streamEvent as ResponseStreamingEvent;\n\n if (!RESPONSE_EVENT_TYPES.includes(event.type)) {\n state.eventTypes.push(event.type);\n return;\n }\n\n // Handle output text delta\n if (recordOutputs) {\n // Handle tool call events for Responses API\n if (event.type === 'response.output_item.done' && 'item' in event) {\n state.responsesApiToolCalls.push(event.item);\n }\n\n if (event.type === 'response.output_text.delta' && 'delta' in event && event.delta) {\n state.responseTexts.push(event.delta);\n return;\n }\n }\n\n if ('response' in event) {\n const { response } = event as { response: OpenAIResponseObject };\n state.responseId = response.id ?? state.responseId;\n state.responseModel = response.model ?? state.responseModel;\n state.responseTimestamp = response.created_at ?? state.responseTimestamp;\n\n if (response.usage) {\n // For stream responses, the input tokens remain constant across all events in the stream.\n // Output tokens, however, are only finalized in the last event.\n // Since we can't guarantee that the last event will include usage data or even be a typed event,\n // we update the output token values on every event that includes them.\n // This ensures that output token usage is always set, even if the final event lacks it.\n state.promptTokens = response.usage.input_tokens;\n state.completionTokens = response.usage.output_tokens;\n state.totalTokens = response.usage.total_tokens;\n }\n\n if (response.status) {\n state.finishReasons.push(response.status);\n }\n\n if (recordOutputs && response.output_text) {\n state.responseTexts.push(response.output_text);\n }\n }\n}\n\n/**\n * Instruments a stream of OpenAI events, updating the provided span with relevant attributes and\n * optionally recording output text. This function yields each event from the input stream as it is processed.\n *\n * @template T - The type of events in the stream.\n * @param stream - The async iterable stream of events to instrument.\n * @param span - The span to add attributes to and to finish at the end of the stream.\n * @param recordOutputs - Whether to record output text fragments in the span.\n * @returns An async generator yielding each event from the input stream.\n */\nexport async function* instrumentStream(\n stream: AsyncIterable,\n span: Span,\n recordOutputs: boolean,\n): AsyncGenerator {\n const state: StreamingState = {\n eventTypes: [],\n responseTexts: [],\n finishReasons: [],\n responseId: '',\n responseModel: '',\n responseTimestamp: 0,\n promptTokens: undefined,\n completionTokens: undefined,\n totalTokens: undefined,\n chatCompletionToolCalls: {},\n responsesApiToolCalls: [],\n };\n\n try {\n for await (const event of stream) {\n if (isChatCompletionChunk(event)) {\n processChatCompletionChunk(event as ChatCompletionChunk, state, recordOutputs);\n } else if (isResponsesApiStreamEvent(event)) {\n processResponsesApiEvent(event as ResponseStreamingEvent, state, recordOutputs, span);\n }\n yield event;\n }\n } finally {\n setCommonResponseAttributes(span, state.responseId, state.responseModel, state.responseTimestamp);\n setTokenUsageAttributes(span, state.promptTokens, state.completionTokens, state.totalTokens);\n\n span.setAttributes({\n [GEN_AI_RESPONSE_STREAMING_ATTRIBUTE]: true,\n });\n\n if (state.finishReasons.length) {\n span.setAttributes({\n [GEN_AI_RESPONSE_FINISH_REASONS_ATTRIBUTE]: JSON.stringify(state.finishReasons),\n });\n }\n\n if (recordOutputs && state.responseTexts.length) {\n span.setAttributes({\n [GEN_AI_RESPONSE_TEXT_ATTRIBUTE]: state.responseTexts.join(''),\n });\n }\n\n // Set tool calls attribute if any were accumulated\n const chatCompletionToolCallsArray = Object.values(state.chatCompletionToolCalls);\n const allToolCalls = [...chatCompletionToolCallsArray, ...state.responsesApiToolCalls];\n\n if (allToolCalls.length > 0) {\n span.setAttributes({\n [GEN_AI_RESPONSE_TOOL_CALLS_ATTRIBUTE]: JSON.stringify(allToolCalls),\n });\n }\n\n span.end();\n }\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport type { Primitive } from '../types-hoist/misc';\nimport type { ParameterizedString } from '../types-hoist/parameterize';\nimport type { PolymorphicEvent } from '../types-hoist/polymorphics';\n\n// eslint-disable-next-line @typescript-eslint/unbound-method\nconst objectToString = Object.prototype.toString;\n\n/**\n * Checks whether given value's type is one of a few Error or Error-like\n * {@link isError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isError(wat: unknown): wat is Error {\n switch (objectToString.call(wat)) {\n case '[object Error]':\n case '[object Exception]':\n case '[object DOMException]':\n case '[object WebAssembly.Exception]':\n return true;\n default:\n return isInstanceOf(wat, Error);\n }\n}\n/**\n * Checks whether given value is an instance of the given built-in class.\n *\n * @param wat The value to be checked\n * @param className\n * @returns A boolean representing the result.\n */\nfunction isBuiltin(wat: unknown, className: string): boolean {\n return objectToString.call(wat) === `[object ${className}]`;\n}\n\n/**\n * Checks whether given value's type is ErrorEvent\n * {@link isErrorEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isErrorEvent(wat: unknown): boolean {\n return isBuiltin(wat, 'ErrorEvent');\n}\n\n/**\n * Checks whether given value's type is DOMError\n * {@link isDOMError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isDOMError(wat: unknown): boolean {\n return isBuiltin(wat, 'DOMError');\n}\n\n/**\n * Checks whether given value's type is DOMException\n * {@link isDOMException}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isDOMException(wat: unknown): boolean {\n return isBuiltin(wat, 'DOMException');\n}\n\n/**\n * Checks whether given value's type is a string\n * {@link isString}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isString(wat: unknown): wat is string {\n return isBuiltin(wat, 'String');\n}\n\n/**\n * Checks whether given string is parameterized\n * {@link isParameterizedString}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isParameterizedString(wat: unknown): wat is ParameterizedString {\n return (\n typeof wat === 'object' &&\n wat !== null &&\n '__sentry_template_string__' in wat &&\n '__sentry_template_values__' in wat\n );\n}\n\n/**\n * Checks whether given value is a primitive (undefined, null, number, boolean, string, bigint, symbol)\n * {@link isPrimitive}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isPrimitive(wat: unknown): wat is Primitive {\n return wat === null || isParameterizedString(wat) || (typeof wat !== 'object' && typeof wat !== 'function');\n}\n\n/**\n * Checks whether given value's type is an object literal, or a class instance.\n * {@link isPlainObject}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isPlainObject(wat: unknown): wat is Record {\n return isBuiltin(wat, 'Object');\n}\n\n/**\n * Checks whether given value's type is an Event instance\n * {@link isEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isEvent(wat: unknown): wat is PolymorphicEvent {\n return typeof Event !== 'undefined' && isInstanceOf(wat, Event);\n}\n\n/**\n * Checks whether given value's type is an Element instance\n * {@link isElement}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isElement(wat: unknown): boolean {\n return typeof Element !== 'undefined' && isInstanceOf(wat, Element);\n}\n\n/**\n * Checks whether given value's type is an regexp\n * {@link isRegExp}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isRegExp(wat: unknown): wat is RegExp {\n return isBuiltin(wat, 'RegExp');\n}\n\n/**\n * Checks whether given value has a then function.\n * @param wat A value to be checked.\n */\nexport function isThenable(wat: any): wat is PromiseLike {\n // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n return Boolean(wat?.then && typeof wat.then === 'function');\n}\n\n/**\n * Checks whether given value's type is a SyntheticEvent\n * {@link isSyntheticEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isSyntheticEvent(wat: unknown): boolean {\n return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;\n}\n\n/**\n * Checks whether given value's type is an instance of provided constructor.\n * {@link isInstanceOf}.\n *\n * @param wat A value to be checked.\n * @param base A constructor to be used in a check.\n * @returns A boolean representing the result.\n */\nexport function isInstanceOf(wat: any, base: any): boolean {\n try {\n return wat instanceof base;\n } catch {\n return false;\n }\n}\n\ninterface VueViewModel {\n // Vue3\n __isVue?: boolean;\n // Vue2\n _isVue?: boolean;\n}\n/**\n * Checks whether given value's type is a Vue ViewModel.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isVueViewModel(wat: unknown): boolean {\n // Not using Object.prototype.toString because in Vue 3 it would read the instance's Symbol(Symbol.toStringTag) property.\n return !!(typeof wat === 'object' && wat !== null && ((wat as VueViewModel).__isVue || (wat as VueViewModel)._isVue));\n}\n\n/**\n * Checks whether the given parameter is a Standard Web API Request instance.\n *\n * Returns false if Request is not available in the current runtime.\n */\nexport function isRequest(request: unknown): request is Request {\n return typeof Request !== 'undefined' && isInstanceOf(request, Request);\n}\n","import type { ParameterizedString } from '../types-hoist/parameterize';\n\n/**\n * Tagged template function which returns parameterized representation of the message\n * For example: parameterize`This is a log statement with ${x} and ${y} params`, would return:\n * \"__sentry_template_string__\": 'This is a log statement with %s and %s params',\n * \"__sentry_template_values__\": ['first', 'second']\n *\n * @param strings An array of string values splitted between expressions\n * @param values Expressions extracted from template string\n *\n * @returns A `ParameterizedString` object that can be passed into `captureMessage` or Sentry.logger.X methods.\n */\nexport function parameterize(strings: TemplateStringsArray, ...values: unknown[]): ParameterizedString {\n const formatted = new String(String.raw(strings, ...values)) as ParameterizedString;\n formatted.__sentry_template_string__ = strings.join('\\x00').replace(/%/g, '%%').replace(/\\0/g, '%s');\n formatted.__sentry_template_values__ = values;\n return formatted;\n}\n\n/**\n * Tagged template function which returns parameterized representation of the message.\n *\n * @param strings An array of string values splitted between expressions\n * @param values Expressions extracted from template string\n * @returns A `ParameterizedString` object that can be passed into `captureMessage` or Sentry.logger.X methods.\n */\nexport const fmt = parameterize;\n","import type { Primitive } from '../types-hoist/misc';\nimport { isSyntheticEvent, isVueViewModel } from './is';\nimport { convertToPlainObject } from './object';\nimport { getFunctionName } from './stacktrace';\n\ntype Prototype = { constructor?: (...args: unknown[]) => unknown };\n// This is a hack to placate TS, relying on the fact that technically, arrays are objects with integer keys. Normally we\n// think of those keys as actual numbers, but `arr['0']` turns out to work just as well as `arr[0]`, and doing it this\n// way lets us use a single type in the places where behave as if we are only dealing with objects, even if some of them\n// might be arrays.\ntype ObjOrArray = { [key: string]: T };\n\ntype MemoFunc = [\n // memoize\n (obj: object) => boolean,\n // unmemoize\n (obj: object) => void,\n];\n\n/**\n * Recursively normalizes the given object.\n *\n * - Creates a copy to prevent original input mutation\n * - Skips non-enumerable properties\n * - When stringifying, calls `toJSON` if implemented\n * - Removes circular references\n * - Translates non-serializable values (`undefined`/`NaN`/functions) to serializable format\n * - Translates known global objects/classes to a string representations\n * - Takes care of `Error` object serialization\n * - Optionally limits depth of final output\n * - Optionally limits number of properties/elements included in any single object/array\n *\n * @param input The object to be normalized.\n * @param depth The max depth to which to normalize the object. (Anything deeper stringified whole.)\n * @param maxProperties The max number of elements or properties to be included in any single array or\n * object in the normalized output.\n * @returns A normalized version of the object, or `\"**non-serializable**\"` if any errors are thrown during normalization.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function normalize(input: unknown, depth: number = 100, maxProperties: number = +Infinity): any {\n try {\n // since we're at the outermost level, we don't provide a key\n return visit('', input, depth, maxProperties);\n } catch (err) {\n return { ERROR: `**non-serializable** (${err})` };\n }\n}\n\n/** JSDoc */\nexport function normalizeToSize(\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n object: { [key: string]: any },\n // Default Node.js REPL depth\n depth: number = 3,\n // 100kB, as 200kB is max payload size, so half sounds reasonable\n maxSize: number = 100 * 1024,\n): T {\n const normalized = normalize(object, depth);\n\n if (jsonSize(normalized) > maxSize) {\n return normalizeToSize(object, depth - 1, maxSize);\n }\n\n return normalized as T;\n}\n\n/**\n * Visits a node to perform normalization on it\n *\n * @param key The key corresponding to the given node\n * @param value The node to be visited\n * @param depth Optional number indicating the maximum recursion depth\n * @param maxProperties Optional maximum number of properties/elements included in any single object/array\n * @param memo Optional Memo class handling decycling\n */\nfunction visit(\n key: string,\n value: unknown,\n depth: number = +Infinity,\n maxProperties: number = +Infinity,\n memo = memoBuilder(),\n): Primitive | ObjOrArray {\n const [memoize, unmemoize] = memo;\n\n // Get the simple cases out of the way first\n if (\n value == null || // this matches null and undefined -> eqeq not eqeqeq\n ['boolean', 'string'].includes(typeof value) ||\n (typeof value === 'number' && Number.isFinite(value))\n ) {\n return value as Primitive;\n }\n\n const stringified = stringifyValue(key, value);\n\n // Anything we could potentially dig into more (objects or arrays) will have come back as `\"[object XXXX]\"`.\n // Everything else will have already been serialized, so if we don't see that pattern, we're done.\n if (!stringified.startsWith('[object ')) {\n return stringified;\n }\n\n // From here on, we can assert that `value` is either an object or an array.\n\n // Do not normalize objects that we know have already been normalized. As a general rule, the\n // \"__sentry_skip_normalization__\" property should only be used sparingly and only should only be set on objects that\n // have already been normalized.\n if ((value as ObjOrArray)['__sentry_skip_normalization__']) {\n return value as ObjOrArray;\n }\n\n // We can set `__sentry_override_normalization_depth__` on an object to ensure that from there\n // We keep a certain amount of depth.\n // This should be used sparingly, e.g. we use it for the redux integration to ensure we get a certain amount of state.\n const remainingDepth =\n typeof (value as ObjOrArray)['__sentry_override_normalization_depth__'] === 'number'\n ? ((value as ObjOrArray)['__sentry_override_normalization_depth__'] as number)\n : depth;\n\n // We're also done if we've reached the max depth\n if (remainingDepth === 0) {\n // At this point we know `serialized` is a string of the form `\"[object XXXX]\"`. Clean it up so it's just `\"[XXXX]\"`.\n return stringified.replace('object ', '');\n }\n\n // If we've already visited this branch, bail out, as it's circular reference. If not, note that we're seeing it now.\n if (memoize(value)) {\n return '[Circular ~]';\n }\n\n // If the value has a `toJSON` method, we call it to extract more information\n const valueWithToJSON = value as unknown & { toJSON?: () => unknown };\n if (valueWithToJSON && typeof valueWithToJSON.toJSON === 'function') {\n try {\n const jsonValue = valueWithToJSON.toJSON();\n // We need to normalize the return value of `.toJSON()` in case it has circular references\n return visit('', jsonValue, remainingDepth - 1, maxProperties, memo);\n } catch {\n // pass (The built-in `toJSON` failed, but we can still try to do it ourselves)\n }\n }\n\n // At this point we know we either have an object or an array, we haven't seen it before, and we're going to recurse\n // because we haven't yet reached the max depth. Create an accumulator to hold the results of visiting each\n // property/entry, and keep track of the number of items we add to it.\n const normalized = (Array.isArray(value) ? [] : {}) as ObjOrArray;\n let numAdded = 0;\n\n // Before we begin, convert`Error` and`Event` instances into plain objects, since some of each of their relevant\n // properties are non-enumerable and otherwise would get missed.\n const visitable = convertToPlainObject(value as ObjOrArray);\n\n for (const visitKey in visitable) {\n // Avoid iterating over fields in the prototype if they've somehow been exposed to enumeration.\n if (!Object.prototype.hasOwnProperty.call(visitable, visitKey)) {\n continue;\n }\n\n if (numAdded >= maxProperties) {\n normalized[visitKey] = '[MaxProperties ~]';\n break;\n }\n\n // Recursively visit all the child nodes\n const visitValue = visitable[visitKey];\n normalized[visitKey] = visit(visitKey, visitValue, remainingDepth - 1, maxProperties, memo);\n\n numAdded++;\n }\n\n // Once we've visited all the branches, remove the parent from memo storage\n unmemoize(value);\n\n // Return accumulated values\n return normalized;\n}\n\n/* eslint-disable complexity */\n/**\n * Stringify the given value. Handles various known special values and types.\n *\n * Not meant to be used on simple primitives which already have a string representation, as it will, for example, turn\n * the number 1231 into \"[Object Number]\", nor on `null`, as it will throw.\n *\n * @param value The value to stringify\n * @returns A stringified representation of the given value\n */\nfunction stringifyValue(\n key: unknown,\n // this type is a tiny bit of a cheat, since this function does handle NaN (which is technically a number), but for\n // our internal use, it'll do\n value: Exclude,\n): string {\n try {\n if (key === 'domain' && value && typeof value === 'object' && (value as { _events: unknown })._events) {\n return '[Domain]';\n }\n\n if (key === 'domainEmitter') {\n return '[DomainEmitter]';\n }\n\n // It's safe to use `global`, `window`, and `document` here in this manner, as we are asserting using `typeof` first\n // which won't throw if they are not present.\n\n if (typeof global !== 'undefined' && value === global) {\n return '[Global]';\n }\n\n // eslint-disable-next-line no-restricted-globals\n if (typeof window !== 'undefined' && value === window) {\n return '[Window]';\n }\n\n // eslint-disable-next-line no-restricted-globals\n if (typeof document !== 'undefined' && value === document) {\n return '[Document]';\n }\n\n if (isVueViewModel(value)) {\n return '[VueViewModel]';\n }\n\n // React's SyntheticEvent thingy\n if (isSyntheticEvent(value)) {\n return '[SyntheticEvent]';\n }\n\n if (typeof value === 'number' && !Number.isFinite(value)) {\n return `[${value}]`;\n }\n\n if (typeof value === 'function') {\n return `[Function: ${getFunctionName(value)}]`;\n }\n\n if (typeof value === 'symbol') {\n return `[${String(value)}]`;\n }\n\n // stringified BigInts are indistinguishable from regular numbers, so we need to label them to avoid confusion\n if (typeof value === 'bigint') {\n return `[BigInt: ${String(value)}]`;\n }\n\n // Now that we've knocked out all the special cases and the primitives, all we have left are objects. Simply casting\n // them to strings means that instances of classes which haven't defined their `toStringTag` will just come out as\n // `\"[object Object]\"`. If we instead look at the constructor's name (which is the same as the name of the class),\n // we can make sure that only plain objects come out that way.\n const objName = getConstructorName(value);\n\n // Handle HTML Elements\n if (/^HTML(\\w*)Element$/.test(objName)) {\n return `[HTMLElement: ${objName}]`;\n }\n\n return `[object ${objName}]`;\n } catch (err) {\n return `**non-serializable** (${err})`;\n }\n}\n/* eslint-enable complexity */\n\nfunction getConstructorName(value: unknown): string {\n const prototype: Prototype | null = Object.getPrototypeOf(value);\n\n return prototype?.constructor ? prototype.constructor.name : 'null prototype';\n}\n\n/** Calculates bytes size of input string */\nfunction utf8Length(value: string): number {\n // eslint-disable-next-line no-bitwise\n return ~-encodeURI(value).split(/%..|./).length;\n}\n\n/** Calculates bytes size of input object */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction jsonSize(value: any): number {\n return utf8Length(JSON.stringify(value));\n}\n\n/**\n * Normalizes URLs in exceptions and stacktraces to a base path so Sentry can fingerprint\n * across platforms and working directory.\n *\n * @param url The URL to be normalized.\n * @param basePath The application base path.\n * @returns The normalized URL.\n */\nexport function normalizeUrlToBase(url: string, basePath: string): string {\n const escapedBase = basePath\n // Backslash to forward\n .replace(/\\\\/g, '/')\n // Escape RegExp special characters\n .replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&');\n\n let newUrl = url;\n try {\n newUrl = decodeURI(url);\n } catch {\n // Sometime this breaks\n }\n return (\n newUrl\n .replace(/\\\\/g, '/')\n .replace(/webpack:\\/?/g, '') // Remove intermediate base path\n // eslint-disable-next-line @sentry-internal/sdk/no-regexp-constructor\n .replace(new RegExp(`(file://)?/*${escapedBase}/*`, 'ig'), 'app:///')\n );\n}\n\n/**\n * Helper to decycle json objects\n */\nfunction memoBuilder(): MemoFunc {\n const inner = new WeakSet();\n function memoize(obj: object): boolean {\n if (inner.has(obj)) {\n return true;\n }\n inner.add(obj);\n return false;\n }\n\n function unmemoize(obj: object): void {\n inner.delete(obj);\n }\n return [memoize, unmemoize];\n}\n","import type { Span } from '../../types-hoist/span';\nimport {\n GEN_AI_RESPONSE_ID_ATTRIBUTE,\n GEN_AI_RESPONSE_MODEL_ATTRIBUTE,\n GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE,\n GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE,\n GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE,\n OPENAI_OPERATIONS,\n OPENAI_RESPONSE_ID_ATTRIBUTE,\n OPENAI_RESPONSE_MODEL_ATTRIBUTE,\n OPENAI_RESPONSE_TIMESTAMP_ATTRIBUTE,\n OPENAI_USAGE_COMPLETION_TOKENS_ATTRIBUTE,\n OPENAI_USAGE_PROMPT_TOKENS_ATTRIBUTE,\n} from '../ai/gen-ai-attributes';\nimport { INSTRUMENTED_METHODS } from './constants';\nimport type {\n ChatCompletionChunk,\n InstrumentedMethod,\n OpenAiChatCompletionObject,\n OpenAIResponseObject,\n ResponseStreamingEvent,\n} from './types';\n\n/**\n * Maps OpenAI method paths to Sentry operation names\n */\nexport function getOperationName(methodPath: string): string {\n if (methodPath.includes('chat.completions')) {\n return OPENAI_OPERATIONS.CHAT;\n }\n if (methodPath.includes('responses')) {\n return OPENAI_OPERATIONS.RESPONSES;\n }\n return methodPath.split('.').pop() || 'unknown';\n}\n\n/**\n * Get the span operation for OpenAI methods\n * Following Sentry's convention: \"gen_ai.{operation_name}\"\n */\nexport function getSpanOperation(methodPath: string): string {\n return `gen_ai.${getOperationName(methodPath)}`;\n}\n\n/**\n * Check if a method path should be instrumented\n */\nexport function shouldInstrument(methodPath: string): methodPath is InstrumentedMethod {\n return INSTRUMENTED_METHODS.includes(methodPath as InstrumentedMethod);\n}\n\n/**\n * Build method path from current traversal\n */\nexport function buildMethodPath(currentPath: string, prop: string): string {\n return currentPath ? `${currentPath}.${prop}` : prop;\n}\n\n/**\n * Check if response is a Chat Completion object\n */\nexport function isChatCompletionResponse(response: unknown): response is OpenAiChatCompletionObject {\n return (\n response !== null &&\n typeof response === 'object' &&\n 'object' in response &&\n (response as Record).object === 'chat.completion'\n );\n}\n\n/**\n * Check if response is a Responses API object\n */\nexport function isResponsesApiResponse(response: unknown): response is OpenAIResponseObject {\n return (\n response !== null &&\n typeof response === 'object' &&\n 'object' in response &&\n (response as Record).object === 'response'\n );\n}\n\n/**\n * Check if streaming event is from the Responses API\n */\nexport function isResponsesApiStreamEvent(event: unknown): event is ResponseStreamingEvent {\n return (\n event !== null &&\n typeof event === 'object' &&\n 'type' in event &&\n typeof (event as Record).type === 'string' &&\n ((event as Record).type as string).startsWith('response.')\n );\n}\n\n/**\n * Check if streaming event is a chat completion chunk\n */\nexport function isChatCompletionChunk(event: unknown): event is ChatCompletionChunk {\n return (\n event !== null &&\n typeof event === 'object' &&\n 'object' in event &&\n (event as Record).object === 'chat.completion.chunk'\n );\n}\n\n/**\n * Set token usage attributes\n * @param span - The span to add attributes to\n * @param promptTokens - The number of prompt tokens\n * @param completionTokens - The number of completion tokens\n * @param totalTokens - The number of total tokens\n */\nexport function setTokenUsageAttributes(\n span: Span,\n promptTokens?: number,\n completionTokens?: number,\n totalTokens?: number,\n): void {\n if (promptTokens !== undefined) {\n span.setAttributes({\n [OPENAI_USAGE_PROMPT_TOKENS_ATTRIBUTE]: promptTokens,\n [GEN_AI_USAGE_INPUT_TOKENS_ATTRIBUTE]: promptTokens,\n });\n }\n if (completionTokens !== undefined) {\n span.setAttributes({\n [OPENAI_USAGE_COMPLETION_TOKENS_ATTRIBUTE]: completionTokens,\n [GEN_AI_USAGE_OUTPUT_TOKENS_ATTRIBUTE]: completionTokens,\n });\n }\n if (totalTokens !== undefined) {\n span.setAttributes({\n [GEN_AI_USAGE_TOTAL_TOKENS_ATTRIBUTE]: totalTokens,\n });\n }\n}\n\n/**\n * Set common response attributes\n * @param span - The span to add attributes to\n * @param id - The response id\n * @param model - The response model\n * @param timestamp - The response timestamp\n */\nexport function setCommonResponseAttributes(span: Span, id: string, model: string, timestamp: number): void {\n span.setAttributes({\n [OPENAI_RESPONSE_ID_ATTRIBUTE]: id,\n [GEN_AI_RESPONSE_ID_ATTRIBUTE]: id,\n });\n span.setAttributes({\n [OPENAI_RESPONSE_MODEL_ATTRIBUTE]: model,\n [GEN_AI_RESPONSE_MODEL_ATTRIBUTE]: model,\n });\n span.setAttributes({\n [OPENAI_RESPONSE_TIMESTAMP_ATTRIBUTE]: new Date(timestamp * 1000).toISOString(),\n });\n}\n","/**\n * Shallow merge two objects.\n * Does not mutate the passed in objects.\n * Undefined/empty values in the merge object will overwrite existing values.\n *\n * By default, this merges 2 levels deep.\n */\nexport function merge(initialObj: T, mergeObj: T, levels = 2): T {\n // If the merge value is not an object, or we have no merge levels left,\n // we just set the value to the merge value\n if (!mergeObj || typeof mergeObj !== 'object' || levels <= 0) {\n return mergeObj;\n }\n\n // If the merge object is an empty object, and the initial object is not undefined, we return the initial object\n if (initialObj && Object.keys(mergeObj).length === 0) {\n return initialObj;\n }\n\n // Clone object\n const output = { ...initialObj };\n\n // Merge values into output, resursively\n for (const key in mergeObj) {\n if (Object.prototype.hasOwnProperty.call(mergeObj, key)) {\n output[key] = merge(output[key], mergeObj[key], levels - 1);\n }\n }\n\n return output;\n}\n","/**\n * Parse a sample rate from a given value.\n * This will either return a boolean or number sample rate, if the sample rate is valid (between 0 and 1).\n * If a string is passed, we try to convert it to a number.\n *\n * Any invalid sample rate will return `undefined`.\n */\nexport function parseSampleRate(sampleRate: unknown): number | undefined {\n if (typeof sampleRate === 'boolean') {\n return Number(sampleRate);\n }\n\n const rate = typeof sampleRate === 'string' ? parseFloat(sampleRate) : sampleRate;\n if (typeof rate !== 'number' || isNaN(rate) || rate < 0 || rate > 1) {\n return undefined;\n }\n\n return rate;\n}\n"],"sourceRoot":""}