@depup/sentry__node 10.44.0-depup.0

package/build/types-ts3.8/integrations/tracing/graphql.d.ts

@@ -0,0 +1,48 @@
+import { GraphQLInstrumentation } from '@opentelemetry/instrumentation-graphql';
+interface GraphqlOptions {
+    /**
+     * Do not create spans for resolvers.
+     *
+     * Defaults to true.
+     */
+    ignoreResolveSpans?: boolean;
+    /**
+     * Don't create spans for the execution of the default resolver on object properties.
+     *
+     * When a resolver function is not defined on the schema for a field, graphql will
+     * use the default resolver which just looks for a property with that name on the object.
+     * If the property is not a function, it's not very interesting to trace.
+     * This option can reduce noise and number of spans created.
+     *
+     * Defaults to true.
+     */
+    ignoreTrivialResolveSpans?: boolean;
+    /**
+     * If this is enabled, a http.server root span containing this span will automatically be renamed to include the operation name.
+     * Set this to `false` if you do not want this behavior, and want to keep the default http.server span name.
+     *
+     * Defaults to true.
+     */
+    useOperationNameForRootSpan?: boolean;
+}
+export declare const instrumentGraphql: ((options: GraphqlOptions) => GraphQLInstrumentation) & {
+    id: string;
+};
+/**
+ * Adds Sentry tracing instrumentation for the [graphql](https://www.npmjs.com/package/graphql) library.
+ *
+ * For more information, see the [`graphqlIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/graphql/).
+ *
+ * @param {GraphqlOptions} options Configuration options for the GraphQL integration.
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.graphqlIntegration()],
+ * });
+ */
+export declare const graphqlIntegration: (options?: GraphqlOptions | undefined) => import("@sentry/core").Integration;
+export {};
+//# sourceMappingURL=graphql.d.ts.map

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

@@ -0,0 +1,50 @@
+import { HapiInstrumentation } from '@opentelemetry/instrumentation-hapi';
+import { Server } from './types';
+export declare const instrumentHapi: ((options?: unknown) => HapiInstrumentation) & {
+    id: string;
+};
+/**
+ * Adds Sentry tracing instrumentation for [Hapi](https://hapi.dev/).
+ *
+ * If you also want to capture errors, you need to call `setupHapiErrorHandler(server)` after you set up your server.
+ *
+ * For more information, see the [hapi documentation](https://docs.sentry.io/platforms/javascript/guides/hapi/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *   integrations: [Sentry.hapiIntegration()],
+ * })
+ * ```
+ */
+export declare const hapiIntegration: () => import("@sentry/core").Integration;
+export declare const hapiErrorPlugin: {
+    name: string;
+    version: string;
+    register: (serverArg: Record<any, any>) => Promise<void>;
+};
+/**
+ * Add a Hapi plugin to capture errors to Sentry.
+ *
+ * @param server The Hapi server to attach the error handler to
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ * const Hapi = require('@hapi/hapi');
+ *
+ * const init = async () => {
+ *   const server = Hapi.server();
+ *
+ *   // all your routes here
+ *
+ *   await Sentry.setupHapiErrorHandler(server);
+ *
+ *   await server.start();
+ * };
+ * ```
+ */
+export declare function setupHapiErrorHandler(server: Server): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/integrations/tracing/hapi/types.d.ts

