openlit 1.13.0 → 1.14.0

package/dist/instrumentation/transformers/index.js

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const instrumentation_1 = require("@opentelemetry/instrumentation");
+const api_1 = require("@opentelemetry/api");
+const constant_1 = require("../../constant");
+const wrapper_1 = __importDefault(require("./wrapper"));
+/**
+ * Instruments local HuggingFace inference via the Transformers.js SDK.
+ *
+ * Supported packages (registered as separate module definitions so either
+ * package name triggers instrumentation):
+ *   - `@huggingface/transformers` (current name, v3+)
+ *   - `@xenova/transformers` (older name)
+ *
+ * Parity: the Python SDK instruments `transformers.TextGenerationPipeline.__call__`
+ * and reports it as the `chat` operation. Transformers.js implements each
+ * pipeline as a subclass whose `_call` method runs the inference, so we patch
+ * the `_call` of every known pipeline subclass (and the base `Pipeline` as a
+ * final catch). The operation type is resolved at runtime from the pipeline's
+ * `task`, so text-generation matches Python while other local pipelines
+ * (summarization, translation, feature-extraction, …) get the closest OTel
+ * operation.
+ */
+class OpenlitTransformersInstrumentation extends instrumentation_1.InstrumentationBase {
+    constructor(config = {}) {
+        super(`${constant_1.INSTRUMENTATION_PREFIX}/instrumentation-transformers`, '1.0.0', config);
+    }
+    init() {
+        const makeDef = (packageName) => new instrumentation_1.InstrumentationNodeModuleDefinition(packageName, ['>=2.0.0'], (moduleExports, moduleVersion) => {
+            this._patch(moduleExports, moduleVersion);
+            return moduleExports;
+        }, (moduleExports) => {
+            if (moduleExports !== undefined) {
+                this._unpatch(moduleExports);
+            }
+        });
+        return [makeDef('@huggingface/transformers'), makeDef('@xenova/transformers')];
+    }
+    manualPatch(transformers) {
+        this._patch(transformers);
+    }
+    _patch(moduleExports, moduleVersion) {
+        try {
+            const tracer = this.tracer;
+            const sdkVersion = moduleVersion ? String(moduleVersion) : undefined;
+            let patched = false;
+            for (const className of OpenlitTransformersInstrumentation.PIPELINE_CLASSES) {
+                const PipelineClass = moduleExports[className];
+                const proto = PipelineClass?.prototype;
+                if (!proto)
+                    continue;
+                // Only patch a class that defines its OWN `_call`, so each distinct
+                // implementation is wrapped exactly once. Subclasses that inherit
+                // `_call` reuse the ancestor's wrapped method.
+                if (!Object.prototype.hasOwnProperty.call(proto, '_call'))
+                    continue;
+                if (typeof proto._call !== 'function')
+                    continue;
+                if ((0, instrumentation_1.isWrapped)(proto._call)) {
+                    this._unwrap(proto, '_call');
+                }
+                this._wrap(proto, '_call', wrapper_1.default._patchPipelineCall(tracer, className, sdkVersion));
+                patched = true;
+            }
+            // Fallback: if no Pipeline subclass exposed `_call` (very old or very new
+            // SDK internals), wrap the `pipeline()` factory instead.
+            if (!patched && typeof moduleExports.pipeline === 'function') {
+                if (!(0, instrumentation_1.isWrapped)(moduleExports.pipeline)) {
+                    this._wrap(moduleExports, 'pipeline', wrapper_1.default._patchPipelineFactory(tracer, sdkVersion));
+                }
+            }
+        }
+        catch (e) {
+            api_1.diag.error('transformers instrumentation: error in _patch method', e);
+        }
+    }
+    _unpatch(moduleExports) {
+        try {
+            for (const className of OpenlitTransformersInstrumentation.PIPELINE_CLASSES) {
+                const proto = moduleExports[className]?.prototype;
+                if (!proto)
+                    continue;
+                if (Object.prototype.hasOwnProperty.call(proto, '_call') && (0, instrumentation_1.isWrapped)(proto._call)) {
+                    this._unwrap(proto, '_call');
+                }
+            }
+            if ((0, instrumentation_1.isWrapped)(moduleExports.pipeline)) {
+                this._unwrap(moduleExports, 'pipeline');
+            }
+        }
+        catch (e) {
+            api_1.diag.error('transformers instrumentation: error in _unpatch method', e);
+        }
+    }
+}
+/**
+ * Pipeline subclasses whose `_call` we patch. Most specific first; the base
+ * `Pipeline` is the final fallback. Subclasses that inherit `_call` from an
+ * ancestor in this list are covered by that ancestor's patch (the operation
+ * is resolved from the live instance's `task`, so the span stays correct).
+ */
+OpenlitTransformersInstrumentation.PIPELINE_CLASSES = [
+    'TextGenerationPipeline',
+    'Text2TextGenerationPipeline',
+    'SummarizationPipeline',
+    'TranslationPipeline',
+    'FillMaskPipeline',
+    'QuestionAnsweringPipeline',
+    'TextClassificationPipeline',
+    'TokenClassificationPipeline',
+    'ZeroShotClassificationPipeline',
+    'FeatureExtractionPipeline',
+    'Pipeline',
+];
+exports.default = OpenlitTransformersInstrumentation;
+//# sourceMappingURL=index.js.map

