langwatch 0.0.1

package/dist/index.mjs

@@ -0,0 +1,666 @@
+import {
+  __spreadProps,
+  __spreadValues,
+  convertFromVercelAIMessages
+} from "./chunk-GOA2HL4A.mjs";
+
+// src/index.ts
+import EventEmitter from "events";
+import { nanoid } from "nanoid";
+import { ZodError } from "zod";
+import { fromZodError } from "zod-validation-error";
+
+// src/helpers.ts
+function camelToSnakeCase(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function camelToSnakeCaseNested(obj) {
+  if (Array.isArray(obj)) {
+    return obj.map(
+      (item) => camelToSnakeCaseNested(item)
+    );
+  } else if (typeof obj === "object" && obj !== null) {
+    const newObj = {};
+    for (const key in obj) {
+      if (obj.hasOwnProperty(key)) {
+        const newKey = camelToSnakeCase(key);
+        newObj[newKey] = camelToSnakeCaseNested(obj[key]);
+      }
+    }
+    return newObj;
+  } else {
+    return 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.union([
+  typedValueTextSchema,
+  typedValueChatMessagesSchema,
+  typedValueGuardrailResultSchema,
+  typedValueJsonSchema,
+  typedValueRawSchema
+]);
+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(),
+  outputs: z.array(spanInputOutputSchema),
+  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, outputs: true }),
+  rAGSpanSchema.omit({ input: true, outputs: true }),
+  baseSpanSchema.omit({ input: true, outputs: true })
+]).and(
+  z.object({
+    input: spanInputOutputValidatorSchema.optional().nullable(),
+    outputs: z.array(spanInputOutputValidatorSchema)
+  })
+);
+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({
+    apiKey,
+    endpoint = ((_a) => (_a = process.env.LANGWATCH_ENDPOINT) != null ? _a : "https://app.langwatch.ai")()
+  } = {}) {
+    super();
+    const apiKey_ = apiKey != null ? apiKey : process.env.LANGWATCH_API_KEY;
+    if (!apiKey_) {
+      console.warn(
+        "[LangWatch] \u26A0\uFE0F LangWatch API key is not set, please set the LANGWATCH_API_KEY environment variable or pass it in the constructor. Traces will not be captured."
+      );
+    }
+    this.apiKey = apiKey_;
+    this.endpoint = endpoint;
+  }
+  getTrace({
+    traceId,
+    metadata
+  } = {}) {
+    return new LangWatchTrace({
+      client: this,
+      traceId: traceId != null ? traceId : `trace_${nanoid()}`,
+      metadata
+    });
+  }
+  async sendTrace(params) {
+    const backoff = [1e3, 2e3, 4e3, 8e3, 16e3];
+    for (const backoffTime of backoff) {
+      try {
+        await this._sendTrace(params);
+        return;
+      } catch (e) {
+        console.warn(
+          `[LangWatch] \u26A0\uFE0F Failed to send trace, retrying in ${backoffTime / 1e3}s`
+        );
+        await new Promise((resolve) => setTimeout(resolve, backoffTime));
+      }
+    }
+    console.warn("[LangWatch] \u26A0\uFE0F Failed to send trace, giving up");
+  }
+  async _sendTrace(params) {
+    if (params.spans.length === 0) {
+      return;
+    }
+    if (!this.apiKey) {
+      const error = new Error(
+        "[LangWatch] \u26A0\uFE0F LangWatch API key is not set, LLMs traces will not be sent, go to https://langwatch.ai to set it up"
+      );
+      this.emit("error", error);
+      console.warn(error.message);
+      return;
+    }
+    const response = await fetch(`${this.endpoint}/api/collector`, {
+      method: "POST",
+      headers: {
+        "X-Auth-Token": this.apiKey,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(params)
+    });
+    if (response.status === 429) {
+      const error = new Error(
+        "[LangWatch] \u26A0\uFE0F Rate limit exceeded, dropping message from being sent to LangWatch. Please check your dashboard to upgrade your plan."
+      );
+      this.emit("error", error);
+      console.warn(error.message);
+      return;
+    }
+    if (!response.ok) {
+      const error = new Error(
+        `[LangWatch] \u26A0\uFE0F Failed to send trace, status: ${response.status}`
+      );
+      this.emit("error", error);
+      throw error;
+    }
+  }
+};
+var LangWatchTrace = class {
+  constructor({
+    client,
+    traceId,
+    metadata
+  }) {
+    this.finishedSpans = {};
+    this.client = client;
+    this.traceId = traceId;
+    this.metadata = metadata;
+  }
+  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] } : {});
+  }
+  startSpan(params) {
+    const span = new LangWatchSpan(__spreadValues({
+      trace: this
+    }, params));
+    return span;
+  }
+  startLLMSpan(params) {
+    const span = new LangWatchLLMSpan(__spreadValues({
+      trace: this
+    }, params));
+    return span;
+  }
+  startRAGSpan(params) {
+    const span = new LangWatchRAGSpan(__spreadValues({
+      trace: this
+    }, params));
+    return span;
+  }
+  onEnd(span) {
+    this.finishedSpans[span.span_id] = span;
+    this.delayedSendSpans();
+  }
+  delayedSendSpans() {
+    clearTimeout(this.timeoutRef);
+    this.timeoutRef = setTimeout(() => {
+      void this.sendSpans();
+    }, 1e3);
+  }
+  async sendSpans() {
+    clearTimeout(this.timeoutRef);
+    let trace = void 0;
+    try {
+      trace = collectorRESTParamsSchema.parse({
+        trace_id: this.traceId,
+        metadata: camelToSnakeCaseNested(this.metadata),
+        spans: Object.values(this.finishedSpans)
+      });
+    } catch (error) {
+      if (error instanceof ZodError) {
+        console.warn("[LangWatch] \u26A0\uFE0F Failed to parse trace");
+        console.warn(fromZodError(error).message);
+      } else {
+        console.warn(error);
+      }
+      this.client.emit("error", error);
+    }
+    if (trace) {
+      await this.client.sendTrace(trace);
+    }
+  }
+};
+var LangWatchSpan = class _LangWatchSpan {
+  constructor({
+    trace,
+    spanId,
+    parentId,
+    type,
+    name,
+    input,
+    outputs,
+    error,
+    timestamps,
+    metrics
+  }) {
+    this.spanId = spanId != null ? spanId : `span_${nanoid()}`;
+    this.parentId = parentId;
+    this.trace = trace;
+    this.type = type != null ? type : "span";
+    this.name = name;
+    this.input = input;
+    this.outputs = outputs != null ? outputs : [];
+    this.error = error;
+    this.timestamps = timestamps != null ? timestamps : {
+      startedAt: Date.now()
+    };
+    this.metrics = metrics;
+  }
+  update(params) {
+    if (params.type) {
+      this.type = params.type;
+    }
+    if ("name" in params) {
+      this.name = params.name;
+    }
+    if ("input" in params) {
+      this.input = params.input;
+    }
+    if (params.outputs) {
+      this.outputs = params.outputs;
+    }
+    if ("error" in params) {
+      this.error = params.error;
+    }
+    if (params.timestamps) {
+      this.timestamps = params.timestamps;
+    }
+    if ("metrics" in params) {
+      this.metrics = params.metrics;
+    }
+  }
+  startSpan(params) {
+    const span = new _LangWatchSpan(__spreadValues({
+      trace: this.trace,
+      parentId: this.spanId
+    }, params));
+    return span;
+  }
+  startLLMSpan(params) {
+    const span = new LangWatchLLMSpan(__spreadValues({
+      trace: this.trace,
+      parentId: this.spanId
+    }, params));
+    return span;
+  }
+  startRAGSpan(params) {
+    const span = new LangWatchRAGSpan(__spreadValues({
+      trace: this.trace,
+      parentId: this.spanId
+    }, params));
+    return span;
+  }
+  end(params) {
+    this.timestamps.finishedAt = Date.now();
+    if (params) {
+      this.update(params);
+    }
+    try {
+      const finalSpan = spanSchema.parse(
+        camelToSnakeCaseNested(__spreadProps(__spreadValues({}, this), {
+          trace: void 0,
+          traceId: this.trace.traceId,
+          timestamps: __spreadProps(__spreadValues({}, this.timestamps), {
+            finishedAt: this.timestamps.finishedAt
+          })
+        }))
+      );
+      this.trace.onEnd(finalSpan);
+    } catch (error) {
+      if (error instanceof ZodError) {
+        console.warn("[LangWatch] \u26A0\uFE0F Failed to parse span");
+        console.warn(fromZodError(error).message);
+      } else {
+        console.warn(error);
+      }
+      this.trace.client.emit("error", error);
+    }
+  }
+};
+var LangWatchLLMSpan = class extends LangWatchSpan {
+  constructor(params) {
+    var _a, _b;
+    super(__spreadValues({}, params));
+    this.type = "llm";
+    this.model = (_a = params.model) != null ? _a : "unknown";
+    this.params = (_b = params.params) != null ? _b : {};
+  }
+  update(params) {
+    super.update(params);
+    if (params.model) {
+      this.model = params.model;
+    }
+    if (params.params) {
+      this.params = params.params;
+    }
+  }
+  end(params) {
+    super.end(params);
+  }
+};
+var LangWatchRAGSpan = class extends LangWatchSpan {
+  constructor(params) {
+    var _a;
+    super(__spreadValues({}, params));
+    this.type = "rag";
+    this.contexts = (_a = params.contexts) != null ? _a : [];
+  }
+  update(params) {
+    super.update(params);
+    if (params.contexts) {
+      this.contexts = params.contexts;
+    }
+  }
+  end(params) {
+    super.end(params);
+  }
+};
+export {
+  LangWatch,
+  LangWatchLLMSpan,
+  LangWatchRAGSpan,
+  LangWatchSpan,
+  LangWatchTrace,
+  convertFromVercelAIMessages
+};
+//# sourceMappingURL=index.mjs.map