@latitude-data/telemetry 1.0.3 → 1.1.0

package/dist/index.cjs

@@ -13,7 +13,6 @@ var instrumentation = require('@opentelemetry/instrumentation');
 var resources = require('@opentelemetry/resources');
 var sdkTraceNode = require('@opentelemetry/sdk-trace-node');
 var instrumentationAnthropic = require('@traceloop/instrumentation-anthropic');
-var instrumentationAzure = require('@traceloop/instrumentation-azure');
 var instrumentationBedrock = require('@traceloop/instrumentation-bedrock');
 var instrumentationCohere = require('@traceloop/instrumentation-cohere');
 var instrumentationLangchain = require('@traceloop/instrumentation-langchain');
@@ -96,6 +95,7 @@ const DEFAULT_REDACT_SPAN_PROCESSOR = () => new RedactSpanProcessor({
     attributes: [
         /^.*auth.*$/i,
         /^.*authorization.*$/i,
+        /^(?!gen_ai\.).*usage.*$/i,
         /^(?!gen_ai\.).*token.*$/i,
         /^.*secret.*$/i,
         /^.*key.*$/i,
@@ -138,289 +138,6 @@ function GET_GATEWAY_BASE_URL() {
 }
 const env = { GATEWAY_BASE_URL: GET_GATEWAY_BASE_URL() };
 
-var SegmentSource;
-(function (SegmentSource) {
-    SegmentSource["API"] = "api";
-    SegmentSource["AgentAsTool"] = "agent_as_tool";
-    SegmentSource["Copilot"] = "copilot";
-    SegmentSource["EmailTrigger"] = "email_trigger";
-    SegmentSource["Evaluation"] = "evaluation";
-    SegmentSource["Experiment"] = "experiment";
-    SegmentSource["Playground"] = "playground";
-    SegmentSource["ScheduledTrigger"] = "scheduled_trigger";
-    SegmentSource["IntegrationTrigger"] = "integration_trigger";
-    SegmentSource["SharedPrompt"] = "shared_prompt";
-    SegmentSource["User"] = "user";
-})(SegmentSource || (SegmentSource = {}));
-var SegmentType;
-(function (SegmentType) {
-    SegmentType["Document"] = "document";
-    SegmentType["Step"] = "step";
-})(SegmentType || (SegmentType = {}));
-const SEGMENT_SPECIFICATIONS = {
-    [SegmentType.Document]: {
-        name: 'Prompt',
-        description: 'A prompt',
-    },
-    [SegmentType.Step]: {
-        name: 'Step',
-        description: 'A step in a prompt',
-    },
-};
-const baseSegmentBaggageSchema = zod.z.object({
-    id: zod.z.string(),
-    parentId: zod.z.string().optional(),
-    source: zod.z.nativeEnum(SegmentSource),
-});
-zod.z.discriminatedUnion('type', [
-    baseSegmentBaggageSchema.extend({
-        type: zod.z.literal(SegmentType.Document),
-        data: zod.z.object({
-            logUuid: zod.z.string().optional(), // TODO(tracing): temporal related log, remove when observability is ready
-            commitUuid: zod.z.string(),
-            documentUuid: zod.z.string(),
-            experimentUuid: zod.z.string().optional(),
-            externalId: zod.z.string().optional(),
-        }),
-    }),
-    baseSegmentBaggageSchema.extend({
-        type: zod.z.literal(SegmentType.Step),
-        data: zod.z.undefined().optional(),
-    }),
-]);
-
-var SpanKind;
-(function (SpanKind) {
-    SpanKind["Internal"] = "internal";
-    SpanKind["Server"] = "server";
-    SpanKind["Client"] = "client";
-    SpanKind["Producer"] = "producer";
-    SpanKind["Consumer"] = "consumer";
-})(SpanKind || (SpanKind = {}));
-// Note: loosely based on OpenTelemetry GenAI semantic conventions
-var SpanType;
-(function (SpanType) {
-    SpanType["Tool"] = "tool";
-    SpanType["Completion"] = "completion";
-    SpanType["Embedding"] = "embedding";
-    SpanType["Retrieval"] = "retrieval";
-    SpanType["Reranking"] = "reranking";
-    SpanType["Http"] = "http";
-    SpanType["Segment"] = "segment";
-    SpanType["Unknown"] = "unknown";
-})(SpanType || (SpanType = {}));
-const SPAN_SPECIFICATIONS = {
-    [SpanType.Tool]: {
-        name: 'Tool',
-        description: 'A tool call',
-        isGenAI: true,
-        isHidden: false,
-    },
-    [SpanType.Completion]: {
-        name: 'Completion',
-        description: 'A completion call',
-        isGenAI: true,
-        isHidden: false,
-    },
-    [SpanType.Embedding]: {
-        name: 'Embedding',
-        description: 'An embedding call',
-        isGenAI: true,
-        isHidden: false,
-    },
-    [SpanType.Retrieval]: {
-        name: 'Retrieval',
-        description: 'A retrieval call',
-        isGenAI: true,
-        isHidden: false,
-    },
-    [SpanType.Reranking]: {
-        name: 'Reranking',
-        description: 'A reranking call',
-        isGenAI: true,
-        isHidden: false,
-    },
-    [SpanType.Http]: {
-        name: 'HTTP',
-        description: 'An HTTP request',
-        isGenAI: false,
-        isHidden: true,
-    },
-    [SpanType.Segment]: {
-        name: 'Segment',
-        description: 'A (partial) segment of a trace',
-        isGenAI: false,
-        isHidden: false,
-    },
-    [SpanType.Unknown]: {
-        name: 'Unknown',
-        description: 'An unknown span',
-        isGenAI: false,
-        isHidden: true,
-    },
-};
-var SpanStatus;
-(function (SpanStatus) {
-    SpanStatus["Unset"] = "unset";
-    SpanStatus["Ok"] = "ok";
-    SpanStatus["Error"] = "error";
-})(SpanStatus || (SpanStatus = {}));
-
-// Note: Traces are unmaterialized but this context is used to propagate the trace
-// See www.w3.org/TR/trace-context and w3c.github.io/baggage
-zod.z.object({
-    traceparent: zod.z.string(), // <version>-<trace-id>-<span-id>-<trace-flags>
-    tracestate: zod.z.string().optional(), // <key>=urlencoded(<value>)[,<key>=urlencoded(<value>)]*
-    baggage: zod.z.string().optional(), // <key>=urlencoded(<value>)[,<key>=urlencoded(<value>)]*
-});
-
-/* Note: Instrumentation scopes from all language SDKs */
-const SCOPE_LATITUDE = 'so.latitude.instrumentation';
-var InstrumentationScope;
-(function (InstrumentationScope) {
-    InstrumentationScope["Manual"] = "manual";
-    InstrumentationScope["Latitude"] = "latitude";
-    InstrumentationScope["OpenAI"] = "openai";
-    InstrumentationScope["Anthropic"] = "anthropic";
-    InstrumentationScope["AzureOpenAI"] = "azure";
-    InstrumentationScope["VercelAI"] = "vercelai";
-    InstrumentationScope["VertexAI"] = "vertexai";
-    InstrumentationScope["AIPlatform"] = "aiplatform";
-    InstrumentationScope["MistralAI"] = "mistralai";
-    InstrumentationScope["Bedrock"] = "bedrock";
-    InstrumentationScope["Sagemaker"] = "sagemaker";
-    InstrumentationScope["TogetherAI"] = "togetherai";
-    InstrumentationScope["Replicate"] = "replicate";
-    InstrumentationScope["Groq"] = "groq";
-    InstrumentationScope["Cohere"] = "cohere";
-    InstrumentationScope["LiteLLM"] = "litellm";
-    InstrumentationScope["Langchain"] = "langchain";
-    InstrumentationScope["LlamaIndex"] = "llamaindex";
-    InstrumentationScope["DSPy"] = "dspy";
-    InstrumentationScope["Haystack"] = "haystack";
-    InstrumentationScope["Ollama"] = "ollama";
-    InstrumentationScope["Transformers"] = "transformers";
-    InstrumentationScope["AlephAlpha"] = "alephalpha";
-})(InstrumentationScope || (InstrumentationScope = {}));
-/* Note: non-standard OpenTelemetry semantic conventions used in Latitude */
-const ATTR_LATITUDE = 'latitude';
-const ATTR_LATITUDE_TYPE = `${ATTR_LATITUDE}.type`;
-const ATTR_LATITUDE_SEGMENT_ID = `${ATTR_LATITUDE}.segment.id`;
-const ATTR_LATITUDE_SEGMENT_PARENT_ID = `${ATTR_LATITUDE}.segment.parent_id`;
-const ATTR_LATITUDE_SEGMENTS = `${ATTR_LATITUDE}.segments`;
-const GEN_AI_TOOL_TYPE_VALUE_FUNCTION = 'function';
-const ATTR_GEN_AI_TOOL_CALL_ARGUMENTS = 'gen_ai.tool.call.arguments';
-const ATTR_GEN_AI_TOOL_RESULT_VALUE = 'gen_ai.tool.result.value';
-const ATTR_GEN_AI_TOOL_RESULT_IS_ERROR = 'gen_ai.tool.result.is_error';
-const ATTR_GEN_AI_REQUEST = 'gen_ai.request';
-const ATTR_GEN_AI_REQUEST_CONFIGURATION = 'gen_ai.request.configuration';
-const ATTR_GEN_AI_REQUEST_TEMPLATE = 'gen_ai.request.template';
-const ATTR_GEN_AI_REQUEST_PARAMETERS = 'gen_ai.request.parameters';
-const ATTR_GEN_AI_REQUEST_MESSAGES = 'gen_ai.request.messages';
-const ATTR_GEN_AI_RESPONSE = 'gen_ai.response';
-const ATTR_GEN_AI_RESPONSE_MESSAGES = 'gen_ai.response.messages';
-const ATTR_GEN_AI_USAGE_PROMPT_TOKENS = 'gen_ai.usage.prompt_tokens';
-const ATTR_GEN_AI_USAGE_CACHED_TOKENS = 'gen_ai.usage.cached_tokens';
-const ATTR_GEN_AI_USAGE_REASONING_TOKENS = 'gen_ai.usage.reasoning_tokens'; // prettier-ignore
-const ATTR_GEN_AI_USAGE_COMPLETION_TOKENS = 'gen_ai.usage.completion_tokens'; // prettier-ignore
-const ATTR_GEN_AI_PROMPTS = 'gen_ai.prompt'; // gen_ai.prompt.{index}.{role/content/...}
-const ATTR_GEN_AI_COMPLETIONS = 'gen_ai.completion'; // gen_ai.completion.{index}.{role/content/...}
-const ATTR_GEN_AI_MESSAGE_ROLE = 'role';
-const ATTR_GEN_AI_MESSAGE_CONTENT = 'content'; // string or object
-const ATTR_GEN_AI_MESSAGE_TOOL_NAME = 'tool_name';
-const ATTR_GEN_AI_MESSAGE_TOOL_CALL_ID = 'tool_call_id';
-const ATTR_GEN_AI_MESSAGE_TOOL_RESULT_IS_ERROR = 'is_error';
-const ATTR_GEN_AI_MESSAGE_TOOL_CALLS = 'tool_calls'; // gen_ai.completion.{index}.tool_calls.{index}.{id/name/arguments}
-const ATTR_GEN_AI_MESSAGE_TOOL_CALLS_ID = 'id';
-const ATTR_GEN_AI_MESSAGE_TOOL_CALLS_NAME = 'name';
-const ATTR_GEN_AI_MESSAGE_TOOL_CALLS_ARGUMENTS = 'arguments';
-const GEN_AI_RESPONSE_FINISH_REASON_VALUE_STOP = 'stop';
-const GEN_AI_RESPONSE_FINISH_REASON_VALUE_TOOL_CALLS = 'tool_calls';
-const ATTR_HTTP_REQUEST_URL = 'http.request.url';
-const ATTR_HTTP_REQUEST_BODY = 'http.request.body';
-const ATTR_HTTP_REQUEST_HEADER = 'http.request.header';
-const ATTR_HTTP_RESPONSE_BODY = 'http.response.body';
-const ATTR_HTTP_RESPONSE_HEADER = 'http.response.header';
-/* Note: Schemas for span ingestion following OpenTelemetry service request specification */
-var Otlp;
-(function (Otlp) {
-    Otlp.attributeValueSchema = zod.z.object({
-        stringValue: zod.z.string().optional(),
-        intValue: zod.z.number().optional(),
-        boolValue: zod.z.boolean().optional(),
-        arrayValue: zod.z
-            .object({
-            values: zod.z.array(zod.z.object({
-                stringValue: zod.z.string().optional(),
-                intValue: zod.z.number().optional(),
-                boolValue: zod.z.boolean().optional(),
-            })),
-        })
-            .optional(),
-    });
-    Otlp.attributeSchema = zod.z.object({
-        key: zod.z.string(),
-        value: Otlp.attributeValueSchema,
-    });
-    Otlp.eventSchema = zod.z.object({
-        name: zod.z.string(),
-        timeUnixNano: zod.z.string(),
-        attributes: zod.z.array(Otlp.attributeSchema).optional(),
-    });
-    Otlp.linkSchema = zod.z.object({
-        traceId: zod.z.string(),
-        spanId: zod.z.string(),
-        attributes: zod.z.array(Otlp.attributeSchema).optional(),
-    });
-    (function (StatusCode) {
-        StatusCode[StatusCode["Unset"] = 0] = "Unset";
-        StatusCode[StatusCode["Ok"] = 1] = "Ok";
-        StatusCode[StatusCode["Error"] = 2] = "Error";
-    })(Otlp.StatusCode || (Otlp.StatusCode = {}));
-    Otlp.statusSchema = zod.z.object({
-        code: zod.z.number(),
-        message: zod.z.string().optional(),
-    });
-    (function (SpanKind) {
-        SpanKind[SpanKind["Internal"] = 0] = "Internal";
-        SpanKind[SpanKind["Server"] = 1] = "Server";
-        SpanKind[SpanKind["Client"] = 2] = "Client";
-        SpanKind[SpanKind["Producer"] = 3] = "Producer";
-        SpanKind[SpanKind["Consumer"] = 4] = "Consumer";
-    })(Otlp.SpanKind || (Otlp.SpanKind = {}));
-    Otlp.spanSchema = zod.z.object({
-        traceId: zod.z.string(),
-        spanId: zod.z.string(),
-        parentSpanId: zod.z.string().optional(),
-        name: zod.z.string(),
-        kind: zod.z.number(),
-        startTimeUnixNano: zod.z.string(),
-        endTimeUnixNano: zod.z.string(),
-        status: Otlp.statusSchema.optional(),
-        events: zod.z.array(Otlp.eventSchema).optional(),
-        links: zod.z.array(Otlp.linkSchema).optional(),
-        attributes: zod.z.array(Otlp.attributeSchema).optional(),
-    });
-    Otlp.scopeSchema = zod.z.object({
-        name: zod.z.string(),
-        version: zod.z.string().optional(),
-    });
-    Otlp.scopeSpanSchema = zod.z.object({
-        scope: Otlp.scopeSchema,
-        spans: zod.z.array(Otlp.spanSchema),
-    });
-    Otlp.resourceSchema = zod.z.object({
-        attributes: zod.z.array(Otlp.attributeSchema),
-    });
-    Otlp.resourceSpanSchema = zod.z.object({
-        resource: Otlp.resourceSchema,
-        scopeSpans: zod.z.array(Otlp.scopeSpanSchema),
-    });
-    Otlp.serviceRequestSchema = zod.z.object({
-        resourceSpans: zod.z.array(Otlp.resourceSpanSchema),
-    });
-})(Otlp || (Otlp = {}));
-
 var StreamEventTypes;
 (function (StreamEventTypes) {
     StreamEventTypes["Latitude"] = "latitude-event";
@@ -445,17 +162,27 @@ var LatitudeTool;
     LatitudeTool["RunCode"] = "code";
     LatitudeTool["WebSearch"] = "search";
     LatitudeTool["WebExtract"] = "extract";
+    LatitudeTool["Think"] = "think";
+    LatitudeTool["TODO"] = "todo";
 })(LatitudeTool || (LatitudeTool = {}));
 var LatitudeToolInternalName;
 (function (LatitudeToolInternalName) {
     LatitudeToolInternalName["RunCode"] = "lat_tool_run_code";
     LatitudeToolInternalName["WebSearch"] = "lat_tool_web_search";
     LatitudeToolInternalName["WebExtract"] = "lat_tool_web_extract";
+    LatitudeToolInternalName["Think"] = "think";
+    LatitudeToolInternalName["TODO"] = "todo_write";
 })(LatitudeToolInternalName || (LatitudeToolInternalName = {}));
+[
+    LatitudeTool.Think,
+    LatitudeTool.TODO,
+];
 
 const actualOutputConfiguration = zod.z.object({
     messageSelection: zod.z.enum(['last', 'all']), // Which assistant messages to select
-    contentFilter: zod.z.enum(['text', 'image', 'file', 'tool_call']).optional(),
+    contentFilter: zod.z
+        .enum(['text', 'reasoning', 'image', 'file', 'tool_call'])
+        .optional(),
     parsingFormat: zod.z.enum(['string', 'json']),
     fieldAccessor: zod.z.string().optional(), // Field accessor to get the output from if it's a key-value format
 });
@@ -465,11 +192,11 @@ const expectedOutputConfiguration = zod.z.object({
 });
 const baseEvaluationConfiguration = zod.z.object({
     reverseScale: zod.z.boolean(), // If true, lower is better, otherwise, higher is better
-    actualOutput: actualOutputConfiguration.optional(), // Optional for backwards compatibility
-    expectedOutput: expectedOutputConfiguration.optional(), // Optional for backwards compatibility
+    actualOutput: actualOutputConfiguration,
+    expectedOutput: expectedOutputConfiguration.optional(),
 });
 const baseEvaluationResultMetadata = zod.z.object({
-    // Configuration snapshot is defined in every metric specification
+    // configuration: Configuration snapshot is defined in every metric specification
     actualOutput: zod.z.string(),
     expectedOutput: zod.z.string().optional(),
     datasetLabel: zod.z.string().optional(),
@@ -478,7 +205,79 @@ const baseEvaluationResultError = zod.z.object({
     message: zod.z.string(),
 });
 
+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
+    zod.z.object({
+        uuid: zod.z.string(), // Result uuid (for side effects)
+        name: zod.z.string(), // Evaluation name
+        score: zod.z.number(), // Normalized score
+        reason: zod.z.string(),
+        passed: zod.z.boolean(),
+    })),
+});
+const compositeEvaluationResultError = baseEvaluationResultError.extend({
+    errors: zod.z
+        .record(zod.z.string(), // Evaluation uuid
+    zod.z.object({
+        uuid: zod.z.string(), // Result uuid (for side effects)
+        name: zod.z.string(), // Evaluation name
+        message: zod.z.string(),
+    }))
+        .optional(),
+});
+// AVERAGE
+const compositeEvaluationAverageConfiguration = compositeEvaluationConfiguration.extend({});
+compositeEvaluationResultMetadata.extend({
+    configuration: compositeEvaluationAverageConfiguration,
+});
+compositeEvaluationResultError.extend({});
+const CompositeEvaluationAverageSpecification = {
+    };
+// WEIGHTED
+const compositeEvaluationWeightedConfiguration = compositeEvaluationConfiguration.extend({
+    weights: zod.z.record(zod.z.string(), // Evaluation uuid
+    zod.z.number()),
+});
+compositeEvaluationResultMetadata.extend({
+    configuration: compositeEvaluationWeightedConfiguration,
+});
+compositeEvaluationResultError.extend({});
+const CompositeEvaluationWeightedSpecification = {
+    };
+// CUSTOM
+const compositeEvaluationCustomConfiguration = compositeEvaluationConfiguration.extend({
+    formula: zod.z.string(),
+});
+compositeEvaluationResultMetadata.extend({
+    configuration: compositeEvaluationCustomConfiguration,
+});
+compositeEvaluationResultError.extend({});
+const CompositeEvaluationCustomSpecification = {
+    };
+/* ------------------------------------------------------------------------- */
+var CompositeEvaluationMetric;
+(function (CompositeEvaluationMetric) {
+    CompositeEvaluationMetric["Average"] = "average";
+    CompositeEvaluationMetric["Weighted"] = "weighted";
+    CompositeEvaluationMetric["Custom"] = "custom";
+})(CompositeEvaluationMetric || (CompositeEvaluationMetric = {}));
+const CompositeEvaluationSpecification = {
+    // prettier-ignore
+    metrics: {
+        [CompositeEvaluationMetric.Average]: CompositeEvaluationAverageSpecification,
+        [CompositeEvaluationMetric.Weighted]: CompositeEvaluationWeightedSpecification,
+        [CompositeEvaluationMetric.Custom]: CompositeEvaluationCustomSpecification,
+    },
+};
+
 const humanEvaluationConfiguration = baseEvaluationConfiguration.extend({
+    enableControls: zod.z.boolean().optional(), // UI annotation controls
     criteria: zod.z.string().optional(),
 });
 const humanEvaluationResultMetadata = baseEvaluationResultMetadata.extend({
@@ -619,7 +418,9 @@ const LlmEvaluationSpecification = {
 };
 
 const ruleEvaluationConfiguration = baseEvaluationConfiguration.extend({});
-const ruleEvaluationResultMetadata = baseEvaluationResultMetadata.extend({});
+const ruleEvaluationResultMetadata = baseEvaluationResultMetadata.extend({
+    reason: zod.z.string().optional(),
+});
 const ruleEvaluationResultError = baseEvaluationResultError.extend({});
 // EXACT MATCH
 const ruleEvaluationExactMatchConfiguration = ruleEvaluationConfiguration.extend({
@@ -729,12 +530,14 @@ var EvaluationType;
     EvaluationType["Rule"] = "rule";
     EvaluationType["Llm"] = "llm";
     EvaluationType["Human"] = "human";
+    EvaluationType["Composite"] = "composite";
 })(EvaluationType || (EvaluationType = {}));
-const EvaluationTypeSchema = zod.z.nativeEnum(EvaluationType);
+const EvaluationTypeSchema = zod.z.enum(EvaluationType);
 const EvaluationMetricSchema = zod.z.union([
-    zod.z.nativeEnum(RuleEvaluationMetric),
-    zod.z.nativeEnum(LlmEvaluationMetric),
-    zod.z.nativeEnum(HumanEvaluationMetric),
+    zod.z.enum(RuleEvaluationMetric),
+    zod.z.enum(LlmEvaluationMetric),
+    zod.z.enum(HumanEvaluationMetric),
+    zod.z.enum(CompositeEvaluationMetric),
 ]);
 const EvaluationConfigurationSchema = zod.z.custom();
 // prettier-ignore
@@ -745,6 +548,7 @@ zod.z.custom();
     [EvaluationType.Rule]: RuleEvaluationSpecification,
     [EvaluationType.Llm]: LlmEvaluationSpecification,
     [EvaluationType.Human]: HumanEvaluationSpecification,
+    [EvaluationType.Composite]: CompositeEvaluationSpecification,
 });
 zod.z.object({
     name: zod.z.string(),
@@ -758,7 +562,6 @@ zod.z.object({
     enableSuggestions: zod.z.boolean().nullable().optional(),
     autoApplySuggestions: zod.z.boolean().nullable().optional(),
 });
-Object.values(SegmentSource).filter((source) => source !== SegmentSource.Evaluation && source !== SegmentSource.Experiment);
 
 var LegacyChainEventTypes;
 (function (LegacyChainEventTypes) {
@@ -779,17 +582,71 @@ var ChainEventTypes;
     ChainEventTypes["StepCompleted"] = "step-completed";
     ChainEventTypes["StepStarted"] = "step-started";
     ChainEventTypes["ToolCompleted"] = "tool-completed";
-    ChainEventTypes["ToolsRequested"] = "tools-requested";
     ChainEventTypes["ToolResult"] = "tool-result";
     ChainEventTypes["ToolsStarted"] = "tools-started";
 })(ChainEventTypes || (ChainEventTypes = {}));
 
+zod.z.object({
+    name: zod.z.string(),
+    provider: zod.z.string(),
+    model: zod.z.string(),
+    temperature: zod.z.number(),
+});
+// Experiment ran from a dataset
+const experimentDatasetSourceSchema = zod.z.object({
+    source: zod.z.literal('dataset'),
+    datasetId: zod.z.number(),
+    fromRow: zod.z.number(),
+    toRow: zod.z.number(),
+    datasetLabels: zod.z.record(zod.z.string(), zod.z.string()),
+    parametersMap: zod.z.record(zod.z.string(), zod.z.number()),
+});
+// Experiment ran from last logs (from commit and creation time of experiment)
+const experimentLogsSourceSchema = zod.z.object({
+    source: zod.z.literal('logs'),
+    count: zod.z.number(),
+});
+// Experiment ran with manual parameters (currently only used for prompts with no parameters)
+const experimentManualSourceSchema = zod.z.object({
+    source: zod.z.literal('manual'),
+    count: zod.z.number(),
+    parametersMap: zod.z.record(zod.z.string(), zod.z.number()),
+});
+zod.z.discriminatedUnion('source', [
+    experimentDatasetSourceSchema,
+    experimentLogsSourceSchema,
+    experimentManualSourceSchema,
+]);
+
+var QuotaType;
+(function (QuotaType) {
+    QuotaType["Seats"] = "seats";
+    QuotaType["Runs"] = "runs";
+    QuotaType["Credits"] = "credits";
+})(QuotaType || (QuotaType = {}));
+var GrantSource;
+(function (GrantSource) {
+    GrantSource["System"] = "system";
+    GrantSource["Subscription"] = "subscription";
+    GrantSource["Purchase"] = "purchase";
+    GrantSource["Reward"] = "reward";
+    GrantSource["Promocode"] = "promocode";
+})(GrantSource || (GrantSource = {}));
+
+var ModifiedDocumentType;
+(function (ModifiedDocumentType) {
+    ModifiedDocumentType["Created"] = "created";
+    ModifiedDocumentType["Updated"] = "updated";
+    ModifiedDocumentType["UpdatedPath"] = "updated_path";
+    ModifiedDocumentType["Deleted"] = "deleted";
+})(ModifiedDocumentType || (ModifiedDocumentType = {}));
+
 var IntegrationType;
 (function (IntegrationType) {
     IntegrationType["Latitude"] = "latitude";
     IntegrationType["ExternalMCP"] = "custom_mcp";
-    IntegrationType["HostedMCP"] = "mcp_server";
     IntegrationType["Pipedream"] = "pipedream";
+    IntegrationType["HostedMCP"] = "mcp_server";
 })(IntegrationType || (IntegrationType = {}));
 var HostedIntegrationType;
 (function (HostedIntegrationType) {
@@ -886,13 +743,40 @@ var HostedIntegrationType;
     // Loops = 'loops', // Does not exist
 })(HostedIntegrationType || (HostedIntegrationType = {}));
 
-// TODO(evalsv2): Remove
-var EvaluationResultableType;
-(function (EvaluationResultableType) {
-    EvaluationResultableType["Boolean"] = "evaluation_resultable_booleans";
-    EvaluationResultableType["Text"] = "evaluation_resultable_texts";
-    EvaluationResultableType["Number"] = "evaluation_resultable_numbers";
-})(EvaluationResultableType || (EvaluationResultableType = {}));
+var LogSources;
+(function (LogSources) {
+    LogSources["API"] = "api";
+    LogSources["AgentAsTool"] = "agent_as_tool";
+    LogSources["Copilot"] = "copilot";
+    LogSources["EmailTrigger"] = "email_trigger";
+    LogSources["Evaluation"] = "evaluation";
+    LogSources["Experiment"] = "experiment";
+    LogSources["IntegrationTrigger"] = "integration_trigger";
+    LogSources["Playground"] = "playground";
+    LogSources["ScheduledTrigger"] = "scheduled_trigger";
+    LogSources["SharedPrompt"] = "shared_prompt";
+    LogSources["ShadowTest"] = "shadow_test";
+    LogSources["ABTestChallenger"] = "ab_test_challenger";
+    LogSources["User"] = "user";
+})(LogSources || (LogSources = {}));
+
+var RunSourceGroup;
+(function (RunSourceGroup) {
+    RunSourceGroup["Production"] = "production";
+    RunSourceGroup["Playground"] = "playground";
+})(RunSourceGroup || (RunSourceGroup = {}));
+({
+    [RunSourceGroup.Production]: [
+        LogSources.API,
+        LogSources.Copilot,
+        LogSources.EmailTrigger,
+        LogSources.IntegrationTrigger,
+        LogSources.ScheduledTrigger,
+        LogSources.SharedPrompt,
+        LogSources.User,
+    ],
+    [RunSourceGroup.Playground]: [LogSources.Playground, LogSources.Experiment],
+});
 
 var MessageRole;
 (function (MessageRole) {
@@ -902,13 +786,272 @@ var MessageRole;
     MessageRole["tool"] = "tool";
 })(MessageRole || (MessageRole = {}));
 
-var ModifiedDocumentType;
-(function (ModifiedDocumentType) {
-    ModifiedDocumentType["Created"] = "created";
-    ModifiedDocumentType["Updated"] = "updated";
-    ModifiedDocumentType["UpdatedPath"] = "updated_path";
-    ModifiedDocumentType["Deleted"] = "deleted";
-})(ModifiedDocumentType || (ModifiedDocumentType = {}));
+var SpanKind;
+(function (SpanKind) {
+    SpanKind["Internal"] = "internal";
+    SpanKind["Server"] = "server";
+    SpanKind["Client"] = "client";
+    SpanKind["Producer"] = "producer";
+    SpanKind["Consumer"] = "consumer";
+})(SpanKind || (SpanKind = {}));
+// Note: loosely based on OpenTelemetry GenAI semantic conventions
+var SpanType;
+(function (SpanType) {
+    SpanType["Tool"] = "tool";
+    SpanType["Completion"] = "completion";
+    SpanType["Embedding"] = "embedding";
+    SpanType["Retrieval"] = "retrieval";
+    SpanType["Reranking"] = "reranking";
+    SpanType["Http"] = "http";
+    SpanType["Unknown"] = "unknown";
+    SpanType["Prompt"] = "prompt";
+    SpanType["Chat"] = "chat";
+    SpanType["External"] = "external";
+    SpanType["UnresolvedExternal"] = "unresolved_external";
+    SpanType["Step"] = "step";
+})(SpanType || (SpanType = {}));
+const SPAN_SPECIFICATIONS = {
+    [SpanType.Tool]: {
+        name: 'Tool',
+        description: 'A tool call',
+        isGenAI: true,
+        isHidden: false,
+    },
+    [SpanType.Completion]: {
+        name: 'Completion',
+        description: 'A completion call',
+        isGenAI: true,
+        isHidden: false,
+    },
+    [SpanType.Embedding]: {
+        name: 'Embedding',
+        description: 'An embedding call',
+        isGenAI: true,
+        isHidden: false,
+    },
+    [SpanType.Retrieval]: {
+        name: 'Retrieval',
+        description: 'A retrieval call',
+        isGenAI: true,
+        isHidden: false,
+    },
+    [SpanType.Reranking]: {
+        name: 'Reranking',
+        description: 'A reranking call',
+        isGenAI: true,
+        isHidden: false,
+    },
+    [SpanType.Http]: {
+        name: 'HTTP',
+        description: 'An HTTP request',
+        isGenAI: false,
+        isHidden: true,
+    },
+    [SpanType.Unknown]: {
+        name: 'Unknown',
+        description: 'An unknown span',
+        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) {
+    SpanStatus["Unset"] = "unset";
+    SpanStatus["Ok"] = "ok";
+    SpanStatus["Error"] = "error";
+})(SpanStatus || (SpanStatus = {}));
+
+// Note: Traces are unmaterialized but this context is used to propagate the trace
+// See www.w3.org/TR/trace-context and w3c.github.io/baggage
+zod.z.object({
+    traceparent: zod.z.string(), // <version>-<trace-id>-<span-id>-<trace-flags>
+    tracestate: zod.z.string().optional(), // <key>=urlencoded(<value>)[,<key>=urlencoded(<value>)]*
+    baggage: zod.z.string().optional(), // <key>=urlencoded(<value>)[,<key>=urlencoded(<value>)]*
+});
+
+/* Note: Instrumentation scopes from all language SDKs */
+const SCOPE_LATITUDE = 'so.latitude.instrumentation';
+var InstrumentationScope;
+(function (InstrumentationScope) {
+    InstrumentationScope["Manual"] = "manual";
+    InstrumentationScope["Latitude"] = "latitude";
+    InstrumentationScope["OpenAI"] = "openai";
+    InstrumentationScope["Anthropic"] = "anthropic";
+    InstrumentationScope["AzureOpenAI"] = "azure";
+    InstrumentationScope["VercelAI"] = "vercelai";
+    InstrumentationScope["VertexAI"] = "vertexai";
+    InstrumentationScope["AIPlatform"] = "aiplatform";
+    InstrumentationScope["MistralAI"] = "mistralai";
+    InstrumentationScope["Bedrock"] = "bedrock";
+    InstrumentationScope["Sagemaker"] = "sagemaker";
+    InstrumentationScope["TogetherAI"] = "togetherai";
+    InstrumentationScope["Replicate"] = "replicate";
+    InstrumentationScope["Groq"] = "groq";
+    InstrumentationScope["Cohere"] = "cohere";
+    InstrumentationScope["LiteLLM"] = "litellm";
+    InstrumentationScope["Langchain"] = "langchain";
+    InstrumentationScope["LlamaIndex"] = "llamaindex";
+    InstrumentationScope["DSPy"] = "dspy";
+    InstrumentationScope["Haystack"] = "haystack";
+    InstrumentationScope["Ollama"] = "ollama";
+    InstrumentationScope["Transformers"] = "transformers";
+    InstrumentationScope["AlephAlpha"] = "alephalpha";
+})(InstrumentationScope || (InstrumentationScope = {}));
+/* Note: non-standard OpenTelemetry semantic conventions used in Latitude */
+const ATTR_LATITUDE = 'latitude';
+const ATTR_LATITUDE_TYPE = `${ATTR_LATITUDE}.type`;
+const ATTR_LATITUDE_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) {
+    Otlp.attributeValueSchema = zod.z.object({
+        stringValue: zod.z.string().optional(),
+        intValue: zod.z.number().optional(),
+        boolValue: zod.z.boolean().optional(),
+        arrayValue: zod.z
+            .object({
+            values: zod.z.array(zod.z.object({
+                stringValue: zod.z.string().optional(),
+                intValue: zod.z.number().optional(),
+                boolValue: zod.z.boolean().optional(),
+            })),
+        })
+            .optional(),
+    });
+    Otlp.attributeSchema = zod.z.object({
+        key: zod.z.string(),
+        value: Otlp.attributeValueSchema,
+    });
+    Otlp.eventSchema = zod.z.object({
+        name: zod.z.string(),
+        timeUnixNano: zod.z.string(),
+        attributes: zod.z.array(Otlp.attributeSchema).optional(),
+    });
+    Otlp.linkSchema = zod.z.object({
+        traceId: zod.z.string(),
+        spanId: zod.z.string(),
+        attributes: zod.z.array(Otlp.attributeSchema).optional(),
+    });
+    (function (StatusCode) {
+        StatusCode[StatusCode["Unset"] = 0] = "Unset";
+        StatusCode[StatusCode["Ok"] = 1] = "Ok";
+        StatusCode[StatusCode["Error"] = 2] = "Error";
+    })(Otlp.StatusCode || (Otlp.StatusCode = {}));
+    Otlp.statusSchema = zod.z.object({
+        code: zod.z.number(),
+        message: zod.z.string().optional(),
+    });
+    (function (SpanKind) {
+        SpanKind[SpanKind["Internal"] = 0] = "Internal";
+        SpanKind[SpanKind["Server"] = 1] = "Server";
+        SpanKind[SpanKind["Client"] = 2] = "Client";
+        SpanKind[SpanKind["Producer"] = 3] = "Producer";
+        SpanKind[SpanKind["Consumer"] = 4] = "Consumer";
+    })(Otlp.SpanKind || (Otlp.SpanKind = {}));
+    Otlp.spanSchema = zod.z.object({
+        traceId: zod.z.string(),
+        spanId: zod.z.string(),
+        parentSpanId: zod.z.string().optional(),
+        name: zod.z.string(),
+        kind: zod.z.number(),
+        startTimeUnixNano: zod.z.string(),
+        endTimeUnixNano: zod.z.string(),
+        status: Otlp.statusSchema.optional(),
+        events: zod.z.array(Otlp.eventSchema).optional(),
+        links: zod.z.array(Otlp.linkSchema).optional(),
+        attributes: zod.z.array(Otlp.attributeSchema).optional(),
+    });
+    Otlp.scopeSchema = zod.z.object({
+        name: zod.z.string(),
+        version: zod.z.string().optional(),
+    });
+    Otlp.scopeSpanSchema = zod.z.object({
+        scope: Otlp.scopeSchema,
+        spans: zod.z.array(Otlp.spanSchema),
+    });
+    Otlp.resourceSchema = zod.z.object({
+        attributes: zod.z.array(Otlp.attributeSchema),
+    });
+    Otlp.resourceSpanSchema = zod.z.object({
+        resource: Otlp.resourceSchema,
+        scopeSpans: zod.z.array(Otlp.scopeSpanSchema),
+    });
+    Otlp.serviceRequestSchema = zod.z.object({
+        resourceSpans: zod.z.array(Otlp.resourceSpanSchema),
+    });
+})(Otlp || (Otlp = {}));
 
 // TODO(tracing): deprecated
 const HEAD_COMMIT = 'live';
@@ -939,6 +1082,12 @@ var DocumentTriggerType;
     DocumentTriggerType["Scheduled"] = "scheduled";
     DocumentTriggerType["Integration"] = "integration";
 })(DocumentTriggerType || (DocumentTriggerType = {}));
