@latitude-data/telemetry 2.0.4 → 3.0.0-alpha.1

package/dist/index.js

@@ -1,2089 +1,485 @@
-import { z } from 'zod';
-import { ATTR_GEN_AI_OPERATION_NAME, ATTR_GEN_AI_TOOL_CALL_ID, ATTR_GEN_AI_TOOL_TYPE, ATTR_GEN_AI_TOOL_NAME, ATTR_GEN_AI_SYSTEM, ATTR_GEN_AI_RESPONSE_FINISH_REASONS, ATTR_GEN_AI_RESPONSE_MODEL, ATTR_GEN_AI_USAGE_OUTPUT_TOKENS, ATTR_GEN_AI_USAGE_INPUT_TOKENS } from '@opentelemetry/semantic-conventions/incubating';
-import { ATTR_HTTP_REQUEST_METHOD, ATTR_HTTP_RESPONSE_STATUS_CODE, ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
-import * as otel from '@opentelemetry/api';
-import { trace, propagation, context } from '@opentelemetry/api';
-import { Translator, Provider } from 'rosetta-ai';
-import { v4 } from 'uuid';
-import { BaggageSpanProcessor, ALLOW_ALL_BAGGAGE_KEYS } from '@opentelemetry/baggage-span-processor';
-import { AsyncLocalStorageContextManager } from '@opentelemetry/context-async-hooks';
-import { CompositePropagator, W3CTraceContextPropagator, W3CBaggagePropagator } from '@opentelemetry/core';
-import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
-import { registerInstrumentations } from '@opentelemetry/instrumentation';
-import { Resource } from '@opentelemetry/resources';
-import { NodeTracerProvider, SimpleSpanProcessor, BatchSpanProcessor } from '@opentelemetry/sdk-trace-node';
-import { AnthropicInstrumentation } from '@traceloop/instrumentation-anthropic';
-import { BedrockInstrumentation } from '@traceloop/instrumentation-bedrock';
-import { CohereInstrumentation } from '@traceloop/instrumentation-cohere';
-import { LangChainInstrumentation } from '@traceloop/instrumentation-langchain';
-import { LlamaIndexInstrumentation } from '@traceloop/instrumentation-llamaindex';
-import { OpenAIInstrumentation } from '@traceloop/instrumentation-openai';
-import { TogetherInstrumentation } from '@traceloop/instrumentation-together';
-import { AIPlatformInstrumentation, VertexAIInstrumentation } from '@traceloop/instrumentation-vertexai';
-
-class RedactSpanProcessor {
-    options;
-    constructor(options) {
-        this.options = options;
-        if (!options.mask) {
-            this.options.mask = (_attribute, _value) => '******';
-        }
-    }
-    onStart(_span, _context) {
-        // Noop
-    }
-    onEnd(span) {
-        Object.assign(span.attributes, this.redactAttributes(span.attributes));
-        for (const event of span.events) {
-            if (!event.attributes)
-                continue;
-            Object.assign(event.attributes, this.redactAttributes(event.attributes));
-        }
-        for (const link of span.links) {
-            if (!link.attributes)
-                continue;
-            Object.assign(link.attributes, this.redactAttributes(link.attributes));
-        }
-    }
-    forceFlush() {
-        return Promise.resolve();
-    }
-    shutdown() {
-        return Promise.resolve();
-    }
-    shouldRedact(attribute) {
-        return this.options.attributes.some((pattern) => {
-            if (typeof pattern === 'string') {
-                return attribute === pattern;
-            }
-            else if (pattern instanceof RegExp) {
-                return pattern.test(attribute);
-            }
-            return false;
-        });
-    }
-    redactAttributes(attributes) {
-        const redacted = {};
-        for (const [key, value] of Object.entries(attributes)) {
-            if (this.shouldRedact(key)) {
-                redacted[key] = this.options.mask(key, value);
-            }
-        }
-        return redacted;
-    }
-}
-const DEFAULT_REDACT_SPAN_PROCESSOR = () => new RedactSpanProcessor({
-    attributes: [
-        /^.*auth.*$/i,
-        /^.*authorization.*$/i,
-        /^(?!gen_ai\.).*usage.*$/i,
-        /^(?!gen_ai\.).*token.*$/i,
-        /^.*secret.*$/i,
-        /^.*key.*$/i,
-        /^.*password.*$/i,
-        /^.*cookie.*$/i,
-        /^.*session.*$/i,
-        /^.*credential.*$/i,
-        /^.*signature.*$/i,
-        /^.*oauth.*$/i,
-        /^.*saml.*$/i,
-        /^.*openid.*$/i,
-        /^.*refresh.*$/i,
-        /^.*jwt.*$/i,
-        /^.*otp.*$/i,
-        /^.*mfa.*$/i,
-        /^.*csrf.*$/i,
-        /^.*xsrf.*$/i,
-        /^.*refresh.*$/i,
-        /^.*x[-_]forwarded[-_]for.*$/i,
-        /^.*x[-_]real[-_]ip.*$/i,
-    ],
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
-const DEFAULT_GATEWAY_BASE_URL = {
-    production: 'https://gateway.latitude.so',
-    development: 'http://localhost:8787',
-    test: 'http://localhost:8787',
-}["production"];
-function GET_GATEWAY_BASE_URL() {
-    if (process.env.GATEWAY_BASE_URL) {
-        return process.env.GATEWAY_BASE_URL;
-    }
-    if (!process.env.GATEWAY_HOSTNAME) {
-        return DEFAULT_GATEWAY_BASE_URL;
-    }
-    const protocol = process.env.GATEWAY_SSL ? 'https' : 'http';
-    const port = process.env.GATEWAY_PORT ?? (process.env.GATEWAY_SSL ? 443 : 80);
-    const hostname = process.env.GATEWAY_HOSTNAME;
-    return `${protocol}://${hostname}:${port}`;
+// src/sdk/context.ts
+import { context, createContextKey, trace } from "@opentelemetry/api";
+var LATITUDE_CONTEXT_KEY = createContextKey("latitude-internal-context");
+var CAPTURE_TRACER_NAME = "so.latitude.instrumentation.capture";
+function getLatitudeContext(ctx) {
+  return ctx.getValue(LATITUDE_CONTEXT_KEY);
 }
-const env = { GATEWAY_BASE_URL: GET_GATEWAY_BASE_URL() };
-
-function toSnakeCase(str) {
-    return str
-        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
-        .replace(/[^A-Za-z0-9]+/g, '_')
-        .replace(/_+/g, '_')
-        .replace(/^_+|_+$/g, '')
-        .toLowerCase();
+function mergeArrays(a, b) {
+  if (!a && !b) return void 0;
+  if (!a) return b;
+  if (!b) return a;
+  return [.../* @__PURE__ */ new Set([...a, ...b])];
 }
-function toKebabCase(input) {
-    return input
-        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
-        .replace(/[^A-Za-z0-9]+/g, '-')
-        .replace(/-+/g, '-')
-        .replace(/^-+|-+$/g, '')
-        .toLowerCase();
+function capture(name, fn, options = {}) {
+  const currentContext = context.active();
+  const existingData = getLatitudeContext(currentContext);
+  const mergedData = {
+    name: options.name ?? name,
+    tags: mergeArrays(existingData?.tags, options.tags),
+    metadata: { ...existingData?.metadata, ...options.metadata },
+    sessionId: options.sessionId ?? existingData?.sessionId,
+    userId: options.userId ?? existingData?.userId
+  };
+  const newContext = currentContext.setValue(LATITUDE_CONTEXT_KEY, mergedData);
+  const existingSpan = trace.getSpan(currentContext);
+  if (existingSpan) {
+    return context.with(newContext, fn);
+  }
+  const tracer = trace.getTracer(CAPTURE_TRACER_NAME);
+  return tracer.startActiveSpan(name, { attributes: { "latitude.capture.root": true } }, newContext, (span) => {
+    let result;
+    try {
+      result = fn();
+    } catch (error) {
+      span.recordException(error);
+      span.end();
+      throw error;
+    }
+    if (result instanceof Promise) {
+      return result.catch((error) => {
+        span.recordException(error);
+        throw error;
+      }).finally(() => {
+        span.end();
+      });
+    }
+    span.end();
+    return result;
+  });
 }
 
-var StreamEventTypes;
-(function (StreamEventTypes) {
-    StreamEventTypes["Latitude"] = "latitude-event";
-    StreamEventTypes["Provider"] = "provider-event";
-})(StreamEventTypes || (StreamEventTypes = {}));
-z.object({
-    id: z.string(),
-    name: z.string(),
-    result: z.unknown(),
-    isError: z.boolean().optional(),
-    text: z.string().optional(),
-});
-z.object({
-    inputTokens: z.number(),
-    outputTokens: z.number(),
-    promptTokens: z.number(),
-    completionTokens: z.number(),
-    totalTokens: z.number(),
-    reasoningTokens: z.number(),
-    cachedInputTokens: z.number(),
-});
-
-var ParameterType;
-(function (ParameterType) {
-    ParameterType["Text"] = "text";
-    ParameterType["Image"] = "image";
-    ParameterType["File"] = "file";
-})(ParameterType || (ParameterType = {}));
-var LatitudeTool;
-(function (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 = z.object({
-    messageSelection: z.enum(['last', 'all']), // Which assistant messages to select
-    contentFilter: z
-        .enum(['text', 'reasoning', 'image', 'file', 'tool_call'])
-        .optional(),
-    parsingFormat: z.enum(['string', 'json']),
-    fieldAccessor: z.string().optional(), // Field accessor to get the output from if it's a key-value format
-});
-const expectedOutputConfiguration = z.object({
-    parsingFormat: z.enum(['string', 'json']),
-    fieldAccessor: z.string().optional(), // Field accessor to get the output from if it's a key-value format
-});
-const EVALUATION_TRIGGER_TARGETS = ['first', 'every', 'last'];
-const LAST_INTERACTION_DEBOUNCE_MIN_SECONDS = 30;
-const LAST_INTERACTION_DEBOUNCE_MAX_SECONDS = 60 * 60 * 24; // 1 day
-const MIN_EVALUATION_SAMPLE_RATE = 0; // 0%
-const MAX_EVALUATION_SAMPLE_RATE = 100; // 100%
-const triggerConfiguration = z.object({
-    target: z.enum(EVALUATION_TRIGGER_TARGETS),
-    lastInteractionDebounce: z
-        .number()
-        .min(LAST_INTERACTION_DEBOUNCE_MIN_SECONDS)
-        .max(LAST_INTERACTION_DEBOUNCE_MAX_SECONDS)
-        .optional(),
-    sampleRate: z
-        .number()
-        .int()
-        .min(MIN_EVALUATION_SAMPLE_RATE)
-        .max(MAX_EVALUATION_SAMPLE_RATE)
-        .optional(),
-});
-const baseEvaluationConfiguration = z.object({
-    reverseScale: z.boolean(), // If true, lower is better, otherwise, higher is better
-    actualOutput: actualOutputConfiguration,
-    expectedOutput: expectedOutputConfiguration.optional(),
-    trigger: triggerConfiguration.optional(),
-});
-const baseEvaluationResultMetadata = z.object({
-    // configuration: Configuration snapshot is defined in every metric specification
-    actualOutput: z.string(),
-    expectedOutput: z.string().optional(),
-    datasetLabel: z.string().optional(),
-});
-const baseEvaluationResultError = z.object({
-    message: z.string(),
-});
-
-const compositeEvaluationConfiguration = baseEvaluationConfiguration.extend({
-    evaluationUuids: z.array(z.string()),
-    minThreshold: z.number().optional(), // Threshold percentage
-    maxThreshold: z.number().optional(), // Threshold percentage
-});
-const compositeEvaluationResultMetadata = baseEvaluationResultMetadata.extend({
-    results: z.record(z.string(), // Evaluation uuid
-    z.object({
-        uuid: z.string(), // Result uuid (for side effects)
-        name: z.string(), // Evaluation name
-        score: z.number(), // Normalized score
-        reason: z.string(),
-        passed: z.boolean(),
-        tokens: z.number().optional(), // Optional llm evaluation usage
-    })),
-});
-const compositeEvaluationResultError = baseEvaluationResultError.extend({
-    errors: z
-        .record(z.string(), // Evaluation uuid
-    z.object({
-        uuid: z.string(), // Result uuid (for side effects)
-        name: z.string(), // Evaluation name
-        message: z.string(),
-    }))
-        .optional(),
-});
-// AVERAGE
-const compositeEvaluationAverageConfiguration = compositeEvaluationConfiguration.extend({});
-compositeEvaluationResultMetadata.extend({
-    configuration: compositeEvaluationAverageConfiguration,
-});
-compositeEvaluationResultError.extend({});
-const CompositeEvaluationAverageSpecification = {
-    };
-// WEIGHTED
-const compositeEvaluationWeightedConfiguration = compositeEvaluationConfiguration.extend({
-    weights: z.record(z.string(), // Evaluation uuid
-    z.number()),
-});
-compositeEvaluationResultMetadata.extend({
-    configuration: compositeEvaluationWeightedConfiguration,
-});
-compositeEvaluationResultError.extend({});
-const CompositeEvaluationWeightedSpecification = {
-    };
-// CUSTOM
-const compositeEvaluationCustomConfiguration = compositeEvaluationConfiguration.extend({
-    formula: 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 selectedContextSchema = z.object({
-    messageIndex: z.number().int().nonnegative(),
-    contentBlockIndex: z.number().int().nonnegative(),
-    contentType: z.enum([
-        'text',
-        'reasoning',
-        'image',
-        'file',
-        'tool-call',
-        'tool-result',
-    ]),
-    textRange: z
-        .object({
-        start: z.number().int().nonnegative(),
-        end: z.number().int().nonnegative(),
-    })
-        .optional(),
-    selectedText: z.string().optional(),
-    toolCallId: z.string().optional(),
-});
-const humanEvaluationConfiguration = baseEvaluationConfiguration.extend({
-    enableControls: z.boolean().optional(), // UI annotation controls
-    criteria: z.string().optional(),
-});
-const humanEvaluationResultMetadata = baseEvaluationResultMetadata.extend({
-    reason: z.string().optional(),
-    enrichedReason: z.string().optional(),
-    selectedContexts: z.array(selectedContextSchema).optional(),
-});
-const humanEvaluationResultError = baseEvaluationResultError.extend({});
-// BINARY
-const humanEvaluationBinaryConfiguration = humanEvaluationConfiguration.extend({
-    passDescription: z.string().optional(),
-    failDescription: z.string().optional(),
-});
-humanEvaluationResultMetadata.extend({
-    configuration: humanEvaluationBinaryConfiguration,
-});
-humanEvaluationResultError.extend({});
-const HumanEvaluationBinarySpecification = {
-    };
-// RATING
-const humanEvaluationRatingConfiguration = humanEvaluationConfiguration.extend({
-    minRating: z.number(),
-    minRatingDescription: z.string().optional(),
-    maxRating: z.number(),
-    maxRatingDescription: z.string().optional(),
-    minThreshold: z.number().optional(), // Threshold in rating range
-    maxThreshold: z.number().optional(), // Threshold in rating range
-});
-humanEvaluationResultMetadata.extend({
-    configuration: humanEvaluationRatingConfiguration,
-});
-humanEvaluationResultError.extend({});
-const HumanEvaluationRatingSpecification = {
-    };
-/* ------------------------------------------------------------------------- */
-var HumanEvaluationMetric;
-(function (HumanEvaluationMetric) {
-    HumanEvaluationMetric["Binary"] = "binary";
-    HumanEvaluationMetric["Rating"] = "rating";
-})(HumanEvaluationMetric || (HumanEvaluationMetric = {}));
-const HumanEvaluationSpecification = {
-    // prettier-ignore
-    metrics: {
-        [HumanEvaluationMetric.Binary]: HumanEvaluationBinarySpecification,
-        [HumanEvaluationMetric.Rating]: HumanEvaluationRatingSpecification,
-    },
-};
-
-const llmEvaluationConfiguration = baseEvaluationConfiguration.extend({
-    provider: z.string(),
-    model: z.string(),
-});
-const llmEvaluationResultMetadata = baseEvaluationResultMetadata.extend({
-    evaluationLogId: z.number(),
-    reason: z.string(),
-    tokens: z.number(),
-    cost: z.number(),
-    duration: z.number(),
-});
-const llmEvaluationResultError = baseEvaluationResultError.extend({
-    runErrorId: z.number().optional(),
-});
-// BINARY
-const llmEvaluationBinaryConfiguration = llmEvaluationConfiguration.extend({
-    criteria: z.string(),
-    passDescription: z.string(),
-    failDescription: z.string(),
-});
-llmEvaluationResultMetadata.extend({
-    configuration: llmEvaluationBinaryConfiguration,
-});
-llmEvaluationResultError.extend({});
-const LlmEvaluationBinarySpecification = {
-    };
-// RATING
-const llmEvaluationRatingConfiguration = llmEvaluationConfiguration.extend({
-    criteria: z.string(),
-    minRating: z.number(),
-    minRatingDescription: z.string(),
-    maxRating: z.number(),
-    maxRatingDescription: z.string(),
-    minThreshold: z.number().optional(), // Threshold in rating range
-    maxThreshold: z.number().optional(), // Threshold in rating range
-});
-llmEvaluationResultMetadata.extend({
-    configuration: llmEvaluationRatingConfiguration,
-});
-llmEvaluationResultError.extend({});
-const LlmEvaluationRatingSpecification = {
-    };
-// COMPARISON
-const llmEvaluationComparisonConfiguration = llmEvaluationConfiguration.extend({
-    criteria: z.string(),
-    passDescription: z.string(),
-    failDescription: z.string(),
-    minThreshold: z.number().optional(), // Threshold percentage
-    maxThreshold: z.number().optional(), // Threshold percentage
-});
-llmEvaluationResultMetadata.extend({
-    configuration: llmEvaluationComparisonConfiguration,
-});
-llmEvaluationResultError.extend({});
-const LlmEvaluationComparisonSpecification = {
-    };
-// CUSTOM
-const llmEvaluationCustomConfiguration = llmEvaluationConfiguration.extend({
-    prompt: z.string(),
-    minScore: z.number(),
-    maxScore: z.number(),
-    minThreshold: z.number().optional(), // Threshold percentage
-    maxThreshold: z.number().optional(), // Threshold percentage
-});
-llmEvaluationResultMetadata.extend({
-    configuration: llmEvaluationCustomConfiguration,
-});
-llmEvaluationResultError.extend({});
-const LlmEvaluationCustomSpecification = {
-    };
-// CUSTOM LABELED
-const LlmEvaluationCustomLabeledSpecification = {
-    };
-/* ------------------------------------------------------------------------- */
-var LlmEvaluationMetric;
-(function (LlmEvaluationMetric) {
-    LlmEvaluationMetric["Binary"] = "binary";
-    LlmEvaluationMetric["Rating"] = "rating";
-    LlmEvaluationMetric["Comparison"] = "comparison";
-    LlmEvaluationMetric["Custom"] = "custom";
-    LlmEvaluationMetric["CustomLabeled"] = "custom_labeled";
-})(LlmEvaluationMetric || (LlmEvaluationMetric = {}));
-const LlmEvaluationSpecification = {
-    // prettier-ignore
-    metrics: {
-        [LlmEvaluationMetric.Binary]: LlmEvaluationBinarySpecification,
-        [LlmEvaluationMetric.Rating]: LlmEvaluationRatingSpecification,
-        [LlmEvaluationMetric.Comparison]: LlmEvaluationComparisonSpecification,
-        [LlmEvaluationMetric.Custom]: LlmEvaluationCustomSpecification,
-        [LlmEvaluationMetric.CustomLabeled]: LlmEvaluationCustomLabeledSpecification,
-    },
-};
+// src/sdk/init.ts
+import { context as context2, propagation } from "@opentelemetry/api";
+import { AsyncLocalStorageContextManager } from "@opentelemetry/context-async-hooks";
+import { CompositePropagator, W3CBaggagePropagator, W3CTraceContextPropagator } from "@opentelemetry/core";
+import { Resource } from "@opentelemetry/resources";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
 
-const ruleEvaluationConfiguration = baseEvaluationConfiguration.extend({});
-const ruleEvaluationResultMetadata = baseEvaluationResultMetadata.extend({
-    reason: z.string().optional(),
-});
-const ruleEvaluationResultError = baseEvaluationResultError.extend({});
-// EXACT MATCH
-const ruleEvaluationExactMatchConfiguration = ruleEvaluationConfiguration.extend({
-    caseInsensitive: z.boolean(),
-});
-ruleEvaluationResultMetadata.extend({
-    configuration: ruleEvaluationExactMatchConfiguration,
-});
-ruleEvaluationResultError.extend({});
-const RuleEvaluationExactMatchSpecification = {
-    };
-// REGULAR EXPRESSION
-const ruleEvaluationRegularExpressionConfiguration = ruleEvaluationConfiguration.extend({
-    pattern: z.string(),
-});
-ruleEvaluationResultMetadata.extend({
-    configuration: ruleEvaluationRegularExpressionConfiguration,
-});
-ruleEvaluationResultError.extend({});
-const RuleEvaluationRegularExpressionSpecification = {
-    };
-// SCHEMA VALIDATION
-const ruleEvaluationSchemaValidationConfiguration = ruleEvaluationConfiguration.extend({
-    format: z.enum(['json']),
-    schema: z.string(),
-});
-ruleEvaluationResultMetadata.extend({
-    configuration: ruleEvaluationSchemaValidationConfiguration,
-});
-ruleEvaluationResultError.extend({});
-const RuleEvaluationSchemaValidationSpecification = {
-    };
-// LENGTH COUNT
-const ruleEvaluationLengthCountConfiguration = ruleEvaluationConfiguration.extend({
-    algorithm: z.enum(['character', 'word', 'sentence']),
-    minLength: z.number().optional(),
-    maxLength: z.number().optional(),
-});
-ruleEvaluationResultMetadata.extend({
-    configuration: ruleEvaluationLengthCountConfiguration,
-});
-ruleEvaluationResultError.extend({});
-const RuleEvaluationLengthCountSpecification = {
-    };
-// LEXICAL OVERLAP
-const ruleEvaluationLexicalOverlapConfiguration = ruleEvaluationConfiguration.extend({
-    algorithm: z.enum(['substring', 'levenshtein_distance', 'rouge']),
-    minOverlap: z.number().optional(), // Percentage of overlap
-    maxOverlap: z.number().optional(), // Percentage of overlap
-});
-ruleEvaluationResultMetadata.extend({
-    configuration: ruleEvaluationLexicalOverlapConfiguration,
-});
-ruleEvaluationResultError.extend({});
-const RuleEvaluationLexicalOverlapSpecification = {
-    };
-// SEMANTIC SIMILARITY
-const ruleEvaluationSemanticSimilarityConfiguration = ruleEvaluationConfiguration.extend({
-    algorithm: z.enum(['cosine_distance']),
-    minSimilarity: z.number().optional(), // Percentage of similarity
-    maxSimilarity: z.number().optional(), // Percentage of similarity
-});
-ruleEvaluationResultMetadata.extend({
-    configuration: ruleEvaluationSemanticSimilarityConfiguration,
-});
-ruleEvaluationResultError.extend({});
-const RuleEvaluationSemanticSimilaritySpecification = {
-    };
-// NUMERIC SIMILARITY
-const ruleEvaluationNumericSimilarityConfiguration = ruleEvaluationConfiguration.extend({
-    algorithm: z.enum(['relative_difference']),
-    minSimilarity: z.number().optional(), // Percentage of similarity
-    maxSimilarity: z.number().optional(), // Percentage of similarity
-});
-ruleEvaluationResultMetadata.extend({
-    configuration: ruleEvaluationNumericSimilarityConfiguration,
-});
-ruleEvaluationResultError.extend({});
-const RuleEvaluationNumericSimilaritySpecification = {
-    };
-/* ------------------------------------------------------------------------- */
-var RuleEvaluationMetric;
-(function (RuleEvaluationMetric) {
-    RuleEvaluationMetric["ExactMatch"] = "exact_match";
-    RuleEvaluationMetric["RegularExpression"] = "regular_expression";
-    RuleEvaluationMetric["SchemaValidation"] = "schema_validation";
-    RuleEvaluationMetric["LengthCount"] = "length_count";
-    RuleEvaluationMetric["LexicalOverlap"] = "lexical_overlap";
-    RuleEvaluationMetric["SemanticSimilarity"] = "semantic_similarity";
-    RuleEvaluationMetric["NumericSimilarity"] = "numeric_similarity";
-})(RuleEvaluationMetric || (RuleEvaluationMetric = {}));
-const RuleEvaluationSpecification = {
-    // prettier-ignore
-    metrics: {
-        [RuleEvaluationMetric.ExactMatch]: RuleEvaluationExactMatchSpecification,
-        [RuleEvaluationMetric.RegularExpression]: RuleEvaluationRegularExpressionSpecification,
-        [RuleEvaluationMetric.SchemaValidation]: RuleEvaluationSchemaValidationSpecification,
-        [RuleEvaluationMetric.LengthCount]: RuleEvaluationLengthCountSpecification,
-        [RuleEvaluationMetric.LexicalOverlap]: RuleEvaluationLexicalOverlapSpecification,
-        [RuleEvaluationMetric.SemanticSimilarity]: RuleEvaluationSemanticSimilaritySpecification,
-        [RuleEvaluationMetric.NumericSimilarity]: RuleEvaluationNumericSimilaritySpecification,
-    },
+// src/sdk/instrumentations.ts
+import { registerInstrumentations } from "@opentelemetry/instrumentation";
+import { AnthropicInstrumentation } from "@traceloop/instrumentation-anthropic";
+import { BedrockInstrumentation } from "@traceloop/instrumentation-bedrock";
+import { CohereInstrumentation } from "@traceloop/instrumentation-cohere";
+import { LangChainInstrumentation } from "@traceloop/instrumentation-langchain";
+import { LlamaIndexInstrumentation } from "@traceloop/instrumentation-llamaindex";
+import { OpenAIInstrumentation } from "@traceloop/instrumentation-openai";
+import { TogetherInstrumentation } from "@traceloop/instrumentation-together";
+import { AIPlatformInstrumentation, VertexAIInstrumentation } from "@traceloop/instrumentation-vertexai";
+var INSTRUMENTATION_MAP = {
+  openai: { ctor: OpenAIInstrumentation, moduleName: "openai", defaultEnrichTokens: true },
+  anthropic: { ctor: AnthropicInstrumentation, moduleName: "@anthropic-ai/sdk" },
+  bedrock: { ctor: BedrockInstrumentation, moduleName: "@aws-sdk/client-bedrock-runtime" },
+  cohere: { ctor: CohereInstrumentation, moduleName: "cohere-ai" },
+  langchain: { ctor: LangChainInstrumentation, moduleName: "langchain" },
+  llamaindex: { ctor: LlamaIndexInstrumentation, moduleName: "llamaindex" },
+  togetherai: { ctor: TogetherInstrumentation, moduleName: "together-ai", defaultEnrichTokens: false },
+  vertexai: { ctor: VertexAIInstrumentation, moduleName: "@google-cloud/vertexai" },
+  aiplatform: { ctor: AIPlatformInstrumentation, moduleName: "@google-cloud/aiplatform" }
 };
+async function createLatitudeInstrumentations(options) {
+  const result = [];
+  for (const type of options.instrumentations) {
+    const config = INSTRUMENTATION_MAP[type];
+    if (!config) {
+      console.warn(`[Latitude] Unknown instrumentation type: ${type}`);
+      continue;
+    }
+    const enrichTokens = options.enrichTokens?.[type] ?? config.defaultEnrichTokens;
+    const inst = new config.ctor(enrichTokens !== void 0 ? { enrichTokens } : void 0);
+    const moduleRef = options.modules?.[type] ?? await tryRequire(config.moduleName);
+    if (!moduleRef) {
+      console.warn(
+        `[Latitude] Module not found for ${type}: ${config.moduleName}. Install it or pass it explicitly in 'modules'.`
+      );
+      continue;
+    }
+    inst.manuallyInstrument?.(moduleRef);
+    result.push(inst);
+  }
+  return result;
+}
+async function tryRequire(moduleName) {
+  try {
+    return __require(moduleName);
+  } catch {
+    try {
+      const mod = await import(moduleName);
+      return mod.default ?? mod;
+    } catch {
+      return void 0;
+    }
+  }
+}
+async function registerLatitudeInstrumentations(options) {
+  const instrumentations = await createLatitudeInstrumentations(options);
+  registerInstrumentations({
+    instrumentations,
+    tracerProvider: options.tracerProvider
+  });
+}
 
-var EvaluationType;
-(function (EvaluationType) {
-    EvaluationType["Rule"] = "rule";
-    EvaluationType["Llm"] = "llm";
-    EvaluationType["Human"] = "human";
-    EvaluationType["Composite"] = "composite";
-})(EvaluationType || (EvaluationType = {}));
-const EvaluationTypeSchema = z.enum(EvaluationType);
-const EvaluationMetricSchema = z.union([
-    z.enum(RuleEvaluationMetric),
-    z.enum(LlmEvaluationMetric),
-    z.enum(HumanEvaluationMetric),
-    z.enum(CompositeEvaluationMetric),
-]);
-const EvaluationConfigurationSchema = z.custom();
-// prettier-ignore
-z.custom();
-// prettier-ignore
-z.custom();
-({
-    [EvaluationType.Rule]: RuleEvaluationSpecification,
-    [EvaluationType.Llm]: LlmEvaluationSpecification,
-    [EvaluationType.Human]: HumanEvaluationSpecification,
-    [EvaluationType.Composite]: CompositeEvaluationSpecification,
-});
-z.object({
-    name: z.string(),
-    description: z.string(),
-    type: EvaluationTypeSchema,
-    metric: EvaluationMetricSchema,
-    configuration: EvaluationConfigurationSchema,
-});
-z.object({
-    evaluateLiveLogs: z.boolean().nullable().optional(),
-});
-
-var ChainEventTypes;
-(function (ChainEventTypes) {
-    ChainEventTypes["ChainCompleted"] = "chain-completed";
-    ChainEventTypes["ChainError"] = "chain-error";
-    ChainEventTypes["ChainStarted"] = "chain-started";
-    ChainEventTypes["IntegrationWakingUp"] = "integration-waking-up";
-    ChainEventTypes["ProviderCompleted"] = "provider-completed";
-    ChainEventTypes["ProviderStarted"] = "provider-started";
-    ChainEventTypes["StepCompleted"] = "step-completed";
-    ChainEventTypes["StepStarted"] = "step-started";
-    ChainEventTypes["ToolCompleted"] = "tool-completed";
-    ChainEventTypes["ToolResult"] = "tool-result";
-    ChainEventTypes["ToolsStarted"] = "tools-started";
-})(ChainEventTypes || (ChainEventTypes = {}));
-
-z.object({
-    name: z.string(),
-    provider: z.string(),
-    model: z.string(),
-    temperature: z.number(),
-});
-// Experiment ran from a dataset
-const experimentDatasetSourceSchema = z.object({
-    source: z.literal('dataset'),
-    datasetId: z.number(),
-    fromRow: z.number(),
-    toRow: z.number(),
-    datasetLabels: z.record(z.string(), z.string()),
-    parametersMap: z.record(z.string(), z.number()),
-});
-// Experiment ran from last logs (from commit and creation time of experiment)
-const experimentLogsSourceSchema = z.object({
-    source: z.literal('logs'),
-    count: z.number(),
-});
-// Experiment ran with manual parameters (currently only used for prompts with no parameters)
-const experimentManualSourceSchema = z.object({
-    source: z.literal('manual'),
-    count: z.number(),
-    parametersMap: z.record(z.string(), z.number()),
-});
-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["Pipedream"] = "pipedream";
-    IntegrationType["HostedMCP"] = "mcp_server";
-})(IntegrationType || (IntegrationType = {}));
-var HostedIntegrationType;
-(function (HostedIntegrationType) {
-    HostedIntegrationType["Stripe"] = "stripe";
-    HostedIntegrationType["Slack"] = "slack";
-    HostedIntegrationType["Github"] = "github";
-    HostedIntegrationType["Notion"] = "notion";
-    HostedIntegrationType["Twitter"] = "twitter";
-    HostedIntegrationType["Airtable"] = "airtable";
-    HostedIntegrationType["Linear"] = "linear";
-    HostedIntegrationType["YoutubeCaptions"] = "youtube_captions";
-    HostedIntegrationType["Reddit"] = "reddit";
-    HostedIntegrationType["Telegram"] = "telegram";
-    HostedIntegrationType["Tinybird"] = "tinybird";
-    HostedIntegrationType["Perplexity"] = "perplexity";
-    HostedIntegrationType["AwsKbRetrieval"] = "aws_kb_retrieval";
-    HostedIntegrationType["BraveSearch"] = "brave_search";
-    HostedIntegrationType["EverArt"] = "ever_art";
-    HostedIntegrationType["Fetch"] = "fetch";
-    HostedIntegrationType["GitLab"] = "gitlab";
-    HostedIntegrationType["GoogleMaps"] = "google_maps";
-    HostedIntegrationType["Sentry"] = "sentry";
-    HostedIntegrationType["Puppeteer"] = "puppeteer";
-    HostedIntegrationType["Time"] = "time";
-    HostedIntegrationType["browserbase"] = "browserbase";
-    HostedIntegrationType["Neon"] = "neon";
-    HostedIntegrationType["Postgres"] = "postgres";
-    HostedIntegrationType["Supabase"] = "supabase";
-    HostedIntegrationType["Redis"] = "redis";
-    HostedIntegrationType["Jira"] = "jira";
-    HostedIntegrationType["Attio"] = "attio";
-    HostedIntegrationType["Ghost"] = "ghost";
-    HostedIntegrationType["Figma"] = "figma";
-    HostedIntegrationType["Hyperbrowser"] = "hyperbrowser";
-    HostedIntegrationType["Audiense"] = "audiense";
-    HostedIntegrationType["Apify"] = "apify";
-    HostedIntegrationType["Exa"] = "exa";
-    HostedIntegrationType["YepCode"] = "yepcode";
-    HostedIntegrationType["Monday"] = "monday";
-    HostedIntegrationType["AgentQL"] = "agentql";
-    HostedIntegrationType["AgentRPC"] = "agentrpc";
-    HostedIntegrationType["AstraDB"] = "astra_db";
-    HostedIntegrationType["Bankless"] = "bankless";
-    HostedIntegrationType["Bicscan"] = "bicscan";
-    HostedIntegrationType["Chargebee"] = "chargebee";
-    HostedIntegrationType["Chronulus"] = "chronulus";
-    HostedIntegrationType["CircleCI"] = "circleci";
-    HostedIntegrationType["Codacy"] = "codacy";
-    HostedIntegrationType["CodeLogic"] = "codelogic";
-    HostedIntegrationType["Convex"] = "convex";
-    HostedIntegrationType["Dart"] = "dart";
-    HostedIntegrationType["DevHubCMS"] = "devhub_cms";
-    HostedIntegrationType["Elasticsearch"] = "elasticsearch";
-    HostedIntegrationType["ESignatures"] = "esignatures";
-    HostedIntegrationType["Fewsats"] = "fewsats";
-    HostedIntegrationType["Firecrawl"] = "firecrawl";
-    HostedIntegrationType["Graphlit"] = "graphlit";
-    HostedIntegrationType["Heroku"] = "heroku";
-    HostedIntegrationType["IntegrationAppHubspot"] = "integration_app_hubspot";
-    HostedIntegrationType["LaraTranslate"] = "lara_translate";
-    HostedIntegrationType["Logfire"] = "logfire";
-    HostedIntegrationType["Langfuse"] = "langfuse";
-    HostedIntegrationType["LingoSupabase"] = "lingo_supabase";
-    HostedIntegrationType["Make"] = "make";
-    HostedIntegrationType["Meilisearch"] = "meilisearch";
-    HostedIntegrationType["Momento"] = "momento";
-    HostedIntegrationType["Neo4jAura"] = "neo4j_aura";
-    HostedIntegrationType["Octagon"] = "octagon";
-    HostedIntegrationType["Paddle"] = "paddle";
-    HostedIntegrationType["PayPal"] = "paypal";
-    HostedIntegrationType["Qdrant"] = "qdrant";
-    HostedIntegrationType["Raygun"] = "raygun";
-    HostedIntegrationType["Rember"] = "rember";
-    HostedIntegrationType["Riza"] = "riza";
-    HostedIntegrationType["Search1API"] = "search1api";
-    HostedIntegrationType["Semgrep"] = "semgrep";
-    HostedIntegrationType["Tavily"] = "tavily";
-    HostedIntegrationType["Unstructured"] = "unstructured";
-    HostedIntegrationType["Vectorize"] = "vectorize";
-    HostedIntegrationType["Xero"] = "xero";
-    HostedIntegrationType["Readwise"] = "readwise";
-    HostedIntegrationType["Airbnb"] = "airbnb";
-    HostedIntegrationType["Mintlify"] = "mintlify";
-    // Require all auth file :point_down:
-    // Gmail = 'google_drive',
-    // GoogleCalendar = 'google_drive',
-    // GoogleDrive = 'google_drive',
-    // GoogleWorkspace = 'google_workspace', // env vars not supported (?)
-    // TODO: implement these
-    // Wordpress = 'wordpress', // Not on OpenTools
-    // Discord = 'discord', // Not on OpenTools
-    // Intercom = 'intercom', // Not on OpenTools
-    // Hubspot = 'hubspot', // Docker based
-    // Loops = 'loops', // Does not exist
-})(HostedIntegrationType || (HostedIntegrationType = {}));
-
-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["Optimization"] = "optimization";
-})(LogSources || (LogSources = {}));
-
-var RunSourceGroup;
-(function (RunSourceGroup) {
-    RunSourceGroup["Production"] = "production";
-    RunSourceGroup["Playground"] = "playground";
-})(RunSourceGroup || (RunSourceGroup = {}));
-({
-    [RunSourceGroup.Production]: [
-        LogSources.API,
-        LogSources.ShadowTest,
-        LogSources.ABTestChallenger,
-        LogSources.EmailTrigger,
-        LogSources.IntegrationTrigger,
-        LogSources.ScheduledTrigger,
-        LogSources.SharedPrompt,
-        LogSources.User,
-    ],
-    [RunSourceGroup.Playground]: [LogSources.Playground, LogSources.Experiment],
-});
+// src/sdk/processor.ts
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import {
+  BatchSpanProcessor,
+  SimpleSpanProcessor
+} from "@opentelemetry/sdk-trace-node";
 
-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) {
-    // Latitude wrappers
-    SpanType["Prompt"] = "prompt";
-    SpanType["Chat"] = "chat";
-    SpanType["External"] = "external";
-    SpanType["UnresolvedExternal"] = "unresolved_external";
-    // Added a HTTP span to capture raw HTTP requests and responses when running from Latitude
-    SpanType["Http"] = "http";
-    // Any known span from supported specifications will be grouped into one of these types
-    SpanType["Completion"] = "completion";
-    SpanType["Tool"] = "tool";
-    SpanType["Embedding"] = "embedding";
-    SpanType["Unknown"] = "unknown";
-})(SpanType || (SpanType = {}));
-[
-    SpanType.Prompt,
-    SpanType.External,
-    SpanType.Chat,
-];
-const SPAN_SPECIFICATIONS = {
-    [SpanType.Prompt]: {
-        name: 'Prompt',
-        description: 'A prompt span',
-        isGenAI: false,
-        isHidden: false,
-    },
-    [SpanType.Chat]: {
-        name: 'Chat',
-        description: 'A chat continuation span',
-        isGenAI: false,
-        isHidden: false,
-    },
-    [SpanType.External]: {
-        name: 'External',
-        description: 'An external capture span',
-        isGenAI: false,
-        isHidden: false,
-    },
-    [SpanType.UnresolvedExternal]: {
-        name: 'Unresolved External',
-        description: 'An external span that needs path resolution before storage',
-        isGenAI: false,
-        isHidden: true,
-    },
-    [SpanType.Completion]: {
-        name: 'Completion',
-        description: 'A completion call',
-        isGenAI: true,
-        isHidden: false,
-    },
-    [SpanType.Embedding]: {
-        name: 'Embedding',
-        description: 'An embedding call',
-        isGenAI: true,
-        isHidden: false,
-    },
-    [SpanType.Tool]: {
-        name: 'Tool',
-        description: 'A tool 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,
-    },
+// src/constants/attributes.ts
+var ATTRIBUTES = {
+  name: "latitude.capture.name",
+  tags: "latitude.tags",
+  metadata: "latitude.metadata",
+  sessionId: "session.id",
+  userId: "user.id"
 };
-var SpanStatus;
-(function (SpanStatus) {
-    SpanStatus["Unset"] = "unset";
-    SpanStatus["Ok"] = "ok";
-    SpanStatus["Error"] = "error";
-})(SpanStatus || (SpanStatus = {}));
-new Set([
-    SpanType.Prompt,
-    SpanType.Chat,
-    SpanType.External,
-]);
 
-// Note: Traces are unmaterialized but this context is used to propagate the trace
-// See www.w3.org/TR/trace-context and w3c.github.io/baggage
-z.object({
-    traceparent: z.string(), // <version>-<trace-id>-<span-id>-<trace-flags>
-    tracestate: z.string().optional(), // <key>=urlencoded(<value>)[,<key>=urlencoded(<value>)]*
-    baggage: z.string().optional(), // <key>=urlencoded(<value>)[,<key>=urlencoded(<value>)]*
-});
+// src/constants/scope.ts
+var SCOPE_LATITUDE = "so.latitude.instrumentation";
 
-const ATTRIBUTES = {
-    // Custom attributes added and used by Latitude spans (Prompt / External / Chat)
-    LATITUDE: {
-        type: 'latitude.type',
-        documentUuid: 'latitude.document_uuid',
-        promptPath: 'latitude.prompt_path',
-        commitUuid: 'latitude.commit_uuid',
-        documentLogUuid: 'latitude.document_log_uuid',
-        projectId: 'latitude.project_id',
-        experimentUuid: 'latitude.experiment_uuid',
-        source: 'latitude.source',
-        externalId: 'latitude.external_id',
-        testDeploymentId: 'latitude.test_deployment_id',
-        previousTraceId: 'latitude.previous_trace_id',
-        // Custom additions to the GenAI semantic conventions (deprecated)
-        request: {
-            _root: 'gen_ai.request',
-            configuration: 'gen_ai.request.configuration',
-            template: 'gen_ai.request.template',
-            parameters: 'gen_ai.request.parameters'},
-        response: {
-            _root: 'gen_ai.response'},
-        usage: {
-            promptTokens: 'gen_ai.usage.prompt_tokens',
-            cachedTokens: 'gen_ai.usage.cached_tokens',
-            reasoningTokens: 'gen_ai.usage.reasoning_tokens',
-            completionTokens: 'gen_ai.usage.completion_tokens',
-        },
-    },
-    // Official OpenTelemetry semantic conventions
-    OPENTELEMETRY: {
-        HTTP: {
-            request: {
-                url: 'http.request.url',
-                body: 'http.request.body',
-                header: 'http.request.header',
-                method: ATTR_HTTP_REQUEST_METHOD,
-            },
-            response: {
-                body: 'http.response.body',
-                header: 'http.response.header',
-                statusCode: ATTR_HTTP_RESPONSE_STATUS_CODE,
-            },
-        },
-        // GenAI semantic conventions
-        // https://opentelemetry.io/docs/specs/semconv/gen-ai/gen-ai-spans/
-        GEN_AI: {
-            operation: ATTR_GEN_AI_OPERATION_NAME,
-            response: {
-                model: ATTR_GEN_AI_RESPONSE_MODEL,
-                finishReasons: ATTR_GEN_AI_RESPONSE_FINISH_REASONS,
-            },
-            usage: {
-                inputTokens: ATTR_GEN_AI_USAGE_INPUT_TOKENS,
-                outputTokens: ATTR_GEN_AI_USAGE_OUTPUT_TOKENS,
-            },
-            systemInstructions: 'gen_ai.system.instructions', // Contains the PARTS of the "system message"
-            tool: {
-                call: {
-                    id: ATTR_GEN_AI_TOOL_CALL_ID,
-                    arguments: 'gen_ai.tool.call.arguments'}},
-            input: {
-                messages: 'gen_ai.input.messages',
-            },
-            output: {
-                messages: 'gen_ai.output.messages',
-            },
-            _deprecated: {
-                system: ATTR_GEN_AI_SYSTEM,
-                tool: {
-                    name: ATTR_GEN_AI_TOOL_NAME,
-                    type: ATTR_GEN_AI_TOOL_TYPE,
-                    result: {
-                        value: 'gen_ai.tool.result.value',
-                        isError: 'gen_ai.tool.result.is_error',
-                    },
-                }},
-        },
-    }};
-const VALUES = {
-    OPENTELEMETRY: {
-        GEN_AI: {
-            response: {
-                finishReasons: {
-                    stop: 'stop',
-                    toolCalls: 'tool_calls'},
-            },
-            tool: {
-                type: {
-                    function: 'function',
-                },
-            }},
-    }};
+// src/env/env.ts
+var DEFAULT_EXPORTER_URL = {
+  production: "https://ingest.latitude.so",
+  development: "http://localhost:3002",
+  test: "http://localhost:3002"
+}[process.env.NODE_ENV ?? "development"] ?? "http://localhost:3002";
+function getExporterUrl() {
+  if (process.env.LATITUDE_TELEMETRY_URL) {
+    return process.env.LATITUDE_TELEMETRY_URL;
+  }
+  return DEFAULT_EXPORTER_URL;
+}
+var env = { EXPORTER_URL: getExporterUrl() };
 
-/* 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: Schemas for span ingestion following OpenTelemetry service request specification */
-var Otlp;
-(function (Otlp) {
-    Otlp.attributeValueSchema = z.object({
-        stringValue: z.string().optional(),
-        intValue: z.number().optional(),
-        boolValue: z.boolean().optional(),
-        arrayValue: z
-            .object({
-            values: z.array(z.object({
-                stringValue: z.string().optional(),
-                intValue: z.number().optional(),
-                boolValue: z.boolean().optional(),
-            })),
-        })
-            .optional(),
-    });
-    Otlp.attributeSchema = z.object({
-        key: z.string(),
-        value: Otlp.attributeValueSchema,
-    });
-    Otlp.eventSchema = z.object({
-        name: z.string(),
-        timeUnixNano: z.string(),
-        attributes: z.array(Otlp.attributeSchema).optional(),
-    });
-    Otlp.linkSchema = z.object({
-        traceId: z.string(),
-        spanId: z.string(),
-        attributes: 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 = z.object({
-        code: z.number(),
-        message: z.string().optional(),
+// src/sdk/redact.ts
+var RedactSpanProcessor = class {
+  options;
+  constructor(options) {
+    this.options = options;
+    if (!options.mask) {
+      this.options.mask = (_attribute, _value) => "******";
+    }
+  }
+  onStart(_span, _context) {
+  }
+  onEnd(span) {
+    Object.assign(span.attributes, this.redactAttributes(span.attributes));
+    for (const event of span.events) {
+      if (!event.attributes) continue;
+      Object.assign(event.attributes, this.redactAttributes(event.attributes));
+    }
+    for (const link of span.links) {
+      if (!link.attributes) continue;
+      Object.assign(link.attributes, this.redactAttributes(link.attributes));
+    }
+  }
+  forceFlush() {
+    return Promise.resolve();
+  }
+  shutdown() {
+    return Promise.resolve();
+  }
+  shouldRedact(attribute) {
+    return this.options.attributes.some((pattern) => {
+      if (typeof pattern === "string") {
+        return attribute === pattern;
+      } else if (pattern instanceof RegExp) {
+        return pattern.test(attribute);
+      }
+      return false;
     });
-    (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 = z.object({
-        traceId: z.string(),
-        spanId: z.string(),
-        parentSpanId: z.string().optional(),
-        name: z.string(),
-        kind: z.number(),
-        startTimeUnixNano: z.string(),
-        endTimeUnixNano: z.string(),
-        status: Otlp.statusSchema.optional(),
-        events: z.array(Otlp.eventSchema).optional(),
-        links: z.array(Otlp.linkSchema).optional(),
-        attributes: z.array(Otlp.attributeSchema).optional(),
-    });
-    Otlp.scopeSchema = z.object({
-        name: z.string(),
-        version: z.string().optional(),
-    });
-    Otlp.scopeSpanSchema = z.object({
-        scope: Otlp.scopeSchema,
-        spans: z.array(Otlp.spanSchema),
-    });
-    Otlp.resourceSchema = z.object({
-        attributes: z.array(Otlp.attributeSchema),
-    });
-    Otlp.resourceSpanSchema = z.object({
-        resource: Otlp.resourceSchema,
-        scopeSpans: z.array(Otlp.scopeSpanSchema),
-    });
-    Otlp.serviceRequestSchema = z.object({
-        resourceSpans: z.array(Otlp.resourceSpanSchema),
-    });
-})(Otlp || (Otlp = {}));
-
-const MAX_SIMULATION_TURNS = 10;
-const globalGoalSourceSchema = z.object({
-    type: z.literal('global'),
-    value: z.string(),
-});
-const columnGoalSourceSchema = z.object({
-    type: z.literal('column'),
-    columnIndex: z.number(),
-});
-const simulatedUserGoalSourceSchema = z.discriminatedUnion('type', [
-    globalGoalSourceSchema,
-    columnGoalSourceSchema,
-]);
-const SimulationSettingsSchema = z.object({
-    simulateToolResponses: z.boolean().optional(),
-    simulatedTools: z.array(z.string()).optional(), // Empty array means all tools are simulated (if simulateToolResponses is true).
-    toolSimulationInstructions: z.string().optional(), // A prompt used to guide and generate the simulation result
-    maxTurns: z.number().min(1).max(MAX_SIMULATION_TURNS).optional(), // The maximum number of turns to simulate. Default is 1, and any greater value will add a new user message to the simulated conversation.
-    simulatedUserGoal: z.string().optional(), // Deprecated: Use simulatedUserGoalSource instead. Kept for backward compatibility.
-    simulatedUserGoalSource: simulatedUserGoalSourceSchema.optional(), // The source for the simulated user goal (global text or dataset column).
-});
-
-var OptimizationEngine;
-(function (OptimizationEngine) {
-    OptimizationEngine["Identity"] = "identity";
-    OptimizationEngine["Gepa"] = "gepa";
-})(OptimizationEngine || (OptimizationEngine = {}));
-const OptimizationBudgetSchema = z.object({
-    time: z.number().min(0).optional(),
-    tokens: z.number().min(0).optional(),
-});
-z.object({
-    dataset: z
-        .object({
-        target: z.number().min(0).optional(), // Note: number of rows to curate when not provided by the user
-        label: z.string().optional(), // Note: expected output column when using a labeled evaluation
-    })
-        .optional(),
-    parameters: z
-        .record(z.string(), z.object({
-        column: z.string().optional(), // Note: corresponding column in the user-provided trainset and testset
-        isPii: z.boolean().optional(),
-    }))
-        .optional(),
-    simulation: SimulationSettingsSchema.optional(),
-    scope: z
-        .object({
-        configuration: z.boolean().optional(),
-        instructions: z.boolean().optional(),
-    })
-        .optional(),
-    budget: OptimizationBudgetSchema.optional(),
-});
-
-// TODO(tracing): deprecated
-const HEAD_COMMIT = 'live';
-var Providers;
-(function (Providers) {
-    Providers["OpenAI"] = "openai";
-    Providers["Anthropic"] = "anthropic";
-    Providers["Groq"] = "groq";
-    Providers["Mistral"] = "mistral";
-    Providers["Azure"] = "azure";
-    Providers["Google"] = "google";
-    Providers["GoogleVertex"] = "google_vertex";
-    Providers["AnthropicVertex"] = "anthropic_vertex";
-    Providers["Custom"] = "custom";
-    Providers["XAI"] = "xai";
-    Providers["AmazonBedrock"] = "amazon_bedrock";
-    Providers["DeepSeek"] = "deepseek";
-    Providers["Perplexity"] = "perplexity";
-})(Providers || (Providers = {}));
-var DocumentType;
-(function (DocumentType) {
-    DocumentType["Prompt"] = "prompt";
-    DocumentType["Agent"] = "agent";
-})(DocumentType || (DocumentType = {}));
-var DocumentTriggerType;
-(function (DocumentTriggerType) {
-    DocumentTriggerType["Email"] = "email";
-    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";
-    DocumentTriggerParameters["SenderName"] = "senderName";
-    DocumentTriggerParameters["Subject"] = "subject";
-    DocumentTriggerParameters["Body"] = "body";
-    DocumentTriggerParameters["Attachments"] = "attachments";
-})(DocumentTriggerParameters || (DocumentTriggerParameters = {}));
-const DOCUMENT_PATH_REGEXP = /^([\w-]+\/)*([\w-.])+$/;
-
-const translator = new Translator({
-    filterEmptyMessages: true,
-    providerMetadata: 'preserve',
+  }
+  redactAttributes(attributes) {
+    const redacted = {};
+    for (const [key, value] of Object.entries(attributes)) {
+      if (this.shouldRedact(key)) {
+        redacted[key] = this.options.mask?.(key, value);
+      }
+    }
+    return redacted;
+  }
+};
+var DEFAULT_REDACT_SPAN_PROCESSOR = () => new RedactSpanProcessor({
+  attributes: [
+    // HTTP security headers
+    /^http\.request\.header\.authorization$/i,
+    /^http\.request\.header\.cookie$/i,
+    /^http\.request\.header\.x[-_]api[-_]key$/i,
+    // Database statements may contain sensitive data
+    /^db\.statement$/i
+  ]
 });
-class ManualInstrumentation {
-    enabled;
-    tracer;
-    options;
-    constructor(tracer, options) {
-        this.enabled = false;
-        this.tracer = tracer;
-        this.options = options ?? {};
-    }
-    isEnabled() {
-        return this.enabled;
-    }
-    enable() {
-        this.enabled = true;
-    }
-    disable() {
-        this.enabled = false;
-    }
-    resume(ctx) {
-        const parts = ctx.traceparent.split('-');
-        if (parts.length !== 4) {
-            return otel.ROOT_CONTEXT;
-        }
-        const [, traceId, spanId, flags] = parts;
-        if (!traceId || !spanId) {
-            return otel.ROOT_CONTEXT;
-        }
-        const spanContext = {
-            traceId,
-            spanId,
-            traceFlags: parseInt(flags ?? '01', 16),
-            isRemote: true,
-        };
-        let context = trace.setSpanContext(otel.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 = propagation.createBaggage(baggageEntries);
-            context = propagation.setBaggage(context, baggage);
-        }
-        return context;
-    }
-    error(span, error, options) {
-        options = options || {};
-        span.recordException(error);
-        span.setAttributes(options.attributes || {});
-        span.setStatus({
-            code: otel.SpanStatusCode.ERROR,
-            message: error.message || undefined,
-        });
-        span.end();
-    }
-    span(ctx, name, type, options) {
-        if (!this.enabled) {
-            return {
-                context: ctx,
-                end: (_options) => { },
-                fail: (_error, _options) => { },
-            };
-        }
-        const start = options || {};
-        let operation = undefined;
-        if (SPAN_SPECIFICATIONS[type].isGenAI) {
-            operation = type;
-        }
-        const span = this.tracer.startSpan(name, {
-            attributes: {
-                [ATTRIBUTES.LATITUDE.type]: type,
-                ...(operation && {
-                    [ATTRIBUTES.OPENTELEMETRY.GEN_AI.operation]: operation,
-                }),
-                ...(start.attributes || {}),
-            },
-            kind: otel.SpanKind.CLIENT,
-        }, ctx);
-        const newCtx = trace.setSpan(ctx, span);
-        return {
-            context: newCtx,
-            end: (options) => {
-                const end = options || {};
-                span.setAttributes(end.attributes || {});
-                span.setStatus({ code: otel.SpanStatusCode.OK });
-                span.end();
-            },
-            fail: (error, options) => {
-                this.error(span, error, options);
-            },
-        };
-    }
-    unknown(ctx, options) {
-        return this.span(ctx, options?.name || SPAN_SPECIFICATIONS[SpanType.Unknown].name, SpanType.Unknown, options);
-    }
-    tool(ctx, options) {
-        const start = options;
-        let jsonArguments = '';
-        try {
-            jsonArguments = JSON.stringify(start.call.arguments);
-        }
-        catch (_error) {
-            jsonArguments = '{}';
-        }
-        const span = this.span(ctx, start.name, SpanType.Tool, {
-            attributes: {
-                [ATTRIBUTES.OPENTELEMETRY.GEN_AI._deprecated.tool.name]: start.name,
-                [ATTRIBUTES.OPENTELEMETRY.GEN_AI._deprecated.tool.type]: VALUES.OPENTELEMETRY.GEN_AI.tool.type.function,
-                [ATTRIBUTES.OPENTELEMETRY.GEN_AI.tool.call.id]: start.call.id,
-                [ATTRIBUTES.OPENTELEMETRY.GEN_AI.tool.call.arguments]: jsonArguments,
-                ...(start.attributes || {}),
-            },
-        });
-        return {
-            ...span,
-            end: (options) => {
-                const end = options;
-                let stringResult = '';
-                if (typeof end.result.value !== 'string') {
-                    try {
-                        stringResult = JSON.stringify(end.result.value);
-                    }
-                    catch (_error) {
-                        stringResult = '{}';
-                    }
-                }
-                else {
-                    stringResult = end.result.value;
-                }
-                span.end({
-                    attributes: {
-                        [ATTRIBUTES.OPENTELEMETRY.GEN_AI._deprecated.tool.result.value]: stringResult,
-                        [ATTRIBUTES.OPENTELEMETRY.GEN_AI._deprecated.tool.result.isError]: end.result.isError,
-                        ...(end.attributes || {}),
-                    },
-                });
-            },
-        };
-    }
-    attribifyConfiguration(direction, configuration) {
-        const prefix = direction === 'input'
-            ? ATTRIBUTES.LATITUDE.request._root
-            : ATTRIBUTES.LATITUDE.response._root;
-        const attributes = {};
-        for (const key in configuration) {
-            const field = toSnakeCase(key);
-            let value = configuration[key];
-            if (value === null || value === undefined)
-                continue;
-            if (typeof value === 'object' && !Array.isArray(value)) {
-                try {
-                    value = JSON.stringify(value);
-                }
-                catch (_error) {
-                    value = '{}';
-                }
-            }
-            attributes[`${prefix}.${field}`] = value;
-        }
-        return attributes;
-    }
-    completion(ctx, options) {
-        const start = options;
-        const configuration = {
-            ...(start.configuration ?? {}),
-            model: start.model,
-        };
-        let jsonConfiguration = '';
-        try {
-            jsonConfiguration = JSON.stringify(configuration);
-        }
-        catch (_error) {
-            jsonConfiguration = '{}';
-        }
-        const attrConfiguration = this.attribifyConfiguration('input', configuration);
-        const input = start.input ?? [];
-        let jsonSystem = '';
-        let jsonInput = '';
-        try {
-            const translated = translator.translate(input, {
-                from: this.options.provider,
-                to: Provider.GenAI,
-                direction: 'input',
-            });
-            jsonSystem = JSON.stringify(translated.system ?? []);
-            jsonInput = JSON.stringify(translated.messages ?? []);
-        }
-        catch (_error) {
-            jsonSystem = '[]';
-            jsonInput = '[]';
-        }
-        const span = this.span(ctx, start.name || `${start.provider} / ${start.model}`, SpanType.Completion, {
-            attributes: {
-                [ATTRIBUTES.OPENTELEMETRY.GEN_AI._deprecated.system]: start.provider,
-                [ATTRIBUTES.LATITUDE.request.configuration]: jsonConfiguration,
-                ...attrConfiguration,
-                [ATTRIBUTES.OPENTELEMETRY.GEN_AI.systemInstructions]: jsonSystem,
-                [ATTRIBUTES.OPENTELEMETRY.GEN_AI.input.messages]: jsonInput,
-                ...(start.attributes || {}),
-                [ATTRIBUTES.LATITUDE.commitUuid]: start.versionUuid,
-                [ATTRIBUTES.LATITUDE.documentUuid]: start.promptUuid,
-                [ATTRIBUTES.LATITUDE.experimentUuid]: start.experimentUuid,
-            },
-        });
-        return {
-            ...span,
-            end: (options) => {
-                const end = options ?? {};
-                const output = end.output ?? [];
-                let jsonOutput = '';
-                try {
-                    const translated = translator.translate(output, {
-                        from: this.options.provider,
-                        to: Provider.GenAI,
-                        direction: 'output',
-                    });
-                    jsonOutput = JSON.stringify(translated.messages ?? []);
-                }
-                catch (_error) {
-                    jsonOutput = '[]';
-                }
-                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: {
-                        [ATTRIBUTES.OPENTELEMETRY.GEN_AI.output.messages]: jsonOutput,
-                        [ATTRIBUTES.OPENTELEMETRY.GEN_AI.usage.inputTokens]: inputTokens,
-                        [ATTRIBUTES.OPENTELEMETRY.GEN_AI.usage.outputTokens]: outputTokens,
-                        [ATTRIBUTES.LATITUDE.usage.promptTokens]: tokens.prompt,
-                        [ATTRIBUTES.LATITUDE.usage.cachedTokens]: tokens.cached,
-                        [ATTRIBUTES.LATITUDE.usage.reasoningTokens]: tokens.reasoning,
-                        [ATTRIBUTES.LATITUDE.usage.completionTokens]: tokens.completion,
-                        [ATTRIBUTES.OPENTELEMETRY.GEN_AI.response.model]: start.model,
-                        [ATTRIBUTES.OPENTELEMETRY.GEN_AI.response.finishReasons]: [
-                            finishReason,
-                        ],
-                        ...(end.attributes || {}),
-                    },
-                });
-            },
-        };
-    }
-    embedding(ctx, options) {
-        return this.span(ctx, options?.name || SPAN_SPECIFICATIONS[SpanType.Embedding].name, SpanType.Embedding, options);
-    }
-    attribifyHeaders(direction, headers) {
-        const prefix = direction === 'request'
-            ? ATTRIBUTES.OPENTELEMETRY.HTTP.request.header
-            : ATTRIBUTES.OPENTELEMETRY.HTTP.response.header;
-        const attributes = {};
-        for (const key in headers) {
-            const field = toKebabCase(key);
-            const value = headers[key];
-            if (value === null || value === undefined)
-                continue;
-            attributes[`${prefix}.${field}`] = value;
-        }
-        return attributes;
-    }
-    http(ctx, options) {
-        const start = options;
-        const method = start.request.method.toUpperCase();
-        // Note: do not serialize headers as a single attribute because fields won't be redacted
-        const attrHeaders = this.attribifyHeaders('request', start.request.headers);
-        let finalBody = '';
-        if (typeof start.request.body === 'string') {
-            finalBody = start.request.body;
-        }
-        else {
-            try {
-                finalBody = JSON.stringify(start.request.body);
-            }
-            catch (_error) {
-                finalBody = '{}';
-            }
-        }
-        const span = this.span(ctx, start.name || `${method} ${start.request.url}`, SpanType.Http, {
-            attributes: {
-                [ATTRIBUTES.OPENTELEMETRY.HTTP.request.method]: method,
-                [ATTRIBUTES.OPENTELEMETRY.HTTP.request.url]: start.request.url,
-                ...attrHeaders,
-                [ATTRIBUTES.OPENTELEMETRY.HTTP.request.body]: finalBody,
-                ...(start.attributes || {}),
-            },
-        });
-        return {
-            ...span,
-            end: (options) => {
-                const end = options;
-                // Note: do not serialize headers as a single attribute because fields won't be redacted
-                const attrHeaders = this.attribifyHeaders('response', end.response.headers);
-                let finalBody = '';
-                if (typeof end.response.body === 'string') {
-                    finalBody = end.response.body;
-                }
-                else {
-                    try {
-                        finalBody = JSON.stringify(end.response.body);
-                    }
-                    catch (_error) {
-                        finalBody = '{}';
-                    }
-                }
-                span.end({
-                    attributes: {
-                        [ATTRIBUTES.OPENTELEMETRY.HTTP.response.statusCode]: end.response.status,
-                        ...attrHeaders,
-                        [ATTRIBUTES.OPENTELEMETRY.HTTP.response.body]: finalBody,
-                        ...(end.attributes || {}),
-                    },
-                });
-            },
-        };
-    }
-    prompt(ctx, { documentLogUuid, versionUuid, promptUuid, projectId, experimentUuid, testDeploymentId, externalId, template, parameters, name, source, ...rest }) {
-        let jsonParameters = '';
-        try {
-            jsonParameters = JSON.stringify(parameters || {});
-        }
-        catch (_error) {
-            jsonParameters = '{}';
-        }
-        const attributes = {
-            [ATTRIBUTES.LATITUDE.request.template]: template,
-            [ATTRIBUTES.LATITUDE.request.parameters]: jsonParameters,
-            [ATTRIBUTES.LATITUDE.commitUuid]: versionUuid || HEAD_COMMIT,
-            [ATTRIBUTES.LATITUDE.documentUuid]: promptUuid,
-            [ATTRIBUTES.LATITUDE.projectId]: projectId,
-            [ATTRIBUTES.LATITUDE.documentLogUuid]: documentLogUuid,
-            ...(experimentUuid && {
-                [ATTRIBUTES.LATITUDE.experimentUuid]: experimentUuid,
-            }),
-            ...(testDeploymentId && {
-                [ATTRIBUTES.LATITUDE.testDeploymentId]: testDeploymentId,
-            }),
-            ...(externalId && { [ATTRIBUTES.LATITUDE.externalId]: externalId }),
-            ...(source && { [ATTRIBUTES.LATITUDE.source]: source }),
-            ...(rest.attributes || {}),
-        };
-        return this.span(ctx, name || `prompt-${promptUuid}`, SpanType.Prompt, {
-            attributes,
-        });
-    }
-    chat(ctx, { documentLogUuid, previousTraceId, source, name, versionUuid, promptUuid, ...rest }) {
-        const attributes = {
-            [ATTRIBUTES.LATITUDE.documentLogUuid]: documentLogUuid,
-            [ATTRIBUTES.LATITUDE.previousTraceId]: previousTraceId,
-            ...(versionUuid && { [ATTRIBUTES.LATITUDE.commitUuid]: versionUuid }),
-            ...(promptUuid && { [ATTRIBUTES.LATITUDE.documentUuid]: promptUuid }),
-            ...(source && { [ATTRIBUTES.LATITUDE.source]: source }),
-            ...(rest.attributes || {}),
-        };
-        return this.span(ctx, name || `chat-${documentLogUuid}`, SpanType.Chat, {
-            attributes,
-        });
-    }
-    external(ctx, { promptUuid, documentLogUuid, source, versionUuid, externalId, name, ...rest }) {
-        const attributes = {
-            [ATTRIBUTES.LATITUDE.documentUuid]: promptUuid,
-            [ATTRIBUTES.LATITUDE.documentLogUuid]: documentLogUuid,
-            [ATTRIBUTES.LATITUDE.source]: source ?? LogSources.API,
-            ...(versionUuid && { [ATTRIBUTES.LATITUDE.commitUuid]: versionUuid }),
-            ...(externalId && { [ATTRIBUTES.LATITUDE.externalId]: externalId }),
-            ...(rest.attributes || {}),
-        };
-        return this.span(ctx, name || `external-${promptUuid}`, SpanType.External, {
-            attributes,
-        });
-    }
-    // TODO(tracing): deprecate
-    unresolvedExternal(ctx, { path, projectId, versionUuid, conversationUuid, name, ...rest }) {
-        const attributes = {
-            [ATTRIBUTES.LATITUDE.promptPath]: path,
-            [ATTRIBUTES.LATITUDE.projectId]: projectId,
-            ...(versionUuid && { [ATTRIBUTES.LATITUDE.commitUuid]: versionUuid }),
-            ...(conversationUuid && {
-                [ATTRIBUTES.LATITUDE.documentLogUuid]: conversationUuid,
-            }),
-            ...(rest.attributes || {}),
-        };
-        return this.span(ctx, name || `capture-${path}`, SpanType.UnresolvedExternal, { attributes });
-    }
-}
-
-class LatitudeInstrumentation {
-    options;
-    manualTelemetry;
-    constructor(tracer, options) {
-        this.manualTelemetry = new ManualInstrumentation(tracer);
-        this.options = options;
-    }
-    isEnabled() {
-        return this.manualTelemetry.isEnabled();
-    }
-    enable() {
-        this.manualTelemetry.enable();
-        this.options.module.instrument(this);
-    }
-    disable() {
-        this.manualTelemetry.disable();
-        this.options.module.uninstrument();
-    }
-    countTokens(messages) {
-        let length = 0;
-        for (const message of messages) {
-            if (!('content' in message))
-                continue;
-            if (typeof message.content === 'string') {
-                length += message.content.length;
-            }
-            else if (Array.isArray(message.content)) {
-                for (const content of message.content) {
-                    if (content.type === 'text') {
-                        length += content.text.length;
-                    }
-                }
-            }
-        }
-        // Note: this is an estimation to not bundle a tokenizer
-        return Math.ceil(length / 4);
-    }
-    async wrapRenderChain(fn, ...args) {
-        const { prompt, parameters } = args[0];
-        const $prompt = this.manualTelemetry.prompt(context.active(), {
-            documentLogUuid: v4(),
-            versionUuid: prompt.versionUuid,
-            promptUuid: prompt.uuid,
-            template: prompt.content,
-            parameters: parameters,
-        });
-        let result;
-        try {
-            result = await context.with($prompt.context, async () => await fn(...args));
-        }
-        catch (error) {
-            $prompt.fail(error);
-            throw error;
-        }
-        $prompt.end();
-        return result;
-    }
-    async wrapRenderCompletion(fn, ...args) {
-        if (!this.options.completions) {
-            return await fn(...args);
-        }
-        const { provider, config, messages } = args[0];
-        const model = config.model || 'unknown';
-        const $completion = this.manualTelemetry.completion(context.active(), {
-            name: `${provider} / ${model}`,
-            provider: provider,
-            model: model,
-            configuration: config,
-            input: messages,
-        });
-        let result;
-        try {
-            result = await context.with($completion.context, async () => await fn(...args));
-        }
-        catch (error) {
-            $completion.fail(error);
-            throw error;
-        }
-        // Note: enhance, this is just an estimation
-        const promptTokens = this.countTokens(messages);
-        const completionTokens = this.countTokens(result.messages);
-        $completion.end({
-            output: result.messages,
-            tokens: {
-                prompt: promptTokens,
-                cached: 0,
-                reasoning: 0,
-                completion: completionTokens,
-            },
-            finishReason: result.toolRequests.length > 0
-                ? VALUES.OPENTELEMETRY.GEN_AI.response.finishReasons.toolCalls
-                : VALUES.OPENTELEMETRY.GEN_AI.response.finishReasons.stop,
-        });
-        return result;
-    }
-    async wrapRenderTool(fn, ...args) {
-        const { toolRequest } = args[0];
-        const $tool = this.manualTelemetry.tool(context.active(), {
-            name: toolRequest.toolName,
-            call: {
-                id: toolRequest.toolCallId,
-                arguments: toolRequest.toolArguments,
-            },
-        });
-        let result;
-        try {
-            result = await context.with($tool.context, async () => await fn(...args));
-        }
-        catch (error) {
-            $tool.fail(error);
-            throw error;
-        }
-        $tool.end({
-            result: {
-                value: result.result,
-                isError: result.isError,
-            },
-        });
-        return result;
-    }
-}
 
-var LatitudeErrorCodes;
-(function (LatitudeErrorCodes) {
-    LatitudeErrorCodes["UnexpectedError"] = "UnexpectedError";
-    LatitudeErrorCodes["OverloadedError"] = "OverloadedError";
-    LatitudeErrorCodes["RateLimitError"] = "RateLimitError";
-    LatitudeErrorCodes["UnauthorizedError"] = "UnauthorizedError";
-    LatitudeErrorCodes["ForbiddenError"] = "ForbiddenError";
-    LatitudeErrorCodes["BadRequestError"] = "BadRequestError";
-    LatitudeErrorCodes["NotFoundError"] = "NotFoundError";
-    LatitudeErrorCodes["ConflictError"] = "ConflictError";
-    LatitudeErrorCodes["UnprocessableEntityError"] = "UnprocessableEntityError";
-    LatitudeErrorCodes["NotImplementedError"] = "NotImplementedError";
-    LatitudeErrorCodes["PaymentRequiredError"] = "PaymentRequiredError";
-    LatitudeErrorCodes["AbortedError"] = "AbortedError";
-    LatitudeErrorCodes["BillingError"] = "BillingError";
-})(LatitudeErrorCodes || (LatitudeErrorCodes = {}));
-// NOTE: If you add a new error code, please add it to the pg enum in models/runErrors.ts
-var RunErrorCodes;
-(function (RunErrorCodes) {
-    RunErrorCodes["AIProviderConfigError"] = "ai_provider_config_error";
-    RunErrorCodes["AIRunError"] = "ai_run_error";
-    RunErrorCodes["ChainCompileError"] = "chain_compile_error";
-    RunErrorCodes["DefaultProviderExceededQuota"] = "default_provider_exceeded_quota_error";
-    RunErrorCodes["DefaultProviderInvalidModel"] = "default_provider_invalid_model_error";
-    RunErrorCodes["DocumentConfigError"] = "document_config_error";
-    RunErrorCodes["ErrorGeneratingMockToolResult"] = "error_generating_mock_tool_result";
-    RunErrorCodes["FailedToWakeUpIntegrationError"] = "failed_to_wake_up_integration_error";
-    RunErrorCodes["InvalidResponseFormatError"] = "invalid_response_format_error";
-    RunErrorCodes["MaxStepCountExceededError"] = "max_step_count_exceeded_error";
-    RunErrorCodes["MissingProvider"] = "missing_provider_error";
-    RunErrorCodes["RateLimit"] = "rate_limit_error";
-    RunErrorCodes["Unknown"] = "unknown_error";
-    RunErrorCodes["UnsupportedProviderResponseTypeError"] = "unsupported_provider_response_type_error";
-    RunErrorCodes["PaymentRequiredError"] = "payment_required_error";
-    RunErrorCodes["AbortError"] = "abort_error";
-    // DEPRECATED, but do not delete
-    RunErrorCodes["EvaluationRunMissingProviderLogError"] = "ev_run_missing_provider_log_error";
-    RunErrorCodes["EvaluationRunMissingWorkspaceError"] = "ev_run_missing_workspace_error";
-    RunErrorCodes["EvaluationRunResponseJsonFormatError"] = "ev_run_response_json_format_error";
-    RunErrorCodes["EvaluationRunUnsupportedResultTypeError"] = "ev_run_unsupported_result_type_error";
-})(RunErrorCodes || (RunErrorCodes = {}));
-var ApiErrorCodes;
-(function (ApiErrorCodes) {
-    ApiErrorCodes["HTTPException"] = "http_exception";
-    ApiErrorCodes["InternalServerError"] = "internal_server_error";
-})(ApiErrorCodes || (ApiErrorCodes = {}));
-
-class LatitudeError extends Error {
-    statusCode = 500;
-    name = LatitudeErrorCodes.UnexpectedError;
-    headers = {};
-    details;
-    constructor(message, details, status, name) {
-        super(message);
-        this.details = details ?? {};
-        this.statusCode = status ?? this.statusCode;
-        this.name = name ?? this.constructor.name;
-    }
-    serialize() {
-        return {
-            name: this.name,
-            code: this.name,
-            status: this.statusCode,
-            message: this.message,
-            details: this.details,
-        };
-    }
-    static deserialize(json) {
-        return new LatitudeError(json.message, json.details, json.status, json.name);
-    }
+// src/sdk/span-filter.ts
+var GEN_AI_PREFIX = "gen_ai.";
+var LLM_PREFIX = "llm.";
+var OPENINFERENCE_KIND = "openinference.span.kind";
+var OTEL_LLM_INSTRUMENTATION_SCOPE_PREFIXES = [
+  "opentelemetry.instrumentation.alephalpha",
+  "opentelemetry.instrumentation.anthropic",
+  "opentelemetry.instrumentation.bedrock",
+  "opentelemetry.instrumentation.cohere",
+  "opentelemetry.instrumentation.crewai",
+  "opentelemetry.instrumentation.google_generativeai",
+  "opentelemetry.instrumentation.groq",
+  "opentelemetry.instrumentation.haystack",
+  "opentelemetry.instrumentation.langchain",
+  "opentelemetry.instrumentation.llamaindex",
+  "opentelemetry.instrumentation.mistralai",
+  "opentelemetry.instrumentation.ollama",
+  "opentelemetry.instrumentation.openai",
+  "opentelemetry.instrumentation.replicate",
+  "opentelemetry.instrumentation.sagemaker",
+  "opentelemetry.instrumentation.together",
+  "opentelemetry.instrumentation.transformers",
+  "opentelemetry.instrumentation.vertexai",
+  "opentelemetry.instrumentation.watsonx",
+  "openinference.instrumentation"
+];
+var LLM_SCOPE_SUBSTRINGS = ["openinference", "traceloop", "langsmith", "litellm"];
+function buildShouldExportSpanFromFields(fields) {
+  return buildShouldExportSpan({
+    ...fields.disableSmartFilter !== void 0 ? { disableSmartFilter: fields.disableSmartFilter } : {},
+    ...fields.shouldExportSpan !== void 0 ? { shouldExportSpan: fields.shouldExportSpan } : {},
+    ...fields.blockedInstrumentationScopes !== void 0 ? { blockedInstrumentationScopes: fields.blockedInstrumentationScopes } : {}
+  });
 }
-class BadRequestError extends LatitudeError {
-    statusCode = 400;
-    name = LatitudeErrorCodes.BadRequestError;
+function attributeKeys(span) {
+  const attrs = span.attributes;
+  if (!attrs || typeof attrs !== "object") return [];
+  return Object.keys(attrs);
 }
-
-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.ROOT_CONTEXT;
-class SpanFactory {
-    telemetry;
-    constructor(telemetry) {
-        this.telemetry = telemetry;
-    }
-    span(options, ctx) {
-        return this.telemetry.unknown(ctx ?? context.active(), options);
-    }
-    tool(options, ctx) {
-        return this.telemetry.tool(ctx ?? context.active(), options);
-    }
-    completion(options, ctx) {
-        return this.telemetry.completion(ctx ?? context.active(), options);
-    }
-    embedding(options, ctx) {
-        return this.telemetry.embedding(ctx ?? context.active(), options);
-    }
-    http(options, ctx) {
-        return this.telemetry.http(ctx ?? context.active(), options);
-    }
-    prompt(options, ctx) {
-        return this.telemetry.prompt(ctx ?? context.active(), options);
-    }
-    chat(options, ctx) {
-        return this.telemetry.chat(ctx ?? context.active(), options);
-    }
-    external(options, ctx) {
-        return this.telemetry.external(ctx ?? context.active(), options);
-    }
+function instrumentationScopeName(span) {
+  return span.instrumentationLibrary?.name ?? "";
 }
-class ContextManager {
-    telemetry;
-    constructor(telemetry) {
-        this.telemetry = telemetry;
-    }
-    resume(ctx) {
-        return this.telemetry.resume(ctx);
-    }
-    active() {
-        return context.active();
-    }
-    with(ctx, fn, thisArg, ...args) {
-        return context.with(ctx, fn, thisArg, ...args);
-    }
+function isGenAiOrLlmAttributeSpan(span) {
+  for (const key of attributeKeys(span)) {
+    if (key.startsWith(GEN_AI_PREFIX) || key.startsWith(LLM_PREFIX)) return true;
+    if (key === OPENINFERENCE_KIND || key.startsWith("openinference.")) return true;
+    if (key.startsWith("ai.")) return true;
+    if (key.startsWith("latitude.")) return true;
+  }
+  return false;
 }
-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();
-        });
-    }
+function isLatitudeInstrumentationSpan(span) {
+  const name = instrumentationScopeName(span);
+  return name === SCOPE_LATITUDE || name.startsWith(`${SCOPE_LATITUDE}.`);
 }
-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);
-    }
+function isKnownLlmInstrumentationScope(span) {
+  const name = instrumentationScopeName(span);
+  if (!name) return false;
+  for (const prefix of OTEL_LLM_INSTRUMENTATION_SCOPE_PREFIXES) {
+    if (name === prefix || name.startsWith(`${prefix}.`)) return true;
+  }
+  const lower = name.toLowerCase();
+  for (const part of LLM_SCOPE_SUBSTRINGS) {
+    if (lower.includes(part)) return true;
+  }
+  return false;
 }
-class ScopedTracerProvider {
-    scope;
-    version;
-    provider;
-    constructor(scope, version, provider) {
-        this.scope = scope;
-        this.version = version;
-        this.provider = provider;
-    }
-    getTracer(_name, _version, options) {
-        return this.provider.getTracer(this.scope, this.version, options);
-    }
+function isDefaultExportSpan(span) {
+  if (isLatitudeInstrumentationSpan(span)) return true;
+  if (isGenAiOrLlmAttributeSpan(span)) return true;
+  if (isKnownLlmInstrumentationScope(span)) return true;
+  return false;
 }
-class LifecycleManager {
-    nodeProvider;
-    exporter;
-    constructor(nodeProvider, exporter) {
-        this.nodeProvider = nodeProvider;
-        this.exporter = exporter;
-    }
-    async flush() {
-        await this.nodeProvider.forceFlush();
-        await this.exporter.forceFlush?.();
-    }
-    async shutdown() {
-        await this.flush();
-        await this.nodeProvider.shutdown();
-        await this.exporter.shutdown?.();
-    }
+function buildShouldExportSpan(options) {
+  if (options.disableSmartFilter) return () => true;
+  const blocked = new Set(options.blockedInstrumentationScopes ?? []);
+  const extra = options.shouldExportSpan;
+  return (span) => {
+    const scope = instrumentationScopeName(span);
+    if (blocked.has(scope)) return false;
+    if (isDefaultExportSpan(span)) return true;
+    if (extra?.(span)) return true;
+    return false;
+  };
 }
-const DEFAULT_SPAN_EXPORTER = (apiKey) => new OTLPTraceExporter({
-    url: TRACES_URL,
-    headers: {
+var ExportFilterSpanProcessor = class {
+  shouldExport;
+  inner;
+  constructor(shouldExport, inner) {
+    this.shouldExport = shouldExport;
+    this.inner = inner;
+  }
+  onStart(span, parentContext) {
+    this.inner.onStart(span, parentContext);
+  }
+  onEnd(span) {
+    if (!this.shouldExport(span)) return;
+    this.inner.onEnd(span);
+  }
+  forceFlush() {
+    return this.inner.forceFlush();
+  }
+  shutdown() {
+    return this.inner.shutdown();
+  }
+};
+var RedactThenExportSpanProcessor = class {
+  redact;
+  exportProcessor;
+  constructor(redact, exportProcessor) {
+    this.redact = redact;
+    this.exportProcessor = exportProcessor;
+  }
+  onStart(span, parentContext) {
+    this.redact?.onStart(span, parentContext);
+    this.exportProcessor.onStart(span, parentContext);
+  }
+  onEnd(span) {
+    this.redact?.onEnd(span);
+    this.exportProcessor.onEnd(span);
+  }
+  forceFlush() {
+    return this.exportProcessor.forceFlush();
+  }
+  shutdown() {
+    return this.exportProcessor.shutdown();
+  }
+};
+
+// src/sdk/processor.ts
+var LatitudeSpanProcessor = class {
+  tail;
+  constructor(apiKey, projectSlug, options) {
+    if (!apiKey || apiKey.trim() === "") {
+      throw new Error("[Latitude] apiKey is required and cannot be empty");
+    }
+    if (!projectSlug || projectSlug.trim() === "") {
+      throw new Error("[Latitude] projectSlug is required and cannot be empty");
+    }
+    const exporter = options?.exporter ?? new OTLPTraceExporter({
+      url: `${env.EXPORTER_URL}/v1/traces`,
+      headers: {
         Authorization: `Bearer ${apiKey}`,
-        'Content-Type': 'application/json',
-    },
-    timeoutMillis: 30 * 1000,
-});
-// Note: Only exporting typescript instrumentations
-var Instrumentation;
-(function (Instrumentation) {
-    Instrumentation["Anthropic"] = "anthropic";
-    Instrumentation["AIPlatform"] = "aiplatform";
-    Instrumentation["Bedrock"] = "bedrock";
-    Instrumentation["Cohere"] = "cohere";
-    Instrumentation["Langchain"] = "langchain";
-    Instrumentation["Latitude"] = "latitude";
-    Instrumentation["LlamaIndex"] = "llamaindex";
-    Instrumentation["Manual"] = "manual";
-    Instrumentation["OpenAI"] = "openai";
-    Instrumentation["TogetherAI"] = "togetherai";
-    Instrumentation["VertexAI"] = "vertexai";
-})(Instrumentation || (Instrumentation = {}));
-class LatitudeTelemetry {
-    options;
-    nodeProvider;
-    manualInstrumentation;
-    instrumentationsList;
-    span;
-    context;
-    instrumentation;
-    tracer;
-    lifecycle;
-    constructor(apiKey, options) {
-        this.options = options || {};
-        if (!this.options.exporter) {
-            this.options.exporter = DEFAULT_SPAN_EXPORTER(apiKey);
-        }
-        context.setGlobalContextManager(new AsyncLocalStorageContextManager().enable());
-        propagation.setGlobalPropagator(new CompositePropagator({
-            propagators: [
-                ...(this.options.propagators || []),
-                new W3CTraceContextPropagator(),
-                new W3CBaggagePropagator(),
-            ],
-        }));
-        this.nodeProvider = new NodeTracerProvider({
-            resource: new Resource({ [ATTR_SERVICE_NAME]: SERVICE_NAME }),
-        });
-        this.lifecycle = new LifecycleManager(this.nodeProvider, this.options.exporter);
-        // Note: important, must run before the exporter span processors
-        this.nodeProvider.addSpanProcessor(new BaggageSpanProcessor(ALLOW_ALL_BAGGAGE_KEYS));
-        if (this.options.processors) {
-            this.options.processors.forEach((processor) => {
-                this.nodeProvider.addSpanProcessor(processor);
-            });
-        }
-        else {
-            this.nodeProvider.addSpanProcessor(DEFAULT_REDACT_SPAN_PROCESSOR());
-        }
-        if (this.options.disableBatch) {
-            this.nodeProvider.addSpanProcessor(new SimpleSpanProcessor(this.options.exporter));
-        }
-        else {
-            this.nodeProvider.addSpanProcessor(new BatchSpanProcessor(this.options.exporter));
-        }
-        this.nodeProvider.register();
-        process.on('SIGTERM', async () => this.shutdown);
-        process.on('SIGINT', async () => this.shutdown);
-        this.manualInstrumentation = null;
-        this.instrumentationsList = [];
-        this.tracer = new TracerManager(this.nodeProvider, SCOPE_VERSION);
-        this.initInstrumentations();
-        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.lifecycle.flush();
-    }
-    async shutdown() {
-        await this.lifecycle.shutdown();
-    }
-    // TODO(tracing): auto instrument outgoing HTTP requests
-    initInstrumentations() {
-        this.instrumentationsList = [];
-        const tracer = this.tracer.get(Instrumentation.Manual);
-        this.manualInstrumentation = new ManualInstrumentation(tracer, this.options.instrumentations?.manual);
-        this.instrumentationsList.push(this.manualInstrumentation);
-        const latitude = this.options.instrumentations?.latitude;
-        if (latitude) {
-            const tracer = this.tracer.get(Instrumentation.Latitude);
-            const instrumentation = new LatitudeInstrumentation(tracer, typeof latitude === 'object' ? latitude : { module: latitude });
-            this.instrumentationsList.push(instrumentation);
-        }
-        const configureInstrumentation = (instrumentationType, InstrumentationConstructor, instrumentationOptions) => {
-            const providerPkg = this.options.instrumentations?.[instrumentationType];
-            if (!providerPkg)
-                return;
-            const provider = this.tracer.provider(instrumentationType);
-            const instrumentation = new InstrumentationConstructor(instrumentationOptions); // prettier-ignore
-            instrumentation.setTracerProvider(provider);
-            instrumentation.manuallyInstrument(providerPkg);
-            registerInstrumentations({
-                instrumentations: [instrumentation],
-                tracerProvider: provider,
-            });
-            this.instrumentationsList.push(instrumentation);
-        };
-        configureInstrumentation(Instrumentation.Anthropic, AnthropicInstrumentation); // prettier-ignore
-        configureInstrumentation(Instrumentation.AIPlatform, AIPlatformInstrumentation); // prettier-ignore
-        configureInstrumentation(Instrumentation.Bedrock, BedrockInstrumentation); // prettier-ignore
-        configureInstrumentation(Instrumentation.Cohere, CohereInstrumentation); // prettier-ignore
-        configureInstrumentation(Instrumentation.Langchain, LangChainInstrumentation); // prettier-ignore
-        configureInstrumentation(Instrumentation.LlamaIndex, LlamaIndexInstrumentation); // prettier-ignore
-        // NOTE: `stream: true` in OpenAI make enrichTokens fail, so disabling.
-        configureInstrumentation(Instrumentation.OpenAI, OpenAIInstrumentation, { enrichTokens: false }); // prettier-ignore
-        configureInstrumentation(Instrumentation.TogetherAI, TogetherInstrumentation, { enrichTokens: false }); // prettier-ignore
-        configureInstrumentation(Instrumentation.VertexAI, VertexAIInstrumentation); // prettier-ignore
-    }
-    async capture(options, fn) {
-        if (!DOCUMENT_PATH_REGEXP.test(options.path)) {
-            throw new BadRequestError("Invalid path, no spaces. Only letters, numbers, '.', '-' and '_'");
-        }
-        const captureBaggageEntries = {
-            [ATTRIBUTES.LATITUDE.promptPath]: { value: options.path },
-            [ATTRIBUTES.LATITUDE.projectId]: { value: String(options.projectId) },
-        };
-        if (options.versionUuid) {
-            captureBaggageEntries[ATTRIBUTES.LATITUDE.commitUuid] = {
-                value: options.versionUuid,
-            };
-        }
-        if (options.conversationUuid) {
-            captureBaggageEntries[ATTRIBUTES.LATITUDE.documentLogUuid] = {
-                value: options.conversationUuid,
-            };
-        }
-        const captureContext = propagation.setBaggage(BACKGROUND(), propagation.createBaggage(captureBaggageEntries));
-        const span = this.manualInstrumentation.unresolvedExternal(captureContext, options);
-        let result;
-        try {
-            result = await context.with(span.context, async () => await fn(span.context));
-        }
-        catch (error) {
-            span.fail(error);
-            throw error;
-        }
-        span.end();
-        return result;
-    }
-}
+        "Content-Type": "application/json",
+        "X-Latitude-Project": projectSlug
+      },
+      timeoutMillis: 3e4
+    });
+    const redact = options?.disableRedact ? null : options?.redact ? new RedactSpanProcessor(options.redact) : DEFAULT_REDACT_SPAN_PROCESSOR();
+    const batchOrSimple = options?.disableBatch ? new SimpleSpanProcessor(exporter) : new BatchSpanProcessor(exporter);
+    const shouldExport = buildShouldExportSpanFromFields({
+      disableSmartFilter: options?.disableSmartFilter,
+      shouldExportSpan: options?.shouldExportSpan,
+      blockedInstrumentationScopes: options?.blockedInstrumentationScopes
+    });
+    const redactThenExport = new RedactThenExportSpanProcessor(redact, batchOrSimple);
+    this.tail = new ExportFilterSpanProcessor(shouldExport, redactThenExport);
+  }
+  onStart(span, parentContext) {
+    const latitudeData = getLatitudeContext(parentContext);
+    if (latitudeData) {
+      if (latitudeData.name) {
+        span.setAttribute(ATTRIBUTES.name, latitudeData.name);
+        if (span.attributes["latitude.capture.root"]) {
+          span.updateName(latitudeData.name);
+        }
+      }
+      if (latitudeData.tags && latitudeData.tags.length > 0) {
+        span.setAttribute(ATTRIBUTES.tags, JSON.stringify(latitudeData.tags));
+      }
+      if (latitudeData.metadata && Object.keys(latitudeData.metadata).length > 0) {
+        span.setAttribute(ATTRIBUTES.metadata, JSON.stringify(latitudeData.metadata));
+      }
+      if (latitudeData.sessionId) {
+        span.setAttribute(ATTRIBUTES.sessionId, latitudeData.sessionId);
+      }
+      if (latitudeData.userId) {
+        span.setAttribute(ATTRIBUTES.userId, latitudeData.userId);
+      }
+    }
+    this.tail.onStart(span, parentContext);
+  }
+  onEnd(span) {
+    this.tail.onEnd(span);
+  }
+  async forceFlush() {
+    await this.tail.forceFlush();
+  }
+  async shutdown() {
+    await this.tail.shutdown();
+  }
+};
 
-export { BACKGROUND, DEFAULT_REDACT_SPAN_PROCESSOR, DEFAULT_SPAN_EXPORTER, Instrumentation, LatitudeTelemetry, RedactSpanProcessor };
-//# sourceMappingURL=index.js.map
+// src/sdk/init.ts
+var SERVICE_NAME = process.env.npm_package_name || "unknown";
+var shutdownHandlersRegistered = false;
+function initLatitude(options) {
+  const { apiKey, projectSlug, instrumentations = [], ...processorOptions } = options;
+  if (!apiKey || apiKey.trim() === "") {
+    throw new Error("[Latitude] apiKey is required and cannot be empty");
+  }
+  if (!projectSlug || projectSlug.trim() === "") {
+    throw new Error("[Latitude] projectSlug is required and cannot be empty");
+  }
+  const contextManager = new AsyncLocalStorageContextManager();
+  contextManager.enable();
+  const propagator = new CompositePropagator({
+    propagators: [new W3CTraceContextPropagator(), new W3CBaggagePropagator()]
+  });
+  context2.setGlobalContextManager(contextManager);
+  propagation.setGlobalPropagator(propagator);
+  const provider = new NodeTracerProvider({
+    resource: new Resource({
+      [ATTR_SERVICE_NAME]: SERVICE_NAME
+    }),
+    spanProcessors: [new LatitudeSpanProcessor(apiKey, projectSlug, processorOptions)]
+  });
+  provider.register();
+  const ready = registerLatitudeInstrumentations({
+    instrumentations,
+    tracerProvider: provider
+  }).catch((err) => {
+    console.warn("[Latitude] Failed to register instrumentations:", err);
+  });
+  const shutdown = async () => {
+    await provider.shutdown();
+  };
+  const flush = async () => {
+    await provider.forceFlush();
+  };
+  const handleShutdown = async () => {
+    try {
+      await shutdown();
+    } catch (err) {
+      console.error("Error during Latitude Telemetry shutdown:", err);
+    }
+  };
+  if (!shutdownHandlersRegistered) {
+    process.once("SIGTERM", handleShutdown);
+    process.once("SIGINT", handleShutdown);
+    shutdownHandlersRegistered = true;
+  }
+  return {
+    provider,
+    flush,
+    shutdown,
+    ready
+  };
+}
+export {
+  ExportFilterSpanProcessor,
+  LatitudeSpanProcessor,
+  RedactSpanProcessor,
+  RedactThenExportSpanProcessor,
+  buildShouldExportSpan,
+  buildShouldExportSpanFromFields,
+  capture,
+  initLatitude,
+  isDefaultExportSpan,
+  isGenAiOrLlmAttributeSpan,
+  isLatitudeInstrumentationSpan,
+  registerLatitudeInstrumentations
+};
+//# sourceMappingURL=index.js.map