weflayr 0.24.0 → 0.26.1

package/dist/src/instrumentation/vercel/get_structured_output_schema_telemetry.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Structured-output schema capture for Vercel AI SDK (ai >= 7) model-call spans.
+ *
+ * A `generateObject` call's schema is only ever emitted on the operation's ROOT
+ * span (`onObjectOperationStart` stamps `ai.schema` there under the
+ * supplemental-attributes opt-in) — and weflayr's span filter drops that
+ * aggregate span, keeping one span per model call. So the schema never reaches
+ * the exported span, even though the gateway bills it as input.
+ *
+ * The operation and its nested model call share one `callId` in the
+ * dispatcher's call state. Wrap `onObjectOperationStart` to remember the
+ * event's schema by callId, and `onObjectStepEnd` — the object operation's own
+ * model-call hook, where the call state's `inferenceSpan` exists (object
+ * operations never fire `onLanguageModelCallEnd`; verified live) — to stamp it
+ * as `ai.schema` on that span, the attribute the worker already reads.
+ * `cleanupCallState` is wrapped so an operation that errors before its model
+ * call does not leak its entry.
+ */
+export declare class VercelStructuredOutputSchemaInstrumentor {
+    private _patched;
+    private _schemasByCallId;
+    instrument(dispatcher: any): void;
+    uninstrument(): void;
+}

package/dist/src/instrumentation/vercel/get_structured_output_schema_telemetry.js

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * Structured-output schema capture for Vercel AI SDK (ai >= 7) model-call spans.
+ *
+ * A `generateObject` call's schema is only ever emitted on the operation's ROOT
+ * span (`onObjectOperationStart` stamps `ai.schema` there under the
+ * supplemental-attributes opt-in) — and weflayr's span filter drops that
+ * aggregate span, keeping one span per model call. So the schema never reaches
+ * the exported span, even though the gateway bills it as input.
+ *
+ * The operation and its nested model call share one `callId` in the
+ * dispatcher's call state. Wrap `onObjectOperationStart` to remember the
+ * event's schema by callId, and `onObjectStepEnd` — the object operation's own
+ * model-call hook, where the call state's `inferenceSpan` exists (object
+ * operations never fire `onLanguageModelCallEnd`; verified live) — to stamp it
+ * as `ai.schema` on that span, the attribute the worker already reads.
+ * `cleanupCallState` is wrapped so an operation that errors before its model
+ * call does not leak its entry.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VercelStructuredOutputSchemaInstrumentor = void 0;
+const SCHEMA_ATTR = 'ai.schema';
+class VercelStructuredOutputSchemaInstrumentor {
+    // [owner, methodName, originalFunction] for uninstrument().
+    _patched = [];
+    _schemasByCallId = new Map();
+    // No-op (and never throws) if the interface is missing — the worst case is
+    // the schema capture staying empty, exactly the pre-complement behaviour.
+    instrument(dispatcher) {
+        if (!dispatcher ||
+            typeof dispatcher.onObjectOperationStart !== 'function' ||
+            typeof dispatcher.onObjectStepEnd !== 'function') {
+            return;
+        }
+        const schemasByCallId = this._schemasByCallId;
+        const originalOperationStart = dispatcher.onObjectOperationStart;
+        dispatcher.onObjectOperationStart = function onObjectOperationStartWithSchema(event) {
+            try {
+                if (event && event.callId && event.schema && typeof event.schema === 'object') {
+                    schemasByCallId.set(event.callId, event.schema);
+                }
+            }
+            catch {
+                // Never break span creation over an enrichment failure.
+            }
+            return originalOperationStart.call(this, event);
+        };
+        this._patched.push([dispatcher, 'onObjectOperationStart', originalOperationStart]);
+        const originalStepEnd = dispatcher.onObjectStepEnd;
+        dispatcher.onObjectStepEnd = function onObjectStepEndWithSchema(event) {
+            try {
+                const schema = event && schemasByCallId.get(event.callId);
+                if (schema) {
+                    const callState = this.getCallState && this.getCallState(event.callId);
+                    const span = callState && callState.inferenceSpan;
+                    if (span && typeof span.setAttribute === 'function') {
+                        span.setAttribute(SCHEMA_ATTR, JSON.stringify(schema));
+                    }
+                }
+            }
+            catch {
+                // Never break span finalization over an enrichment failure.
+            }
+            return originalStepEnd.call(this, event);
+        };
+        this._patched.push([dispatcher, 'onObjectStepEnd', originalStepEnd]);
+        const originalCleanup = dispatcher.cleanupCallState;
+        if (typeof originalCleanup === 'function') {
+            dispatcher.cleanupCallState = function cleanupCallStateWithSchema(callId) {
+                schemasByCallId.delete(callId);
+                return originalCleanup.call(this, callId);
+            };
+            this._patched.push([dispatcher, 'cleanupCallState', originalCleanup]);
+        }
+    }
+    uninstrument() {
+        for (const [owner, methodName, original] of this._patched) {
+            owner[methodName] = original;
+        }
+        this._patched = [];
+        this._schemasByCallId.clear();
+    }
+}
+exports.VercelStructuredOutputSchemaInstrumentor = VercelStructuredOutputSchemaInstrumentor;

