neatlogs 1.1.19 → 1.1.21

package/dist/index.mjs

@@ -18,7 +18,7 @@ import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-proto";
 import * as fs from "fs";
 import * as path from "path";
 import { performance } from "perf_hooks";
-import { ROOT_CONTEXT as ROOT_CONTEXT4, trace as otelTrace3, TraceFlags, SpanStatusCode as SpanStatusCode3 } from "@opentelemetry/api";
+import { ROOT_CONTEXT as ROOT_CONTEXT4, trace as otelTrace4, TraceFlags, SpanStatusCode as SpanStatusCode3 } from "@opentelemetry/api";
 
 // src/core/logger.ts
 var LOG_LEVELS = {
@@ -71,9 +71,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" },
@@ -162,7 +162,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";
@@ -276,15 +276,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(
@@ -2372,11 +2383,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 = otelTrace.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);
 }
@@ -2574,7 +2585,7 @@ var UserPromptTemplate = class extends BasePromptTemplate {
 
 // src/core/context.ts
 import {
-  trace as otelTrace2,
+  trace as otelTrace3,
   createContextKey as createContextKey2,
   ROOT_CONTEXT as ROOT_CONTEXT3,
   SpanStatusCode as SpanStatusCode2
@@ -4215,6 +4226,139 @@ function discardPendingMediaOwner(owner) {
   pendingMediaOwners.delete(owner ?? defaultPendingMediaOwner);
 }
 
+// src/core/auto-root.ts
+import {
+  trace as otelTrace2
+} from "@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: otelTrace2.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 = otelTrace2.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
 import {
   ROOT_CONTEXT as ROOT_CONTEXT2,
@@ -4321,7 +4465,28 @@ function decorateSpan(opts, fn) {
     const tracer = getNeatlogsTracer(TRACER_NAME);
     const isRoot = isRootSpan();
     const parentContext = isRoot ? ROOT_CONTEXT2 : getNeatlogsParentContext();
-    const span2 = tracer.startSpan(spanName, {}, parentContext);
+    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;
@@ -4690,7 +4855,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
@@ -4699,7 +4865,7 @@ function decorateSpan(opts, fn) {
           span2,
           opts.endUserId,
           opts.endUserMetadata,
-          isRoot
+          spanIsRoot
         );
         if (captureInput && args.length > 0) {
           try {
@@ -4739,7 +4905,7 @@ function decorateSpan(opts, fn) {
         finishError(error);
         throw error;
       }
-    });
+    }, autoRoot.ctx, autoRoot.root);
   };
   Object.defineProperty(wrapped, "name", {
     value: spanName,
@@ -4794,6 +4960,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);
@@ -4864,6 +5044,7 @@ async function trace(options, fn) {
     attributes: explicitAttributes,
     ...extraOptions
   } = options;
+  assertNoHttpSpanKind(kind, explicitAttributes);
   const sessionId = sessionIdOption ?? currentSessionId();
   const currentSpan = getActiveNeatlogsSpan();
   const rootSpan = getNeatlogsRootSpan();
@@ -4908,7 +5089,7 @@ async function trace(options, fn) {
   }
   let ctx = getNeatlogsActiveContext();
   if (shouldFallbackToRoot) {
-    ctx = otelTrace2.setSpan(ctx, rootSpan);
+    ctx = otelTrace3.setSpan(ctx, rootSpan);
   }
   const variablesJson = promptVariables ? JSON.stringify(promptVariables) : void 0;
   const userVariablesJson = userPromptVariables ? JSON.stringify(userPromptVariables) : void 0;
@@ -4942,12 +5123,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,
@@ -4999,13 +5181,34 @@ async function trace(options, fn) {
   };
   const parentContext = shouldCreateRootTrace ? ROOT_CONTEXT3 : 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
@@ -6203,27 +6406,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;
@@ -6505,6 +6692,46 @@ function addVerificationMarkerResourceAttribute(attributes) {
   if (marker) attributes[VERIFICATION_MARKER_KEY] = marker;
 }
 
+// src/core/http-span.ts
+import { SpanKind } from "@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 === SpanKind.CLIENT && HTTP_ATTRIBUTE_KEYS.some((key) => key in attributes);
+}
+
 // src/core/span-processor.ts
 var logger10 = getLogger();
 function resolveLogFilePath(configuredPath) {
@@ -6776,6 +7003,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 };
@@ -6935,6 +7163,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");
@@ -7033,8 +7262,8 @@ var NeatlogsSpanProcessor = class {
         isRemote: false,
         traceFlags: TraceFlags.SAMPLED
       };
-      const wrappedSpan = otelTrace3.wrapSpanContext(spanCtx);
-      const ctx = otelTrace3.setSpan(ROOT_CONTEXT4, wrappedSpan);
+      const wrappedSpan = otelTrace4.wrapSpanContext(spanCtx);
+      const ctx = otelTrace4.setSpan(ROOT_CONTEXT4, wrappedSpan);
       const marker = markerTracer.startSpan("neatlogs.trace.complete", void 0, ctx);
       marker.setAttribute("neatlogs.trace.complete", true);
       marker.setAttribute("neatlogs.internal", true);
@@ -7203,7 +7432,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;
@@ -7355,6 +7585,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();
@@ -7375,6 +7609,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,
@@ -9044,19 +9283,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) {
@@ -9158,6 +9385,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")) {
@@ -9241,8 +9486,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 = createHash4("sha256").update(apiKey).digest("hex");
   const serialized = stableValue({
     apiKeyDigest,
@@ -9262,7 +9512,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,
@@ -9342,12 +9592,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()
   );
@@ -9368,8 +9613,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,
@@ -9784,7 +10029,7 @@ function _doctorRuntimeSnapshot() {
 // src/core/client.ts
 import {
   INVALID_SPAN_CONTEXT as INVALID_SPAN_CONTEXT2,
-  trace as otelTrace4
+  trace as otelTrace5
 } from "@opentelemetry/api";
 import { Resource as Resource4 } from "@opentelemetry/resources";
 import { ATTR_SERVICE_NAME as ATTR_SERVICE_NAME2 } from "@opentelemetry/semantic-conventions";
@@ -9800,12 +10045,12 @@ import { OTLPLogExporter as OTLPLogExporter2 } from "@opentelemetry/exporter-log
 var logger14 = getLogger();
 var closedTracer = {
   startSpan() {
-    return otelTrace4.wrapSpanContext(INVALID_SPAN_CONTEXT2);
+    return otelTrace5.wrapSpanContext(INVALID_SPAN_CONTEXT2);
   },
   startActiveSpan(_name, arg2, arg3, arg4) {
     const fn = typeof arg2 === "function" ? arg2 : typeof arg3 === "function" ? arg3 : arg4;
     return fn(
-      otelTrace4.wrapSpanContext(INVALID_SPAN_CONTEXT2)
+      otelTrace5.wrapSpanContext(INVALID_SPAN_CONTEXT2)
     );
   }
 };
@@ -10286,7 +10531,7 @@ function Span(options) {
 import {
   TraceFlags as TraceFlags3,
   createTraceState,
-  trace as otelTrace5
+  trace as otelTrace6
 } from "@opentelemetry/api";
 function injectTraceContext(carrier) {
   const spanContext = getActiveNeatlogsSpan()?.spanContext();
@@ -10316,7 +10561,7 @@ function extractTraceContext(carrier, fn) {
   if (!spanContext) {
     return fn();
   }
-  return withNeatlogsRemoteParent(otelTrace5.wrapSpanContext(spanContext), fn);
+  return withNeatlogsRemoteParent(otelTrace6.wrapSpanContext(spanContext), fn);
 }
 function parseTraceParent(traceparent, tracestate) {
   const match = traceparent?.trim().match(
@@ -10352,10 +10597,14 @@ function setHeader(carrier, name, value) {
 }
 
 // src/ai-sdk.ts
-import { SpanStatusCode as SpanStatusCode6 } from "@opentelemetry/api";
+import {
+  SpanStatusCode as SpanStatusCode6
+} from "@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,
@@ -10364,8 +10613,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) {
@@ -10439,21 +10691,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() {
@@ -10550,15 +10861,126 @@ 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
     }
   };
 }
@@ -10574,110 +10996,6 @@ function recordSpanError(span2, err) {
 // src/openai.ts
 import { SpanStatusCode as SpanStatusCode8 } from "@opentelemetry/api";
 
-// src/core/auto-root.ts
-import {
-  trace as otelTrace6
-} from "@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: otelTrace6.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 = otelTrace6.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));
-}
-
 // src/core/choice-accumulator.ts
 import { SpanStatusCode as SpanStatusCode7 } from "@opentelemetry/api";
 import { createHash as createHash5 } from "crypto";
@@ -17834,6 +18152,7 @@ var neatlogs_telemetry_schema_default = {
         "VECTOR_STORE",
         "MEMORY",
         "GUARDRAIL",
+        "EVALUATOR",
         "LOG",
         "HTTP",
         "UNKNOWN"
@@ -19262,6 +19581,7 @@ var neatlogs_telemetry_schema_default = {
             "AGENT",
             "CHAIN",
             "TASK",
+            "EVALUATOR",
             "HTTP",
             "UNKNOWN"
           ]
@@ -19425,6 +19745,7 @@ var neatlogs_telemetry_schema_default = {
           "neatlogs.vector_store.*",
           "neatlogs.memory.*",
           "neatlogs.guardrail.*",
+          "neatlogs.evaluator.*",
           "neatlogs.mcp.*",
           "neatlogs.code.*"
         ],
@@ -19503,7 +19824,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]