@@ -0,0 +1,166 @@
+import * as stream from 'stream';
+interface Podium {
+    new (events?: Events[]): Podium;
+    new (events?: Events): Podium;
+    registerEvent(events: Events[]): void;
+    registerEvent(events: Events): void;
+    registerPodium?(podiums: Podium[]): void;
+    registerPodium?(podiums: Podium): void;
+    emit(criteria: string | {
+        name: string;
+        channel?: string | undefined;
+        tags?: string | string[] | undefined;
+    }, data: any, callback?: () => void): void;
+    on(criteria: string | Criteria, listener: Listener): void;
+    addListener(criteria: string | Criteria, listener: Listener): void;
+    once(criteria: string | Criteria, listener: Listener): void;
+    removeListener(name: string, listener: Listener): Podium;
+    removeAllListeners(name: string): Podium;
+    hasListeners(name: string): boolean;
+}
+export interface Boom<Data = any> extends Error {
+    isBoom: boolean;
+    isServer: boolean;
+    message: string;
+    output: Output;
+    reformat: () => string;
+    isMissing?: boolean | undefined;
+    data: Data;
+}
+export interface Output {
+    statusCode: number;
+    headers: {
+        [index: string]: string;
+    };
+    payload: Payload;
+}
+export interface Payload {
+    statusCode: number;
+    error: string;
+    message: string;
+    attributes?: any;
+}
+export type Events = string | EventOptionsObject | Podium;
+export interface EventOptionsObject {
+    name: string;
+    channels?: string | string[] | undefined;
+    clone?: boolean | undefined;
+    spread?: boolean | undefined;
+    tags?: boolean | undefined;
+    shared?: boolean | undefined;
+}
+export interface CriteriaObject {
+    name: string;
+    block?: boolean | number | undefined;
+    channels?: string | string[] | undefined;
+    clone?: boolean | undefined;
+    count?: number | undefined;
+    filter?: string | string[] | CriteriaFilterOptionsObject | undefined;
+    spread?: boolean | undefined;
+    tags?: boolean | undefined;
+    listener?: Listener | undefined;
+}
+export interface CriteriaFilterOptionsObject {
+    tags?: string | string[] | undefined;
+    all?: boolean | undefined;
+}
+export type Criteria = string | CriteriaObject;
+export interface Listener {
+    (data: any, tags?: Tags, callback?: () => void): void;
+}
+export type Tags = {
+    [tag: string]: boolean;
+};
+interface UserCredentials {
+}
+interface AppCredentials {
+}
+interface AuthCredentials {
+    scope?: string[] | undefined;
+    user?: UserCredentials | undefined;
+    app?: AppCredentials | undefined;
+}
+interface RequestAuth {
+    artifacts: object;
+    credentials: AuthCredentials;
+    error: Error;
+    isAuthenticated: boolean;
+    isAuthorized: boolean;
+    mode: string;
+    strategy: string;
+}
+interface RequestEvents extends Podium {
+    on(criteria: 'peek', listener: PeekListener): void;
+    on(criteria: 'finish' | 'disconnect', listener: (data: undefined) => void): void;
+    once(criteria: 'peek', listener: PeekListener): void;
+    once(criteria: 'finish' | 'disconnect', listener: (data: undefined) => void): void;
+}
+declare namespace Lifecycle {
+    type Method = (request: Request, h: ResponseToolkit, err?: Error) => ReturnValue;
+    type ReturnValue = ReturnValueTypes | Promise<ReturnValueTypes>;
+    type ReturnValueTypes = (null | string | number | boolean) | Buffer | (Error | Boom) | stream.Stream | (object | object[]) | symbol | ResponseToolkit;
+    type FailAction = 'error' | 'log' | 'ignore' | Method;
+}
+declare namespace Util {
+    interface Dictionary<T> {
+        [key: string]: T;
+    }
+    type HTTP_METHODS_PARTIAL_LOWERCASE = 'get' | 'post' | 'put' | 'patch' | 'delete' | 'options';
+    type HTTP_METHODS_PARTIAL = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | HTTP_METHODS_PARTIAL_LOWERCASE;
+    type HTTP_METHODS = 'HEAD' | 'head' | HTTP_METHODS_PARTIAL;
+}
+interface RequestRoute {
+    method: Util.HTTP_METHODS_PARTIAL;
+    path: string;
+    vhost?: string | string[] | undefined;
+    realm: any;
+    fingerprint: string;
+    auth: {
+        access(request: Request): boolean;
+    };
+}
+export interface Request extends Podium {
+    app: ApplicationState;
+    readonly auth: RequestAuth;
+    events: RequestEvents;
+    readonly headers: Util.Dictionary<string>;
+    readonly path: string;
+    response: ResponseObject | Boom | null;
+    readonly route: RequestRoute;
+    readonly url: URL;
+}
+interface ResponseObjectHeaderOptions {
+    append?: boolean | undefined;
+    separator?: string | undefined;
+    override?: boolean | undefined;
+    duplicate?: boolean | undefined;
+}
+export interface ResponseObject extends Podium {
+    readonly statusCode: number;
+    header(name: string, value: string, options?: ResponseObjectHeaderOptions): ResponseObject;
+}
+interface ResponseToolkit {
+    readonly continue: symbol;
+}
+export interface RequestEvent {
+    timestamp: string;
+    tags: string[];
+    channel: 'internal' | 'app' | 'error';
+    data: object;
+    error: object;
+}
+interface ServerEvents {
+    on(criteria: any, listener: any): void;
+}
+export type Server = Record<string, any> & {
+    events: ServerEvents;
+    register: any;
+    ext(event: any, method: Lifecycle.Method, options?: Record<string, any>): void;
+    initialize(): Promise<void>;
+    start(): Promise<void>;
+};
+interface ApplicationState {
+}
+type PeekListener = (chunk: string, encoding: string) => void;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/build/types-ts3.8/integrations/tracing/hono/constants.d.ts

