langwatch 0.1.0 → 0.1.3

package/dist/{utils-DDcm0z9v.d.ts → utils-CFtM8VVg.d.ts}

@@ -1,5 +1,4 @@
 import { CoreMessage } from 'ai';
-import modelPrices from 'llm-cost/model_prices_and_context_window.json';
 
 type ChatRole = "system" | "user" | "assistant" | "function" | "tool" | "unknown";
 interface FunctionCall {
@@ -17,6 +16,7 @@ interface ChatMessage$1 {
     function_call?: FunctionCall | null;
     tool_calls?: ToolCall[] | null;
     tool_call_id?: string | null;
+    name?: string | null;
 }
 type ChatRichContent$1 = {
     type: "text";
@@ -49,18 +49,23 @@ type Money = {
     currency: string;
     amount: number;
 };
-interface GuardrailResult {
+interface EvaluationResult {
     status: "processed" | "skipped" | "error";
-    passed: boolean;
+    passed?: boolean | null;
     score?: number | null;
+    label?: string | null;
     details?: string | null;
     cost?: Money | null;
 }
 interface TypedValueGuardrailResult {
     type: "guardrail_result";
-    value: GuardrailResult;
+    value: EvaluationResult;
+}
+interface TypedValueEvaluationResult {
+    type: "evaluation_result";
+    value: EvaluationResult;
 }
-type SpanInputOutput$1 = TypedValueText | TypedValueChatMessages | TypedValueGuardrailResult | TypedValueJson | TypedValueRaw | {
+type SpanInputOutput$1 = TypedValueText | TypedValueChatMessages | TypedValueGuardrailResult | TypedValueEvaluationResult | TypedValueJson | TypedValueRaw | {
     type: "list";
     value: SpanInputOutput$1[];
 };
@@ -75,19 +80,32 @@ interface SpanMetrics {
     tokens_estimated?: boolean | null;
     cost?: number | null;
 }
-interface SpanParams {
-    temperature?: number;
-    stream?: boolean;
-    functions?: Record<string, any>[];
-    tools?: Record<string, any>[];
-    tool_choice?: string;
-}
+type ReservedSpanParams = {
+    frequency_penalty?: number | null;
+    logit_bias?: Record<string, number> | null;
+    logprobs?: boolean | null;
+    top_logprobs?: number | null;
+    max_tokens?: number | null;
+    n?: number | null;
+    presence_penalty?: number | null;
+    seed?: number | null;
+    stop?: string | string[] | null;
+    stream?: boolean | null;
+    temperature?: number | null;
+    top_p?: number | null;
+    tools?: Record<string, any>[] | null;
+    tool_choice?: Record<string, any> | string | null;
+    parallel_tool_calls?: boolean | null;
+    functions?: Record<string, any>[] | null;
+    user?: string | null;
+};
+type SpanParams = ReservedSpanParams & Record<string, any>;
 interface SpanTimestamps {
     started_at: number;
     first_token_at?: number | null;
     finished_at: number;
 }
-type SpanTypes = "span" | "llm" | "chain" | "tool" | "agent" | "rag" | "guardrail" | "unknown";
+type SpanTypes = "span" | "llm" | "chain" | "tool" | "agent" | "rag" | "guardrail" | "evaluation" | "workflow" | "component" | "server" | "client" | "producer" | "consumer" | "task" | "unknown";
 interface BaseSpan$1 {
     span_id: string;
     parent_id?: string | null;
@@ -99,12 +117,12 @@ interface BaseSpan$1 {
     error?: ErrorCapture | null;
     timestamps: SpanTimestamps;
     metrics?: SpanMetrics | null;
+    params?: SpanParams | null;
 }
 interface LLMSpan$1 extends BaseSpan$1 {
     type: "llm";
     vendor?: string | null;
-    model: string;
-    params: SpanParams;
+    model?: string | null;
 }
 interface RAGChunk {
     document_id?: string | null;
@@ -131,25 +149,35 @@ type TraceOutput = {
         embeddings: number[];
     };
 };
+type PrimitiveType = string | number | boolean | null | undefined;
+type ReservedTraceMetadata = {
+    thread_id?: string | null;
+    user_id?: string | null;
+    customer_id?: string | null;
+    labels?: string[] | null;
+    topic_id?: string | null;
+    subtopic_id?: string | null;
+    sdk_version?: string | null;
+    sdk_language?: string | null;
+};
+type CustomMetadata = Record<string, PrimitiveType | PrimitiveType[] | Record<string, PrimitiveType> | Record<string, Record<string, PrimitiveType>>>;
+type TraceMetadata = ReservedTraceMetadata & CustomMetadata;
 type Trace = {
     trace_id: string;
     project_id: string;
-    metadata: {
-        thread_id?: string;
-        user_id?: string;
-        customer_id?: string;
-        labels?: string[];
-        topic_id?: string;
-        subtopic_id?: string;
-    };
+    metadata: TraceMetadata;
     timestamps: {
         started_at: number;
         inserted_at: number;
         updated_at: number;
     };
-    input: TraceInput;
+    input?: TraceInput;
     output?: TraceOutput;
-    metrics: {
+    contexts?: RAGChunk[];
+    expected_output?: {
+        value: string;
+    };
+    metrics?: {
         first_token_ms?: number | null;
         total_time_ms?: number | null;
         prompt_tokens?: number | null;
@@ -159,10 +187,39 @@ type Trace = {
     };
     error?: ErrorCapture | null;
     indexing_md5s?: string[];
+    events?: Event[];
+    evaluations?: Evaluation[];
 };
-type Experiment = {
-    experiment_id: string;
-    variant: number;
+type EvaluationStatus = "scheduled" | "in_progress" | "error" | "skipped" | "processed";
+type Evaluation = {
+    evaluation_id: string;
+    evaluator_id: string;
+    span_id?: string | null;
+    name: string;
+    type?: string | null;
+    is_guardrail?: boolean | null;
+    status: EvaluationStatus;
+    passed?: boolean | null;
+    score?: number | null;
+    label?: string | null;
+    details?: string | null;
+    error?: ErrorCapture | null;
+    retries?: number | null;
+    timestamps: {
+        inserted_at?: number | null;
+        started_at?: number | null;
+        finished_at?: number | null;
+        updated_at?: number | null;
+    };
+};
+type RESTEvaluation$1 = Omit<Evaluation, "evaluation_id" | "evaluator_id" | "status" | "timestamps" | "retries"> & {
+    evaluation_id?: string | null;
+    evaluator_id?: string | null;
+    status?: "processed" | "skipped" | "error" | null;
+    timestamps?: {
+        started_at?: number | null;
+        finished_at?: number | null;
+    } | null;
 };
 type CollectorRESTParams = {
     trace_id?: string | null | undefined;
@@ -172,7 +229,23 @@ type CollectorRESTParams = {
         thread_id?: string | null | undefined;
         customer_id?: string | null | undefined;
         labels?: string[] | null | undefined;
-        experiments?: Experiment[] | null | undefined;
+        sdk_version?: string | null | undefined;
+        sdk_language?: string | null | undefined;
+    } & CustomMetadata;
+    expected_output?: string | null;
+    evaluations?: RESTEvaluation$1[];
+};
+type Event = {
+    event_id: string;
+    event_type: string;
+    project_id: string;
+    metrics: Record<string, number>;
+    event_details: Record<string, string>;
+    trace_id: string;
+    timestamps: {
+        started_at: number;
+        inserted_at: number;
+        updated_at: number;
     };
 };
 
@@ -202,13 +275,17 @@ type PendingSpan<T extends BaseSpan> = Omit<T, "traceId" | "timestamps"> & {
 type BaseSpan = ConvertServerSpan<BaseSpan$1>;
 type PendingBaseSpan = PendingSpan<BaseSpan>;
 type LLMSpan = ConvertServerSpan<Omit<LLMSpan$1, "vendor" | "model">> & {
-    model: keyof typeof modelPrices | (string & NonNullable<unknown>);
+    model: string;
 };
 type PendingLLMSpan = PendingSpan<LLMSpan>;
 type RAGSpan = ConvertServerSpan<RAGSpan$1>;
 type PendingRAGSpan = PendingSpan<RAGSpan>;
+type RESTEvaluation = SnakeToCamelCaseNested<Omit<RESTEvaluation$1, "error">> & {
+    error?: RESTEvaluation$1["error"];
+};
 
 declare function convertFromVercelAIMessages(messages: CoreMessage[]): ChatMessage[];
 declare const captureError: (error: unknown) => ErrorCapture;
+declare const autoconvertTypedValues: (value: unknown) => SpanInputOutput;
 
-export { type BaseSpan as B, type CollectorRESTParams as C, type LLMSpan as L, type Metadata as M, type PendingBaseSpan as P, type RAGSpan as R, type Span as S, type PendingLLMSpan as a, type PendingRAGSpan as b, type SpanTypes as c, type ChatMessage as d, type ChatRichContent as e, type SpanInputOutput as f, convertFromVercelAIMessages as g, captureError as h };
+export { type BaseSpan as B, type CollectorRESTParams as C, type LLMSpan as L, type Metadata as M, type PendingBaseSpan as P, type RAGChunk as R, type Span as S, type RESTEvaluation as a, type PendingLLMSpan as b, type PendingRAGSpan as c, type SpanTypes as d, type ChatMessage as e, type ChatRichContent as f, type RAGSpan as g, type SpanInputOutput as h, autoconvertTypedValues as i, captureError as j, convertFromVercelAIMessages as k };

package/dist/utils.d.mts

@@ -1,3 +1,2 @@
 import 'ai';
-export { h as captureError, g as convertFromVercelAIMessages } from './utils-DDcm0z9v.mjs';
-import 'llm-cost/model_prices_and_context_window.json';
+export { i as autoconvertTypedValues, j as captureError, k as convertFromVercelAIMessages } from './utils-CFtM8VVg.mjs';

package/dist/utils.d.ts

@@ -1,3 +1,2 @@
 import 'ai';
-export { h as captureError, g as convertFromVercelAIMessages } from './utils-DDcm0z9v.js';
-import 'llm-cost/model_prices_and_context_window.json';
+export { i as autoconvertTypedValues, j as captureError, k as convertFromVercelAIMessages } from './utils-CFtM8VVg.js';

package/dist/utils.js

@@ -137,6 +137,7 @@ var require_secure_json_parse = __commonJS({
 // src/utils.ts
 var utils_exports = {};
 __export(utils_exports, {
+  autoconvertTypedValues: () => autoconvertTypedValues,
   captureError: () => captureError,
   convertFromVercelAIMessages: () => convertFromVercelAIMessages
 });
@@ -157,6 +158,423 @@ function convertUint8ArrayToBase64(array) {
   return globalThis.btoa(latin1string);
 }
 
+// src/utils.ts
+var import_zod2 = require("zod");
+
+// src/server/types/tracer.generated.ts
+var import_zod = require("zod");
+var chatRoleSchema = import_zod.z.union([
+  import_zod.z.literal("system"),
+  import_zod.z.literal("user"),
+  import_zod.z.literal("assistant"),
+  import_zod.z.literal("function"),
+  import_zod.z.literal("tool"),
+  import_zod.z.literal("unknown")
+]);
+var functionCallSchema = import_zod.z.object({
+  name: import_zod.z.string().optional(),
+  arguments: import_zod.z.string().optional()
+});
+var toolCallSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  type: import_zod.z.string(),
+  function: functionCallSchema
+});
+var rAGChunkSchema = import_zod.z.object({
+  document_id: import_zod.z.string().optional().nullable(),
+  chunk_id: import_zod.z.string().optional().nullable(),
+  content: import_zod.z.union([import_zod.z.string(), import_zod.z.record(import_zod.z.any()), import_zod.z.array(import_zod.z.any())])
+});
+var chatRichContentSchema = import_zod.z.union([
+  import_zod.z.object({
+    type: import_zod.z.literal("text"),
+    text: import_zod.z.string().optional()
+  }),
+  import_zod.z.object({
+    type: import_zod.z.literal("image_url"),
+    image_url: import_zod.z.object({
+      url: import_zod.z.string(),
+      detail: import_zod.z.union([import_zod.z.literal("auto"), import_zod.z.literal("low"), import_zod.z.literal("high")]).optional()
+    }).optional()
+  })
+]);
+var typedValueTextSchema = import_zod.z.object({
+  type: import_zod.z.literal("text"),
+  value: import_zod.z.string()
+});
+var typedValueRawSchema = import_zod.z.object({
+  type: import_zod.z.literal("raw"),
+  value: import_zod.z.string()
+});
+var jSONSerializableSchema = import_zod.z.union([
+  import_zod.z.string(),
+  import_zod.z.number(),
+  import_zod.z.boolean(),
+  import_zod.z.record(import_zod.z.any()),
+  import_zod.z.array(import_zod.z.any())
+]).nullable();
+var typedValueJsonSchema = import_zod.z.object({
+  type: import_zod.z.literal("json"),
+  value: jSONSerializableSchema
+});
+var moneySchema = import_zod.z.object({
+  currency: import_zod.z.string(),
+  amount: import_zod.z.number()
+});
+var evaluationResultSchema = import_zod.z.object({
+  status: import_zod.z.union([
+    import_zod.z.literal("processed"),
+    import_zod.z.literal("skipped"),
+    import_zod.z.literal("error")
+  ]),
+  passed: import_zod.z.boolean().optional().nullable(),
+  score: import_zod.z.number().optional().nullable(),
+  label: import_zod.z.string().optional().nullable(),
+  details: import_zod.z.string().optional().nullable(),
+  cost: moneySchema.optional().nullable()
+});
+var typedValueGuardrailResultSchema = import_zod.z.object({
+  type: import_zod.z.literal("guardrail_result"),
+  value: evaluationResultSchema
+});
+var typedValueEvaluationResultSchema = import_zod.z.object({
+  type: import_zod.z.literal("evaluation_result"),
+  value: evaluationResultSchema
+});
+var errorCaptureSchema = import_zod.z.object({
+  has_error: import_zod.z.literal(true),
+  message: import_zod.z.string(),
+  stacktrace: import_zod.z.array(import_zod.z.string())
+});
+var spanMetricsSchema = import_zod.z.object({
+  prompt_tokens: import_zod.z.number().optional().nullable(),
+  completion_tokens: import_zod.z.number().optional().nullable(),
+  tokens_estimated: import_zod.z.boolean().optional().nullable(),
+  cost: import_zod.z.number().optional().nullable()
+});
+var reservedSpanParamsSchema = import_zod.z.object({
+  frequency_penalty: import_zod.z.number().optional().nullable(),
+  logit_bias: import_zod.z.record(import_zod.z.number()).optional().nullable(),
+  logprobs: import_zod.z.boolean().optional().nullable(),
+  top_logprobs: import_zod.z.number().optional().nullable(),
+  max_tokens: import_zod.z.number().optional().nullable(),
+  n: import_zod.z.number().optional().nullable(),
+  presence_penalty: import_zod.z.number().optional().nullable(),
+  seed: import_zod.z.number().optional().nullable(),
+  stop: import_zod.z.union([import_zod.z.string(), import_zod.z.array(import_zod.z.string())]).optional().nullable(),
+  stream: import_zod.z.boolean().optional().nullable(),
+  temperature: import_zod.z.number().optional().nullable(),
+  top_p: import_zod.z.number().optional().nullable(),
+  tools: import_zod.z.array(import_zod.z.record(import_zod.z.any())).optional().nullable(),
+  tool_choice: import_zod.z.union([import_zod.z.record(import_zod.z.any()), import_zod.z.string()]).optional().nullable(),
+  parallel_tool_calls: import_zod.z.boolean().optional().nullable(),
+  functions: import_zod.z.array(import_zod.z.record(import_zod.z.any())).optional().nullable(),
+  user: import_zod.z.string().optional().nullable()
+});
+var spanParamsSchema = reservedSpanParamsSchema.and(import_zod.z.record(import_zod.z.any()));
+var spanTimestampsSchema = import_zod.z.object({
+  started_at: import_zod.z.number(),
+  first_token_at: import_zod.z.number().optional().nullable(),
+  finished_at: import_zod.z.number()
+});
+var spanTypesSchema = import_zod.z.union([
+  import_zod.z.literal("span"),
+  import_zod.z.literal("llm"),
+  import_zod.z.literal("chain"),
+  import_zod.z.literal("tool"),
+  import_zod.z.literal("agent"),
+  import_zod.z.literal("rag"),
+  import_zod.z.literal("guardrail"),
+  import_zod.z.literal("evaluation"),
+  import_zod.z.literal("workflow"),
+  import_zod.z.literal("component"),
+  import_zod.z.literal("server"),
+  import_zod.z.literal("client"),
+  import_zod.z.literal("producer"),
+  import_zod.z.literal("consumer"),
+  import_zod.z.literal("task"),
+  import_zod.z.literal("unknown")
+]);
+var traceInputSchema = import_zod.z.object({
+  value: import_zod.z.string(),
+  embeddings: import_zod.z.object({
+    model: import_zod.z.string(),
+    embeddings: import_zod.z.array(import_zod.z.number())
+  }).optional(),
+  satisfaction_score: import_zod.z.number().optional()
+});
+var traceOutputSchema = import_zod.z.object({
+  value: import_zod.z.string(),
+  embeddings: import_zod.z.object({
+    model: import_zod.z.string(),
+    embeddings: import_zod.z.array(import_zod.z.number())
+  }).optional()
+});
+var primitiveTypeSchema = import_zod.z.union([import_zod.z.string(), import_zod.z.number(), import_zod.z.boolean(), import_zod.z.undefined()]).nullable();
+var reservedTraceMetadataSchema = import_zod.z.object({
+  thread_id: import_zod.z.string().optional().nullable(),
+  user_id: import_zod.z.string().optional().nullable(),
+  customer_id: import_zod.z.string().optional().nullable(),
+  labels: import_zod.z.array(import_zod.z.string()).optional().nullable(),
+  topic_id: import_zod.z.string().optional().nullable(),
+  subtopic_id: import_zod.z.string().optional().nullable(),
+  sdk_version: import_zod.z.string().optional().nullable(),
+  sdk_language: import_zod.z.string().optional().nullable()
+});
+var customMetadataSchema = import_zod.z.record(
+  import_zod.z.union([
+    primitiveTypeSchema,
+    import_zod.z.array(primitiveTypeSchema),
+    import_zod.z.record(primitiveTypeSchema),
+    import_zod.z.record(import_zod.z.record(primitiveTypeSchema))
+  ])
+);
+var traceMetadataSchema = reservedTraceMetadataSchema.and(customMetadataSchema);
+var eventSchema = import_zod.z.object({
+  event_id: import_zod.z.string(),
+  event_type: import_zod.z.string(),
+  project_id: import_zod.z.string(),
+  metrics: import_zod.z.record(import_zod.z.number()),
+  event_details: import_zod.z.record(import_zod.z.string()),
+  trace_id: import_zod.z.string(),
+  timestamps: import_zod.z.object({
+    started_at: import_zod.z.number(),
+    inserted_at: import_zod.z.number(),
+    updated_at: import_zod.z.number()
+  })
+});
+var elasticSearchEventSchema = eventSchema.omit({ metrics: true, event_details: true }).and(
+  import_zod.z.object({
+    metrics: import_zod.z.array(
+      import_zod.z.object({
+        key: import_zod.z.string(),
+        value: import_zod.z.number()
+      })
+    ),
+    event_details: import_zod.z.array(
+      import_zod.z.object({
+        key: import_zod.z.string(),
+        value: import_zod.z.string()
+      })
+    )
+  })
+);
+var evaluationStatusSchema = import_zod.z.union([
+  import_zod.z.literal("scheduled"),
+  import_zod.z.literal("in_progress"),
+  import_zod.z.literal("error"),
+  import_zod.z.literal("skipped"),
+  import_zod.z.literal("processed")
+]);
+var trackEventRESTParamsValidatorSchema = eventSchema.omit({
+  event_id: true,
+  project_id: true,
+  timestamps: true,
+  event_details: true
+}).and(
+  import_zod.z.object({
+    event_id: import_zod.z.string().optional(),
+    event_details: import_zod.z.record(import_zod.z.string()).optional(),
+    timestamp: import_zod.z.number().optional()
+  })
+);
+var contextsSchema = import_zod.z.object({
+  traceId: import_zod.z.string(),
+  contexts: import_zod.z.array(rAGChunkSchema)
+});
+var chatMessageSchema = import_zod.z.object({
+  role: chatRoleSchema.optional(),
+  content: import_zod.z.union([import_zod.z.string(), import_zod.z.array(chatRichContentSchema)]).optional().nullable(),
+  function_call: functionCallSchema.optional().nullable(),
+  tool_calls: import_zod.z.array(toolCallSchema).optional().nullable(),
+  tool_call_id: import_zod.z.string().optional().nullable(),
+  name: import_zod.z.string().optional().nullable()
+});
+var typedValueChatMessagesSchema = import_zod.z.object({
+  type: import_zod.z.literal("chat_messages"),
+  value: import_zod.z.array(chatMessageSchema)
+});
+var spanInputOutputSchema = import_zod.z.lazy(
+  () => import_zod.z.union([
+    typedValueTextSchema,
+    typedValueChatMessagesSchema,
+    typedValueGuardrailResultSchema,
+    typedValueEvaluationResultSchema,
+    typedValueJsonSchema,
+    typedValueRawSchema,
+    import_zod.z.object({
+      type: import_zod.z.literal("list"),
+      value: import_zod.z.array(spanInputOutputSchema)
+    })
+  ])
+);
+var baseSpanSchema = import_zod.z.object({
+  span_id: import_zod.z.string(),
+  parent_id: import_zod.z.string().optional().nullable(),
+  trace_id: import_zod.z.string(),
+  type: spanTypesSchema,
+  name: import_zod.z.string().optional().nullable(),
+  input: spanInputOutputSchema.optional().nullable(),
+  output: spanInputOutputSchema.optional().nullable(),
+  error: errorCaptureSchema.optional().nullable(),
+  timestamps: spanTimestampsSchema,
+  metrics: spanMetricsSchema.optional().nullable(),
+  params: spanParamsSchema.optional().nullable()
+});
+var lLMSpanSchema = baseSpanSchema.extend({
+  type: import_zod.z.literal("llm"),
+  vendor: import_zod.z.string().optional().nullable(),
+  model: import_zod.z.string().optional().nullable()
+});
+var rAGSpanSchema = baseSpanSchema.extend({
+  type: import_zod.z.literal("rag"),
+  contexts: import_zod.z.array(rAGChunkSchema)
+});
+var spanSchema = import_zod.z.union([
+  lLMSpanSchema,
+  rAGSpanSchema,
+  baseSpanSchema
+]);
+var spanInputOutputValidatorSchema = spanInputOutputSchema.and(
+  import_zod.z.object({
+    value: import_zod.z.any()
+  })
+);
+var spanValidatorSchema = import_zod.z.union([
+  lLMSpanSchema.omit({ input: true, output: true, params: true }),
+  rAGSpanSchema.omit({ input: true, output: true, params: true }),
+  baseSpanSchema.omit({ input: true, output: true, params: true })
+]).and(
+  import_zod.z.object({
+    input: spanInputOutputValidatorSchema.optional().nullable(),
+    output: spanInputOutputValidatorSchema.optional().nullable(),
+    params: import_zod.z.record(import_zod.z.any()).optional().nullable()
+  })
+);
+var evaluationSchema = import_zod.z.object({
+  evaluation_id: import_zod.z.string(),
+  evaluator_id: import_zod.z.string(),
+  span_id: import_zod.z.string().optional().nullable(),
+  name: import_zod.z.string(),
+  type: import_zod.z.string().optional().nullable(),
+  is_guardrail: import_zod.z.boolean().optional().nullable(),
+  status: evaluationStatusSchema,
+  passed: import_zod.z.boolean().optional().nullable(),
+  score: import_zod.z.number().optional().nullable(),
+  label: import_zod.z.string().optional().nullable(),
+  details: import_zod.z.string().optional().nullable(),
+  error: errorCaptureSchema.optional().nullable(),
+  retries: import_zod.z.number().optional().nullable(),
+  timestamps: import_zod.z.object({
+    inserted_at: import_zod.z.number().optional().nullable(),
+    started_at: import_zod.z.number().optional().nullable(),
+    finished_at: import_zod.z.number().optional().nullable(),
+    updated_at: import_zod.z.number().optional().nullable()
+  })
+});
+var rESTEvaluationSchema = evaluationSchema.omit({
+  evaluation_id: true,
+  evaluator_id: true,
+  status: true,
+  timestamps: true,
+  retries: true
+}).and(
+  import_zod.z.object({
+    evaluation_id: import_zod.z.string().optional().nullable(),
+    evaluator_id: import_zod.z.string().optional().nullable(),
+    status: import_zod.z.union([
+      import_zod.z.literal("processed"),
+      import_zod.z.literal("skipped"),
+      import_zod.z.literal("error")
+    ]).optional().nullable(),
+    timestamps: import_zod.z.object({
+      started_at: import_zod.z.number().optional().nullable(),
+      finished_at: import_zod.z.number().optional().nullable()
+    }).optional().nullable()
+  })
+);
+var collectorRESTParamsSchema = import_zod.z.object({
+  trace_id: import_zod.z.union([import_zod.z.string(), import_zod.z.undefined()]).optional().nullable(),
+  spans: import_zod.z.array(spanSchema),
+  metadata: import_zod.z.object({
+    user_id: import_zod.z.union([import_zod.z.string(), import_zod.z.undefined()]).optional().nullable(),
+    thread_id: import_zod.z.union([import_zod.z.string(), import_zod.z.undefined()]).optional().nullable(),
+    customer_id: import_zod.z.union([import_zod.z.string(), import_zod.z.undefined()]).optional().nullable(),
+    labels: import_zod.z.union([import_zod.z.array(import_zod.z.string()), import_zod.z.undefined()]).optional().nullable(),
+    sdk_version: import_zod.z.union([import_zod.z.string(), import_zod.z.undefined()]).optional().nullable(),
+    sdk_language: import_zod.z.union([import_zod.z.string(), import_zod.z.undefined()]).optional().nullable()
+  }).and(customMetadataSchema).optional(),
+  expected_output: import_zod.z.string().optional().nullable(),
+  evaluations: import_zod.z.array(rESTEvaluationSchema).optional()
+});
+var collectorRESTParamsValidatorSchema = collectorRESTParamsSchema.omit({ spans: true });
+var datasetSpanSchema = import_zod.z.union([
+  baseSpanSchema.omit({
+    project_id: true,
+    trace_id: true,
+    id: true,
+    timestamps: true,
+    metrics: true,
+    params: true
+  }).and(
+    import_zod.z.object({
+      params: import_zod.z.record(import_zod.z.any())
+    })
+  ),
+  lLMSpanSchema.omit({
+    project_id: true,
+    trace_id: true,
+    id: true,
+    timestamps: true,
+    metrics: true,
+    params: true
+  }).and(
+    import_zod.z.object({
+      params: import_zod.z.record(import_zod.z.any())
+    })
+  ),
+  rAGSpanSchema.omit({
+    project_id: true,
+    trace_id: true,
+    id: true,
+    timestamps: true,
+    metrics: true,
+    params: true
+  }).and(
+    import_zod.z.object({
+      params: import_zod.z.record(import_zod.z.any())
+    })
+  )
+]);
+var traceSchema = import_zod.z.object({
+  trace_id: import_zod.z.string(),
+  project_id: import_zod.z.string(),
+  metadata: traceMetadataSchema,
+  timestamps: import_zod.z.object({
+    started_at: import_zod.z.number(),
+    inserted_at: import_zod.z.number(),
+    updated_at: import_zod.z.number()
+  }),
+  input: traceInputSchema.optional(),
+  output: traceOutputSchema.optional(),
+  contexts: import_zod.z.array(rAGChunkSchema).optional(),
+  expected_output: import_zod.z.object({
+    value: import_zod.z.string()
+  }).optional(),
+  metrics: import_zod.z.object({
+    first_token_ms: import_zod.z.number().optional().nullable(),
+    total_time_ms: import_zod.z.number().optional().nullable(),
+    prompt_tokens: import_zod.z.number().optional().nullable(),
+    completion_tokens: import_zod.z.number().optional().nullable(),
+    total_cost: import_zod.z.number().optional().nullable(),
+    tokens_estimated: import_zod.z.boolean().optional().nullable()
+  }).optional(),
+  error: errorCaptureSchema.optional().nullable(),
+  indexing_md5s: import_zod.z.array(import_zod.z.string()).optional(),
+  events: import_zod.z.array(eventSchema).optional(),
+  evaluations: import_zod.z.array(evaluationSchema).optional()
+});
+
 // src/utils.ts
 var convertImageToUrl = (image, mimeType) => {
   try {
@@ -283,8 +701,27 @@ var captureError = (error) => {
     };
   }
 };
+var autoconvertTypedValues = (value) => {
+  if (typeof value === "string") {
+    return { type: "text", value };
+  }
+  const chatMessages = import_zod2.z.array(chatMessageSchema).safeParse(value);
+  if (Array.isArray(value) && chatMessages.success) {
+    return {
+      type: "chat_messages",
+      value: chatMessages.data
+    };
+  }
+  try {
+    JSON.stringify(value);
+    return { type: "json", value };
+  } catch (e) {
+    return { type: "raw", value };
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  autoconvertTypedValues,
   captureError,
   convertFromVercelAIMessages
 });