@latitude-data/telemetry 1.1.0 → 1.1.1

package/dist/index.js

@@ -1,8 +1,8 @@
 import { z } from 'zod';
+import { ATTR_GEN_AI_OPERATION_NAME, ATTR_GEN_AI_TOOL_CALL_ID, ATTR_GEN_AI_TOOL_TYPE, ATTR_GEN_AI_TOOL_NAME, ATTR_GEN_AI_SYSTEM, ATTR_GEN_AI_RESPONSE_FINISH_REASONS, ATTR_GEN_AI_RESPONSE_MODEL, ATTR_GEN_AI_USAGE_OUTPUT_TOKENS, ATTR_GEN_AI_USAGE_INPUT_TOKENS } from '@opentelemetry/semantic-conventions/incubating';
+import { ATTR_HTTP_REQUEST_METHOD, ATTR_HTTP_RESPONSE_STATUS_CODE, ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
 import * as otel from '@opentelemetry/api';
 import { trace, propagation, context } from '@opentelemetry/api';
-import { ATTR_HTTP_REQUEST_METHOD, ATTR_HTTP_RESPONSE_STATUS_CODE, ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
-import { ATTR_GEN_AI_OPERATION_NAME, ATTR_GEN_AI_TOOL_CALL_ID, ATTR_GEN_AI_TOOL_TYPE, ATTR_GEN_AI_TOOL_NAME, ATTR_GEN_AI_SYSTEM, ATTR_GEN_AI_RESPONSE_FINISH_REASONS, ATTR_GEN_AI_RESPONSE_MODEL, ATTR_GEN_AI_USAGE_OUTPUT_TOKENS, ATTR_GEN_AI_USAGE_INPUT_TOKENS } from '@opentelemetry/semantic-conventions/incubating';
 import { v4 } from 'uuid';
 import { BaggageSpanProcessor, ALLOW_ALL_BAGGAGE_KEYS } from '@opentelemetry/baggage-span-processor';
 import { AsyncLocalStorageContextManager } from '@opentelemetry/context-async-hooks';
@@ -130,6 +130,15 @@ z.object({
     isError: z.boolean().optional(),
     text: z.string().optional(),
 });
+z.object({
+    inputTokens: z.number(),
+    outputTokens: z.number(),
+    promptTokens: z.number(),
+    completionTokens: z.number(),
+    totalTokens: z.number(),
+    reasoningTokens: z.number(),
+    cachedInputTokens: z.number(),
+});
 
 var ParameterType;
 (function (ParameterType) {
@@ -189,7 +198,6 @@ const compositeEvaluationConfiguration = baseEvaluationConfiguration.extend({
     evaluationUuids: z.array(z.string()),
     minThreshold: z.number().optional(), // Threshold percentage
     maxThreshold: z.number().optional(), // Threshold percentage
-    defaultTarget: z.boolean().optional(), // Default for optimizations and distillations
 });
 const compositeEvaluationResultMetadata = baseEvaluationResultMetadata.extend({
     results: z.record(z.string(), // Evaluation uuid
@@ -256,12 +264,34 @@ const CompositeEvaluationSpecification = {
     },
 };
 
+const selectedContextSchema = z.object({
+    messageIndex: z.number().int().nonnegative(),
+    contentBlockIndex: z.number().int().nonnegative(),
+    contentType: z.enum([
+        'text',
+        'reasoning',
+        'image',
+        'file',
+        'tool-call',
+        'tool-result',
+    ]),
+    textRange: z
+        .object({
+        start: z.number().int().nonnegative(),
+        end: z.number().int().nonnegative(),
+    })
+        .optional(),
+    selectedText: z.string().optional(),
+    toolCallId: z.string().optional(),
+});
 const humanEvaluationConfiguration = baseEvaluationConfiguration.extend({
     enableControls: z.boolean().optional(), // UI annotation controls
     criteria: z.string().optional(),
 });
 const humanEvaluationResultMetadata = baseEvaluationResultMetadata.extend({
     reason: z.string().optional(),
+    enrichedReason: z.string().optional(),
+    selectedContexts: z.array(selectedContextSchema).optional(),
 });
 const humanEvaluationResultError = baseEvaluationResultError.extend({});
 // BINARY
@@ -539,8 +569,6 @@ z.object({
 });
 z.object({
     evaluateLiveLogs: z.boolean().nullable().optional(),
-    enableSuggestions: z.boolean().nullable().optional(),
-    autoApplySuggestions: z.boolean().nullable().optional(),
 });
 
 var LegacyChainEventTypes;
@@ -738,6 +766,7 @@ var LogSources;
     LogSources["ShadowTest"] = "shadow_test";
     LogSources["ABTestChallenger"] = "ab_test_challenger";
     LogSources["User"] = "user";
+    LogSources["Optimization"] = "optimization";
 })(LogSources || (LogSources = {}));
 
 var RunSourceGroup;
@@ -748,7 +777,8 @@ var RunSourceGroup;
 ({
     [RunSourceGroup.Production]: [
         LogSources.API,
-        LogSources.Copilot,
+        LogSources.ShadowTest,
+        LogSources.ABTestChallenger,
         LogSources.EmailTrigger,
         LogSources.IntegrationTrigger,
         LogSources.ScheduledTrigger,
@@ -777,26 +807,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',
@@ -809,15 +862,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,
     },
@@ -833,36 +880,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) {
@@ -870,6 +887,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
@@ -879,6 +901,130 @@ z.object({
     baggage: 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: ATTR_HTTP_REQUEST_METHOD,
+            },
+            response: {
+                body: 'http.response.body',
+                header: 'http.response.header',
+                statusCode: ATTR_HTTP_RESPONSE_STATUS_CODE,
+            },
+        },
+        // GenAI semantic conventions
+        // https://opentelemetry.io/docs/specs/semconv/gen-ai/gen-ai-spans/
+        GEN_AI: {
+            operation: ATTR_GEN_AI_OPERATION_NAME,
+            response: {
+                model: ATTR_GEN_AI_RESPONSE_MODEL,
+                finishReasons: ATTR_GEN_AI_RESPONSE_FINISH_REASONS,
+            },
+            usage: {
+                inputTokens: ATTR_GEN_AI_USAGE_INPUT_TOKENS,
+                outputTokens: ATTR_GEN_AI_USAGE_OUTPUT_TOKENS,
+            },
+            tool: {
+                call: {
+                    id: ATTR_GEN_AI_TOOL_CALL_ID,
+                    arguments: 'gen_ai.tool.call.arguments'}},
+            _deprecated: {
+                system: ATTR_GEN_AI_SYSTEM,
+                tool: {
+                    name: ATTR_GEN_AI_TOOL_NAME,
+                    type: 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;
@@ -907,52 +1053,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) {
@@ -1033,6 +1133,40 @@ var Otlp;
     });
 })(Otlp || (Otlp = {}));
 
+const MAX_SIMULATION_TURNS = 10;
+const SimulationSettingsSchema = z.object({
+    simulateToolResponses: z.boolean().optional(),
+    simulatedTools: z.array(z.string()).optional(), // Empty array means all tools are simulated (if simulateToolResponses is true).
+    toolSimulationInstructions: z.string().optional(), // A prompt used to guide and generate the simulation result
+    maxTurns: 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 = z.object({
+    time: z.number().min(0).optional(),
+    tokens: z.number().min(0).optional(),
+});
+z.object({
+    parameters: z
+        .record(z.string(), z.object({
+        column: z.string().optional(), // Note: corresponding column in the user-provided trainset and testset
+        isPii: z.boolean().optional(),
+    }))
+        .optional(),
+    simulation: SimulationSettingsSchema.optional(),
+    scope: z
+        .object({
+        configuration: z.boolean().optional(),
+        instructions: z.boolean().optional(),
+    })
+        .optional(),
+    budget: OptimizationBudgetSchema.optional(),
+});
+
 // TODO(tracing): deprecated
 const HEAD_COMMIT = 'live';
 var Providers;
@@ -1178,9 +1312,9 @@ class ManualInstrumentation {
         }
         const span = this.tracer.startSpan(name, {
             attributes: {
-                [ATTR_LATITUDE_TYPE]: type,
+                [ATTRIBUTES.LATITUDE.type]: type,
                 ...(operation && {
-                    [ATTR_GEN_AI_OPERATION_NAME]: operation,
+                    [ATTRIBUTES.OPENTELEMETRY.GEN_AI.operation]: operation,
                 }),
                 ...(start.attributes || {}),
             },
@@ -1206,15 +1340,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: {
-                [ATTR_GEN_AI_TOOL_NAME]: start.name,
-                [ATTR_GEN_AI_TOOL_TYPE]: GEN_AI_TOOL_TYPE_VALUE_FUNCTION,
-                [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 || {}),
             },
         });
@@ -1227,7 +1361,7 @@ class ManualInstrumentation {
                     try {
                         stringResult = JSON.stringify(end.result.value);
                     }
-                    catch (error) {
+                    catch (_error) {
                         stringResult = '{}';
                     }
                 }
@@ -1236,8 +1370,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 || {}),
                     },
                 });
@@ -1245,12 +1379,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) {
@@ -1259,28 +1393,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;
@@ -1297,8 +1432,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;
                     }
                 }
@@ -1306,18 +1442,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;
@@ -1337,32 +1471,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;
                     }
@@ -1372,7 +1508,7 @@ class ManualInstrumentation {
                             continue;
                         attributes = {
                             ...attributes,
-                            ...this.attribifyMessageToolCalls(`${prefix}.${i}`, value),
+                            ...this.attribifyMessageToolCalls(otelField.index(i), value),
                         };
                         break;
                     }
@@ -1382,22 +1518,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;
                     }
                 }