package/dist/src/logger.d.ts

@@ -0,0 +1 @@
+export declare const debug: import("node:util").DebugLogger;

package/dist/src/logger.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debug = void 0;
+const node_util_1 = require("node:util");
+// Enable with NODE_DEBUG=weflayr
+exports.debug = (0, node_util_1.debuglog)('weflayr');

package/dist/src/otel/exporter.d.ts

@@ -0,0 +1,19 @@
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
+import type { ExportResult } from '@opentelemetry/core';
+import type { ReadableSpan } from '@opentelemetry/sdk-trace-base';
+declare const _RETRYABLE_STATUS: Set<number>;
+type ExportFn = (spans: ReadableSpan[], resultCallback: (result: ExportResult) => void) => void;
+export declare function _exportWithRetry(originalExport: ExportFn, { maxRetries, maxRetryMs }: {
+    maxRetries: number;
+    maxRetryMs: number;
+}): ExportFn;
+interface BuildExporterOptions {
+    baseUrl: string;
+    apiKey: string;
+    timeoutMs?: number;
+    warnOnExportError?: boolean;
+    maxRetries?: number;
+    maxRetryMs?: number;
+}
+export declare function buildExporter({ baseUrl, apiKey, timeoutMs, warnOnExportError, maxRetries, maxRetryMs, }: BuildExporterOptions): OTLPTraceExporter;
+export { _RETRYABLE_STATUS };

