langwatch 0.30.0 → 0.32.0

package/dist/chunk-Y4VNZ6M4.mjs

@@ -0,0 +1,842 @@
+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