neatlogs 1.1.19 → 1.1.21

package/dist/index.cjs

@@ -130,7 +130,7 @@ var import_exporter_logs_otlp_proto = require("@opentelemetry/exporter-logs-otlp
 var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
 var import_node_perf_hooks = require("perf_hooks");
-var import_api4 = require("@opentelemetry/api");
+var import_api6 = require("@opentelemetry/api");
 
 // src/core/logger.ts
 var LOG_LEVELS = {
@@ -183,9 +183,9 @@ var SCOPE_PATTERNS = {
   // Neatlogs custom instrumentations
   "@neatlogs/instrumentation-google-genai": { provider: "google", framework: "google_genai" },
   "@neatlogs/instrumentation-mastra": { framework: "mastra" },
-  "@neatlogs/instrumentation-ai-sdk": { framework: "ai_sdk" },
+  "@neatlogs/instrumentation-ai-sdk": { framework: "vercel_ai_sdk" },
   // Vercel AI SDK native scope (the `ai` package emits this directly)
-  ai: { framework: "ai_sdk" },
+  ai: { framework: "vercel_ai_sdk" },
   // OpenInference instrumentations (npm @arizeai scope names)
   "@arizeai/openinference-instrumentation-openai": { provider: "openai", framework: "openai" },
   "@arizeai/openinference-instrumentation-anthropic": { provider: "anthropic", framework: "anthropic" },
@@ -274,7 +274,7 @@ function parseInstrumentationScope(scopeName) {
   } else if (scopeLower.includes("dspy")) {
     result.framework = "dspy";
   } else if (scopeLower.includes("vercel-ai") || scopeLower.includes("ai-sdk")) {
-    result.framework = "ai_sdk";
+    result.framework = "vercel_ai_sdk";
   }
   if (scopeLower.includes("openai")) {
     result.provider = "openai";
@@ -388,15 +388,26 @@ var VALID_SPAN_KINDS = /* @__PURE__ */ new Set([
   "RETRIEVER",
   "EMBEDDING",
   "MCP_TOOL",
-  "GUARDRAIL"
+  "GUARDRAIL",
+  "EVALUATOR"
 ]);
 var ALL_SPAN_KINDS = /* @__PURE__ */ new Set([
   ...VALID_SPAN_KINDS,
   "LLM",
   "RERANKER",
-  "EVALUATOR",
   "VECTOR_STORE"
 ]);
+function resolveExplicitSpanKind(attributes) {
+  for (const key of [
+    "neatlogs.span.kind",
+    "openinference.span.kind",
+    "traceloop.span.kind"
+  ]) {
+    const value = String(attributes[key] ?? "").trim();
+    if (value) return value;
+  }
+  return "";
+}
 function inferSpanKindFromName(spanName) {
   const nameLower = spanName.toLowerCase();
   if (["openai", "anthropic", "cohere", "bedrock", "chat", "completion", "llm", "gemini", "google_genai"].some(
@@ -2479,11 +2490,11 @@ function getNeatlogsParentContext(baseContext) {
 function getNeatlogsBaseContext(baseContext) {
   return baseContext ?? getNeatlogsActiveContext();
 }
-function withNeatlogsSpan(span2, fn, baseContext) {
+function withNeatlogsSpan(span2, fn, baseContext, rootSpan) {
   const base = baseContext ?? getNeatlogsActiveContext();
   let ctx = import_api.trace.setSpan(base, span2);
   if (base.getValue(NEATLOGS_ROOT_SPAN_KEY) === void 0) {
-    ctx = ctx.setValue(NEATLOGS_ROOT_SPAN_KEY, span2);
+    ctx = ctx.setValue(NEATLOGS_ROOT_SPAN_KEY, rootSpan ?? span2);
   }
   return privateContextStorage.run(ctx, fn);
 }
@@ -2680,7 +2691,7 @@ var UserPromptTemplate = class extends BasePromptTemplate {
 };
 
 // src/core/context.ts
-var import_api3 = require("@opentelemetry/api");
+var import_api4 = require("@opentelemetry/api");
 
 // src/core/media.ts
 var import_node_crypto2 = require("crypto");
@@ -4317,8 +4328,139 @@ function discardPendingMediaOwner(owner) {
   pendingMediaOwners.delete(owner ?? defaultPendingMediaOwner);
 }
 
-// src/decorators/base.ts
+// src/core/auto-root.ts
 var import_api2 = require("@opentelemetry/api");
+var boundAutoRoots = /* @__PURE__ */ new WeakMap();
+var ROOT_KINDS = /* @__PURE__ */ new Set(["workflow", "chain", "agent", "mcp_tool", "llm"]);
+function autoRootEnabled() {
+  const val = (process.env.NEATLOGS_AUTO_ROOT ?? "").trim().toLowerCase();
+  return !["false", "0", "no", "off"].includes(val);
+}
+function resolveRootWorkflowName() {
+  const clientName = getActiveClient()?.workflowName;
+  if (typeof clientName === "string" && clientName.trim()) return clientName;
+  try {
+    const name = getSessionConfig()?.workflowName;
+    if (typeof name === "string" && name.trim()) return name;
+  } catch {
+  }
+  return "workflow";
+}
+function stampRootIdentity(root) {
+  applySessionAttributes(root, void 0, true);
+  applyEndUserAttributes(root, void 0, void 0, true);
+}
+function bindSpanToAutoRoot(child, root) {
+  if (!root) return child;
+  let ended = false;
+  const proxy = new Proxy(child, {
+    get(target, prop, _receiver) {
+      if (prop === "end") {
+        return (...args) => {
+          if (ended) return;
+          ended = true;
+          try {
+            target.end(...args);
+          } finally {
+            try {
+              root.end();
+            } catch {
+            }
+          }
+        };
+      }
+      const value = Reflect.get(target, prop, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+  boundAutoRoots.set(proxy, root);
+  aliasMediaCaptureSpan(proxy, child);
+  return proxy;
+}
+function maybeOpenAutoRoot(tracer, kind, baseCtx) {
+  const k = String(kind ?? "").toLowerCase();
+  const existing = getActiveNeatlogsSpan();
+  if (!autoRootEnabled() || ROOT_KINDS.has(k) || existing !== void 0 && existing.isRecording()) {
+    return { root: void 0, ctx: baseCtx };
+  }
+  const root = tracer.startSpan(
+    resolveRootWorkflowName(),
+    { attributes: { "neatlogs.span.kind": "workflow", "neatlogs.auto_root": true } },
+    baseCtx
+  );
+  stampRootIdentity(root);
+  return { root, ctx: import_api2.trace.setSpan(baseCtx, root) };
+}
+function endAutoRoot(root) {
+  if (!root) return;
+  try {
+    root.end();
+  } catch {
+  }
+}
+var AutoRootTracer = class {
+  constructor(_tracer) {
+    this._tracer = _tracer;
+  }
+  _tracer;
+  startSpan(name, options, context2) {
+    const kind = String(
+      options?.attributes?.["neatlogs.span.kind"] ?? ""
+    ).toLowerCase();
+    const hasExplicitContext = context2 !== void 0;
+    const ctx = context2 ?? getNeatlogsParentContext();
+    const parent = getActiveNeatlogsSpan();
+    const isParentless = !hasExplicitContext && !(parent !== void 0 && parent.isRecording());
+    const needsRoot = autoRootEnabled() && !ROOT_KINDS.has(kind) && isParentless;
+    if (!needsRoot) {
+      const span2 = this._tracer.startSpan(name, options, ctx);
+      if (isParentless && ROOT_KINDS.has(kind)) stampRootIdentity(span2);
+      return span2;
+    }
+    const root = this._tracer.startSpan(
+      resolveRootWorkflowName(),
+      { attributes: { "neatlogs.span.kind": "workflow", "neatlogs.auto_root": true } },
+      ctx
+    );
+    stampRootIdentity(root);
+    const childCtx = import_api2.trace.setSpan(ctx, root);
+    const child = this._tracer.startSpan(name, options, childCtx);
+    return bindSpanToAutoRoot(child, root);
+  }
+  startActiveSpan = ((name, ...args) => {
+    const callback = args.at(-1);
+    if (typeof callback !== "function") {
+      throw new TypeError("startActiveSpan requires a callback");
+    }
+    const options = args.length >= 2 ? args[0] : void 0;
+    const parentContext = args.length >= 3 ? args[1] : getNeatlogsParentContext();
+    const span2 = args.length >= 3 ? this.startSpan(name, options, parentContext) : this.startSpan(name, options);
+    return withNeatlogsSpan(
+      span2,
+      () => callback(span2),
+      parentContext,
+      boundAutoRoots.get(span2)
+    );
+  });
+};
+function getProviderTracer(name) {
+  return new AutoRootTracer(getNeatlogsTracer(name));
+}
+
+// src/errors.ts
+var NeatlogsConfigurationError = class extends TypeError {
+  code;
+  option;
+  constructor(code, option, message) {
+    super(message);
+    this.name = "NeatlogsConfigurationError";
+    this.code = code;
+    this.option = option;
+  }
+};
+
+// src/decorators/base.ts
+var import_api3 = require("@opentelemetry/api");
 
 // src/constants.ts
 var DEFAULT_INGEST_ENDPOINT = "https://ingest.neatlogs.com";
@@ -4419,8 +4561,29 @@ function decorateSpan(opts, fn) {
   const wrapped = (...args) => {
     const tracer = getNeatlogsTracer(TRACER_NAME);
     const isRoot = isRootSpan();
-    const parentContext = isRoot ? import_api2.ROOT_CONTEXT : getNeatlogsParentContext();
-    const span2 = tracer.startSpan(spanName, {}, parentContext);
+    const parentContext = isRoot ? import_api3.ROOT_CONTEXT : getNeatlogsParentContext();
+    const autoRoot = maybeOpenAutoRoot(
+      tracer,
+      String(opts.kind ?? ""),
+      parentContext
+    );
+    if (autoRoot.root) {
+      applySessionAttributes(autoRoot.root, opts.sessionId, true, {
+        parentSessionId: opts.parentSessionId,
+        sessionFeatureName: opts.sessionFeatureName,
+        sessionEntryPoint: opts.sessionEntryPoint
+      });
+      applyEndUserAttributes(
+        autoRoot.root,
+        opts.endUserId,
+        opts.endUserMetadata,
+        true
+      );
+    }
+    const span2 = bindSpanToAutoRoot(
+      tracer.startSpan(spanName, {}, autoRoot.ctx),
+      autoRoot.root
+    );
     return withNeatlogsSpan(span2, () => {
       let finished = false;
       let streamInterrupted = false;
@@ -4460,7 +4623,7 @@ function decorateSpan(opts, fn) {
         if (finished) return;
         finished = true;
         captureResult(result);
-        span2.setStatus({ code: import_api2.SpanStatusCode.OK });
+        span2.setStatus({ code: import_api3.SpanStatusCode.OK });
         span2.end();
       };
       const setStreamCounts = () => {
@@ -4499,12 +4662,12 @@ function decorateSpan(opts, fn) {
             setStreamCounts();
             captureResult(streamCaptureValue());
           }
-          span2.setStatus({ code: import_api2.SpanStatusCode.UNSET });
+          span2.setStatus({ code: import_api3.SpanStatusCode.UNSET });
           span2.end();
           return;
         }
         span2.setStatus({
-          code: import_api2.SpanStatusCode.ERROR,
+          code: import_api3.SpanStatusCode.ERROR,
           message: error?.message ?? String(error)
         });
         span2.recordException(
@@ -4569,7 +4732,7 @@ function decorateSpan(opts, fn) {
         finished = true;
         span2.setAttribute("neatlogs.stream.cancelled", true);
         captureResult(streamCaptureValue());
-        span2.setStatus({ code: import_api2.SpanStatusCode.UNSET });
+        span2.setStatus({ code: import_api3.SpanStatusCode.UNSET });
         span2.end();
       };
       const wrapAsyncIterator = (iterator) => {
@@ -4789,7 +4952,8 @@ function decorateSpan(opts, fn) {
       });
       try {
         setCommonSpanAttrs(span2, opts);
-        applySessionAttributes(span2, opts.sessionId, isRoot, {
+        const spanIsRoot = isRoot && !autoRoot.root;
+        applySessionAttributes(span2, opts.sessionId, spanIsRoot, {
           parentSessionId: opts.parentSessionId,
           sessionFeatureName: opts.sessionFeatureName,
           sessionEntryPoint: opts.sessionEntryPoint
@@ -4798,7 +4962,7 @@ function decorateSpan(opts, fn) {
           span2,
           opts.endUserId,
           opts.endUserMetadata,
-          isRoot
+          spanIsRoot
         );
         if (captureInput && args.length > 0) {
           try {
@@ -4838,7 +5002,7 @@ function decorateSpan(opts, fn) {
         finishError(error);
         throw error;
       }
-    });
+    }, autoRoot.ctx, autoRoot.root);
   };
   Object.defineProperty(wrapped, "name", {
     value: spanName,
@@ -4870,11 +5034,11 @@ function _setSessionConfig(config) {
 function getSessionConfig() {
   return { ..._sessionConfig };
 }
-var PROMPT_VARIABLES_KEY = (0, import_api3.createContextKey)("neatlogs.prompt_variables");
-var PROMPT_TEMPLATE_KEY = (0, import_api3.createContextKey)("neatlogs.prompt_template");
-var PROMPT_VERSION_KEY = (0, import_api3.createContextKey)("neatlogs.prompt_version");
-var USER_PROMPT_TEMPLATE_KEY = (0, import_api3.createContextKey)("neatlogs.user_prompt_template");
-var USER_PROMPT_VARIABLES_KEY = (0, import_api3.createContextKey)("neatlogs.user_prompt_variables");
+var PROMPT_VARIABLES_KEY = (0, import_api4.createContextKey)("neatlogs.prompt_variables");
+var PROMPT_TEMPLATE_KEY = (0, import_api4.createContextKey)("neatlogs.prompt_template");
+var PROMPT_VERSION_KEY = (0, import_api4.createContextKey)("neatlogs.prompt_version");
+var USER_PROMPT_TEMPLATE_KEY = (0, import_api4.createContextKey)("neatlogs.user_prompt_template");
+var USER_PROMPT_VARIABLES_KEY = (0, import_api4.createContextKey)("neatlogs.user_prompt_variables");
 var KNOWN_OPTION_KEYS = /* @__PURE__ */ new Set([
   "name",
   "kind",
@@ -4893,6 +5057,20 @@ var KNOWN_OPTION_KEYS = /* @__PURE__ */ new Set([
   "endUserId",
   "endUserMetadata"
 ]);
+function assertNoHttpSpanKind(kind, attributes) {
+  const candidates = [
+    kind,
+    attributes?.["neatlogs.span.kind"],
+    attributes?.["openinference.span.kind"]
+  ];
+  if (candidates.some((value) => String(value ?? "").trim().toUpperCase() === "HTTP")) {
+    throw new NeatlogsConfigurationError(
+      "UNSUPPORTED_SPAN_KIND",
+      "kind",
+      "HTTP spans are not supported. Trace the semantic LLM, TOOL, RETRIEVER, or other AI operation instead."
+    );
+  }
+}
 function _setSpanAttributes(span2, kind, attributes) {
   if (kind?.toUpperCase() === "LLM") {
     span2.setAttribute("neatlogs.internal", true);
@@ -4963,6 +5141,7 @@ async function trace(options, fn) {
     attributes: explicitAttributes,
     ...extraOptions
   } = options;
+  assertNoHttpSpanKind(kind, explicitAttributes);
   const sessionId = sessionIdOption ?? currentSessionId();
   const currentSpan = getActiveNeatlogsSpan();
   const rootSpan = getNeatlogsRootSpan();
@@ -5007,7 +5186,7 @@ async function trace(options, fn) {
   }
   let ctx = getNeatlogsActiveContext();
   if (shouldFallbackToRoot) {
-    ctx = import_api3.trace.setSpan(ctx, rootSpan);
+    ctx = import_api4.trace.setSpan(ctx, rootSpan);
   }
   const variablesJson = promptVariables ? JSON.stringify(promptVariables) : void 0;
   const userVariablesJson = userPromptVariables ? JSON.stringify(userPromptVariables) : void 0;
@@ -5041,12 +5220,13 @@ async function trace(options, fn) {
   const tracer = getNeatlogsTracer("neatlogs.trace");
   const spanCallback = async (span3) => {
     _setSpanAttributes(span3, kind, extraAttributes);
-    applySessionAttributes(span3, sessionId, isRootTrace, {
+    const spanIsRoot = isRootTrace && !autoRoot.root;
+    applySessionAttributes(span3, sessionId, spanIsRoot, {
       parentSessionId,
       sessionFeatureName,
       sessionEntryPoint
     });
-    applyEndUserAttributes(span3, endUserId, endUserMetadata, isRootTrace);
+    applyEndUserAttributes(span3, endUserId, endUserMetadata, spanIsRoot);
     if (input !== void 0 && input !== null) {
       const capturedInput = captureMedia(
         span3,
@@ -5079,7 +5259,7 @@ async function trace(options, fn) {
       return result;
     } catch (error) {
       span3.setStatus({
-        code: import_api3.SpanStatusCode.ERROR,
+        code: import_api4.SpanStatusCode.ERROR,
         message: error instanceof Error ? error.message : String(error)
       });
       span3.recordException(
@@ -5096,15 +5276,36 @@ async function trace(options, fn) {
       span3.end();
     }
   };
-  const parentContext = shouldCreateRootTrace ? import_api3.ROOT_CONTEXT : getNeatlogsParentContext(ctx);
+  const parentContext = shouldCreateRootTrace ? import_api4.ROOT_CONTEXT : getNeatlogsParentContext(ctx);
   const startAttributes = kind ? { "openinference.span.kind": kind } : void 0;
-  const span2 = tracer.startSpan(name, startAttributes ? { attributes: startAttributes } : {}, parentContext);
+  const autoRoot = isRootTrace ? maybeOpenAutoRoot(tracer, String(kind ?? "CHAIN"), parentContext) : { root: void 0, ctx: parentContext };
+  if (autoRoot.root) {
+    applySessionAttributes(autoRoot.root, sessionId, true, {
+      parentSessionId,
+      sessionFeatureName,
+      sessionEntryPoint
+    });
+    applyEndUserAttributes(autoRoot.root, endUserId, endUserMetadata, true);
+  }
+  const span2 = bindSpanToAutoRoot(
+    tracer.startSpan(
+      name,
+      startAttributes ? { attributes: startAttributes } : {},
+      autoRoot.ctx
+    ),
+    autoRoot.root
+  );
   if (shouldCreateRootTrace) {
     logger7.debug(`[trace] Creating NEW root trace '${name}' (sessionId=${sessionId})`);
   } else {
     logger7.debug(`[trace] Creating child span '${name}'`);
   }
-  return withNeatlogsSpan(span2, () => spanCallback(span2), ctx);
+  return withNeatlogsSpan(
+    span2,
+    () => spanCallback(span2),
+    autoRoot.ctx,
+    autoRoot.root
+  );
 }
 
 // src/core/crewai-task-registry.ts
@@ -6302,27 +6503,11 @@ var AttributeMapper = class {
   /** Extract and normalize span kind from multiple possible sources. */
   mapSpanKind(attributes) {
     const spanKindConfig = this.mappings.span_kind ?? {};
-    const sources = spanKindConfig.sources ?? [];
     const valuesMap = spanKindConfig.values ?? {};
-    const priority = spanKindConfig.priority ?? "openinference";
-    let spanKindValue;
-    if (priority === "openinference") {
-      if ("openinference.span.kind" in attributes) {
-        spanKindValue = attributes["openinference.span.kind"];
-      }
-    } else {
-      for (const source of sources) {
-        if (source in attributes) {
-          spanKindValue = attributes[source];
-          break;
-        }
-      }
-    }
-    if (!spanKindValue && "neatlogs.span.kind" in attributes) {
-      spanKindValue = attributes["neatlogs.span.kind"];
-    }
-    if (spanKindValue && spanKindValue in valuesMap) {
-      return valuesMap[spanKindValue];
+    const spanKindValue = resolveExplicitSpanKind(attributes);
+    if (spanKindValue) {
+      const mapped = valuesMap[spanKindValue] ?? valuesMap[spanKindValue.toUpperCase()];
+      if (mapped) return mapped;
     }
     if (spanKindValue && Object.values(valuesMap).includes(spanKindValue)) {
       return spanKindValue;
@@ -6604,6 +6789,46 @@ function addVerificationMarkerResourceAttribute(attributes) {
   if (marker) attributes[VERIFICATION_MARKER_KEY] = marker;
 }
 
+// src/core/http-span.ts
+var import_api5 = require("@opentelemetry/api");
+var HTTP_SCOPE_PREFIXES = [
+  "@opentelemetry/instrumentation-http",
+  "@opentelemetry/instrumentation-fetch",
+  "@opentelemetry/instrumentation-undici"
+];
+var HTTP_ATTRIBUTE_KEYS = [
+  "http.method",
+  "http.request.method",
+  "http.url",
+  "http.route",
+  "url.full"
+];
+var SEMANTIC_AI_KINDS = /* @__PURE__ */ new Set([
+  "WORKFLOW",
+  "AGENT",
+  "CHAIN",
+  "TOOL",
+  "RETRIEVER",
+  "EMBEDDING",
+  "GUARDRAIL",
+  "LLM",
+  "RERANKER",
+  "VECTOR_STORE",
+  "TASK",
+  "EVALUATOR",
+  "LOG",
+  "MEMORY",
+  "MCP_TOOL"
+]);
+function isHttpSpan(span2, attributes = span2.attributes ?? {}) {
+  const resolvedKind = resolveExplicitSpanKind(attributes).toUpperCase();
+  if (resolvedKind === "HTTP") return true;
+  if (SEMANTIC_AI_KINDS.has(resolvedKind)) return false;
+  const scopeName = span2.instrumentationLibrary.name ?? "";
+  if (HTTP_SCOPE_PREFIXES.some((prefix) => scopeName.startsWith(prefix))) return true;
+  return span2.kind === import_api5.SpanKind.CLIENT && HTTP_ATTRIBUTE_KEYS.some((key) => key in attributes);
+}
+
 // src/core/span-processor.ts
 var logger10 = getLogger();
 function resolveLogFilePath(configuredPath) {
@@ -6875,6 +7100,7 @@ var NeatlogsSpanProcessor = class {
   onEnd(span2) {
     this._activeSpans.delete(span2.spanContext().spanId);
     if (this._closed) return;
+    if (isHttpSpan(span2)) return;
     if (span2.name === "neatlogs.trace.complete") {
       const markerData = spanToDict(span2, { includeScope: true });
       markerData.resource = { attributes: markerData.resource };
@@ -6991,7 +7217,7 @@ var NeatlogsSpanProcessor = class {
         attributes: unifiedAttrs,
         resource: { attributes: resourceAttrs },
         status: {
-          code: import_api4.SpanStatusCode[span2.status.code] ?? String(span2.status.code),
+          code: import_api6.SpanStatusCode[span2.status.code] ?? String(span2.status.code),
           description: span2.status.message ?? null
         },
         links: span2.links.map((link) => ({
@@ -7034,6 +7260,7 @@ var NeatlogsSpanProcessor = class {
       const maskResult = scheduleMask(span2, spanData, this.mask ?? null);
       const pending = maskResult.then((maskedSpanData) => {
         if (maskedSpanData === null) return;
+        if (isHttpSpan(span2, maskedSpanData.attributes ?? {})) return;
         if (this._processedLogStream && !this._processedLogStream.destroyed) {
           try {
             this._processedLogStream.write(JSON.stringify(maskedSpanData) + "\n");
@@ -7113,9 +7340,9 @@ var NeatlogsSpanProcessor = class {
   _markInterrupted(span2, cleanReason) {
     span2.setAttribute("neatlogs.trace.interrupted", true);
     span2.setAttribute("neatlogs.trace.termination.reason", cleanReason);
-    if (span2.status.code === import_api4.SpanStatusCode.UNSET) {
+    if (span2.status.code === import_api6.SpanStatusCode.UNSET) {
       span2.setStatus({
-        code: import_api4.SpanStatusCode.ERROR,
+        code: import_api6.SpanStatusCode.ERROR,
         message: `Interrupted during ${cleanReason}`
       });
     }
@@ -7130,10 +7357,10 @@ var NeatlogsSpanProcessor = class {
         traceId: rootSpan.spanContext().traceId,
         spanId: rootSpan.spanContext().spanId,
         isRemote: false,
-        traceFlags: import_api4.TraceFlags.SAMPLED
+        traceFlags: import_api6.TraceFlags.SAMPLED
       };
-      const wrappedSpan = import_api4.trace.wrapSpanContext(spanCtx);
-      const ctx = import_api4.trace.setSpan(import_api4.ROOT_CONTEXT, wrappedSpan);
+      const wrappedSpan = import_api6.trace.wrapSpanContext(spanCtx);
+      const ctx = import_api6.trace.setSpan(import_api6.ROOT_CONTEXT, wrappedSpan);
       const marker = markerTracer.startSpan("neatlogs.trace.complete", void 0, ctx);
       marker.setAttribute("neatlogs.trace.complete", true);
       marker.setAttribute("neatlogs.internal", true);
@@ -7302,7 +7529,8 @@ var CompletionMarkerSpanProcessor = class {
   onStart(_span, _parentContext) {
   }
   onEnd(span2) {
-    if (this.closed || span2.name === "neatlogs.trace.complete" || span2.parentSpanId) return;
+    if (this.closed || span2.name === "neatlogs.trace.complete" || span2.parentSpanId || isHttpSpan(span2))
+      return;
     if (!this.source.ownsSpan(span2)) return;
     const task = this.source.whenMaskComplete(span2).then((eligible) => {
       if (!eligible || this.closed) return;
@@ -7351,7 +7579,7 @@ function getRegisteredClients() {
 }
 
 // src/core/filtering-exporter.ts
-var import_api5 = require("@opentelemetry/api");
+var import_api7 = require("@opentelemetry/api");
 var import_core = require("@opentelemetry/core");
 var import_resources = require("@opentelemetry/resources");
 var MEDIA_RESOLUTION_CONCURRENCY = 4;
@@ -7390,7 +7618,7 @@ function toAttributes(value) {
 function statusCode(value, fallback) {
   if (typeof value === "number") return value;
   if (typeof value === "string") {
-    const resolved = import_api5.SpanStatusCode[value];
+    const resolved = import_api7.SpanStatusCode[value];
     if (typeof resolved === "number") return resolved;
   }
   return fallback;
@@ -7454,6 +7682,10 @@ var FilteringExporter = class {
   _onPrepared;
   export(spans, resultCallback) {
     void mapWithConcurrency(spans, MEDIA_RESOLUTION_CONCURRENCY, async (span2) => {
+      if (isHttpSpan(span2)) {
+        discardPendingMedia(span2);
+        return { span: null, mediaReady: true };
+      }
       if (span2.instrumentationLibrary.name === "next.js") {
         discardPendingMedia(span2);
         this.diagnostics?.recordFrameworkSpanDrop();
@@ -7474,6 +7706,11 @@ var FilteringExporter = class {
         ...masked.attributes && typeof masked.attributes === "object" ? masked.attributes : {}
       };
       const maskedData = { ...masked, attributes };
+      const maskedSpan = maskedReadableSpan(span2, maskedData);
+      if (isHttpSpan(maskedSpan)) {
+        discardPendingMedia(span2);
+        return { span: null, mediaReady: true };
+      }
       captureMediaInSnapshot(
         span2,
         maskedData,
@@ -7542,7 +7779,7 @@ var FilteringExporter = class {
 };
 
 // src/core/doctor-capture.ts
-var import_api6 = require("@opentelemetry/api");
+var import_api8 = require("@opentelemetry/api");
 var MAX_TRACES = 16;
 var MAX_SPANS_PER_TRACE = 64;
 var MAX_BYTES_PER_TRACE = 256 * 1024;
@@ -7734,7 +7971,7 @@ function toDiagnosticSpan(span2) {
     parent_span_id: span2.parentSpanId ?? null,
     name: span2.name,
     kind,
-    status: span2.status.code === import_api6.SpanStatusCode.ERROR ? "ERROR" : span2.status.code === import_api6.SpanStatusCode.OK ? "OK" : "UNSET",
+    status: span2.status.code === import_api8.SpanStatusCode.ERROR ? "ERROR" : span2.status.code === import_api8.SpanStatusCode.OK ? "OK" : "UNSET",
     input: first(attributes, [`neatlogs.${kindKey}.input`]) ?? inputMessages,
     output: first(attributes, [`neatlogs.${kindKey}.output`]) ?? outputMessages,
     ...choices ? { choices } : {},
@@ -8221,7 +8458,7 @@ var DeliveryDiagnostics = class {
 };
 
 // src/core/observable-batch-processors.ts
-var import_api7 = require("@opentelemetry/api");
+var import_api9 = require("@opentelemetry/api");
 var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
 var import_sdk_logs = require("@opentelemetry/sdk-logs");
 var ObservableBatchSpanProcessor = class extends import_sdk_trace_base.BatchSpanProcessor {
@@ -8232,7 +8469,7 @@ var ObservableBatchSpanProcessor = class extends import_sdk_trace_base.BatchSpan
   diagnostics;
   onEnd(span2) {
     const state = this;
-    if ((span2.spanContext().traceFlags & import_api7.TraceFlags.SAMPLED) !== 0 && state._finishedSpans.length >= state._maxQueueSize) {
+    if ((span2.spanContext().traceFlags & import_api9.TraceFlags.SAMPLED) !== 0 && state._finishedSpans.length >= state._maxQueueSize) {
       discardPendingMedia(span2);
       this.diagnostics.recordQueueDrop("span");
     }
@@ -8304,7 +8541,7 @@ function log(msgTemplate, options) {
 }
 
 // src/prompt/client.ts
-var import_api8 = require("@opentelemetry/api");
+var import_api10 = require("@opentelemetry/api");
 var import_core4 = require("@opentelemetry/core");
 var PromptClientError = class extends Error {
   constructor(message) {
@@ -9017,8 +9254,8 @@ var PromptClient = class _PromptClient {
     let contextResult;
     try {
       try {
-        const suppressedContext = (0, import_core4.suppressTracing)(import_api8.context.active());
-        contextResult = import_api8.context.with(suppressedContext, startTransport);
+        const suppressedContext = (0, import_core4.suppressTracing)(import_api10.context.active());
+        contextResult = import_api10.context.with(suppressedContext, startTransport);
       } catch {
       }
       if (contextResult && contextResult !== transportPromise) {
@@ -9139,19 +9376,7 @@ function _resetMastraCache() {
 }
 
 // src/version.ts
-var __version__ = "1.1.19";
-
-// src/errors.ts
-var NeatlogsConfigurationError = class extends TypeError {
-  code;
-  option;
-  constructor(code, option, message) {
-    super(message);
-    this.name = "NeatlogsConfigurationError";
-    this.code = code;
-    this.option = option;
-  }
-};
+var __version__ = "1.1.21";
 
 // src/core/deadline.ts
 async function runByDeadline(operation, deadlineMs) {
@@ -9253,6 +9478,24 @@ var INIT_OPTION_KEYS = /* @__PURE__ */ new Set([
   "piiSpanTypes",
   "uploadAuthority"
 ]);
+function resolveInitEndpoint(endpoint) {
+  const explicit = (endpoint ?? "").trim();
+  if (explicit) return explicit;
+  const fromEnv = (process.env.NEATLOGS_ENDPOINT ?? "").trim();
+  return fromEnv || DEFAULT_INGEST_ENDPOINT;
+}
+function resolveIngestBaseUrl(endpoint) {
+  const parsed = new URL(endpoint.trim());
+  const path3 = parsed.pathname.replace(/\/+$/, "");
+  if (path3 !== "" && path3 !== "/v1/traces") {
+    throw new NeatlogsConfigurationError(
+      "INVALID_ENDPOINT",
+      "endpoint",
+      "endpoint must be a base URL or an OTLP traces URL ending in /v1/traces."
+    );
+  }
+  return parsed.origin;
+}
 function validateInitOptions(options) {
   const raw = options;
   if (Object.prototype.hasOwnProperty.call(raw, "instrumentations")) {
@@ -9336,8 +9579,13 @@ function stableValue(value, ancestors = /* @__PURE__ */ new WeakSet(), location
     ancestors.delete(value);
   }
 }
+function resolveApiKey(apiKey) {
+  const explicit = (apiKey ?? "").trim();
+  if (explicit) return explicit;
+  return (process.env.NEATLOGS_API_KEY ?? "").trim();
+}
 function initIdentity(options) {
-  const apiKey = (options.apiKey ?? process.env.NEATLOGS_API_KEY ?? "").trim();
+  const apiKey = resolveApiKey(options.apiKey);
   const apiKeyDigest = (0, import_node_crypto4.createHash)("sha256").update(apiKey).digest("hex");
   const serialized = stableValue({
     apiKeyDigest,
@@ -9357,7 +9605,7 @@ function initIdentity(options) {
     captureLogs: options.captureLogs ?? false,
     pii: options.pii ?? null,
     version: options.version ?? null,
-    endpoint: options.endpoint ?? DEFAULT_INGEST_ENDPOINT,
+    endpoint: resolveInitEndpoint(options.endpoint),
     batchSize: options.batchSize ?? 100,
     flushInterval: options.flushInterval ?? 5,
     piiEnabled: options.piiEnabled ?? null,
@@ -9437,12 +9685,7 @@ async function _performInit(options) {
     );
   }
   _deliveryDiagnostics = new DeliveryDiagnostics();
-  let resolvedKey;
-  if (options.apiKey && options.apiKey.trim()) {
-    resolvedKey = options.apiKey.trim();
-  } else {
-    resolvedKey = (process.env.NEATLOGS_API_KEY ?? "").trim();
-  }
+  let resolvedKey = resolveApiKey(options.apiKey);
   let disableExportResolved = !!options.disableExport || ["true", "1", "yes"].includes(
     (process.env.NEATLOGS_DISABLE_EXPORT ?? "").toLowerCase()
   );
@@ -9463,8 +9706,8 @@ async function _performInit(options) {
   }
   _debugMode2 = options.debug ?? false;
   const resolvedWorkflowName = _resolveWorkflowName(options.workflowName);
-  const endpoint = options.endpoint ?? DEFAULT_INGEST_ENDPOINT;
-  const baseUrl = new URL(endpoint).origin;
+  const endpoint = resolveInitEndpoint(options.endpoint);
+  const baseUrl = resolveIngestBaseUrl(endpoint);
   const uploadAuthority = disableExportResolved ? new DisabledUploadAuthority("export_disabled") : resolveUploadAuthority(
     options.uploadAuthority,
     process.env.NEATLOGS_UPLOADS_ENABLED,
@@ -9877,7 +10120,7 @@ function _doctorRuntimeSnapshot() {
 }
 
 // src/core/client.ts
-var import_api9 = require("@opentelemetry/api");
+var import_api11 = require("@opentelemetry/api");
 var import_resources4 = require("@opentelemetry/resources");
 var import_semantic_conventions2 = require("@opentelemetry/semantic-conventions");
 var import_sdk_trace_node2 = require("@opentelemetry/sdk-trace-node");
@@ -9889,12 +10132,12 @@ var import_exporter_logs_otlp_proto2 = require("@opentelemetry/exporter-logs-otl
 var logger14 = getLogger();
 var closedTracer = {
   startSpan() {
-    return import_api9.trace.wrapSpanContext(import_api9.INVALID_SPAN_CONTEXT);
+    return import_api11.trace.wrapSpanContext(import_api11.INVALID_SPAN_CONTEXT);
   },
   startActiveSpan(_name, arg2, arg3, arg4) {
     const fn = typeof arg2 === "function" ? arg2 : typeof arg3 === "function" ? arg3 : arg4;
     return fn(
-      import_api9.trace.wrapSpanContext(import_api9.INVALID_SPAN_CONTEXT)
+      import_api11.trace.wrapSpanContext(import_api11.INVALID_SPAN_CONTEXT)
     );
   }
 };
@@ -10372,7 +10615,7 @@ function Span(options) {
 }
 
 // src/core/propagation.ts
-var import_api10 = require("@opentelemetry/api");
+var import_api12 = require("@opentelemetry/api");
 function injectTraceContext(carrier) {
   const spanContext = getActiveNeatlogsSpan()?.spanContext();
   if (!spanContext?.traceId || !spanContext.spanId) {
@@ -10381,7 +10624,7 @@ function injectTraceContext(carrier) {
   if (spanContext.traceId === "00000000000000000000000000000000" || spanContext.spanId === "0000000000000000") {
     return false;
   }
-  const flags = spanContext.traceFlags & import_api10.TraceFlags.SAMPLED ? import_api10.TraceFlags.SAMPLED : import_api10.TraceFlags.NONE;
+  const flags = spanContext.traceFlags & import_api12.TraceFlags.SAMPLED ? import_api12.TraceFlags.SAMPLED : import_api12.TraceFlags.NONE;
   setHeader(
     carrier,
     "traceparent",
@@ -10401,7 +10644,7 @@ function extractTraceContext(carrier, fn) {
   if (!spanContext) {
     return fn();
   }
-  return withNeatlogsRemoteParent(import_api10.trace.wrapSpanContext(spanContext), fn);
+  return withNeatlogsRemoteParent(import_api12.trace.wrapSpanContext(spanContext), fn);
 }
 function parseTraceParent(traceparent, tracestate) {
   const match = traceparent?.trim().match(
@@ -10414,9 +10657,9 @@ function parseTraceParent(traceparent, tracestate) {
   return {
     traceId: match[1],
     spanId: match[2],
-    traceFlags: flags & import_api10.TraceFlags.SAMPLED ? import_api10.TraceFlags.SAMPLED : import_api10.TraceFlags.NONE,
+    traceFlags: flags & import_api12.TraceFlags.SAMPLED ? import_api12.TraceFlags.SAMPLED : import_api12.TraceFlags.NONE,
     isRemote: true,
-    ...tracestate?.trim() ? { traceState: (0, import_api10.createTraceState)(tracestate.trim()) } : {}
+    ...tracestate?.trim() ? { traceState: (0, import_api12.createTraceState)(tracestate.trim()) } : {}
   };
 }
 function getHeader(carrier, name) {
@@ -10437,10 +10680,12 @@ function setHeader(carrier, name, value) {
 }
 
 // src/ai-sdk.ts
-var import_api11 = require("@opentelemetry/api");
+var import_api13 = require("@opentelemetry/api");
 var TRACER_NAME2 = "neatlogs.ai-sdk";
 function createAITelemetry(opts = {}) {
   const userMeta = opts.metadata ?? {};
+  const neatlogsTracer = getRoutingNeatlogsTracer(TRACER_NAME2);
+  const callerTracer = opts.tracer;
   return {
     isEnabled: true,
     recordInputs: true,
@@ -10449,8 +10694,11 @@ function createAITelemetry(opts = {}) {
     // internally, which would otherwise parent its native spans from the foreign
     // global context AND push them onto it (so a co-tenant's next span inherits
     // ours). The facade routes both through the private Neatlogs context.
-    tracer: getRoutingNeatlogsTracer(TRACER_NAME2),
-    metadata: { ...userMeta, neatlogsWrapped: true }
+    tracer: callerTracer ? createMirroredTracer(callerTracer, neatlogsTracer) : neatlogsTracer,
+    ...opts.functionId !== void 0 ? { functionId: opts.functionId } : {},
+    // The marker is an implementation detail used only when Neatlogs owns the
+    // telemetry stream. Do not leak it into caller-owned providers.
+    metadata: callerTracer ? { ...userMeta } : { ...userMeta, neatlogsWrapped: true }
   };
 }
 function safeStringify2(value) {
@@ -10524,21 +10772,80 @@ var WRAPPED_FUNCTIONS = [
   "embedMany",
   "rerank"
 ];
+var WRAPPED_AGENT_CONSTRUCTORS = [
+  "ToolLoopAgent",
+  "Experimental_Agent"
+];
+var wrappedExports = /* @__PURE__ */ new WeakSet();
+var wrapperByOriginal = /* @__PURE__ */ new WeakMap();
 function wrapAISDK(aiModule) {
   const wrapped = { ...aiModule };
   for (const name of WRAPPED_FUNCTIONS) {
     const original = aiModule[name];
     if (typeof original !== "function") continue;
+    const existing = getExistingWrapper(original);
+    if (existing) {
+      wrapped[name] = existing;
+      continue;
+    }
     if (name === "streamText" || name === "streamObject") {
-      wrapped[name] = createStreamWrapper(name, original);
+      wrapped[name] = cacheWrapper(
+        original,
+        createStreamWrapper(name, original)
+      );
     } else {
-      wrapped[name] = createAsyncWrapper(name, original);
+      wrapped[name] = cacheWrapper(
+        original,
+        createAsyncWrapper(name, original)
+      );
     }
   }
+  for (const name of WRAPPED_AGENT_CONSTRUCTORS) {
+    const original = aiModule[name];
+    if (typeof original !== "function") continue;
+    const existing = getExistingWrapper(original);
+    wrapped[name] = existing ?? cacheWrapper(
+      original,
+      createAgentConstructorWrapper(original)
+    );
+  }
   return wrapped;
 }
+function getExistingWrapper(original) {
+  if (wrappedExports.has(original)) return original;
+  return wrapperByOriginal.get(original);
+}
+function cacheWrapper(original, wrapped) {
+  wrapperByOriginal.set(original, wrapped);
+  wrappedExports.add(wrapped);
+  return wrapped;
+}
+function createAgentConstructorWrapper(original) {
+  return new Proxy(original, {
+    construct(target, args, newTarget) {
+      if (args.length === 0 || typeof args[0] !== "object" || args[0] === null) {
+        return Reflect.construct(target, args, newTarget);
+      }
+      const settings = mergeAgentSettings(args[0]);
+      return Reflect.construct(target, [settings, ...args.slice(1)], newTarget);
+    }
+  });
+}
+function mergeAgentSettings(settings) {
+  const merged = mergeTelemetry(settings);
+  const userPrepareCall = settings.prepareCall;
+  if (typeof userPrepareCall !== "function") return merged;
+  return {
+    ...merged,
+    prepareCall: async function wrappedPrepareCall(...args) {
+      const prepared = await Reflect.apply(userPrepareCall, this, args);
+      return prepared == null ? prepared : mergeTelemetry(prepared, settings.experimental_telemetry);
+    }
+  };
+}
 function rootSpanKind(name) {
-  if (name === "embed" || name === "embedMany" || name === "rerank") return "CHAIN";
+  if (name === "embed" || name === "embedMany" || name === "rerank")
+    return "CHAIN";
   return "WORKFLOW";
 }
 function getParentContext() {
@@ -10635,134 +10942,143 @@ function createStreamWrapper(name, original) {
     );
   };
 }
-function mergeTelemetry(opts) {
+function createMirroredSpan(primary, secondary) {
+  const mirrored = {
+    spanContext() {
+      return primary.spanContext();
+    },
+    setAttribute(key, value) {
+      primary.setAttribute(key, value);
+      secondary.setAttribute(key, value);
+      return mirrored;
+    },
+    setAttributes(attributes) {
+      primary.setAttributes(attributes);
+      secondary.setAttributes(attributes);
+      return mirrored;
+    },
+    addEvent(name, attributesOrStartTime, startTime) {
+      primary.addEvent(name, attributesOrStartTime, startTime);
+      secondary.addEvent(name, attributesOrStartTime, startTime);
+      return mirrored;
+    },
+    addLink(link) {
+      primary.addLink(link);
+      secondary.addLink(link);
+      return mirrored;
+    },
+    addLinks(links) {
+      primary.addLinks(links);
+      secondary.addLinks(links);
+      return mirrored;
+    },
+    setStatus(status) {
+      primary.setStatus(status);
+      secondary.setStatus(status);
+      return mirrored;
+    },
+    updateName(name) {
+      primary.updateName(name);
+      secondary.updateName(name);
+      return mirrored;
+    },
+    end(endTime) {
+      primary.end(endTime);
+      secondary.end(endTime);
+    },
+    isRecording() {
+      return primary.isRecording() || secondary.isRecording();
+    },
+    recordException(exception, time) {
+      primary.recordException(exception, time);
+      secondary.recordException(exception, time);
+    }
+  };
+  return mirrored;
+}
+function createMirroredTracer(primary, secondary) {
+  return {
+    startSpan(name, options, context2) {
+      const primarySpan = primary.startSpan(name, options, context2);
+      const secondarySpan = secondary.startSpan(name, options);
+      return createMirroredSpan(primarySpan, secondarySpan);
+    },
+    startActiveSpan: ((name, arg2, arg3, arg4) => {
+      let options;
+      let context2;
+      let fn;
+      if (typeof arg2 === "function") {
+        fn = arg2;
+      } else if (typeof arg3 === "function") {
+        options = arg2;
+        fn = arg3;
+      } else {
+        options = arg2;
+        context2 = arg3;
+        fn = arg4;
+      }
+      const runSecondary = (primarySpan) => {
+        const onSecondarySpan = (secondarySpan) => fn(createMirroredSpan(primarySpan, secondarySpan));
+        return options === void 0 ? secondary.startActiveSpan(name, onSecondarySpan) : secondary.startActiveSpan(name, options, onSecondarySpan);
+      };
+      if (context2 !== void 0) {
+        return primary.startActiveSpan(
+          name,
+          options ?? {},
+          context2,
+          runSecondary
+        );
+      }
+      return options === void 0 ? primary.startActiveSpan(name, runSecondary) : primary.startActiveSpan(name, options, runSecondary);
+    })
+  };
+}
+function mergeTelemetry(opts, fallbackTelemetry) {
+  const requestedTelemetry = {
+    ...fallbackTelemetry,
+    ...opts?.experimental_telemetry,
+    metadata: {
+      ...fallbackTelemetry?.metadata,
+      ...opts?.experimental_telemetry?.metadata
+    }
+  };
   const baseTelemetry = createAITelemetry({
-    metadata: opts?.experimental_telemetry?.metadata
+    functionId: requestedTelemetry.functionId,
+    metadata: requestedTelemetry.metadata,
+    tracer: requestedTelemetry.tracer
   });
+  const callerTracer = requestedTelemetry.tracer;
+  const hasCallerTracer = callerTracer !== void 0;
   return {
     ...opts,
     experimental_telemetry: {
-      ...opts?.experimental_telemetry,
-      ...baseTelemetry
+      ...baseTelemetry,
+      ...requestedTelemetry,
+      isEnabled: true,
+      recordInputs: requestedTelemetry.recordInputs ?? true,
+      recordOutputs: requestedTelemetry.recordOutputs ?? true,
+      tracer: baseTelemetry.tracer,
+      // Do not add Neatlogs-only marker metadata to a caller-owned telemetry
+      // pipeline such as Laminar. Both providers receive the same AI SDK span
+      // data, while their providers, parent contexts, and exporters stay separate.
+      metadata: hasCallerTracer ? requestedTelemetry.metadata : baseTelemetry.metadata
     }
   };
 }
 function recordSpanError(span2, err) {
   if (err instanceof Error) {
-    span2.setStatus({ code: import_api11.SpanStatusCode.ERROR, message: err.message });
+    span2.setStatus({ code: import_api13.SpanStatusCode.ERROR, message: err.message });
     span2.recordException(err);
   } else {
-    span2.setStatus({ code: import_api11.SpanStatusCode.ERROR, message: String(err) });
+    span2.setStatus({ code: import_api13.SpanStatusCode.ERROR, message: String(err) });
   }
 }
 
 // src/openai.ts
-var import_api14 = require("@opentelemetry/api");
-
-// src/core/auto-root.ts
-var import_api12 = require("@opentelemetry/api");
-var ROOT_KINDS = /* @__PURE__ */ new Set(["workflow", "chain", "agent", "mcp_tool"]);
-function autoRootEnabled() {
-  const val = (process.env.NEATLOGS_AUTO_ROOT ?? "").trim().toLowerCase();
-  return !["false", "0", "no", "off"].includes(val);
-}
-function resolveRootWorkflowName() {
-  const clientName = getActiveClient()?.workflowName;
-  if (typeof clientName === "string" && clientName.trim()) return clientName;
-  try {
-    const name = getSessionConfig()?.workflowName;
-    if (typeof name === "string" && name.trim()) return name;
-  } catch {
-  }
-  return "workflow";
-}
-function stampAutoRootIdentity(root) {
-  applySessionAttributes(root, void 0, true);
-  applyEndUserAttributes(root, void 0, void 0, true);
-}
-function wrapSpanWithRoot(child, root) {
-  let ended = false;
-  const proxy = new Proxy(child, {
-    get(target, prop, _receiver) {
-      if (prop === "end") {
-        return (...args) => {
-          if (ended) return;
-          ended = true;
-          try {
-            target.end(...args);
-          } finally {
-            try {
-              root.end();
-            } catch {
-            }
-          }
-        };
-      }
-      const value = Reflect.get(target, prop, target);
-      return typeof value === "function" ? value.bind(target) : value;
-    }
-  });
-  aliasMediaCaptureSpan(proxy, child);
-  return proxy;
-}
-function maybeOpenAutoRoot(tracer, kind, baseCtx) {
-  const k = String(kind ?? "").toLowerCase();
-  const existing = getActiveNeatlogsSpan();
-  if (!autoRootEnabled() || ROOT_KINDS.has(k) || existing !== void 0 && existing.isRecording()) {
-    return { root: void 0, ctx: baseCtx };
-  }
-  const root = tracer.startSpan(
-    resolveRootWorkflowName(),
-    { attributes: { "neatlogs.span.kind": "workflow", "neatlogs.auto_root": true } },
-    baseCtx
-  );
-  stampAutoRootIdentity(root);
-  return { root, ctx: import_api12.trace.setSpan(baseCtx, root) };
-}
-function endAutoRoot(root) {
-  if (!root) return;
-  try {
-    root.end();
-  } catch {
-  }
-}
-var AutoRootTracer = class {
-  constructor(_tracer) {
-    this._tracer = _tracer;
-  }
-  _tracer;
-  startSpan(name, options, context2) {
-    const kind = String(
-      options?.attributes?.["neatlogs.span.kind"] ?? ""
-    ).toLowerCase();
-    const ctx = context2 ?? getNeatlogsParentContext();
-    const parent = getActiveNeatlogsSpan();
-    const needsRoot = autoRootEnabled() && !ROOT_KINDS.has(kind) && !(parent !== void 0 && parent.isRecording());
-    if (!needsRoot) {
-      return this._tracer.startSpan(name, options, ctx);
-    }
-    const root = this._tracer.startSpan(
-      resolveRootWorkflowName(),
-      { attributes: { "neatlogs.span.kind": "workflow", "neatlogs.auto_root": true } },
-      ctx
-    );
-    stampAutoRootIdentity(root);
-    const childCtx = import_api12.trace.setSpan(ctx, root);
-    const child = this._tracer.startSpan(name, options, childCtx);
-    return wrapSpanWithRoot(child, root);
-  }
-  // startActiveSpan is used by traceTool (callback-scoped, always under an
-  // active span in practice) — pass straight through, no auto-root.
-  startActiveSpan = ((...args) => this._tracer.startActiveSpan(
-    ...args
-  ));
-};
-function getProviderTracer(name) {
-  return new AutoRootTracer(getNeatlogsTracer(name));
-}
+var import_api15 = require("@opentelemetry/api");
 
 // src/core/choice-accumulator.ts
-var import_api13 = require("@opentelemetry/api");
+var import_api14 = require("@opentelemetry/api");
 var import_node_crypto5 = require("crypto");
 function hash(value) {
   return (0, import_node_crypto5.createHash)("sha256").update(value).digest("hex");
@@ -10964,9 +11280,9 @@ var ChoiceAccumulator = class {
     this.apply(span2);
     if (interrupted) {
       span2.setAttribute("neatlogs.stream.cancelled", true);
-      span2.setStatus({ code: import_api13.SpanStatusCode.UNSET });
+      span2.setStatus({ code: import_api14.SpanStatusCode.UNSET });
     } else {
-      span2.setStatus({ code: import_api13.SpanStatusCode.OK });
+      span2.setStatus({ code: import_api14.SpanStatusCode.OK });
     }
     span2.end();
   }
@@ -10976,9 +11292,9 @@ var ChoiceAccumulator = class {
     this.apply(span2);
     if (error?.name === "AbortError") {
       span2.setAttribute("neatlogs.stream.cancelled", true);
-      span2.setStatus({ code: import_api13.SpanStatusCode.UNSET });
+      span2.setStatus({ code: import_api14.SpanStatusCode.UNSET });
     } else {
-      span2.setStatus({ code: import_api13.SpanStatusCode.ERROR, message: String(error) });
+      span2.setStatus({ code: import_api14.SpanStatusCode.ERROR, message: String(error) });
       if (error instanceof Error) span2.recordException(error);
     }
     span2.end();
@@ -11143,7 +11459,7 @@ function traceTool(name, fn) {
           "output.value",
           safeStringify3(captureMedia(span2, "neatlogs.tool.output", result, "output"))
         );
-        span2.setStatus({ code: import_api14.SpanStatusCode.OK });
+        span2.setStatus({ code: import_api15.SpanStatusCode.OK });
         return result;
       } catch (err) {
         recordError(span2, err);
@@ -11377,7 +11693,7 @@ function wrapResponsesAsyncIterableStream(stream, span2) {
     );
     if (error?.name === "AbortError") {
       span2.setAttribute("neatlogs.stream.cancelled", true);
-      span2.setStatus({ code: import_api14.SpanStatusCode.UNSET });
+      span2.setStatus({ code: import_api15.SpanStatusCode.UNSET });
       span2.end();
       return;
     }
@@ -11451,9 +11767,9 @@ function finalizeResponsesResponse(span2, response, streamedText = "", interrupt
   applyResponsesResponseAttributes(span2, response, streamedText);
   if (interrupted) {
     span2.setAttribute("neatlogs.stream.cancelled", true);
-    span2.setStatus({ code: import_api14.SpanStatusCode.UNSET });
+    span2.setStatus({ code: import_api15.SpanStatusCode.UNSET });
   } else {
-    span2.setStatus({ code: import_api14.SpanStatusCode.OK });
+    span2.setStatus({ code: import_api15.SpanStatusCode.OK });
   }
   span2.end();
 }
@@ -11668,16 +11984,16 @@ function safeStringify3(value) {
 }
 function recordError(span2, err) {
   if (err instanceof Error) {
-    span2.setStatus({ code: import_api14.SpanStatusCode.ERROR, message: err.message });
+    span2.setStatus({ code: import_api15.SpanStatusCode.ERROR, message: err.message });
     span2.recordException(err);
   } else {
-    span2.setStatus({ code: import_api14.SpanStatusCode.ERROR, message: String(err) });
+    span2.setStatus({ code: import_api15.SpanStatusCode.ERROR, message: String(err) });
   }
   span2.end();
 }
 
 // src/anthropic.ts
-var import_api15 = require("@opentelemetry/api");
+var import_api16 = require("@opentelemetry/api");
 var TRACER_NAME4 = "neatlogs.anthropic";
 function wrapAnthropic(client) {
   return wrapNamespace2(client, []);
@@ -11706,7 +12022,7 @@ function traceTool2(name, fn) {
           "output.value",
           safeStringify4(captureMedia(span2, "neatlogs.tool.output", result, "output"))
         );
-        span2.setStatus({ code: import_api15.SpanStatusCode.OK });
+        span2.setStatus({ code: import_api16.SpanStatusCode.OK });
         return result;
       } catch (err) {
         recordError2(span2, err);
@@ -11801,7 +12117,7 @@ function wrapStreamIterable(stream, span2) {
   const accumulated = newAnthropicStreamAccumulator();
   const originalAsyncIterator = stream[Symbol.asyncIterator]?.bind(stream);
   if (!originalAsyncIterator) {
-    span2.setStatus({ code: import_api15.SpanStatusCode.OK });
+    span2.setStatus({ code: import_api16.SpanStatusCode.OK });
     span2.end();
     return stream;
   }
@@ -11854,7 +12170,7 @@ function wrapMessageStream(messageStream, span2) {
       if (finalMsg) {
         finalizeMessageResponse(span2, finalMsg);
       } else {
-        span2.setStatus({ code: import_api15.SpanStatusCode.OK });
+        span2.setStatus({ code: import_api16.SpanStatusCode.OK });
         span2.end();
       }
     });
@@ -12005,7 +12321,7 @@ function finalizeStreamEvents(span2, accumulated) {
   if (accumulated.stopReason) span2.setAttribute("neatlogs.llm.stop_reason", accumulated.stopReason);
   setUsageAttrs(span2, accumulated.usage);
   applyStreamDiagnostics2(span2, accumulated);
-  span2.setStatus({ code: import_api15.SpanStatusCode.OK });
+  span2.setStatus({ code: import_api16.SpanStatusCode.OK });
   span2.end();
 }
 function finalizeMessageResponse(span2, response) {
@@ -12046,7 +12362,7 @@ function finalizeMessageResponse(span2, response) {
   setUsageAttrs(span2, response?.usage);
   if (response?.model) span2.setAttribute("neatlogs.llm.model_name", response.model);
   if (response?.stop_reason) span2.setAttribute("neatlogs.llm.stop_reason", response.stop_reason);
-  span2.setStatus({ code: import_api15.SpanStatusCode.OK });
+  span2.setStatus({ code: import_api16.SpanStatusCode.OK });
   span2.end();
 }
 function markStreamIncomplete(accumulated, reason) {
@@ -12165,16 +12481,16 @@ function safeStringify4(value) {
 }
 function recordError2(span2, err) {
   if (err instanceof Error) {
-    span2.setStatus({ code: import_api15.SpanStatusCode.ERROR, message: err.message });
+    span2.setStatus({ code: import_api16.SpanStatusCode.ERROR, message: err.message });
     span2.recordException(err);
   } else {
-    span2.setStatus({ code: import_api15.SpanStatusCode.ERROR, message: String(err) });
+    span2.setStatus({ code: import_api16.SpanStatusCode.ERROR, message: String(err) });
   }
   span2.end();
 }
 
 // src/azure-openai.ts
-var import_api16 = require("@opentelemetry/api");
+var import_api17 = require("@opentelemetry/api");
 var TRACER_NAME5 = "neatlogs.azure_openai";
 var PROVIDER = "azure";
 var SYSTEM = "azure";
@@ -12205,7 +12521,7 @@ function traceTool3(name, fn) {
           "output.value",
           safeStringify5(captureMedia(span2, "neatlogs.tool.output", result, "output"))
         );
-        span2.setStatus({ code: import_api16.SpanStatusCode.OK });
+        span2.setStatus({ code: import_api17.SpanStatusCode.OK });
         return result;
       } catch (err) {
         recordError3(span2, err);
@@ -12346,7 +12662,7 @@ function tracedResponsesCreate2(original) {
           if (response.usage.input_tokens != null) span2.setAttribute("neatlogs.llm.token_count.prompt", response.usage.input_tokens);
           if (response.usage.output_tokens != null) span2.setAttribute("neatlogs.llm.token_count.completion", response.usage.output_tokens);
         }
-        span2.setStatus({ code: import_api16.SpanStatusCode.OK });
+        span2.setStatus({ code: import_api17.SpanStatusCode.OK });
         span2.end();
         return response;
       },
@@ -12452,7 +12768,7 @@ function finalizeChatResponse2(span2, response) {
     }
   }
   if (response?.model) span2.setAttribute("neatlogs.llm.model_name", response.model);
-  span2.setStatus({ code: import_api16.SpanStatusCode.OK });
+  span2.setStatus({ code: import_api17.SpanStatusCode.OK });
   span2.end();
 }
 function sanitizedJsonToolArguments2(span2, prefix, value) {
@@ -12502,16 +12818,16 @@ function safeStringify5(value) {
 }
 function recordError3(span2, err) {
   if (err instanceof Error) {
-    span2.setStatus({ code: import_api16.SpanStatusCode.ERROR, message: err.message });
+    span2.setStatus({ code: import_api17.SpanStatusCode.ERROR, message: err.message });
     span2.recordException(err);
   } else {
-    span2.setStatus({ code: import_api16.SpanStatusCode.ERROR, message: String(err) });
+    span2.setStatus({ code: import_api17.SpanStatusCode.ERROR, message: String(err) });
   }
   span2.end();
 }
 
 // src/vertex-ai.ts
-var import_api17 = require("@opentelemetry/api");
+var import_api18 = require("@opentelemetry/api");
 var TRACER_NAME6 = "neatlogs.vertex_ai";
 var PROVIDER2 = "vertex_ai";
 var SYSTEM2 = "vertexai";
@@ -12542,7 +12858,7 @@ function traceTool4(name, fn) {
           "output.value",
           safeStringify6(captureMedia(span2, "neatlogs.tool.output", result, "output"))
         );
-        span2.setStatus({ code: import_api17.SpanStatusCode.OK });
+        span2.setStatus({ code: import_api18.SpanStatusCode.OK });
         return result;
       } catch (err) {
         recordError4(span2, err);
@@ -12658,7 +12974,7 @@ function tracedEmbedContent(original) {
           const vals = embeddings[0]?.values;
           if (Array.isArray(vals)) span2.setAttribute("neatlogs.embedding.dimensions", vals.length);
         }
-        span2.setStatus({ code: import_api17.SpanStatusCode.OK });
+        span2.setStatus({ code: import_api18.SpanStatusCode.OK });
         span2.end();
         return response;
       },
@@ -12684,7 +13000,7 @@ function tracedCountTokens(original) {
     return Promise.resolve(result).then(
       (response) => {
         if (response?.totalTokens != null) span2.setAttribute("neatlogs.llm.token_count.prompt", response.totalTokens);
-        span2.setStatus({ code: import_api17.SpanStatusCode.OK });
+        span2.setStatus({ code: import_api18.SpanStatusCode.OK });
         span2.end();
         return response;
       },
@@ -12924,7 +13240,7 @@ function finalizeStreamChunks(span2, accumulated) {
   }
   setUsage(span2, accumulated.usage);
   applyStreamDiagnostics3(span2, accumulated);
-  span2.setStatus({ code: import_api17.SpanStatusCode.OK });
+  span2.setStatus({ code: import_api18.SpanStatusCode.OK });
   span2.end();
 }
 function finalizeResponse(span2, response) {
@@ -12957,7 +13273,7 @@ function finalizeResponse(span2, response) {
     span2.setAttribute("neatlogs.llm.output_messages.0.content", textParts.join(""));
   }
   setUsage(span2, response?.usageMetadata);
-  span2.setStatus({ code: import_api17.SpanStatusCode.OK });
+  span2.setStatus({ code: import_api18.SpanStatusCode.OK });
   span2.end();
 }
 function setUsage(span2, usage) {
@@ -13030,16 +13346,16 @@ function safeStringify6(value) {
 }
 function recordError4(span2, err) {
   if (err instanceof Error) {
-    span2.setStatus({ code: import_api17.SpanStatusCode.ERROR, message: err.message });
+    span2.setStatus({ code: import_api18.SpanStatusCode.ERROR, message: err.message });
     span2.recordException(err);
   } else {
-    span2.setStatus({ code: import_api17.SpanStatusCode.ERROR, message: String(err) });
+    span2.setStatus({ code: import_api18.SpanStatusCode.ERROR, message: String(err) });
   }
   span2.end();
 }
 
 // src/google-genai.ts
-var import_api18 = require("@opentelemetry/api");
+var import_api19 = require("@opentelemetry/api");
 var TRACER_NAME7 = "neatlogs.google_genai";
 var PROVIDER3 = "google";
 var SYSTEM3 = "google_genai";
@@ -13070,7 +13386,7 @@ function traceTool5(name, fn) {
           "output.value",
           safeStringify7(captureMedia(span2, "neatlogs.tool.output", result, "output"))
         );
-        span2.setStatus({ code: import_api18.SpanStatusCode.OK });
+        span2.setStatus({ code: import_api19.SpanStatusCode.OK });
         return result;
       } catch (err) {
         recordError5(span2, err);
@@ -13186,7 +13502,7 @@ function tracedEmbedContent2(original) {
           const vals = embeddings[0]?.values;
           if (Array.isArray(vals)) span2.setAttribute("neatlogs.embedding.dimensions", vals.length);
         }
-        span2.setStatus({ code: import_api18.SpanStatusCode.OK });
+        span2.setStatus({ code: import_api19.SpanStatusCode.OK });
         span2.end();
         return response;
       },
@@ -13212,7 +13528,7 @@ function tracedCountTokens2(original) {
     return Promise.resolve(result).then(
       (response) => {
         if (response?.totalTokens != null) span2.setAttribute("neatlogs.llm.token_count.prompt", response.totalTokens);
-        span2.setStatus({ code: import_api18.SpanStatusCode.OK });
+        span2.setStatus({ code: import_api19.SpanStatusCode.OK });
         span2.end();
         return response;
       },
@@ -13452,7 +13768,7 @@ function finalizeStreamChunks2(span2, accumulated) {
   }
   setUsage2(span2, accumulated.usage);
   applyStreamDiagnostics4(span2, accumulated);
-  span2.setStatus({ code: import_api18.SpanStatusCode.OK });
+  span2.setStatus({ code: import_api19.SpanStatusCode.OK });
   span2.end();
 }
 function finalizeResponse2(span2, response) {
@@ -13485,7 +13801,7 @@ function finalizeResponse2(span2, response) {
     span2.setAttribute("neatlogs.llm.output_messages.0.content", textParts.join(""));
   }
   setUsage2(span2, response?.usageMetadata);
-  span2.setStatus({ code: import_api18.SpanStatusCode.OK });
+  span2.setStatus({ code: import_api19.SpanStatusCode.OK });
   span2.end();
 }
 function setUsage2(span2, usage) {
@@ -13558,16 +13874,16 @@ function safeStringify7(value) {
 }
 function recordError5(span2, err) {
   if (err instanceof Error) {
-    span2.setStatus({ code: import_api18.SpanStatusCode.ERROR, message: err.message });
+    span2.setStatus({ code: import_api19.SpanStatusCode.ERROR, message: err.message });
     span2.recordException(err);
   } else {
-    span2.setStatus({ code: import_api18.SpanStatusCode.ERROR, message: String(err) });
+    span2.setStatus({ code: import_api19.SpanStatusCode.ERROR, message: String(err) });
   }
   span2.end();
 }
 
 // src/bedrock.ts
-var import_api19 = require("@opentelemetry/api");
+var import_api20 = require("@opentelemetry/api");
 var TRACER_NAME8 = "neatlogs.bedrock";
 var PROVIDER4 = "bedrock";
 function traceTool6(name, fn) {
@@ -13594,7 +13910,7 @@ function traceTool6(name, fn) {
           "output.value",
           safeStringify8(captureMedia(span2, "neatlogs.tool.output", result, "output"))
         );
-        span2.setStatus({ code: import_api19.SpanStatusCode.OK });
+        span2.setStatus({ code: import_api20.SpanStatusCode.OK });
         return result;
       } catch (err) {
         recordError6(span2, err);
@@ -13755,7 +14071,7 @@ function finalizeConverse(span2, response) {
   }
   if (response?.stopReason) span2.setAttribute("neatlogs.llm.finish_reason", String(response.stopReason));
   setConverseUsage(span2, response?.usage);
-  span2.setStatus({ code: import_api19.SpanStatusCode.OK });
+  span2.setStatus({ code: import_api20.SpanStatusCode.OK });
   span2.end();
 }
 function setConverseUsage(span2, usage) {
@@ -13769,7 +14085,7 @@ function setConverseUsage(span2, usage) {
 function wrapConverseStream(response, span2) {
   const stream = response?.stream;
   if (!stream || typeof stream[Symbol.asyncIterator] !== "function") {
-    span2.setStatus({ code: import_api19.SpanStatusCode.OK });
+    span2.setStatus({ code: import_api20.SpanStatusCode.OK });
     span2.end();
     return response;
   }
@@ -13875,7 +14191,7 @@ function finalizeConverseStream(span2, textParts, toolCalls, finishReason, usage
   if (finishReason) span2.setAttribute("neatlogs.llm.finish_reason", String(finishReason));
   setConverseUsage(span2, usage);
   applyStreamDiagnostics5(span2, budget);
-  span2.setStatus({ code: import_api19.SpanStatusCode.OK });
+  span2.setStatus({ code: import_api20.SpanStatusCode.OK });
   span2.end();
 }
 function isEmbeddingModel(modelId) {
@@ -13919,7 +14235,7 @@ function tracedInvokeModel(originalSend, command, input, rest, isStream) {
           finalizeInvoke(span2, vendor, decodeBody(response?.body));
         }
       } catch {
-        span2.setStatus({ code: import_api19.SpanStatusCode.OK });
+        span2.setStatus({ code: import_api20.SpanStatusCode.OK });
         span2.end();
       }
       return response;
@@ -13944,7 +14260,7 @@ function finalizeInvokeEmbedding(span2, body) {
     span2.setAttribute("neatlogs.llm.token_count.prompt", body.inputTextTokenCount);
     span2.setAttribute("neatlogs.embedding.token_count", body.inputTextTokenCount);
   }
-  span2.setStatus({ code: import_api19.SpanStatusCode.OK });
+  span2.setStatus({ code: import_api20.SpanStatusCode.OK });
   span2.end();
 }
 function decodeBody(body) {
@@ -14071,13 +14387,13 @@ function finalizeInvoke(span2, vendor, body) {
     span2.setAttribute("neatlogs.llm.token_count.total", promptTokens + completionTokens);
   }
   if (finishReason) span2.setAttribute("neatlogs.llm.finish_reason", String(finishReason));
-  span2.setStatus({ code: import_api19.SpanStatusCode.OK });
+  span2.setStatus({ code: import_api20.SpanStatusCode.OK });
   span2.end();
 }
 function wrapInvokeStream(response, span2, vendor) {
   const body = response?.body;
   if (!body || typeof body[Symbol.asyncIterator] !== "function") {
-    span2.setStatus({ code: import_api19.SpanStatusCode.OK });
+    span2.setStatus({ code: import_api20.SpanStatusCode.OK });
     span2.end();
     return response;
   }
@@ -14131,7 +14447,7 @@ function wrapInvokeStream(response, span2, vendor) {
     if (completionTokens != null) span2.setAttribute("neatlogs.llm.token_count.completion", completionTokens);
     if (finishReason) span2.setAttribute("neatlogs.llm.finish_reason", String(finishReason));
     applyStreamDiagnostics5(span2, budget);
-    span2.setStatus({ code: import_api19.SpanStatusCode.OK });
+    span2.setStatus({ code: import_api20.SpanStatusCode.OK });
     span2.end();
   };
   const wrappedBody = {
@@ -14246,16 +14562,16 @@ function safeStringify8(value) {
 }
 function recordError6(span2, err) {
   if (err instanceof Error) {
-    span2.setStatus({ code: import_api19.SpanStatusCode.ERROR, message: err.message });
+    span2.setStatus({ code: import_api20.SpanStatusCode.ERROR, message: err.message });
     span2.recordException(err);
   } else {
-    span2.setStatus({ code: import_api19.SpanStatusCode.ERROR, message: String(err) });
+    span2.setStatus({ code: import_api20.SpanStatusCode.ERROR, message: String(err) });
   }
   span2.end();
 }
 
 // src/langchain.ts
-var import_api20 = require("@opentelemetry/api");
+var import_api21 = require("@opentelemetry/api");
 var TRACER_NAME9 = "neatlogs.langchain";
 function langchainHandler(opts) {
   return new NeatlogsCallbackHandler(opts);
@@ -14281,7 +14597,7 @@ var NeatlogsCallbackHandler = class {
     const base = getNeatlogsBaseContext();
     const parentSpan = parentRunId ? this._spans.get(parentRunId) : void 0;
     if (parentSpan) {
-      return import_api20.trace.setSpan(base, parentSpan);
+      return import_api21.trace.setSpan(base, parentSpan);
     }
     const tracer = getNeatlogsTracer(TRACER_NAME9);
     const { root, ctx } = maybeOpenAutoRoot(tracer, kind, base);
@@ -14314,7 +14630,7 @@ var NeatlogsCallbackHandler = class {
     const span2 = this._spans.get(runId);
     if (!span2) return;
     if (outputs) span2.setAttribute("output.value", safeStringify9(outputs));
-    span2.setStatus({ code: import_api20.SpanStatusCode.OK });
+    span2.setStatus({ code: import_api21.SpanStatusCode.OK });
     span2.end();
     this._spans.delete(runId);
     this._endAutoRoot(runId);
@@ -14322,7 +14638,7 @@ var NeatlogsCallbackHandler = class {
   async handleChainError(error, runId) {
     const span2 = this._spans.get(runId);
     if (!span2) return;
-    span2.setStatus({ code: import_api20.SpanStatusCode.ERROR, message: error.message });
+    span2.setStatus({ code: import_api21.SpanStatusCode.ERROR, message: error.message });
     span2.recordException(error);
     span2.end();
     this._spans.delete(runId);
@@ -14412,7 +14728,7 @@ var NeatlogsCallbackHandler = class {
         span2.setAttribute("neatlogs.llm.token_count.total", usage.totalTokens ?? usage.total_tokens);
       }
     }
-    span2.setStatus({ code: import_api20.SpanStatusCode.OK });
+    span2.setStatus({ code: import_api21.SpanStatusCode.OK });
     span2.end();
     this._spans.delete(runId);
     this._endAutoRoot(runId);
@@ -14422,7 +14738,7 @@ var NeatlogsCallbackHandler = class {
   async handleLLMError(error, runId) {
     const span2 = this._spans.get(runId);
     if (!span2) return;
-    span2.setStatus({ code: import_api20.SpanStatusCode.ERROR, message: error.message });
+    span2.setStatus({ code: import_api21.SpanStatusCode.ERROR, message: error.message });
     span2.recordException(error);
     span2.end();
     this._spans.delete(runId);
@@ -14446,7 +14762,7 @@ var NeatlogsCallbackHandler = class {
     const span2 = this._spans.get(runId);
     if (!span2) return;
     span2.setAttribute("output.value", String(output));
-    span2.setStatus({ code: import_api20.SpanStatusCode.OK });
+    span2.setStatus({ code: import_api21.SpanStatusCode.OK });
     span2.end();
     this._spans.delete(runId);
     this._endAutoRoot(runId);
@@ -14454,7 +14770,7 @@ var NeatlogsCallbackHandler = class {
   async handleToolError(error, runId) {
     const span2 = this._spans.get(runId);
     if (!span2) return;
-    span2.setStatus({ code: import_api20.SpanStatusCode.ERROR, message: error.message });
+    span2.setStatus({ code: import_api21.SpanStatusCode.ERROR, message: error.message });
     span2.recordException(error);
     span2.end();
     this._spans.delete(runId);
@@ -14485,7 +14801,7 @@ var NeatlogsCallbackHandler = class {
         }
       }
     }
-    span2.setStatus({ code: import_api20.SpanStatusCode.OK });
+    span2.setStatus({ code: import_api21.SpanStatusCode.OK });
     span2.end();
     this._spans.delete(runId);
     this._endAutoRoot(runId);
@@ -14493,7 +14809,7 @@ var NeatlogsCallbackHandler = class {
   async handleRetrieverError(error, runId) {
     const span2 = this._spans.get(runId);
     if (!span2) return;
-    span2.setStatus({ code: import_api20.SpanStatusCode.ERROR, message: error.message });
+    span2.setStatus({ code: import_api21.SpanStatusCode.ERROR, message: error.message });
     span2.recordException(error);
     span2.end();
     this._spans.delete(runId);
@@ -14534,7 +14850,7 @@ function strandsHooks(_agent) {
 }
 
 // src/openai-agents.ts
-var import_api21 = require("@opentelemetry/api");
+var import_api22 = require("@opentelemetry/api");
 var TRACER_NAME10 = "neatlogs.openai_agents";
 function openaiAgentsProcessor() {
   return new NeatlogsTraceProcessor();
@@ -14563,7 +14879,7 @@ var NeatlogsTraceProcessor = class {
     if (startTime) {
       span2.setAttribute("neatlogs.metrics.duration_ms", Date.now() - startTime);
     }
-    span2.setStatus({ code: import_api21.SpanStatusCode.OK });
+    span2.setStatus({ code: import_api22.SpanStatusCode.OK });
     span2.end();
     this._spans.delete(key);
     this._startTimes.delete(key);
@@ -14578,7 +14894,7 @@ var NeatlogsTraceProcessor = class {
     const base = getNeatlogsBaseContext();
     const parentKey = String(span2?.parentId ?? span2?.traceId ?? span2?.trace_id ?? "");
     const parentSpan = this._spans.get(parentKey);
-    const parentCtx = parentSpan ? import_api21.trace.setSpan(base, parentSpan) : base;
+    const parentCtx = parentSpan ? import_api22.trace.setSpan(base, parentSpan) : base;
     let otelSpan;
     if (spanType === "agent" || spanType === "agent_run") {
       const agentName = data?.name ?? data?.agent_name ?? "agent";
@@ -14687,13 +15003,13 @@ var NeatlogsTraceProcessor = class {
     const error = data?.error ?? span2?.error;
     if (error) {
       if (error instanceof Error) {
-        otelSpan.setStatus({ code: import_api21.SpanStatusCode.ERROR, message: error.message });
+        otelSpan.setStatus({ code: import_api22.SpanStatusCode.ERROR, message: error.message });
         otelSpan.recordException(error);
       } else {
-        otelSpan.setStatus({ code: import_api21.SpanStatusCode.ERROR, message: String(error) });
+        otelSpan.setStatus({ code: import_api22.SpanStatusCode.ERROR, message: String(error) });
       }
     } else {
-      otelSpan.setStatus({ code: import_api21.SpanStatusCode.OK });
+      otelSpan.setStatus({ code: import_api22.SpanStatusCode.OK });
     }
     if (startTime) {
       otelSpan.setAttribute("neatlogs.llm.metrics.duration_ms", Date.now() - startTime);
@@ -14704,7 +15020,7 @@ var NeatlogsTraceProcessor = class {
   }
   shutdown() {
     for (const [, span2] of this._spans) {
-      span2.setStatus({ code: import_api21.SpanStatusCode.ERROR, message: "Processor shutdown before span completed" });
+      span2.setStatus({ code: import_api22.SpanStatusCode.ERROR, message: "Processor shutdown before span completed" });
       span2.end();
     }
     this._spans.clear();
@@ -14722,7 +15038,7 @@ function safeStringify10(value) {
 }
 
 // src/mastra-wrap.ts
-var import_api22 = require("@opentelemetry/api");
+var import_api23 = require("@opentelemetry/api");
 var TRACER_NAME11 = "neatlogs.mastra";
 var PATCH_FLAG = "_neatlogs_patched";
 function wrapMastra(entity) {
@@ -15029,7 +15345,7 @@ function wrapRootMastra(mastra) {
 function wrapStreamingOutput(output, span2) {
   if (!output) {
     span2.setAttribute("output.value", toOutputValue(output));
-    span2.setStatus({ code: import_api22.SpanStatusCode.OK });
+    span2.setStatus({ code: import_api23.SpanStatusCode.OK });
     span2.end();
     return output;
   }
@@ -15038,7 +15354,7 @@ function wrapStreamingOutput(output, span2) {
     if (ended) return;
     ended = true;
     if (err) recordError7(span2, err);
-    else span2.setStatus({ code: import_api22.SpanStatusCode.OK });
+    else span2.setStatus({ code: import_api23.SpanStatusCode.OK });
     span2.end();
   };
   if (output.text && typeof output.text.then === "function") {
@@ -15251,7 +15567,7 @@ function wrapModelStreamingResult(result, span2) {
   if (!stream || typeof stream.getReader !== "function") {
     if (result?.usage) recordUsage(span2, result.usage);
     span2.setAttribute("output.value", safeStringify11(result ?? { streamCompleted: true }));
-    span2.setStatus({ code: import_api22.SpanStatusCode.OK });
+    span2.setStatus({ code: import_api23.SpanStatusCode.OK });
     span2.end();
     return result;
   }
@@ -15264,7 +15580,7 @@ function wrapModelStreamingResult(result, span2) {
       recordError7(span2, err);
     } else {
       finalizeModelStreamSpan(span2, capture);
-      span2.setStatus({ code: import_api22.SpanStatusCode.OK });
+      span2.setStatus({ code: import_api23.SpanStatusCode.OK });
     }
     span2.end();
   };
@@ -15447,7 +15763,7 @@ function withActiveSpan(name, attrs, fn) {
   return withNeatlogsSpan(span2, async () => {
     try {
       const result = await fn(span2);
-      span2.setStatus({ code: import_api22.SpanStatusCode.OK });
+      span2.setStatus({ code: import_api23.SpanStatusCode.OK });
       return result;
     } catch (err) {
       recordError7(span2, err);
@@ -15494,15 +15810,15 @@ function recordError7(span2, err) {
     error: err instanceof Error ? { name: err.name, message: err.message } : { message: String(err) }
   }));
   if (err instanceof Error) {
-    span2.setStatus({ code: import_api22.SpanStatusCode.ERROR, message: err.message });
+    span2.setStatus({ code: import_api23.SpanStatusCode.ERROR, message: err.message });
     span2.recordException(err);
   } else {
-    span2.setStatus({ code: import_api22.SpanStatusCode.ERROR, message: String(err) });
+    span2.setStatus({ code: import_api23.SpanStatusCode.ERROR, message: String(err) });
   }
 }
 
 // src/pi-agent.ts
-var import_api23 = require("@opentelemetry/api");
+var import_api24 = require("@opentelemetry/api");
 var TRACER_NAME12 = "neatlogs.pi-agent";
 var PATCH_FLAG2 = "_neatlogs_patched";
 var HARNESS_METHOD_FLAG = "_neatlogs_harness_methods_patched";
@@ -15579,7 +15895,7 @@ function emitHarnessOperation(method, input, result, failure2, model, capturedPa
   let root;
   const inputText = safeStringify12(input ?? {});
   const outputText = failure2 ? `[error] ${failure2 instanceof Error ? failure2.message : String(failure2)}` : harnessOperationOutput(method, result);
-  if (!import_api23.trace.getSpan(parent)?.isRecording()) {
+  if (!import_api24.trace.getSpan(parent)?.isRecording()) {
     root = tracer.startSpan(
       `pi_agent.harness.${method}`,
       {
@@ -15591,7 +15907,7 @@ function emitHarnessOperation(method, input, result, failure2, model, capturedPa
       },
       parent
     );
-    parent = import_api23.trace.setSpan(parent, root);
+    parent = import_api24.trace.setSpan(parent, root);
   }
   const chain = tracer.startSpan(
     `pi_agent.harness.${method}`,
@@ -15605,7 +15921,7 @@ function emitHarnessOperation(method, input, result, failure2, model, capturedPa
     },
     parent
   );
-  const chainCtx = import_api23.trace.setSpan(parent, chain);
+  const chainCtx = import_api24.trace.setSpan(parent, chain);
   const usage = harnessOperationUsage(method, result);
   const madeModelCall = observedModelCall ?? (failure2 ? isHarnessSummarizationFailure(failure2) : method === "compact" ? Boolean(result?.usage) : Boolean(result?.summaryEntry) && result.summaryEntry.fromHook !== true);
   if (madeModelCall || failure2) {
@@ -15646,9 +15962,9 @@ function emitHarnessOperation(method, input, result, failure2, model, capturedPa
   if (failure2) {
     const message = failure2 instanceof Error ? failure2.message : String(failure2);
     chain.setAttribute("neatlogs.error.message", message);
-    chain.setStatus({ code: import_api23.SpanStatusCode.ERROR, message });
+    chain.setStatus({ code: import_api24.SpanStatusCode.ERROR, message });
   } else {
-    chain.setStatus({ code: import_api23.SpanStatusCode.OK });
+    chain.setStatus({ code: import_api24.SpanStatusCode.OK });
   }
   chain.end(endedAt);
   if (root) {
@@ -15656,9 +15972,9 @@ function emitHarnessOperation(method, input, result, failure2, model, capturedPa
     if (failure2) {
       const message = failure2 instanceof Error ? failure2.message : String(failure2);
       root.setAttribute("neatlogs.error.message", message);
-      root.setStatus({ code: import_api23.SpanStatusCode.ERROR, message });
+      root.setStatus({ code: import_api24.SpanStatusCode.ERROR, message });
     } else {
-      root.setStatus({ code: import_api23.SpanStatusCode.OK });
+      root.setStatus({ code: import_api24.SpanStatusCode.OK });
     }
     root.end(endedAt);
   }
@@ -15685,7 +16001,7 @@ function closeLlmFailure(llm, failure2, endedAt) {
   const message = failure2 instanceof Error ? failure2.message : String(failure2);
   llm.span.setAttribute("output.value", `[error] ${message}`);
   llm.span.setAttribute("neatlogs.error.message", message);
-  llm.span.setStatus({ code: import_api23.SpanStatusCode.ERROR, message });
+  llm.span.setStatus({ code: import_api24.SpanStatusCode.ERROR, message });
   llm.span.end(endedAt);
 }
 function tracePiAgentEvents(getTranscript) {
@@ -15707,13 +16023,13 @@ function tracePiStream(streamFn) {
       const state = { toolSpans: /* @__PURE__ */ new Map(), inputMessages: [], turnIndex: 0 };
       state.inputMessages = promptMessagesOf(context2);
       let parent = getNeatlogsParentContext();
-      if (!import_api23.trace.getSpan(parent)?.isRecording()) {
+      if (!import_api24.trace.getSpan(parent)?.isRecording()) {
         root = tracer.startSpan(
           "pi_agent.stream",
           { attributes: { "neatlogs.span.kind": "WORKFLOW" } },
           parent
         );
-        parent = import_api23.trace.setSpan(parent, root);
+        parent = import_api24.trace.setSpan(parent, root);
         const rootInput = state.inputMessages.length ? safeStringify12({ messages: state.inputMessages }) : void 0;
         if (rootInput) root.setAttribute("input.value", rootInput);
       }
@@ -15791,7 +16107,7 @@ function closeStreamFailure(llm, root, err) {
   try {
     llm?.span.setAttribute("output.value", `[error] ${message}`);
     llm?.span.setAttribute("neatlogs.error.message", message);
-    llm?.span.setStatus({ code: import_api23.SpanStatusCode.ERROR, message });
+    llm?.span.setStatus({ code: import_api24.SpanStatusCode.ERROR, message });
     llm?.span.end();
   } catch {
   }
@@ -15811,7 +16127,7 @@ function closeStreamRoot(root, msg, error) {
     } else if (error) {
       root.setAttribute("output.value", `[error] ${error}`);
       root.setAttribute("neatlogs.error.message", error);
-      root.setStatus({ code: import_api23.SpanStatusCode.ERROR, message: error });
+      root.setStatus({ code: import_api24.SpanStatusCode.ERROR, message: error });
     }
     root.end();
   } catch {
@@ -15850,7 +16166,7 @@ function handleEvent(tracer, state, event, getTranscript) {
         base
       );
       state.agentSpan = span2;
-      state.agentCtx = import_api23.trace.setSpan(base, span2);
+      state.agentCtx = import_api24.trace.setSpan(base, span2);
       state.inputMessages = transcriptRows(getTranscript?.());
       state.turnIndex = 0;
       state.runInput = void 0;
@@ -15874,7 +16190,7 @@ function handleEvent(tracer, state, event, getTranscript) {
         parent
       );
       state.turnSpan = span2;
-      state.turnCtx = import_api23.trace.setSpan(parent, span2);
+      state.turnCtx = import_api24.trace.setSpan(parent, span2);
       state.turnHasInput = !!priorInput;
       state.turnStartEpochMs = Date.now();
       break;
@@ -15964,10 +16280,10 @@ function handleEvent(tracer, state, event, getTranscript) {
         span2.setAttribute("output.value", safeStringify12(event.result));
       }
       if (event.isError) {
-        span2.setStatus({ code: import_api23.SpanStatusCode.ERROR, message: toolErrorText(event.result) });
+        span2.setStatus({ code: import_api24.SpanStatusCode.ERROR, message: toolErrorText(event.result) });
         span2.setAttribute("neatlogs.tool.is_error", true);
       } else {
-        span2.setStatus({ code: import_api23.SpanStatusCode.OK });
+        span2.setStatus({ code: import_api24.SpanStatusCode.OK });
       }
       span2.end();
       if (event.toolCallId) state.toolSpans.delete(event.toolCallId);
@@ -15976,7 +16292,7 @@ function handleEvent(tracer, state, event, getTranscript) {
     case "agent_end": {
       for (const ts of state.toolSpans.values()) {
         try {
-          ts.setStatus({ code: import_api23.SpanStatusCode.ERROR, message: "run ended before tool completed" });
+          ts.setStatus({ code: import_api24.SpanStatusCode.ERROR, message: "run ended before tool completed" });
           ts.end();
         } catch {
         }
@@ -15985,7 +16301,7 @@ function handleEvent(tracer, state, event, getTranscript) {
       if (state.llm) {
         try {
           state.llm.span.setAttribute("output.value", "[incomplete] run ended mid-stream");
-          state.llm.span.setStatus({ code: import_api23.SpanStatusCode.ERROR, message: "run ended mid-stream" });
+          state.llm.span.setStatus({ code: import_api24.SpanStatusCode.ERROR, message: "run ended mid-stream" });
           state.llm.span.end();
         } catch {
         }
@@ -16013,9 +16329,9 @@ function handleEvent(tracer, state, event, getTranscript) {
         if (err) {
           state.agentSpan.setAttribute("neatlogs.agent.stop_reason", err.stopReason);
           if (err.message) state.agentSpan.setAttribute("neatlogs.error.message", err.message);
-          state.agentSpan.setStatus({ code: import_api23.SpanStatusCode.ERROR, message: err.message ?? err.stopReason });
+          state.agentSpan.setStatus({ code: import_api24.SpanStatusCode.ERROR, message: err.message ?? err.stopReason });
         } else {
-          state.agentSpan.setStatus({ code: import_api23.SpanStatusCode.OK });
+          state.agentSpan.setStatus({ code: import_api24.SpanStatusCode.OK });
         }
         state.agentSpan.end();
         state.agentSpan = void 0;
@@ -16068,9 +16384,9 @@ function terminalSummary(msg) {
 function applyStopReasonStatus(span2, msg) {
   const reason = msg?.stopReason;
   if (reason === "aborted" || reason === "error") {
-    span2.setStatus({ code: import_api23.SpanStatusCode.ERROR, message: msg?.errorMessage ?? reason });
+    span2.setStatus({ code: import_api24.SpanStatusCode.ERROR, message: msg?.errorMessage ?? reason });
   } else {
-    span2.setStatus({ code: import_api23.SpanStatusCode.OK });
+    span2.setStatus({ code: import_api24.SpanStatusCode.OK });
   }
 }
 function isContentDelta(type) {
@@ -16238,7 +16554,7 @@ function safeStringify12(value) {
 }
 
 // src/claude-agent-sdk.ts
-var import_api24 = require("@opentelemetry/api");
+var import_api25 = require("@opentelemetry/api");
 var TRACER_NAME13 = "neatlogs.claude_agent_sdk";
 var ROOT_SCOPE = "__root__";
 function wrapClaudeAgentSDK(sdk, options = {}) {
@@ -16274,7 +16590,7 @@ function wrapQuery(original, options) {
     } else if (params && isAsyncIterable2(params.prompt)) {
       params = { ...params, prompt: tapPromptStream(params.prompt, promptRef) };
     }
-    const agentCtx = import_api24.trace.setSpan(getNeatlogsBaseContext(), agentSpan);
+    const agentCtx = import_api25.trace.setSpan(getNeatlogsBaseContext(), agentSpan);
     const queryObj = withNeatlogsSpan(agentSpan, () => original(params, ...rest));
     return instrumentQueryIterable(queryObj, agentSpan, agentCtx, tracer, promptRef);
   };
@@ -16294,7 +16610,7 @@ async function* tapPromptStream(prompt, ref) {
 function instrumentQueryIterable(queryObj, agentSpan, agentCtx, tracer, promptRef) {
   const originalAsyncIterator = queryObj?.[Symbol.asyncIterator]?.bind(queryObj);
   if (!originalAsyncIterator) {
-    agentSpan.setStatus({ code: import_api24.SpanStatusCode.OK });
+    agentSpan.setStatus({ code: import_api25.SpanStatusCode.OK });
     agentSpan.end();
     return queryObj;
   }
@@ -16331,7 +16647,7 @@ function instrumentQueryIterable(queryObj, agentSpan, agentCtx, tracer, promptRe
     if (status === "error") {
       recordError8(agentSpan, err);
     } else {
-      agentSpan.setStatus({ code: import_api24.SpanStatusCode.OK });
+      agentSpan.setStatus({ code: import_api25.SpanStatusCode.OK });
       agentSpan.end();
     }
   };
@@ -16373,7 +16689,7 @@ function instrumentQueryIterable(queryObj, agentSpan, agentCtx, tracer, promptRe
 function closeScope(scope, status) {
   try {
     if (scope.finalText) scope.span.setAttribute("output.value", scope.finalText);
-    scope.span.setStatus({ code: status === "ok" ? import_api24.SpanStatusCode.OK : import_api24.SpanStatusCode.ERROR });
+    scope.span.setStatus({ code: status === "ok" ? import_api25.SpanStatusCode.OK : import_api25.SpanStatusCode.ERROR });
     scope.span.end();
   } catch {
   }
@@ -16388,7 +16704,7 @@ function getScope(tracer, state, msg) {
     flushAssistantTurn(tracer, root, state);
   }
   const parentToolSpan = state.toolSpans.get(parentId);
-  const parentCtx = parentToolSpan ? import_api24.trace.setSpan(getNeatlogsBaseContext(), parentToolSpan) : state.scopes.get(ROOT_SCOPE).ctx;
+  const parentCtx = parentToolSpan ? import_api25.trace.setSpan(getNeatlogsBaseContext(), parentToolSpan) : state.scopes.get(ROOT_SCOPE).ctx;
   const subType = msg?.subagent_type ? String(msg.subagent_type) : "subagent";
   const attrs = {
     "neatlogs.span.kind": "AGENT",
@@ -16398,7 +16714,7 @@ function getScope(tracer, state, msg) {
   const span2 = tracer.startSpan(`claude_agent.subagent.${subType}`, { attributes: attrs }, parentCtx);
   const scope = {
     span: span2,
-    ctx: import_api24.trace.setSpan(getNeatlogsBaseContext(), span2),
+    ctx: import_api25.trace.setSpan(getNeatlogsBaseContext(), span2),
     inputMessages: msg?.task_description ? [{ role: "user", content: String(msg.task_description) }] : [],
     assistantBuffer: null,
     finalText: "",
@@ -16522,7 +16838,7 @@ function flushAssistantTurn(tracer, scope, state) {
   if (buf.stopReason) attrs["neatlogs.llm.finish_reason"] = String(buf.stopReason);
   const span2 = tracer.startSpan(`claude_agent.llm.${model || "model"}`, { attributes: attrs }, scope.ctx);
   if (buf.usage) setUsage3(span2, buf.usage);
-  span2.setStatus({ code: import_api24.SpanStatusCode.OK });
+  span2.setStatus({ code: import_api25.SpanStatusCode.OK });
   span2.end();
   if (outText) scope.finalText = outText;
   const turnParts = [];
@@ -16557,10 +16873,10 @@ function closeToolSpansFromUser(state, scope, msg) {
     if (!span2) continue;
     span2.setAttribute("output.value", outText);
     if (block.is_error) {
-      span2.setStatus({ code: import_api24.SpanStatusCode.ERROR });
+      span2.setStatus({ code: import_api25.SpanStatusCode.ERROR });
       span2.setAttribute("neatlogs.tool.is_error", true);
     } else {
-      span2.setStatus({ code: import_api24.SpanStatusCode.OK });
+      span2.setStatus({ code: import_api25.SpanStatusCode.OK });
     }
     span2.end();
     state.toolSpans.delete(id);
@@ -16612,16 +16928,16 @@ function recordError8(span2, err) {
     JSON.stringify({ status: "error", error: message })
   );
   if (err instanceof Error) {
-    span2.setStatus({ code: import_api24.SpanStatusCode.ERROR, message: err.message });
+    span2.setStatus({ code: import_api25.SpanStatusCode.ERROR, message: err.message });
     span2.recordException(err);
   } else {
-    span2.setStatus({ code: import_api24.SpanStatusCode.ERROR, message });
+    span2.setStatus({ code: import_api25.SpanStatusCode.ERROR, message });
   }
   span2.end();
 }
 
 // src/openrouter-agent.ts
-var import_api25 = require("@opentelemetry/api");
+var import_api26 = require("@opentelemetry/api");
 var TRACER_NAME14 = "neatlogs.openrouter_agent";
 var PROVIDER5 = "openrouter";
 function wrapOpenRouterAgent(client) {
@@ -16713,7 +17029,7 @@ function startLlmSpan(opts) {
 }
 function instrumentModelResult(result, span2) {
   if (!result || typeof result !== "object" && typeof result !== "function") {
-    span2.setStatus({ code: import_api25.SpanStatusCode.OK });
+    span2.setStatus({ code: import_api26.SpanStatusCode.OK });
     span2.end();
     return result;
   }
@@ -16724,7 +17040,7 @@ function instrumentModelResult(result, span2) {
     try {
       finalizeLlm(span2, resolved);
     } catch {
-      span2.setStatus({ code: import_api25.SpanStatusCode.OK });
+      span2.setStatus({ code: import_api26.SpanStatusCode.OK });
       span2.end();
     }
   };
@@ -16827,7 +17143,7 @@ function finalizeLlm(span2, result) {
   const finishReason = result?.finishReason ?? result?.finish_reason ?? result?.choices?.[0]?.finish_reason;
   if (finishReason) span2.setAttribute("neatlogs.llm.finish_reason", String(finishReason));
   setOpenResponsesUsage(span2, result);
-  span2.setStatus({ code: import_api25.SpanStatusCode.OK });
+  span2.setStatus({ code: import_api26.SpanStatusCode.OK });
   span2.end();
 }
 function extractOpenResponsesText(result) {
@@ -16853,10 +17169,10 @@ function safeStringify14(value) {
 }
 function recordError9(span2, err) {
   if (err instanceof Error) {
-    span2.setStatus({ code: import_api25.SpanStatusCode.ERROR, message: err.message });
+    span2.setStatus({ code: import_api26.SpanStatusCode.ERROR, message: err.message });
     span2.recordException(err);
   } else {
-    span2.setStatus({ code: import_api25.SpanStatusCode.ERROR, message: String(err) });
+    span2.setStatus({ code: import_api26.SpanStatusCode.ERROR, message: String(err) });
   }
   span2.end();
 }
@@ -17912,6 +18228,7 @@ var neatlogs_telemetry_schema_default = {
         "VECTOR_STORE",
         "MEMORY",
         "GUARDRAIL",
+        "EVALUATOR",
         "LOG",
         "HTTP",
         "UNKNOWN"
@@ -19340,6 +19657,7 @@ var neatlogs_telemetry_schema_default = {
             "AGENT",
             "CHAIN",
             "TASK",
+            "EVALUATOR",
             "HTTP",
             "UNKNOWN"
           ]
@@ -19503,6 +19821,7 @@ var neatlogs_telemetry_schema_default = {
           "neatlogs.vector_store.*",
           "neatlogs.memory.*",
           "neatlogs.guardrail.*",
+          "neatlogs.evaluator.*",
           "neatlogs.mcp.*",
           "neatlogs.code.*"
         ],
@@ -19581,7 +19900,7 @@ var neatlogs_telemetry_schema_default = {
 // src/schema-v2.ts
 var TELEMETRY_CONTRACT_VERSION = "2.0.0";
 var TELEMETRY_SCHEMA_VERSION = 2;
-var TELEMETRY_SCHEMA_SHA256 = "50bbd9f1e6eaa6c83f08dcb84da3a98867c962fc8c4e1edd629da561fe5fe5a8";
+var TELEMETRY_SCHEMA_SHA256 = "ae79717d127e2faa761ad83c8a51a08cae6fce00a04446d46dcc6d1a371818ce";
 var TELEMETRY_SCHEMA_V2 = Object.freeze(neatlogs_telemetry_schema_default);
 var TELEMETRY_CONFLICT_PRECEDENCE = Object.freeze(
   [...neatlogs_telemetry_schema_default["x-neatlogs-policy"].conflict_precedence]