langwatch 0.1.0 → 0.1.3

package/dist/index.mjs

@@ -1,9 +1,14 @@
 import {
   __spreadProps,
   __spreadValues,
+  autoconvertTypedValues,
   captureError,
-  convertFromVercelAIMessages
-} from "./chunk-AP23NJ57.mjs";
+  collectorRESTParamsSchema,
+  convertFromVercelAIMessages,
+  reservedSpanParamsSchema,
+  reservedTraceMetadataSchema,
+  spanSchema
+} from "./chunk-2I4YLOQY.mjs";
 
 // src/index.ts
 import EventEmitter from "events";
@@ -11,11 +16,443 @@ import { nanoid } from "nanoid";
 import { ZodError } from "zod";
 import { fromZodError } from "zod-validation-error";
 
-// src/helpers.ts
+// package.json
+var version = "0.1.3";
+
+// src/evaluations.ts
+var evaluate = async (params) => {
+  const slug = "slug" in params ? params.slug : params.evaluator;
+  const span = optionalCreateSpan({
+    trace: params.trace,
+    span: params.span,
+    name: params.name ? params.name : slug,
+    type: params.asGuardrail ? "guardrail" : "evaluation"
+  });
+  try {
+    const requestParams = prepareData(__spreadProps(__spreadValues({}, params), {
+      slug,
+      traceId: span == null ? void 0 : span.trace.traceId,
+      spanId: span == null ? void 0 : span.spanId,
+      span
+    }));
+    const response = await fetch(requestParams.url, {
+      method: "POST",
+      headers: requestParams.headers,
+      body: JSON.stringify(requestParams.json)
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    const result = await response.json();
+    return handleResponse(result, span, params.asGuardrail);
+  } catch (e) {
+    return handleException(e, span, params.asGuardrail);
+  }
+};
+var optionalCreateSpan = ({
+  trace,
+  span,
+  name,
+  type
+}) => {
+  if (span) {
+    return span.startSpan({ name, type });
+  } else if (trace) {
+    return trace.startSpan({ name, type });
+  }
+  return void 0;
+};
+var prepareData = (params) => {
+  var _a;
+  const data = {};
+  if (params.input) data.input = params.input;
+  if (params.output) data.output = params.output;
+  if (params.expectedOutput) data.expected_output = params.expectedOutput;
+  if (params.contexts && params.contexts.length > 0)
+    data.contexts = params.contexts;
+  if (params.conversation && params.conversation.length > 0)
+    data.conversation = params.conversation;
+  if (params.span) {
+    params.span.update({
+      input: { type: "json", value: data },
+      params: params.settings
+    });
+  }
+  return {
+    url: `${process.env.LANGWATCH_ENDPOINT}/api/evaluations/${params.slug}/evaluate`,
+    json: {
+      trace_id: params.traceId,
+      span_id: params.spanId,
+      name: params.name,
+      data,
+      settings: params.settings,
+      as_guardrail: params.asGuardrail
+    },
+    headers: {
+      "X-Auth-Token": (_a = process.env.LANGWATCH_API_KEY) != null ? _a : "",
+      "Content-Type": "application/json"
+    }
+  };
+};
+var handleResponse = (response, span, asGuardrail = false) => {
+  var _a;
+  if (response.status === "error") {
+    response.details = (_a = response.details) != null ? _a : "";
+  }
+  for (const key of Object.keys(response)) {
+    if (response[key] === null || response[key] === void 0) {
+      delete response[key];
+    }
+  }
+  if (span) {
+    const output = asGuardrail ? {
+      type: "guardrail_result",
+      value: response
+    } : {
+      type: "evaluation_result",
+      value: response
+    };
+    span.update({ output });
+    if (response.cost) {
+      span.update({
+        metrics: {
+          cost: response.cost.amount
+        }
+      });
+    }
+    span.end();
+  }
+  return response;
+};
+var handleException = (e, span, asGuardrail = false) => {
+  const response = {
+    status: "error",
+    details: e.toString()
+  };
+  if (asGuardrail) {
+    response.passed = true;
+  }
+  return handleResponse(response, span, asGuardrail);
+};
+
+// src/langchain.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 { stringify } from "javascript-stringify";
+var LangWatchCallbackHandler = class extends BaseCallbackHandler {
+  constructor({ trace }) {
+    super();
+    this.name = "LangWatchCallbackHandler";
+    this.spans = {};
+    this.trace = trace;
+  }
+  async handleLLMStart(llm, prompts, runId, parentRunId, extraParams, _tags, metadata, name) {
+    this.spans[runId] = this.buildLLMSpan({
+      llm,
+      runId,
+      parentRunId,
+      input: {
+        type: "json",
+        value: prompts
+      },
+      extraParams,
+      metadata,
+      name
+    });
+  }
+  buildLLMSpan({
+    llm,
+    runId,
+    parentRunId,
+    input,
+    extraParams,
+    metadata,
+    name
+  }) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    try {
+      const parent = this.getParent(parentRunId);
+      const vendor = (_b = metadata == null ? void 0 : metadata.ls_provider) != null ? _b : (_a = llm.id.at(-2)) == null ? void 0 : _a.toString();
+      const model = (_e = (_d = metadata == null ? void 0 : metadata.ls_model_name) != null ? _d : (_c = llm.kwargs) == null ? void 0 : _c.model) != null ? _e : "unknown";
+      const span = parent.startLLMSpan({
+        spanId: runId,
+        name: name != null ? name : (_f = llm.id.at(-1)) == null ? void 0 : _f.toString(),
+        input,
+        model: [vendor, model].filter((x) => x).join("/"),
+        params: __spreadValues({
+          temperature: (_g = extraParams == null ? void 0 : extraParams.invocation_params) == null ? void 0 : _g.temperature
+        }, ((_h = extraParams == null ? void 0 : extraParams.invocation_params) == null ? void 0 : _h.functions) ? { functions: (_i = extraParams == null ? void 0 : extraParams.invocation_params) == null ? void 0 : _i.functions } : {})
+      });
+      return span;
+    } catch (e) {
+      this.trace.client.emit("error", e);
+      throw e;
+    }
+  }
+  async handleChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, name) {
+    this.spans[runId] = this.buildLLMSpan({
+      name,
+      llm,
+      runId,
+      parentRunId,
+      input: {
+        type: "chat_messages",
+        value: messages.flatMap(convertFromLangChainMessages)
+      },
+      extraParams,
+      metadata
+    });
+  }
+  async handleNewToken(_token, runId) {
+    const span = this.spans[runId];
+    if (runId && span && !span.timestamps.firstTokenAt) {
+      span.update({
+        timestamps: __spreadProps(__spreadValues({}, span.timestamps), { firstTokenAt: Date.now() })
+      });
+    }
+  }
+  async handleLLMEnd(response, runId, _parentRunId) {
+    try {
+      const span = this.spans[runId];
+      if (!span) {
+        return;
+      }
+      const outputs = [];
+      for (const generation of response.generations) {
+        for (const generation_ of generation) {
+          if ("message" in generation_) {
+            outputs.push({
+              type: "chat_messages",
+              value: convertFromLangChainMessages([
+                generation_.message
+              ])
+            });
+          } else if ("text" in generation_) {
+            outputs.push({
+              type: "text",
+              value: generation_.text
+            });
+          } else {
+            outputs.push({
+              type: "text",
+              value: JSON.stringify(generation_)
+            });
+          }
+        }
+      }
+      const output = outputs.length === 1 ? outputs[0] : { type: "list", value: outputs };
+      span.end({
+        output
+        // ...(metrics ? { metrics } : {}),
+      });
+    } catch (e) {
+      this.trace.client.emit("error", e);
+      throw e;
+    }
+  }
+  async handleLLMError(err, runId, _parentRunId) {
+    this.errorSpan({ runId, error: err });
+  }
+  async handleChainStart(chain, inputs, runId, parentRunId, _tags, _metadata, _runType, name) {
+    this.spans[runId] = this.buildSpan({
+      type: "chain",
+      serialized: chain,
+      runId,
+      parentRunId,
+      input: inputs,
+      name
+    });
+  }
+  async handleChainEnd(output, runId, _parentRunId) {
+    this.endSpan({
+      runId,
+      output
+    });
+  }
+  async handleChainError(err, runId, _parentRunId, _tags, _kwargs) {
+    this.errorSpan({ runId, error: err });
+  }
+  async handleToolStart(tool, input, runId, parentRunId, _tags, _metadata, name) {
+    this.spans[runId] = this.buildSpan({
+      type: "tool",
+      serialized: tool,
+      runId,
+      parentRunId,
+      input,
+      name
+    });
+  }
+  async handleToolEnd(output, runId, _parentRunId) {
+    this.endSpan({ runId, output });
+  }
+  async handleToolError(err, runId, _parentRunId, _tags) {
+    this.errorSpan({ runId, error: err });
+  }
+  async handleRetrieverStart(retriever, query, runId, parentRunId, _tags, _metadata, name) {
+    var _a, _b;
+    try {
+      const parent = this.getParent(parentRunId);
+      this.spans[runId] = parent.startRAGSpan({
+        spanId: runId,
+        name: (_b = name != null ? name : retriever.name) != null ? _b : (_a = retriever.id.at(-1)) == null ? void 0 : _a.toString(),
+        input: this.autoconvertTypedValues(query)
+      });
+    } catch (e) {
+      this.trace.client.emit("error", e);
+      throw e;
+    }
+  }
+  async handleRetrieverEnd(documents, runId, _parentRunId, _tags) {
+    try {
+      const contexts = documents.map((doc) => __spreadValues({
+        content: doc.pageContent
+      }, doc.metadata.source ? { documentId: doc.metadata.source } : {}));
+      const span = this.spans[runId];
+      if (!span) {
+        return;
+      }
+      span.end({
+        contexts,
+        output: this.autoconvertTypedValues(documents)
+      });
+    } catch (e) {
+      this.trace.client.emit("error", e);
+      throw e;
+    }
+  }
+  async handleRetrieverError(err, runId, _parentRunId, _tags) {
+    this.errorSpan({ runId, error: err });
+  }
+  async handleAgentAction(_action, runId, _parentRunId, _tags) {
+    const span = this.spans[runId];
+    if (!span) {
+      return;
+    }
+    span.update({
+      type: "agent"
+    });
+  }
+  async handleAgentEnd(action, runId, _parentRunId, _tags) {
+    this.endSpan({
+      runId,
+      output: action.returnValues
+    });
+  }
+  buildSpan({
+    type,
+    serialized,
+    runId,
+    parentRunId,
+    input,
+    name
+  }) {
+    var _a, _b;
+    try {
+      const parent = this.getParent(parentRunId);
+      const span = parent.startSpan({
+        spanId: runId,
+        type,
+        name: (_b = name != null ? name : serialized.name) != null ? _b : (_a = serialized.id.at(-1)) == null ? void 0 : _a.toString(),
+        input: this.autoconvertTypedValues(input)
+      });
+      return span;
+    } catch (e) {
+      this.trace.client.emit("error", e);
+      throw e;
+    }
+  }
+  endSpan({ runId, output }) {
+    try {
+      const span = this.spans[runId];
+      if (!span) {
+        return;
+      }
+      span.end({
+        output: this.autoconvertTypedValues(output)
+      });
+    } catch (e) {
+      this.trace.client.emit("error", e);
+      throw e;
+    }
+  }
+  errorSpan({ runId, error }) {
+    const span = this.spans[runId];
+    if (!span) {
+      return;
+    }
+    span.end({
+      error
+    });
+  }
+  autoconvertTypedValues(value) {
+    var _a;
+    if (!value || typeof value === "object" && Object.keys(value).length === 0) {
+      return void 0;
+    }
+    if (typeof value === "string") {
+      return { type: "text", value };
+    }
+    try {
+      JSON.stringify(value);
+      return { type: "json", value };
+    } catch (e) {
+      return { type: "text", value: (_a = stringify(value)) != null ? _a : value.toString() };
+    }
+  }
+  getParent(parentRunId) {
+    var _a, _b;
+    return (_b = parentRunId ? this.spans[parentRunId] : this.spans[(_a = Object.keys(this.spans).at(-1)) != null ? _a : ""]) != null ? _b : this.trace;
+  }
+};
+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.at(-1)) === "HumanMessage" || ((_b = message_.id) == null ? void 0 : _b.at(-1)) === "HumanMessageChunk" || message_.type === "human") {
+    role = "user";
+  } else if (message instanceof AIMessage || message instanceof AIMessageChunk || ((_c = message.id) == null ? void 0 : _c.at(-1)) === "AIMessage" || ((_d = message.id) == null ? void 0 : _d.at(-1)) === "AIMessageChunk" || message_.type === "ai") {
+    role = "assistant";
+  } else if (message instanceof SystemMessage || message instanceof SystemMessageChunk || ((_e = message.id) == null ? void 0 : _e.at(-1)) === "SystemMessage" || ((_f = message.id) == null ? void 0 : _f.at(-1)) === "SystemMessageChunk" || message_.type === "system") {
+    role = "system";
+  } else if (message instanceof FunctionMessage || message instanceof FunctionMessageChunk || ((_g = message.id) == null ? void 0 : _g.at(-1)) === "FunctionMessage" || ((_h = message.id) == null ? void 0 : _h.at(-1)) === "FunctionMessageChunk" || message_.type === "function") {
+    role = "function";
+  } else if (message instanceof ToolMessage || message instanceof ToolMessageChunk || ((_i = message.id) == null ? void 0 : _i.at(-1)) === "ToolMessage" || ((_j = message.id) == null ? void 0 : _j.at(-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 } : {});
+};
+
+// src/typeUtils.ts
 function camelToSnakeCase(str) {
   return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
 }