@@ -0,0 +1,11 @@
+export declare const AttributeNames: {
+    readonly HONO_TYPE: "hono.type";
+    readonly HONO_NAME: "hono.name";
+};
+export type AttributeNames = (typeof AttributeNames)[keyof typeof AttributeNames];
+export declare const HonoTypes: {
+    readonly MIDDLEWARE: "middleware";
+    readonly REQUEST_HANDLER: "request_handler";
+};
+export type HonoTypes = (typeof HonoTypes)[keyof typeof HonoTypes];
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1,52 @@
+import { HonoInstrumentation } from './instrumentation';
+import { Context, MiddlewareHandlerInterface } from './types';
+export declare const instrumentHono: ((options?: unknown) => HonoInstrumentation) & {
+    id: string;
+};
+/**
+ * Adds Sentry tracing instrumentation for [Hono](https://hono.dev/).
+ *
+ * If you also want to capture errors, you need to call `setupHonoErrorHandler(app)` after you set up your Hono server.
+ *
+ * For more information, see the [hono documentation](https://docs.sentry.io/platforms/javascript/guides/hono/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *   integrations: [Sentry.honoIntegration()],
+ * })
+ * ```
+ */
+export declare const honoIntegration: () => import("@sentry/core").Integration;
+interface HonoHandlerOptions {
+    /**
+     * Callback method deciding whether error should be captured and sent to Sentry
+     * @param error Captured Hono error
+     */
+    shouldHandleError: (context: Context) => boolean;
+}
+/**
+ * Add a Hono error handler to capture errors to Sentry.
+ *
+ * @param app The Hono instances
+ * @param options Configuration options for the handler
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ * const { Hono } = require("hono");
+ *
+ * const app = new Hono();
+ *
+ * Sentry.setupHonoErrorHandler(app);
+ *
+ * // Add your routes, etc.
+ * ```
+ */
+export declare function setupHonoErrorHandler(app: {
+    use: MiddlewareHandlerInterface;
+}, options?: Partial<HonoHandlerOptions>): void;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/integrations/tracing/hono/instrumentation.d.ts

