@latitude-data/telemetry 1.1.0 → 1.1.1

package/dist/index.cjs

@@ -1,9 +1,9 @@
 '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 semanticConventions = require('@opentelemetry/semantic-conventions');
+var otel = require('@opentelemetry/api');
 var uuid = require('uuid');
 var baggageSpanProcessor = require('@opentelemetry/baggage-span-processor');
 var contextAsyncHooks = require('@opentelemetry/context-async-hooks');
@@ -150,6 +150,15 @@ zod.z.object({
     isError: zod.z.boolean().optional(),
     text: zod.z.string().optional(),
 });
+zod.z.object({
+    inputTokens: zod.z.number(),
+    outputTokens: zod.z.number(),
+    promptTokens: zod.z.number(),
+    completionTokens: zod.z.number(),
+    totalTokens: zod.z.number(),
+    reasoningTokens: zod.z.number(),
+    cachedInputTokens: zod.z.number(),
+});
 
 var ParameterType;
 (function (ParameterType) {
@@ -209,7 +218,6 @@ const compositeEvaluationConfiguration = baseEvaluationConfiguration.extend({
     evaluationUuids: zod.z.array(zod.z.string()),
     minThreshold: zod.z.number().optional(), // Threshold percentage
     maxThreshold: zod.z.number().optional(), // Threshold percentage
-    defaultTarget: zod.z.boolean().optional(), // Default for optimizations and distillations
 });
 const compositeEvaluationResultMetadata = baseEvaluationResultMetadata.extend({
     results: zod.z.record(zod.z.string(), // Evaluation uuid
@@ -276,12 +284,34 @@ const CompositeEvaluationSpecification = {
     },
 };
 
+const selectedContextSchema = zod.z.object({
+    messageIndex: zod.z.number().int().nonnegative(),
+    contentBlockIndex: zod.z.number().int().nonnegative(),
+    contentType: zod.z.enum([
+        'text',
+        'reasoning',
+        'image',
+        'file',
+        'tool-call',
+        'tool-result',
+    ]),
+    textRange: zod.z
+        .object({
+        start: zod.z.number().int().nonnegative(),
+        end: zod.z.number().int().nonnegative(),
+    })
+        .optional(),
+    selectedText: zod.z.string().optional(),
+    toolCallId: zod.z.string().optional(),
+});
 const humanEvaluationConfiguration = baseEvaluationConfiguration.extend({
     enableControls: zod.z.boolean().optional(), // UI annotation controls
     criteria: zod.z.string().optional(),
 });
 const humanEvaluationResultMetadata = baseEvaluationResultMetadata.extend({
     reason: zod.z.string().optional(),
+    enrichedReason: zod.z.string().optional(),
+    selectedContexts: zod.z.array(selectedContextSchema).optional(),
 });
 const humanEvaluationResultError = baseEvaluationResultError.extend({});
 // BINARY
@@ -559,8 +589,6 @@ zod.z.object({
 });
 zod.z.object({
     evaluateLiveLogs: zod.z.boolean().nullable().optional(),
-    enableSuggestions: zod.z.boolean().nullable().optional(),
-    autoApplySuggestions: zod.z.boolean().nullable().optional(),
 });
 
 var LegacyChainEventTypes;
@@ -758,6 +786,7 @@ var LogSources;
     LogSources["ShadowTest"] = "shadow_test";
     LogSources["ABTestChallenger"] = "ab_test_challenger";
     LogSources["User"] = "user";
+    LogSources["Optimization"] = "optimization";
 })(LogSources || (LogSources = {}));
 
 var RunSourceGroup;
@@ -768,7 +797,8 @@ var RunSourceGroup;
 ({
     [RunSourceGroup.Production]: [
         LogSources.API,
-        LogSources.Copilot,
+        LogSources.ShadowTest,
+        LogSources.ABTestChallenger,
         LogSources.EmailTrigger,
         LogSources.IntegrationTrigger,
         LogSources.ScheduledTrigger,
@@ -797,26 +827,49 @@ var 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["Unknown"] = "unknown";
+    // Latitude wrappers
     SpanType["Prompt"] = "prompt";
     SpanType["Chat"] = "chat";
     SpanType["External"] = "external";
     SpanType["UnresolvedExternal"] = "unresolved_external";
-    SpanType["Step"] = "step";
+    // Added a HTTP span to capture raw HTTP requests and responses when running from Latitude
+    SpanType["Http"] = "http";
+    // Any known span from supported specifications will be grouped into one of these types
+    SpanType["Completion"] = "completion";
+    SpanType["Tool"] = "tool";
+    SpanType["Embedding"] = "embedding";
+    SpanType["Unknown"] = "unknown";
 })(SpanType || (SpanType = {}));
+[
+    SpanType.Prompt,
+    SpanType.External,
+    SpanType.Chat,
+];
 const SPAN_SPECIFICATIONS = {
-    [SpanType.Tool]: {
-        name: 'Tool',
-        description: 'A tool call',
-        isGenAI: true,
+    [SpanType.Prompt]: {
+        name: 'Prompt',
+        description: 'A prompt span',
+        isGenAI: false,
+        isHidden: false,
+    },
+    [SpanType.Chat]: {
+        name: 'Chat',
+        description: 'A chat continuation span',
+        isGenAI: false,
         isHidden: false,
     },
+    [SpanType.External]: {
+        name: 'External',
+        description: 'An external capture span',
+        isGenAI: false,
+        isHidden: false,
+    },
+    [SpanType.UnresolvedExternal]: {
+        name: 'Unresolved External',
+        description: 'An external span that needs path resolution before storage',
+        isGenAI: false,
+        isHidden: true,
+    },
     [SpanType.Completion]: {
         name: 'Completion',
         description: 'A completion call',
@@ -829,15 +882,9 @@ const SPAN_SPECIFICATIONS = {
         isGenAI: true,
         isHidden: false,
     },
-    [SpanType.Retrieval]: {
-        name: 'Retrieval',
-        description: 'A retrieval call',
-        isGenAI: true,
-        isHidden: false,
-    },
-    [SpanType.Reranking]: {
-        name: 'Reranking',
-        description: 'A reranking call',
+    [SpanType.Tool]: {
+        name: 'Tool',
+        description: 'A tool call',
         isGenAI: true,
         isHidden: false,
     },
@@ -853,36 +900,6 @@ const SPAN_SPECIFICATIONS = {
         isGenAI: false,
         isHidden: true,
     },
-    [SpanType.Prompt]: {
-        name: 'Prompt',
-        description: 'A prompt span',
-        isGenAI: false,
-        isHidden: false,
-    },
-    [SpanType.Chat]: {
-        name: 'Chat',
-        description: 'A chat continuation span',
-        isGenAI: false,
-        isHidden: false,
-    },
-    [SpanType.External]: {
-        name: 'External',
-        description: 'An external capture span',
-        isGenAI: false,
-        isHidden: false,
-    },
-    [SpanType.UnresolvedExternal]: {
-        name: 'Unresolved External',
-        description: 'An external span that needs path resolution before storage',
-        isGenAI: false,
-        isHidden: true,
-    },
-    [SpanType.Step]: {
-        name: 'Step',
-        description: 'A step span',
-        isGenAI: false,
-        isHidden: false,
-    },
 };
 var SpanStatus;
 (function (SpanStatus) {
@@ -890,6 +907,11 @@ var SpanStatus;
     SpanStatus["Ok"] = "ok";
     SpanStatus["Error"] = "error";
 })(SpanStatus || (SpanStatus = {}));
+new Set([
+    SpanType.Prompt,
+    SpanType.Chat,
+    SpanType.External,
+]);
 
 // 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
@@ -899,6 +921,130 @@ zod.z.object({
     baggage: zod.z.string().optional(), // <key>=urlencoded(<value>)[,<key>=urlencoded(<value>)]*
 });
 
+const ATTRIBUTES = {
+    // Custom attributes added and used by Latitude spans (Prompt / External / Chat)
+    LATITUDE: {
+        type: 'latitude.type',
+        documentUuid: 'latitude.document_uuid',
+        promptPath: 'latitude.prompt_path',
+        commitUuid: 'latitude.commit_uuid',
+        documentLogUuid: 'latitude.document_log_uuid',
+        projectId: 'latitude.project_id',
+        experimentUuid: 'latitude.experiment_uuid',
+        source: 'latitude.source',
+        externalId: 'latitude.external_id',
+        testDeploymentId: 'latitude.test_deployment_id',
+        previousTraceId: 'latitude.previous_trace_id',
+        // Custom additions to the GenAI semantic conventions (deprecated)
+        request: {
+            _root: 'gen_ai.request',
+            configuration: 'gen_ai.request.configuration',
+            template: 'gen_ai.request.template',
+            parameters: 'gen_ai.request.parameters',
+            messages: 'gen_ai.request.messages'},
+        response: {
+            _root: 'gen_ai.response',
+            messages: 'gen_ai.response.messages',
+        },
+        usage: {
+            promptTokens: 'gen_ai.usage.prompt_tokens',
+            cachedTokens: 'gen_ai.usage.cached_tokens',
+            reasoningTokens: 'gen_ai.usage.reasoning_tokens',
+            completionTokens: 'gen_ai.usage.completion_tokens',
+        },
+    },
+    // Official OpenTelemetry semantic conventions
+    OPENTELEMETRY: {
+        HTTP: {
+            request: {
+                url: 'http.request.url',
+                body: 'http.request.body',
+                header: 'http.request.header',
+                method: semanticConventions.ATTR_HTTP_REQUEST_METHOD,
+            },
+            response: {
+                body: 'http.response.body',
+                header: 'http.response.header',
+                statusCode: semanticConventions.ATTR_HTTP_RESPONSE_STATUS_CODE,
+            },
+        },
+        // GenAI semantic conventions
+        // https://opentelemetry.io/docs/specs/semconv/gen-ai/gen-ai-spans/
+        GEN_AI: {
+            operation: incubating.ATTR_GEN_AI_OPERATION_NAME,
+            response: {
+                model: incubating.ATTR_GEN_AI_RESPONSE_MODEL,
+                finishReasons: incubating.ATTR_GEN_AI_RESPONSE_FINISH_REASONS,
+            },
+            usage: {
+                inputTokens: incubating.ATTR_GEN_AI_USAGE_INPUT_TOKENS,
+                outputTokens: incubating.ATTR_GEN_AI_USAGE_OUTPUT_TOKENS,
+            },
+            tool: {
+                call: {
+                    id: incubating.ATTR_GEN_AI_TOOL_CALL_ID,
+                    arguments: 'gen_ai.tool.call.arguments'}},
+            _deprecated: {
+                system: incubating.ATTR_GEN_AI_SYSTEM,
+                tool: {
+                    name: incubating.ATTR_GEN_AI_TOOL_NAME,
+                    type: incubating.ATTR_GEN_AI_TOOL_TYPE,
+                    result: {
+                        value: 'gen_ai.tool.result.value',
+                        isError: 'gen_ai.tool.result.is_error',
+                    },
+                },
+                prompt: {
+                    _root: 'gen_ai.prompt',
+                    index: (promptIndex) => ({
+                        role: `gen_ai.prompt.${promptIndex}.role`,
+                        content: `gen_ai.prompt.${promptIndex}.content`, // string or object
+                        toolCalls: (toolCallIndex) => ({
+                            id: `gen_ai.prompt.${promptIndex}.tool_calls.${toolCallIndex}.id`,
+                            name: `gen_ai.prompt.${promptIndex}.tool_calls.${toolCallIndex}.name`,
+                            arguments: `gen_ai.prompt.${promptIndex}.tool_calls.${toolCallIndex}.arguments`,
+                        }),
+                        tool: {
+                            callId: `gen_ai.prompt.${promptIndex}.tool_call_id`,
+                            toolName: `gen_ai.prompt.${promptIndex}.tool_name`,
+                            isError: `gen_ai.prompt.${promptIndex}.is_error`,
+                        },
+                    }),
+                },
+                completion: {
+                    _root: 'gen_ai.completion',
+                    index: (completionIndex) => ({
+                        role: `gen_ai.completion.${completionIndex}.role`,
+                        content: `gen_ai.completion.${completionIndex}.content`, // string or object
+                        toolCalls: (toolCallIndex) => ({
+                            id: `gen_ai.completion.${completionIndex}.tool_calls.${toolCallIndex}.id`,
+                            name: `gen_ai.completion.${completionIndex}.tool_calls.${toolCallIndex}.name`,
+                            arguments: `gen_ai.completion.${completionIndex}.tool_calls.${toolCallIndex}.arguments`,
+                        }),
+                        tool: {
+                            callId: `gen_ai.prompt.${completionIndex}.tool_call_id`,
+                            toolName: `gen_ai.prompt.${completionIndex}.tool_name`,
+                            isError: `gen_ai.prompt.${completionIndex}.is_error`,
+                        },
+                    }),
+                }},
+        },
+    }};
+const VALUES = {
+    OPENTELEMETRY: {
+        GEN_AI: {
+            response: {
+                finishReasons: {
+                    stop: 'stop',
+                    toolCalls: 'tool_calls'},
+            },
+            tool: {
+                type: {
+                    function: 'function',
+                },
+            }},
+    }};
+
 /* Note: Instrumentation scopes from all language SDKs */
 const SCOPE_LATITUDE = 'so.latitude.instrumentation';
 var InstrumentationScope;
@@ -927,52 +1073,6 @@ var InstrumentationScope;
     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_DOCUMENT_UUID = `${ATTR_LATITUDE}.document_uuid`;
-const ATTR_LATITUDE_PROMPT_PATH = `${ATTR_LATITUDE}.prompt_path`;
-const ATTR_LATITUDE_COMMIT_UUID = `${ATTR_LATITUDE}.commit_uuid`;
-const ATTR_LATITUDE_DOCUMENT_LOG_UUID = `${ATTR_LATITUDE}.document_log_uuid`;
-const ATTR_LATITUDE_PROJECT_ID = `${ATTR_LATITUDE}.project_id`;
-const ATTR_LATITUDE_EXPERIMENT_UUID = `${ATTR_LATITUDE}.experiment_uuid`;
-const ATTR_LATITUDE_SOURCE = `${ATTR_LATITUDE}.source`;
-const ATTR_LATITUDE_EXTERNAL_ID = `${ATTR_LATITUDE}.external_id`;
-const ATTR_LATITUDE_TEST_DEPLOYMENT_ID = `${ATTR_LATITUDE}.test_deployment_id`;
-const ATTR_LATITUDE_PREVIOUS_TRACE_ID = `${ATTR_LATITUDE}.previous_trace_id`;
-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) {
@@ -1053,6 +1153,40 @@ var Otlp;
     });
 })(Otlp || (Otlp = {}));
 
+const MAX_SIMULATION_TURNS = 10;
+const SimulationSettingsSchema = zod.z.object({
+    simulateToolResponses: zod.z.boolean().optional(),
+    simulatedTools: zod.z.array(zod.z.string()).optional(), // Empty array means all tools are simulated (if simulateToolResponses is true).
+    toolSimulationInstructions: zod.z.string().optional(), // A prompt used to guide and generate the simulation result
+    maxTurns: zod.z.number().min(1).max(MAX_SIMULATION_TURNS).optional(), // The maximum number of turns to simulate. Default is 1, and any greater value will add a new user message to the simulated conversation.
+});
+
+var OptimizationEngine;
+(function (OptimizationEngine) {
+    OptimizationEngine["Identity"] = "identity";
+    OptimizationEngine["Gepa"] = "gepa";
+})(OptimizationEngine || (OptimizationEngine = {}));
+const OptimizationBudgetSchema = zod.z.object({
+    time: zod.z.number().min(0).optional(),
+    tokens: zod.z.number().min(0).optional(),
+});
+zod.z.object({
+    parameters: zod.z
+        .record(zod.z.string(), zod.z.object({
+        column: zod.z.string().optional(), // Note: corresponding column in the user-provided trainset and testset
+        isPii: zod.z.boolean().optional(),
+    }))
+        .optional(),
+    simulation: SimulationSettingsSchema.optional(),
+    scope: zod.z
+        .object({
+        configuration: zod.z.boolean().optional(),
+        instructions: zod.z.boolean().optional(),
+    })
+        .optional(),
+    budget: OptimizationBudgetSchema.optional(),
+});
+
 // TODO(tracing): deprecated
 const HEAD_COMMIT = 'live';
 var Providers;
@@ -1198,9 +1332,9 @@ class ManualInstrumentation {
         }
         const span = this.tracer.startSpan(name, {
             attributes: {
-                [ATTR_LATITUDE_TYPE]: type,
+                [ATTRIBUTES.LATITUDE.type]: type,
                 ...(operation && {
-                    [incubating.ATTR_GEN_AI_OPERATION_NAME]: operation,
+                    [ATTRIBUTES.OPENTELEMETRY.GEN_AI.operation]: operation,
                 }),
                 ...(start.attributes || {}),
             },
@@ -1226,15 +1360,15 @@ class ManualInstrumentation {
         try {
             jsonArguments = JSON.stringify(start.call.arguments);
         }
-        catch (error) {
+        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,
+                [ATTRIBUTES.OPENTELEMETRY.GEN_AI._deprecated.tool.name]: start.name,
+                [ATTRIBUTES.OPENTELEMETRY.GEN_AI._deprecated.tool.type]: VALUES.OPENTELEMETRY.GEN_AI.tool.type.function,
+                [ATTRIBUTES.OPENTELEMETRY.GEN_AI.tool.call.id]: start.call.id,
+                [ATTRIBUTES.OPENTELEMETRY.GEN_AI.tool.call.arguments]: jsonArguments,
                 ...(start.attributes || {}),
             },
         });
@@ -1247,7 +1381,7 @@ class ManualInstrumentation {
                     try {
                         stringResult = JSON.stringify(end.result.value);
                     }
-                    catch (error) {
+                    catch (_error) {
                         stringResult = '{}';
                     }
                 }
@@ -1256,8 +1390,8 @@ class ManualInstrumentation {
                 }
                 span.end({
                     attributes: {
-                        [ATTR_GEN_AI_TOOL_RESULT_VALUE]: stringResult,
-                        [ATTR_GEN_AI_TOOL_RESULT_IS_ERROR]: end.result.isError,
+                        [ATTRIBUTES.OPENTELEMETRY.GEN_AI._deprecated.tool.result.value]: stringResult,
+                        [ATTRIBUTES.OPENTELEMETRY.GEN_AI._deprecated.tool.result.isError]: end.result.isError,
                         ...(end.attributes || {}),
                     },
                 });
@@ -1265,12 +1399,12 @@ class ManualInstrumentation {
             fail: span.fail,
         };
     }
-    attribifyMessageToolCalls(prefix, toolCalls) {
+    attribifyMessageToolCalls(otelMessageField, 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];
+                const value = toolCalls[i][key];
                 if (value === null || value === undefined)
                     continue;
                 switch (field) {
@@ -1279,28 +1413,29 @@ class ManualInstrumentation {
                     case 'toolUseId': {
                         if (typeof value !== 'string')
                             continue;
-                        attributes[`${prefix}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS}.${i}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS_ID}`] = value;
+                        attributes[otelMessageField.toolCalls(i).id] = value;
                         break;
                     }
                     case 'name':
                     case 'toolName': {
                         if (typeof value !== 'string')
                             continue;
-                        attributes[`${prefix}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS}.${i}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS_NAME}`] = value;
+                        attributes[otelMessageField.toolCalls(i).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;
+                            attributes[otelMessageField.toolCalls(i).arguments] = value;
                         }
                         else {
                             try {
-                                attributes[`${prefix}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS}.${i}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS_ARGUMENTS}`] = JSON.stringify(value);
+                                attributes[otelMessageField.toolCalls(i).arguments] =
+                                    JSON.stringify(value);
                             }
-                            catch (error) {
-                                attributes[`${prefix}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS}.${i}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS_ARGUMENTS}`] = '{}';
+                            catch (_error) {
+                                attributes[otelMessageField.toolCalls(i).arguments] = '{}';
                             }
                         }
                         break;
@@ -1317,8 +1452,9 @@ class ManualInstrumentation {
                             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;
+                        attributes[otelMessageField.toolCalls(i).name] = value.name;
+                        attributes[otelMessageField.toolCalls(i).arguments] =
+                            value.arguments;
                         break;
                     }
                 }
@@ -1326,18 +1462,16 @@ class ManualInstrumentation {
         }
         return attributes;
     }
-    attribifyMessageContent(prefix, content) {
+    attribifyMessageContent(otelMessageField, 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);
+            attributes[otelMessageField.content] = JSON.stringify(content);
         }
-        catch (error) {
-            attributes[`${prefix}.${ATTR_GEN_AI_MESSAGE_CONTENT}`] = '[]';
+        catch (_error) {
+            attributes[otelMessageField.content] = '[]';
         }
         if (!Array.isArray(content))
             return attributes;
@@ -1357,32 +1491,34 @@ class ManualInstrumentation {
         if (toolCalls.length > 0) {
             attributes = {
                 ...attributes,
-                ...this.attribifyMessageToolCalls(prefix, toolCalls),
+                ...this.attribifyMessageToolCalls(otelMessageField, toolCalls),
             };
         }
         return attributes;
     }
     attribifyMessages(direction, messages) {
-        const prefix = direction === 'input' ? ATTR_GEN_AI_PROMPTS : ATTR_GEN_AI_COMPLETIONS;
+        const otelField = direction === 'input'
+            ? ATTRIBUTES.OPENTELEMETRY.GEN_AI._deprecated.prompt
+            : ATTRIBUTES.OPENTELEMETRY.GEN_AI._deprecated.completion;
         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];
+                const 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;
+                        attributes[otelField.index(i).role] = value;
                         break;
                     }
                     /* Tool calls for Anthropic and PromptL are in the content */
                     case 'content': {
                         attributes = {
                             ...attributes,
-                            ...this.attribifyMessageContent(`${prefix}.${i}`, value),
+                            ...this.attribifyMessageContent(otelField.index(i), value),
                         };
                         break;
                     }
@@ -1392,7 +1528,7 @@ class ManualInstrumentation {
                             continue;
                         attributes = {
                             ...attributes,
-                            ...this.attribifyMessageToolCalls(`${prefix}.${i}`, value),
+                            ...this.attribifyMessageToolCalls(otelField.index(i), value),
                         };
                         break;
                     }
@@ -1402,22 +1538,20 @@ class ManualInstrumentation {
                     case 'toolUseId': {
                         if (typeof value !== 'string')
                             continue;
-                        attributes[`${prefix}.${i}.${ATTR_GEN_AI_MESSAGE_TOOL_CALL_ID}`] =
-                            value;
+                        attributes[otelField.index(i).tool.callId] = value;
                         break;
                     }
                     case 'toolName': {
                         if (typeof value !== 'string')
                             continue;
-                        attributes[`${prefix}.${i}.${ATTR_GEN_AI_MESSAGE_TOOL_NAME}`] =
-                            value;
+                        attributes[otelField.index(i).tool.toolName] = 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;
+                        attributes[otelField.index(i).tool.isError] = value;
                         break;
                     }
                 }
@@ -1426,7 +1560,9 @@ class ManualInstrumentation {
         return attributes;
     }
     attribifyConfiguration(direction, configuration) {
-        const prefix = direction === 'input' ? ATTR_GEN_AI_REQUEST : ATTR_GEN_AI_RESPONSE;
+        const prefix = direction === 'input'
+            ? ATTRIBUTES.LATITUDE.request._root
+            : ATTRIBUTES.LATITUDE.response._root;
         const attributes = {};
         for (const key in configuration) {
             const field = this.toSnakeCase(key);
@@ -1437,7 +1573,7 @@ class ManualInstrumentation {
                 try {
                     value = JSON.stringify(value);
                 }
-                catch (error) {
+                catch (_error) {
                     value = '{}';
                 }
             }
@@ -1455,7 +1591,7 @@ class ManualInstrumentation {
         try {
             jsonConfiguration = JSON.stringify(configuration);
         }
-        catch (error) {
+        catch (_error) {
             jsonConfiguration = '{}';
         }
         const attrConfiguration = this.attribifyConfiguration('input', configuration);
@@ -1464,21 +1600,21 @@ class ManualInstrumentation {
         try {
             jsonInput = JSON.stringify(input);
         }
-        catch (error) {
+        catch (_error) {
             jsonInput = '[]';
         }
         const attrInput = this.attribifyMessages('input', 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,
+                [ATTRIBUTES.OPENTELEMETRY.GEN_AI._deprecated.system]: start.provider,
+                [ATTRIBUTES.LATITUDE.request.configuration]: jsonConfiguration,
                 ...attrConfiguration,
-                [ATTR_GEN_AI_REQUEST_MESSAGES]: jsonInput,
+                [ATTRIBUTES.LATITUDE.request.messages]: jsonInput,
                 ...attrInput,
                 ...(start.attributes || {}),
-                [ATTR_LATITUDE_COMMIT_UUID]: start.versionUuid,
-                [ATTR_LATITUDE_DOCUMENT_UUID]: start.promptUuid,
-                [ATTR_LATITUDE_EXPERIMENT_UUID]: start.experimentUuid,
+                [ATTRIBUTES.LATITUDE.commitUuid]: start.versionUuid,
+                [ATTRIBUTES.LATITUDE.documentUuid]: start.promptUuid,
+                [ATTRIBUTES.LATITUDE.experimentUuid]: start.experimentUuid,
             },
         });
         return {
@@ -1490,7 +1626,7 @@ class ManualInstrumentation {
                 try {
                     jsonOutput = JSON.stringify(output);
                 }
-                catch (error) {
+                catch (_error) {
                     jsonOutput = '[]';
                 }
                 const attrOutput = this.attribifyMessages('output', output);
@@ -1505,16 +1641,18 @@ class ManualInstrumentation {
                 const finishReason = end.finishReason ?? '';
                 span.end({
                     attributes: {
-                        [ATTR_GEN_AI_RESPONSE_MESSAGES]: jsonOutput,
+                        [ATTRIBUTES.LATITUDE.response.messages]: jsonOutput,
                         ...attrOutput,
-                        [incubating.ATTR_GEN_AI_USAGE_INPUT_TOKENS]: inputTokens,
-                        [ATTR_GEN_AI_USAGE_PROMPT_TOKENS]: tokens.prompt,
-                        [ATTR_GEN_AI_USAGE_CACHED_TOKENS]: tokens.cached,
-                        [ATTR_GEN_AI_USAGE_REASONING_TOKENS]: tokens.reasoning,
-                        [ATTR_GEN_AI_USAGE_COMPLETION_TOKENS]: 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]: [finishReason],
+                        [ATTRIBUTES.OPENTELEMETRY.GEN_AI.usage.inputTokens]: inputTokens,
+                        [ATTRIBUTES.OPENTELEMETRY.GEN_AI.usage.outputTokens]: outputTokens,
+                        [ATTRIBUTES.LATITUDE.usage.promptTokens]: tokens.prompt,
+                        [ATTRIBUTES.LATITUDE.usage.cachedTokens]: tokens.cached,
+                        [ATTRIBUTES.LATITUDE.usage.reasoningTokens]: tokens.reasoning,
+                        [ATTRIBUTES.LATITUDE.usage.completionTokens]: tokens.completion,
+                        [ATTRIBUTES.OPENTELEMETRY.GEN_AI.response.model]: start.model,
+                        [ATTRIBUTES.OPENTELEMETRY.GEN_AI.response.finishReasons]: [
+                            finishReason,
+                        ],
                         ...(end.attributes || {}),
                     },
                 });
@@ -1525,16 +1663,10 @@ class ManualInstrumentation {
     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;
+            ? ATTRIBUTES.OPENTELEMETRY.HTTP.request.header
+            : ATTRIBUTES.OPENTELEMETRY.HTTP.response.header;
         const attributes = {};
         for (const key in headers) {
             const field = this.toKebabCase(key);
@@ -1558,16 +1690,16 @@ class ManualInstrumentation {
             try {
                 finalBody = JSON.stringify(start.request.body);
             }
-            catch (error) {
+            catch (_error) {
                 finalBody = '{}';
             }
         }
         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,
+                [ATTRIBUTES.OPENTELEMETRY.HTTP.request.method]: method,
+                [ATTRIBUTES.OPENTELEMETRY.HTTP.request.url]: start.request.url,
                 ...attrHeaders,
-                [ATTR_HTTP_REQUEST_BODY]: finalBody,
+                [ATTRIBUTES.OPENTELEMETRY.HTTP.request.body]: finalBody,
                 ...(start.attributes || {}),
             },
         });
@@ -1585,15 +1717,15 @@ class ManualInstrumentation {
                     try {
                         finalBody = JSON.stringify(end.response.body);
                     }
-                    catch (error) {
+                    catch (_error) {
                         finalBody = '{}';
                     }
                 }
                 span.end({
                     attributes: {
-                        [semanticConventions.ATTR_HTTP_RESPONSE_STATUS_CODE]: end.response.status,
+                        [ATTRIBUTES.OPENTELEMETRY.HTTP.response.statusCode]: end.response.status,
                         ...attrHeaders,
-                        [ATTR_HTTP_RESPONSE_BODY]: finalBody,
+                        [ATTRIBUTES.OPENTELEMETRY.HTTP.response.body]: finalBody,
                         ...(end.attributes || {}),
                     },
                 });
@@ -1606,49 +1738,48 @@ class ManualInstrumentation {
         try {
             jsonParameters = JSON.stringify(parameters || {});
         }
-        catch (error) {
+        catch (_error) {
             jsonParameters = '{}';
         }
         const attributes = {
-            [ATTR_GEN_AI_REQUEST_TEMPLATE]: template,
-            [ATTR_GEN_AI_REQUEST_PARAMETERS]: jsonParameters,
-            [ATTR_LATITUDE_COMMIT_UUID]: versionUuid || HEAD_COMMIT,
-            [ATTR_LATITUDE_DOCUMENT_UUID]: promptUuid,
-            [ATTR_LATITUDE_PROJECT_ID]: projectId,
-            [ATTR_LATITUDE_DOCUMENT_LOG_UUID]: documentLogUuid,
+            [ATTRIBUTES.LATITUDE.request.template]: template,
+            [ATTRIBUTES.LATITUDE.request.parameters]: jsonParameters,
+            [ATTRIBUTES.LATITUDE.commitUuid]: versionUuid || HEAD_COMMIT,
+            [ATTRIBUTES.LATITUDE.documentUuid]: promptUuid,
+            [ATTRIBUTES.LATITUDE.projectId]: projectId,
+            [ATTRIBUTES.LATITUDE.documentLogUuid]: documentLogUuid,
             ...(experimentUuid && {
-                [ATTR_LATITUDE_EXPERIMENT_UUID]: experimentUuid,
+                [ATTRIBUTES.LATITUDE.experimentUuid]: experimentUuid,
             }),
             ...(testDeploymentId && {
-                [ATTR_LATITUDE_TEST_DEPLOYMENT_ID]: testDeploymentId,
+                [ATTRIBUTES.LATITUDE.testDeploymentId]: testDeploymentId,
             }),
-            ...(externalId && { [ATTR_LATITUDE_EXTERNAL_ID]: externalId }),
-            ...(source && { [ATTR_LATITUDE_SOURCE]: source }),
+            ...(externalId && { [ATTRIBUTES.LATITUDE.externalId]: externalId }),
+            ...(source && { [ATTRIBUTES.LATITUDE.source]: source }),
             ...(rest.attributes || {}),
         };
         return this.span(ctx, name || `prompt-${promptUuid}`, SpanType.Prompt, {
             attributes,
         });
     }
-    step(ctx, options) {
-        return this.span(ctx, 'step', SpanType.Step, options);
-    }
-    chat(ctx, { documentLogUuid, previousTraceId, source, name, ...rest }) {
+    chat(ctx, { documentLogUuid, previousTraceId, source, name, versionUuid, promptUuid, ...rest }) {
         const attributes = {
-            [ATTR_LATITUDE_DOCUMENT_LOG_UUID]: documentLogUuid,
-            [ATTR_LATITUDE_PREVIOUS_TRACE_ID]: previousTraceId,
-            ...(source && { [ATTR_LATITUDE_SOURCE]: source }),
+            [ATTRIBUTES.LATITUDE.documentLogUuid]: documentLogUuid,
+            [ATTRIBUTES.LATITUDE.previousTraceId]: previousTraceId,
+            ...(versionUuid && { [ATTRIBUTES.LATITUDE.commitUuid]: versionUuid }),
+            ...(promptUuid && { [ATTRIBUTES.LATITUDE.documentUuid]: promptUuid }),
+            ...(source && { [ATTRIBUTES.LATITUDE.source]: source }),
             ...(rest.attributes || {}),
         };
         return this.span(ctx, name || 'chat', SpanType.Chat, { attributes });
     }
     external(ctx, { promptUuid, documentLogUuid, source, versionUuid, externalId, name, ...rest }) {
         const attributes = {
-            [ATTR_LATITUDE_DOCUMENT_UUID]: promptUuid,
-            [ATTR_LATITUDE_DOCUMENT_LOG_UUID]: documentLogUuid,
-            [ATTR_LATITUDE_SOURCE]: source ?? LogSources.API,
-            ...(versionUuid && { [ATTR_LATITUDE_COMMIT_UUID]: versionUuid }),
-            ...(externalId && { [ATTR_LATITUDE_EXTERNAL_ID]: externalId }),
+            [ATTRIBUTES.LATITUDE.documentUuid]: promptUuid,
+            [ATTRIBUTES.LATITUDE.documentLogUuid]: documentLogUuid,
+            [ATTRIBUTES.LATITUDE.source]: source ?? LogSources.API,
+            ...(versionUuid && { [ATTRIBUTES.LATITUDE.commitUuid]: versionUuid }),
+            ...(externalId && { [ATTRIBUTES.LATITUDE.externalId]: externalId }),
             ...(rest.attributes || {}),
         };
         return this.span(ctx, name || `external-${promptUuid}`, SpanType.External, {
@@ -1657,11 +1788,11 @@ class ManualInstrumentation {
     }
     unresolvedExternal(ctx, { path, projectId, versionUuid, conversationUuid, name, ...rest }) {
         const attributes = {
-            [ATTR_LATITUDE_PROMPT_PATH]: path,
-            [ATTR_LATITUDE_PROJECT_ID]: projectId,
-            ...(versionUuid && { [ATTR_LATITUDE_COMMIT_UUID]: versionUuid }),
+            [ATTRIBUTES.LATITUDE.promptPath]: path,
+            [ATTRIBUTES.LATITUDE.projectId]: projectId,
+            ...(versionUuid && { [ATTRIBUTES.LATITUDE.commitUuid]: versionUuid }),
             ...(conversationUuid && {
-                [ATTR_LATITUDE_DOCUMENT_LOG_UUID]: conversationUuid,
+                [ATTRIBUTES.LATITUDE.documentLogUuid]: conversationUuid,
             }),
             ...(rest.attributes || {}),
         };
@@ -1726,19 +1857,6 @@ class LatitudeInstrumentation {
         $prompt.end();
         return result;
     }
-    async wrapRenderStep(fn, ...args) {
-        const $step = this.manualTelemetry.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);
@@ -1772,8 +1890,8 @@ class LatitudeInstrumentation {
                 completion: completionTokens,
             },
             finishReason: result.toolRequests.length > 0
-                ? GEN_AI_RESPONSE_FINISH_REASON_VALUE_TOOL_CALLS
-                : GEN_AI_RESPONSE_FINISH_REASON_VALUE_STOP,
+                ? VALUES.OPENTELEMETRY.GEN_AI.response.finishReasons.toolCalls
+                : VALUES.OPENTELEMETRY.GEN_AI.response.finishReasons.stop,
         });
         return result;
     }
@@ -1818,6 +1936,7 @@ var LatitudeErrorCodes;
     LatitudeErrorCodes["NotImplementedError"] = "NotImplementedError";
     LatitudeErrorCodes["PaymentRequiredError"] = "PaymentRequiredError";
     LatitudeErrorCodes["AbortedError"] = "AbortedError";
+    LatitudeErrorCodes["BillingError"] = "BillingError";
 })(LatitudeErrorCodes || (LatitudeErrorCodes = {}));
 // NOTE: If you add a new error code, please add it to the pg enum in models/runErrors.ts
 var RunErrorCodes;
@@ -1897,21 +2016,12 @@ class SpanFactory {
     embedding(options, ctx) {
         return this.telemetry.embedding(ctx ?? otel.context.active(), options);
     }
-    retrieval(options, ctx) {
-        return this.telemetry.retrieval(ctx ?? otel.context.active(), options);
-    }
-    reranking(options, ctx) {
-        return this.telemetry.reranking(ctx ?? otel.context.active(), options);
-    }
     http(options, ctx) {
         return this.telemetry.http(ctx ?? otel.context.active(), options);
     }
     prompt(options, ctx) {
         return this.telemetry.prompt(ctx ?? otel.context.active(), options);
     }
-    step(options, ctx) {
-        return this.telemetry.step(ctx ?? otel.context.active(), options);
-    }
     chat(options, ctx) {
         return this.telemetry.chat(ctx ?? otel.context.active(), options);
     }
@@ -2092,8 +2202,9 @@ class LatitudeTelemetry {
         configureInstrumentation(exports.Instrumentation.Cohere, instrumentationCohere.CohereInstrumentation); // prettier-ignore
         configureInstrumentation(exports.Instrumentation.Langchain, instrumentationLangchain.LangChainInstrumentation); // prettier-ignore
         configureInstrumentation(exports.Instrumentation.LlamaIndex, instrumentationLlamaindex.LlamaIndexInstrumentation); // prettier-ignore
-        configureInstrumentation(exports.Instrumentation.OpenAI, instrumentationOpenai.OpenAIInstrumentation, { enrichTokens: true }); // prettier-ignore
-        configureInstrumentation(exports.Instrumentation.TogetherAI, instrumentationTogether.TogetherInstrumentation, { enrichTokens: true }); // prettier-ignore
+        // NOTE: `stream: true` in OpenAI make enrichTokens fail, so disabling.
+        configureInstrumentation(exports.Instrumentation.OpenAI, instrumentationOpenai.OpenAIInstrumentation, { enrichTokens: false }); // prettier-ignore
+        configureInstrumentation(exports.Instrumentation.TogetherAI, instrumentationTogether.TogetherInstrumentation, { enrichTokens: false }); // prettier-ignore
         configureInstrumentation(exports.Instrumentation.VertexAI, instrumentationVertexai.VertexAIInstrumentation); // prettier-ignore
     }
     async capture(options, fn) {