-function camelToSnakeCaseNested(obj) {
+function camelToSnakeCaseNested(obj, parentKey) {
   if (Array.isArray(obj)) {
     return obj.map(
       (item) => camelToSnakeCaseNested(item)
@@ -25,7 +462,11 @@ function camelToSnakeCaseNested(obj) {
     for (const key in obj) {
       if (obj.hasOwnProperty(key)) {
         const newKey = camelToSnakeCase(key);
-        newObj[newKey] = camelToSnakeCaseNested(obj[key]);
+        if (parentKey === "metadata" && !Object.keys(reservedTraceMetadataSchema.shape).includes(newKey) || parentKey === "params" && !Object.keys(reservedSpanParamsSchema.shape).includes(newKey)) {
+          newObj[key] = obj[key];
+        } else {
+          newObj[newKey] = camelToSnakeCaseNested(obj[key], newKey);
+        }
       }
     }
     return newObj;
@@ -34,355 +475,6 @@ function camelToSnakeCaseNested(obj) {
   }
 }
 
-// src/server/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 chatRichContentSchema = z.union([
-  z.object({
-    type: z.literal("text"),
-    text: z.string().optional()
-  }),
-  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()
-  })
-]);
-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.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 guardrailResultSchema = z.object({
-  status: z.union([
-    z.literal("processed"),
-    z.literal("skipped"),
-    z.literal("error")
-  ]),
-  passed: z.boolean(),
-  score: z.number().optional().nullable(),
-  details: z.string().optional().nullable(),
-  cost: moneySchema.optional().nullable()
-});
-var typedValueGuardrailResultSchema = z.object({
-  type: z.literal("guardrail_result"),
-  value: guardrailResultSchema
-});
-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 spanParamsSchema = z.object({
-  temperature: z.number().optional(),
-  stream: z.boolean().optional(),
-  functions: z.array(z.record(z.any())).optional(),
-  tools: z.array(z.record(z.any())).optional(),
-  tool_choice: z.string().optional()
-});
-var spanTimestampsSchema = z.object({
-  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("unknown")
-]);
-var rAGChunkSchema = z.object({
-  document_id: z.string().optional().nullable(),
-  chunk_id: z.string().optional().nullable(),
-  content: z.union([z.string(), z.record(z.any()), z.array(z.any())])
-});
-var traceInputSchema = z.object({
-  value: z.string(),
-  embeddings: z.object({
-    model: z.string(),
-    embeddings: z.array(z.number())
-  }).optional(),
-  satisfaction_score: z.number().optional()
-});
-var traceOutputSchema = z.object({
-  value: z.string(),
-  embeddings: z.object({
-    model: z.string(),
-    embeddings: z.array(z.number())
-  }).optional()
-});
-var traceSchema = z.object({
-  trace_id: z.string(),
-  project_id: z.string(),
-  metadata: z.object({
-    thread_id: z.string().optional(),
-    user_id: z.string().optional(),
-    customer_id: z.string().optional(),
-    labels: z.array(z.string()).optional(),
-    topic_id: z.string().optional(),
-    subtopic_id: z.string().optional()
-  }),
-  timestamps: z.object({
-    started_at: z.number(),
-    inserted_at: z.number(),
-    updated_at: z.number()
-  }),
-  input: traceInputSchema,
-  output: traceOutputSchema.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(),
-    total_cost: z.number().optional().nullable(),
-    tokens_estimated: z.boolean().optional().nullable()
-  }),
-  error: errorCaptureSchema.optional().nullable(),
-  indexing_md5s: z.array(z.string()).optional()
-});
-var elasticSearchTraceSchema = traceSchema.and(
-  z.object({
-    timestamps: traceSchema.shape.timestamps.and(
-      z.object({
-        updated_at: z.number()
-      })
-    )
-  })
-);
-var traceCheckSchema = z.object({
-  trace_id: z.string(),
-  check_id: z.string(),
-  project_id: z.string(),
-  check_type: z.string(),
-  check_name: z.string(),
-  is_guardrail: z.boolean(),
-  status: z.union([
-    z.literal("scheduled"),
-    z.literal("in_progress"),
-    z.literal("error"),
-    z.literal("skipped"),
-    z.literal("processed")
-  ]),
-  passed: z.boolean().optional(),
-  score: z.number().optional(),
-  details: z.string().optional(),
-  error: errorCaptureSchema.optional().nullable(),
-  retries: z.number().optional(),
-  timestamps: z.object({
-    inserted_at: z.number().optional(),
-    started_at: z.number().optional(),
-    finished_at: z.number().optional(),
-    updated_at: z.number()
-  }),
-  trace_metadata: z.object({
-    thread_id: z.string().optional(),
-    user_id: z.string().optional(),
-    customer_id: z.string().optional(),
-    labels: z.array(z.string()).optional(),
-    topics: z.array(z.string()).optional()
-  })
-});
-var experimentSchema = z.object({
-  experiment_id: z.string(),
-  variant: z.number()
-});
-var eventSchema = z.object({
-  event_id: z.string(),
-  event_type: z.string(),
-  project_id: z.string(),
-  metrics: z.record(z.number()),
-  event_details: z.record(z.string()),
-  trace_id: z.string().optional(),
-  trace_metadata: z.object({
-    thread_id: z.string().optional(),
-    user_id: z.string().optional(),
-    customer_id: z.string().optional(),
-    labels: z.array(z.string()).optional(),
-    topics: z.array(z.string()).optional()
-  }),
-  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 trackEventRESTParamsValidatorSchema = eventSchema.omit({
-  event_id: true,
-  project_id: true,
-  timestamps: true,
-  event_details: true,
-  trace_metadata: true
-}).and(
-  z.object({
-    event_id: z.string().optional(),
-    event_details: z.record(z.string()).optional(),
-    timestamp: z.number().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()
-});
-var typedValueChatMessagesSchema = z.object({
-  type: z.literal("chat_messages"),
-  value: z.array(chatMessageSchema)
-});
-var spanInputOutputSchema = z.lazy(
-  () => z.union([
-    typedValueTextSchema,
-    typedValueChatMessagesSchema,
-    typedValueGuardrailResultSchema,
-    typedValueJsonSchema,
-    typedValueRawSchema,
-    z.object({
-      type: z.literal("list"),
-      value: z.array(spanInputOutputSchema)
-    })
-  ])
-);
-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()
-});
-var lLMSpanSchema = baseSpanSchema.extend({
-  type: z.literal("llm"),
-  vendor: z.string().optional().nullable(),
-  model: z.string(),
-  params: spanParamsSchema
-});
-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 }),
-  rAGSpanSchema.omit({ input: true, output: true }),
-  baseSpanSchema.omit({ input: true, output: true })
-]).and(
-  z.object({
-    input: spanInputOutputValidatorSchema.optional().nullable(),
-    output: spanInputOutputValidatorSchema.optional().nullable()
-  })
-);
-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(),
-    experiments: z.union([z.array(experimentSchema), z.undefined()]).optional().nullable()
-  }).optional()
-});
-var collectorRESTParamsValidatorSchema = collectorRESTParamsSchema.omit({ spans: true });
-var datasetSpanSchema = z.union([
-  baseSpanSchema.omit({
-    project_id: true,
-    trace_id: true,
-    id: true,
-    timestamps: true,
-    metrics: true
-  }),
-  lLMSpanSchema.omit({
-    project_id: true,
-    trace_id: true,
-    id: true,
-    timestamps: true,
-    metrics: true
-  }),
-  rAGSpanSchema.omit({
-    project_id: true,
-    trace_id: true,
-    id: true,
-    timestamps: true,
-    metrics: true
-  })
-]);
-
 // src/index.ts
 var LangWatch = class extends EventEmitter {
   constructor({
@@ -467,34 +559,139 @@ var LangWatchTrace = class {
     metadata
   }) {
     this.finishedSpans = {};
+    this.evaluations = [];
+    this.addEvaluation = ({
+      evaluationId,
+      span,
+      name,
+      type,
+      isGuardrail,
+      status = "processed",
+      passed,
+      score,
+      label,
+      details,
+      error,
+      timestamps
+    }) => {
+      var _a, _b;
+      const currentEvaluationIndex = this.evaluations.findIndex(
+        (e) => evaluationId && "evaluationId" in e && e.evaluationId === evaluationId
+      );
+      const currentEvaluation = currentEvaluationIndex !== -1 ? this.evaluations[currentEvaluationIndex] : void 0;
+      const evaluationResult = __spreadValues(__spreadValues(__spreadValues(__spreadValues({
+        status
+      }, passed !== void 0 && { passed }), score !== void 0 && { score }), label !== void 0 && { label }), details !== void 0 && { details });
+      let span_ = span;
+      if (!span_) {
+        span_ = this.startSpan({
+          type: "evaluation"
+        });
+      }
+      if (span_.type !== "evaluation") {
+        span_ = span_.startSpan({ type: "evaluation" });
+      }
+      span_.update({
+        name,
+        output: {
+          type: "evaluation_result",
+          value: evaluationResult
+        },
+        error,
+        timestamps: timestamps ? {
+          startedAt: (_a = timestamps.startedAt) != null ? _a : span_.timestamps.startedAt,
+          finishedAt: (_b = timestamps.finishedAt) != null ? _b : void 0
+        } : void 0
+      });
+      span_.end();
+      const evaluation = {
+        evaluationId: evaluationId != null ? evaluationId : `eval_${nanoid()}`,
+        spanId: span_.spanId,
+        name,
+        type,
+        isGuardrail,
+        status,
+        passed,
+        score,
+        label,
+        details,
+        error: error ? captureError(error) : void 0,
+        timestamps: timestamps != null ? timestamps : {
+          startedAt: span_.timestamps.startedAt,
+          finishedAt: span_.timestamps.finishedAt
+        }
+      };
+      if (currentEvaluation && currentEvaluationIndex !== -1) {
+        this.evaluations[currentEvaluationIndex] = __spreadValues(__spreadValues({}, currentEvaluation), evaluation);
+      } else {
+        this.evaluations.push(evaluation);
+      }
+    };
     this.client = client;
     this.traceId = traceId;
-    this.metadata = metadata;
+    this.metadata = __spreadProps(__spreadValues({}, metadata), {
+      sdkVersion: version,
+      sdkLanguage: "typescript"
+    });
   }
   update({ metadata }) {
-    var _a, _b;
-    this.metadata = __spreadValues(__spreadValues(__spreadValues({}, this.metadata), metadata), typeof metadata.labels !== "undefined" ? { labels: [...(_b = (_a = this.metadata) == null ? void 0 : _a.labels) != null ? _b : [], ...metadata.labels] } : {});
+    var _a, _b, _c;
+    this.metadata = __spreadValues(__spreadValues(__spreadValues({}, this.metadata), metadata), typeof metadata.labels !== "undefined" ? {
+      labels: [
+        ...(_b = (_a = this.metadata) == null ? void 0 : _a.labels) != null ? _b : [],
+        ...(_c = metadata.labels) != null ? _c : []
+      ]
+    } : {});
+  }
+  setCurrentSpan(span) {
+    this.currentSpan = {
+      current: span,
+      previous: this.currentSpan
+    };
+  }
+  getCurrentSpan() {
+    var _a;
+    return (_a = this.currentSpan) == null ? void 0 : _a.current;
+  }
+  resetCurrentSpan() {
+    var _a;
+    this.currentSpan = (_a = this.currentSpan) == null ? void 0 : _a.previous;
   }
   startSpan(params) {
     const span = new LangWatchSpan(__spreadValues({
       trace: this
     }, params));
+    this.setCurrentSpan(span);
     return span;
   }
   startLLMSpan(params) {
     const span = new LangWatchLLMSpan(__spreadValues({
       trace: this
     }, params));
+    this.setCurrentSpan(span);
     return span;
   }
   startRAGSpan(params) {
     const span = new LangWatchRAGSpan(__spreadValues({
       trace: this
     }, params));
+    this.setCurrentSpan(span);
     return span;
   }
+  async evaluate(params) {
+    return evaluate(__spreadValues({
+      trace: this
+    }, params));
+  }
+  getLangChainCallback() {
+    if (!this.langchainCallback) {
+      this.langchainCallback = new LangWatchCallbackHandler({ trace: this });
+    }
+    return this.langchainCallback;
+  }
   onEnd(span) {
     this.finishedSpans[span.span_id] = span;
+    this.resetCurrentSpan();
     this.delayedSendSpans();
   }
   delayedSendSpans() {
@@ -509,8 +706,9 @@ var LangWatchTrace = class {
     try {
       trace = collectorRESTParamsSchema.parse({
         trace_id: this.traceId,
-        metadata: camelToSnakeCaseNested(this.metadata),
-        spans: Object.values(this.finishedSpans)
+        metadata: camelToSnakeCaseNested(this.metadata, "metadata"),
+        spans: Object.values(this.finishedSpans),
+        evaluations: camelToSnakeCaseNested(this.evaluations)
       });
     } catch (error) {
       if (error instanceof ZodError) {
@@ -585,6 +783,7 @@ var LangWatchSpan = class _LangWatchSpan {
       trace: this.trace,
       parentId: this.spanId
     }, params));
+    this.trace.setCurrentSpan(span);
     return span;
   }
   startLLMSpan(params) {
@@ -592,6 +791,7 @@ var LangWatchSpan = class _LangWatchSpan {
       trace: this.trace,
       parentId: this.spanId
     }, params));
+    this.trace.setCurrentSpan(span);
     return span;
   }
   startRAGSpan(params) {
@@ -599,8 +799,19 @@ var LangWatchSpan = class _LangWatchSpan {
       trace: this.trace,
       parentId: this.spanId
     }, params));
+    this.trace.setCurrentSpan(span);
     return span;
   }
+  addEvaluation(params) {
+    this.trace.addEvaluation(__spreadProps(__spreadValues({}, params), {
+      span: this
+    }));
+  }
+  async evaluate(params) {
+    return evaluate(__spreadValues({
+      span: this
+    }, params));
+  }
   end(params) {
     this.timestamps.finishedAt = Date.now();
     if (params) {
@@ -671,6 +882,7 @@ export {
   LangWatchRAGSpan,
   LangWatchSpan,
   LangWatchTrace,
+  autoconvertTypedValues,
   captureError,
   convertFromVercelAIMessages
 };