@@ -0,0 +1,55 @@
+import { Span } from '@opentelemetry/api';
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+export interface HonoResponseHookFunction {
+    (span: Span): void;
+}
+export interface HonoInstrumentationConfig extends InstrumentationConfig {
+    /** Function for adding custom span attributes from the response */
+    responseHook?: HonoResponseHookFunction;
+}
+/**
+ * Hono instrumentation for OpenTelemetry
+ */
+export declare class HonoInstrumentation extends InstrumentationBase<HonoInstrumentationConfig> {
+    constructor(config?: HonoInstrumentationConfig);
+    /**
+     * Initialize the instrumentation.
+     */
+    init(): InstrumentationNodeModuleDefinition[];
+    /**
+     * Patches the module exports to instrument Hono.
+     */
+    private _patch;
+    /**
+     * Patches the route handler to instrument it.
+     */
+    private _patchHandler;
+    /**
+     * Patches the 'on' handler to instrument it.
+     */
+    private _patchOnHandler;
+    /**
+     * Patches the middleware handler to instrument it.
+     */
+    private _patchMiddlewareHandler;
+    /**
+     * Wraps a handler or middleware handler to apply instrumentation.
+     */
+    private _wrapHandler;
+    /**
+     * Safely executes a function and handles errors.
+     */
+    private _safeExecute;
+    /**
+     * Determines the handler type based on the result.
+     * @param result
+     * @private
+     */
+    private _determineHandlerType;
+    /**
+     * Handles errors by setting the span status and recording the exception.
+     */
+    private _handleError;
+}
+//# sourceMappingURL=instrumentation.d.ts.map

package/build/types-ts3.8/integrations/tracing/hono/types.d.ts

@@ -0,0 +1,36 @@
+export type HonoRequest = {
+    path: string;
+    method: string;
+};
+export type Context = {
+    req: HonoRequest;
+    res: Response;
+    error: Error | undefined;
+};
+export type Next = () => Promise<void>;
+export type Handler = (c: Context, next: Next) => Promise<Response> | Response;
+export type MiddlewareHandler = (c: Context, next: Next) => Promise<Response | void>;
+export type HandlerInterface = {
+    (...handlers: (Handler | MiddlewareHandler)[]): HonoInstance;
+    (path: string, ...handlers: (Handler | MiddlewareHandler)[]): HonoInstance;
+};
+export type OnHandlerInterface = {
+    (method: string | string[], path: string | string[], ...handlers: (Handler | MiddlewareHandler)[]): HonoInstance;
+};
+export type MiddlewareHandlerInterface = {
+    (...handlers: MiddlewareHandler[]): HonoInstance;
+    (path: string, ...handlers: MiddlewareHandler[]): HonoInstance;
+};
+export interface HonoInstance {
+    get: HandlerInterface;
+    post: HandlerInterface;
+    put: HandlerInterface;
+    delete: HandlerInterface;
+    options: HandlerInterface;
+    patch: HandlerInterface;
+    all: HandlerInterface;
+    on: OnHandlerInterface;
+    use: MiddlewareHandlerInterface;
+}
+export type Hono = new (...args: unknown[]) => HonoInstance;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,12 @@
+import { Integration } from '@sentry/core';
+/**
+ * With OTEL, all performance integrations will be added, as OTEL only initializes them when the patched package is actually required.
+ */
+export declare function getAutoPerformanceIntegrations(): Integration[];
+/**
+ * Get a list of methods to instrument OTEL, when preload instrumentation.
+ */
+export declare function getOpenTelemetryInstrumentationToPreload(): (((options?: any) => void) & {
+    id: string;
+})[];
+//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/integrations/tracing/kafka.d.ts

@@ -0,0 +1,19 @@
+import { KafkaJsInstrumentation } from '@opentelemetry/instrumentation-kafkajs';
+export declare const instrumentKafka: ((options?: unknown) => KafkaJsInstrumentation) & {
+    id: string;
+};
+/**
+ * Adds Sentry tracing instrumentation for the [kafkajs](https://www.npmjs.com/package/kafkajs) library.
+ *
+ * For more information, see the [`kafkaIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/kafka/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.kafkaIntegration()],
+ * });
+ */
+export declare const kafkaIntegration: () => import("@sentry/core").Integration;
+//# sourceMappingURL=kafka.d.ts.map

