@latitude-data/telemetry 1.1.0 → 2.0.0

package/dist/index.cjs

@@ -1,9 +1,10 @@
 '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 rosettaAi = require('rosetta-ai');
 var uuid = require('uuid');
 var baggageSpanProcessor = require('@opentelemetry/baggage-span-processor');
 var contextAsyncHooks = require('@opentelemetry/context-async-hooks');
@@ -138,6 +139,23 @@ function GET_GATEWAY_BASE_URL() {
 }
 const env = { GATEWAY_BASE_URL: GET_GATEWAY_BASE_URL() };
 
+function toSnakeCase(str) {
+    return str
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .replace(/[^A-Za-z0-9]+/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_+|_+$/g, '')
+        .toLowerCase();
+}
+function toKebabCase(input) {
+    return input
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/[^A-Za-z0-9]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .toLowerCase();
+}
+
 var StreamEventTypes;
 (function (StreamEventTypes) {
     StreamEventTypes["Latitude"] = "latitude-event";
@@ -150,6 +168,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) {
@@ -190,10 +217,24 @@ 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 EVALUATION_TRIGGER_TARGETS = ['first', 'every', 'last'];
+const DEFAULT_LAST_INTERACTION_DEBOUNCE_SECONDS = 120;
+const LAST_INTERACTION_DEBOUNCE_MIN_SECONDS = 30;
+const LAST_INTERACTION_DEBOUNCE_MAX_SECONDS = 60 * 60 * 24; // 1 day
+const triggerConfiguration = zod.z.object({
+    target: zod.z.enum(EVALUATION_TRIGGER_TARGETS),
+    lastInteractionDebounce: zod.z
+        .number()
+        .min(LAST_INTERACTION_DEBOUNCE_MIN_SECONDS)
+        .max(LAST_INTERACTION_DEBOUNCE_MAX_SECONDS)
+        .optional()
+        .default(DEFAULT_LAST_INTERACTION_DEBOUNCE_SECONDS),
+});
 const baseEvaluationConfiguration = zod.z.object({
     reverseScale: zod.z.boolean(), // If true, lower is better, otherwise, higher is better
     actualOutput: actualOutputConfiguration,
     expectedOutput: expectedOutputConfiguration.optional(),
+    trigger: triggerConfiguration.optional(),
 });
 const baseEvaluationResultMetadata = zod.z.object({
     // configuration: Configuration snapshot is defined in every metric specification
@@ -209,7 +250,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 +316,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,18 +621,8 @@ 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;
-(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["ChainCompleted"] = "chain-completed";
@@ -758,6 +810,7 @@ var LogSources;
     LogSources["ShadowTest"] = "shadow_test";
     LogSources["ABTestChallenger"] = "ab_test_challenger";
     LogSources["User"] = "user";
+    LogSources["Optimization"] = "optimization";
 })(LogSources || (LogSources = {}));
 
 var RunSourceGroup;
@@ -768,7 +821,8 @@ var RunSourceGroup;
 ({
     [RunSourceGroup.Production]: [
         LogSources.API,
-        LogSources.Copilot,
+        LogSources.ShadowTest,
+        LogSources.ABTestChallenger,
         LogSources.EmailTrigger,
         LogSources.IntegrationTrigger,
         LogSources.ScheduledTrigger,
@@ -778,14 +832,6 @@ var RunSourceGroup;
     [RunSourceGroup.Playground]: [LogSources.Playground, LogSources.Experiment],
 });
 
-var MessageRole;
-(function (MessageRole) {
-    MessageRole["system"] = "system";
-    MessageRole["user"] = "user";
-    MessageRole["assistant"] = "assistant";
-    MessageRole["tool"] = "tool";
-})(MessageRole || (MessageRole = {}));
-
 var SpanKind;
 (function (SpanKind) {
     SpanKind["Internal"] = "internal";
@@ -797,26 +843,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 +898,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 +916,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 +923,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 +937,100 @@ 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'},
+        response: {
+            _root: 'gen_ai.response'},
+        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,
+            },
+            systemInstructions: 'gen_ai.system.instructions', // Contains the PARTS of the "system message"
+            tool: {
+                call: {
+                    id: incubating.ATTR_GEN_AI_TOOL_CALL_ID,
+                    arguments: 'gen_ai.tool.call.arguments'}},
+            input: {
+                messages: 'gen_ai.input.messages',
+            },
+            output: {
+                messages: 'gen_ai.output.messages',
+            },
+            _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',
+                    },
+                }},
+        },
+    }};
+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 +1059,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 +1139,54 @@ var Otlp;
     });
 })(Otlp || (Otlp = {}));
 