package/dist/src/otel/exporter.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._RETRYABLE_STATUS = void 0;
+exports._exportWithRetry = _exportWithRetry;
+exports.buildExporter = buildExporter;
+const async_retry_1 = __importDefault(require("async-retry"));
+const exporter_trace_otlp_http_1 = require("@opentelemetry/exporter-trace-otlp-http");
+const logger_1 = require("../logger");
+// OTLP-spec retryable statuses: rate-limit + transient server errors.
+const _RETRYABLE_STATUS = new Set([429, 502, 503, 504]);
+exports._RETRYABLE_STATUS = _RETRYABLE_STATUS;
+function _isNonRetryable(err) {
+    // Tells async-retry's `bail` whether to give up: bail on 4xx (other than
+    // 429); retry on retryable statuses and on transport errors (no status).
+    const status = err?.exportResult?.error?.code;
+    return status !== undefined && !_RETRYABLE_STATUS.has(status);
+}
+function _formatFailure(result, url) {
+    const err = result?.error;
+    const status = err?.code;
+    const body = typeof err?.data === 'string' ? err.data.slice(0, 200) : undefined;
+    const message = err?.message || String(err) || 'unknown error';
+    let hint = '';
+    if (status === 401 || status === 403) {
+        hint = ' Check your apiKey / WEFLAYR_API_KEY.';
+    }
+    else if (status === 404) {
+        hint = ' Check the baseUrl is correct.';
+    }
+    else if (!status && /ECONN|ENOTFOUND|timeout/i.test(message)) {
+        hint = ' The endpoint is unreachable — check baseUrl and network.';
+    }
+    return (`Weflayr: failed to export telemetry to ${url}` +
+        (status ? ` (HTTP ${status})` : '') +
+        `: ${message}.${hint}` +
+        (body ? ` Response: ${body}` : ''));
+}
+// Wrap a callback-style OTel exporter `export(spans, cb)` with retry. Retries
+// transport errors + retryable HTTP statuses; bails on other 4xx.
+function _exportWithRetry(originalExport, { maxRetries, maxRetryMs }) {
+    return (spans, resultCallback) => {
+        (0, async_retry_1.default)(async (bail) => {
+            const result = await new Promise((resolve) => originalExport(spans, resolve));
+            if (result?.code === 0)
+                return result;
+            const err = new Error(result?.error?.message || 'export failed');
+            err.exportResult = result;
+            if (_isNonRetryable(err)) {
+                bail(err);
+                return result;
+            }
+            throw err;
+        }, { retries: maxRetries - 1, minTimeout: 50, maxRetryTime: maxRetryMs, factor: 2 })
+            .then((result) => resultCallback(result))
+            .catch((err) => resultCallback(err.exportResult || { code: 1, error: err }));
+    };
+}
+function buildExporter({ baseUrl, apiKey, timeoutMs = 5000, warnOnExportError = true, maxRetries = 2, maxRetryMs = 1000, }) {
+    const url = `${baseUrl.replace(/\/$/, '')}/`;
+    const exporter = new exporter_trace_otlp_http_1.OTLPTraceExporter({
+        url,
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+        },
+        timeoutMillis: timeoutMs,
+    });
+    const originalExport = exporter.export.bind(exporter);
+    const wrappedExport = _exportWithRetry(originalExport, { maxRetries, maxRetryMs });
+    exporter.export = (spans, resultCallback) => {
+        const start = Date.now();
+        (0, logger_1.debug)('exporter.export: posting count=%d', spans.length);
+        wrappedExport(spans, (result) => {
+            const ms = Date.now() - start;
+            if (result && result.code === 0) {
+                (0, logger_1.debug)('exporter.export: ok count=%d elapsed_ms=%d', spans.length, ms);
+            }
+            else {
+                const err = result?.error;
+                (0, logger_1.debug)('exporter.export: FAIL count=%d elapsed_ms=%d code=%s error=%s', spans.length, ms, err?.code, err?.message || err || '(none)');
+                if (warnOnExportError) {
+                    // console.warn writes to stderr synchronously. process.emitWarning
+                    // is queued for the next tick, so a caller doing process.exit() from
+                    // their error handler races past it and the warning is lost.
+                    console.warn(`[weflayr] ${_formatFailure(result, url)}`);
+                }
+            }
+            resultCallback(result);
+        });
+    };
+    return exporter;
+}

package/dist/src/otel/propagation.d.ts

@@ -0,0 +1,46 @@
+import { type Context } from '@opentelemetry/api';
+import type { AIProviderName } from '../auto-instrument';
+declare const WEFLAYR_METADATA_CONTEXT_KEY: symbol;
+declare const FEATURE_NAME_ATTR = "weflayr.feature_name";
+declare const CUSTOMER_NAME_ATTR = "weflayr.customer_name";
+declare const PROVIDER_NAME_ATTR = "weflayr.provider_name";
+declare const UUID_ATTR = "weflayr.uuid";
+declare const EXTRA_TAG_PREFIX = "weflayr.tag.";
+export interface PropagateMetadataOptions {
+    /** Product-side feature triggering the LLM call (e.g. `"onboarding-summary"`). */
+    featureName: string;
+    /** Name of the end-user / tenant customer the call is made for. */
+    customerName?: string;
+    /** @deprecated Use `customerName` instead. */
+    customerId?: string;
+    /**
+     * Override for the provider seen on the wire. Set this only if it differs
+     * from the SDK auto-detected by OpenTelemetry — e.g. calls routed through
+     * `vercel_ai_gateway` that proxies to OpenAI/Anthropic but should be
+     * reported as the gateway.
+     */
+    providerNameOverride?: AIProviderName;
+    /** @deprecated Use `providerNameOverride` instead. */
+    providerName?: AIProviderName;
+    /**
+     * Arbitrary scalar key/value pairs to attach. Values must be `string`,
+     * `number`, or `boolean` so they survive the ClickHouse `Map(String,
+     * String)` column they land in. Avoid `featureName` / `customerName` keys
+     * here — they have dedicated fields.
+     */
+    extraTags?: Record<string, string | number | boolean>;
+}
+export declare function getMergedMetadataFromContext(parentContext?: Context): Record<string, unknown>;
+/**
+ * Attach Weflayr metadata to every LLM span created inside this scope.
+ *
+ * Callable form: `propagateMetadata(options, fn)` runs `fn` immediately.
+ * Decorator form: `propagateMetadata(options)` returns a wrapper usable as a
+ * function-decorator (`@propagateMetadata(...)` on class methods) or as a
+ * plain `wrap(fn)` -> wrappedFn helper. Each invocation of the wrapped
+ * function mints a fresh `uuid`, matching the callable form's "one uuid per
+ * propagateMetadata call" contract.
+ */
+export declare function propagateMetadata<T>(options: PropagateMetadataOptions, fn: () => Promise<T> | T): Promise<T> | T;
+export declare function propagateMetadata(options: PropagateMetadataOptions): (target: unknown, key?: string, descriptor?: PropertyDescriptor) => unknown;
+export { WEFLAYR_METADATA_CONTEXT_KEY, FEATURE_NAME_ATTR, CUSTOMER_NAME_ATTR, PROVIDER_NAME_ATTR, UUID_ATTR, EXTRA_TAG_PREFIX, };