package/build/types-ts3.8/integrations/tracing/knex.d.ts

@@ -0,0 +1,20 @@
+import { KnexInstrumentation } from '@opentelemetry/instrumentation-knex';
+export declare const instrumentKnex: ((options?: unknown) => KnexInstrumentation) & {
+    id: string;
+};
+/**
+ * Knex integration
+ *
+ * Capture tracing data for [Knex](https://knexjs.org/).
+ *
+ * @example
+ * ```javascript
+ * import * as Sentry from '@sentry/node';
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.knexIntegration()],
+ * });
+ * ```
+ */
+export declare const knexIntegration: () => import("@sentry/core").Integration;
+//# sourceMappingURL=knex.d.ts.map

package/build/types-ts3.8/integrations/tracing/koa.d.ts

@@ -0,0 +1,70 @@
+import { KoaInstrumentation } from '@opentelemetry/instrumentation-koa';
+interface KoaOptions {
+    /**
+     * Ignore layers of specified types
+     */
+    ignoreLayersType?: Array<'middleware' | 'router'>;
+}
+export declare const instrumentKoa: ((options: KoaOptions | undefined) => KoaInstrumentation) & {
+    id: string;
+};
+/**
+ * Adds Sentry tracing instrumentation for [Koa](https://koajs.com/).
+ *
+ * If you also want to capture errors, you need to call `setupKoaErrorHandler(app)` after you set up your Koa server.
+ *
+ * For more information, see the [koa documentation](https://docs.sentry.io/platforms/javascript/guides/koa/).
+ *
+ * @param {KoaOptions} options Configuration options for the Koa integration.
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *   integrations: [Sentry.koaIntegration()],
+ * })
+ * ```
+ *
+ * @example
+ * ```javascript
+ * // To ignore middleware spans
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *   integrations: [
+ *     Sentry.koaIntegration({
+ *       ignoreLayersType: ['middleware']
+ *     })
+ *   ],
+ * })
+ * ```
+ */
+export declare const koaIntegration: (options?: KoaOptions | undefined) => import("@sentry/core").Integration;
+/**
+ * Add an Koa error handler to capture errors to Sentry.
+ *
+ * The error handler must be before any other middleware and after all controllers.
+ *
+ * @param app The Express instances
+ * @param options {ExpressHandlerOptions} Configuration options for the handler
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ * const Koa = require("koa");
+ *
+ * const app = new Koa();
+ *
+ * Sentry.setupKoaErrorHandler(app);
+ *
+ * // Add your routes, etc.
+ *
+ * app.listen(3000);
+ * ```
+ */
+export declare const setupKoaErrorHandler: (app: {
+    use: (arg0: (ctx: any, next: any) => Promise<void>) => void;
+}) => void;
+export {};
+//# sourceMappingURL=koa.d.ts.map

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

