langwatch 0.2.0 → 0.3.0-prerelease.2

package/dist/observability/instrumentation/langchain/index.mjs

@@ -0,0 +1,666 @@
+import {
+  canAutomaticallyCaptureInput,
+  canAutomaticallyCaptureOutput
+} from "../../../chunk-QEWDG5QE.mjs";
+import {
+  getLangWatchTracer
+} from "../../../chunk-PMBEK6YE.mjs";
+import {
+  ATTR_LANGWATCH_LANGCHAIN_EVENT_NAME,
+  ATTR_LANGWATCH_LANGCHAIN_RUN_EXTRA_PARAMS,
+  ATTR_LANGWATCH_LANGCHAIN_RUN_ID,
+  ATTR_LANGWATCH_LANGCHAIN_RUN_METADATA,
+  ATTR_LANGWATCH_LANGCHAIN_RUN_PARENT_ID,
+  ATTR_LANGWATCH_LANGCHAIN_RUN_TAGS,
+  ATTR_LANGWATCH_LANGCHAIN_RUN_TYPE,
+  ATTR_LANGWATCH_LANGCHAIN_TAGS,
+  EVNT_LANGWATCH_LANGCHAIN_CALLBACK,
+  __spreadValues
+} from "../../../chunk-4BZATFKJ.mjs";
+
+// src/observability/instrumentation/langchain/index.ts
+import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
+import {
+  AIMessage,
+  AIMessageChunk,
+  FunctionMessage,
+  FunctionMessageChunk,
+  HumanMessage,
+  HumanMessageChunk,
+  SystemMessage,
+  SystemMessageChunk,
+  ToolMessage,
+  ToolMessageChunk,
+  mapChatMessagesToStoredMessages
+} from "@langchain/core/messages";
+import { context, trace, SpanStatusCode } from "@opentelemetry/api";
+
+// src/internal/generated/types/tracer.generated.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 chatRichContentSchema = z.union([
+  z.object({
+    type: z.literal("text"),
+    text: 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()
+  })
+]);
+var chatMessageSchema = z.object({
+  role: chatRoleSchema.optional(),
+  content: z.union([z.string(), z.array(chatRichContentSchema)]).optional().nullable(),
+  function_call: functionCallSchema.optional().nullable(),
+  tool_calls: z.array(toolCallSchema).optional().nullable(),
+  tool_call_id: z.string().optional().nullable(),
+  name: 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(),
+  tokens_estimated: z.boolean().optional().nullable(),
+  cost: z.number().optional().nullable()
+});
+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"),
+  z.literal("workflow"),
+  z.literal("component"),
+  z.literal("module"),
+  z.literal("server"),
+  z.literal("client"),
+  z.literal("producer"),
+  z.literal("consumer"),
+  z.literal("task"),
+  z.literal("unknown")
+]);
+var spanInputOutputValidatorSchema = spanInputOutputSchema.and(
+  z.object({
+    value: z.any()
+  })
+);
+var traceInputSchema = z.object({
+  value: z.string(),
+  satisfaction_score: z.number().optional()
+});
+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 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(),
+  status: evaluationStatusSchema,
+  passed: z.boolean().optional().nullable(),
+  score: z.number().optional().nullable(),
+  label: z.string().optional().nullable(),
+  details: z.string().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 contextsSchema = z.object({
+  traceId: z.string(),
+  contexts: z.array(rAGChunkSchema)
+});
+
+// src/observability/instrumentation/langchain/index.ts
+import { z as z2 } from "zod";
+var LangWatchCallbackHandler = class extends BaseCallbackHandler {
+  constructor() {
+    super();
+    this.name = "LangWatchCallbackHandler";
+    this.tracer = getLangWatchTracer("langwatch.instrumentation.langchain");
+    this.spans = {};
+  }
+  getParentContext(parentRunId) {
+    if (parentRunId && this.spans[parentRunId]) {
+      return trace.setSpan(context.active(), this.spans[parentRunId]);
+    }
+    return context.active();
+  }
+  getSpan(runId) {
+    return this.spans[runId];
+  }
+  async handleLLMStart(llm, prompts, runId, parentRunId, extraParams, _tags, metadata, name) {
+    var _a, _b, _c;
+    const parentContext = this.getParentContext(parentRunId);
+    const span = this.tracer.startSpan(
+      (_c = name != null ? name : (_b = (_a = llm.id) == null ? void 0 : _a[llm.id.length - 1]) == null ? void 0 : _b.toString()) != null ? _c : "llm",
+      {},
+      parentContext
+    );
+    span.setType("llm");
+    if (canAutomaticallyCaptureInput()) {
+      span.setInput(prompts);
+    }
+    if (_tags) {
+      span.setAttribute(ATTR_LANGWATCH_LANGCHAIN_RUN_TAGS, _tags);
+    }
+    if (extraParams) {
+      span.setAttributes(
+        Object.fromEntries(
+          Object.entries(extraParams).map(([key, value]) => [
+            [`${ATTR_LANGWATCH_LANGCHAIN_RUN_EXTRA_PARAMS}.${key}`],
+            wrapNonScalarValues(value)
+          ])
+        )
+      );
+    }
+    if (metadata) {
+      if (metadata.ls_model_name) {
+        span.setRequestModel(metadata.ls_model_name);
+        metadata.ls_model_name = void 0;
+      }
+      span.setAttributes(
+        Object.fromEntries(
+          Object.entries(metadata).map(([key, value]) => [
+            [`${ATTR_LANGWATCH_LANGCHAIN_RUN_METADATA}.${key}`],
+            wrapNonScalarValues(value)
+          ])
+        )
+      );
+    }
+    this.spans[runId] = span;
+  }
+  async handleChatModelStart(llm, messages, runId, parentRunId, extraParams, _tags, metadata, name) {
+    var _a, _b, _c;
+    const parentContext = this.getParentContext(parentRunId);
+    const span = this.tracer.startSpan(
+      (_c = name != null ? name : (_b = (_a = llm.id) == null ? void 0 : _a[llm.id.length - 1]) == null ? void 0 : _b.toString()) != null ? _c : "chat_model",
+      {},
+      parentContext
+    );
+    span.setType("llm");
+    if (canAutomaticallyCaptureInput()) {
+      span.setInput(messages.flatMap(convertFromLangChainMessages));
+    }
+    if (_tags) {
+      span.setAttribute(ATTR_LANGWATCH_LANGCHAIN_RUN_TAGS, _tags);
+    }
+    if (extraParams) {
+      span.setAttributes(
+        Object.fromEntries(
+          Object.entries(extraParams).map(([key, value]) => [
+            [`${ATTR_LANGWATCH_LANGCHAIN_RUN_EXTRA_PARAMS}.${key}`],
+            wrapNonScalarValues(value)
+          ])
+        )
+      );
+    }
+    if (metadata) {
+      if (metadata.ls_model_name) {
+        span.setRequestModel(metadata.ls_model_name);
+        metadata.ls_model_name = void 0;
+      }
+      span.setAttributes(
+        Object.fromEntries(
+          Object.entries(metadata).map(([key, value]) => [
+            [`${ATTR_LANGWATCH_LANGCHAIN_RUN_METADATA}.${key}`],
+            wrapNonScalarValues(value)
+          ])
+        )
+      );
+    }
+    this.spans[runId] = span;
+  }
+  async handleLLMEnd(response, runId, _parentRunId) {
+    const span = this.getSpan(runId);
+    if (!span) return;
+    const outputs = [];
+    for (const generation of response.generations) {
+      for (const generation_ of generation) {
+        if ("message" in generation_ && generation_.message) {
+          outputs.push(
+            convertFromLangChainMessages([
+              generation_.message
+            ])
+          );
+        } else if ("text" in generation_) {
+          outputs.push(generation_.text);
+        } else {
+          outputs.push(JSON.stringify(generation_));
+        }
+      }
+    }
+    const output = outputs.length === 1 ? outputs[0] : outputs;
+    if (canAutomaticallyCaptureOutput()) {
+      span.setOutput(output);
+    }
+    addLangChainEvent(span, "handleLLMEnd", runId, _parentRunId);
+    span.end();
+    this.spans[runId] = void 0;
+  }
+  async handleLLMError(err, runId, _parentRunId) {
+    const span = this.getSpan(runId);
+    if (!span) return;
+    addLangChainEvent(span, "handleLLMError", runId, _parentRunId);
+    span.recordException(err);
+    span.setStatus({ code: SpanStatusCode.ERROR, message: err.message });
+    span.end();
+    this.spans[runId] = void 0;
+  }
+  async handleChainStart(chain, inputs, runId, parentRunId, _tags, _metadata, _runType, name) {
+    var _a, _b, _c;
+    const parentContext = this.getParentContext(parentRunId);
+    const span = this.tracer.startSpan(
+      (_c = name != null ? name : (_b = (_a = chain.id) == null ? void 0 : _a[chain.id.length - 1]) == null ? void 0 : _b.toString()) != null ? _c : "chain",
+      {},
+      parentContext
+    );
+    span.setType("chain");
+    if (canAutomaticallyCaptureInput()) {
+      span.setInput(inputs);
+    }
+    if (_tags) {
+      span.setAttribute(ATTR_LANGWATCH_LANGCHAIN_RUN_TAGS, _tags);
+    }
+    if (_metadata) {
+      span.setAttributes(
+        Object.fromEntries(
+          Object.entries(_metadata).map(([key, value]) => [
+            [`${ATTR_LANGWATCH_LANGCHAIN_RUN_METADATA}.${key}`],
+            wrapNonScalarValues(value)
+          ])
+        )
+      );
+    }
+    if (_runType) {
+      span.setAttribute(ATTR_LANGWATCH_LANGCHAIN_RUN_TYPE, _runType);
+    }
+    this.spans[runId] = span;
+  }
+  async handleChainEnd(output, runId, _parentRunId) {
+    const span = this.getSpan(runId);
+    if (!span) return;
+    addLangChainEvent(span, "handleChainEnd", runId, _parentRunId);
+    span.setOutput(output);
+    span.end();
+    this.spans[runId] = void 0;
+  }
+  async handleChainError(err, runId, _parentRunId, _tags, _kwargs) {
+    const span = this.getSpan(runId);
+    if (!span) return;
+    addLangChainEvent(span, "handleChainError", runId, _parentRunId);
+    span.recordException(err);
+    span.setStatus({ code: SpanStatusCode.ERROR, message: err.message });
+    span.end();
+    this.spans[runId] = void 0;
+  }
+  async handleToolStart(tool, input, runId, parentRunId, _tags, _metadata, name) {
+    var _a, _b, _c;
+    const parentContext = this.getParentContext(parentRunId);
+    const span = this.tracer.startSpan(
+      (_c = name != null ? name : (_b = (_a = tool.id) == null ? void 0 : _a[tool.id.length - 1]) == null ? void 0 : _b.toString()) != null ? _c : "tool",
+      {},
+      parentContext
+    );
+    span.setType("tool");
+    if (canAutomaticallyCaptureInput()) {
+      span.setInputString(input);
+    }
+    span.setAttributes({
+      [ATTR_LANGWATCH_LANGCHAIN_RUN_ID]: runId,
+      [ATTR_LANGWATCH_LANGCHAIN_RUN_PARENT_ID]: parentRunId
+    });
+    if (_tags) {
+      span.setAttribute(ATTR_LANGWATCH_LANGCHAIN_RUN_TAGS, _tags);
+    }
+    if (_metadata) {
+      span.setAttributes(
+        Object.fromEntries(
+          Object.entries(_metadata).map(([key, value]) => [
+            [`${ATTR_LANGWATCH_LANGCHAIN_RUN_METADATA}.${key}`],
+            wrapNonScalarValues(value)
+          ])
+        )
+      );
+    }
+    this.spans[runId] = span;
+  }
+  async handleToolEnd(output, runId, _parentRunId) {
+    const span = this.getSpan(runId);
+    if (!span) return;
+    if (canAutomaticallyCaptureOutput()) {
+      span.setOutputString(output);
+    }
+    addLangChainEvent(span, "handleToolEnd", runId, _parentRunId);
+    span.end();
+    this.spans[runId] = void 0;
+  }
+  async handleToolError(err, runId, _parentRunId, _tags) {
+    const span = this.getSpan(runId);
+    if (!span) return;
+    addLangChainEvent(span, "handleToolError", runId, _parentRunId, _tags);
+    span.recordException(err);
+    span.setStatus({ code: SpanStatusCode.ERROR, message: err.message });
+    span.end();
+    this.spans[runId] = void 0;
+  }
+  async handleRetrieverStart(retriever, query, runId, parentRunId, _tags, _metadata, name) {
+    var _a, _b, _c;
+    const parentContext = this.getParentContext(parentRunId);
+    const span = this.tracer.startSpan(
+      (_c = name != null ? name : (_b = (_a = retriever.id) == null ? void 0 : _a[retriever.id.length - 1]) == null ? void 0 : _b.toString()) != null ? _c : "retriever",
+      {},
+      parentContext
+    );
+    span.setType("rag");
+    if (canAutomaticallyCaptureInput()) {
+      span.setInputString(query);
+    }
+    if (_tags) {
+      span.setAttribute(ATTR_LANGWATCH_LANGCHAIN_RUN_TAGS, _tags);
+    }
+    if (_metadata) {
+      span.setAttributes(
+        Object.fromEntries(
+          Object.entries(_metadata).map(([key, value]) => [
+            [`${ATTR_LANGWATCH_LANGCHAIN_RUN_METADATA}.${key}`],
+            wrapNonScalarValues(value)
+          ])
+        )
+      );
+    }
+    span.setAttributes({
+      [ATTR_LANGWATCH_LANGCHAIN_RUN_ID]: runId,
+      [ATTR_LANGWATCH_LANGCHAIN_RUN_PARENT_ID]: parentRunId
+    });
+    this.spans[runId] = span;
+  }
+  async handleRetrieverEnd(documents, runId, _parentRunId, _tags) {
+    const span = this.getSpan(runId);
+    if (!span) return;
+    if (canAutomaticallyCaptureOutput()) {
+      span.setOutput(documents);
+    }
+    addLangChainEvent(span, "handleRetrieverEnd", runId, _parentRunId, _tags);
+    span.setRAGContexts(
+      documents.map((document) => ({
+        document_id: document.metadata.id,
+        chunk_id: document.metadata.chunk_id,
+        content: canAutomaticallyCaptureInput() ? document.pageContent : ""
+      }))
+    );
+    span.end();
+    this.spans[runId] = void 0;
+  }
+  async handleRetrieverError(err, runId, _parentRunId, _tags) {
+    const span = this.getSpan(runId);
+    if (!span) return;
+    addLangChainEvent(span, "handleRetrieverError", runId, _parentRunId, _tags);
+    span.recordException(err);
+    span.setStatus({ code: SpanStatusCode.ERROR, message: err.message });
+    span.end();
+    this.spans[runId] = void 0;
+  }
+  async handleAgentAction(_action, runId, _parentRunId, _tags) {
+    const span = this.getSpan(runId);
+    if (!span) return;
+    addLangChainEvent(span, "handleAgentAction", runId, _parentRunId, _tags);
+    span.setType("agent");
+  }
+  async handleAgentEnd(action, runId, _parentRunId, _tags) {
+    const span = this.getSpan(runId);
+    if (!span) return;
+    addLangChainEvent(span, "handleAgentEnd", runId, _parentRunId, _tags);
+    if (canAutomaticallyCaptureOutput()) {
+      span.setOutput(action.returnValues);
+    }
+    span.end();
+    this.spans[runId] = void 0;
+  }
+};
+var convertFromLangChainMessages = (messages) => {
+  const chatMessages = [];
+  for (const message of messages) {
+    chatMessages.push(
+      convertFromLangChainMessage(message)
+    );
+  }
+  return chatMessages;
+};
+var convertFromLangChainMessage = (message) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  let role = "user";
+  const message_ = message.lc_serializable ? mapChatMessagesToStoredMessages([message])[0] : message;
+  if (message_ instanceof HumanMessage || message_ instanceof HumanMessageChunk || ((_a = message_.id) == null ? void 0 : _a[message_.id.length - 1]) === "HumanMessage" || ((_b = message_.id) == null ? void 0 : _b[message_.id.length - 1]) === "HumanMessageChunk" || message_.type === "human") {
+    role = "user";
+  } else if (message instanceof AIMessage || message instanceof AIMessageChunk || ((_c = message.id) == null ? void 0 : _c[message.id.length - 1]) === "AIMessage" || ((_d = message.id) == null ? void 0 : _d[message.id.length - 1]) === "AIMessageChunk" || message_.type === "ai") {
+    role = "assistant";
+  } else if (message instanceof SystemMessage || message instanceof SystemMessageChunk || ((_e = message.id) == null ? void 0 : _e[message.id.length - 1]) === "SystemMessage" || ((_f = message.id) == null ? void 0 : _f[message.id.length - 1]) === "SystemMessageChunk" || message_.type === "system") {
+    role = "system";
+  } else if (message instanceof FunctionMessage || message instanceof FunctionMessageChunk || ((_g = message.id) == null ? void 0 : _g[message.id.length - 1]) === "FunctionMessage" || ((_h = message.id) == null ? void 0 : _h[message.id.length - 1]) === "FunctionMessageChunk" || message_.type === "function") {
+    role = "function";
+  } else if (message instanceof ToolMessage || message instanceof ToolMessageChunk || ((_i = message.id) == null ? void 0 : _i[message.id.length - 1]) === "ToolMessage" || ((_j = message.id) == null ? void 0 : _j[message.id.length - 1]) === "ToolMessageChunk" || message_.type === "tool") {
+    role = "tool";
+  }
+  const content = typeof message.content === "string" ? message.content : message.content.map(
+    (content2) => content2.type === "text" ? { type: "text", text: content2.text } : content2.type == "image_url" ? { type: "image_url", image_url: content2.image_url } : { type: "text", text: JSON.stringify(content2) }
+  );
+  const functionCall = message.additional_kwargs;
+  return __spreadValues({
+    role,
+    content
+  }, functionCall && typeof functionCall === "object" && Object.keys(functionCall).length > 0 ? { function_call: functionCall } : {});
+};
+function wrapNonScalarValues(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  const chatMessages = z2.array(chatMessageSchema).safeParse(value);
+  if (Array.isArray(value) && chatMessages.success) {
+    return JSON.stringify({
+      type: "chat_messages",
+      value: chatMessages.data
+    });
+  }
+  try {
+    JSON.stringify(value);
+    return JSON.stringify({
+      type: "json",
+      value
+    });
+  } catch (e) {
+    return JSON.stringify({
+      type: "raw",
+      value
+    });
+  }
+}
+function addLangChainEvent(span, eventName, runId, parentRunId, tags, metadata, attributes) {
+  const attrs = __spreadValues({
+    [ATTR_LANGWATCH_LANGCHAIN_RUN_ID]: runId,
+    [ATTR_LANGWATCH_LANGCHAIN_RUN_PARENT_ID]: parentRunId,
+    [ATTR_LANGWATCH_LANGCHAIN_EVENT_NAME]: eventName
+  }, attributes);
+  if (tags) {
+    attrs[ATTR_LANGWATCH_LANGCHAIN_TAGS] = tags;
+  }
+  if (metadata) {
+    Object.entries(metadata).forEach(([key, value]) => {
+      attrs[key] = wrapNonScalarValues(value);
+    });
+  }
+  span.addEvent(EVNT_LANGWATCH_LANGCHAIN_CALLBACK, attrs);
+}
+export {
+  LangWatchCallbackHandler,
+  convertFromLangChainMessages
+};
+//# sourceMappingURL=index.mjs.map