+var DocumentTriggerStatus;
+(function (DocumentTriggerStatus) {
+    DocumentTriggerStatus["Pending"] = "pending";
+    DocumentTriggerStatus["Deployed"] = "deployed";
+    DocumentTriggerStatus["Deprecated"] = "deprecated";
+})(DocumentTriggerStatus || (DocumentTriggerStatus = {}));
 var DocumentTriggerParameters;
 (function (DocumentTriggerParameters) {
     DocumentTriggerParameters["SenderEmail"] = "senderEmail";
@@ -947,14 +1096,13 @@ var DocumentTriggerParameters;
     DocumentTriggerParameters["Body"] = "body";
     DocumentTriggerParameters["Attachments"] = "attachments";
 })(DocumentTriggerParameters || (DocumentTriggerParameters = {}));
+const DOCUMENT_PATH_REGEXP = /^([\w-]+\/)*([\w-.])+$/;
 
 class ManualInstrumentation {
     enabled;
-    source;
     tracer;
-    constructor(source, tracer) {
+    constructor(tracer) {
         this.enabled = false;
-        this.source = source;
         this.tracer = tracer;
     }
     isEnabled() {
@@ -966,95 +1114,34 @@ class ManualInstrumentation {
     disable() {
         this.enabled = false;
     }
-    baggage(ctx) {
-        if ('traceparent' in ctx) {
-            ctx = otel.propagation.extract(otel__namespace.ROOT_CONTEXT, ctx);
+    resume(ctx) {
+        const parts = ctx.traceparent.split('-');
+        if (parts.length !== 4) {
+            return otel__namespace.ROOT_CONTEXT;
         }
-        const baggage = Object.fromEntries(otel.propagation.getBaggage(ctx)?.getAllEntries() || []);
-        if (!(ATTR_LATITUDE_SEGMENT_ID in baggage) ||
-            !(ATTR_LATITUDE_SEGMENTS in baggage)) {
-            return undefined;
+        const [, traceId, spanId, flags] = parts;
+        if (!traceId || !spanId) {
+            return otel__namespace.ROOT_CONTEXT;
         }
-        const segment = {
-            id: baggage[ATTR_LATITUDE_SEGMENT_ID].value,
-            parentId: baggage[ATTR_LATITUDE_SEGMENT_PARENT_ID]?.value,
+        const spanContext = {
+            traceId,
+            spanId,
+            traceFlags: parseInt(flags ?? '01', 16),
+            isRemote: true,
         };
-        let segments = [];
-        try {
-            segments = JSON.parse(baggage[ATTR_LATITUDE_SEGMENTS].value);
-        }
-        catch (error) {
-            return undefined;
-        }
-        if (segments.length < 1) {
-            return undefined;
-        }
-        return { segment, segments };
-    }
-    setBaggage(ctx, baggage, extra) {
-        let parent = Object.fromEntries(otel.propagation.getBaggage(ctx)?.getAllEntries() || []);
-        parent = Object.fromEntries(Object.entries(parent).filter(([attribute]) => attribute !== ATTR_LATITUDE_SEGMENT_ID &&
-            attribute !== ATTR_LATITUDE_SEGMENT_PARENT_ID &&
-            attribute !== ATTR_LATITUDE_SEGMENTS));
-        if (!baggage) {
-            const payload = otel.propagation.createBaggage({ ...parent, ...(extra || {}) });
-            return otel.propagation.setBaggage(ctx, payload);
-        }
-        let jsonSegments = '';
-        try {
-            jsonSegments = JSON.stringify(baggage.segments);
-        }
-        catch (error) {
-            jsonSegments = '[]';
-        }
-        const payload = otel.propagation.createBaggage({
-            ...parent,
-            [ATTR_LATITUDE_SEGMENT_ID]: { value: baggage.segment.id },
-            ...(baggage.segment.parentId && {
-                [ATTR_LATITUDE_SEGMENT_PARENT_ID]: { value: baggage.segment.parentId },
-            }),
-            [ATTR_LATITUDE_SEGMENTS]: { value: jsonSegments },
-            ...(extra || {}),
-        });
-        return otel.propagation.setBaggage(ctx, payload);
-    }
-    pause(ctx) {
-        const baggage = this.baggage(ctx);
-        if (baggage) {
-            baggage.segments.at(-1).paused = 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);
         }
-        ctx = this.setBaggage(ctx, baggage);
-        let carrier = {};
-        otel.propagation.inject(ctx, carrier);
-        return carrier;
-    }
-    resume(ctx) {
-        return otel.propagation.extract(otel__namespace.ROOT_CONTEXT, ctx);
-    }
-    restored(ctx) {
-        const baggage = this.baggage(ctx);
-        return !baggage?.segments.some((segment) => segment.paused);
-    }
-    restore(ctx) {
-        let baggage = this.baggage(ctx);
-        if (!baggage)
-            return ctx;
-        const segments = baggage.segments;
-        while (segments.at(-1)?.paused)
-            segments.pop();
-        const segment = segments.at(-1);
-        if (!segment)
-            return otel__namespace.ROOT_CONTEXT;
-        baggage = {
-            segment: { id: segment.id, parentId: segment.parentId },
-            segments: segments,
-        };
-        ctx = this.setBaggage(ctx, baggage);
-        let carrier = {};
-        otel.propagation.inject(ctx, carrier);
-        carrier.traceparent = segment.traceparent;
-        carrier.tracestate = segment.tracestate;
-        return this.resume(carrier);
+        return context;
     }
     capitalize(str) {
         if (str.length === 0)
@@ -1361,7 +1448,7 @@ class ManualInstrumentation {
     completion(ctx, options) {
         const start = options;
         const configuration = {
-            ...start.configuration,
+            ...(start.configuration ?? {}),
             model: start.model,
         };
         let jsonConfiguration = '';
@@ -1372,14 +1459,15 @@ class ManualInstrumentation {
             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) {
             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,
@@ -1388,34 +1476,45 @@ class ManualInstrumentation {
                 [ATTR_GEN_AI_REQUEST_MESSAGES]: jsonInput,
                 ...attrInput,
                 ...(start.attributes || {}),
+                [ATTR_LATITUDE_COMMIT_UUID]: start.versionUuid,
+                [ATTR_LATITUDE_DOCUMENT_UUID]: start.promptUuid,
+                [ATTR_LATITUDE_EXPERIMENT_UUID]: 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) {
                     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,
                         ...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,
+                        [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]: [end.finishReason],
+                        [incubating.ATTR_GEN_AI_RESPONSE_FINISH_REASONS]: [finishReason],
                         ...(end.attributes || {}),
                     },
                 });
@@ -1502,49 +1601,7 @@ class ManualInstrumentation {
             fail: span.fail,
         };
     }
-    segment(ctx, type, data, options) {
-        options = options || {};
-        let baggage = this.baggage(ctx);
-        const parent = baggage?.segments.at(-1);
-        const segments = baggage?.segments || [];
-        segments.push({
-            ...{
-                id: options._internal?.id || uuid.v4(),
-                ...(parent?.id && { parentId: parent.id }),
-                source: options._internal?.source || parent?.source || this.source,
-                type: type,
-                data: data,
-            },
-            traceparent: 'undefined',
-            tracestate: undefined,
-        });
-        const segment = segments.at(-1);
-        baggage = {
-            segment: { id: segment.id, parentId: segment.parentId },
-            segments: segments,
-        };
-        ctx = this.setBaggage(ctx, baggage, options.baggage);
-        // Dummy wrapper to force the same trace and carry on some segment attributes
-        const span = this.span(ctx, SEGMENT_SPECIFICATIONS[type].name, SpanType.Segment, { attributes: options.attributes });
-        let carrier = {};
-        otel.propagation.inject(span.context, carrier);
-        baggage.segments.at(-1).traceparent = carrier.traceparent;
-        baggage.segments.at(-1).tracestate = carrier.tracestate;
-        // Fix current segment span segments attribute now that we know the trace
-        otel.trace
-            .getSpan(span.context)
-            .setAttribute(ATTR_LATITUDE_SEGMENTS, JSON.stringify(baggage.segments));
-        ctx = this.setBaggage(span.context, baggage, options.baggage);
-        return { context: ctx, end: span.end, fail: span.fail };
-    }
-    prompt(ctx, { logUuid, versionUuid, promptUuid, experimentUuid, externalId, template, parameters, ...rest }) {
-        const baggage = {
-            ...(logUuid && { logUuid }), // TODO(tracing): temporal related log, remove when observability is ready
-            commitUuid: versionUuid || HEAD_COMMIT,
-            documentUuid: promptUuid,
-            ...(experimentUuid && { experimentUuid }),
-            ...(externalId && { externalId }),
-        };
+    prompt(ctx, { documentLogUuid, versionUuid, promptUuid, projectId, experimentUuid, testDeploymentId, externalId, template, parameters, name, source, ...rest }) {
         let jsonParameters = '';
         try {
             jsonParameters = JSON.stringify(parameters || {});
@@ -1555,34 +1612,79 @@ class ManualInstrumentation {
         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,
+            ...(experimentUuid && {
+                [ATTR_LATITUDE_EXPERIMENT_UUID]: experimentUuid,
+            }),
+            ...(testDeploymentId && {
+                [ATTR_LATITUDE_TEST_DEPLOYMENT_ID]: testDeploymentId,
+            }),
+            ...(externalId && { [ATTR_LATITUDE_EXTERNAL_ID]: externalId }),
+            ...(source && { [ATTR_LATITUDE_SOURCE]: source }),
             ...(rest.attributes || {}),
         };
-        return this.segment(ctx, SegmentType.Document, baggage, {
-            ...rest,
+        return this.span(ctx, name || `prompt-${promptUuid}`, SpanType.Prompt, {
             attributes,
         });
     }
     step(ctx, options) {
-        return this.segment(ctx, SegmentType.Step, undefined, options);
+        return this.span(ctx, 'step', SpanType.Step, options);
+    }
+    chat(ctx, { documentLogUuid, previousTraceId, source, name, ...rest }) {
+        const attributes = {
+            [ATTR_LATITUDE_DOCUMENT_LOG_UUID]: documentLogUuid,
+            [ATTR_LATITUDE_PREVIOUS_TRACE_ID]: previousTraceId,
+            ...(source && { [ATTR_LATITUDE_SOURCE]: source }),
+            ...(rest.attributes || {}),
+        };
+        return this.span(ctx, name || 'chat', SpanType.Chat, { attributes });
+    }
+    external(ctx, { promptUuid, documentLogUuid, source, versionUuid, externalId, name, ...rest }) {
+        const attributes = {
+            [ATTR_LATITUDE_DOCUMENT_UUID]: promptUuid,
+            [ATTR_LATITUDE_DOCUMENT_LOG_UUID]: documentLogUuid,
+            [ATTR_LATITUDE_SOURCE]: source ?? LogSources.API,
+            ...(versionUuid && { [ATTR_LATITUDE_COMMIT_UUID]: versionUuid }),
+            ...(externalId && { [ATTR_LATITUDE_EXTERNAL_ID]: externalId }),
+            ...(rest.attributes || {}),
+        };
+        return this.span(ctx, name || `external-${promptUuid}`, SpanType.External, {
+            attributes,
+        });
+    }
+    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 }),
+            ...(conversationUuid && {
+                [ATTR_LATITUDE_DOCUMENT_LOG_UUID]: conversationUuid,
+            }),
+            ...(rest.attributes || {}),
+        };
+        return this.span(ctx, name || `capture-${path}`, SpanType.UnresolvedExternal, { attributes });
     }
 }
 
 class LatitudeInstrumentation {
     options;
-    telemetry;
-    constructor(source, tracer, options) {
-        this.telemetry = new ManualInstrumentation(source, tracer);
+    manualTelemetry;
+    constructor(tracer, options) {
+        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) {
@@ -1606,7 +1708,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,
@@ -1624,7 +1727,7 @@ class LatitudeInstrumentation {
         return result;
     }
     async wrapRenderStep(fn, ...args) {
-        const $step = this.telemetry.step(otel.context.active());
+        const $step = this.manualTelemetry.step(otel.context.active());
         let result;
         try {
             result = await otel.context.with($step.context, async () => await fn(...args));
@@ -1642,7 +1745,7 @@ class LatitudeInstrumentation {
         }
         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,
@@ -1676,7 +1779,7 @@ class LatitudeInstrumentation {
     }
     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,
@@ -1701,10 +1804,165 @@ 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 || (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);
+    }
+    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);
+    }
+    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;
@@ -1729,24 +1987,26 @@ const DEFAULT_SPAN_EXPORTER = (apiKey) => new exporterTraceOtlpHttp.OTLPTraceExp
 // Note: Only exporting typescript instrumentations
 exports.Instrumentation = void 0;
 (function (Instrumentation) {
-    Instrumentation["Latitude"] = "latitude";
-    Instrumentation["OpenAI"] = "openai";
     Instrumentation["Anthropic"] = "anthropic";
-    Instrumentation["AzureOpenAI"] = "azure";
-    Instrumentation["VercelAI"] = "vercelai";
-    Instrumentation["VertexAI"] = "vertexai";
     Instrumentation["AIPlatform"] = "aiplatform";
     Instrumentation["Bedrock"] = "bedrock";
-    Instrumentation["TogetherAI"] = "togetherai";
     Instrumentation["Cohere"] = "cohere";
     Instrumentation["Langchain"] = "langchain";
+    Instrumentation["Latitude"] = "latitude";
     Instrumentation["LlamaIndex"] = "llamaindex";
+    Instrumentation["OpenAI"] = "openai";
+    Instrumentation["TogetherAI"] = "togetherai";
+    Instrumentation["VertexAI"] = "vertexai";
 })(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) {
@@ -1760,234 +2020,100 @@ 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(SegmentSource.API, 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 instrumentation = new LatitudeInstrumentation(SegmentSource.API, tracer, typeof latitude === 'object' ? latitude : { module: latitude });
-            this.instrumentations.push(instrumentation);
-        }
-        const openai = this.options.instrumentations?.openai;
-        if (openai) {
-            const provider = this.tracerProvider(exports.Instrumentation.OpenAI);
-            const instrumentation$1 = new instrumentationOpenai.OpenAIInstrumentation({ enrichTokens: true });
-            instrumentation$1.setTracerProvider(provider);
-            instrumentation$1.manuallyInstrument(openai);
-            instrumentation.registerInstrumentations({
-                instrumentations: [instrumentation$1],
-                tracerProvider: provider,
-            });
-            this.instrumentations.push(instrumentation$1);
-        }
-        const anthropic = this.options.instrumentations?.anthropic;
-        if (anthropic) {
-            const provider = this.tracerProvider(exports.Instrumentation.Anthropic);
-            const instrumentation$1 = new instrumentationAnthropic.AnthropicInstrumentation();
-            instrumentation$1.setTracerProvider(provider);
-            instrumentation$1.manuallyInstrument(anthropic);
-            instrumentation.registerInstrumentations({
-                instrumentations: [instrumentation$1],
-                tracerProvider: provider,
-            });
-            this.instrumentations.push(instrumentation$1);
-        }
-        const azure = this.options.instrumentations?.azure;
-        if (azure) {
-            const provider = this.tracerProvider(exports.Instrumentation.AzureOpenAI);
-            const instrumentation$1 = new instrumentationAzure.AzureOpenAIInstrumentation();
-            instrumentation$1.setTracerProvider(provider);
-            instrumentation$1.manuallyInstrument(azure);
-            instrumentation.registerInstrumentations({
-                instrumentations: [instrumentation$1],
-                tracerProvider: provider,
-            });
-            this.instrumentations.push(instrumentation$1);
-        }
-        const vertexai = this.options.instrumentations?.vertexai;
-        if (vertexai) {
-            const provider = this.tracerProvider(exports.Instrumentation.VertexAI);
-            const instrumentation$1 = new instrumentationVertexai.VertexAIInstrumentation();
-            instrumentation$1.setTracerProvider(provider);
-            instrumentation$1.manuallyInstrument(vertexai);
-            instrumentation.registerInstrumentations({
-                instrumentations: [instrumentation$1],
-                tracerProvider: provider,
-            });
-            this.instrumentations.push(instrumentation$1);
-        }
-        const aiplatform = this.options.instrumentations?.aiplatform;
-        if (aiplatform) {
-            const provider = this.tracerProvider(exports.Instrumentation.AIPlatform);
-            const instrumentation$1 = new instrumentationVertexai.AIPlatformInstrumentation();
-            instrumentation$1.setTracerProvider(provider);
-            instrumentation$1.manuallyInstrument(aiplatform);
-            instrumentation.registerInstrumentations({
-                instrumentations: [instrumentation$1],
-                tracerProvider: provider,
-            });
-            this.instrumentations.push(instrumentation$1);
-        }
-        const bedrock = this.options.instrumentations?.bedrock;
-        if (bedrock) {
-            const provider = this.tracerProvider(exports.Instrumentation.Bedrock);
-            const instrumentation$1 = new instrumentationBedrock.BedrockInstrumentation();
-            instrumentation$1.setTracerProvider(provider);
-            instrumentation$1.manuallyInstrument(bedrock);
-            instrumentation.registerInstrumentations({
-                instrumentations: [instrumentation$1],
-                tracerProvider: provider,
-            });
-            this.instrumentations.push(instrumentation$1);
+            const tracer = this.tracer.get(exports.Instrumentation.Latitude);
+            const instrumentation = new LatitudeInstrumentation(tracer, typeof latitude === 'object' ? latitude : { module: latitude });
+            this.instrumentationsList.push(instrumentation);
         }
-        const togetherai = this.options.instrumentations?.togetherai;
-        if (togetherai) {
-            const provider = this.tracerProvider(exports.Instrumentation.TogetherAI);
-            const instrumentation$1 = new instrumentationTogether.TogetherInstrumentation({
-                enrichTokens: true,
-            });
+        const configureInstrumentation = (instrumentationType, InstrumentationConstructor, instrumentationOptions) => {
+            const providerPkg = this.options.instrumentations?.[instrumentationType];
+            const provider = this.tracer.provider(instrumentationType);
+            const instrumentation$1 = new InstrumentationConstructor(instrumentationOptions); // prettier-ignore
             instrumentation$1.setTracerProvider(provider);
-            instrumentation$1.manuallyInstrument(togetherai);
+            if (providerPkg) {
+                instrumentation$1.manuallyInstrument(providerPkg);
+            }
             instrumentation.registerInstrumentations({
                 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
+        configureInstrumentation(exports.Instrumentation.Bedrock, instrumentationBedrock.BedrockInstrumentation); // prettier-ignore
+        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
+        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 cohere = this.options.instrumentations?.cohere;
-        if (cohere) {
-            const provider = this.tracerProvider(exports.Instrumentation.Cohere);
-            const instrumentation$1 = new instrumentationCohere.CohereInstrumentation();
-            instrumentation$1.setTracerProvider(provider);
-            instrumentation$1.manuallyInstrument(cohere);
-            instrumentation.registerInstrumentations({
-                instrumentations: [instrumentation$1],
-                tracerProvider: provider,
-            });
-            this.instrumentations.push(instrumentation$1);
+        const 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;
         }
-        const langchain = this.options.instrumentations?.langchain;
-        if (langchain) {
-            const provider = this.tracerProvider(exports.Instrumentation.Langchain);
-            const instrumentation$1 = new instrumentationLangchain.LangChainInstrumentation();
-            instrumentation$1.setTracerProvider(provider);
-            instrumentation$1.manuallyInstrument(langchain);
-            instrumentation.registerInstrumentations({
-                instrumentations: [instrumentation$1],
-                tracerProvider: provider,
-            });
-            this.instrumentations.push(instrumentation$1);
+        catch (error) {
+            span.fail(error);
+            throw error;
         }
-        const llamaindex = this.options.instrumentations?.llamaindex;
-        if (llamaindex) {
-            const provider = this.tracerProvider(exports.Instrumentation.LlamaIndex);
-            const instrumentation$1 = new instrumentationLlamaindex.LlamaIndexInstrumentation();
-            instrumentation$1.setTracerProvider(provider);
-            instrumentation$1.manuallyInstrument(llamaindex);
-            instrumentation.registerInstrumentations({
-                instrumentations: [instrumentation$1],
-                tracerProvider: provider,
-            });
-            this.instrumentations.push(instrumentation$1);
+        finally {
+            await this.flush();
         }
     }
-    instrument() {
-        this.instrumentations.forEach((instrumentation) => {
-            if (!instrumentation.isEnabled())
-                instrumentation.enable();
-        });
-    }
-    uninstrument() {
-        this.instrumentations.forEach((instrumentation) => {
-            if (instrumentation.isEnabled())
-                instrumentation.disable();
-        });
-    }
-    baggage(ctx) {
-        return this.telemetry.baggage(ctx);
-    }
-    pause(ctx) {
-        return this.telemetry.pause(ctx);
-    }
-    resume(ctx) {
-        return this.telemetry.resume(ctx);
-    }
-    restored(ctx) {
-        return this.telemetry.restored(ctx);
-    }
-    restore(ctx) {
-        return this.telemetry.restore(ctx);
-    }
-    tool(ctx, options) {
-        return this.telemetry.tool(ctx, options);
-    }
-    completion(ctx, options) {
-        return this.telemetry.completion(ctx, options);
-    }
-    embedding(ctx, options) {
-        return this.telemetry.embedding(ctx, options);
-    }
-    retrieval(ctx, options) {
-        return this.telemetry.retrieval(ctx, options);
-    }
-    reranking(ctx, options) {
-        return this.telemetry.reranking(ctx, options);
-    }
-    http(ctx, options) {
-        return this.telemetry.http(ctx, options);
-    }
-    prompt(ctx, options) {
-        return this.telemetry.prompt(ctx, options);
-    }
-    step(ctx, options) {
-        return this.telemetry.step(ctx, options);
-    }
 }
 
 exports.BACKGROUND = BACKGROUND;