package/dist/instrumentation/transformers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/instrumentation/transformers/index.ts"],"names":[],"mappings":"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"}

package/dist/instrumentation/transformers/wrapper.d.ts

@@ -0,0 +1,49 @@
+import { Span, Tracer } from '@opentelemetry/api';
+import BaseWrapper, { BaseSpanAttributes } from '../base-wrapper';
+declare class TransformersWrapper extends BaseWrapper {
+    static aiSystem: string;
+    static serverAddress: string;
+    static serverPort: number;
+    /**
+     * Stamp `openlit.agent.version_hash` (auto) and `gen_ai.agent.version`
+     * (user override) on the span and return them so the caller can merge them
+     * into the inference-event extras.
+     */
+    static _stampAgentVersion(span: Span, args: {
+        systemInstructionsJson?: string | null;
+        primaryModel?: string;
+        temperature?: number | null;
+        top_p?: number | null;
+        max_tokens?: number | null;
+    }): Record<string, string>;
+    /**
+     * Patch a Pipeline subclass `_call` (the method invoked when the pipeline
+     * object is used as a function). `this` is the pipeline instance.
+     * args[0] = inputs, args[1] = generation options.
+     */
+    static _patchPipelineCall(tracer: Tracer, className: string, sdkVersion?: string): any;
+    /**
+     * Patch the `pipeline()` factory as a fallback when no Pipeline subclass
+     * prototype is exported. Wraps the returned callable so each invocation
+     * emits a span. The original callable is invoked directly (not via the
+     * wrapper) so we never lose its prototype behavior.
+     */
+    static _patchPipelineFactory(tracer: Tracer, sdkVersion?: string): any;
+    /**
+     * Synchronous attribute setter shared by the class- and factory-patch paths.
+     * Returns the metric params so the caller can record metrics in `finally`.
+     */
+    static _handleResponse({ instance, args, response, span, requestModel, task, operation, genAIEndpoint, ttft, sdkVersion, }: {
+        instance: any;
+        args: any[];
+        response: any;
+        span: Span;
+        requestModel: string;
+        task: string;
+        operation: string;
+        genAIEndpoint: string;
+        ttft: number;
+        sdkVersion?: string;
+    }): BaseSpanAttributes;
+}
+export default TransformersWrapper;

package/dist/instrumentation/transformers/wrapper.js

