@latitude-data/telemetry 1.0.4 → 1.1.1

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 uuid = require('uuid');
 var baggageSpanProcessor = require('@opentelemetry/baggage-span-processor');
 var contextAsyncHooks = require('@opentelemetry/context-async-hooks');
 var core = require('@opentelemetry/core');
@@ -94,7 +95,7 @@ const DEFAULT_REDACT_SPAN_PROCESSOR = () => new RedactSpanProcessor({
     attributes: [
         /^.*auth.*$/i,
         /^.*authorization.*$/i,
-        /^(?!ai\.).*usage.*$/i,
+        /^(?!gen_ai\.).*usage.*$/i,
         /^(?!gen_ai\.).*token.*$/i,
         /^.*secret.*$/i,
         /^.*key.*$/i,
@@ -149,6 +150,15 @@ zod.z.object({
     isError: zod.z.boolean().optional(),
     text: zod.z.string().optional(),
 });
+zod.z.object({
+    inputTokens: zod.z.number(),
+    outputTokens: zod.z.number(),
+    promptTokens: zod.z.number(),
+    completionTokens: zod.z.number(),
+    totalTokens: zod.z.number(),
+    reasoningTokens: zod.z.number(),
+    cachedInputTokens: zod.z.number(),
+});
 
 var ParameterType;
 (function (ParameterType) {
@@ -274,12 +284,34 @@ const CompositeEvaluationSpecification = {
     },
 };
 
+const selectedContextSchema = zod.z.object({
+    messageIndex: zod.z.number().int().nonnegative(),
+    contentBlockIndex: zod.z.number().int().nonnegative(),
+    contentType: zod.z.enum([
+        'text',
+        'reasoning',
+        'image',
+        'file',
+        'tool-call',
+        'tool-result',
+    ]),
+    textRange: zod.z
+        .object({
+        start: zod.z.number().int().nonnegative(),
+        end: zod.z.number().int().nonnegative(),
+    })
+        .optional(),
+    selectedText: zod.z.string().optional(),
+    toolCallId: zod.z.string().optional(),
+});
 const humanEvaluationConfiguration = baseEvaluationConfiguration.extend({
-    enableControls: zod.z.boolean().optional(),
+    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
@@ -557,8 +589,6 @@ zod.z.object({
 });
 zod.z.object({
     evaluateLiveLogs: zod.z.boolean().nullable().optional(),
-    enableSuggestions: zod.z.boolean().nullable().optional(),
-    autoApplySuggestions: zod.z.boolean().nullable().optional(),
 });
 
 var LegacyChainEventTypes;
@@ -756,6 +786,7 @@ var LogSources;
     LogSources["ShadowTest"] = "shadow_test";
     LogSources["ABTestChallenger"] = "ab_test_challenger";
     LogSources["User"] = "user";
+    LogSources["Optimization"] = "optimization";
 })(LogSources || (LogSources = {}));
 
 var RunSourceGroup;
@@ -766,7 +797,8 @@ var RunSourceGroup;
 ({
     [RunSourceGroup.Production]: [
         LogSources.API,
-        LogSources.Copilot,
+        LogSources.ShadowTest,
+        LogSources.ABTestChallenger,
         LogSources.EmailTrigger,
         LogSources.IntegrationTrigger,
         LogSources.ScheduledTrigger,
@@ -795,23 +827,49 @@ var SpanKind;
 // Note: loosely based on OpenTelemetry GenAI semantic conventions
 var SpanType;
 (function (SpanType) {
-    SpanType["Tool"] = "tool";
+    // Latitude wrappers
+    SpanType["Prompt"] = "prompt";
+    SpanType["Chat"] = "chat";
+    SpanType["External"] = "external";
+    SpanType["UnresolvedExternal"] = "unresolved_external";
+    // 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["Retrieval"] = "retrieval";
-    SpanType["Reranking"] = "reranking";
-    SpanType["Http"] = "http";
     SpanType["Unknown"] = "unknown";
-    SpanType["Prompt"] = "prompt";
-    SpanType["Step"] = "step";
 })(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',
@@ -824,15 +882,9 @@ const SPAN_SPECIFICATIONS = {
         isGenAI: true,
         isHidden: false,
     },
-    [SpanType.Retrieval]: {
-        name: 'Retrieval',
-        description: 'A retrieval call',
-        isGenAI: true,
-        isHidden: false,
-    },
-    [SpanType.Reranking]: {
-        name: 'Reranking',
-        description: 'A reranking call',
+    [SpanType.Tool]: {
+        name: 'Tool',
+        description: 'A tool call',
         isGenAI: true,
         isHidden: false,
     },
@@ -848,18 +900,6 @@ const SPAN_SPECIFICATIONS = {
         isGenAI: false,
         isHidden: true,
     },
-    [SpanType.Prompt]: {
-        name: 'Prompt',
-        description: 'A prompt span',
-        isGenAI: false,
-        isHidden: false,
-    },
-    [SpanType.Step]: {
-        name: 'Step',
-        description: 'A step span',
-        isGenAI: false,
-        isHidden: false,
-    },
 };
 var SpanStatus;
 (function (SpanStatus) {
@@ -867,6 +907,11 @@ var SpanStatus;
     SpanStatus["Ok"] = "ok";
     SpanStatus["Error"] = "error";
 })(SpanStatus || (SpanStatus = {}));
+new Set([
+    SpanType.Prompt,
+    SpanType.Chat,
+    SpanType.External,
+]);
 
 // Note: Traces are unmaterialized but this context is used to propagate the trace
 // See www.w3.org/TR/trace-context and w3c.github.io/baggage
@@ -876,6 +921,130 @@ zod.z.object({
     baggage: zod.z.string().optional(), // <key>=urlencoded(<value>)[,<key>=urlencoded(<value>)]*
 });
 
+const ATTRIBUTES = {
+    // Custom attributes added and used by Latitude spans (Prompt / External / Chat)
+    LATITUDE: {
+        type: 'latitude.type',
+        documentUuid: 'latitude.document_uuid',
+        promptPath: 'latitude.prompt_path',
+        commitUuid: 'latitude.commit_uuid',
+        documentLogUuid: 'latitude.document_log_uuid',
+        projectId: 'latitude.project_id',
+        experimentUuid: 'latitude.experiment_uuid',
+        source: 'latitude.source',
+        externalId: 'latitude.external_id',
+        testDeploymentId: 'latitude.test_deployment_id',
+        previousTraceId: 'latitude.previous_trace_id',
+        // Custom additions to the GenAI semantic conventions (deprecated)
+        request: {
+            _root: 'gen_ai.request',
+            configuration: 'gen_ai.request.configuration',
+            template: 'gen_ai.request.template',
+            parameters: 'gen_ai.request.parameters',
+            messages: 'gen_ai.request.messages'},
+        response: {
+            _root: 'gen_ai.response',
+            messages: 'gen_ai.response.messages',
+        },
+        usage: {
+            promptTokens: 'gen_ai.usage.prompt_tokens',
+            cachedTokens: 'gen_ai.usage.cached_tokens',
+            reasoningTokens: 'gen_ai.usage.reasoning_tokens',
+            completionTokens: 'gen_ai.usage.completion_tokens',
+        },
+    },
+    // Official OpenTelemetry semantic conventions
+    OPENTELEMETRY: {
+        HTTP: {
+            request: {
+                url: 'http.request.url',
+                body: 'http.request.body',
+                header: 'http.request.header',
+                method: semanticConventions.ATTR_HTTP_REQUEST_METHOD,
+            },
+            response: {
+                body: 'http.response.body',
+                header: 'http.response.header',
+                statusCode: semanticConventions.ATTR_HTTP_RESPONSE_STATUS_CODE,
+            },
+        },
+        // GenAI semantic conventions
+        // https://opentelemetry.io/docs/specs/semconv/gen-ai/gen-ai-spans/
+        GEN_AI: {
+            operation: incubating.ATTR_GEN_AI_OPERATION_NAME,
+            response: {
+                model: incubating.ATTR_GEN_AI_RESPONSE_MODEL,
+                finishReasons: incubating.ATTR_GEN_AI_RESPONSE_FINISH_REASONS,
+            },
+            usage: {
+                inputTokens: incubating.ATTR_GEN_AI_USAGE_INPUT_TOKENS,
+                outputTokens: incubating.ATTR_GEN_AI_USAGE_OUTPUT_TOKENS,
+            },
+            tool: {
+                call: {
+                    id: incubating.ATTR_GEN_AI_TOOL_CALL_ID,
+                    arguments: 'gen_ai.tool.call.arguments'}},
+            _deprecated: {
+                system: incubating.ATTR_GEN_AI_SYSTEM,
+                tool: {
+                    name: incubating.ATTR_GEN_AI_TOOL_NAME,
+                    type: incubating.ATTR_GEN_AI_TOOL_TYPE,
+                    result: {
+                        value: 'gen_ai.tool.result.value',
+                        isError: 'gen_ai.tool.result.is_error',
+                    },
+                },
+                prompt: {
+                    _root: 'gen_ai.prompt',
+                    index: (promptIndex) => ({
+                        role: `gen_ai.prompt.${promptIndex}.role`,
+                        content: `gen_ai.prompt.${promptIndex}.content`, // string or object
+                        toolCalls: (toolCallIndex) => ({
+                            id: `gen_ai.prompt.${promptIndex}.tool_calls.${toolCallIndex}.id`,
+                            name: `gen_ai.prompt.${promptIndex}.tool_calls.${toolCallIndex}.name`,
+                            arguments: `gen_ai.prompt.${promptIndex}.tool_calls.${toolCallIndex}.arguments`,
+                        }),
+                        tool: {
+                            callId: `gen_ai.prompt.${promptIndex}.tool_call_id`,
+                            toolName: `gen_ai.prompt.${promptIndex}.tool_name`,
+                            isError: `gen_ai.prompt.${promptIndex}.is_error`,
+                        },
+                    }),
+                },
+                completion: {
+                    _root: 'gen_ai.completion',
+                    index: (completionIndex) => ({
+                        role: `gen_ai.completion.${completionIndex}.role`,
+                        content: `gen_ai.completion.${completionIndex}.content`, // string or object
+                        toolCalls: (toolCallIndex) => ({
+                            id: `gen_ai.completion.${completionIndex}.tool_calls.${toolCallIndex}.id`,
+                            name: `gen_ai.completion.${completionIndex}.tool_calls.${toolCallIndex}.name`,
+                            arguments: `gen_ai.completion.${completionIndex}.tool_calls.${toolCallIndex}.arguments`,
+                        }),
+                        tool: {
+                            callId: `gen_ai.prompt.${completionIndex}.tool_call_id`,
+                            toolName: `gen_ai.prompt.${completionIndex}.tool_name`,
+                            isError: `gen_ai.prompt.${completionIndex}.is_error`,
+                        },
+                    }),
+                }},
+        },
+    }};
+const VALUES = {
+    OPENTELEMETRY: {
+        GEN_AI: {
+            response: {
+                finishReasons: {
+                    stop: 'stop',
+                    toolCalls: 'tool_calls'},
+            },
+            tool: {
+                type: {
+                    function: 'function',
+                },
+            }},
+    }};
+
 /* Note: Instrumentation scopes from all language SDKs */
 const SCOPE_LATITUDE = 'so.latitude.instrumentation';
 var InstrumentationScope;
@@ -904,43 +1073,6 @@ var InstrumentationScope;
     InstrumentationScope["Transformers"] = "transformers";
     InstrumentationScope["AlephAlpha"] = "alephalpha";
 })(InstrumentationScope || (InstrumentationScope = {}));
-/* Note: non-standard OpenTelemetry semantic conventions used in Latitude */
-const ATTR_LATITUDE = 'latitude';
-const ATTR_LATITUDE_TYPE = `${ATTR_LATITUDE}.type`;
-const ATTR_LATITUDE_TEST_DEPLOYMENT_ID = `${ATTR_LATITUDE}.test_deployment_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) {
@@ -1021,6 +1153,40 @@ var Otlp;
     });
 })(Otlp || (Otlp = {}));
 
+const MAX_SIMULATION_TURNS = 10;
+const SimulationSettingsSchema = zod.z.object({
+    simulateToolResponses: zod.z.boolean().optional(),
+    simulatedTools: zod.z.array(zod.z.string()).optional(), // Empty array means all tools are simulated (if simulateToolResponses is true).
+    toolSimulationInstructions: zod.z.string().optional(), // A prompt used to guide and generate the simulation result
+    maxTurns: zod.z.number().min(1).max(MAX_SIMULATION_TURNS).optional(), // The maximum number of turns to simulate. Default is 1, and any greater value will add a new user message to the simulated conversation.
+});
+
+var OptimizationEngine;
+(function (OptimizationEngine) {
+    OptimizationEngine["Identity"] = "identity";
+    OptimizationEngine["Gepa"] = "gepa";
+})(OptimizationEngine || (OptimizationEngine = {}));
+const OptimizationBudgetSchema = zod.z.object({
+    time: zod.z.number().min(0).optional(),
+    tokens: zod.z.number().min(0).optional(),
+});
+zod.z.object({
+    parameters: zod.z
+        .record(zod.z.string(), zod.z.object({
+        column: zod.z.string().optional(), // Note: corresponding column in the user-provided trainset and testset
+        isPii: zod.z.boolean().optional(),
+    }))
+        .optional(),
+    simulation: SimulationSettingsSchema.optional(),
+    scope: zod.z
+        .object({
+        configuration: zod.z.boolean().optional(),
+        instructions: zod.z.boolean().optional(),
+    })
+        .optional(),
+    budget: OptimizationBudgetSchema.optional(),
+});
+
 // TODO(tracing): deprecated
 const HEAD_COMMIT = 'live';
 var Providers;
@@ -1064,6 +1230,7 @@ var DocumentTriggerParameters;
     DocumentTriggerParameters["Body"] = "body";
     DocumentTriggerParameters["Attachments"] = "attachments";
 })(DocumentTriggerParameters || (DocumentTriggerParameters = {}));
+const DOCUMENT_PATH_REGEXP = /^([\w-]+\/)*([\w-.])+$/;
 
 class ManualInstrumentation {
     enabled;
@@ -1082,7 +1249,33 @@ class ManualInstrumentation {
         this.enabled = false;
     }
     resume(ctx) {
-        return otel.propagation.extract(otel__namespace.ROOT_CONTEXT, ctx);
+        const parts = ctx.traceparent.split('-');
+        if (parts.length !== 4) {
+            return otel__namespace.ROOT_CONTEXT;
+        }
+        const [, traceId, spanId, flags] = parts;
+        if (!traceId || !spanId) {
+            return otel__namespace.ROOT_CONTEXT;
+        }
+        const spanContext = {
+            traceId,
+            spanId,
+            traceFlags: parseInt(flags ?? '01', 16),
+            isRemote: true,
+        };
+        let context = otel.trace.setSpanContext(otel__namespace.ROOT_CONTEXT, spanContext);
+        if (ctx.baggage) {
+            const baggageEntries = {};
+            for (const pair of ctx.baggage.split(',')) {
+                const [key, value] = pair.split('=');
+                if (key && value) {
+                    baggageEntries[key] = { value: decodeURIComponent(value) };
+                }
+            }
+            const baggage = otel.propagation.createBaggage(baggageEntries);
+            context = otel.propagation.setBaggage(context, baggage);
+        }
+        return context;
     }
     capitalize(str) {
         if (str.length === 0)
@@ -1139,9 +1332,9 @@ class ManualInstrumentation {
         }
         const span = this.tracer.startSpan(name, {
             attributes: {
-                [ATTR_LATITUDE_TYPE]: type,
+                [ATTRIBUTES.LATITUDE.type]: type,
                 ...(operation && {
-                    [incubating.ATTR_GEN_AI_OPERATION_NAME]: operation,
+                    [ATTRIBUTES.OPENTELEMETRY.GEN_AI.operation]: operation,
                 }),
                 ...(start.attributes || {}),
             },
@@ -1167,15 +1360,15 @@ class ManualInstrumentation {
         try {
             jsonArguments = JSON.stringify(start.call.arguments);
         }
-        catch (error) {
+        catch (_error) {
             jsonArguments = '{}';
         }
         const span = this.span(ctx, start.name, SpanType.Tool, {
             attributes: {
-                [incubating.ATTR_GEN_AI_TOOL_NAME]: start.name,
-                [incubating.ATTR_GEN_AI_TOOL_TYPE]: GEN_AI_TOOL_TYPE_VALUE_FUNCTION,
-                [incubating.ATTR_GEN_AI_TOOL_CALL_ID]: start.call.id,
-                [ATTR_GEN_AI_TOOL_CALL_ARGUMENTS]: jsonArguments,
+                [ATTRIBUTES.OPENTELEMETRY.GEN_AI._deprecated.tool.name]: start.name,
+                [ATTRIBUTES.OPENTELEMETRY.GEN_AI._deprecated.tool.type]: VALUES.OPENTELEMETRY.GEN_AI.tool.type.function,
+                [ATTRIBUTES.OPENTELEMETRY.GEN_AI.tool.call.id]: start.call.id,
+                [ATTRIBUTES.OPENTELEMETRY.GEN_AI.tool.call.arguments]: jsonArguments,
                 ...(start.attributes || {}),
             },
         });
@@ -1188,7 +1381,7 @@ class ManualInstrumentation {
                     try {
                         stringResult = JSON.stringify(end.result.value);
                     }
-                    catch (error) {
+                    catch (_error) {
                         stringResult = '{}';
                     }
                 }
@@ -1197,8 +1390,8 @@ class ManualInstrumentation {
                 }
                 span.end({
                     attributes: {
-                        [ATTR_GEN_AI_TOOL_RESULT_VALUE]: stringResult,
-                        [ATTR_GEN_AI_TOOL_RESULT_IS_ERROR]: end.result.isError,
+                        [ATTRIBUTES.OPENTELEMETRY.GEN_AI._deprecated.tool.result.value]: stringResult,
+                        [ATTRIBUTES.OPENTELEMETRY.GEN_AI._deprecated.tool.result.isError]: end.result.isError,
                         ...(end.attributes || {}),
                     },
                 });
@@ -1206,12 +1399,12 @@ class ManualInstrumentation {
             fail: span.fail,
         };
     }
-    attribifyMessageToolCalls(prefix, toolCalls) {
+    attribifyMessageToolCalls(otelMessageField, toolCalls) {
         const attributes = {};
         for (let i = 0; i < toolCalls.length; i++) {
             for (const key in toolCalls[i]) {
                 const field = this.toCamelCase(key);
-                let value = toolCalls[i][key];
+                const value = toolCalls[i][key];
                 if (value === null || value === undefined)
                     continue;
                 switch (field) {
@@ -1220,28 +1413,29 @@ class ManualInstrumentation {
                     case 'toolUseId': {
                         if (typeof value !== 'string')
                             continue;
-                        attributes[`${prefix}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS}.${i}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS_ID}`] = value;
+                        attributes[otelMessageField.toolCalls(i).id] = value;
                         break;
                     }
                     case 'name':
                     case 'toolName': {
                         if (typeof value !== 'string')
                             continue;
-                        attributes[`${prefix}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS}.${i}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS_NAME}`] = value;
+                        attributes[otelMessageField.toolCalls(i).name] = value;
                         break;
                     }
                     case 'arguments':
                     case 'toolArguments':
                     case 'input': {
                         if (typeof value === 'string') {
-                            attributes[`${prefix}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS}.${i}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS_ARGUMENTS}`] = value;
+                            attributes[otelMessageField.toolCalls(i).arguments] = value;
                         }
                         else {
                             try {
-                                attributes[`${prefix}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS}.${i}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS_ARGUMENTS}`] = JSON.stringify(value);
+                                attributes[otelMessageField.toolCalls(i).arguments] =
+                                    JSON.stringify(value);
                             }
-                            catch (error) {
-                                attributes[`${prefix}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS}.${i}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS_ARGUMENTS}`] = '{}';
+                            catch (_error) {
+                                attributes[otelMessageField.toolCalls(i).arguments] = '{}';
                             }
                         }
                         break;
@@ -1258,8 +1452,9 @@ class ManualInstrumentation {
                             continue;
                         if (typeof value.arguments !== 'string')
                             continue;
-                        attributes[`${prefix}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS}.${i}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS_NAME}`] = value.name;
-                        attributes[`${prefix}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS}.${i}.${ATTR_GEN_AI_MESSAGE_TOOL_CALLS_ARGUMENTS}`] = value.arguments;
+                        attributes[otelMessageField.toolCalls(i).name] = value.name;
+                        attributes[otelMessageField.toolCalls(i).arguments] =
+                            value.arguments;
                         break;
                     }
                 }
@@ -1267,18 +1462,16 @@ class ManualInstrumentation {
         }
         return attributes;
     }
-    attribifyMessageContent(prefix, content) {
+    attribifyMessageContent(otelMessageField, content) {
         let attributes = {};
         if (typeof content === 'string') {
-            attributes[`${prefix}.${ATTR_GEN_AI_MESSAGE_CONTENT}`] = content;
             return attributes;
         }
         try {
-            attributes[`${prefix}.${ATTR_GEN_AI_MESSAGE_CONTENT}`] =
-                JSON.stringify(content);
+            attributes[otelMessageField.content] = JSON.stringify(content);
         }
-        catch (error) {
-            attributes[`${prefix}.${ATTR_GEN_AI_MESSAGE_CONTENT}`] = '[]';
+        catch (_error) {
+            attributes[otelMessageField.content] = '[]';
         }
         if (!Array.isArray(content))
             return attributes;
@@ -1298,32 +1491,34 @@ class ManualInstrumentation {
         if (toolCalls.length > 0) {
             attributes = {
                 ...attributes,
-                ...this.attribifyMessageToolCalls(prefix, toolCalls),
+                ...this.attribifyMessageToolCalls(otelMessageField, toolCalls),
             };
         }
         return attributes;
     }
     attribifyMessages(direction, messages) {
-        const prefix = direction === 'input' ? ATTR_GEN_AI_PROMPTS : ATTR_GEN_AI_COMPLETIONS;
+        const otelField = direction === 'input'
+            ? ATTRIBUTES.OPENTELEMETRY.GEN_AI._deprecated.prompt
+            : ATTRIBUTES.OPENTELEMETRY.GEN_AI._deprecated.completion;
         let attributes = {};
         for (let i = 0; i < messages.length; i++) {
             for (const key in messages[i]) {
                 const field = this.toCamelCase(key);
-                let value = messages[i][key];
+                const value = messages[i][key];
                 if (value === null || value === undefined)
                     continue;
                 switch (field) {
                     case 'role': {
                         if (typeof value !== 'string')
                             continue;
-                        attributes[`${prefix}.${i}.${ATTR_GEN_AI_MESSAGE_ROLE}`] = value;
+                        attributes[otelField.index(i).role] = value;
                         break;
                     }
                     /* Tool calls for Anthropic and PromptL are in the content */
                     case 'content': {
                         attributes = {
                             ...attributes,
-                            ...this.attribifyMessageContent(`${prefix}.${i}`, value),
+                            ...this.attribifyMessageContent(otelField.index(i), value),
                         };
                         break;
                     }
@@ -1333,7 +1528,7 @@ class ManualInstrumentation {
                             continue;
                         attributes = {
                             ...attributes,
-                            ...this.attribifyMessageToolCalls(`${prefix}.${i}`, value),
+                            ...this.attribifyMessageToolCalls(otelField.index(i), value),
                         };
                         break;
                     }
@@ -1343,22 +1538,20 @@ class ManualInstrumentation {
                     case 'toolUseId': {
                         if (typeof value !== 'string')
                             continue;
-                        attributes[`${prefix}.${i}.${ATTR_GEN_AI_MESSAGE_TOOL_CALL_ID}`] =
-                            value;
+                        attributes[otelField.index(i).tool.callId] = value;
                         break;
                     }
                     case 'toolName': {
                         if (typeof value !== 'string')
                             continue;
-                        attributes[`${prefix}.${i}.${ATTR_GEN_AI_MESSAGE_TOOL_NAME}`] =
-                            value;
+                        attributes[otelField.index(i).tool.toolName] = value;
                         break;
                     }
                     // Note: 'toolResult' is 'content' itself
                     case 'isError': {
                         if (typeof value !== 'boolean')
                             continue;
-                        attributes[`${prefix}.${i}.${ATTR_GEN_AI_MESSAGE_TOOL_RESULT_IS_ERROR}`] = value;
+                        attributes[otelField.index(i).tool.isError] = value;
                         break;
                     }
                 }
@@ -1367,7 +1560,9 @@ class ManualInstrumentation {
         return attributes;
     }
     attribifyConfiguration(direction, configuration) {
-        const prefix = direction === 'input' ? ATTR_GEN_AI_REQUEST : ATTR_GEN_AI_RESPONSE;
+        const prefix = direction === 'input'
+            ? ATTRIBUTES.LATITUDE.request._root
+            : ATTRIBUTES.LATITUDE.response._root;
         const attributes = {};
         for (const key in configuration) {
             const field = this.toSnakeCase(key);
@@ -1378,7 +1573,7 @@ class ManualInstrumentation {
                 try {
                     value = JSON.stringify(value);
                 }
-                catch (error) {
+                catch (_error) {
                     value = '{}';
                 }
             }
@@ -1389,64 +1584,75 @@ class ManualInstrumentation {
     completion(ctx, options) {
         const start = options;
         const configuration = {
-            ...start.configuration,
+            ...(start.configuration ?? {}),
             model: start.model,
         };
         let jsonConfiguration = '';
         try {
             jsonConfiguration = JSON.stringify(configuration);
         }
-        catch (error) {
+        catch (_error) {
             jsonConfiguration = '{}';
         }
         const attrConfiguration = this.attribifyConfiguration('input', configuration);
+        const input = start.input ?? [];
         let jsonInput = '';
         try {
-            jsonInput = JSON.stringify(start.input);
+            jsonInput = JSON.stringify(input);
         }
-        catch (error) {
+        catch (_error) {
             jsonInput = '[]';
         }
-        const attrInput = this.attribifyMessages('input', start.input);
+        const attrInput = this.attribifyMessages('input', input);
         const span = this.span(ctx, start.name || `${start.provider} / ${start.model}`, SpanType.Completion, {
             attributes: {
-                [incubating.ATTR_GEN_AI_SYSTEM]: start.provider,
-                [ATTR_GEN_AI_REQUEST_CONFIGURATION]: jsonConfiguration,
+                [ATTRIBUTES.OPENTELEMETRY.GEN_AI._deprecated.system]: start.provider,
+                [ATTRIBUTES.LATITUDE.request.configuration]: jsonConfiguration,
                 ...attrConfiguration,
-                [ATTR_GEN_AI_REQUEST_MESSAGES]: jsonInput,
+                [ATTRIBUTES.LATITUDE.request.messages]: jsonInput,
                 ...attrInput,
                 ...(start.attributes || {}),
-                ['latitude.commitUuid']: start.versionUuid,
-                ['latitude.documentUuid']: start.promptUuid,
-                ['latitude.experimentUuid']: start.experimentUuid,
+                [ATTRIBUTES.LATITUDE.commitUuid]: start.versionUuid,
+                [ATTRIBUTES.LATITUDE.documentUuid]: start.promptUuid,
+                [ATTRIBUTES.LATITUDE.experimentUuid]: start.experimentUuid,
             },
         });
         return {
             context: span.context,
             end: (options) => {
-                const end = options;
+                const end = options ?? {};
+                const output = end.output ?? [];
                 let jsonOutput = '';
                 try {
-                    jsonOutput = JSON.stringify(end.output);
+                    jsonOutput = JSON.stringify(output);
                 }
-                catch (error) {
+                catch (_error) {
                     jsonOutput = '[]';
                 }
-                const attrOutput = this.attribifyMessages('output', end.output);
-                const inputTokens = end.tokens.prompt + end.tokens.cached;
-                const outputTokens = end.tokens.reasoning + end.tokens.completion;
+                const attrOutput = this.attribifyMessages('output', output);
+                const tokens = {
+                    prompt: end.tokens?.prompt ?? 0,
+                    cached: end.tokens?.cached ?? 0,
+                    reasoning: end.tokens?.reasoning ?? 0,
+                    completion: end.tokens?.completion ?? 0,
+                };
+                const inputTokens = tokens.prompt + tokens.cached;
+                const outputTokens = tokens.reasoning + tokens.completion;
+                const finishReason = end.finishReason ?? '';
                 span.end({
                     attributes: {
-                        [ATTR_GEN_AI_RESPONSE_MESSAGES]: jsonOutput,
+                        [ATTRIBUTES.LATITUDE.response.messages]: jsonOutput,
                         ...attrOutput,
-                        [incubating.ATTR_GEN_AI_USAGE_INPUT_TOKENS]: inputTokens,
-                        [ATTR_GEN_AI_USAGE_PROMPT_TOKENS]: end.tokens.prompt,
-                        [ATTR_GEN_AI_USAGE_CACHED_TOKENS]: end.tokens.cached,
-                        [ATTR_GEN_AI_USAGE_REASONING_TOKENS]: end.tokens.reasoning,
-                        [ATTR_GEN_AI_USAGE_COMPLETION_TOKENS]: end.tokens.completion,
-                        [incubating.ATTR_GEN_AI_USAGE_OUTPUT_TOKENS]: outputTokens,
-                        [incubating.ATTR_GEN_AI_RESPONSE_MODEL]: start.model,
-                        [incubating.ATTR_GEN_AI_RESPONSE_FINISH_REASONS]: [end.finishReason],
+                        [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 || {}),
                     },
                 });
@@ -1457,16 +1663,10 @@ class ManualInstrumentation {
     embedding(ctx, options) {
         return this.span(ctx, options?.name || SPAN_SPECIFICATIONS[SpanType.Embedding].name, SpanType.Embedding, options);
     }
-    retrieval(ctx, options) {
-        return this.span(ctx, options?.name || SPAN_SPECIFICATIONS[SpanType.Retrieval].name, SpanType.Retrieval, options);
-    }
-    reranking(ctx, options) {
-        return this.span(ctx, options?.name || SPAN_SPECIFICATIONS[SpanType.Reranking].name, SpanType.Reranking, options);
-    }
     attribifyHeaders(direction, headers) {
         const prefix = direction === 'request'
-            ? ATTR_HTTP_REQUEST_HEADER
-            : ATTR_HTTP_RESPONSE_HEADER;
+            ? ATTRIBUTES.OPENTELEMETRY.HTTP.request.header
+            : ATTRIBUTES.OPENTELEMETRY.HTTP.response.header;
         const attributes = {};
         for (const key in headers) {
             const field = this.toKebabCase(key);
@@ -1490,16 +1690,16 @@ class ManualInstrumentation {
             try {
                 finalBody = JSON.stringify(start.request.body);
             }
-            catch (error) {
+            catch (_error) {
                 finalBody = '{}';
             }
         }
         const span = this.span(ctx, start.name || `${method} ${start.request.url}`, SpanType.Http, {
             attributes: {
-                [semanticConventions.ATTR_HTTP_REQUEST_METHOD]: method,
-                [ATTR_HTTP_REQUEST_URL]: start.request.url,
+                [ATTRIBUTES.OPENTELEMETRY.HTTP.request.method]: method,
+                [ATTRIBUTES.OPENTELEMETRY.HTTP.request.url]: start.request.url,
                 ...attrHeaders,
-                [ATTR_HTTP_REQUEST_BODY]: finalBody,
+                [ATTRIBUTES.OPENTELEMETRY.HTTP.request.body]: finalBody,
                 ...(start.attributes || {}),
             },
         });
@@ -1517,15 +1717,15 @@ class ManualInstrumentation {
                     try {
                         finalBody = JSON.stringify(end.response.body);
                     }
-                    catch (error) {
+                    catch (_error) {
                         finalBody = '{}';
                     }
                 }
                 span.end({
                     attributes: {
-                        [semanticConventions.ATTR_HTTP_RESPONSE_STATUS_CODE]: end.response.status,
+                        [ATTRIBUTES.OPENTELEMETRY.HTTP.response.statusCode]: end.response.status,
                         ...attrHeaders,
-                        [ATTR_HTTP_RESPONSE_BODY]: finalBody,
+                        [ATTRIBUTES.OPENTELEMETRY.HTTP.response.body]: finalBody,
                         ...(end.attributes || {}),
                     },
                 });
@@ -1538,49 +1738,84 @@ 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,
-            ['latitude.commitUuid']: versionUuid || HEAD_COMMIT,
-            ['latitude.documentUuid']: promptUuid,
-            ['latitude.projectId']: projectId,
-            ...(documentLogUuid && { ['latitude.documentLogUuid']: documentLogUuid }),
-            ...(experimentUuid && { ['latitude.experimentUuid']: experimentUuid }),
+            [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 && {
+                [ATTRIBUTES.LATITUDE.experimentUuid]: experimentUuid,
+            }),
             ...(testDeploymentId && {
-                [ATTR_LATITUDE_TEST_DEPLOYMENT_ID]: testDeploymentId,
+                [ATTRIBUTES.LATITUDE.testDeploymentId]: testDeploymentId,
             }),
-            ...(externalId && { ['latitude.externalId']: externalId }),
-            ...(source && { ['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, versionUuid, promptUuid, ...rest }) {
+        const attributes = {
+            [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 = {
+            [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, {
+            attributes,
+        });
+    }
+    unresolvedExternal(ctx, { path, projectId, versionUuid, conversationUuid, name, ...rest }) {
+        const attributes = {
+            [ATTRIBUTES.LATITUDE.promptPath]: path,
+            [ATTRIBUTES.LATITUDE.projectId]: projectId,
+            ...(versionUuid && { [ATTRIBUTES.LATITUDE.commitUuid]: versionUuid }),
+            ...(conversationUuid && {
+                [ATTRIBUTES.LATITUDE.documentLogUuid]: conversationUuid,
+            }),
+            ...(rest.attributes || {}),
+        };
+        return this.span(ctx, name || `capture-${path}`, SpanType.UnresolvedExternal, { attributes });
     }
 }
 
 class LatitudeInstrumentation {
     options;
-    telemetry;
+    manualTelemetry;
     constructor(tracer, options) {
-        this.telemetry = new ManualInstrumentation(tracer);
+        this.manualTelemetry = new ManualInstrumentation(tracer);
         this.options = options;
     }
     isEnabled() {
-        return this.telemetry.isEnabled();
+        return this.manualTelemetry.isEnabled();
     }
     enable() {
         this.options.module.instrument(this);
-        this.telemetry.enable();
+        this.manualTelemetry.enable();
     }
     disable() {
-        this.telemetry.disable();
+        this.manualTelemetry.disable();
         this.options.module.uninstrument();
     }
     countTokens(messages) {
@@ -1604,7 +1839,8 @@ class LatitudeInstrumentation {
     }
     async wrapRenderChain(fn, ...args) {
         const { prompt, parameters } = args[0];
-        const $prompt = this.telemetry.prompt(otel.context.active(), {
+        const $prompt = this.manualTelemetry.prompt(otel.context.active(), {
+            documentLogUuid: uuid.v4(),
             versionUuid: prompt.versionUuid,
             promptUuid: prompt.uuid,
             template: prompt.content,
@@ -1621,26 +1857,13 @@ class LatitudeInstrumentation {
         $prompt.end();
         return result;
     }
-    async wrapRenderStep(fn, ...args) {
-        const $step = this.telemetry.step(otel.context.active());
-        let result;
-        try {
-            result = await otel.context.with($step.context, async () => await fn(...args));
-        }
-        catch (error) {
-            $step.fail(error);
-            throw error;
-        }
-        $step.end();
-        return result;
-    }
     async wrapRenderCompletion(fn, ...args) {
         if (!this.options.completions) {
             return await fn(...args);
         }
         const { provider, config, messages } = args[0];
         const model = config.model || 'unknown';
-        const $completion = this.telemetry.completion(otel.context.active(), {
+        const $completion = this.manualTelemetry.completion(otel.context.active(), {
             name: `${provider} / ${model}`,
             provider: provider,
             model: model,
@@ -1667,14 +1890,14 @@ 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;
     }
     async wrapRenderTool(fn, ...args) {
         const { toolRequest } = args[0];
-        const $tool = this.telemetry.tool(otel.context.active(), {
+        const $tool = this.manualTelemetry.tool(otel.context.active(), {
             name: toolRequest.toolName,
             call: {
                 id: toolRequest.toolCallId,
@@ -1699,10 +1922,157 @@ class LatitudeInstrumentation {
     }
 }
 
+var LatitudeErrorCodes;
+(function (LatitudeErrorCodes) {
+    LatitudeErrorCodes["UnexpectedError"] = "UnexpectedError";
+    LatitudeErrorCodes["OverloadedError"] = "OverloadedError";
+    LatitudeErrorCodes["RateLimitError"] = "RateLimitError";
+    LatitudeErrorCodes["UnauthorizedError"] = "UnauthorizedError";
+    LatitudeErrorCodes["ForbiddenError"] = "ForbiddenError";
+    LatitudeErrorCodes["BadRequestError"] = "BadRequestError";
+    LatitudeErrorCodes["NotFoundError"] = "NotFoundError";
+    LatitudeErrorCodes["ConflictError"] = "ConflictError";
+    LatitudeErrorCodes["UnprocessableEntityError"] = "UnprocessableEntityError";
+    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;
+(function (RunErrorCodes) {
+    RunErrorCodes["AIProviderConfigError"] = "ai_provider_config_error";
+    RunErrorCodes["AIRunError"] = "ai_run_error";
+    RunErrorCodes["ChainCompileError"] = "chain_compile_error";
+    RunErrorCodes["DefaultProviderExceededQuota"] = "default_provider_exceeded_quota_error";
+    RunErrorCodes["DefaultProviderInvalidModel"] = "default_provider_invalid_model_error";
+    RunErrorCodes["DocumentConfigError"] = "document_config_error";
+    RunErrorCodes["ErrorGeneratingMockToolResult"] = "error_generating_mock_tool_result";
+    RunErrorCodes["FailedToWakeUpIntegrationError"] = "failed_to_wake_up_integration_error";
+    RunErrorCodes["InvalidResponseFormatError"] = "invalid_response_format_error";
+    RunErrorCodes["MaxStepCountExceededError"] = "max_step_count_exceeded_error";
+    RunErrorCodes["MissingProvider"] = "missing_provider_error";
+    RunErrorCodes["RateLimit"] = "rate_limit_error";
+    RunErrorCodes["Unknown"] = "unknown_error";
+    RunErrorCodes["UnsupportedProviderResponseTypeError"] = "unsupported_provider_response_type_error";
+    RunErrorCodes["PaymentRequiredError"] = "payment_required_error";
+    RunErrorCodes["AbortError"] = "abort_error";
+    // DEPRECATED, but do not delete
+    RunErrorCodes["EvaluationRunMissingProviderLogError"] = "ev_run_missing_provider_log_error";
+    RunErrorCodes["EvaluationRunMissingWorkspaceError"] = "ev_run_missing_workspace_error";
+    RunErrorCodes["EvaluationRunResponseJsonFormatError"] = "ev_run_response_json_format_error";
+    RunErrorCodes["EvaluationRunUnsupportedResultTypeError"] = "ev_run_unsupported_result_type_error";
+})(RunErrorCodes || (RunErrorCodes = {}));
+var ApiErrorCodes;
+(function (ApiErrorCodes) {
+    ApiErrorCodes["HTTPException"] = "http_exception";
+    ApiErrorCodes["InternalServerError"] = "internal_server_error";
+})(ApiErrorCodes || (ApiErrorCodes = {}));
+
+class LatitudeError extends Error {
+    statusCode = 500;
+    name = LatitudeErrorCodes.UnexpectedError;
+    headers = {};
+    details;
+    constructor(message, details, status, name) {
+        super(message);
+        this.details = details ?? {};
+        this.statusCode = status ?? this.statusCode;
+        this.name = name ?? this.constructor.name;
+    }
+    serialize() {
+        return {
+            name: this.name,
+            code: this.name,
+            status: this.statusCode,
+            message: this.message,
+            details: this.details,
+        };
+    }
+    static deserialize(json) {
+        return new LatitudeError(json.message, json.details, json.status, json.name);
+    }
+}
+class BadRequestError extends LatitudeError {
+    statusCode = 400;
+    name = LatitudeErrorCodes.BadRequestError;
+}
+
 const TRACES_URL = `${env.GATEWAY_BASE_URL}/api/v3/traces`;
 const SERVICE_NAME = process.env.npm_package_name || 'unknown';
 const SCOPE_VERSION = process.env.npm_package_version || 'unknown';
 const BACKGROUND = () => otel__namespace.ROOT_CONTEXT;
+class SpanFactory {
+    telemetry;
+    constructor(telemetry) {
+        this.telemetry = telemetry;
+    }
+    tool(options, ctx) {
+        return this.telemetry.tool(ctx ?? otel.context.active(), options);
+    }
+    completion(options, ctx) {
+        return this.telemetry.completion(ctx ?? otel.context.active(), options);
+    }
+    embedding(options, ctx) {
+        return this.telemetry.embedding(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);
+    }
+    chat(options, ctx) {
+        return this.telemetry.chat(ctx ?? otel.context.active(), options);
+    }
+    external(options, ctx) {
+        return this.telemetry.external(ctx ?? otel.context.active(), options);
+    }
+}
+class ContextManager {
+    telemetry;
+    constructor(telemetry) {
+        this.telemetry = telemetry;
+    }
+    resume(ctx) {
+        return this.telemetry.resume(ctx);
+    }
+    active() {
+        return otel.context.active();
+    }
+}
+class InstrumentationManager {
+    instrumentations;
+    constructor(instrumentations) {
+        this.instrumentations = instrumentations;
+    }
+    enable() {
+        this.instrumentations.forEach((instrumentation) => {
+            if (!instrumentation.isEnabled())
+                instrumentation.enable();
+        });
+    }
+    disable() {
+        this.instrumentations.forEach((instrumentation) => {
+            if (instrumentation.isEnabled())
+                instrumentation.disable();
+        });
+    }
+}
+class TracerManager {
+    nodeProvider;
+    scopeVersion;
+    constructor(nodeProvider, scopeVersion) {
+        this.nodeProvider = nodeProvider;
+        this.scopeVersion = scopeVersion;
+    }
+    get(scope) {
+        return this.provider(scope).getTracer('');
+    }
+    provider(scope) {
+        return new ScopedTracerProvider(`${SCOPE_LATITUDE}.${scope}`, this.scopeVersion, this.nodeProvider);
+    }
+}
 class ScopedTracerProvider {
     scope;
     version;
@@ -1740,9 +2110,13 @@ exports.Instrumentation = void 0;
 })(exports.Instrumentation || (exports.Instrumentation = {}));
 class LatitudeTelemetry {
     options;
-    provider;
-    telemetry;
-    instrumentations;
+    nodeProvider;
+    manualInstrumentation;
+    instrumentationsList;
+    span;
+    context;
+    instrumentation;
+    tracer;
     constructor(apiKey, options) {
         this.options = options || {};
         if (!this.options.exporter) {
@@ -1756,63 +2130,61 @@ class LatitudeTelemetry {
                 new core.W3CBaggagePropagator(),
             ],
         }));
-        this.provider = new sdkTraceNode.NodeTracerProvider({
+        this.nodeProvider = new sdkTraceNode.NodeTracerProvider({
             resource: new resources.Resource({ [semanticConventions.ATTR_SERVICE_NAME]: SERVICE_NAME }),
         });
         // Note: important, must run before the exporter span processors
-        this.provider.addSpanProcessor(new baggageSpanProcessor.BaggageSpanProcessor(baggageSpanProcessor.ALLOW_ALL_BAGGAGE_KEYS));
+        this.nodeProvider.addSpanProcessor(new baggageSpanProcessor.BaggageSpanProcessor(baggageSpanProcessor.ALLOW_ALL_BAGGAGE_KEYS));
         if (this.options.processors) {
             this.options.processors.forEach((processor) => {
-                this.provider.addSpanProcessor(processor);
+                this.nodeProvider.addSpanProcessor(processor);
             });
         }
         else {
-            this.provider.addSpanProcessor(DEFAULT_REDACT_SPAN_PROCESSOR());
+            this.nodeProvider.addSpanProcessor(DEFAULT_REDACT_SPAN_PROCESSOR());
         }
         if (this.options.disableBatch) {
-            this.provider.addSpanProcessor(new sdkTraceNode.SimpleSpanProcessor(this.options.exporter));
+            this.nodeProvider.addSpanProcessor(new sdkTraceNode.SimpleSpanProcessor(this.options.exporter));
         }
         else {
-            this.provider.addSpanProcessor(new sdkTraceNode.BatchSpanProcessor(this.options.exporter));
+            this.nodeProvider.addSpanProcessor(new sdkTraceNode.BatchSpanProcessor(this.options.exporter));
         }
-        this.provider.register();
+        this.nodeProvider.register();
         process.on('SIGTERM', async () => this.shutdown);
         process.on('SIGINT', async () => this.shutdown);
-        this.telemetry = null;
-        this.instrumentations = [];
+        this.manualInstrumentation = null;
+        this.instrumentationsList = [];
+        this.tracer = new TracerManager(this.nodeProvider, SCOPE_VERSION);
         this.initInstrumentations();
-        this.instrument();
+        this.instrumentation = new InstrumentationManager(this.instrumentationsList);
+        this.instrumentation.enable();
+        this.span = new SpanFactory(this.manualInstrumentation);
+        this.context = new ContextManager(this.manualInstrumentation);
     }
     async flush() {
-        await this.provider.forceFlush();
+        await this.nodeProvider.forceFlush();
         await this.options.exporter.forceFlush?.();
     }
     async shutdown() {
         await this.flush();
-        await this.provider.shutdown();
+        await this.nodeProvider.shutdown();
         await this.options.exporter.shutdown?.();
     }
-    tracerProvider(instrumentation) {
-        return new ScopedTracerProvider(`${SCOPE_LATITUDE}.${instrumentation}`, SCOPE_VERSION, this.provider);
-    }
-    tracer(instrumentation) {
-        return this.tracerProvider(instrumentation).getTracer('');
-    }
     // TODO(tracing): auto instrument outgoing HTTP requests
     initInstrumentations() {
-        this.instrumentations = [];
-        const tracer = this.tracer(InstrumentationScope.Manual);
-        this.telemetry = new ManualInstrumentation(tracer);
-        this.instrumentations.push(this.telemetry);
+        this.instrumentationsList = [];
+        const tracer = this.tracer.get(InstrumentationScope.Manual);
+        this.manualInstrumentation = new ManualInstrumentation(tracer);
+        this.instrumentationsList.push(this.manualInstrumentation);
         const latitude = this.options.instrumentations?.latitude;
         if (latitude) {
-            const tracer = this.tracer(exports.Instrumentation.Latitude);
+            const tracer = this.tracer.get(exports.Instrumentation.Latitude);
             const instrumentation = new LatitudeInstrumentation(tracer, typeof latitude === 'object' ? latitude : { module: latitude });
-            this.instrumentations.push(instrumentation);
+            this.instrumentationsList.push(instrumentation);
         }
         const configureInstrumentation = (instrumentationType, InstrumentationConstructor, instrumentationOptions) => {
             const providerPkg = this.options.instrumentations?.[instrumentationType];
-            const provider = this.tracerProvider(instrumentationType);
+            const provider = this.tracer.provider(instrumentationType);
             const instrumentation$1 = new InstrumentationConstructor(instrumentationOptions); // prettier-ignore
             instrumentation$1.setTracerProvider(provider);
             if (providerPkg) {
@@ -1822,7 +2194,7 @@ class LatitudeTelemetry {
                 instrumentations: [instrumentation$1],
                 tracerProvider: provider,
             });
-            this.instrumentations.push(instrumentation$1);
+            this.instrumentationsList.push(instrumentation$1);
         };
         configureInstrumentation(exports.Instrumentation.Anthropic, instrumentationAnthropic.AnthropicInstrumentation); // prettier-ignore
         configureInstrumentation(exports.Instrumentation.AIPlatform, instrumentationVertexai.AIPlatformInstrumentation); // prettier-ignore
@@ -1830,48 +2202,28 @@ 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
     }
-    instrument() {
-        this.instrumentations.forEach((instrumentation) => {
-            if (!instrumentation.isEnabled())
-                instrumentation.enable();
-        });
-    }
-    uninstrument() {
-        this.instrumentations.forEach((instrumentation) => {
-            if (instrumentation.isEnabled())
-                instrumentation.disable();
-        });
-    }
-    resume(ctx) {
-        return this.telemetry.resume(ctx);
-    }
-    tool(ctx, options) {
-        return this.telemetry.tool(ctx, options);
-    }
-    completion(ctx, options) {
-        return this.telemetry.completion(ctx, options);
-    }
-    embedding(ctx, options) {
-        return this.telemetry.embedding(ctx, options);
-    }
-    retrieval(ctx, options) {
-        return this.telemetry.retrieval(ctx, options);
-    }
-    reranking(ctx, options) {
-        return this.telemetry.reranking(ctx, options);
-    }
-    http(ctx, options) {
-        return this.telemetry.http(ctx, options);
-    }
-    prompt(ctx, options) {
-        return this.telemetry.prompt(ctx, options);
-    }
-    step(ctx, options) {
-        return this.telemetry.step(ctx, options);
+    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);
+        try {
+            const result = await otel.context.with(span.context, () => fn(span.context));
+            span.end();
+            return result;
+        }
+        catch (error) {
+            span.fail(error);
+            throw error;
+        }
+        finally {
+            await this.flush();
+        }
     }
 }