@@ -1406,7 +1540,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);
@@ -1417,7 +1553,7 @@ class ManualInstrumentation {
                 try {
                     value = JSON.stringify(value);
                 }
-                catch (error) {
+                catch (_error) {
                     value = '{}';
                 }
             }
@@ -1435,7 +1571,7 @@ class ManualInstrumentation {
         try {
             jsonConfiguration = JSON.stringify(configuration);
         }
-        catch (error) {
+        catch (_error) {
             jsonConfiguration = '{}';
         }
         const attrConfiguration = this.attribifyConfiguration('input', configuration);
@@ -1444,21 +1580,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: {
-                [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 {
@@ -1470,7 +1606,7 @@ class ManualInstrumentation {
                 try {
                     jsonOutput = JSON.stringify(output);
                 }
-                catch (error) {
+                catch (_error) {
                     jsonOutput = '[]';
                 }
                 const attrOutput = this.attribifyMessages('output', output);
@@ -1485,16 +1621,18 @@ class ManualInstrumentation {
                 const finishReason = end.finishReason ?? '';
                 span.end({
                     attributes: {
-                        [ATTR_GEN_AI_RESPONSE_MESSAGES]: jsonOutput,
+                        [ATTRIBUTES.LATITUDE.response.messages]: jsonOutput,
                         ...attrOutput,
-                        [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,
-                        [ATTR_GEN_AI_USAGE_OUTPUT_TOKENS]: outputTokens,
-                        [ATTR_GEN_AI_RESPONSE_MODEL]: start.model,
-                        [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 || {}),
                     },
                 });
@@ -1505,16 +1643,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);
@@ -1538,16 +1670,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: {
-                [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 || {}),
             },
         });
@@ -1565,15 +1697,15 @@ class ManualInstrumentation {
                     try {
                         finalBody = JSON.stringify(end.response.body);
                     }
-                    catch (error) {
+                    catch (_error) {
                         finalBody = '{}';
                     }
                 }
                 span.end({
                     attributes: {
-                        [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 || {}),
                     },
                 });
@@ -1586,49 +1718,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, {
@@ -1637,11 +1768,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 || {}),
         };
@@ -1706,19 +1837,6 @@ class LatitudeInstrumentation {
         $prompt.end();
         return result;
     }
-    async wrapRenderStep(fn, ...args) {
-        const $step = this.manualTelemetry.step(context.active());
-        let result;
-        try {
-            result = await 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);
@@ -1752,8 +1870,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;
     }
@@ -1798,6 +1916,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;
@@ -1877,21 +1996,12 @@ class SpanFactory {
     embedding(options, ctx) {
         return this.telemetry.embedding(ctx ?? context.active(), options);
     }
-    retrieval(options, ctx) {
-        return this.telemetry.retrieval(ctx ?? context.active(), options);
-    }
-    reranking(options, ctx) {
-        return this.telemetry.reranking(ctx ?? context.active(), options);
-    }
     http(options, ctx) {
         return this.telemetry.http(ctx ?? context.active(), options);
     }
     prompt(options, ctx) {
         return this.telemetry.prompt(ctx ?? context.active(), options);
     }
-    step(options, ctx) {
-        return this.telemetry.step(ctx ?? context.active(), options);
-    }
     chat(options, ctx) {
         return this.telemetry.chat(ctx ?? context.active(), options);
     }
@@ -2072,8 +2182,9 @@ class LatitudeTelemetry {
         configureInstrumentation(Instrumentation.Cohere, CohereInstrumentation); // prettier-ignore
         configureInstrumentation(Instrumentation.Langchain, LangChainInstrumentation); // prettier-ignore
         configureInstrumentation(Instrumentation.LlamaIndex, LlamaIndexInstrumentation); // prettier-ignore
-        configureInstrumentation(Instrumentation.OpenAI, OpenAIInstrumentation, { enrichTokens: true }); // prettier-ignore
-        configureInstrumentation(Instrumentation.TogetherAI, TogetherInstrumentation, { enrichTokens: true }); // prettier-ignore
+        // NOTE: `stream: true` in OpenAI make enrichTokens fail, so disabling.
+        configureInstrumentation(Instrumentation.OpenAI, OpenAIInstrumentation, { enrichTokens: false }); // prettier-ignore
+        configureInstrumentation(Instrumentation.TogetherAI, TogetherInstrumentation, { enrichTokens: false }); // prettier-ignore
         configureInstrumentation(Instrumentation.VertexAI, VertexAIInstrumentation); // prettier-ignore
     }
     async capture(options, fn) {