@latitude-data/telemetry 1.0.3 → 1.0.4

package/dist/index.cjs

@@ -4,7 +4,6 @@ var zod = require('zod');
 var otel = require('@opentelemetry/api');
 var semanticConventions = require('@opentelemetry/semantic-conventions');
 var incubating = require('@opentelemetry/semantic-conventions/incubating');
-var uuid = require('uuid');
 var baggageSpanProcessor = require('@opentelemetry/baggage-span-processor');
 var contextAsyncHooks = require('@opentelemetry/context-async-hooks');
 var core = require('@opentelemetry/core');
@@ -13,7 +12,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 +94,7 @@ const DEFAULT_REDACT_SPAN_PROCESSOR = () => new RedactSpanProcessor({
     attributes: [
         /^.*auth.*$/i,
         /^.*authorization.*$/i,
+        /^(?!ai\.).*usage.*$/i,
         /^(?!gen_ai\.).*token.*$/i,
         /^.*secret.*$/i,
         /^.*key.*$/i,
@@ -138,289 +137,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 +161,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 +191,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 +204,78 @@ 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
+});
+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(),
     criteria: zod.z.string().optional(),
 });
 const humanEvaluationResultMetadata = baseEvaluationResultMetadata.extend({
@@ -619,7 +416,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 +528,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 +546,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 +560,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 +580,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 +741,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 +784,242 @@ 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["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.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_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) {
+    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 +1050,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";
@@ -950,11 +1067,9 @@ var DocumentTriggerParameters;
 
 class ManualInstrumentation {
     enabled;
-    source;
     tracer;
-    constructor(source, tracer) {
+    constructor(tracer) {
         this.enabled = false;
-        this.source = source;
         this.tracer = tracer;
     }
     isEnabled() {
@@ -966,96 +1081,9 @@ class ManualInstrumentation {
     disable() {
         this.enabled = false;
     }
-    baggage(ctx) {
-        if ('traceparent' in ctx) {
-            ctx = otel.propagation.extract(otel__namespace.ROOT_CONTEXT, ctx);
-        }
-        const baggage = Object.fromEntries(otel.propagation.getBaggage(ctx)?.getAllEntries() || []);
-        if (!(ATTR_LATITUDE_SEGMENT_ID in baggage) ||
-            !(ATTR_LATITUDE_SEGMENTS in baggage)) {
-            return undefined;
-        }
-        const segment = {
-            id: baggage[ATTR_LATITUDE_SEGMENT_ID].value,
-            parentId: baggage[ATTR_LATITUDE_SEGMENT_PARENT_ID]?.value,
-        };
-        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;
-        }
-        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);
-    }
     capitalize(str) {
         if (str.length === 0)
             return str;
@@ -1388,6 +1416,9 @@ class ManualInstrumentation {
                 [ATTR_GEN_AI_REQUEST_MESSAGES]: jsonInput,
                 ...attrInput,
                 ...(start.attributes || {}),
+                ['latitude.commitUuid']: start.versionUuid,
+                ['latitude.documentUuid']: start.promptUuid,
+                ['latitude.experimentUuid']: start.experimentUuid,
             },
         });
         return {
@@ -1502,49 +1533,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,23 +1544,32 @@ class ManualInstrumentation {
         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 }),
+            ...(testDeploymentId && {
+                [ATTR_LATITUDE_TEST_DEPLOYMENT_ID]: testDeploymentId,
+            }),
+            ...(externalId && { ['latitude.externalId']: externalId }),
+            ...(source && { ['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);
     }
 }
 
 class LatitudeInstrumentation {
     options;
     telemetry;
-    constructor(source, tracer, options) {
-        this.telemetry = new ManualInstrumentation(source, tracer);
+    constructor(tracer, options) {
+        this.telemetry = new ManualInstrumentation(tracer);
         this.options = options;
     }
     isEnabled() {
@@ -1729,18 +1727,16 @@ 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;
@@ -1806,136 +1802,37 @@ class LatitudeTelemetry {
     initInstrumentations() {
         this.instrumentations = [];
         const tracer = this.tracer(InstrumentationScope.Manual);
-        this.telemetry = new ManualInstrumentation(SegmentSource.API, tracer);
+        this.telemetry = new ManualInstrumentation(tracer);
         this.instrumentations.push(this.telemetry);
         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 });
+            const instrumentation = new LatitudeInstrumentation(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();
+        const configureInstrumentation = (instrumentationType, InstrumentationConstructor, instrumentationOptions) => {
+            const providerPkg = this.options.instrumentations?.[instrumentationType];
+            const provider = this.tracerProvider(instrumentationType);
+            const instrumentation$1 = new InstrumentationConstructor(instrumentationOptions); // prettier-ignore
             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 togetherai = this.options.instrumentations?.togetherai;
-        if (togetherai) {
-            const provider = this.tracerProvider(exports.Instrumentation.TogetherAI);
-            const instrumentation$1 = new instrumentationTogether.TogetherInstrumentation({
-                enrichTokens: true,
-            });
-            instrumentation$1.setTracerProvider(provider);
-            instrumentation$1.manuallyInstrument(togetherai);
-            instrumentation.registerInstrumentations({
-                instrumentations: [instrumentation$1],
-                tracerProvider: provider,
-            });
-            this.instrumentations.push(instrumentation$1);
-        }
-        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 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);
-        }
-        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);
+            if (providerPkg) {
+                instrumentation$1.manuallyInstrument(providerPkg);
+            }
             instrumentation.registerInstrumentations({
                 instrumentations: [instrumentation$1],
                 tracerProvider: provider,
             });
             this.instrumentations.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
     }
     instrument() {
         this.instrumentations.forEach((instrumentation) => {
@@ -1949,21 +1846,9 @@ class LatitudeTelemetry {
                 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);
     }