npm - @latitude-data/telemetry - Versions diffs - 0.0.3 → 1.0.0 - Mend

@latitude-data/telemetry 0.0.3 → 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/dist/index.cjs CHANGED Viewed

@@ -1,487 +1,1978 @@
 'use strict';
+var zod = require('zod');
+var otel = require('@opentelemetry/api');
+var semanticConventions = require('@opentelemetry/semantic-conventions');
+var incubating = require('@opentelemetry/semantic-conventions/incubating');
+var uuid = require('uuid');
+var baggageSpanProcessor = require('@opentelemetry/baggage-span-processor');
+var contextAsyncHooks = require('@opentelemetry/context-async-hooks');
 var core = require('@opentelemetry/core');
-var otlpExporterBase = require('@opentelemetry/otlp-exporter-base');
-var sdkTraceBase = require('@opentelemetry/sdk-trace-base');
-var sdkNode = require('@opentelemetry/sdk-node');
+var exporterTraceOtlpHttp = require('@opentelemetry/exporter-trace-otlp-http');
+var instrumentation = require('@opentelemetry/instrumentation');
+var resources = require('@opentelemetry/resources');
 var sdkTraceNode = require('@opentelemetry/sdk-trace-node');
 var instrumentationAnthropic = require('@traceloop/instrumentation-anthropic');
-var instrumentationOpenai = require('@traceloop/instrumentation-openai');
 var instrumentationAzure = require('@traceloop/instrumentation-azure');
-var instrumentationVertexai = require('@traceloop/instrumentation-vertexai');
 var instrumentationBedrock = require('@traceloop/instrumentation-bedrock');
 var instrumentationCohere = require('@traceloop/instrumentation-cohere');
