langwatch 0.33.0 → 0.33.2

package/dist/chunk-Y4VNZ6M4.mjs

@@ -1,842 +0,0 @@
-import {
-  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
-} from "./chunk-GVFRS2UN.mjs";
-import {
-  __spreadProps,
-  __spreadValues
-} from "./chunk-BAX4W3AY.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"),
-  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()
-  })
-]);
-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 traceSchema = z.object({
-  trace_id: z.string(),
-  project_id: z.string(),
-  metadata: traceMetadataSchema,
-  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)
-});
-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/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;
-  }
-  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));
-        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,
-  createLangWatchSpan,
-  getLangWatchTracer,
-  getLangWatchTracerFromProvider
-};
-//# sourceMappingURL=chunk-Y4VNZ6M4.mjs.map