langwatch 0.30.0 → 0.32.0

package/dist/chunk-HLWOZ2EB.js

@@ -0,0 +1,842 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } }
+
+
+
+
+
+
+
+
+
+var _chunkVS22JXRYjs = require('./chunk-VS22JXRY.js');
+
+
+
+var _chunkBRPEG3YQjs = require('./chunk-BRPEG3YQ.js');
+
+// 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
+var _zod = require('zod');
+var chatRoleSchema = _zod.z.union([
+  _zod.z.literal("system"),
+  _zod.z.literal("user"),
+  _zod.z.literal("assistant"),
+  _zod.z.literal("function"),
+  _zod.z.literal("tool"),
+  _zod.z.literal("unknown")
+]);
+var functionCallSchema = _zod.z.object({
+  name: _zod.z.string().optional(),
+  arguments: _zod.z.string().optional()
+});
+var toolCallSchema = _zod.z.object({
+  id: _zod.z.string(),
+  type: _zod.z.string(),
+  function: functionCallSchema
+});
+var rAGChunkSchema = _zod.z.object({
+  document_id: _zod.z.string().optional().nullable(),
+  chunk_id: _zod.z.string().optional().nullable(),
+  content: _zod.z.union([_zod.z.string(), _zod.z.record(_zod.z.string(), _zod.z.any()), _zod.z.array(_zod.z.any())])
+});
+var contextsSchema = _zod.z.object({
+  traceId: _zod.z.string(),
+  contexts: _zod.z.array(rAGChunkSchema)
+});
+var chatRichContentSchema = _zod.z.union([
+  _zod.z.object({
+    type: _zod.z.literal("text"),
+    text: _zod.z.string().optional(),
+    /** pi-ai uses `content` instead of `text` inside text blocks */
+    content: _zod.z.string().optional()
+  }),
+  _zod.z.object({
+    text: _zod.z.string()
+  }),
+  _zod.z.object({
+    type: _zod.z.literal("image_url"),
+    image_url: _zod.z.object({
+      url: _zod.z.string(),
+      detail: _zod.z.union([_zod.z.literal("auto"), _zod.z.literal("low"), _zod.z.literal("high")]).optional()
+    }).optional()
+  }),
+  _zod.z.object({
+    type: _zod.z.literal("tool_call"),
+    toolName: _zod.z.string().optional(),
+    toolCallId: _zod.z.string().optional(),
+    args: _zod.z.string().optional()
+  }),
+  _zod.z.object({
+    type: _zod.z.literal("tool_result"),
+    toolName: _zod.z.string().optional(),
+    toolCallId: _zod.z.string().optional(),
+    result: _zod.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}.
+   */
+  _zod.z.object({
+    type: _zod.z.literal("binary"),
+    mimeType: _zod.z.string(),
+    data: _zod.z.string().optional(),
+    url: _zod.z.string().optional(),
+    id: _zod.z.string().optional(),
+    filename: _zod.z.string().optional()
+  })
+]);
+var chatMessageSchema = _zod.z.object({
+  role: chatRoleSchema.optional(),
+  content: _zod.z.union([_zod.z.string(), _zod.z.array(chatRichContentSchema)]).optional().nullable(),
+  /** Vercel AI SDK / pi-ai use `parts` instead of `content` */
+  parts: _zod.z.array(chatRichContentSchema).optional(),
+  function_call: functionCallSchema.optional().nullable(),
+  tool_calls: _zod.z.array(toolCallSchema).optional().nullable(),
+  tool_call_id: _zod.z.string().optional().nullable(),
+  name: _zod.z.string().optional().nullable(),
+  reasoning_content: _zod.z.string().optional().nullable()
+});
+var typedValueTextSchema = _zod.z.object({
+  type: _zod.z.literal("text"),
+  value: _zod.z.string()
+});
+var typedValueRawSchema = _zod.z.object({
+  type: _zod.z.literal("raw"),
+  value: _zod.z.string()
+});
+var jSONSerializableSchema = _zod.z.union([
+  _zod.z.string(),
+  _zod.z.number(),
+  _zod.z.boolean(),
+  _zod.z.record(_zod.z.string(), _zod.z.any()),
+  _zod.z.array(_zod.z.any())
+]).nullable();
+var typedValueJsonSchema = _zod.z.object({
+  type: _zod.z.literal("json"),
+  value: jSONSerializableSchema
+});
+var moneySchema = _zod.z.object({
+  currency: _zod.z.string(),
+  amount: _zod.z.number()
+});
+var evaluationResultSchema = _zod.z.object({
+  status: _zod.z.union([
+    _zod.z.literal("processed"),
+    _zod.z.literal("skipped"),
+    _zod.z.literal("error")
+  ]),
+  passed: _zod.z.boolean().optional().nullable(),
+  score: _zod.z.number().optional().nullable(),
+  label: _zod.z.string().optional().nullable(),
+  details: _zod.z.string().optional().nullable(),
+  cost: moneySchema.optional().nullable()
+});
+var typedValueGuardrailResultSchema = _zod.z.object({
+  type: _zod.z.literal("guardrail_result"),
+  value: evaluationResultSchema
+});
+var typedValueEvaluationResultSchema = _zod.z.object({
+  type: _zod.z.literal("evaluation_result"),
+  value: evaluationResultSchema
+});
+var typedValueChatMessagesSchema = _zod.z.object({
+  type: _zod.z.literal("chat_messages"),
+  value: _zod.z.array(chatMessageSchema)
+});
+var spanInputOutputSchema = _zod.z.lazy(
+  () => _zod.z.union([
+    typedValueTextSchema,
+    typedValueChatMessagesSchema,
+    typedValueGuardrailResultSchema,
+    typedValueEvaluationResultSchema,
+    typedValueJsonSchema,
+    typedValueRawSchema,
+    _zod.z.object({
+      type: _zod.z.literal("list"),
+      value: _zod.z.array(spanInputOutputSchema)
+    })
+  ])
+);
+var errorCaptureSchema = _zod.z.object({
+  has_error: _zod.z.literal(true),
+  message: _zod.z.string(),
+  stacktrace: _zod.z.array(_zod.z.string())
+});
+var spanMetricsSchema = _zod.z.object({
+  prompt_tokens: _zod.z.number().optional().nullable(),
+  completion_tokens: _zod.z.number().optional().nullable(),
+  reasoning_tokens: _zod.z.number().optional().nullable(),
+  cache_read_input_tokens: _zod.z.number().optional().nullable(),
+  cache_creation_input_tokens: _zod.z.number().optional().nullable(),
+  tokens_estimated: _zod.z.boolean().optional().nullable(),
+  cost: _zod.z.number().optional().nullable()
+});
+var reservedSpanParamsSchema = _zod.z.object({
+  frequency_penalty: _zod.z.number().optional().nullable(),
+  logit_bias: _zod.z.record(_zod.z.string(), _zod.z.number()).optional().nullable(),
+  logprobs: _zod.z.boolean().optional().nullable(),
+  top_logprobs: _zod.z.number().optional().nullable(),
+  max_tokens: _zod.z.number().optional().nullable(),
+  n: _zod.z.number().optional().nullable(),
+  presence_penalty: _zod.z.number().optional().nullable(),
+  seed: _zod.z.number().optional().nullable(),
+  stop: _zod.z.union([_zod.z.string(), _zod.z.array(_zod.z.string())]).optional().nullable(),
+  stream: _zod.z.boolean().optional().nullable(),
+  temperature: _zod.z.number().optional().nullable(),
+  top_p: _zod.z.number().optional().nullable(),
+  tools: _zod.z.array(_zod.z.record(_zod.z.string(), _zod.z.any())).optional().nullable(),
+  tool_choice: _zod.z.union([_zod.z.record(_zod.z.string(), _zod.z.any()), _zod.z.string()]).optional().nullable(),
+  parallel_tool_calls: _zod.z.boolean().optional().nullable(),
+  functions: _zod.z.array(_zod.z.record(_zod.z.string(), _zod.z.any())).optional().nullable(),
+  user: _zod.z.string().optional().nullable(),
+  reasoning_effort: _zod.z.string().optional().nullable()
+});
+var spanParamsSchema = reservedSpanParamsSchema.and(
+  _zod.z.record(_zod.z.string(), _zod.z.any())
+);
+var spanTimestampsSchema = _zod.z.object({
+  ignore_timestamps_on_write: _zod.z.boolean().optional().nullable(),
+  started_at: _zod.z.number(),
+  first_token_at: _zod.z.number().optional().nullable(),
+  finished_at: _zod.z.number()
+});
+var spanTypesSchema = _zod.z.union([
+  _zod.z.literal("span"),
+  _zod.z.literal("llm"),
+  _zod.z.literal("chain"),
+  _zod.z.literal("tool"),
+  _zod.z.literal("agent"),
+  _zod.z.literal("rag"),
+  _zod.z.literal("guardrail"),
+  _zod.z.literal("evaluation"),
+  // Low-code
+  _zod.z.literal("workflow"),
+  _zod.z.literal("component"),
+  // DSPy
+  _zod.z.literal("module"),
+  // OpenTelemetry
+  _zod.z.literal("server"),
+  _zod.z.literal("client"),
+  _zod.z.literal("producer"),
+  _zod.z.literal("consumer"),
+  // Other
+  _zod.z.literal("task"),
+  // openllmetry
+  _zod.z.literal("unknown")
+]);
+var baseSpanSchema = _zod.z.object({
+  span_id: _zod.z.string(),
+  parent_id: _zod.z.string().optional().nullable(),
+  trace_id: _zod.z.string(),
+  type: spanTypesSchema,
+  name: _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: _zod.z.literal("llm"),
+  // TODO: deprecate field, standardize on litellm model names
+  vendor: _zod.z.string().optional().nullable(),
+  model: _zod.z.string().optional().nullable()
+});
+var rAGSpanSchema = baseSpanSchema.extend({
+  type: _zod.z.literal("rag"),
+  contexts: _zod.z.array(rAGChunkSchema)
+});
+var spanSchema = _zod.z.union([lLMSpanSchema, rAGSpanSchema, baseSpanSchema]);
+var spanInputOutputValidatorSchema = spanInputOutputSchema.and(
+  _zod.z.object({
+    value: _zod.z.any()
+  })
+);
+var spanValidatorSchema = _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(
+  _zod.z.object({
+    input: spanInputOutputValidatorSchema.optional().nullable(),
+    output: spanInputOutputValidatorSchema.optional().nullable(),
+    params: _zod.z.record(_zod.z.string(), _zod.z.any()).optional().nullable()
+  })
+);
+var traceInputSchema = _zod.z.object({
+  value: _zod.z.string()
+});
+var traceOutputSchema = _zod.z.object({
+  value: _zod.z.string()
+});
+var primitiveTypeSchema = _zod.z.union([_zod.z.string(), _zod.z.number(), _zod.z.boolean(), _zod.z.undefined()]).nullable();
+var reservedTraceMetadataSchema = _zod.z.object({
+  thread_id: _zod.z.string().optional().nullable(),
+  user_id: _zod.z.string().optional().nullable(),
+  customer_id: _zod.z.string().optional().nullable(),
+  labels: _zod.z.array(_zod.z.string()).optional().nullable(),
+  topic_id: _zod.z.string().optional().nullable(),
+  subtopic_id: _zod.z.string().optional().nullable(),
+  sdk_name: _zod.z.string().optional().nullable(),
+  sdk_version: _zod.z.string().optional().nullable(),
+  sdk_language: _zod.z.string().optional().nullable(),
+  telemetry_sdk_language: _zod.z.string().optional().nullable(),
+  telemetry_sdk_name: _zod.z.string().optional().nullable(),
+  telemetry_sdk_version: _zod.z.string().optional().nullable(),
+  prompt_ids: _zod.z.array(_zod.z.string()).optional().nullable(),
+  prompt_version_ids: _zod.z.array(_zod.z.string()).optional().nullable()
+});
+var reservedTraceMetadataMappingSchema = _zod.z.record(
+  _zod.z.string(),
+  reservedTraceMetadataSchema.keyof()
+);
+var customMetadataSchema = _zod.z.record(
+  _zod.z.string(),
+  _zod.z.union([
+    primitiveTypeSchema,
+    _zod.z.array(primitiveTypeSchema),
+    _zod.z.record(_zod.z.string(), primitiveTypeSchema),
+    _zod.z.record(_zod.z.string(), _zod.z.record(_zod.z.string(), primitiveTypeSchema))
+  ])
+);
+var traceMetadataSchema = reservedTraceMetadataSchema.and(customMetadataSchema);
+var eventSchema = _zod.z.object({
+  event_id: _zod.z.string(),
+  event_type: _zod.z.string(),
+  // Type of event (e.g., 'thumbs_up_down', 'add_to_cart')
+  project_id: _zod.z.string(),
+  metrics: _zod.z.record(_zod.z.string(), _zod.z.number()),
+  event_details: _zod.z.record(_zod.z.string(), _zod.z.string()),
+  trace_id: _zod.z.string(),
+  timestamps: _zod.z.object({
+    started_at: _zod.z.number(),
+    inserted_at: _zod.z.number(),
+    updated_at: _zod.z.number()
+  })
+});
+var elasticSearchEventSchema = eventSchema.omit({ metrics: true, event_details: true }).and(
+  _zod.z.object({
+    metrics: _zod.z.array(
+      _zod.z.object({
+        key: _zod.z.string(),
+        value: _zod.z.number()
+      })
+    ),
+    event_details: _zod.z.array(
+      _zod.z.object({
+        key: _zod.z.string(),
+        value: _zod.z.string()
+      })
+    )
+  })
+);
+var evaluationStatusSchema = _zod.z.union([
+  _zod.z.literal("scheduled"),
+  _zod.z.literal("in_progress"),
+  _zod.z.literal("error"),
+  _zod.z.literal("skipped"),
+  _zod.z.literal("processed")
+]);
+var evaluationSchema = _zod.z.object({
+  evaluation_id: _zod.z.string(),
+  evaluator_id: _zod.z.string(),
+  span_id: _zod.z.string().optional().nullable(),
+  name: _zod.z.string(),
+  type: _zod.z.string().optional().nullable(),
+  is_guardrail: _zod.z.boolean().optional().nullable(),
+  evaluation_thread_id: _zod.z.string().optional().nullable(),
+  // Thread ID used for thread-based evaluation data
+  status: evaluationStatusSchema,
+  passed: _zod.z.boolean().optional().nullable(),
+  score: _zod.z.number().optional().nullable(),
+  label: _zod.z.string().optional().nullable(),
+  details: _zod.z.string().optional().nullable(),
+  inputs: _zod.z.record(_zod.z.string(), _zod.z.any()).optional().nullable(),
+  error: errorCaptureSchema.optional().nullable(),
+  retries: _zod.z.number().optional().nullable(),
+  timestamps: _zod.z.object({
+    ignore_timestamps_on_write: _zod.z.boolean().optional().nullable(),
+    inserted_at: _zod.z.number().optional().nullable(),
+    started_at: _zod.z.number().optional().nullable(),
+    finished_at: _zod.z.number().optional().nullable(),
+    updated_at: _zod.z.number().optional().nullable()
+  })
+});
+var rESTEvaluationSchema = evaluationSchema.omit({
+  evaluation_id: true,
+  evaluator_id: true,
+  status: true,
+  timestamps: true,
+  retries: true
+}).and(
+  _zod.z.object({
+    evaluation_id: _zod.z.string().optional().nullable(),
+    evaluator_id: _zod.z.string().optional().nullable(),
+    status: _zod.z.union([
+      _zod.z.literal("processed"),
+      _zod.z.literal("skipped"),
+      _zod.z.literal("error")
+    ]).optional().nullable(),
+    timestamps: _zod.z.object({
+      started_at: _zod.z.number().optional().nullable(),
+      finished_at: _zod.z.number().optional().nullable()
+    }).optional().nullable()
+  })
+);
+var traceSchema = _zod.z.object({
+  trace_id: _zod.z.string(),
+  project_id: _zod.z.string(),
+  metadata: traceMetadataSchema,
+  timestamps: _zod.z.object({
+    started_at: _zod.z.number(),
+    inserted_at: _zod.z.number(),
+    updated_at: _zod.z.number()
+  }),
+  input: traceInputSchema.optional(),
+  output: traceOutputSchema.optional(),
+  contexts: _zod.z.array(rAGChunkSchema).optional(),
+  expected_output: _zod.z.object({
+    value: _zod.z.string()
+  }).optional(),
+  metrics: _zod.z.object({
+    first_token_ms: _zod.z.number().optional().nullable(),
+    total_time_ms: _zod.z.number().optional().nullable(),
+    prompt_tokens: _zod.z.number().optional().nullable(),
+    completion_tokens: _zod.z.number().optional().nullable(),
+    reasoning_tokens: _zod.z.number().optional().nullable(),
+    cache_read_input_tokens: _zod.z.number().optional().nullable(),
+    cache_creation_input_tokens: _zod.z.number().optional().nullable(),
+    total_cost: _zod.z.number().optional().nullable(),
+    tokens_estimated: _zod.z.boolean().optional().nullable()
+  }).optional(),
+  error: errorCaptureSchema.optional().nullable(),
+  indexing_md5s: _zod.z.array(_zod.z.string()).optional(),
+  events: _zod.z.array(eventSchema).optional(),
+  evaluations: _zod.z.array(evaluationSchema).optional(),
+  spans: _zod.z.array(spanSchema)
+});
+var lLMModeTraceSchema = traceSchema.omit({ timestamps: true, indexing_md5s: true }).and(
+  _zod.z.object({
+    timestamps: _zod.z.object({
+      started_at: _zod.z.string(),
+      inserted_at: _zod.z.string(),
+      updated_at: _zod.z.string()
+    }),
+    ascii_tree: _zod.z.string()
+  })
+);
+var collectorRESTParamsSchema = _zod.z.object({
+  trace_id: _zod.z.union([_zod.z.string(), _zod.z.undefined()]).optional().nullable(),
+  spans: _zod.z.array(spanSchema),
+  metadata: _zod.z.object({
+    user_id: _zod.z.union([_zod.z.string(), _zod.z.undefined()]).optional().nullable(),
+    thread_id: _zod.z.union([_zod.z.string(), _zod.z.undefined()]).optional().nullable(),
+    customer_id: _zod.z.union([_zod.z.string(), _zod.z.undefined()]).optional().nullable(),
+    labels: _zod.z.union([_zod.z.array(_zod.z.string()), _zod.z.undefined()]).optional().nullable(),
+    sdk_version: _zod.z.union([_zod.z.string(), _zod.z.undefined()]).optional().nullable(),
+    sdk_language: _zod.z.union([_zod.z.string(), _zod.z.undefined()]).optional().nullable()
+  }).and(customMetadataSchema).optional(),
+  expected_output: _zod.z.string().optional().nullable(),
+  evaluations: _zod.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(
+  _zod.z.object({
+    event_id: _zod.z.string().optional(),
+    // auto generated unless you want to guarantee idempotency
+    event_details: _zod.z.record(_zod.z.string(), _zod.z.string().nullable()).optional(),
+    timestamp: _zod.z.number().optional()
+    // The timestamp when the event occurred
+  })
+);
+
+// src/observability-sdk/span/implementation.ts
+var _incubating = require('@opentelemetry/semantic-conventions/incubating'); var semconv = _interopRequireWildcard(_incubating);
+
+// src/observability-sdk/span/input-output.ts
+
+var simpleChatMessageSchema = _zod.z.object({
+  role: _zod.z.string(),
+  content: _zod.z.union([_zod.z.string(), _zod.z.array(_zod.z.any())]).nullable().optional()
+});
+var simpleChatMessageArraySchema = _zod.z.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 = _zod.z.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 = _zod.z.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 = _zod.z.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 = _zod.z.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;
+  }
+  setType(type) {
+    return this.setAttribute(_chunkVS22JXRYjs.ATTR_LANGWATCH_SPAN_TYPE, type);
+  }
+  setSelectedPrompt(prompt) {
+    return this.setAttributes({
+      [_chunkVS22JXRYjs.ATTR_LANGWATCH_PROMPT_SELECTED_ID]: prompt.id,
+      [_chunkVS22JXRYjs.ATTR_LANGWATCH_PROMPT_ID]: prompt.id,
+      [_chunkVS22JXRYjs.ATTR_LANGWATCH_PROMPT_VERSION_ID]: prompt.versionId,
+      [_chunkVS22JXRYjs.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(
+      _chunkVS22JXRYjs.ATTR_LANGWATCH_RAG_CONTEXTS,
+      JSON.stringify(ragContexts)
+    );
+  }
+  setRAGContext(ragContext) {
+    return this.setRAGContexts([ragContext]);
+  }
+  setMetrics(metrics) {
+    return this.setAttribute(
+      _chunkVS22JXRYjs.ATTR_LANGWATCH_METRICS,
+      JSON.stringify({
+        type: "json",
+        value: metrics
+      })
+    );
+  }
+  setInput(typeOrInput, input) {
+    const spanInput = processSpanInputOutput(typeOrInput, input);
+    return this.setAttribute(
+      _chunkVS22JXRYjs.ATTR_LANGWATCH_INPUT,
+      JSON.stringify(spanInput)
+    );
+  }
+  setOutput(typeOrOutput, output) {
+    const spanOutput = processSpanInputOutput(typeOrOutput, output);
+    return this.setAttribute(
+      _chunkVS22JXRYjs.ATTR_LANGWATCH_OUTPUT,
+      JSON.stringify(spanOutput)
+    );
+  }
+};
+function createLangWatchSpan(span) {
+  return new LangWatchSpanInternal(span);
+}
+
+// src/observability-sdk/tracer/implementation.ts
+
+
+
+var _api = require('@opentelemetry/api');
+function getLangWatchTracer(name, version) {
+  return getLangWatchTracerFromProvider(
+    _api.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: _api.SpanStatusCode.OK
+                    });
+                    return result2;
+                  }).catch((err) => {
+                    var _a2, _b2;
+                    wrappedSpan.setStatus({
+                      code: _api.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: _api.SpanStatusCode.OK
+                });
+                wrappedSpan.end();
+                return result;
+              } catch (err) {
+                wrappedSpan.setStatus({
+                  code: _api.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));
+        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 _chunkBRPEG3YQjs.__spreadProps.call(void 0, _chunkBRPEG3YQjs.__spreadValues.call(void 0, {}, options), {
+    attributes: _chunkBRPEG3YQjs.__spreadProps.call(void 0, _chunkBRPEG3YQjs.__spreadValues.call(void 0, {}, options == null ? void 0 : options.attributes), {
+      "langwatch.origin": "application"
+    })
+  });
+}
+
+
+
+
+
+
+
+exports.spanTypes = spanTypes; exports.chatMessageSchema = chatMessageSchema; exports.createLangWatchSpan = createLangWatchSpan; exports.getLangWatchTracer = getLangWatchTracer; exports.getLangWatchTracerFromProvider = getLangWatchTracerFromProvider;
+//# sourceMappingURL=chunk-HLWOZ2EB.js.map