package/dist/src/otel/propagation.js

@@ -0,0 +1,110 @@
+"use strict";
+// Copyright 2024 Langfuse GmbH
+// Licensed under the MIT License.
+// Original source: https://github.com/langfuse/langfuse-js/blob/main/packages/core/src/propagation.ts
+//
+// Modifications copyright 2026 Weflayr
+// This file has been modified from its original form:
+//   - Translated from TypeScript to JavaScript
+//   - Replaced Langfuse's fixed schema with Weflayr's structured metadata
+//     (featureName, customerName, providerNameOverride, extraTags) plus an
+//     auto-generated per-call uuid
+//   - Removed asBaggage cross-process propagation (not needed yet)
+//   - Removed experiment framework keys
+//   - Structured fields are written under stable `weflayr.*` span attribute
+//     keys; extraTags entries are written verbatim
+//
+// See LICENSE-MIT in the package root for the full license text.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXTRA_TAG_PREFIX = exports.UUID_ATTR = exports.PROVIDER_NAME_ATTR = exports.CUSTOMER_NAME_ATTR = exports.FEATURE_NAME_ATTR = exports.WEFLAYR_METADATA_CONTEXT_KEY = void 0;
+exports.getMergedMetadataFromContext = getMergedMetadataFromContext;
+exports.propagateMetadata = propagateMetadata;
+const node_crypto_1 = require("node:crypto");
+const api_1 = require("@opentelemetry/api");
+const WEFLAYR_METADATA_CONTEXT_KEY = (0, api_1.createContextKey)('weflayr_metadata');
+exports.WEFLAYR_METADATA_CONTEXT_KEY = WEFLAYR_METADATA_CONTEXT_KEY;
+const FEATURE_NAME_ATTR = 'weflayr.feature_name';
+exports.FEATURE_NAME_ATTR = FEATURE_NAME_ATTR;
+const CUSTOMER_NAME_ATTR = 'weflayr.customer_name';
+exports.CUSTOMER_NAME_ATTR = CUSTOMER_NAME_ATTR;
+const PROVIDER_NAME_ATTR = 'weflayr.provider_name';
+exports.PROVIDER_NAME_ATTR = PROVIDER_NAME_ATTR;
+const UUID_ATTR = 'weflayr.uuid';
+exports.UUID_ATTR = UUID_ATTR;
+// Prefix for user-supplied `extraTags` so downstream normalizers can pick
+// them out without colliding with instrumentor-set `gen_ai.*` attributes.
+const EXTRA_TAG_PREFIX = 'weflayr.tag.';
+exports.EXTRA_TAG_PREFIX = EXTRA_TAG_PREFIX;
+function getMergedMetadataFromContext(parentContext) {
+    const ctx = parentContext ?? api_1.context.active();
+    const existing = ctx.getValue(WEFLAYR_METADATA_CONTEXT_KEY);
+    return existing && typeof existing === 'object' ? { ...existing } : {};
+}
+function _buildAttributes({ featureName, customerName, providerNameOverride, extraTags, spanUuid, }) {
+    const attributes = {
+        [FEATURE_NAME_ATTR]: featureName,
+        [CUSTOMER_NAME_ATTR]: customerName,
+        [UUID_ATTR]: spanUuid,
+    };
+    for (const [key, value] of Object.entries(extraTags)) {
+        attributes[`${EXTRA_TAG_PREFIX}${key}`] = value;
+    }
+    if (providerNameOverride !== undefined && providerNameOverride !== null) {
+        attributes[PROVIDER_NAME_ATTR] = providerNameOverride;
+    }
+    return attributes;
+}
+function propagateMetadata(options, fn) {
+    const { featureName, customerId, providerName } = options ?? {};
+    let { customerName, providerNameOverride } = options ?? {};
+    if (customerId != null) {
+        process.emitWarning('propagateMetadata: `customerId` is deprecated, use `customerName`', 'DeprecationWarning');
+        customerName = customerName ?? customerId;
+    }
+    if (providerName != null) {
+        process.emitWarning('propagateMetadata: `providerName` is deprecated, use `providerNameOverride`', 'DeprecationWarning');
+        providerNameOverride = providerNameOverride ?? providerName;
+    }
+    if (featureName == null || customerName == null) {
+        throw new Error('propagateMetadata: `featureName` and `customerName` are required');
+    }
+    const normalizedOptions = { ...options, customerName, providerNameOverride };
+    if (typeof fn === 'function') {
+        return _runWithMetadata(normalizedOptions, fn);
+    }
+    return function decorator(target, _key, descriptor) {
+        if (descriptor && typeof descriptor.value === 'function') {
+            const original = descriptor.value;
+            descriptor.value = function wrapped(...args) {
+                return _runWithMetadata(normalizedOptions, () => original.apply(this, args));
+            };
+            return descriptor;
+        }
+        if (typeof target === 'function') {
+            return function wrapped(...args) {
+                return _runWithMetadata(normalizedOptions, () => target.apply(this, args));
+            };
+        }
+        return target;
+    };
+}
+function _runWithMetadata(options, fn) {
+    const { featureName, customerName, providerNameOverride, extraTags } = options;
+    const attributes = _buildAttributes({
+        featureName,
+        customerName,
+        providerNameOverride,
+        extraTags: extraTags ?? {},
+        spanUuid: (0, node_crypto_1.randomUUID)().replace(/-/g, ''),
+    });
+    const parent = api_1.context.active();
+    const merged = { ...getMergedMetadataFromContext(parent), ...attributes };
+    const newContext = parent.setValue(WEFLAYR_METADATA_CONTEXT_KEY, merged);
+    const activeSpan = api_1.trace.getActiveSpan();
+    if (activeSpan && activeSpan.isRecording()) {
+        for (const [k, v] of Object.entries(attributes)) {
+            activeSpan.setAttribute(k, v);
+        }
+    }
+    return api_1.context.with(newContext, fn);
+}