@@ -0,0 +1,472 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_1 = require("@opentelemetry/api");
+const config_1 = __importDefault(require("../../config"));
+const helpers_1 = __importStar(require("../../helpers"));
+const semantic_convention_1 = __importDefault(require("../../semantic-convention"));
+const base_wrapper_1 = __importDefault(require("../base-wrapper"));
+const TASK_OPERATION = {
+    // Generative chat-style (Python parity)
+    'text-generation': { operation: semantic_convention_1.default.GEN_AI_OPERATION_TYPE_CHAT, isEmbedding: false },
+    // Sequence-to-sequence / extractive text producers
+    'text2text-generation': { operation: semantic_convention_1.default.GEN_AI_OPERATION_TYPE_TEXT_COMPLETION, isEmbedding: false },
+    summarization: { operation: semantic_convention_1.default.GEN_AI_OPERATION_TYPE_TEXT_COMPLETION, isEmbedding: false },
+    translation: { operation: semantic_convention_1.default.GEN_AI_OPERATION_TYPE_TEXT_COMPLETION, isEmbedding: false },
+    'fill-mask': { operation: semantic_convention_1.default.GEN_AI_OPERATION_TYPE_TEXT_COMPLETION, isEmbedding: false },
+    'question-answering': { operation: semantic_convention_1.default.GEN_AI_OPERATION_TYPE_TEXT_COMPLETION, isEmbedding: false },
+    'text-classification': { operation: semantic_convention_1.default.GEN_AI_OPERATION_TYPE_TEXT_COMPLETION, isEmbedding: false },
+    'token-classification': { operation: semantic_convention_1.default.GEN_AI_OPERATION_TYPE_TEXT_COMPLETION, isEmbedding: false },
+    'zero-shot-classification': { operation: semantic_convention_1.default.GEN_AI_OPERATION_TYPE_TEXT_COMPLETION, isEmbedding: false },
+    // Embedding producers
+    'feature-extraction': { operation: semantic_convention_1.default.GEN_AI_OPERATION_TYPE_EMBEDDING, isEmbedding: true },
+    'sentence-similarity': { operation: semantic_convention_1.default.GEN_AI_OPERATION_TYPE_EMBEDDING, isEmbedding: true },
+};
+/** Map a Pipeline subclass name to its canonical Transformers.js task string. */
+const CLASS_TASK = {
+    TextGenerationPipeline: 'text-generation',
+    Text2TextGenerationPipeline: 'text2text-generation',
+    SummarizationPipeline: 'summarization',
+    TranslationPipeline: 'translation',
+    FillMaskPipeline: 'fill-mask',
+    QuestionAnsweringPipeline: 'question-answering',
+    TextClassificationPipeline: 'text-classification',
+    TokenClassificationPipeline: 'token-classification',
+    ZeroShotClassificationPipeline: 'zero-shot-classification',
+    FeatureExtractionPipeline: 'feature-extraction',
+};
+function resolveTask(instance, className) {
+    return ((typeof instance?.task === 'string' && instance.task) ||
+        CLASS_TASK[className] ||
+        'text-generation');
+}
+function classifyTask(task) {
+    return (TASK_OPERATION[task] || {
+        operation: semantic_convention_1.default.GEN_AI_OPERATION_TYPE_TEXT_COMPLETION,
+        isEmbedding: false,
+    });
+}
+/**
+ * Resolve the model identifier from a pipeline instance, mirroring Python's
+ * `instance.model.config.name_or_path`. HF configs expose the path under a few
+ * keys across versions, so we probe the common ones before falling back.
+ */
+function resolveModel(instance) {
+    const config = instance?.model?.config ?? {};
+    return (config._name_or_path ||
+        config.name_or_path ||
+        config.model_type ||
+        instance?.model?.name_or_path ||
+        (typeof instance?.task === 'string' ? instance.task : '') ||
+        'unknown');
+}
+/**
+ * Extract the generation parameters for a call, mirroring Python which reads
+ * `instance._forward_params` (set at pipeline construction) merged with the
+ * call-time options object.
+ */
+function resolveGenerationParams(instance, options) {
+    const forward = instance?._forward_params ?? {};
+    const opts = options ?? {};
+    const pick = (key, altKey) => opts[key] ?? (altKey ? opts[altKey] : undefined) ?? forward[key] ?? (altKey ? forward[altKey] : undefined) ?? null;
+    return {
+        temperature: pick('temperature'),
+        topK: pick('top_k'),
+        topP: pick('top_p'),
+        maxTokens: pick('max_new_tokens', 'max_length'),
+    };
+}
+/**
+ * Convert a Transformers.js pipeline result into a flat text string per task,
+ * mirroring the task branches in Python's `process_chat_response`.
+ */
+function extractCompletion(task, response) {
+    const first = Array.isArray(response) ? response[0] : response;
+    const fromEntry = (entry) => {
+        if (entry === null || entry === undefined)
+            return '';
+        if (typeof entry !== 'object')
+            return String(entry);
+        // text-generation may nest a chat-message list under generated_text
+        if (Array.isArray(entry.generated_text)) {
+            const last = entry.generated_text[entry.generated_text.length - 1];
+            return last?.content ?? String(last ?? '');
+        }
+        return (entry.generated_text ??
+            entry.summary_text ??
+            entry.translation_text ??
+            entry.answer ??
+            entry.sequence ??
+            entry.token_str ??
+            entry.label ??
+            entry.text ??
+            '');
+    };
+    switch (task) {
+        case 'automatic-speech-recognition':
+            return typeof response === 'object' && response !== null ? response.text ?? '' : '';
+        case 'feature-extraction':
+        case 'sentence-similarity':
+            return '';
+        default: {
+            const out = fromEntry(first);
+            if (out)
+                return out;
+            // Fall back to a stable serialization for unknown shapes.
+            try {
+                return typeof response === 'string' ? response : JSON.stringify(response);
+            }
+            catch {
+                return String(response ?? '');
+            }
+        }
+    }
+}
+function stringifyInputs(inputs) {
+    if (typeof inputs === 'string')
+        return inputs;
+    if (Array.isArray(inputs)) {
+        return inputs
+            .map((i) => (typeof i === 'string' ? i : i?.content ?? JSON.stringify(i)))
+            .join('\n');
+    }
+    if (inputs && typeof inputs === 'object') {
+        // question-answering style { question, context }
+        if (typeof inputs.question === 'string') {
+            return inputs.context
+                ? `question: ${inputs.question} context: ${inputs.context}`
+                : inputs.question;
+        }
+        try {
+            return JSON.stringify(inputs);
+        }
+        catch {
+            return String(inputs);
+        }
+    }
+    return String(inputs ?? '');
+}
+class TransformersWrapper extends base_wrapper_1.default {
+    /**
+     * Stamp `openlit.agent.version_hash` (auto) and `gen_ai.agent.version`
+     * (user override) on the span and return them so the caller can merge them
+     * into the inference-event extras.
+     */
+    static _stampAgentVersion(span, args) {
+        const out = {};
+        try {
+            const versionHash = helpers_1.default.computeAgentVersionHash({
+                systemInstructions: args.systemInstructionsJson ?? null,
+                toolDefinitions: null,
+                primaryModel: args.primaryModel ?? null,
+                runtimeConfig: {
+                    temperature: args.temperature ?? null,
+                    top_p: args.top_p ?? null,
+                    max_tokens: args.max_tokens ?? null,
+                    provider: semantic_convention_1.default.GEN_AI_SYSTEM_HUGGING_FACE,
+                },
+                providers: [semantic_convention_1.default.GEN_AI_SYSTEM_HUGGING_FACE],
+            });
+            if (versionHash) {
+                out[semantic_convention_1.default.OPENLIT_AGENT_VERSION_HASH] = versionHash;
+                span.setAttribute(semantic_convention_1.default.OPENLIT_AGENT_VERSION_HASH, versionHash);
+            }
+        }
+        catch {
+            /* Hash computation must never fail the wrapped call. */
+        }
+        const versionLabel = (0, helpers_1.getCurrentAgentVersion)();
+        if (versionLabel) {
+            out[semantic_convention_1.default.GEN_AI_AGENT_VERSION] = versionLabel;
+            span.setAttribute(semantic_convention_1.default.GEN_AI_AGENT_VERSION, versionLabel);
+        }
+        return out;
+    }
+    /**
+     * Patch a Pipeline subclass `_call` (the method invoked when the pipeline
+     * object is used as a function). `this` is the pipeline instance.
+     * args[0] = inputs, args[1] = generation options.
+     */
+    static _patchPipelineCall(tracer, className, sdkVersion) {
+        return (originalMethod) => {
+            return async function (...args) {
+                if ((0, helpers_1.isFrameworkLlmActive)())
+                    return originalMethod.apply(this, args);
+                const task = resolveTask(this, className);
+                const requestModel = resolveModel(this);
+                const { operation } = classifyTask(task);
+                const genAIEndpoint = `transformers.${task}`;
+                const spanName = `${operation} ${requestModel}`;
+                const effectiveCtx = (0, helpers_1.getFrameworkParentContext)() ?? api_1.context.active();
+                const span = tracer.startSpan(spanName, { kind: api_1.SpanKind.CLIENT, attributes: spanCreationAttrs(operation, requestModel) }, effectiveCtx);
+                return api_1.context.with(api_1.trace.setSpan(effectiveCtx, span), async () => {
+                    let metricParams;
+                    const startTime = Date.now();
+                    try {
+                        const response = await originalMethod.apply(this, args);
+                        metricParams = TransformersWrapper._handleResponse({
+                            instance: this,
+                            args,
+                            response,
+                            span,
+                            requestModel,
+                            task,
+                            operation,
+                            genAIEndpoint,
+                            ttft: (Date.now() - startTime) / 1000,
+                            sdkVersion,
+                        });
+                        return response;
+                    }
+                    catch (e) {
+                        helpers_1.default.handleException(span, e);
+                        base_wrapper_1.default.recordMetrics(span, {
+                            genAIEndpoint,
+                            model: requestModel,
+                            aiSystem: TransformersWrapper.aiSystem,
+                            serverAddress: TransformersWrapper.serverAddress,
+                            serverPort: TransformersWrapper.serverPort,
+                            errorType: e?.constructor?.name || '_OTHER',
+                        });
+                        throw e;
+                    }
+                    finally {
+                        span.end();
+                        if (metricParams) {
+                            base_wrapper_1.default.recordMetrics(span, metricParams);
+                        }
+                    }
+                });
+            };
+        };
+    }
+    /**
+     * Patch the `pipeline()` factory as a fallback when no Pipeline subclass
+     * prototype is exported. Wraps the returned callable so each invocation
+     * emits a span. The original callable is invoked directly (not via the
+     * wrapper) so we never lose its prototype behavior.
+     */
+    static _patchPipelineFactory(tracer, sdkVersion) {
+        return (originalFactory) => {
+            return async function (...factoryArgs) {
+                const pipe = await originalFactory.apply(this, factoryArgs);
+                if (typeof pipe !== 'function')
+                    return pipe;
+                const task = (typeof factoryArgs[0] === 'string' && factoryArgs[0]) ||
+                    (typeof pipe.task === 'string' && pipe.task) ||
+                    'text-generation';
+                const { operation } = classifyTask(task);
+                const genAIEndpoint = `transformers.${task}`;
+                const wrappedPipe = async function (...callArgs) {
+                    if ((0, helpers_1.isFrameworkLlmActive)())
+                        return pipe.apply(this, callArgs);
+                    const requestModel = resolveModel(pipe) ||
+                        (typeof factoryArgs[1] === 'string' ? factoryArgs[1] : 'unknown');
+                    const spanName = `${operation} ${requestModel}`;
+                    const effectiveCtx = (0, helpers_1.getFrameworkParentContext)() ?? api_1.context.active();
+                    const span = tracer.startSpan(spanName, { kind: api_1.SpanKind.CLIENT, attributes: spanCreationAttrs(operation, requestModel) }, effectiveCtx);
+                    return api_1.context.with(api_1.trace.setSpan(effectiveCtx, span), async () => {
+                        let metricParams;
+                        const startTime = Date.now();
+                        try {
+                            const response = await pipe.apply(this, callArgs);
+                            metricParams = TransformersWrapper._handleResponse({
+                                instance: pipe,
+                                args: callArgs,
+                                response,
+                                span,
+                                requestModel,
+                                task,
+                                operation,
+                                genAIEndpoint,
+                                ttft: (Date.now() - startTime) / 1000,
+                                sdkVersion,
+                            });
+                            return response;
+                        }
+                        catch (e) {
+                            helpers_1.default.handleException(span, e);
+                            base_wrapper_1.default.recordMetrics(span, {
+                                genAIEndpoint,
+                                model: requestModel,
+                                aiSystem: TransformersWrapper.aiSystem,
+                                serverAddress: TransformersWrapper.serverAddress,
+                                serverPort: TransformersWrapper.serverPort,
+                                errorType: e?.constructor?.name || '_OTHER',
+                            });
+                            throw e;
+                        }
+                        finally {
+                            span.end();
+                            if (metricParams) {
+                                base_wrapper_1.default.recordMetrics(span, metricParams);
+                            }
+                        }
+                    });
+                };
+                // Preserve callable identity so the wrapped pipe behaves like the original.
+                Object.setPrototypeOf(wrappedPipe, Object.getPrototypeOf(pipe));
+                Object.assign(wrappedPipe, pipe);
+                return wrappedPipe;
+            };
+        };
+    }
+    /**
+     * Synchronous attribute setter shared by the class- and factory-patch paths.
+     * Returns the metric params so the caller can record metrics in `finally`.
+     */
+    static _handleResponse({ instance, args, response, span, requestModel, task, operation, genAIEndpoint, ttft, sdkVersion, }) {
+        const captureContent = config_1.default.captureMessageContent;
+        const { isEmbedding } = classifyTask(task);
+        const inputs = args[0];
+        const options = args[1] || {};
+        const { temperature, topK, topP, maxTokens } = resolveGenerationParams(instance, options);
+        const inputStr = stringifyInputs(inputs);
+        const completion = extractCompletion(task, response);
+        const inputTokens = helpers_1.default.generalTokens(inputStr) ?? 0;
+        const outputTokens = isEmbedding ? 0 : helpers_1.default.generalTokens(completion) ?? 0;
+        const pricingInfo = config_1.default.pricingInfo || {};
+        const cost = helpers_1.default.getChatModelCost(requestModel, pricingInfo, inputTokens, outputTokens);
+        // Common attributes (telemetry sdk, env, app, request model, cost, server).
+        TransformersWrapper.setBaseSpanAttributes(span, {
+            genAIEndpoint,
+            model: requestModel,
+            cost,
+            aiSystem: TransformersWrapper.aiSystem,
+            serverAddress: TransformersWrapper.serverAddress,
+            serverPort: TransformersWrapper.serverPort,
+        });
+        // Parity: Python stamps gen_ai.system and the transformers package version
+        // (setBaseSpanAttributes uses OpenLIT's SDK version).
+        span.setAttribute(semantic_convention_1.default.GEN_AI_PROVIDER_NAME, TransformersWrapper.aiSystem);
+        if (sdkVersion) {
+            span.setAttribute(semantic_convention_1.default.GEN_AI_SDK_VERSION, sdkVersion);
+        }
+        // Request parameters (only when present, matching Python).
+        if (temperature !== null) {
+            span.setAttribute(semantic_convention_1.default.GEN_AI_REQUEST_TEMPERATURE, temperature);
+        }
+        if (topK !== null) {
+            span.setAttribute(semantic_convention_1.default.GEN_AI_REQUEST_TOP_K, topK);
+        }
+        if (topP !== null) {
+            span.setAttribute(semantic_convention_1.default.GEN_AI_REQUEST_TOP_P, topP);
+        }
+        if (maxTokens !== null) {
+            span.setAttribute(semantic_convention_1.default.GEN_AI_REQUEST_MAX_TOKENS, maxTokens);
+        }
+        span.setAttribute(semantic_convention_1.default.GEN_AI_REQUEST_IS_STREAM, false);
+        // Response parameters.
+        span.setAttribute(semantic_convention_1.default.GEN_AI_RESPONSE_MODEL, requestModel);
+        if (!isEmbedding) {
+            span.setAttribute(semantic_convention_1.default.GEN_AI_RESPONSE_FINISH_REASON, ['stop']);
+            span.setAttribute(semantic_convention_1.default.GEN_AI_OUTPUT_TYPE, semantic_convention_1.default.GEN_AI_OUTPUT_TYPE_TEXT);
+        }
+        // Tokens, cost, cache (cache stamped as 0 even when unused, like Python).
+        span.setAttribute(semantic_convention_1.default.GEN_AI_USAGE_INPUT_TOKENS, inputTokens);
+        span.setAttribute(semantic_convention_1.default.GEN_AI_USAGE_OUTPUT_TOKENS, outputTokens);
+        span.setAttribute(semantic_convention_1.default.GEN_AI_CLIENT_TOKEN_USAGE, inputTokens + outputTokens);
+        span.setAttribute(semantic_convention_1.default.GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS, 0);
+        span.setAttribute(semantic_convention_1.default.GEN_AI_USAGE_CACHE_CREATION_INPUT_TOKENS, 0);
+        // Timing (Python always sets these; tbt is 0 for non-streaming pipelines).
+        span.setAttribute(semantic_convention_1.default.GEN_AI_SERVER_TTFT, ttft);
+        span.setAttribute(semantic_convention_1.default.GEN_AI_SERVER_TBT, 0);
+        const versionExtras = TransformersWrapper._stampAgentVersion(span, {
+            systemInstructionsJson: null,
+            primaryModel: requestModel,
+            temperature,
+            top_p: topP,
+            max_tokens: maxTokens,
+        });
+        let inputMessagesJson;
+        let outputMessagesJson;
+        if (captureContent) {
+            inputMessagesJson = helpers_1.default.buildInputMessages([{ role: 'user', content: inputStr }]);
+            span.setAttribute(semantic_convention_1.default.GEN_AI_INPUT_MESSAGES, inputMessagesJson);
+            if (!isEmbedding) {
+                outputMessagesJson = helpers_1.default.buildOutputMessages(completion, 'stop');
+                span.setAttribute(semantic_convention_1.default.GEN_AI_OUTPUT_MESSAGES, outputMessagesJson);
+            }
+        }
+        if (!config_1.default.disableEvents) {
+            const eventAttrs = {
+                [semantic_convention_1.default.GEN_AI_OPERATION]: operation,
+                [semantic_convention_1.default.GEN_AI_REQUEST_MODEL]: requestModel,
+                [semantic_convention_1.default.GEN_AI_RESPONSE_MODEL]: requestModel,
+                [semantic_convention_1.default.SERVER_ADDRESS]: TransformersWrapper.serverAddress,
+                [semantic_convention_1.default.SERVER_PORT]: TransformersWrapper.serverPort,
+                [semantic_convention_1.default.GEN_AI_USAGE_INPUT_TOKENS]: inputTokens,
+                [semantic_convention_1.default.GEN_AI_USAGE_OUTPUT_TOKENS]: outputTokens,
+                ...versionExtras,
+            };
+            if (!isEmbedding) {
+                eventAttrs[semantic_convention_1.default.GEN_AI_RESPONSE_FINISH_REASON] = ['stop'];
+                eventAttrs[semantic_convention_1.default.GEN_AI_OUTPUT_TYPE] = semantic_convention_1.default.GEN_AI_OUTPUT_TYPE_TEXT;
+            }
+            if (captureContent) {
+                if (inputMessagesJson)
+                    eventAttrs[semantic_convention_1.default.GEN_AI_INPUT_MESSAGES] = inputMessagesJson;
+                if (outputMessagesJson)
+                    eventAttrs[semantic_convention_1.default.GEN_AI_OUTPUT_MESSAGES] = outputMessagesJson;
+            }
+            helpers_1.default.emitInferenceEvent(span, eventAttrs);
+        }
+        return {
+            genAIEndpoint,
+            model: requestModel,
+            cost,
+            aiSystem: TransformersWrapper.aiSystem,
+            serverAddress: TransformersWrapper.serverAddress,
+            serverPort: TransformersWrapper.serverPort,
+        };
+    }
+}
+TransformersWrapper.aiSystem = semantic_convention_1.default.GEN_AI_SYSTEM_HUGGING_FACE;
+TransformersWrapper.serverAddress = '127.0.0.1';
+TransformersWrapper.serverPort = 80;
+function spanCreationAttrs(operationName, requestModel) {
+    return {
+        [semantic_convention_1.default.GEN_AI_OPERATION]: operationName,
+        [semantic_convention_1.default.GEN_AI_PROVIDER_NAME_OTEL]: semantic_convention_1.default.GEN_AI_SYSTEM_HUGGING_FACE,
+        [semantic_convention_1.default.GEN_AI_REQUEST_MODEL]: requestModel,
+        [semantic_convention_1.default.SERVER_ADDRESS]: TransformersWrapper.serverAddress,
+        [semantic_convention_1.default.SERVER_PORT]: TransformersWrapper.serverPort,
+    };
+}
+exports.default = TransformersWrapper;
+//# sourceMappingURL=wrapper.js.map