@latitude-data/telemetry 0.0.4 → 1.0.1

package/dist/index.cjs

@@ -1,487 +1,2053 @@
 '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',
+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 SEGMENT_SPECIFICATIONS = {
+    [SegmentType.Document]: {
+        name: 'Prompt',
+        description: 'A prompt',
+    },
+    [SegmentType.Step]: {
+        name: 'Step',
+        description: 'A step in a prompt',
+    },
 };
-const AIResultPostfixes = {
-    text: 'text',
-    toolCalls: 'toolCalls',
-    object: 'object',
+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 SPAN_SPECIFICATIONS = {
+    [SpanType.Tool]: {
+        name: 'Tool',
+        description: 'A tool call',
+        isGenAI: true,
+        isHidden: false,
+    },
+    [SpanType.Completion]: {
+        name: 'Completion',
+        description: 'A completion call',
+        isGenAI: true,
+        isHidden: false,
+    },
+    [SpanType.Embedding]: {
+        name: 'Embedding',
+        description: 'An embedding call',
+        isGenAI: true,
+        isHidden: false,
+    },
+    [SpanType.Retrieval]: {
+        name: 'Retrieval',
+        description: 'A retrieval call',
+        isGenAI: true,
+        isHidden: false,
+    },
+    [SpanType.Reranking]: {
+        name: 'Reranking',
+        description: 'A reranking call',
+        isGenAI: true,
+        isHidden: false,
+    },
+    [SpanType.Http]: {
+        name: 'HTTP',
+        description: 'An HTTP request',
+        isGenAI: false,
+        isHidden: true,
+    },
+    [SpanType.Segment]: {
+        name: 'Segment',
+        description: 'A (partial) segment of a trace',
+        isGenAI: false,
+        isHidden: true,
+    },
+    [SpanType.Unknown]: {
+        name: 'Unknown',
+        description: 'An unknown span',
+        isGenAI: false,
+        isHidden: true,
+    },
 };
-const AIPromptPostfixes = {
-    messages: 'messages',
+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_HEADER = 'http.request.header';
+const ATTR_HTTP_RESPONSE_BODY = 'http.response.body';
+const ATTR_HTTP_RESPONSE_HEADER = '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(),
+    });
+    (function (StatusCode) {
+        StatusCode[StatusCode["Unset"] = 0] = "Unset";
+        StatusCode[StatusCode["Ok"] = 1] = "Ok";
+        StatusCode[StatusCode["Error"] = 2] = "Error";
+    })(Otlp.StatusCode || (Otlp.StatusCode = {}));
+    Otlp.statusSchema = zod.z.object({
+        code: zod.z.number(),
+        message: zod.z.string().optional(),
+    });
+    (function (SpanKind) {
+        SpanKind[SpanKind["Internal"] = 0] = "Internal";
+        SpanKind[SpanKind["Server"] = 1] = "Server";
+        SpanKind[SpanKind["Client"] = 2] = "Client";
+        SpanKind[SpanKind["Producer"] = 3] = "Producer";
+        SpanKind[SpanKind["Consumer"] = 4] = "Consumer";
+    })(Otlp.SpanKind || (Otlp.SpanKind = {}));
+    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 FinishReason;
+(function (FinishReason) {
+    FinishReason["Stop"] = "stop";
+    FinishReason["Length"] = "length";
+    FinishReason["ContentFilter"] = "content-filter";
+    FinishReason["ToolCalls"] = "tool-calls";
+    FinishReason["Error"] = "error";
+    FinishReason["Other"] = "other";
+    FinishReason["Unknown"] = "unknown";
+})(FinishReason || (FinishReason = {}));
+
+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["Pipedream"] = "pipedream";
+})(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 (SPAN_SPECIFICATIONS[type].isGenAI) {
+            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;
                     }
-                    catch (e) {
-                        console.error('Latitude: Could not serialize latitude.metadata attribute', e);
+                    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;
+                    }
+                    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 || SPAN_SPECIFICATIONS[SpanType.Embedding].name, SpanType.Embedding, options);
+    }
+    retrieval(ctx, options) {
+        return this.span(ctx, options?.name || SPAN_SPECIFICATIONS[SpanType.Retrieval].name, SpanType.Retrieval, options);
+    }
+    reranking(ctx, options) {
+        return this.span(ctx, options?.name || SPAN_SPECIFICATIONS[SpanType.Reranking].name, SpanType.Reranking, options);
+    }
+    attribifyHeaders(direction, headers) {
+        const prefix = direction === 'request'
+            ? ATTR_HTTP_REQUEST_HEADER
+            : ATTR_HTTP_RESPONSE_HEADER;
+        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();
+        // Note: do not serialize headers as a single attribute because fields won't be redacted
+        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;
+                // Note: do not serialize headers as a single attribute because fields won't be redacted
+                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, SEGMENT_SPECIFICATIONS[type].name, 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;
+            }
+            else if (Array.isArray(message.content)) {
+                for (const content of message.content) {
+                    if (content.type === 'text') {
+                        length += content.text.length;
+                    }
+                }
             }
-            span.end();
-            return res;
+        }
+        // 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/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