package/dist/src/otel/span-filter.d.ts

@@ -0,0 +1,3 @@
+import type { ReadableSpan } from '@opentelemetry/sdk-trace-base';
+export declare function isKnownLLMInstrumentor(span: ReadableSpan): boolean;
+export declare function isDefaultExportSpan(span: ReadableSpan): boolean;

package/dist/src/otel/span-filter.js

@@ -0,0 +1,61 @@
+"use strict";
+// Copyright 2024 Langfuse GmbH
+// Licensed under the MIT License.
+// Original source: https://github.com/langfuse/langfuse-js/blob/main/packages/otel/src/span-filter.ts
+//
+// Modifications copyright 2026 Weflayr
+// This file has been modified from its original form:
+//   - Translated from TypeScript to JavaScript
+//   - Dropped the LANGFUSE_TRACER_NAME special case (we have no SDK-internal tracer)
+//   - Dropped isLangfuseSpan
+//   - Export only spans from known LLM instrumentation scopes: general-purpose
+//     APM SDKs (Sentry, Datadog, ...) also instrument LLM calls with gen_ai.*
+//     attributes, so the original "any span with gen_ai.* attributes" check
+//     exported the same call twice
+//
+// See LICENSE-MIT in the package root for the full license text.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isKnownLLMInstrumentor = isKnownLLMInstrumentor;
+exports.isDefaultExportSpan = isDefaultExportSpan;
+const KNOWN_LLM_INSTRUMENTATION_SCOPE_PREFIXES = [
+    'agent_framework',
+    'ai',
+    'gen_ai',
+    'haystack',
+    'langsmith',
+    'litellm',
+    'mistralai_sdk_tracer',
+    'openinference',
+    'opentelemetry.instrumentation.anthropic',
+    'opentelemetry.instrumentation.aws_bedrock',
+    'opentelemetry.instrumentation.bedrock',
+    'opentelemetry.instrumentation.cohere',
+    'opentelemetry.instrumentation.gemini',
+    'opentelemetry.instrumentation.google_genai',
+    'opentelemetry.instrumentation.google_generativeai',
+    'opentelemetry.instrumentation.openai',
+    'opentelemetry.instrumentation.openai_v2',
+    'opentelemetry.instrumentation.vertex_ai',
+    'opentelemetry.instrumentation.vertexai',
+    'weflayr.instrumentation',
+    'strands-agents',
+    'vllm',
+    '@traceloop/instrumentation-openai',
+    '@traceloop/instrumentation-anthropic',
+    '@traceloop/instrumentation-bedrock',
+    '@traceloop/instrumentation-cohere',
+    '@traceloop/instrumentation-google-generativeai',
+    '@traceloop/instrumentation-langchain',
+    '@traceloop/instrumentation-llamaindex',
+    '@traceloop/instrumentation-pinecone',
+    '@traceloop/instrumentation-chromadb',
+    '@traceloop/instrumentation-qdrant',
+    '@traceloop/instrumentation-mcp',
+];
+function isKnownLLMInstrumentor(span) {
+    const scope = span.instrumentationScope.name;
+    return KNOWN_LLM_INSTRUMENTATION_SCOPE_PREFIXES.some((prefix) => scope === prefix || scope.startsWith(`${prefix}.`));
+}
+function isDefaultExportSpan(span) {
+    return isKnownLLMInstrumentor(span);
+}

