langwatch 1.0.0 → 1.2.0

package/dist/chunk-C323F5VC.mjs

@@ -1,1005 +0,0 @@
-import {
-  ATTR_LANGWATCH_EVALUATION_CUSTOM,
-  ATTR_LANGWATCH_INPUT,
-  ATTR_LANGWATCH_METRICS,
-  ATTR_LANGWATCH_OUTPUT,
-  ATTR_LANGWATCH_PROMPT_ID,
-  ATTR_LANGWATCH_PROMPT_SELECTED_ID,
-  ATTR_LANGWATCH_PROMPT_VERSION_ID,
-  ATTR_LANGWATCH_PROMPT_VERSION_NUMBER,
-  ATTR_LANGWATCH_RAG_CONTEXTS,
-  ATTR_LANGWATCH_SPAN_TYPE,
-  __spreadProps,
-  __spreadValues
-} from "./chunk-L5KBRKHS.mjs";
-
-// src/observability-sdk/span/types.ts
-var INPUT_OUTPUT_TYPES = [
-  "text",
-  "raw",
-  "chat_messages",
-  "list",
-  "json",
-  "guardrail_result",
-  "evaluation_result"
-];
-var spanTypes = [
-  "span",
-  "llm",
-  "chain",
-  "tool",
-  "agent",
-  "guardrail",
-  "evaluation",
-  "rag",
-  "prompt",
-  "workflow",
-  "component",
-  "module",
-  "server",
-  "client",
-  "producer",
-  "consumer",
-  "task",
-  "unknown"
-];
-
-// src/internal/generated/types/tracer.ts
-import { z } from "zod";
-var chatRoleSchema = z.union([
-  z.literal("system"),
-  /**
-   * OpenAI Responses-dialect spelling of the system role. Accepted wherever
-   * chat messages are parsed and treated as a system-role message everywhere
-   * it matters (system-instruction extraction, transcript rendering) — a
-   * developer message must never fail schema validation into a raw-JSON
-   * fallback, and never render as a user bubble.
-   */
-  z.literal("developer"),
-  z.literal("user"),
-  z.literal("assistant"),
-  z.literal("function"),
-  z.literal("tool"),
-  z.literal("unknown")
-]);
-var functionCallSchema = z.object({
-  name: z.string().optional(),
-  arguments: z.string().optional()
-});
-var toolCallSchema = z.object({
-  id: z.string(),
-  type: z.string(),
-  function: functionCallSchema
-});
-var rAGChunkSchema = z.object({
-  document_id: z.string().optional().nullable(),
-  chunk_id: z.string().optional().nullable(),
-  content: z.union([
-    z.string(),
-    z.record(z.string(), z.any()),
-    z.array(z.any())
-  ])
-});
-var contextsSchema = z.object({
-  traceId: z.string(),
-  contexts: z.array(rAGChunkSchema)
-});
-var chatRichContentSchema = z.union([
-  z.object({
-    type: z.literal("text"),
-    text: z.string().optional(),
-    /** pi-ai uses `content` instead of `text` inside text blocks */
-    content: z.string().optional()
-  }),
-  z.object({
-    text: z.string()
-  }),
-  z.object({
-    type: z.literal("image_url"),
-    image_url: z.object({
-      url: z.string(),
-      detail: z.union([z.literal("auto"), z.literal("low"), z.literal("high")]).optional()
-    }).optional()
-  }),
-  z.object({
-    type: z.literal("tool_call"),
-    toolName: z.string().optional(),
-    toolCallId: z.string().optional(),
-    args: z.string().optional()
-  }),
-  z.object({
-    type: z.literal("tool_result"),
-    toolName: z.string().optional(),
-    toolCallId: z.string().optional(),
-    result: z.any().optional()
-  }),
-  /**
-   * AG-UI binary content part. Used for audio/image/video/file attachments.
-   * Mutually-exclusive payload: exactly one of `data` (inline base64), `url`
-   * (already-externalized reference), or `id` (stored_objects id) is present.
-   * After ingest-side extraction (stored-objects pipeline), inline `data` is
-   * rewritten to `id` + `url` pointing at /api/files/{id}.
-   */
-  z.object({
-    type: z.literal("binary"),
-    mimeType: z.string(),
-    data: z.string().optional(),
-    url: z.string().optional(),
-    id: z.string().optional(),
-    filename: z.string().optional()
-  }),
-  /**
-   * OpenAI Realtime `input_audio` content part. Pre-extraction the payload is
-   * inline base64 (`{ data, format }`); after ingest-side stored-objects
-   * extraction it is rewritten to a reference (`{ url, mimeType }`) pointing at
-   * /api/files/{projectId}/{id}. Every field is optional so this validates both
-   * shapes. Mirrors `inputAudioContentPartSchema` in the scenario event schemas.
-   */
-  z.object({
-    type: z.literal("input_audio"),
-    input_audio: z.object({
-      data: z.string().optional(),
-      format: z.string().optional(),
-      url: z.string().optional(),
-      mimeType: z.string().optional(),
-      id: z.string().optional()
-    })
-  }),
-  /**
-   * AG-UI media `audio` content part. A typed `source` carries either an
-   * externalized `url` or inline base64 `data`, with an optional `mimeType`.
-   * Shared shape with image/video/document media parts (see `visitContentPart`).
-   */
-  z.object({
-    type: z.literal("audio"),
-    source: z.object({
-      type: z.union([z.literal("url"), z.literal("data")]),
-      value: z.string(),
-      mimeType: z.string().optional()
-    })
-  }),
-  /**
-   * AI-SDK image part. `image` is a data: URI pre-extraction, a
-   * /api/files/{projectId}/{id} reference after ingest-side extraction, or an
-   * external http(s) URL (passed through, never re-hosted). This is the shape
-   * the typescript scenario SDK ships for image attachments in simulated user
-   * messages (scenario docs: multimodal-images).
-   */
-  z.object({
-    type: z.literal("image"),
-    image: z.string(),
-    mediaType: z.string().optional()
-  }),
-  /**
-   * AI-SDK file part. Non-audio mediaTypes are externalized to a `binary`
-   * reference at ingest; audio/* mediaTypes route through the `input_audio`
-   * externalization path (see `visitContentPart`).
-   */
-  z.object({
-    type: z.literal("file"),
-    mediaType: z.string(),
-    data: z.string().optional(),
-    url: z.string().optional(),
-    filename: z.string().optional()
-  }),
-  /**
-   * OpenAI ChatCompletion file part (scenario docs: multimodal-files).
-   * `file_data` is a data: URI or raw base64; `file_id` references a file
-   * hosted on the provider side and carries no bytes, so it passes through
-   * extraction unchanged. Externalized at ingest to a `binary` reference
-   * preserving the filename.
-   */
-  z.object({
-    type: z.literal("file"),
-    file: z.object({
-      file_data: z.string().optional(),
-      file_id: z.string().optional(),
-      filename: z.string().optional()
-    })
-  })
-]);
-var chatMessageSchema = z.object({
-  role: chatRoleSchema.optional(),
-  content: z.union([z.string(), z.array(chatRichContentSchema)]).optional().nullable(),
-  /** Vercel AI SDK / pi-ai use `parts` instead of `content` */
-  parts: z.array(chatRichContentSchema).optional(),
-  function_call: functionCallSchema.optional().nullable(),
-  tool_calls: z.array(toolCallSchema).optional().nullable(),
-  tool_call_id: z.string().optional().nullable(),
-  name: z.string().optional().nullable(),
-  reasoning_content: z.string().optional().nullable()
-});
-var typedValueTextSchema = z.object({
-  type: z.literal("text"),
-  value: z.string()
-});
-var typedValueRawSchema = z.object({
-  type: z.literal("raw"),
-  value: z.string()
-});
-var jSONSerializableSchema = z.union([
-  z.string(),
-  z.number(),
-  z.boolean(),
-  z.record(z.string(), z.any()),
-  z.array(z.any())
-]).nullable();
-var typedValueJsonSchema = z.object({
-  type: z.literal("json"),
-  value: jSONSerializableSchema
-});
-var moneySchema = z.object({
-  currency: z.string(),
-  amount: z.number()
-});
-var evaluationResultSchema = z.object({
-  status: z.union([
-    z.literal("processed"),
-    z.literal("skipped"),
-    z.literal("error")
-  ]),
-  passed: z.boolean().optional().nullable(),
-  score: z.number().optional().nullable(),
-  label: z.string().optional().nullable(),
-  details: z.string().optional().nullable(),
-  cost: moneySchema.optional().nullable()
-});
-var typedValueGuardrailResultSchema = z.object({
-  type: z.literal("guardrail_result"),
-  value: evaluationResultSchema
-});
-var typedValueEvaluationResultSchema = z.object({
-  type: z.literal("evaluation_result"),
-  value: evaluationResultSchema
-});
-var typedValueChatMessagesSchema = z.object({
-  type: z.literal("chat_messages"),
-  value: z.array(chatMessageSchema)
-});
-var spanInputOutputSchema = z.lazy(
-  () => z.union([
-    typedValueTextSchema,
-    typedValueChatMessagesSchema,
-    typedValueGuardrailResultSchema,
-    typedValueEvaluationResultSchema,
-    typedValueJsonSchema,
-    typedValueRawSchema,
-    z.object({
-      type: z.literal("list"),
-      value: z.array(spanInputOutputSchema)
-    })
-  ])
-);
-var errorCaptureSchema = z.object({
-  has_error: z.literal(true),
-  message: z.string(),
-  stacktrace: z.array(z.string())
-});
-var spanMetricsSchema = z.object({
-  prompt_tokens: z.number().optional().nullable(),
-  completion_tokens: z.number().optional().nullable(),
-  reasoning_tokens: z.number().optional().nullable(),
-  cache_read_input_tokens: z.number().optional().nullable(),
-  cache_creation_input_tokens: z.number().optional().nullable(),
-  tokens_estimated: z.boolean().optional().nullable(),
-  cost: z.number().optional().nullable()
-});
-var reservedSpanParamsSchema = z.object({
-  frequency_penalty: z.number().optional().nullable(),
-  logit_bias: z.record(z.string(), z.number()).optional().nullable(),
-  logprobs: z.boolean().optional().nullable(),
-  top_logprobs: z.number().optional().nullable(),
-  max_tokens: z.number().optional().nullable(),
-  n: z.number().optional().nullable(),
-  presence_penalty: z.number().optional().nullable(),
-  seed: z.number().optional().nullable(),
-  stop: z.union([z.string(), z.array(z.string())]).optional().nullable(),
-  stream: z.boolean().optional().nullable(),
-  temperature: z.number().optional().nullable(),
-  top_p: z.number().optional().nullable(),
-  tools: z.array(z.record(z.string(), z.any())).optional().nullable(),
-  tool_choice: z.union([z.record(z.string(), z.any()), z.string()]).optional().nullable(),
-  parallel_tool_calls: z.boolean().optional().nullable(),
-  functions: z.array(z.record(z.string(), z.any())).optional().nullable(),
-  user: z.string().optional().nullable(),
-  reasoning_effort: z.string().optional().nullable()
-});
-var spanParamsSchema = reservedSpanParamsSchema.and(
-  z.record(z.string(), z.any())
-);
-var spanTimestampsSchema = z.object({
-  ignore_timestamps_on_write: z.boolean().optional().nullable(),
-  started_at: z.number(),
-  first_token_at: z.number().optional().nullable(),
-  finished_at: z.number()
-});
-var spanTypesSchema = z.union([
-  z.literal("span"),
-  z.literal("llm"),
-  z.literal("chain"),
-  z.literal("tool"),
-  z.literal("agent"),
-  z.literal("rag"),
-  z.literal("guardrail"),
-  z.literal("evaluation"),
-  // Low-code
-  z.literal("workflow"),
-  z.literal("component"),
-  // DSPy
-  z.literal("module"),
-  // OpenTelemetry
-  z.literal("server"),
-  z.literal("client"),
-  z.literal("producer"),
-  z.literal("consumer"),
-  // Other
-  z.literal("task"),
-  // openllmetry
-  z.literal("unknown")
-]);
-var baseSpanSchema = z.object({
-  span_id: z.string(),
-  parent_id: z.string().optional().nullable(),
-  trace_id: z.string(),
-  type: spanTypesSchema,
-  name: 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: z.literal("llm"),
-  // TODO: deprecate field, standardize on litellm model names
-  vendor: z.string().optional().nullable(),
-  model: z.string().optional().nullable()
-});
-var rAGSpanSchema = baseSpanSchema.extend({
-  type: z.literal("rag"),
-  contexts: z.array(rAGChunkSchema)
-});
-var spanSchema = z.union([
-  lLMSpanSchema,
-  rAGSpanSchema,
-  baseSpanSchema
-]);
-var spanInputOutputValidatorSchema = spanInputOutputSchema.and(
-  z.object({
-    value: z.any()
-  })
-);
-var spanValidatorSchema = 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(
-  z.object({
-    input: spanInputOutputValidatorSchema.optional().nullable(),
-    output: spanInputOutputValidatorSchema.optional().nullable(),
-    params: z.record(z.string(), z.any()).optional().nullable()
-  })
-);
-var traceInputSchema = z.object({
-  value: z.string()
-});
-var traceOutputSchema = z.object({
-  value: z.string()
-});
-var primitiveTypeSchema = z.union([z.string(), z.number(), z.boolean(), z.undefined()]).nullable();
-var reservedTraceMetadataSchema = z.object({
-  thread_id: z.string().optional().nullable(),
-  user_id: z.string().optional().nullable(),
-  customer_id: z.string().optional().nullable(),
-  labels: z.array(z.string()).optional().nullable(),
-  topic_id: z.string().optional().nullable(),
-  subtopic_id: z.string().optional().nullable(),
-  sdk_name: z.string().optional().nullable(),
-  sdk_version: z.string().optional().nullable(),
-  sdk_language: z.string().optional().nullable(),
-  telemetry_sdk_language: z.string().optional().nullable(),
-  telemetry_sdk_name: z.string().optional().nullable(),
-  telemetry_sdk_version: z.string().optional().nullable(),
-  prompt_ids: z.array(z.string()).optional().nullable(),
-  prompt_version_ids: z.array(z.string()).optional().nullable()
-});
-var reservedTraceMetadataMappingSchema = z.record(
-  z.string(),
-  reservedTraceMetadataSchema.keyof()
-);
-var customMetadataSchema = z.record(
-  z.string(),
-  z.union([
-    primitiveTypeSchema,
-    z.array(primitiveTypeSchema),
-    z.record(z.string(), primitiveTypeSchema),
-    z.record(z.string(), z.record(z.string(), primitiveTypeSchema))
-  ])
-);
-var traceMetadataSchema = reservedTraceMetadataSchema.and(customMetadataSchema);
-var eventSchema = z.object({
-  event_id: z.string(),
-  event_type: z.string(),
-  // Type of event (e.g., 'thumbs_up_down', 'add_to_cart')
-  project_id: z.string(),
-  metrics: z.record(z.string(), z.number()),
-  event_details: z.record(z.string(), z.string()),
-  trace_id: z.string(),
-  timestamps: z.object({
-    started_at: z.number(),
-    inserted_at: z.number(),
-    updated_at: z.number()
-  })
-});
-var elasticSearchEventSchema = eventSchema.omit({ metrics: true, event_details: true }).and(
-  z.object({
-    metrics: z.array(
-      z.object({
-        key: z.string(),
-        value: z.number()
-      })
-    ),
-    event_details: z.array(
-      z.object({
-        key: z.string(),
-        value: z.string()
-      })
-    )
-  })
-);
-var evaluationStatusSchema = z.union([
-  z.literal("scheduled"),
-  z.literal("in_progress"),
-  z.literal("error"),
-  z.literal("skipped"),
-  z.literal("processed")
-]);
-var evaluationSchema = z.object({
-  evaluation_id: z.string(),
-  evaluator_id: z.string(),
-  span_id: z.string().optional().nullable(),
-  name: z.string(),
-  type: z.string().optional().nullable(),
-  is_guardrail: z.boolean().optional().nullable(),
-  evaluation_thread_id: z.string().optional().nullable(),
-  // Thread ID used for thread-based evaluation data
-  status: evaluationStatusSchema,
-  passed: z.boolean().optional().nullable(),
-  score: z.number().optional().nullable(),
-  label: z.string().optional().nullable(),
-  details: z.string().optional().nullable(),
-  inputs: z.record(z.string(), z.any()).optional().nullable(),
-  error: errorCaptureSchema.optional().nullable(),
-  retries: z.number().optional().nullable(),
-  timestamps: z.object({
-    ignore_timestamps_on_write: z.boolean().optional().nullable(),
-    inserted_at: z.number().optional().nullable(),
-    started_at: z.number().optional().nullable(),
-    finished_at: z.number().optional().nullable(),
-    updated_at: z.number().optional().nullable()
-  })
-});
-var rESTEvaluationSchema = evaluationSchema.omit({
-  evaluation_id: true,
-  evaluator_id: true,
-  status: true,
-  timestamps: true,
-  retries: true
-}).and(
-  z.object({
-    evaluation_id: z.string().optional().nullable(),
-    evaluator_id: z.string().optional().nullable(),
-    status: z.union([
-      z.literal("processed"),
-      z.literal("skipped"),
-      z.literal("error")
-    ]).optional().nullable(),
-    timestamps: z.object({
-      started_at: z.number().optional().nullable(),
-      finished_at: z.number().optional().nullable()
-    }).optional().nullable()
-  })
-);
-var tracePrivacySchema = z.object({
-  // Content categories that a `drop` privacy policy stripped before the spans
-  // were stored, derived at read time from the marker the drop stamps on each
-  // span. The content was never stored and cannot be recovered, which is what
-  // distinguishes it from a read-time `restrict` (the data is kept and hidden by
-  // audience, surfaced through the field-redaction path). Absent when nothing
-  // was dropped.
-  droppedCategories: z.array(z.string()).optional()
-});
-var traceSchema = z.object({
-  trace_id: z.string(),
-  project_id: z.string(),
-  metadata: traceMetadataSchema,
-  privacy: tracePrivacySchema.optional(),
-  timestamps: z.object({
-    started_at: z.number(),
-    inserted_at: z.number(),
-    updated_at: z.number()
-  }),
-  input: traceInputSchema.optional(),
-  output: traceOutputSchema.optional(),
-  contexts: z.array(rAGChunkSchema).optional(),
-  expected_output: z.object({
-    value: z.string()
-  }).optional(),
-  metrics: z.object({
-    first_token_ms: z.number().optional().nullable(),
-    total_time_ms: z.number().optional().nullable(),
-    prompt_tokens: z.number().optional().nullable(),
-    completion_tokens: z.number().optional().nullable(),
-    reasoning_tokens: z.number().optional().nullable(),
-    cache_read_input_tokens: z.number().optional().nullable(),
-    cache_creation_input_tokens: z.number().optional().nullable(),
-    total_cost: z.number().optional().nullable(),
-    tokens_estimated: z.boolean().optional().nullable()
-  }).optional(),
-  error: errorCaptureSchema.optional().nullable(),
-  indexing_md5s: z.array(z.string()).optional(),
-  events: z.array(eventSchema).optional(),
-  evaluations: z.array(evaluationSchema).optional(),
-  spans: z.array(spanSchema),
-  // Set server-side when content was teaser-redacted by the plan's
-  // visibility window — the UI renders the upgrade CTA off this flag.
-  redacted_by_visibility_window: z.boolean().optional()
-});
-var lLMModeTraceSchema = traceSchema.omit({ timestamps: true, indexing_md5s: true }).and(
-  z.object({
-    timestamps: z.object({
-      started_at: z.string(),
-      inserted_at: z.string(),
-      updated_at: z.string()
-    }),
-    ascii_tree: z.string()
-  })
-);
-var collectorRESTParamsSchema = z.object({
-  trace_id: z.union([z.string(), z.undefined()]).optional().nullable(),
-  spans: z.array(spanSchema),
-  metadata: z.object({
-    user_id: z.union([z.string(), z.undefined()]).optional().nullable(),
-    thread_id: z.union([z.string(), z.undefined()]).optional().nullable(),
-    customer_id: z.union([z.string(), z.undefined()]).optional().nullable(),
-    labels: z.union([z.array(z.string()), z.undefined()]).optional().nullable(),
-    sdk_version: z.union([z.string(), z.undefined()]).optional().nullable(),
-    sdk_language: z.union([z.string(), z.undefined()]).optional().nullable()
-  }).and(customMetadataSchema).optional(),
-  expected_output: z.string().optional().nullable(),
-  evaluations: z.array(rESTEvaluationSchema).optional()
-});
-var collectorRESTParamsValidatorSchema = collectorRESTParamsSchema.omit({ spans: true });
-var trackEventRESTParamsValidatorSchema = eventSchema.omit({
-  event_id: true,
-  project_id: true,
-  timestamps: true,
-  event_details: true
-}).and(
-  z.object({
-    event_id: z.string().optional(),
-    // auto generated unless you want to guarantee idempotency
-    event_details: z.record(z.string(), z.string().nullable()).optional(),
-    timestamp: z.number().optional()
-    // The timestamp when the event occurred
-  })
-);
-
-// src/observability-sdk/evaluation/index.ts
-import { isSpanContextValid } from "@opentelemetry/api";
-import { generate as generateKsuid } from "xksuid";
-function toEpochMillis(value) {
-  return value instanceof Date ? value.getTime() : value;
-}
-function captureError(error) {
-  if (error instanceof Error) {
-    return {
-      message: String(error),
-      stacktrace: error.stack ? error.stack.split("\n") : []
-    };
-  }
-  return {
-    message: String(error),
-    stacktrace: []
-  };
-}
-function emitEvaluationEvent(span, params) {
-  var _a, _b, _c, _d, _e, _f, _g, _h;
-  const spanContext = span.spanContext();
-  const spanId = spanContext && isSpanContextValid(spanContext) ? spanContext.spanId : null;
-  const payload = {
-    evaluation_id: (_a = params.evaluationId) != null ? _a : `eval_${generateKsuid()}`,
-    span_id: spanId,
-    name: params.name,
-    type: (_b = params.type) != null ? _b : null,
-    is_guardrail: (_c = params.isGuardrail) != null ? _c : null,
-    status: (_d = params.status) != null ? _d : "processed",
-    passed: (_e = params.passed) != null ? _e : null,
-    score: (_f = params.score) != null ? _f : null,
-    label: (_g = params.label) != null ? _g : null,
-    details: (_h = params.details) != null ? _h : null,
-    error: params.error != null ? captureError(params.error) : null,
-    timestamps: params.timestamps ? {
-      started_at: toEpochMillis(params.timestamps.startedAt),
-      finished_at: toEpochMillis(params.timestamps.finishedAt)
-    } : null
-  };
-  span.addEvent(ATTR_LANGWATCH_EVALUATION_CUSTOM, {
-    json_encoded_event: JSON.stringify(payload)
-  });
-}
-
-// src/observability-sdk/span/implementation.ts
-import * as semconv from "@opentelemetry/semantic-conventions/incubating";
-
-// src/observability-sdk/span/input-output.ts
-import { z as z2 } from "zod";
-var simpleChatMessageSchema = z2.object({
-  role: z2.string(),
-  content: z2.union([z2.string(), z2.array(z2.any())]).nullable().optional()
-});
-var simpleChatMessageArraySchema = z2.array(simpleChatMessageSchema);
-function createSafeFallbackValue(value) {
-  if (typeof value === "object" && value !== null) {
-    try {
-      return JSON.stringify(value);
-    } catch (e) {
-      return JSON.stringify({ type: "raw", value: "[Non-Serializable]" });
-    }
-  }
-  return String(value);
-}
-function createSafeSpanInputOutput(type, value) {
-  const safeValue = createSafeFallbackValue(value);
-  return { type, value: safeValue };
-}
-function isString(value) {
-  return typeof value === "string";
-}
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isChatMessage(value) {
-  if (!isObject(value)) return false;
-  return typeof value.role === "string" && (typeof value.content === "string" || value.content === null || value.content === void 0);
-}
-function isChatMessageArray(value) {
-  return Array.isArray(value) && value.every(isChatMessage);
-}
-function processChatMessages(value) {
-  const messages = Array.isArray(value) ? value : [value];
-  const strictResult = z2.array(chatMessageSchema).safeParse(messages);
-  if (strictResult.success) {
-    return { type: "chat_messages", value: strictResult.data };
-  }
-  const simpleResult = simpleChatMessageArraySchema.safeParse(messages);
-  if (simpleResult.success) {
-    return { type: "chat_messages", value: simpleResult.data };
-  }
-  return createSafeSpanInputOutput("text", JSON.stringify(messages));
-}
-function convertToSpanInputOutput(value) {
-  try {
-    if (value === null || value === void 0) {
-      return spanInputOutputSchema.parse({ type: "json", value: null });
-    }
-    if (isString(value)) {
-      return spanInputOutputSchema.parse({ type: "text", value });
-    }
-    if (isChatMessage(value) || Array.isArray(value) && value.length > 0 && isChatMessageArray(value)) {
-      return processChatMessages(value);
-    }
-    if (Array.isArray(value)) {
-      return spanInputOutputSchema.parse({
-        type: "list",
-        value: value.map((item) => convertToSpanInputOutput(item))
-      });
-    }
-    if (isObject(value)) {
-      try {
-        return spanInputOutputSchema.parse({ type: "json", value });
-      } catch (e) {
-        return createSafeSpanInputOutput("text", value);
-      }
-    }
-    return createSafeSpanInputOutput("text", value);
-  } catch (e) {
-    return createSafeSpanInputOutput("text", value);
-  }
-}
-function isValidInputOutputType(type) {
-  return INPUT_OUTPUT_TYPES.includes(type);
-}
-function validateValueForInputOutputType(type, value) {
-  switch (type) {
-    case "chat_messages": {
-      const messages = Array.isArray(value) ? value : [value];
-      const strictResult = z2.array(chatMessageSchema).safeParse(messages);
-      if (strictResult.success) {
-        return strictResult.data;
-      }
-      const simpleResult = simpleChatMessageArraySchema.safeParse(messages);
-      if (simpleResult.success) {
-        return simpleResult.data;
-      }
-      return [{ role: "user", content: createSafeFallbackValue(value) }];
-    }
-    case "list": {
-      const listResult = z2.array(spanInputOutputSchema).safeParse(value);
-      return listResult.success ? listResult.data : [{ type: "text", value: createSafeFallbackValue(value) }];
-    }
-    case "json": {
-      try {
-        JSON.stringify(value);
-        return value;
-      } catch (e) {
-        return createSafeFallbackValue(value);
-      }
-    }
-    case "text":
-    case "raw": {
-      const stringResult = z2.string().safeParse(value);
-      return stringResult.success ? stringResult.data : createSafeFallbackValue(value);
-    }
-    case "guardrail_result":
-    case "evaluation_result": {
-      try {
-        JSON.stringify(value);
-        return value;
-      } catch (e) {
-        return createSafeFallbackValue(value);
-      }
-    }
-    default:
-      return value;
-  }
-}
-function processSpanInputOutput(typeOrValue, value) {
-  try {
-    if (typeof typeOrValue === "string" && value !== void 0) {
-      const type = isValidInputOutputType(typeOrValue) ? typeOrValue : "json";
-      const validatedValue = validateValueForInputOutputType(type, value);
-      const result = spanInputOutputSchema.safeParse({ type, value: validatedValue });
-      return result.success ? result.data : createSafeSpanInputOutput("raw", validatedValue);
-    }
-    return convertToSpanInputOutput(typeOrValue);
-  } catch (e) {
-    return createSafeSpanInputOutput("text", typeOrValue);
-  }
-}
-
-// src/observability-sdk/span/implementation.ts
-var LangWatchSpanInternal = class {
-  constructor(span) {
-    this.span = span;
-  }
-  setAttributes(attributes) {
-    this.span.setAttributes(attributes);
-    return this;
-  }
-  setAttribute(key, value) {
-    this.span.setAttribute(key, value);
-    return this;
-  }
-  addEvent(name, attributes) {
-    this.span.addEvent(name, attributes);
-    return this;
-  }
-  recordException(exception) {
-    this.span.recordException(exception);
-    return this;
-  }
-  setStatus(status) {
-    this.span.setStatus(status);
-    return this;
-  }
-  updateName(name) {
-    this.span.updateName(name);
-    return this;
-  }
-  end(endTime) {
-    this.span.end(endTime);
-  }
-  isRecording() {
-    return this.span.isRecording();
-  }
-  spanContext() {
-    return this.span.spanContext();
-  }
-  addLink(link) {
-    this.span.addLink(link);
-    return this;
-  }
-  addLinks(links) {
-    this.span.addLinks(links);
-    return this;
-  }
-  /**
-   * Records a manual evaluation on this span by emitting the `langwatch.evaluation.custom` span
-   * event. See {@link AddEvaluationParams} for available parameters.
-   */
-  addEvaluation(params) {
-    emitEvaluationEvent(this.span, params);
-    return this;
-  }
-  /**
-   * @deprecated Use {@link addEvaluation} instead. Thin back-compat alias kept for
-   * the earlier documented name.
-   */
-  recordEvaluation(params) {
-    return this.addEvaluation(params);
-  }
-  setType(type) {
-    return this.setAttribute(ATTR_LANGWATCH_SPAN_TYPE, type);
-  }
-  setSelectedPrompt(prompt) {
-    return this.setAttributes({
-      [ATTR_LANGWATCH_PROMPT_SELECTED_ID]: prompt.id,
-      [ATTR_LANGWATCH_PROMPT_ID]: prompt.id,
-      [ATTR_LANGWATCH_PROMPT_VERSION_ID]: prompt.versionId,
-      [ATTR_LANGWATCH_PROMPT_VERSION_NUMBER]: prompt.version
-    });
-  }
-  setRequestModel(model) {
-    return this.setAttribute(semconv.ATTR_GEN_AI_REQUEST_MODEL, model);
-  }
-  setResponseModel(model) {
-    return this.setAttribute(semconv.ATTR_GEN_AI_RESPONSE_MODEL, model);
-  }
-  setRAGContexts(ragContexts) {
-    return this.setAttribute(
-      ATTR_LANGWATCH_RAG_CONTEXTS,
-      JSON.stringify(ragContexts)
-    );
-  }
-  setRAGContext(ragContext) {
-    return this.setRAGContexts([ragContext]);
-  }
-  setMetrics(metrics) {
-    return this.setAttribute(
-      ATTR_LANGWATCH_METRICS,
-      JSON.stringify({
-        type: "json",
-        value: metrics
-      })
-    );
-  }
-  setInput(typeOrInput, input) {
-    const spanInput = processSpanInputOutput(typeOrInput, input);
-    return this.setAttribute(
-      ATTR_LANGWATCH_INPUT,
-      JSON.stringify(spanInput)
-    );
-  }
-  setOutput(typeOrOutput, output) {
-    const spanOutput = processSpanInputOutput(typeOrOutput, output);
-    return this.setAttribute(
-      ATTR_LANGWATCH_OUTPUT,
-      JSON.stringify(spanOutput)
-    );
-  }
-};
-function createLangWatchSpan(span) {
-  return new LangWatchSpanInternal(span);
-}
-
-// src/observability-sdk/tracer/implementation.ts
-import {
-  SpanStatusCode,
-  trace
-} from "@opentelemetry/api";
-function getLangWatchTracer(name, version) {
-  return getLangWatchTracerFromProvider(
-    trace.getTracerProvider(),
-    name,
-    version
-  );
-}
-function getLangWatchTracerFromProvider(tracerProvider, name, version) {
-  const tracer = tracerProvider.getTracer(name, version);
-  let proxyInstance;
-  const handler = {
-    get(target, prop) {
-      switch (prop) {
-        case "startActiveSpan":
-          return (...args) => {
-            const spanArgs = normalizeSpanArgs(args);
-            const options = withDefaultOrigin(spanArgs.options);
-            const wrappedFn = (span, ...cbArgs) => spanArgs.fn(createLangWatchSpan(span), ...cbArgs);
-            if (spanArgs.context !== void 0)
-              return target.startActiveSpan(spanArgs.name, options, spanArgs.context, wrappedFn);
-            return target.startActiveSpan(spanArgs.name, options, wrappedFn);
-          };
-        case "withActiveSpan":
-          return (...args) => {
-            const spanArgs = normalizeSpanArgs(args);
-            const optionsWithOrigin = withDefaultOrigin(spanArgs.options);
-            const cb = (span) => {
-              var _a, _b;
-              const wrappedSpan = createLangWatchSpan(span);
-              try {
-                const result = spanArgs.fn(wrappedSpan);
-                if (result && typeof result.then === "function") {
-                  return result.then((result2) => {
-                    wrappedSpan.setStatus({
-                      code: SpanStatusCode.OK
-                    });
-                    return result2;
-                  }).catch((err) => {
-                    var _a2, _b2;
-                    wrappedSpan.setStatus({
-                      code: SpanStatusCode.ERROR,
-                      message: (_a2 = err == null ? void 0 : err.message) != null ? _a2 : String(err)
-                    });
-                    (_b2 = wrappedSpan.recordException) == null ? void 0 : _b2.call(wrappedSpan, err);
-                    throw err;
-                  }).finally(() => {
-                    wrappedSpan.end();
-                  });
-                }
-                wrappedSpan.setStatus({
-                  code: SpanStatusCode.OK
-                });
-                wrappedSpan.end();
-                return result;
-              } catch (err) {
-                wrappedSpan.setStatus({
-                  code: SpanStatusCode.ERROR,
-                  message: (_a = err == null ? void 0 : err.message) != null ? _a : String(err)
-                });
-                (_b = wrappedSpan.recordException) == null ? void 0 : _b.call(wrappedSpan, err);
-                wrappedSpan.end();
-                throw err;
-              }
-            };
-            if (spanArgs.context !== void 0)
-              return target.startActiveSpan(spanArgs.name, optionsWithOrigin, spanArgs.context, cb);
-            return target.startActiveSpan(spanArgs.name, optionsWithOrigin, cb);
-          };
-        case "startSpan":
-          return (name2, options, context) => createLangWatchSpan(target.startSpan(name2, withDefaultOrigin(options), context));
-        case "addEvaluation":
-          return (params) => {
-            const activeSpan = trace.getActiveSpan();
-            if (!activeSpan) return;
-            emitEvaluationEvent(activeSpan, params);
-          };
-        default: {
-          const value = target[prop];
-          return typeof value === "function" ? value.bind(target) : value;
-        }
-      }
-    }
-  };
-  proxyInstance = new Proxy(tracer, handler);
-  return proxyInstance;
-}
-function normalizeSpanArgs(args) {
-  const [name, arg2, arg3, arg4] = args;
-  if (typeof arg4 === "function")
-    return { name, options: arg2, context: arg3, fn: arg4 };
-  if (typeof arg3 === "function") return { name, options: arg2, fn: arg3 };
-  if (typeof arg2 === "function") return { name, fn: arg2 };
-  throw new Error("Expected a span callback as the last argument");
-}
-function withDefaultOrigin(options) {
-  var _a;
-  const existing = (_a = options == null ? void 0 : options.attributes) == null ? void 0 : _a["langwatch.origin"];
-  if (existing) return options != null ? options : {};
-  return __spreadProps(__spreadValues({}, options), {
-    attributes: __spreadProps(__spreadValues({}, options == null ? void 0 : options.attributes), {
-      "langwatch.origin": "application"
-    })
-  });
-}
-
-export {
-  spanTypes,
-  chatMessageSchema,
-  emitEvaluationEvent,
-  createLangWatchSpan,
-  getLangWatchTracer,
-  getLangWatchTracerFromProvider
-};
-//# sourceMappingURL=chunk-C323F5VC.mjs.map