-var resources = require('@opentelemetry/resources');
-var api = require('@opentelemetry/api');
+var instrumentationLangchain = require('@traceloop/instrumentation-langchain');
+var instrumentationLlamaindex = require('@traceloop/instrumentation-llamaindex');
+var instrumentationOpenai = require('@traceloop/instrumentation-openai');
+var instrumentationTogether = require('@traceloop/instrumentation-together');
+var instrumentationVertexai = require('@traceloop/instrumentation-vertexai');
-const DOMAIN = 'gateway.latitude.so/api/v2/otlp'
-    ;
-const PROTOCOL = 'https' ;
-class LatitudeExporter extends otlpExporterBase.OTLPExporterBase {
-    url;
-    headers;
-    constructor(config) {
-        super(config);
-        this.url = config.endpoint || this.__defaultUrl;
-        this.headers = {
-            Authorization: `Bearer ${config.apiKey}`,
-        };
-    }
-    async export(spans, resultCallback) {
-        await this.send(spans, () => resultCallback({ code: core.ExportResultCode.SUCCESS }), (error) => {
-            resultCallback({ code: core.ExportResultCode.FAILED, error });
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
         });
     }
-    async shutdown() {
-        // No-op
-    }
-    async onShutdown() {
-        // No-op
+    n.default = e;
+    return Object.freeze(n);
+}
+var otel__namespace = /*#__PURE__*/_interopNamespaceDefault(otel);
+class RedactSpanProcessor {
+    options;
+    constructor(options) {
+        this.options = options;
+        if (!options.mask) {
+            this.options.mask = (_attribute, _value) => '******';
+        }
     }
-    async onInit() {
-        // No-op
+    onStart(_span, _context) {
+        // Noop
     }
-    async send(spans, onSuccess, onError) {
-        if (spans.length === 0) {
-            onSuccess();
-            return;
-        }
-        const serviceRequest = this.convert(spans);
-        const body = JSON.stringify(serviceRequest);
-        try {
-            const response = await fetch(this.url, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    ...this.headers,
-                },
-                body,
-            });
-            if (!response.ok || response.status >= 400) {
-                throw new Error(`${response.status} ${response.statusText}`);
-            }
-            onSuccess();
+    onEnd(span) {
+        Object.assign(span.attributes, this.redactAttributes(span.attributes));
+        for (const event of span.events) {
+            if (!event.attributes)
+                continue;
+            Object.assign(event.attributes, this.redactAttributes(event.attributes));
         }
-        catch (error) {
-            onError(error);
+        for (const link of span.links) {
+            if (!link.attributes)
+                continue;
+            Object.assign(link.attributes, this.redactAttributes(link.attributes));
         }
     }
-    convert(spans) {
-        return {
-            resourceSpans: [
-                {
-                    resource: {
-                        attributes: this.convertAttributes(spans[0]?.resource?.attributes || {}),
-                    },
-                    scopeSpans: [
-                        {
-                            spans: spans.map((span) => ({
-                                traceId: span.spanContext().traceId,
-                                spanId: span.spanContext().spanId,
-                                parentSpanId: span.parentSpanId,
-                                name: span.name,
-                                kind: span.kind,
-                                startTimeUnixNano: core.hrTimeToNanoseconds(span.startTime).toString(),
-                                endTimeUnixNano: span.endTime
-                                    ? core.hrTimeToNanoseconds(span.endTime).toString()
-                                    : undefined,
-                                attributes: this.convertAttributes(span.attributes),
-                                status: span.status && {
-                                    code: span.status.code,
-                                    message: span.status.message,
-                                },
-                                events: span.events?.map((event) => ({
-                                    timeUnixNano: core.hrTimeToNanoseconds(event.time).toString(),
-                                    name: event.name,
-                                    attributes: this.convertAttributes(event.attributes),
-                                })),
-                                links: span.links?.map((link) => ({
-                                    traceId: link.context.traceId,
-                                    spanId: link.context.spanId,
-                                    attributes: this.convertAttributes(link.attributes),
-                                })),
-                            })),
-                        },
-                    ],
-                },
-            ],
-        };
+    forceFlush() {
+        return Promise.resolve();
     }
-    getDefaultUrl(config) {
-        return config.endpoint || this.__defaultUrl;
+    shutdown() {
+        return Promise.resolve();
     }
-    get __defaultUrl() {
-        return `${PROTOCOL}://${DOMAIN}/v1/traces`;
+    shouldRedact(attribute) {
+        return this.options.attributes.some((pattern) => {
+            if (typeof pattern === 'string') {
+                return attribute === pattern;
+            }
+            else if (pattern instanceof RegExp) {
+                return pattern.test(attribute);
+            }
+            return false;
+        });
     }
-    convertAttributes(attributes = {}) {
-        return Object.entries(attributes).map(([key, value]) => ({
-            key,
-            value: this.convertAttributeValue(value),
-        }));
+    redactAttributes(attributes) {
+        const redacted = {};
+        for (const [key, value] of Object.entries(attributes)) {
+            if (this.shouldRedact(key)) {
+                redacted[key] = this.options.mask(key, value);
+            }
+        }
+        return redacted;
     }
-    convertAttributeValue(value) {
-        if (typeof value === 'string')
-            return { stringValue: value };
-        if (typeof value === 'number')
-            return { intValue: value };
-        if (typeof value === 'boolean')
-            return { boolValue: value };
-        return { stringValue: String(value) };
+}
+const DEFAULT_REDACT_SPAN_PROCESSOR = () => new RedactSpanProcessor({
+    attributes: [
+        /^.*auth.*$/i,
+        /^.*authorization.*$/i,
+        /^(?!gen_ai\.).*token.*$/i,
+        /^.*secret.*$/i,
+        /^.*key.*$/i,
+        /^.*password.*$/i,
+        /^.*cookie.*$/i,
+        /^.*session.*$/i,
+        /^.*credential.*$/i,
+        /^.*signature.*$/i,
+        /^.*oauth.*$/i,
+        /^.*saml.*$/i,
+        /^.*openid.*$/i,
+        /^.*refresh.*$/i,
+        /^.*jwt.*$/i,
+        /^.*otp.*$/i,
+        /^.*mfa.*$/i,
+        /^.*csrf.*$/i,
+        /^.*xsrf.*$/i,
+        /^.*refresh.*$/i,
+        /^.*x[-_]forwarded[-_]for.*$/i,
+        /^.*x[-_]real[-_]ip.*$/i,
+    ],
+});
+const DEFAULT_GATEWAY_BASE_URL = {
+    production: 'https://gateway.latitude.so',
+    development: 'http://localhost:8787',
+    test: 'http://localhost:8787',
+}["production"];
+function GET_GATEWAY_BASE_URL() {
+    if (process.env.GATEWAY_BASE_URL) {
+        return process.env.GATEWAY_BASE_URL;
     }
+    if (!process.env.GATEWAY_HOSTNAME) {
+        return DEFAULT_GATEWAY_BASE_URL;
+    }
+    const protocol = process.env.GATEWAY_SSL ? 'https' : 'http';
+    const port = process.env.GATEWAY_PORT ?? (process.env.GATEWAY_SSL ? 443 : 80);
+    const hostname = process.env.GATEWAY_HOSTNAME;
+    return `${protocol}://${hostname}:${port}`;
 }
+const env = { GATEWAY_BASE_URL: GET_GATEWAY_BASE_URL() };
-/**
- * Below are the semantic conventions for the Vercel AI SDK.
- * @see https://sdk.vercel.ai/docs/ai-sdk-core/telemetry#collected-data
- */
-const AI_PREFIX = 'ai';
-const AIPrefixes = {
-    settings: 'settings',
-    model: 'model',
-    usage: 'usage',
-    telemetry: 'telemetry',
-    prompt: 'prompt',
-    toolCall: 'toolCall',
-    response: 'response',
-};
-const AIUsagePostfixes = {
-    completionTokens: 'completionTokens',
-    promptTokens: 'promptTokens',
-};
-const AIResultPostfixes = {
-    text: 'text',
-    toolCalls: 'toolCalls',
-    object: 'object',
-};
-const AIPromptPostfixes = {
-    messages: 'messages',
+var SegmentSource;
+(function (SegmentSource) {
+    SegmentSource["API"] = "api";
+    SegmentSource["Playground"] = "playground";
+    SegmentSource["Evaluation"] = "evaluation";
+    SegmentSource["Experiment"] = "experiment";
+    SegmentSource["User"] = "user";
+    SegmentSource["SharedPrompt"] = "shared_prompt";
+    SegmentSource["AgentAsTool"] = "agent_as_tool";
+    SegmentSource["EmailTrigger"] = "email_trigger";
+    SegmentSource["ScheduledTrigger"] = "scheduled_trigger";
+})(SegmentSource || (SegmentSource = {}));
+var SegmentType;
+(function (SegmentType) {
+    SegmentType["Document"] = "document";
+    SegmentType["Step"] = "step";
+})(SegmentType || (SegmentType = {}));
+const baseSegmentBaggageSchema = zod.z.object({
+    id: zod.z.string(),
+    parentId: zod.z.string().optional(),
+    source: zod.z.nativeEnum(SegmentSource),
+});
+zod.z.discriminatedUnion('type', [
+    baseSegmentBaggageSchema.extend({
+        type: zod.z.literal(SegmentType.Document),
+        data: zod.z.object({
+            logUuid: zod.z.string().optional(), // TODO(tracing): temporal related log, remove when observability is ready
+            commitUuid: zod.z.string(),
+            documentUuid: zod.z.string(),
+            experimentUuid: zod.z.string().optional(),
+            externalId: zod.z.string().optional(),
+        }),
+    }),
+    baseSegmentBaggageSchema.extend({
+        type: zod.z.literal(SegmentType.Step),
+        data: zod.z.undefined().optional(),
+    }),
+]);
+var SpanKind;
+(function (SpanKind) {
+    SpanKind["Internal"] = "internal";
+    SpanKind["Server"] = "server";
+    SpanKind["Client"] = "client";
+    SpanKind["Producer"] = "producer";
+    SpanKind["Consumer"] = "consumer";
+})(SpanKind || (SpanKind = {}));
+// Note: loosely based on OpenTelemetry GenAI semantic conventions
+var SpanType;
+(function (SpanType) {
+    SpanType["Tool"] = "tool";
+    SpanType["Completion"] = "completion";
+    SpanType["Embedding"] = "embedding";
+    SpanType["Retrieval"] = "retrieval";
+    SpanType["Reranking"] = "reranking";
+    SpanType["Http"] = "http";
+    SpanType["Segment"] = "segment";
+    SpanType["Unknown"] = "unknown";
+})(SpanType || (SpanType = {}));
+const GENAI_SPANS = [
+    SpanType.Tool,
+    SpanType.Completion,
+    SpanType.Embedding,
+    SpanType.Retrieval,
+    SpanType.Reranking,
+];
+[SpanType.Http, SpanType.Segment, SpanType.Unknown];
+var SpanStatus;
+(function (SpanStatus) {
+    SpanStatus["Unset"] = "unset";
+    SpanStatus["Ok"] = "ok";
+    SpanStatus["Error"] = "error";
+})(SpanStatus || (SpanStatus = {}));
+// Note: Traces are unmaterialized but this context is used to propagate the trace
+// See www.w3.org/TR/trace-context and w3c.github.io/baggage
+zod.z.object({
+    traceparent: zod.z.string(), // <version>-<trace-id>-<span-id>-<trace-flags>
+    tracestate: zod.z.string().optional(), // <key>=urlencoded(<value>)[,<key>=urlencoded(<value>)]*
+    baggage: zod.z.string().optional(), // <key>=urlencoded(<value>)[,<key>=urlencoded(<value>)]*
+});
+/* Note: Instrumentation scopes from all language SDKs */
+const SCOPE_LATITUDE = 'so.latitude.instrumentation';
+var InstrumentationScope;
+(function (InstrumentationScope) {
+    InstrumentationScope["Manual"] = "manual";
+    InstrumentationScope["Latitude"] = "latitude";
+    InstrumentationScope["OpenAI"] = "openai";
+    InstrumentationScope["Anthropic"] = "anthropic";
+    InstrumentationScope["AzureOpenAI"] = "azure";
+    InstrumentationScope["VercelAI"] = "vercelai";
+    InstrumentationScope["VertexAI"] = "vertexai";
+    InstrumentationScope["AIPlatform"] = "aiplatform";
+    InstrumentationScope["MistralAI"] = "mistralai";
+    InstrumentationScope["Bedrock"] = "bedrock";
+    InstrumentationScope["Sagemaker"] = "sagemaker";
+    InstrumentationScope["TogetherAI"] = "togetherai";
+    InstrumentationScope["Replicate"] = "replicate";
+    InstrumentationScope["Groq"] = "groq";
+    InstrumentationScope["Cohere"] = "cohere";
+    InstrumentationScope["LiteLLM"] = "litellm";
+    InstrumentationScope["Langchain"] = "langchain";
+    InstrumentationScope["LlamaIndex"] = "llamaindex";
+    InstrumentationScope["DSPy"] = "dspy";
+    InstrumentationScope["Haystack"] = "haystack";
+    InstrumentationScope["Ollama"] = "ollama";
+    InstrumentationScope["Transformers"] = "transformers";
+    InstrumentationScope["AlephAlpha"] = "alephalpha";
+})(InstrumentationScope || (InstrumentationScope = {}));
+/* Note: non-standard OpenTelemetry semantic conventions used in Latitude */
+const ATTR_LATITUDE = 'latitude';
+const ATTR_LATITUDE_TYPE = `${ATTR_LATITUDE}.type`;
+const ATTR_LATITUDE_SEGMENT_ID = `${ATTR_LATITUDE}.segment.id`;
+const ATTR_LATITUDE_SEGMENT_PARENT_ID = `${ATTR_LATITUDE}.segment.parent_id`;
+const ATTR_LATITUDE_SEGMENTS = `${ATTR_LATITUDE}.segments`;
+const GEN_AI_TOOL_TYPE_VALUE_FUNCTION = 'function';
+const ATTR_GEN_AI_TOOL_CALL_ARGUMENTS = 'gen_ai.tool.call.arguments';
+const ATTR_GEN_AI_TOOL_RESULT_VALUE = 'gen_ai.tool.result.value';
+const ATTR_GEN_AI_TOOL_RESULT_IS_ERROR = 'gen_ai.tool.result.is_error';
+const ATTR_GEN_AI_REQUEST = 'gen_ai.request';
+const ATTR_GEN_AI_REQUEST_CONFIGURATION = 'gen_ai.request.configuration';
+const ATTR_GEN_AI_REQUEST_TEMPLATE = 'gen_ai.request.template';
+const ATTR_GEN_AI_REQUEST_PARAMETERS = 'gen_ai.request.parameters';
+const ATTR_GEN_AI_REQUEST_MESSAGES = 'gen_ai.request.messages';
+const ATTR_GEN_AI_RESPONSE = 'gen_ai.response';
+const ATTR_GEN_AI_RESPONSE_MESSAGES = 'gen_ai.response.messages';
+const ATTR_GEN_AI_USAGE_PROMPT_TOKENS = 'gen_ai.usage.prompt_tokens';
+const ATTR_GEN_AI_USAGE_CACHED_TOKENS = 'gen_ai.usage.cached_tokens';
+const ATTR_GEN_AI_USAGE_REASONING_TOKENS = 'gen_ai.usage.reasoning_tokens'; // prettier-ignore
+const ATTR_GEN_AI_USAGE_COMPLETION_TOKENS = 'gen_ai.usage.completion_tokens'; // prettier-ignore
+const ATTR_GEN_AI_PROMPTS = 'gen_ai.prompt'; // gen_ai.prompt.{index}.{role/content/...}
+const ATTR_GEN_AI_COMPLETIONS = 'gen_ai.completion'; // gen_ai.completion.{index}.{role/content/...}
+const ATTR_GEN_AI_MESSAGE_ROLE = 'role';
+const ATTR_GEN_AI_MESSAGE_CONTENT = 'content'; // string or object
+const ATTR_GEN_AI_MESSAGE_TOOL_NAME = 'tool_name';
+const ATTR_GEN_AI_MESSAGE_TOOL_CALL_ID = 'tool_call_id';
+const ATTR_GEN_AI_MESSAGE_TOOL_RESULT_IS_ERROR = 'is_error';
+const ATTR_GEN_AI_MESSAGE_TOOL_CALLS = 'tool_calls'; // gen_ai.completion.{index}.tool_calls.{index}.{id/name/arguments}
+const ATTR_GEN_AI_MESSAGE_TOOL_CALLS_ID = 'id';
+const ATTR_GEN_AI_MESSAGE_TOOL_CALLS_NAME = 'name';
+const ATTR_GEN_AI_MESSAGE_TOOL_CALLS_ARGUMENTS = 'arguments';
+const GEN_AI_RESPONSE_FINISH_REASON_VALUE_STOP = 'stop';
+const GEN_AI_RESPONSE_FINISH_REASON_VALUE_TOOL_CALLS = 'tool_calls';
+const ATTR_HTTP_REQUEST_URL = 'http.request.url';
+const ATTR_HTTP_REQUEST_BODY = 'http.request.body';
+const ATTR_HTTP_REQUEST_HEADERS = 'http.request.header';
+const ATTR_HTTP_RESPONSE_BODY = 'http.response.body';
+const ATTR_HTTP_RESPONSE_HEADERS = 'http.response.header';
+/* Note: Schemas for span ingestion following OpenTelemetry service request specification */
+var Otlp;
+(function (Otlp) {
+    Otlp.attributeValueSchema = zod.z.object({
+        stringValue: zod.z.string().optional(),
+        intValue: zod.z.number().optional(),
+        boolValue: zod.z.boolean().optional(),
+        arrayValue: zod.z
+            .object({
+            values: zod.z.array(zod.z.object({
+                stringValue: zod.z.string().optional(),
+                intValue: zod.z.number().optional(),
+                boolValue: zod.z.boolean().optional(),
+            })),
+        })
+            .optional(),
+    });
+    Otlp.attributeSchema = zod.z.object({
+        key: zod.z.string(),
+        value: Otlp.attributeValueSchema,
+    });
+    Otlp.eventSchema = zod.z.object({
+        name: zod.z.string(),
+        timeUnixNano: zod.z.string(),
+        attributes: zod.z.array(Otlp.attributeSchema).optional(),
+    });
+    Otlp.linkSchema = zod.z.object({
+        traceId: zod.z.string(),
+        spanId: zod.z.string(),
+        attributes: zod.z.array(Otlp.attributeSchema).optional(),
+    });
+    Otlp.statusSchema = zod.z.object({
+        code: zod.z.number(),
+        message: zod.z.string().optional(),
+    });
+    Otlp.spanSchema = zod.z.object({
+        traceId: zod.z.string(),
+        spanId: zod.z.string(),
+        parentSpanId: zod.z.string().optional(),
+        name: zod.z.string(),
+        kind: zod.z.number(),
+        startTimeUnixNano: zod.z.string(),
+        endTimeUnixNano: zod.z.string(),
+        status: Otlp.statusSchema.optional(),
+        events: zod.z.array(Otlp.eventSchema).optional(),
+        links: zod.z.array(Otlp.linkSchema).optional(),
+        attributes: zod.z.array(Otlp.attributeSchema).optional(),
+    });
+    Otlp.scopeSchema = zod.z.object({
+        name: zod.z.string(),
+        version: zod.z.string().optional(),
+    });
+    Otlp.scopeSpanSchema = zod.z.object({
+        scope: Otlp.scopeSchema,
+        spans: zod.z.array(Otlp.spanSchema),
+    });
+    Otlp.resourceSchema = zod.z.object({
+        attributes: zod.z.array(Otlp.attributeSchema),
+    });
+    Otlp.resourceSpanSchema = zod.z.object({
+        resource: Otlp.resourceSchema,
+        scopeSpans: zod.z.array(Otlp.scopeSpanSchema),
+    });
+    Otlp.serviceRequestSchema = zod.z.object({
+        resourceSpans: zod.z.array(Otlp.resourceSpanSchema),
+    });
+})(Otlp || (Otlp = {}));
+var StreamEventTypes;
+(function (StreamEventTypes) {
+    StreamEventTypes["Latitude"] = "latitude-event";
+    StreamEventTypes["Provider"] = "provider-event";
+})(StreamEventTypes || (StreamEventTypes = {}));
+zod.z.object({
+    id: zod.z.string(),
+    name: zod.z.string(),
+    result: zod.z.unknown(),
+    isError: zod.z.boolean().optional(),
+    text: zod.z.string().optional(),
+});
+var ParameterType;
+(function (ParameterType) {
+    ParameterType["Text"] = "text";
+    ParameterType["Image"] = "image";
+    ParameterType["File"] = "file";
+})(ParameterType || (ParameterType = {}));
+var LatitudeTool;
+(function (LatitudeTool) {
+    LatitudeTool["RunCode"] = "code";
+    LatitudeTool["WebSearch"] = "search";
+    LatitudeTool["WebExtract"] = "extract";
+})(LatitudeTool || (LatitudeTool = {}));
+var LatitudeToolInternalName;
+(function (LatitudeToolInternalName) {
+    LatitudeToolInternalName["RunCode"] = "lat_tool_run_code";
+    LatitudeToolInternalName["WebSearch"] = "lat_tool_web_search";
+    LatitudeToolInternalName["WebExtract"] = "lat_tool_web_extract";
+})(LatitudeToolInternalName || (LatitudeToolInternalName = {}));
+const actualOutputConfiguration = zod.z.object({
+    messageSelection: zod.z.enum(['last', 'all']), // Which assistant messages to select
+    contentFilter: zod.z.enum(['text', 'image', 'file', 'tool_call']).optional(),
+    parsingFormat: zod.z.enum(['string', 'json']),
+    fieldAccessor: zod.z.string().optional(), // Field accessor to get the output from if it's a key-value format
+});
+const expectedOutputConfiguration = zod.z.object({
+    parsingFormat: zod.z.enum(['string', 'json']),
+    fieldAccessor: zod.z.string().optional(), // Field accessor to get the output from if it's a key-value format
+});
+const baseEvaluationConfiguration = zod.z.object({
+    reverseScale: zod.z.boolean(), // If true, lower is better, otherwise, higher is better
+    actualOutput: actualOutputConfiguration.optional(), // Optional for backwards compatibility
+    expectedOutput: expectedOutputConfiguration.optional(), // Optional for backwards compatibility
+});
+const baseEvaluationResultMetadata = zod.z.object({
+    // Configuration snapshot is defined in every metric specification
+    actualOutput: zod.z.string(),
+    expectedOutput: zod.z.string().optional(),
+    datasetLabel: zod.z.string().optional(),
+});
+const baseEvaluationResultError = zod.z.object({
+    message: zod.z.string(),
+});
+const humanEvaluationConfiguration = baseEvaluationConfiguration.extend({
+    criteria: zod.z.string().optional(),
+});
+const humanEvaluationResultMetadata = baseEvaluationResultMetadata.extend({
+    reason: zod.z.string().optional(),
+});
+const humanEvaluationResultError = baseEvaluationResultError.extend({});
+// BINARY
+const humanEvaluationBinaryConfiguration = humanEvaluationConfiguration.extend({
+    passDescription: zod.z.string().optional(),
+    failDescription: zod.z.string().optional(),
+});
+humanEvaluationResultMetadata.extend({
+    configuration: humanEvaluationBinaryConfiguration,
+});
+humanEvaluationResultError.extend({});
+const HumanEvaluationBinarySpecification = {
+    };
+// RATING
+const humanEvaluationRatingConfiguration = humanEvaluationConfiguration.extend({
+    minRating: zod.z.number(),
+    minRatingDescription: zod.z.string().optional(),
+    maxRating: zod.z.number(),
+    maxRatingDescription: zod.z.string().optional(),
+    minThreshold: zod.z.number().optional(), // Threshold in rating range
+    maxThreshold: zod.z.number().optional(), // Threshold in rating range
+});
+humanEvaluationResultMetadata.extend({
+    configuration: humanEvaluationRatingConfiguration,
+});
+humanEvaluationResultError.extend({});
+const HumanEvaluationRatingSpecification = {
+    };
+/* ------------------------------------------------------------------------- */
+var HumanEvaluationMetric;
+(function (HumanEvaluationMetric) {
+    HumanEvaluationMetric["Binary"] = "binary";
+    HumanEvaluationMetric["Rating"] = "rating";
+})(HumanEvaluationMetric || (HumanEvaluationMetric = {}));
+const HumanEvaluationSpecification = {
+    // prettier-ignore
+    metrics: {
+        [HumanEvaluationMetric.Binary]: HumanEvaluationBinarySpecification,
+        [HumanEvaluationMetric.Rating]: HumanEvaluationRatingSpecification,
+    },
 };
-const AIToolCallPostfixes = {
-    id: 'id',
-    name: 'name',
-    args: 'args',
-    result: 'result',
+const llmEvaluationConfiguration = baseEvaluationConfiguration.extend({
+    provider: zod.z.string(),
+    model: zod.z.string(),
+});
+const llmEvaluationResultMetadata = baseEvaluationResultMetadata.extend({
+    evaluationLogId: zod.z.number(),
+    reason: zod.z.string(),
+    tokens: zod.z.number(),
+    cost: zod.z.number(),
+    duration: zod.z.number(),
+});
+const llmEvaluationResultError = baseEvaluationResultError.extend({
+    runErrorId: zod.z.number().optional(),
+});
+// BINARY
+const llmEvaluationBinaryConfiguration = llmEvaluationConfiguration.extend({
+    criteria: zod.z.string(),
+    passDescription: zod.z.string(),
+    failDescription: zod.z.string(),
+});
+llmEvaluationResultMetadata.extend({
+    configuration: llmEvaluationBinaryConfiguration,
+});
+llmEvaluationResultError.extend({});
+const LlmEvaluationBinarySpecification = {
+    };
+// RATING
+const llmEvaluationRatingConfiguration = llmEvaluationConfiguration.extend({
+    criteria: zod.z.string(),
+    minRating: zod.z.number(),
+    minRatingDescription: zod.z.string(),
+    maxRating: zod.z.number(),
+    maxRatingDescription: zod.z.string(),
+    minThreshold: zod.z.number().optional(), // Threshold in rating range
+    maxThreshold: zod.z.number().optional(), // Threshold in rating range
+});
+llmEvaluationResultMetadata.extend({
+    configuration: llmEvaluationRatingConfiguration,
+});
+llmEvaluationResultError.extend({});
+const LlmEvaluationRatingSpecification = {
+    };
+// COMPARISON
+const llmEvaluationComparisonConfiguration = llmEvaluationConfiguration.extend({
+    criteria: zod.z.string(),
+    passDescription: zod.z.string(),
+    failDescription: zod.z.string(),
+    minThreshold: zod.z.number().optional(), // Threshold percentage
+    maxThreshold: zod.z.number().optional(), // Threshold percentage
+});
+llmEvaluationResultMetadata.extend({
+    configuration: llmEvaluationComparisonConfiguration,
+});
+llmEvaluationResultError.extend({});
+const LlmEvaluationComparisonSpecification = {
+    };
+// CUSTOM
+const llmEvaluationCustomConfiguration = llmEvaluationConfiguration.extend({
+    prompt: zod.z.string(),
+    minScore: zod.z.number(),
+    maxScore: zod.z.number(),
+    minThreshold: zod.z.number().optional(), // Threshold percentage
+    maxThreshold: zod.z.number().optional(), // Threshold percentage
+});
+llmEvaluationResultMetadata.extend({
+    configuration: llmEvaluationCustomConfiguration,
+});
+llmEvaluationResultError.extend({});
+const LlmEvaluationCustomSpecification = {
+    };
+// CUSTOM LABELED
+const LlmEvaluationCustomLabeledSpecification = {
+    };
+/* ------------------------------------------------------------------------- */
+var LlmEvaluationMetric;
+(function (LlmEvaluationMetric) {
+    LlmEvaluationMetric["Binary"] = "binary";
+    LlmEvaluationMetric["Rating"] = "rating";
+    LlmEvaluationMetric["Comparison"] = "comparison";
+    LlmEvaluationMetric["Custom"] = "custom";
+    LlmEvaluationMetric["CustomLabeled"] = "custom_labeled";
+})(LlmEvaluationMetric || (LlmEvaluationMetric = {}));
+const LlmEvaluationSpecification = {
+    // prettier-ignore
+    metrics: {
+        [LlmEvaluationMetric.Binary]: LlmEvaluationBinarySpecification,
+        [LlmEvaluationMetric.Rating]: LlmEvaluationRatingSpecification,
+        [LlmEvaluationMetric.Comparison]: LlmEvaluationComparisonSpecification,
+        [LlmEvaluationMetric.Custom]: LlmEvaluationCustomSpecification,
+        [LlmEvaluationMetric.CustomLabeled]: LlmEvaluationCustomLabeledSpecification,
+    },
 };
-const SETTINGS = `${AI_PREFIX}.${AIPrefixes.settings}`;
-const MODEL_ID = `${AI_PREFIX}.${AIPrefixes.model}.id`;
-const METADATA = `${AI_PREFIX}.${AIPrefixes.telemetry}.metadata`;
-const TOKEN_COUNT_COMPLETION = `${AI_PREFIX}.${AIPrefixes.usage}.${AIUsagePostfixes.completionTokens}`;
-const TOKEN_COUNT_PROMPT = `${AI_PREFIX}.${AIPrefixes.usage}.${AIUsagePostfixes.promptTokens}`;
-const RESPONSE_TEXT = `${AI_PREFIX}.${AIPrefixes.response}.${AIResultPostfixes.text}`;
-const RESPONSE_TOOL_CALLS = `${AI_PREFIX}.${AIPrefixes.response}.${AIResultPostfixes.toolCalls}`;
-const RESULT_OBJECT = `${AI_PREFIX}.${AIPrefixes.response}.${AIResultPostfixes.object}`;
-const PROMPT = `${AI_PREFIX}.${AIPrefixes.prompt}`;
-const PROMPT_MESSAGES = `${PROMPT}.${AIPromptPostfixes.messages}`;
-const EMBEDDING_TEXT = `${AI_PREFIX}.value`;
-const EMBEDDING_VECTOR = `${AI_PREFIX}.embedding`;
-const EMBEDDING_TEXTS = `${AI_PREFIX}.values`;
-const EMBEDDING_VECTORS = `${AI_PREFIX}.embeddings`;
-const TOOL_CALL_ID = `${AI_PREFIX}.${AIPrefixes.toolCall}.${AIToolCallPostfixes.id}`;
-const TOOL_CALL_NAME = `${AI_PREFIX}.${AIPrefixes.toolCall}.${AIToolCallPostfixes.name}`;
-const TOOL_CALL_ARGS = `${AI_PREFIX}.${AIPrefixes.toolCall}.${AIToolCallPostfixes.args}`;
-const TOOL_CALL_RESULT = `${AI_PREFIX}.${AIPrefixes.toolCall}.${AIToolCallPostfixes.result}`;
-/**
- * The semantic conventions used by the Vercel AI SDK.
- * @see https://sdk.vercel.ai/docs/ai-sdk-core/telemetry#collected-data
- */
-const AISemanticConventions = {
-    MODEL_ID,
-    METADATA,
-    SETTINGS,
-    TOKEN_COUNT_COMPLETION,
-    TOKEN_COUNT_PROMPT,
-    RESPONSE_TEXT,
-    RESPONSE_TOOL_CALLS,
-    RESULT_OBJECT,
-    PROMPT,
-    PROMPT_MESSAGES,
-    EMBEDDING_TEXT,
-    EMBEDDING_VECTOR,
-    EMBEDDING_TEXTS,
-    EMBEDDING_VECTORS,
-    TOOL_CALL_ID,
-    TOOL_CALL_NAME,
-    TOOL_CALL_ARGS,
-    TOOL_CALL_RESULT,
+const ruleEvaluationConfiguration = baseEvaluationConfiguration.extend({});
+const ruleEvaluationResultMetadata = baseEvaluationResultMetadata.extend({});
+const ruleEvaluationResultError = baseEvaluationResultError.extend({});
+// EXACT MATCH
+const ruleEvaluationExactMatchConfiguration = ruleEvaluationConfiguration.extend({
+    caseInsensitive: zod.z.boolean(),
+});
+ruleEvaluationResultMetadata.extend({
+    configuration: ruleEvaluationExactMatchConfiguration,
+});
+ruleEvaluationResultError.extend({});
+const RuleEvaluationExactMatchSpecification = {
+    };
+// REGULAR EXPRESSION
+const ruleEvaluationRegularExpressionConfiguration = ruleEvaluationConfiguration.extend({
+    pattern: zod.z.string(),
+});
+ruleEvaluationResultMetadata.extend({
+    configuration: ruleEvaluationRegularExpressionConfiguration,
+});
+ruleEvaluationResultError.extend({});
+const RuleEvaluationRegularExpressionSpecification = {
+    };
+// SCHEMA VALIDATION
+const ruleEvaluationSchemaValidationConfiguration = ruleEvaluationConfiguration.extend({
+    format: zod.z.enum(['json']),
+    schema: zod.z.string(),
+});
+ruleEvaluationResultMetadata.extend({
+    configuration: ruleEvaluationSchemaValidationConfiguration,
+});
+ruleEvaluationResultError.extend({});
+const RuleEvaluationSchemaValidationSpecification = {
+    };
+// LENGTH COUNT
+const ruleEvaluationLengthCountConfiguration = ruleEvaluationConfiguration.extend({
+    algorithm: zod.z.enum(['character', 'word', 'sentence']),
+    minLength: zod.z.number().optional(),
+    maxLength: zod.z.number().optional(),
+});
+ruleEvaluationResultMetadata.extend({
+    configuration: ruleEvaluationLengthCountConfiguration,
+});
+ruleEvaluationResultError.extend({});
+const RuleEvaluationLengthCountSpecification = {
+    };
+// LEXICAL OVERLAP
+const ruleEvaluationLexicalOverlapConfiguration = ruleEvaluationConfiguration.extend({
+    algorithm: zod.z.enum(['substring', 'levenshtein_distance', 'rouge']),
+    minOverlap: zod.z.number().optional(), // Percentage of overlap
+    maxOverlap: zod.z.number().optional(), // Percentage of overlap
+});
+ruleEvaluationResultMetadata.extend({
+    configuration: ruleEvaluationLexicalOverlapConfiguration,
+});
+ruleEvaluationResultError.extend({});
+const RuleEvaluationLexicalOverlapSpecification = {
+    };
+// SEMANTIC SIMILARITY
+const ruleEvaluationSemanticSimilarityConfiguration = ruleEvaluationConfiguration.extend({
+    algorithm: zod.z.enum(['cosine_distance']),
+    minSimilarity: zod.z.number().optional(), // Percentage of similarity
+    maxSimilarity: zod.z.number().optional(), // Percentage of similarity
+});
+ruleEvaluationResultMetadata.extend({
+    configuration: ruleEvaluationSemanticSimilarityConfiguration,
+});
+ruleEvaluationResultError.extend({});
+const RuleEvaluationSemanticSimilaritySpecification = {
+    };
+// NUMERIC SIMILARITY
+const ruleEvaluationNumericSimilarityConfiguration = ruleEvaluationConfiguration.extend({
+    algorithm: zod.z.enum(['relative_difference']),
+    minSimilarity: zod.z.number().optional(), // Percentage of similarity
+    maxSimilarity: zod.z.number().optional(), // Percentage of similarity
+});
+ruleEvaluationResultMetadata.extend({
+    configuration: ruleEvaluationNumericSimilarityConfiguration,
+});
+ruleEvaluationResultError.extend({});
+const RuleEvaluationNumericSimilaritySpecification = {
+    };
+/* ------------------------------------------------------------------------- */
+var RuleEvaluationMetric;
+(function (RuleEvaluationMetric) {
+    RuleEvaluationMetric["ExactMatch"] = "exact_match";
+    RuleEvaluationMetric["RegularExpression"] = "regular_expression";
+    RuleEvaluationMetric["SchemaValidation"] = "schema_validation";
+    RuleEvaluationMetric["LengthCount"] = "length_count";
+    RuleEvaluationMetric["LexicalOverlap"] = "lexical_overlap";
+    RuleEvaluationMetric["SemanticSimilarity"] = "semantic_similarity";
+    RuleEvaluationMetric["NumericSimilarity"] = "numeric_similarity";
+})(RuleEvaluationMetric || (RuleEvaluationMetric = {}));
+const RuleEvaluationSpecification = {
+    // prettier-ignore
+    metrics: {
+        [RuleEvaluationMetric.ExactMatch]: RuleEvaluationExactMatchSpecification,
+        [RuleEvaluationMetric.RegularExpression]: RuleEvaluationRegularExpressionSpecification,
+        [RuleEvaluationMetric.SchemaValidation]: RuleEvaluationSchemaValidationSpecification,
+        [RuleEvaluationMetric.LengthCount]: RuleEvaluationLengthCountSpecification,
+        [RuleEvaluationMetric.LexicalOverlap]: RuleEvaluationLexicalOverlapSpecification,
+        [RuleEvaluationMetric.SemanticSimilarity]: RuleEvaluationSemanticSimilaritySpecification,
+        [RuleEvaluationMetric.NumericSimilarity]: RuleEvaluationNumericSimilaritySpecification,
+    },
 };
-Object.freeze(Object.values(AISemanticConventions));
-class VercelSpanProcessor extends sdkTraceBase.SimpleSpanProcessor {
-    onEnd(span) {
-        if (!shouldProcess(span))
-            return;
-        if (shouldConvertToLatitudeFormat(span))
-            convertToLatitudeFormat(span);
-        super.onEnd(span);
+var EvaluationType;
+(function (EvaluationType) {
+    EvaluationType["Rule"] = "rule";
+    EvaluationType["Llm"] = "llm";
+    EvaluationType["Human"] = "human";
+})(EvaluationType || (EvaluationType = {}));
+const EvaluationTypeSchema = zod.z.nativeEnum(EvaluationType);
+const EvaluationMetricSchema = zod.z.union([
+    zod.z.nativeEnum(RuleEvaluationMetric),
+    zod.z.nativeEnum(LlmEvaluationMetric),
+    zod.z.nativeEnum(HumanEvaluationMetric),
+]);
+const EvaluationConfigurationSchema = zod.z.custom();
+// prettier-ignore
+zod.z.custom();
+// prettier-ignore
+zod.z.custom();
+({
+    [EvaluationType.Rule]: RuleEvaluationSpecification,
+    [EvaluationType.Llm]: LlmEvaluationSpecification,
+    [EvaluationType.Human]: HumanEvaluationSpecification,
+});
+zod.z.object({
+    name: zod.z.string(),
+    description: zod.z.string(),
+    type: EvaluationTypeSchema,
+    metric: EvaluationMetricSchema,
+    configuration: EvaluationConfigurationSchema,
+});
+zod.z.object({
+    evaluateLiveLogs: zod.z.boolean().nullable().optional(),
+    enableSuggestions: zod.z.boolean().nullable().optional(),
+    autoApplySuggestions: zod.z.boolean().nullable().optional(),
+});
+Object.values(SegmentSource).filter((source) => source !== SegmentSource.Evaluation && source !== SegmentSource.Experiment);
+var LegacyChainEventTypes;
+(function (LegacyChainEventTypes) {
+    LegacyChainEventTypes["Error"] = "chain-error";
+    LegacyChainEventTypes["Step"] = "chain-step";
+    LegacyChainEventTypes["Complete"] = "chain-complete";
+    LegacyChainEventTypes["StepComplete"] = "chain-step-complete";
+})(LegacyChainEventTypes || (LegacyChainEventTypes = {}));
+var ChainEventTypes;
+(function (ChainEventTypes) {
+    ChainEventTypes["ChainStarted"] = "chain-started";
+    ChainEventTypes["StepStarted"] = "step-started";
+    ChainEventTypes["ProviderStarted"] = "provider-started";
+    ChainEventTypes["ProviderCompleted"] = "provider-completed";
+    ChainEventTypes["ToolsStarted"] = "tools-started";
+    ChainEventTypes["ToolCompleted"] = "tool-completed";
+    ChainEventTypes["StepCompleted"] = "step-completed";
+    ChainEventTypes["ChainCompleted"] = "chain-completed";
+    ChainEventTypes["ChainError"] = "chain-error";
+    ChainEventTypes["ToolsRequested"] = "tools-requested";
+    ChainEventTypes["IntegrationWakingUp"] = "integration-waking-up";
+})(ChainEventTypes || (ChainEventTypes = {}));
+var IntegrationType;
+(function (IntegrationType) {
+    IntegrationType["Latitude"] = "latitude";
+    IntegrationType["ExternalMCP"] = "custom_mcp";
+    IntegrationType["HostedMCP"] = "mcp_server";
+})(IntegrationType || (IntegrationType = {}));
+var HostedIntegrationType;
+(function (HostedIntegrationType) {
+    HostedIntegrationType["Stripe"] = "stripe";
+    HostedIntegrationType["Slack"] = "slack";
+    HostedIntegrationType["Github"] = "github";
+    HostedIntegrationType["Notion"] = "notion";
+    HostedIntegrationType["Twitter"] = "twitter";
+    HostedIntegrationType["Airtable"] = "airtable";
+    HostedIntegrationType["Linear"] = "linear";
+    HostedIntegrationType["YoutubeCaptions"] = "youtube_captions";
+    HostedIntegrationType["Reddit"] = "reddit";
+    HostedIntegrationType["Telegram"] = "telegram";
+    HostedIntegrationType["Tinybird"] = "tinybird";
+    HostedIntegrationType["Perplexity"] = "perplexity";
+    HostedIntegrationType["AwsKbRetrieval"] = "aws_kb_retrieval";
+    HostedIntegrationType["BraveSearch"] = "brave_search";
+    HostedIntegrationType["EverArt"] = "ever_art";
+    HostedIntegrationType["Fetch"] = "fetch";
+    HostedIntegrationType["GitLab"] = "gitlab";
+    HostedIntegrationType["GoogleMaps"] = "google_maps";
+    HostedIntegrationType["Sentry"] = "sentry";
+    HostedIntegrationType["Puppeteer"] = "puppeteer";
+    HostedIntegrationType["Time"] = "time";
+    HostedIntegrationType["browserbase"] = "browserbase";
+    HostedIntegrationType["Neon"] = "neon";
+    HostedIntegrationType["Postgres"] = "postgres";
+    HostedIntegrationType["Supabase"] = "supabase";
+    HostedIntegrationType["Redis"] = "redis";
+    HostedIntegrationType["Jira"] = "jira";
+    HostedIntegrationType["Attio"] = "attio";
+    HostedIntegrationType["Ghost"] = "ghost";
+    HostedIntegrationType["Figma"] = "figma";
+    HostedIntegrationType["Hyperbrowser"] = "hyperbrowser";
+    HostedIntegrationType["Audiense"] = "audiense";
+    HostedIntegrationType["Apify"] = "apify";
+    HostedIntegrationType["Exa"] = "exa";
+    HostedIntegrationType["YepCode"] = "yepcode";
+    HostedIntegrationType["Monday"] = "monday";
+    HostedIntegrationType["AgentQL"] = "agentql";
+    HostedIntegrationType["AgentRPC"] = "agentrpc";
+    HostedIntegrationType["AstraDB"] = "astra_db";
+    HostedIntegrationType["Bankless"] = "bankless";
+    HostedIntegrationType["Bicscan"] = "bicscan";
+    HostedIntegrationType["Chargebee"] = "chargebee";
+    HostedIntegrationType["Chronulus"] = "chronulus";
+    HostedIntegrationType["CircleCI"] = "circleci";
+    HostedIntegrationType["Codacy"] = "codacy";
+    HostedIntegrationType["CodeLogic"] = "codelogic";
+    HostedIntegrationType["Convex"] = "convex";
+    HostedIntegrationType["Dart"] = "dart";
+    HostedIntegrationType["DevHubCMS"] = "devhub_cms";
+    HostedIntegrationType["Elasticsearch"] = "elasticsearch";
+    HostedIntegrationType["ESignatures"] = "esignatures";
+    HostedIntegrationType["Fewsats"] = "fewsats";
+    HostedIntegrationType["Firecrawl"] = "firecrawl";
+    HostedIntegrationType["Graphlit"] = "graphlit";
+    HostedIntegrationType["Heroku"] = "heroku";
+    HostedIntegrationType["IntegrationAppHubspot"] = "integration_app_hubspot";
+    HostedIntegrationType["LaraTranslate"] = "lara_translate";
+    HostedIntegrationType["Logfire"] = "logfire";
+    HostedIntegrationType["Langfuse"] = "langfuse";
+    HostedIntegrationType["LingoSupabase"] = "lingo_supabase";
+    HostedIntegrationType["Make"] = "make";
+    HostedIntegrationType["Meilisearch"] = "meilisearch";
+    HostedIntegrationType["Momento"] = "momento";
+    HostedIntegrationType["Neo4jAura"] = "neo4j_aura";
+    HostedIntegrationType["Octagon"] = "octagon";
+    HostedIntegrationType["Paddle"] = "paddle";
+    HostedIntegrationType["PayPal"] = "paypal";
+    HostedIntegrationType["Qdrant"] = "qdrant";
+    HostedIntegrationType["Raygun"] = "raygun";
+    HostedIntegrationType["Rember"] = "rember";
+    HostedIntegrationType["Riza"] = "riza";
+    HostedIntegrationType["Search1API"] = "search1api";
+    HostedIntegrationType["Semgrep"] = "semgrep";
+    HostedIntegrationType["Tavily"] = "tavily";
+    HostedIntegrationType["Unstructured"] = "unstructured";
+    HostedIntegrationType["Vectorize"] = "vectorize";
+    HostedIntegrationType["Xero"] = "xero";
+    HostedIntegrationType["Readwise"] = "readwise";
+    HostedIntegrationType["Airbnb"] = "airbnb";
+    HostedIntegrationType["Mintlify"] = "mintlify";
+    // Require all auth file :point_down:
+    // Gmail = 'google_drive',
+    // GoogleCalendar = 'google_drive',
+    // GoogleDrive = 'google_drive',
+    // GoogleWorkspace = 'google_workspace', // env vars not supported (?)
+    // TODO: implement these
+    // Wordpress = 'wordpress', // Not on OpenTools
+    // Discord = 'discord', // Not on OpenTools
+    // Intercom = 'intercom', // Not on OpenTools
+    // Hubspot = 'hubspot', // Docker based
+    // Loops = 'loops', // Does not exist
+})(HostedIntegrationType || (HostedIntegrationType = {}));
+// TODO(evalsv2): Remove
+var EvaluationResultableType;
+(function (EvaluationResultableType) {
+    EvaluationResultableType["Boolean"] = "evaluation_resultable_booleans";
+    EvaluationResultableType["Text"] = "evaluation_resultable_texts";
+    EvaluationResultableType["Number"] = "evaluation_resultable_numbers";
+})(EvaluationResultableType || (EvaluationResultableType = {}));
+var ModifiedDocumentType;
+(function (ModifiedDocumentType) {
+    ModifiedDocumentType["Created"] = "created";
+    ModifiedDocumentType["Updated"] = "updated";
+    ModifiedDocumentType["UpdatedPath"] = "updated_path";
+    ModifiedDocumentType["Deleted"] = "deleted";
+})(ModifiedDocumentType || (ModifiedDocumentType = {}));
+// TODO(tracing): deprecated
+const HEAD_COMMIT = 'live';
+var Providers;
+(function (Providers) {
+    Providers["OpenAI"] = "openai";
+    Providers["Anthropic"] = "anthropic";
+    Providers["Groq"] = "groq";
+    Providers["Mistral"] = "mistral";
+    Providers["Azure"] = "azure";
+    Providers["Google"] = "google";
+    Providers["GoogleVertex"] = "google_vertex";
+    Providers["AnthropicVertex"] = "anthropic_vertex";
+    Providers["Custom"] = "custom";
+    Providers["XAI"] = "xai";
+    Providers["AmazonBedrock"] = "amazon_bedrock";
+    Providers["DeepSeek"] = "deepseek";
+    Providers["Perplexity"] = "perplexity";
+})(Providers || (Providers = {}));
+var DocumentType;
+(function (DocumentType) {
+    DocumentType["Prompt"] = "prompt";
+    DocumentType["Agent"] = "agent";
+})(DocumentType || (DocumentType = {}));
+var DocumentTriggerType;
+(function (DocumentTriggerType) {
+    DocumentTriggerType["Email"] = "email";
+    DocumentTriggerType["Scheduled"] = "scheduled";
+})(DocumentTriggerType || (DocumentTriggerType = {}));
+var DocumentTriggerParameters;
+(function (DocumentTriggerParameters) {
+    DocumentTriggerParameters["SenderEmail"] = "senderEmail";
+    DocumentTriggerParameters["SenderName"] = "senderName";
+    DocumentTriggerParameters["Subject"] = "subject";
+    DocumentTriggerParameters["Body"] = "body";
+    DocumentTriggerParameters["Attachments"] = "attachments";
+})(DocumentTriggerParameters || (DocumentTriggerParameters = {}));
+class ManualInstrumentation {
+    enabled;
+    source;
+    tracer;
+    constructor(source, tracer) {
+        this.enabled = false;
+        this.source = source;
+        this.tracer = tracer;
     }
-}
-class VercelBatchSpanProcessor extends sdkTraceBase.BatchSpanProcessor {
-    onEnd(span) {
-        if (!shouldProcess(span))
-            return;
-        if (shouldConvertToLatitudeFormat(span))
-            convertToLatitudeFormat(span);
-        super.onEnd(span);
+    isEnabled() {
+        return this.enabled;
     }
-}
-function shouldProcess(span) {
-    return (Object.keys(span.attributes).some((k) => k.startsWith('latitude.')) ||
-        Object.keys(span.attributes).some((k) => k.startsWith('ai.')));
-}
-function shouldConvertToLatitudeFormat(span) {
-    return Object.keys(span.attributes).some((k) => k.startsWith('ai.'));
-}
-function convertToLatitudeFormat(span) {
-    try {
-        const computedAttrs = computeOpenLLMAttributes(span);
-        if (computedAttrs) {
-            ;
-            span.attributes = {
-                ...span.attributes,
-                ...computedAttrs,
-            };
-        }
+    enable() {
+        this.enabled = true;
     }
-    catch (e) {
-        console.log('Latitude telemetry Error: ', e);
-        // do nothing
+    disable() {
+        this.enabled = false;
     }
-}
-function computeOpenLLMAttributes(span) {
-    const attrs = span.attributes || {};
-    const result = {};
-    // Extract model information
-    if (attrs[AISemanticConventions.MODEL_ID]) {
-        result['gen_ai.request.model'] = String(attrs[AISemanticConventions.MODEL_ID]);
-        result['gen_ai.response.model'] = String(attrs[AISemanticConventions.MODEL_ID]);
-    }
-    // Extract settings
-    try {
-        const settings = attrs[AISemanticConventions.SETTINGS]
-            ? JSON.parse(String(attrs[AISemanticConventions.SETTINGS]))
-            : {};
-        if (settings) {
-            // Add max tokens if present
-            if (settings.maxTokens) {
-                result['gen_ai.request.max_tokens'] = settings.maxTokens;
-            }
-            if (!attrs['gen_ai.system'] && settings.provider) {
-                result['gen_ai.system'] = String(settings.provider);
-            }
+    baggage(ctx) {
+        if ('traceparent' in ctx) {
+            ctx = otel.propagation.extract(otel__namespace.ROOT_CONTEXT, ctx);
         }
+        const baggage = Object.fromEntries(otel.propagation.getBaggage(ctx)?.getAllEntries() || []);
+        if (!(ATTR_LATITUDE_SEGMENT_ID in baggage) ||
+            !(ATTR_LATITUDE_SEGMENTS in baggage)) {
+            return undefined;
+        }
+        const segment = {
+            id: baggage[ATTR_LATITUDE_SEGMENT_ID].value,
+            parentId: baggage[ATTR_LATITUDE_SEGMENT_PARENT_ID]?.value,
+        };
+        let segments = [];
+        try {
+            segments = JSON.parse(baggage[ATTR_LATITUDE_SEGMENTS].value);
+        }
+        catch (error) {
+            return undefined;
+        }
+        if (segments.length < 1) {
+            return undefined;
+        }
+        return { segment, segments };
     }
-    catch (e) {
-        console.error('Error parsing settings', e);
-    }
-    // Set request type to chat as that's what Vercel AI SDK uses
-    result['llm.request.type'] = 'chat';
-    // Extract messages
-    try {
-        const messages = attrs['ai.prompt.messages']
-            ? JSON.parse(String(attrs['ai.prompt.messages']))
-            : [];
-        // Process prompt messages
-        messages.forEach((msg, index) => {
-            result[`gen_ai.prompt.${index}.role`] = msg.role;
-            result[`gen_ai.prompt.${index}.content`] =
-                typeof msg.content === 'string'
-                    ? msg.content
-                    : JSON.stringify(msg.content);
+    setBaggage(ctx, baggage, extra) {
+        let parent = Object.fromEntries(otel.propagation.getBaggage(ctx)?.getAllEntries() || []);
+        parent = Object.fromEntries(Object.entries(parent).filter(([attribute]) => attribute !== ATTR_LATITUDE_SEGMENT_ID &&
+            attribute !== ATTR_LATITUDE_SEGMENT_PARENT_ID &&
+            attribute !== ATTR_LATITUDE_SEGMENTS));
+        if (!baggage) {
+            const payload = otel.propagation.createBaggage({ ...parent, ...(extra || {}) });
+            return otel.propagation.setBaggage(ctx, payload);
+        }
+        let jsonSegments = '';
+        try {
+            jsonSegments = JSON.stringify(baggage.segments);
+        }
+        catch (error) {
+            jsonSegments = '[]';
+        }
+        const payload = otel.propagation.createBaggage({
+            ...parent,
+            [ATTR_LATITUDE_SEGMENT_ID]: { value: baggage.segment.id },
+            ...(baggage.segment.parentId && {
+                [ATTR_LATITUDE_SEGMENT_PARENT_ID]: { value: baggage.segment.parentId },
+            }),
+            [ATTR_LATITUDE_SEGMENTS]: { value: jsonSegments },
+            ...(extra || {}),
         });
+        return otel.propagation.setBaggage(ctx, payload);
     }
-    catch (e) {
-        console.error('Error parsing messages', e);
-        return undefined;
+    pause(ctx) {
+        const baggage = this.baggage(ctx);
+        if (baggage) {
+            baggage.segments.at(-1).paused = true;
+        }
+        ctx = this.setBaggage(ctx, baggage);
+        let carrier = {};
+        otel.propagation.inject(ctx, carrier);
+        return carrier;
     }
-    // Extract completion/response
-    const responseText = attrs['ai.response.text'];
-    const responseObject = attrs['ai.response.object'];
-    const responseToolCalls = attrs['ai.response.toolCalls'];
-    if (responseText) {
-        result[`gen_ai.completion.0.role`] = 'assistant';
-        result[`gen_ai.completion.0.content`] = String(responseText);
+    resume(ctx) {
+        return otel.propagation.extract(otel__namespace.ROOT_CONTEXT, ctx);
     }
-    else if (responseToolCalls) {
-        try {
-            const toolCalls = JSON.parse(String(responseToolCalls));
-            if (toolCalls.length > 0) {
-                result['gen_ai.completion.0.finish_reason'] = 'tool_calls';
-                result[`gen_ai.completion.0.role`] = 'assistant';
-                toolCalls.forEach((toolCall, toolCallIndex) => {
-                    result[`gen_ai.completion.0.tool_calls.${toolCallIndex}.id`] =
-                        toolCall.toolCallId;
-                    result[`gen_ai.completion.0.tool_calls.${toolCallIndex}.name`] =
-                        toolCall.toolName;
-                    result[`gen_ai.completion.0.tool_calls.${toolCallIndex}.arguments`] =
-                        toolCall.args;
-                });
-            }
-        }
-        catch (e) {
-            console.error('Error parsing tool calls', e);
-        }
+    restored(ctx) {
+        const baggage = this.baggage(ctx);
+        return !baggage?.segments.some((segment) => segment.paused);
     }
-    else if (responseObject) {
-        result['gen_ai.completion.0.role'] = 'assistant';
-        result['gen_ai.completion.0.content'] = String(responseObject);
+    restore(ctx) {
+        let baggage = this.baggage(ctx);
+        if (!baggage)
+            return ctx;
+        const segments = baggage.segments;
+        while (segments.at(-1)?.paused)
+            segments.pop();
+        const segment = segments.at(-1);
+        if (!segment)
+            return otel__namespace.ROOT_CONTEXT;
+        baggage = {
+            segment: { id: segment.id, parentId: segment.parentId },
+            segments: segments,
+        };
+        ctx = this.setBaggage(ctx, baggage);
+        let carrier = {};
+        otel.propagation.inject(ctx, carrier);
+        carrier.traceparent = segment.traceparent;
+        carrier.tracestate = segment.tracestate;
+        return this.resume(carrier);
     }
-    // Extract token usage
-    const completionTokens = attrs['ai.usage.completionTokens'];
-    const promptTokens = attrs['ai.usage.promptTokens'];
-    if (typeof completionTokens === 'number') {
-        result['gen_ai.usage.completion_tokens'] = completionTokens;
+    capitalize(str) {
+        if (str.length === 0)
+            return str;
+        return str.charAt(0).toUpperCase() + str.toLowerCase().slice(1);
     }
-    if (typeof promptTokens === 'number') {
-        result['gen_ai.usage.prompt_tokens'] = promptTokens;
+    toCamelCase(str) {
+        return str
+            .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+            .replace(/[^A-Za-z0-9]+/g, ' ')
+            .trim()
+            .split(' ')
+            .map((w, i) => (i ? this.capitalize(w) : w.toLowerCase()))
+            .join('');
     }
-    if (typeof completionTokens === 'number' &&
-        typeof promptTokens === 'number') {
-        result['llm.usage.total_tokens'] = completionTokens + promptTokens;
+    toSnakeCase(str) {
+        return str
+            .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+            .replace(/[^A-Za-z0-9]+/g, '_')
+            .replace(/_+/g, '_')
+            .replace(/^_+|_+$/g, '')
+            .toLowerCase();
     }
-    return result;
-}
-class LatitudeTelemetrySDK {
-    exporter;
-    constructor({ exporter, modules = {}, disableBatch = false, processors = [], }) {
-        this.exporter = exporter;
-        this._init(modules, { disableBatch, processors });
-    }
-    _init(modules, options) {
-        const instrumentations = [];
-        if (modules?.openAI) {
-            const openAIInstrumentation = new instrumentationOpenai.OpenAIInstrumentation({
-                enrichTokens: true,
-            });
-            // @ts-ignore
-            openAIInstrumentation.manuallyInstrument(modules.openAI);
-            instrumentations.push(openAIInstrumentation);
-        }
-        if (modules?.anthropic) {
-            const anthropicInstrumentation = new instrumentationAnthropic.AnthropicInstrumentation();
-            anthropicInstrumentation.manuallyInstrument(modules.anthropic);
-            instrumentations.push(new instrumentationAnthropic.AnthropicInstrumentation());
-        }
-        if (modules?.azureOpenAI) {
-            const azureOpenAIInstrumentation = new instrumentationAzure.AzureOpenAIInstrumentation();
-            azureOpenAIInstrumentation.manuallyInstrument(modules.azureOpenAI);
-            instrumentations.push(azureOpenAIInstrumentation);
-        }
-        if (modules?.cohere) {
-            const cohereInstrumentation = new instrumentationCohere.CohereInstrumentation();
-            cohereInstrumentation.manuallyInstrument(modules.cohere);
-            instrumentations.push(cohereInstrumentation);
-        }
-        if (modules?.google_vertexai) {
-            const vertexAIInstrumentation = new instrumentationVertexai.VertexAIInstrumentation();
-            vertexAIInstrumentation.manuallyInstrument(modules.google_vertexai);
-            instrumentations.push(vertexAIInstrumentation);
-        }
-        if (modules?.google_aiplatform) {
-            const aiplatformInstrumentation = new instrumentationVertexai.AIPlatformInstrumentation();
-            aiplatformInstrumentation.manuallyInstrument(modules.google_aiplatform);
-            instrumentations.push(aiplatformInstrumentation);
-        }
-        if (modules?.bedrock) {
-            const bedrockInstrumentation = new instrumentationBedrock.BedrockInstrumentation();
-            bedrockInstrumentation.manuallyInstrument(modules.bedrock);
-            instrumentations.push(bedrockInstrumentation);
-        }
-        // TODO: Enable these once we have manually tested them
-        //if (modules?.langchain) {
-        //  const langchainInstrumentation = new LangChainInstrumentation()
-        //  langchainInstrumentation.manuallyInstrument(modules.langchain!)
-        //  instrumentations.push(langchainInstrumentation)
-        //}
-        //
-        //if (modules?.llamaIndex) {
-        //  const llamaindexInstrumentation = new LlamaIndexInstrumentation()
-        //  llamaindexInstrumentation.manuallyInstrument(modules.llamaIndex!)
-        //  instrumentations.push(llamaindexInstrumentation)
-        //}
-        //if (modules?.pinecone) {
-        //  const pineconeInstrumentation = new PineconeInstrumentation()
-        //  pineconeInstrumentation.manuallyInstrument(modules.pinecone!)
-        //  instrumentations.push(pineconeInstrumentation)
-        //}
-        //if (modules?.chromadb) {
-        //  const chromadbInstrumentation = new ChromaDBInstrumentation()
-        //  chromadbInstrumentation.manuallyInstrument(modules.chromadb!)
-        //  instrumentations.push(chromadbInstrumentation)
-        //}
-        //if (modules?.qdrant) {
-        //  const qdrantInstrumentation = new QdrantInstrumentation()
-        //  qdrantInstrumentation.manuallyInstrument(modules.qdrant!)
-        //  instrumentations.push(qdrantInstrumentation)
-        //}
-        if (!instrumentations.length && !options?.processors?.length) {
-            console.warn('Latitude: No instrumentations or processors to initialize');
-            return;
-        }
-        const processors = options?.disableBatch
-            ? [
-                new sdkTraceNode.SimpleSpanProcessor(this.exporter),
-                ...(options?.processors?.map((processor) => new processor(this.exporter)) || []),
-            ]
-            : [
-                new sdkTraceNode.BatchSpanProcessor(this.exporter),
-                ...(options?.processors?.map((processor) => new processor(this.exporter)) || []),
-            ];
-        const sdk = new sdkNode.NodeSDK({
-            resource: new resources.Resource({
-                'service.name': process.env.npm_package_name,
-            }),
-            instrumentations,
-            traceExporter: this.exporter,
-            // @ts-ignore
-            spanProcessors: processors,
+    toKebabCase(input) {
+        return input
+            .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+            .replace(/[^A-Za-z0-9]+/g, '-')
+            .replace(/-+/g, '-')
+            .replace(/^-+|-+$/g, '')
+            .toLowerCase();
+    }
+    error(span, error, options) {
+        options = options || {};
+        span.recordException(error);
+        span.setAttributes(options.attributes || {});
+        span.setStatus({
+            code: otel__namespace.SpanStatusCode.ERROR,
+            message: error.message || undefined,
         });
-        sdk.start();
+        span.end();
     }
-    span(s, fn) {
-        const c = api.context.active();
-        return api.context.with(c, () => api.trace
-            .getTracer('latitude')
-            .startActiveSpan(s.name ?? 'latitude.span', {}, c, async (span) => {
-            try {
-                if (s.prompt) {
+    span(ctx, name, type, options) {
+        if (!this.enabled) {
+            return {
+                context: ctx,
+                end: (_options) => { },
+                fail: (_error, _options) => { },
+            };
+        }
+        const start = options || {};
+        let operation = undefined;
+        if (GENAI_SPANS.includes(type)) {
+            operation = type;
+        }
+        const span = this.tracer.startSpan(name, {
+            attributes: {
+                [ATTR_LATITUDE_TYPE]: type,
+                ...(operation && {
+                    [incubating.ATTR_GEN_AI_OPERATION_NAME]: operation,
+                }),
+                ...(start.attributes || {}),
+            },
+            kind: otel__namespace.SpanKind.CLIENT,
+        }, ctx);
+        const newCtx = otel.trace.setSpan(ctx, span);
+        return {
+            context: newCtx,
+            end: (options) => {
+                const end = options || {};
+                span.setAttributes(end.attributes || {});
+                span.setStatus({ code: otel__namespace.SpanStatusCode.OK });
+                span.end();
+            },
+            fail: (error, options) => {
+                this.error(span, error, options);
+            },
+        };
+    }
+    tool(ctx, options) {
+        const start = options;
+        let jsonArguments = '';
+        try {
+            jsonArguments = JSON.stringify(start.call.arguments);
+        }
+        catch (error) {
+            jsonArguments = '{}';
+        }
+        const span = this.span(ctx, start.name, SpanType.Tool, {
+            attributes: {
+                [incubating.ATTR_GEN_AI_TOOL_NAME]: start.name,
+                [incubating.ATTR_GEN_AI_TOOL_TYPE]: GEN_AI_TOOL_TYPE_VALUE_FUNCTION,
+                [incubating.ATTR_GEN_AI_TOOL_CALL_ID]: start.call.id,
+                [ATTR_GEN_AI_TOOL_CALL_ARGUMENTS]: jsonArguments,
+                ...(start.attributes || {}),
+            },
+        });
+        return {
+            context: span.context,
+            end: (options) => {
+                const end = options;
+                let stringResult = '';
+                if (typeof end.result.value !== 'string') {
                     try {
-                        span.setAttribute('latitude.prompt', JSON.stringify(s.prompt));
+                        stringResult = JSON.stringify(end.result.value);
                     }
-                    catch (e) {
-                        console.error('Latitude: Could not serialize latitude.prompt attribute', e);
+                    catch (error) {
+                        stringResult = '{}';
                     }
                 }
-                if (s.distinctId) {
-                    span.setAttribute('latitude.distinctId', s.distinctId);
+                else {
+                    stringResult = end.result.value;
                 }
-                if (s.metadata) {
-                    try {
-                        span.setAttribute('latitude.metadata', JSON.stringify(s.metadata));
+                span.end({
+                    attributes: {
+                        [ATTR_GEN_AI_TOOL_RESULT_VALUE]: stringResult,
+                        [ATTR_GEN_AI_TOOL_RESULT_IS_ERROR]: end.result.isError,
+                        ...(end.attributes || {}),
+                    },
+                });
+            },
+            fail: span.fail,
+        };
+    }
+    attribifyMessageToolCalls(prefix, toolCalls) {
+        const attributes = {};
+        for (let i = 0; i < toolCalls.length; i++) {
+            for (const key in toolCalls[i]) {
+                const field = this.toCamelCase(key);
+                let value = toolCalls[i][key];
+                if (value === null || value === undefined)
+                    continue;
+                switch (field) {
+                    case 'id':
+                    case 'toolCallId':
+                    case 'toolUseId': {
+                        if (typeof value !== 'string')
+                            continue;
+                        attributes[`${prefix}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS}.${i}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS_ID}`] = value;
+                        break;
+                    }
+                    case 'name':
+                    case 'toolName': {
+                        if (typeof value !== 'string')
+                            continue;
+                        attributes[`${prefix}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS}.${i}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS_NAME}`] = value;
+                        break;
                     }
-                    catch (e) {
-                        console.error('Latitude: Could not serialize latitude.metadata attribute', e);
+                    case 'arguments':
+                    case 'toolArguments':
+                    case 'input': {
+                        if (typeof value === 'string') {
+                            attributes[`${prefix}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS}.${i}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS_ARGUMENTS}`] = value;
+                        }
+                        else {
+                            try {
+                                attributes[`${prefix}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS}.${i}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS_ARGUMENTS}`] = JSON.stringify(value);
+                            }
+                            catch (error) {
+                                attributes[`${prefix}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS}.${i}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS_ARGUMENTS}`] = '{}';
+                            }
+                        }
+                        break;
                     }
+                    /* OpenAI function calls */
+                    case 'function': {
+                        if (typeof value !== 'object')
+                            continue;
+                        if (!('name' in value))
+                            continue;
+                        if (typeof value.name !== 'string')
+                            continue;
+                        if (!('arguments' in value))
+                            continue;
+                        if (typeof value.arguments !== 'string')
+                            continue;
+                        attributes[`${prefix}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS}.${i}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS_NAME}`] = value.name;
+                        attributes[`${prefix}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS}.${i}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS_ARGUMENTS}`] = value.arguments;
+                        break;
+                    }
+                }
+            }
+        }
+        return attributes;
+    }
+    attribifyMessageContent(prefix, content) {
+        let attributes = {};
+        if (typeof content === 'string') {
+            attributes[`${prefix}.${ATTR_GEN_AI_MESSAGE_CONTENT}`] = content;
+            return attributes;
+        }
+        try {
+            attributes[`${prefix}.${ATTR_GEN_AI_MESSAGE_CONTENT}`] =
+                JSON.stringify(content);
+        }
+        catch (error) {
+            attributes[`${prefix}.${ATTR_GEN_AI_MESSAGE_CONTENT}`] = '[]';
+        }
+        if (!Array.isArray(content))
+            return attributes;
+        /* Tool calls for Anthropic and PromptL are in the content */
+        const toolCalls = [];
+        for (const item of content) {
+            for (const key in item) {
+                if (this.toCamelCase(key) !== 'type')
+                    continue;
+                if (typeof item[key] !== 'string')
+                    continue;
+                if (item[key] !== 'tool-call' && item[key] !== 'tool_use')
+                    continue;
+                toolCalls.push(item);
+            }
+        }
+        if (toolCalls.length > 0) {
+            attributes = {
+                ...attributes,
+                ...this.attribifyMessageToolCalls(prefix, toolCalls),
+            };
+        }
+        return attributes;
+    }
+    attribifyMessages(direction, messages) {
+        const prefix = direction === 'input' ? ATTR_GEN_AI_PROMPTS : ATTR_GEN_AI_COMPLETIONS;
+        let attributes = {};
+        for (let i = 0; i < messages.length; i++) {
+            for (const key in messages[i]) {
+                const field = this.toCamelCase(key);
+                let value = messages[i][key];
+                if (value === null || value === undefined)
+                    continue;
+                switch (field) {
+                    case 'role': {
+                        if (typeof value !== 'string')
+                            continue;
+                        attributes[`${prefix}.${i}.${ATTR_GEN_AI_MESSAGE_ROLE}`] = value;
+                        break;
+                    }
+                    /* Tool calls for Anthropic and PromptL are in the content */
+                    case 'content': {
+                        attributes = {
+                            ...attributes,
+                            ...this.attribifyMessageContent(`${prefix}.${i}`, value),
+                        };
+                        break;
+                    }
+                    /* Tool calls for OpenAI */
+                    case 'toolCalls': {
+                        if (!Array.isArray(value))
+                            continue;
+                        attributes = {
+                            ...attributes,
+                            ...this.attribifyMessageToolCalls(`${prefix}.${i}`, value),
+                        };
+                        break;
+                    }
+                    /* Tool result for OpenAI / Anthropic / PromptL */
+                    case 'toolCallId':
+                    case 'toolId':
+                    case 'toolUseId': {
+                        if (typeof value !== 'string')
+                            continue;
+                        attributes[`${prefix}.${i}.${ATTR_GEN_AI_MESSAGE_TOOL_CALL_ID}`] =
+                            value;
+                        break;
+                    }
+                    case 'toolName': {
+                        if (typeof value !== 'string')
+                            continue;
+                        attributes[`${prefix}.${i}.${ATTR_GEN_AI_MESSAGE_TOOL_NAME}`] =
+                            value;
+                        break;
+                    }
+                    // Note: 'toolResult' is 'content' itself
+                    case 'isError': {
+                        if (typeof value !== 'boolean')
+                            continue;
+                        attributes[`${prefix}.${i}.${ATTR_GEN_AI_MESSAGE_TOOL_RESULT_IS_ERROR}`] = value;
+                        break;
+                    }
+                }
+            }
+        }
+        return attributes;
+    }
+    attribifyConfiguration(direction, configuration) {
+        const prefix = direction === 'input' ? ATTR_GEN_AI_REQUEST : ATTR_GEN_AI_RESPONSE;
+        const attributes = {};
+        for (const key in configuration) {
+            const field = this.toSnakeCase(key);
+            let value = configuration[key];
+            if (value === null || value === undefined)
+                continue;
+            if (typeof value === 'object' && !Array.isArray(value)) {
+                try {
+                    value = JSON.stringify(value);
+                }
+                catch (error) {
+                    value = '{}';
+                }
+            }
+            attributes[`${prefix}.${field}`] = value;
+        }
+        return attributes;
+    }
+    completion(ctx, options) {
+        const start = options;
+        const configuration = {
+            ...start.configuration,
+            model: start.model,
+        };
+        let jsonConfiguration = '';
+        try {
+            jsonConfiguration = JSON.stringify(configuration);
+        }
+        catch (error) {
+            jsonConfiguration = '{}';
+        }
+        const attrConfiguration = this.attribifyConfiguration('input', configuration);
+        let jsonInput = '';
+        try {
+            jsonInput = JSON.stringify(start.input);
+        }
+        catch (error) {
+            jsonInput = '[]';
+        }
+        const attrInput = this.attribifyMessages('input', start.input);
+        const span = this.span(ctx, start.name || `${start.provider} / ${start.model}`, SpanType.Completion, {
+            attributes: {
+                [incubating.ATTR_GEN_AI_SYSTEM]: start.provider,
+                [ATTR_GEN_AI_REQUEST_CONFIGURATION]: jsonConfiguration,
+                ...attrConfiguration,
+                [ATTR_GEN_AI_REQUEST_MESSAGES]: jsonInput,
+                ...attrInput,
+                ...(start.attributes || {}),
+            },
+        });
+        return {
+            context: span.context,
+            end: (options) => {
+                const end = options;
+                let jsonOutput = '';
+                try {
+                    jsonOutput = JSON.stringify(end.output);
+                }
+                catch (error) {
+                    jsonOutput = '[]';
                 }
+                const attrOutput = this.attribifyMessages('output', end.output);
+                const inputTokens = end.tokens.prompt + end.tokens.cached;
+                const outputTokens = end.tokens.reasoning + end.tokens.completion;
+                span.end({
+                    attributes: {
+                        [ATTR_GEN_AI_RESPONSE_MESSAGES]: jsonOutput,
+                        ...attrOutput,
+                        [incubating.ATTR_GEN_AI_USAGE_INPUT_TOKENS]: inputTokens,
+                        [ATTR_GEN_AI_USAGE_PROMPT_TOKENS]: end.tokens.prompt,
+                        [ATTR_GEN_AI_USAGE_CACHED_TOKENS]: end.tokens.cached,
+                        [ATTR_GEN_AI_USAGE_REASONING_TOKENS]: end.tokens.reasoning,
+                        [ATTR_GEN_AI_USAGE_COMPLETION_TOKENS]: end.tokens.completion,
+                        [incubating.ATTR_GEN_AI_USAGE_OUTPUT_TOKENS]: outputTokens,
+                        [incubating.ATTR_GEN_AI_RESPONSE_MODEL]: start.model,
+                        [incubating.ATTR_GEN_AI_RESPONSE_FINISH_REASONS]: [end.finishReason],
+                        ...(end.attributes || {}),
+                    },
+                });
+            },
+            fail: span.fail,
+        };
+    }
+    embedding(ctx, options) {
+        return this.span(ctx, options?.name || 'Embedding', SpanType.Embedding, options);
+    }
+    retrieval(ctx, options) {
+        return this.span(ctx, options?.name || 'Retrieval', SpanType.Retrieval, options);
+    }
+    reranking(ctx, options) {
+        return this.span(ctx, options?.name || 'Reranking', SpanType.Reranking, options);
+    }
+    attribifyHeaders(direction, headers) {
+        const prefix = direction === 'request'
+            ? ATTR_HTTP_REQUEST_HEADERS
+            : ATTR_HTTP_RESPONSE_HEADERS;
+        const attributes = {};
+        for (const key in headers) {
+            const field = this.toKebabCase(key);
+            const value = headers[key];
+            if (value === null || value === undefined)
+                continue;
+            attributes[`${prefix}.${field}`] = value;
+        }
+        return attributes;
+    }
+    http(ctx, options) {
+        const start = options;
+        const method = start.request.method.toUpperCase();
+        const attrHeaders = this.attribifyHeaders('request', start.request.headers);
+        let finalBody = '';
+        if (typeof start.request.body === 'string') {
+            finalBody = start.request.body;
+        }
+        else {
+            try {
+                finalBody = JSON.stringify(start.request.body);
             }
             catch (error) {
-                console.error(error);
+                finalBody = '{}';
             }
-            const res = fn(span);
-            if (res instanceof Promise) {
-                return res.then((resolvedRes) => {
-                    span.end();
-                    return resolvedRes;
+        }
+        const span = this.span(ctx, start.name || `${method} ${start.request.url}`, SpanType.Http, {
+            attributes: {
+                [semanticConventions.ATTR_HTTP_REQUEST_METHOD]: method,
+                [ATTR_HTTP_REQUEST_URL]: start.request.url,
+                ...attrHeaders,
+                [ATTR_HTTP_REQUEST_BODY]: finalBody,
+                ...(start.attributes || {}),
+            },
+        });
+        return {
+            context: span.context,
+            end: (options) => {
+                const end = options;
+                const attrHeaders = this.attribifyHeaders('response', end.response.headers);
+                let finalBody = '';
+                if (typeof end.response.body === 'string') {
+                    finalBody = end.response.body;
+                }
+                else {
+                    try {
+                        finalBody = JSON.stringify(end.response.body);
+                    }
+                    catch (error) {
+                        finalBody = '{}';
+                    }
+                }
+                span.end({
+                    attributes: {
+                        [semanticConventions.ATTR_HTTP_RESPONSE_STATUS_CODE]: end.response.status,
+                        ...attrHeaders,
+                        [ATTR_HTTP_RESPONSE_BODY]: finalBody,
+                        ...(end.attributes || {}),
+                    },
                 });
+            },
+            fail: span.fail,
+        };
+    }
+    segment(ctx, type, data, options) {
+        options = options || {};
+        let baggage = this.baggage(ctx);
+        const parent = baggage?.segments.at(-1);
+        const segments = baggage?.segments || [];
+        segments.push({
+            ...{
+                id: options._internal?.id || uuid.v4(),
+                ...(parent?.id && { parentId: parent.id }),
+                source: options._internal?.source || parent?.source || this.source,
+                type: type,
+                data: data,
+            },
+            traceparent: 'undefined',
+            tracestate: undefined,
+        });
+        const segment = segments.at(-1);
+        baggage = {
+            segment: { id: segment.id, parentId: segment.parentId },
+            segments: segments,
+        };
+        ctx = this.setBaggage(ctx, baggage, options.baggage);
+        // Dummy wrapper to force the same trace and carry on some segment attributes
+        const span = this.span(ctx, type, SpanType.Segment, {
+            attributes: options.attributes,
+        });
+        let carrier = {};
+        otel.propagation.inject(span.context, carrier);
+        baggage.segments.at(-1).traceparent = carrier.traceparent;
+        baggage.segments.at(-1).tracestate = carrier.tracestate;
+        // Fix current segment span segments attribute now that we know the trace
+        otel.trace
+            .getSpan(span.context)
+            .setAttribute(ATTR_LATITUDE_SEGMENTS, JSON.stringify(baggage.segments));
+        ctx = this.setBaggage(span.context, baggage, options.baggage);
+        return { context: ctx, end: span.end, fail: span.fail };
+    }
+    prompt(ctx, { logUuid, versionUuid, promptUuid, experimentUuid, externalId, template, parameters, ...rest }) {
+        const baggage = {
+            ...(logUuid && { logUuid }), // TODO(tracing): temporal related log, remove when observability is ready
+            commitUuid: versionUuid || HEAD_COMMIT,
+            documentUuid: promptUuid,
+            ...(experimentUuid && { experimentUuid }),
+            ...(externalId && { externalId }),
+        };
+        let jsonParameters = '';
+        try {
+            jsonParameters = JSON.stringify(parameters || {});
+        }
+        catch (error) {
+            jsonParameters = '{}';
+        }
+        const attributes = {
+            [ATTR_GEN_AI_REQUEST_TEMPLATE]: template,
+            [ATTR_GEN_AI_REQUEST_PARAMETERS]: jsonParameters,
+            ...(rest.attributes || {}),
+        };
+        return this.segment(ctx, SegmentType.Document, baggage, {
+            ...rest,
+            attributes,
+        });
+    }
+    step(ctx, options) {
+        return this.segment(ctx, SegmentType.Step, undefined, options);
+    }
+}
+class LatitudeInstrumentation {
+    options;
+    telemetry;
+    constructor(source, tracer, options) {
+        this.telemetry = new ManualInstrumentation(source, tracer);
+        this.options = options;
+    }
+    isEnabled() {
+        return this.telemetry.isEnabled();
+    }
+    enable() {
+        this.options.module.instrument(this);
+        this.telemetry.enable();
+    }
+    disable() {
+        this.telemetry.disable();
+        this.options.module.uninstrument();
+    }
+    countTokens(messages) {
+        let length = 0;
+        for (const message of messages) {
+            if (!('content' in message))
+                continue;
+            if (typeof message.content === 'string') {
+                length += message.content.length;
             }
-            span.end();
-            return res;
+            else if (Array.isArray(message.content)) {
+                for (const content of message.content) {
+                    if (content.type === 'text') {
+                        length += content.text.length;
+                    }
+                }
+            }
+        }
+        // Note: this is an estimation to not bundle a tokenizer
+        return Math.ceil(length / 4);
+    }
+    withTraceContext(ctx, fn) {
+        return otel.context.with(this.telemetry.resume(ctx), fn);
+    }
+    async wrapToolHandler(fn, ...args) {
+        const toolArguments = args[0];
+        const { toolId, toolName } = args[1];
+        const $tool = this.telemetry.tool(otel.context.active(), {
+            name: toolName,
+            call: {
+                id: toolId,
+                arguments: toolArguments,
+            },
+        });
+        let result;
+        try {
+            result = await otel.context.with($tool.context, async () => await fn(...args));
+        }
+        catch (error) {
+            if (error.name === 'ToolExecutionPausedError') {
+                $tool.fail(error);
+                throw error;
+            }
+            $tool.end({
+                result: {
+                    value: error.message,
+                    isError: true,
+                },
+            });
+            throw error;
+        }
+        $tool.end({
+            result: {
+                value: result,
+                isError: false,
+            },
+        });
+        return result;
+    }
+    async wrapRenderChain(fn, ...args) {
+        const { prompt, parameters } = args[0];
+        const $prompt = this.telemetry.prompt(otel.context.active(), {
+            versionUuid: prompt.versionUuid,
+            promptUuid: prompt.uuid,
+            template: prompt.content,
+            parameters: parameters,
+        });
+        let result;
+        try {
+            result = await otel.context.with($prompt.context, async () => await fn(...args));
+        }
+        catch (error) {
+            $prompt.fail(error);
+            throw error;
+        }
+        $prompt.end();
+        return result;
+    }
+    async wrapRenderAgent(fn, ...args) {
+        const { prompt, parameters } = args[0];
+        const $prompt = this.telemetry.prompt(otel.context.active(), {
+            versionUuid: prompt.versionUuid,
+            promptUuid: prompt.uuid,
+            template: prompt.content,
+            parameters: parameters,
+        });
+        let result;
+        try {
+            result = await otel.context.with($prompt.context, async () => await fn(...args));
+        }
+        catch (error) {
+            $prompt.fail(error);
+            throw error;
+        }
+        $prompt.end();
+        return result;
+    }
+    async wrapRenderStep(fn, ...args) {
+        const $step = this.telemetry.step(otel.context.active());
+        let result;
+        try {
+            result = await otel.context.with($step.context, async () => await fn(...args));
+        }
+        catch (error) {
+            $step.fail(error);
+            throw error;
+        }
+        $step.end();
+        return result;
+    }
+    async wrapRenderCompletion(fn, ...args) {
+        if (!this.options.completions) {
+            return await fn(...args);
+        }
+        const { provider, config, messages } = args[0];
+        const model = config.model || 'unknown';
+        const $completion = this.telemetry.completion(otel.context.active(), {
+            name: `${provider} / ${model}`,
+            provider: provider,
+            model: model,
+            configuration: config,
+            input: messages,
+        });
+        let result;
+        try {
+            result = await otel.context.with($completion.context, async () => await fn(...args));
+        }
+        catch (error) {
+            $completion.fail(error);
+            throw error;
+        }
+        // Note: enhance, this is just an estimation
+        const promptTokens = this.countTokens(messages);
+        const completionTokens = this.countTokens(result.messages);
+        $completion.end({
+            output: result.messages,
+            tokens: {
+                prompt: promptTokens,
+                cached: 0,
+                reasoning: 0,
+                completion: completionTokens,
+            },
+            finishReason: result.toolRequests.length > 0
+                ? GEN_AI_RESPONSE_FINISH_REASON_VALUE_TOOL_CALLS
+                : GEN_AI_RESPONSE_FINISH_REASON_VALUE_STOP,
+        });
+        return result;
+    }
+    async wrapRenderTool(fn, ...args) {
+        const { toolRequest } = args[0];
+        const $tool = this.telemetry.tool(otel.context.active(), {
+            name: toolRequest.toolName,
+            call: {
+                id: toolRequest.toolCallId,
+                arguments: toolRequest.toolArguments,
+            },
+        });
+        let result;
+        try {
+            result = await otel.context.with($tool.context, async () => await fn(...args));
+        }
+        catch (error) {
+            $tool.fail(error);
+            throw error;
+        }
+        $tool.end({
+            result: {
+                value: result,
+                isError: false, // Note: currently unknown
+            },
+        });
+        return result;
+    }
+}
+const TRACES_URL = `${env.GATEWAY_BASE_URL}/api/v3/otlp/v1/traces`;
+const SERVICE_NAME = process.env.npm_package_name || 'unknown';
+const SCOPE_VERSION = process.env.npm_package_version || 'unknown';
+const BACKGROUND = () => otel__namespace.ROOT_CONTEXT;
+class ScopedTracerProvider {
+    scope;
+    version;
+    provider;
+    constructor(scope, version, provider) {
+        this.scope = scope;
+        this.version = version;
+        this.provider = provider;
+    }
+    getTracer(_name, _version, options) {
+        return this.provider.getTracer(this.scope, this.version, options);
+    }
+}
+const DEFAULT_SPAN_EXPORTER = (apiKey) => new exporterTraceOtlpHttp.OTLPTraceExporter({
+    url: TRACES_URL,
+    headers: {
+        Authorization: `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+    },
+    timeoutMillis: 30 * 1000,
+});
+// Note: Only exporting typescript instrumentations
+exports.Instrumentation = void 0;
+(function (Instrumentation) {
+    Instrumentation["Latitude"] = "latitude";
+    Instrumentation["OpenAI"] = "openai";
+    Instrumentation["Anthropic"] = "anthropic";
+    Instrumentation["AzureOpenAI"] = "azure";
+    Instrumentation["VercelAI"] = "vercelai";
+    Instrumentation["VertexAI"] = "vertexai";
+    Instrumentation["AIPlatform"] = "aiplatform";
+    Instrumentation["Bedrock"] = "bedrock";
+    Instrumentation["TogetherAI"] = "togetherai";
+    Instrumentation["Cohere"] = "cohere";
+    Instrumentation["Langchain"] = "langchain";
+    Instrumentation["LlamaIndex"] = "llamaindex";
+})(exports.Instrumentation || (exports.Instrumentation = {}));
+class LatitudeTelemetry {
+    options;
+    provider;
+    telemetry;
+    instrumentations;
+    constructor(apiKey, options) {
+        this.options = options || {};
+        if (!this.options.exporter) {
+            this.options.exporter = DEFAULT_SPAN_EXPORTER(apiKey);
+        }
+        otel.context.setGlobalContextManager(new contextAsyncHooks.AsyncLocalStorageContextManager().enable());
+        otel.propagation.setGlobalPropagator(new core.CompositePropagator({
+            propagators: [
+                ...(this.options.propagators || []),
+                new core.W3CTraceContextPropagator(),
+                new core.W3CBaggagePropagator(),
+            ],
         }));
+        this.provider = new sdkTraceNode.NodeTracerProvider({
+            resource: new resources.Resource({ [semanticConventions.ATTR_SERVICE_NAME]: SERVICE_NAME }),
+        });
+        // Note: important, must run before the exporter span processors
+        this.provider.addSpanProcessor(new baggageSpanProcessor.BaggageSpanProcessor(baggageSpanProcessor.ALLOW_ALL_BAGGAGE_KEYS));
+        if (this.options.processors) {
+            this.options.processors.forEach((processor) => {
+                this.provider.addSpanProcessor(processor);
+            });
+        }
+        else {
+            this.provider.addSpanProcessor(DEFAULT_REDACT_SPAN_PROCESSOR());
+        }
+        if (this.options.disableBatch) {
+            this.provider.addSpanProcessor(new sdkTraceNode.SimpleSpanProcessor(this.options.exporter));
+        }
+        else {
+            this.provider.addSpanProcessor(new sdkTraceNode.BatchSpanProcessor(this.options.exporter));
+        }
+        this.provider.register();
+        process.on('SIGTERM', async () => this.shutdown);
+        process.on('SIGINT', async () => this.shutdown);
+        this.telemetry = null;
+        this.instrumentations = [];
+        this.initInstrumentations();
+        this.instrument();
+    }
+    async flush() {
+        await this.provider.forceFlush();
+        await this.options.exporter.forceFlush?.();
+    }
+    async shutdown() {
+        await this.flush();
+        await this.provider.shutdown();
+        await this.options.exporter.shutdown?.();
+    }
+    tracerProvider(instrumentation) {
+        return new ScopedTracerProvider(`${SCOPE_LATITUDE}.${instrumentation}`, SCOPE_VERSION, this.provider);
+    }
+    tracer(instrumentation) {
+        return this.tracerProvider(instrumentation).getTracer('');
+    }
+    // TODO(tracing): auto instrument outgoing HTTP requests
+    initInstrumentations() {
+        this.instrumentations = [];
+        const tracer = this.tracer(InstrumentationScope.Manual);
+        this.telemetry = new ManualInstrumentation(SegmentSource.API, tracer);
+        this.instrumentations.push(this.telemetry);
+        const latitude = this.options.instrumentations?.latitude;
+        if (latitude) {
+            const tracer = this.tracer(exports.Instrumentation.Latitude);
+            const instrumentation = new LatitudeInstrumentation(SegmentSource.API, tracer, typeof latitude === 'object' ? latitude : { module: latitude });
+            this.instrumentations.push(instrumentation);
+        }
+        const openai = this.options.instrumentations?.openai;
+        if (openai) {
+            const provider = this.tracerProvider(exports.Instrumentation.OpenAI);
+            const instrumentation$1 = new instrumentationOpenai.OpenAIInstrumentation({ enrichTokens: true });
+            instrumentation$1.setTracerProvider(provider);
+            instrumentation$1.manuallyInstrument(openai);
+            instrumentation.registerInstrumentations({
+                instrumentations: [instrumentation$1],
+                tracerProvider: provider,
+            });
+            this.instrumentations.push(instrumentation$1);
+        }
+        const anthropic = this.options.instrumentations?.anthropic;
+        if (anthropic) {
+            const provider = this.tracerProvider(exports.Instrumentation.Anthropic);
+            const instrumentation$1 = new instrumentationAnthropic.AnthropicInstrumentation();
+            instrumentation$1.setTracerProvider(provider);
+            instrumentation$1.manuallyInstrument(anthropic);
+            instrumentation.registerInstrumentations({
+                instrumentations: [instrumentation$1],
+                tracerProvider: provider,
+            });
+            this.instrumentations.push(instrumentation$1);
+        }
+        const azure = this.options.instrumentations?.azure;
+        if (azure) {
+            const provider = this.tracerProvider(exports.Instrumentation.AzureOpenAI);
+            const instrumentation$1 = new instrumentationAzure.AzureOpenAIInstrumentation();
+            instrumentation$1.setTracerProvider(provider);
+            instrumentation$1.manuallyInstrument(azure);
+            instrumentation.registerInstrumentations({
+                instrumentations: [instrumentation$1],
+                tracerProvider: provider,
+            });
+            this.instrumentations.push(instrumentation$1);
+        }
+        const vertexai = this.options.instrumentations?.vertexai;
+        if (vertexai) {
+            const provider = this.tracerProvider(exports.Instrumentation.VertexAI);
+            const instrumentation$1 = new instrumentationVertexai.VertexAIInstrumentation();
+            instrumentation$1.setTracerProvider(provider);
+            instrumentation$1.manuallyInstrument(vertexai);
+            instrumentation.registerInstrumentations({
+                instrumentations: [instrumentation$1],
+                tracerProvider: provider,
+            });
+            this.instrumentations.push(instrumentation$1);
+        }
+        const aiplatform = this.options.instrumentations?.aiplatform;
+        if (aiplatform) {
+            const provider = this.tracerProvider(exports.Instrumentation.AIPlatform);
+            const instrumentation$1 = new instrumentationVertexai.AIPlatformInstrumentation();
+            instrumentation$1.setTracerProvider(provider);
+            instrumentation$1.manuallyInstrument(aiplatform);
+            instrumentation.registerInstrumentations({
+                instrumentations: [instrumentation$1],
+                tracerProvider: provider,
+            });
+            this.instrumentations.push(instrumentation$1);
+        }
+        const bedrock = this.options.instrumentations?.bedrock;
+        if (bedrock) {
+            const provider = this.tracerProvider(exports.Instrumentation.Bedrock);
+            const instrumentation$1 = new instrumentationBedrock.BedrockInstrumentation();
+            instrumentation$1.setTracerProvider(provider);
+            instrumentation$1.manuallyInstrument(bedrock);
+            instrumentation.registerInstrumentations({
+                instrumentations: [instrumentation$1],
+                tracerProvider: provider,
+            });
+            this.instrumentations.push(instrumentation$1);
+        }
+        const togetherai = this.options.instrumentations?.togetherai;
+        if (togetherai) {
+            const provider = this.tracerProvider(exports.Instrumentation.TogetherAI);
+            const instrumentation$1 = new instrumentationTogether.TogetherInstrumentation({
+                enrichTokens: true,
+            });
+            instrumentation$1.setTracerProvider(provider);
+            instrumentation$1.manuallyInstrument(togetherai);
+            instrumentation.registerInstrumentations({
+                instrumentations: [instrumentation$1],
+                tracerProvider: provider,
+            });
+            this.instrumentations.push(instrumentation$1);
+        }
+        const cohere = this.options.instrumentations?.cohere;
+        if (cohere) {
+            const provider = this.tracerProvider(exports.Instrumentation.Cohere);
+            const instrumentation$1 = new instrumentationCohere.CohereInstrumentation();
+            instrumentation$1.setTracerProvider(provider);
+            instrumentation$1.manuallyInstrument(cohere);
+            instrumentation.registerInstrumentations({
+                instrumentations: [instrumentation$1],
+                tracerProvider: provider,
+            });
+            this.instrumentations.push(instrumentation$1);
+        }
+        const langchain = this.options.instrumentations?.langchain;
+        if (langchain) {
+            const provider = this.tracerProvider(exports.Instrumentation.Langchain);
+            const instrumentation$1 = new instrumentationLangchain.LangChainInstrumentation();
+            instrumentation$1.setTracerProvider(provider);
+            instrumentation$1.manuallyInstrument(langchain);
+            instrumentation.registerInstrumentations({
+                instrumentations: [instrumentation$1],
+                tracerProvider: provider,
+            });
+            this.instrumentations.push(instrumentation$1);
+        }
+        const llamaindex = this.options.instrumentations?.llamaindex;
+        if (llamaindex) {
+            const provider = this.tracerProvider(exports.Instrumentation.LlamaIndex);
+            const instrumentation$1 = new instrumentationLlamaindex.LlamaIndexInstrumentation();
+            instrumentation$1.setTracerProvider(provider);
+            instrumentation$1.manuallyInstrument(llamaindex);
+            instrumentation.registerInstrumentations({
+                instrumentations: [instrumentation$1],
+                tracerProvider: provider,
+            });
+            this.instrumentations.push(instrumentation$1);
+        }
+    }
+    instrument() {
+        this.instrumentations.forEach((instrumentation) => {
+            if (!instrumentation.isEnabled())
+                instrumentation.enable();
+        });
+    }
+    uninstrument() {
+        this.instrumentations.forEach((instrumentation) => {
+            if (instrumentation.isEnabled())
+                instrumentation.disable();
+        });
+    }
+    baggage(ctx) {
+        return this.telemetry.baggage(ctx);
+    }
+    pause(ctx) {
+        return this.telemetry.pause(ctx);
+    }
+    resume(ctx) {
+        return this.telemetry.resume(ctx);
+    }
+    restored(ctx) {
+        return this.telemetry.restored(ctx);
+    }
+    restore(ctx) {
+        return this.telemetry.restore(ctx);
+    }
+    tool(ctx, options) {
+        return this.telemetry.tool(ctx, options);
+    }
+    completion(ctx, options) {
+        return this.telemetry.completion(ctx, options);
+    }
+    embedding(ctx, options) {
+        return this.telemetry.embedding(ctx, options);
+    }
+    retrieval(ctx, options) {
+        return this.telemetry.retrieval(ctx, options);
+    }
+    reranking(ctx, options) {
+        return this.telemetry.reranking(ctx, options);
+    }
+    http(ctx, options) {
+        return this.telemetry.http(ctx, options);
+    }
+    prompt(ctx, options) {
+        return this.telemetry.prompt(ctx, options);
+    }
+    step(ctx, options) {
+        return this.telemetry.step(ctx, options);
     }
 }
-exports.LatitudeExporter = LatitudeExporter;
-exports.LatitudeTelemetrySDK = LatitudeTelemetrySDK;
-exports.VercelBatchSpanProcessor = VercelBatchSpanProcessor;
-exports.VercelSpanProcessor = VercelSpanProcessor;
+exports.BACKGROUND = BACKGROUND;
+exports.DEFAULT_REDACT_SPAN_PROCESSOR = DEFAULT_REDACT_SPAN_PROCESSOR;
+exports.DEFAULT_SPAN_EXPORTER = DEFAULT_SPAN_EXPORTER;
+exports.LatitudeTelemetry = LatitudeTelemetry;
+exports.RedactSpanProcessor = RedactSpanProcessor;
 //# sourceMappingURL=index.cjs.map