@@ -0,0 +1,97 @@
+import { LangChainOptions } from '@sentry/core';
+export declare const instrumentLangChain: ((options?: LangChainOptions | undefined) => import("@opentelemetry/instrumentation").Instrumentation<import("@opentelemetry/instrumentation").InstrumentationConfig>) & {
+    id: string;
+};
+/**
+ * Adds Sentry tracing instrumentation for LangChain.
+ *
+ * This integration is enabled by default.
+ *
+ * When configured, this integration automatically instruments LangChain runnable instances
+ * to capture telemetry data by injecting Sentry callback handlers into all LangChain calls.
+ *
+ * **Important:** This integration automatically skips wrapping the OpenAI, Anthropic, and Google GenAI
+ * providers to prevent duplicate spans when using LangChain with these AI providers.
+ * LangChain handles the instrumentation for all underlying AI providers.
+ *
+ * @example
+ * ```javascript
+ * import * as Sentry from '@sentry/node';
+ * import { ChatOpenAI } from '@langchain/openai';
+ *
+ * Sentry.init({
+ *   integrations: [Sentry.langChainIntegration()],
+ *   sendDefaultPii: true, // Enable to record inputs/outputs
+ * });
+ *
+ * // LangChain calls are automatically instrumented
+ * const model = new ChatOpenAI();
+ * await model.invoke("What is the capital of France?");
+ * ```
+ *
+ * ## Manual Callback Handler
+ *
+ * You can also manually add the Sentry callback handler alongside other callbacks:
+ *
+ * @example
+ * ```javascript
+ * import * as Sentry from '@sentry/node';
+ * import { ChatOpenAI } from '@langchain/openai';
+ *
+ * const sentryHandler = Sentry.createLangChainCallbackHandler({
+ *   recordInputs: true,
+ *   recordOutputs: true
+ * });
+ *
+ * const model = new ChatOpenAI();
+ * await model.invoke(
+ *   "What is the capital of France?",
+ *   { callbacks: [sentryHandler, myOtherCallback] }
+ * );
+ * ```
+ *
+ * ## Options
+ *
+ * - `recordInputs`: Whether to record input messages/prompts (default: respects `sendDefaultPii` client option)
+ * - `recordOutputs`: Whether to record response text (default: respects `sendDefaultPii` client option)
+ *
+ * ### Default Behavior
+ *
+ * By default, the integration will:
+ * - Record inputs and outputs ONLY if `sendDefaultPii` is set to `true` in your Sentry client options
+ * - Otherwise, inputs and outputs are NOT recorded unless explicitly enabled
+ *
+ * @example
+ * ```javascript
+ * // Record inputs and outputs when sendDefaultPii is false
+ * Sentry.init({
+ *   integrations: [
+ *     Sentry.langChainIntegration({
+ *       recordInputs: true,
+ *       recordOutputs: true
+ *     })
+ *   ],
+ * });
+ *
+ * // Never record inputs/outputs regardless of sendDefaultPii
+ * Sentry.init({
+ *   sendDefaultPii: true,
+ *   integrations: [
+ *     Sentry.langChainIntegration({
+ *       recordInputs: false,
+ *       recordOutputs: false
+ *     })
+ *   ],
+ * });
+ * ```
+ *
+ * ## Supported Events
+ *
+ * The integration captures the following LangChain lifecycle events:
+ * - LLM/Chat Model: start, end, error
+ * - Chain: start, end, error
+ * - Tool: start, end, error
+ *
+ */
+export declare const langChainIntegration: (options?: LangChainOptions | undefined) => import("@sentry/core").Integration;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,29 @@
+import { InstrumentationBase, InstrumentationConfig, InstrumentationModuleDefinition } from '@opentelemetry/instrumentation';
+import { LangChainOptions } from '@sentry/core';
+type LangChainInstrumentationOptions = InstrumentationConfig & LangChainOptions;
+/**
+ * Sentry LangChain instrumentation using OpenTelemetry.
+ */
+export declare class SentryLangChainInstrumentation extends InstrumentationBase<LangChainInstrumentationOptions> {
+    constructor(config?: LangChainInstrumentationOptions);
+    /**
+     * Initializes the instrumentation by defining the modules to be patched.
+     * We patch the BaseChatModel class methods to inject callbacks
+     *
+     * We hook into provider packages (@langchain/anthropic, @langchain/openai, etc.)
+     * because @langchain/core is often bundled and not loaded as a separate module
+     */
+    init(): InstrumentationModuleDefinition | InstrumentationModuleDefinition[];
+    /**
+     * Core patch logic - patches chat model methods to inject Sentry callbacks
+     * This is called when a LangChain provider package is loaded
+     */
+    private _patch;
+    /**
+     * Patches chat model methods (invoke, stream, batch) to inject Sentry callbacks
+     * Finds a chat model class from the provider package exports and patches its prototype methods
+     */
+    private _patchRunnableMethods;
+}
+export {};
+//# sourceMappingURL=instrumentation.d.ts.map