package/dist/src/otel/span-processor.d.ts

@@ -0,0 +1,55 @@
+import { type Context, type Span } from '@opentelemetry/api';
+import { type ReadableSpan, type SpanExporter, type SpanProcessor } from '@opentelemetry/sdk-trace-base';
+export declare const CONTENT_CAPTURE_ENV = "OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT";
+/** Arbitrary key-value tags applied to OTel spans. */
+export type Tags = Record<string, string | number | boolean>;
+/**
+ * Span attributes the mask callback can read or scrub. The OpenTelemetry GenAI
+ * semantic-convention keys get autocomplete; the index signature catches user
+ * tags and provider-specific attributes (e.g. Vercel AI's `ai.*`).
+ */
+export interface OtelSpanAttributes {
+    'gen_ai.system'?: string;
+    'gen_ai.operation.name'?: string;
+    'gen_ai.request.model'?: string;
+    'gen_ai.request.temperature'?: number;
+    'gen_ai.request.max_tokens'?: number;
+    'gen_ai.response.model'?: string;
+    'gen_ai.response.id'?: string;
+    'gen_ai.response.finish_reasons'?: string[];
+    'gen_ai.usage.input_tokens'?: number;
+    'gen_ai.usage.output_tokens'?: number;
+    /** Only populated when `captureMessageContent=true`. */
+    'gen_ai.prompt'?: string;
+    /** Only populated when `captureMessageContent=true`. */
+    'gen_ai.completion'?: string;
+    'gen_ai.tool.name'?: string;
+    'gen_ai.tool.call.id'?: string;
+    'gen_ai.tool.call.arguments'?: string;
+    'error.type'?: string;
+    [key: string]: unknown;
+}
+export interface WeflayrSpanProcessorOptions {
+    exporter: SpanExporter;
+    exportMode?: 'batch' | 'immediate';
+    defaultTags?: Tags;
+    mask?: (attrs: OtelSpanAttributes) => OtelSpanAttributes;
+    shouldExportSpan?: (span: ReadableSpan) => boolean;
+}
+type StartedSpan = Span & ReadableSpan;
+export declare class WeflayrSpanProcessor implements SpanProcessor {
+    private _delegate;
+    private _defaultTags;
+    private _mask?;
+    private _maskFunctionSource;
+    private _shouldExportSpan;
+    private _vercelAiSdkSpanFilter;
+    private _openLlmSpans;
+    constructor({ exporter, exportMode, defaultTags, mask, shouldExportSpan, }: WeflayrSpanProcessorOptions);
+    onStart(span: StartedSpan, parentContext: Context): void;
+    onEnd(span: ReadableSpan): void;
+    forceFlush(): Promise<void>;
+    private _endOrphanedLlmSpans;
+    shutdown(): Promise<void>;
+}
+export {};