+const MAX_SIMULATION_TURNS = 10;
+const globalGoalSourceSchema = zod.z.object({
+    type: zod.z.literal('global'),
+    value: zod.z.string(),
+});
+const columnGoalSourceSchema = zod.z.object({
+    type: zod.z.literal('column'),
+    columnIndex: zod.z.number(),
+});
+const simulatedUserGoalSourceSchema = zod.z.discriminatedUnion('type', [
+    globalGoalSourceSchema,
+    columnGoalSourceSchema,
+]);
+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.
+    simulatedUserGoal: zod.z.string().optional(), // Deprecated: Use simulatedUserGoalSource instead. Kept for backward compatibility.
+    simulatedUserGoalSource: simulatedUserGoalSourceSchema.optional(), // The source for the simulated user goal (global text or dataset column).
+});
+
+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;
@@ -1098,12 +1232,18 @@ var DocumentTriggerParameters;
 })(DocumentTriggerParameters || (DocumentTriggerParameters = {}));
 const DOCUMENT_PATH_REGEXP = /^([\w-]+\/)*([\w-.])+$/;
 
+const translator = new rosettaAi.Translator({
+    filterEmptyMessages: true,
+    providerMetadata: 'preserve',
+});
 class ManualInstrumentation {
     enabled;
     tracer;
-    constructor(tracer) {
+    options;
+    constructor(tracer, options) {
         this.enabled = false;
         this.tracer = tracer;
+        this.options = options ?? {};
     }
     isEnabled() {
         return this.enabled;
@@ -1143,36 +1283,6 @@ class ManualInstrumentation {
         }
         return context;
     }
-    capitalize(str) {
-        if (str.length === 0)
-            return str;
-        return str.charAt(0).toUpperCase() + str.toLowerCase().slice(1);
-    }
-    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('');
-    }
-    toSnakeCase(str) {
-        return str
-            .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
-            .replace(/[^A-Za-z0-9]+/g, '_')
-            .replace(/_+/g, '_')
-            .replace(/^_+|_+$/g, '')
-            .toLowerCase();
-    }
-    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);
@@ -1198,9 +1308,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 || {}),
             },
@@ -1220,26 +1330,29 @@ class ManualInstrumentation {
             },
         };
     }
+    unknown(ctx, options) {
+        return this.span(ctx, options?.name || SPAN_SPECIFICATIONS[SpanType.Unknown].name, SpanType.Unknown, options);
+    }
     tool(ctx, options) {
         const start = options;
         let jsonArguments = '';
         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 || {}),
             },
         });
         return {
-            context: span.context,
+            ...span,
             end: (options) => {
                 const end = options;
                 let stringResult = '';
@@ -1247,7 +1360,7 @@ class ManualInstrumentation {
                     try {
                         stringResult = JSON.stringify(end.result.value);
                     }
-                    catch (error) {
+                    catch (_error) {
                         stringResult = '{}';
                     }
                 }
@@ -1256,180 +1369,21 @@ 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 || {}),
                     },
                 });
             },
-            fail: span.fail,
         };
     }
-    attribifyMessageToolCalls(prefix, toolCalls) {
-        const attributes = {};
-        for (let i = 0; i < toolCalls.length; i++) {
-            for (const key in toolCalls[i]) {
-                const field = this.toCamelCase(key);
-                let value = toolCalls[i][key];
-                if (value === null || value === undefined)
-                    continue;
-                switch (field) {
-                    case 'id':
-                    case 'toolCallId':
-                    case 'toolUseId': {
-                        if (typeof value !== 'string')
-                            continue;
-                        attributes[`${prefix}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS}.${i}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS_ID}`] = value;
-                        break;
-                    }
-                    case 'name':
-                    case 'toolName': {
-                        if (typeof value !== 'string')
-                            continue;
-                        attributes[`${prefix}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS}.${i}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS_NAME}`] = value;
-                        break;
-                    }
-                    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 prefix = direction === 'input'
+            ? ATTRIBUTES.LATITUDE.request._root
+            : ATTRIBUTES.LATITUDE.response._root;
         const attributes = {};
         for (const key in configuration) {
-            const field = this.toSnakeCase(key);
+            const field = toSnakeCase(key);
             let value = configuration[key];
             if (value === null || value === undefined)
                 continue;
@@ -1437,7 +1391,7 @@ class ManualInstrumentation {
                 try {
                     value = JSON.stringify(value);
                 }
-                catch (error) {
+                catch (_error) {
                     value = '{}';
                 }
             }
@@ -1455,45 +1409,56 @@ class ManualInstrumentation {
         try {
             jsonConfiguration = JSON.stringify(configuration);
         }
-        catch (error) {
+        catch (_error) {
             jsonConfiguration = '{}';
         }
         const attrConfiguration = this.attribifyConfiguration('input', configuration);
         const input = start.input ?? [];
+        let jsonSystem = '';
         let jsonInput = '';
         try {
-            jsonInput = JSON.stringify(input);
+            const translated = translator.translate(input, {
+                from: this.options.provider,
+                to: rosettaAi.Provider.GenAI,
+                direction: 'input',
+            });
+            jsonSystem = JSON.stringify(translated.system ?? []);
+            jsonInput = JSON.stringify(translated.messages ?? []);
         }
-        catch (error) {
+        catch (_error) {
+            jsonSystem = '[]';
             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,
-                ...attrInput,
+                [ATTRIBUTES.OPENTELEMETRY.GEN_AI.systemInstructions]: jsonSystem,
+                [ATTRIBUTES.OPENTELEMETRY.GEN_AI.input.messages]: jsonInput,
                 ...(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 {
-            context: span.context,
+            ...span,
             end: (options) => {
                 const end = options ?? {};
                 const output = end.output ?? [];
                 let jsonOutput = '';
                 try {
-                    jsonOutput = JSON.stringify(output);
+                    const translated = translator.translate(output, {
+                        from: this.options.provider,
+                        to: rosettaAi.Provider.GenAI,
+                        direction: 'output',
+                    });
+                    jsonOutput = JSON.stringify(translated.messages ?? []);
                 }
-                catch (error) {
+                catch (_error) {
                     jsonOutput = '[]';
                 }
-                const attrOutput = this.attribifyMessages('output', output);
                 const tokens = {
                     prompt: end.tokens?.prompt ?? 0,
                     cached: end.tokens?.cached ?? 0,
@@ -1505,39 +1470,33 @@ class ManualInstrumentation {
                 const finishReason = end.finishReason ?? '';
                 span.end({
                     attributes: {
-                        [ATTR_GEN_AI_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.output.messages]: jsonOutput,
+                        [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 || {}),
                     },
                 });
             },
-            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;
+            ? ATTRIBUTES.OPENTELEMETRY.HTTP.request.header
+            : ATTRIBUTES.OPENTELEMETRY.HTTP.response.header;
         const attributes = {};
         for (const key in headers) {
-            const field = this.toKebabCase(key);
+            const field = toKebabCase(key);
             const value = headers[key];
             if (value === null || value === undefined)
                 continue;
@@ -1558,21 +1517,21 @@ 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 || {}),
             },
         });
         return {
-            context: span.context,
+            ...span,
             end: (options) => {
                 const end = options;
                 // Note: do not serialize headers as a single attribute because fields won't be redacted
@@ -1585,20 +1544,19 @@ 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 || {}),
                     },
                 });
             },
-            fail: span.fail,
         };
     }
     prompt(ctx, { documentLogUuid, versionUuid, promptUuid, projectId, experimentUuid, testDeploymentId, externalId, template, parameters, name, source, ...rest }) {
@@ -1606,49 +1564,50 @@ 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 });
+        return this.span(ctx, name || `chat-${documentLogUuid}`, 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 +1616,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 || {}),
         };
@@ -1680,8 +1639,8 @@ class LatitudeInstrumentation {
         return this.manualTelemetry.isEnabled();
     }
     enable() {
-        this.options.module.instrument(this);
         this.manualTelemetry.enable();
+        this.options.module.instrument(this);
     }
     disable() {
         this.manualTelemetry.disable();
@@ -1726,19 +1685,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 +1718,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 +1764,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;
@@ -1888,6 +1835,9 @@ class SpanFactory {
     constructor(telemetry) {
         this.telemetry = telemetry;
     }
+    span(options, ctx) {
+        return this.telemetry.unknown(ctx ?? otel.context.active(), options);
+    }
     tool(options, ctx) {
         return this.telemetry.tool(ctx ?? otel.context.active(), options);
     }
@@ -1897,21 +1847,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);
     }
@@ -1930,6 +1871,9 @@ class ContextManager {
     active() {
         return otel.context.active();
     }
+    with(ctx, fn, thisArg, ...args) {
+        return otel.context.with(ctx, fn, thisArg, ...args);
+    }
 }
 class InstrumentationManager {
     instrumentations;
@@ -1976,6 +1920,23 @@ class ScopedTracerProvider {
         return this.provider.getTracer(this.scope, this.version, options);
     }
 }
+class LifecycleManager {
+    nodeProvider;
+    exporter;
+    constructor(nodeProvider, exporter) {
+        this.nodeProvider = nodeProvider;
+        this.exporter = exporter;
+    }
+    async flush() {
+        await this.nodeProvider.forceFlush();
+        await this.exporter.forceFlush?.();
+    }
+    async shutdown() {
+        await this.flush();
+        await this.nodeProvider.shutdown();
+        await this.exporter.shutdown?.();
+    }
+}
 const DEFAULT_SPAN_EXPORTER = (apiKey) => new exporterTraceOtlpHttp.OTLPTraceExporter({
     url: TRACES_URL,
     headers: {
@@ -1994,6 +1955,7 @@ exports.Instrumentation = void 0;
     Instrumentation["Langchain"] = "langchain";
     Instrumentation["Latitude"] = "latitude";
     Instrumentation["LlamaIndex"] = "llamaindex";
+    Instrumentation["Manual"] = "manual";
     Instrumentation["OpenAI"] = "openai";
     Instrumentation["TogetherAI"] = "togetherai";
     Instrumentation["VertexAI"] = "vertexai";
@@ -2007,6 +1969,7 @@ class LatitudeTelemetry {
     context;
     instrumentation;
     tracer;
+    lifecycle;
     constructor(apiKey, options) {
         this.options = options || {};
         if (!this.options.exporter) {
@@ -2023,6 +1986,7 @@ class LatitudeTelemetry {
         this.nodeProvider = new sdkTraceNode.NodeTracerProvider({
             resource: new resources.Resource({ [semanticConventions.ATTR_SERVICE_NAME]: SERVICE_NAME }),
         });
+        this.lifecycle = new LifecycleManager(this.nodeProvider, this.options.exporter);
         // Note: important, must run before the exporter span processors
         this.nodeProvider.addSpanProcessor(new baggageSpanProcessor.BaggageSpanProcessor(baggageSpanProcessor.ALLOW_ALL_BAGGAGE_KEYS));
         if (this.options.processors) {
@@ -2052,19 +2016,16 @@ class LatitudeTelemetry {
         this.context = new ContextManager(this.manualInstrumentation);
     }
     async flush() {
-        await this.nodeProvider.forceFlush();
-        await this.options.exporter.forceFlush?.();
+        await this.lifecycle.flush();
     }
     async shutdown() {
-        await this.flush();
-        await this.nodeProvider.shutdown();
-        await this.options.exporter.shutdown?.();
+        await this.lifecycle.shutdown();
     }
     // TODO(tracing): auto instrument outgoing HTTP requests
     initInstrumentations() {
         this.instrumentationsList = [];
-        const tracer = this.tracer.get(InstrumentationScope.Manual);
-        this.manualInstrumentation = new ManualInstrumentation(tracer);
+        const tracer = this.tracer.get(exports.Instrumentation.Manual);
+        this.manualInstrumentation = new ManualInstrumentation(tracer, this.options.instrumentations?.manual);
         this.instrumentationsList.push(this.manualInstrumentation);
         const latitude = this.options.instrumentations?.latitude;
         if (latitude) {
@@ -2074,12 +2035,12 @@ class LatitudeTelemetry {
         }
         const configureInstrumentation = (instrumentationType, InstrumentationConstructor, instrumentationOptions) => {
             const providerPkg = this.options.instrumentations?.[instrumentationType];
+            if (!providerPkg)
+                return;
             const provider = this.tracer.provider(instrumentationType);
             const instrumentation$1 = new InstrumentationConstructor(instrumentationOptions); // prettier-ignore
             instrumentation$1.setTracerProvider(provider);
-            if (providerPkg) {
-                instrumentation$1.manuallyInstrument(providerPkg);
-            }
+            instrumentation$1.manuallyInstrument(providerPkg);
             instrumentation.registerInstrumentations({
                 instrumentations: [instrumentation$1],
                 tracerProvider: provider,
@@ -2092,27 +2053,26 @@ 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) {
         if (!DOCUMENT_PATH_REGEXP.test(options.path)) {
             throw new BadRequestError("Invalid path, no spaces. Only letters, numbers, '.', '-' and '_'");
         }
-        const span = this.manualInstrumentation.unresolvedExternal(otel__namespace.ROOT_CONTEXT, options);
+        const span = this.manualInstrumentation.unresolvedExternal(BACKGROUND(), options);
+        let result;
         try {
-            const result = await otel.context.with(span.context, () => fn(span.context));
-            span.end();
-            return result;
+            result = await otel.context.with(span.context, async () => await fn(span.context));
         }
         catch (error) {
             span.fail(error);
             throw error;
         }
-        finally {
-            await this.flush();
-        }
+        span.end();
+        return result;
     }
 }