neatlogs 1.0.9 → 1.1.0

package/dist/index.cjs

@@ -86,7 +86,7 @@ module.exports = __toCommonJS(index_exports);
 // src/init.ts
 var import_node_crypto = require("crypto");
 var path3 = __toESM(require("path"));
-var import_api7 = require("@opentelemetry/api");
+var import_api8 = require("@opentelemetry/api");
 var import_api_logs = require("@opentelemetry/api-logs");
 var import_resources = require("@opentelemetry/resources");
 var import_semantic_conventions = require("@opentelemetry/semantic-conventions");
@@ -101,7 +101,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_api3 = require("@opentelemetry/api");
+var import_api4 = require("@opentelemetry/api");
 
 // src/core/logger.ts
 var LOG_LEVELS = {
@@ -2370,11 +2370,46 @@ var UserPromptTemplate = class extends BasePromptTemplate {
 };
 
 // src/core/context.ts
-var import_api2 = require("@opentelemetry/api");
+var import_api3 = require("@opentelemetry/api");
 
-// src/decorators/base.ts
+// src/core/end-user.ts
 var import_api = require("@opentelemetry/api");
 var logger4 = getLogger();
+var END_USER_ID_KEY = "neatlogs.end_user.id";
+var END_USER_METADATA_KEY = "neatlogs.end_user.metadata";
+function normalizeEndUserMetadata(metadata) {
+  if (metadata === void 0 || metadata === null) return void 0;
+  if (typeof metadata === "string") return metadata || void 0;
+  try {
+    return JSON.stringify(metadata);
+  } catch {
+    return JSON.stringify(String(metadata));
+  }
+}
+function isRootSpan() {
+  const current = import_api.trace.getSpan(import_api.context.active());
+  return !(current && current.isRecording());
+}
+function applyEndUserAttributes(span2, endUserId, endUserMetadata, isRoot = true) {
+  if (!endUserId && !endUserMetadata) return;
+  if (!isRoot) {
+    logger4.debug(
+      "[end_user] Ignoring endUserId/endUserMetadata on a non-root span \u2014 declare it on the trace root (top-level trace()/span()) or init()."
+    );
+    return;
+  }
+  if (endUserId) {
+    span2.setAttribute(END_USER_ID_KEY, String(endUserId));
+  }
+  const metaJson = normalizeEndUserMetadata(endUserMetadata);
+  if (metaJson) {
+    span2.setAttribute(END_USER_METADATA_KEY, metaJson);
+  }
+}
+
+// src/decorators/base.ts
+var import_api2 = require("@opentelemetry/api");
+var logger5 = getLogger();
 var TRACER_NAME = "neatlogs";
 function safeJsonDumps(value) {
   try {
@@ -2423,21 +2458,23 @@ function setCommonSpanAttrs(span2, opts) {
   }
 }
 function decorateSpan(opts, fn) {
-  const tracer = import_api.trace.getTracer(TRACER_NAME);
+  const tracer = import_api2.trace.getTracer(TRACER_NAME);
   const spanName = opts.spanName ?? opts.name ?? (fn.name || "anonymous");
   const captureInput = opts.captureInput !== false;
   const captureOutput = opts.captureOutput !== false;
   const doCapture = shouldCaptureContent();
   const wrapped = (...args) => {
+    const isRoot = isRootSpan();
     return tracer.startActiveSpan(spanName, (span2) => {
       try {
         setCommonSpanAttrs(span2, opts);
+        applyEndUserAttributes(span2, opts.endUserId, opts.endUserMetadata, isRoot);
         if (captureInput && doCapture && args.length > 0) {
           try {
             const inputValue = args.length === 1 ? serializeObj(args[0]) : args.map(serializeObj);
             span2.setAttribute("input.value", safeJsonDumps(inputValue));
           } catch (err) {
-            logger4.debug(`Failed to capture input: ${err}`);
+            logger5.debug(`Failed to capture input: ${err}`);
           }
         }
         const result = fn(...args);
@@ -2447,7 +2484,7 @@ function decorateSpan(opts, fn) {
               try {
                 span2.setAttribute("output.value", safeJsonDumps(serializeObj(resolved)));
               } catch (err) {
-                logger4.debug(`Failed to capture output: ${err}`);
+                logger5.debug(`Failed to capture output: ${err}`);
               }
             }
             if (opts.postprocessResult) {
@@ -2455,15 +2492,15 @@ function decorateSpan(opts, fn) {
                 const boundInputs = _extractBoundInputs(fn, args);
                 opts.postprocessResult(span2, resolved, boundInputs);
               } catch (err) {
-                logger4.debug(`Postprocess failed: ${err}`);
+                logger5.debug(`Postprocess failed: ${err}`);
               }
             }
-            span2.setStatus({ code: import_api.SpanStatusCode.OK });
+            span2.setStatus({ code: import_api2.SpanStatusCode.OK });
             span2.end();
             return resolved;
           }).catch((error) => {
             span2.setStatus({
-              code: import_api.SpanStatusCode.ERROR,
+              code: import_api2.SpanStatusCode.ERROR,
               message: error?.message ?? String(error)
             });
             span2.recordException(error instanceof Error ? error : new Error(String(error)));
@@ -2475,7 +2512,7 @@ function decorateSpan(opts, fn) {
           try {
             span2.setAttribute("output.value", safeJsonDumps(serializeObj(result)));
           } catch (err) {
-            logger4.debug(`Failed to capture output: ${err}`);
+            logger5.debug(`Failed to capture output: ${err}`);
           }
         }
         if (opts.postprocessResult) {
@@ -2483,15 +2520,15 @@ function decorateSpan(opts, fn) {
             const boundInputs = _extractBoundInputs(fn, args);
             opts.postprocessResult(span2, result, boundInputs);
           } catch (err) {
-            logger4.debug(`Postprocess failed: ${err}`);
+            logger5.debug(`Postprocess failed: ${err}`);
           }
         }
-        span2.setStatus({ code: import_api.SpanStatusCode.OK });
+        span2.setStatus({ code: import_api2.SpanStatusCode.OK });
         span2.end();
         return result;
       } catch (error) {
         span2.setStatus({
-          code: import_api.SpanStatusCode.ERROR,
+          code: import_api2.SpanStatusCode.ERROR,
           message: error?.message ?? String(error)
         });
         span2.recordException(error instanceof Error ? error : new Error(String(error)));
@@ -2517,7 +2554,7 @@ function _extractBoundInputs(fn, args) {
 }
 
 // src/core/context.ts
-var logger5 = getLogger();
+var logger6 = getLogger();
 var _sessionConfig = {};
 function _setSessionConfig(config) {
   _sessionConfig = config;
@@ -2525,11 +2562,11 @@ function _setSessionConfig(config) {
 function getSessionConfig() {
   return { ..._sessionConfig };
 }
-var PROMPT_VARIABLES_KEY = (0, import_api2.createContextKey)("neatlogs.prompt_variables");
-var PROMPT_TEMPLATE_KEY = (0, import_api2.createContextKey)("neatlogs.prompt_template");
-var PROMPT_VERSION_KEY = (0, import_api2.createContextKey)("neatlogs.prompt_version");
-var USER_PROMPT_TEMPLATE_KEY = (0, import_api2.createContextKey)("neatlogs.user_prompt_template");
-var USER_PROMPT_VARIABLES_KEY = (0, import_api2.createContextKey)("neatlogs.user_prompt_variables");
+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 KNOWN_OPTION_KEYS = /* @__PURE__ */ new Set([
   "name",
   "kind",
@@ -2540,7 +2577,9 @@ var KNOWN_OPTION_KEYS = /* @__PURE__ */ new Set([
   "userPromptVariables",
   "version",
   "mask",
-  "attributes"
+  "attributes",
+  "endUserId",
+  "endUserMetadata"
 ]);
 function _setSpanAttributes(span2, kind, attributes) {
   span2.setAttribute("neatlogs.internal", true);
@@ -2557,7 +2596,7 @@ function _finalizePromptCapture(span2, isPromptTemplateObj, isUserPromptTemplate
         "llm.prompt_template_variables",
         JSON.stringify(capturedVars)
       );
-      logger5.debug(
+      logger6.debug(
         `[trace] Auto-captured variables from PromptContext: ${Object.keys(capturedVars).join(", ")}`
       );
     }
@@ -2569,7 +2608,7 @@ function _finalizePromptCapture(span2, isPromptTemplateObj, isUserPromptTemplate
         "llm.user_prompt_template_variables",
         JSON.stringify(capturedUserVars)
       );
-      logger5.debug(
+      logger6.debug(
         `[trace] Auto-captured variables from UserPromptContext: ${Object.keys(capturedUserVars).join(", ")}`
       );
     }
@@ -2586,12 +2625,14 @@ async function trace2(options, fn) {
     userPromptVariables,
     version,
     mask,
+    endUserId,
+    endUserMetadata,
     attributes: explicitAttributes,
     ...extraOptions
   } = options;
   const sessionConfig = getSessionConfig();
   const sessionId = sessionConfig.sessionId;
-  const currentSpan = import_api2.trace.getSpan(import_api2.context.active());
+  const currentSpan = import_api3.trace.getSpan(import_api3.context.active());
   const isInActiveTrace = currentSpan !== void 0 && currentSpan.isRecording();
   const shouldCreateRootTrace = !!sessionId && !isInActiveTrace;
   let templateString;
@@ -2601,7 +2642,7 @@ async function trace2(options, fn) {
       isPromptTemplateObj = true;
       const t = promptTemplate.template;
       templateString = typeof t === "string" ? t : JSON.stringify(t);
-      logger5.debug(
+      logger6.debug(
         `[trace] Using PromptTemplate object with variables: ${promptTemplate.variables.join(", ")}`
       );
     } else if (typeof promptTemplate === "string") {
@@ -2618,7 +2659,7 @@ async function trace2(options, fn) {
       isUserPromptTemplateObj = true;
       const t = userPromptTemplate.template;
       userTemplateString = typeof t === "string" ? t : JSON.stringify(t);
-      logger5.debug(
+      logger6.debug(
         `[trace] Using UserPromptTemplate object with variables: ${userPromptTemplate.variables.join(", ")}`
       );
     } else if (typeof userPromptTemplate === "string") {
@@ -2628,28 +2669,28 @@ async function trace2(options, fn) {
       userTemplateString = typeof t === "string" ? t : JSON.stringify(t);
     }
   }
-  let ctx = import_api2.context.active();
+  let ctx = import_api3.context.active();
   const variablesJson = promptVariables ? JSON.stringify(promptVariables) : void 0;
   const userVariablesJson = userPromptVariables ? JSON.stringify(userPromptVariables) : void 0;
   if (variablesJson) {
     ctx = ctx.setValue(PROMPT_VARIABLES_KEY, variablesJson);
-    logger5.debug(`[trace] Set neatlogs.prompt_variables in context: ${variablesJson}`);
+    logger6.debug(`[trace] Set neatlogs.prompt_variables in context: ${variablesJson}`);
   }
   if (templateString) {
     ctx = ctx.setValue(PROMPT_TEMPLATE_KEY, templateString);
-    logger5.debug(`[trace] Set neatlogs.prompt_template in context: ${templateString}`);
+    logger6.debug(`[trace] Set neatlogs.prompt_template in context: ${templateString}`);
   }
   if (userVariablesJson) {
     ctx = ctx.setValue(USER_PROMPT_VARIABLES_KEY, userVariablesJson);
-    logger5.debug(`[trace] Set neatlogs.user_prompt_variables in context: ${userVariablesJson}`);
+    logger6.debug(`[trace] Set neatlogs.user_prompt_variables in context: ${userVariablesJson}`);
   }
   if (userTemplateString) {
     ctx = ctx.setValue(USER_PROMPT_TEMPLATE_KEY, userTemplateString);
-    logger5.debug(`[trace] Set neatlogs.user_prompt_template in context: ${userTemplateString}`);
+    logger6.debug(`[trace] Set neatlogs.user_prompt_template in context: ${userTemplateString}`);
   }
   if (version) {
     ctx = ctx.setValue(PROMPT_VERSION_KEY, version);
-    logger5.debug(`[trace] Set neatlogs.prompt_version in context: ${version}`);
+    logger6.debug(`[trace] Set neatlogs.prompt_version in context: ${version}`);
   }
   const extraAttributes = { ...explicitAttributes ?? {} };
   for (const [key, value] of Object.entries(extraOptions)) {
@@ -2657,9 +2698,11 @@ async function trace2(options, fn) {
       extraAttributes[key] = value;
     }
   }
-  const tracer = import_api2.trace.getTracer("neatlogs.trace");
+  const isRootTrace = shouldCreateRootTrace || !isInActiveTrace;
+  const tracer = import_api3.trace.getTracer("neatlogs.trace");
   const spanCallback = async (span2) => {
     _setSpanAttributes(span2, kind, extraAttributes);
+    applyEndUserAttributes(span2, endUserId, endUserMetadata, isRootTrace);
     if (input !== void 0 && input !== null) {
       span2.setAttribute("input.value", safeJsonDumps(serializeObj(input)));
     }
@@ -2680,7 +2723,7 @@ async function trace2(options, fn) {
       return result;
     } catch (error) {
       span2.setStatus({
-        code: import_api2.SpanStatusCode.ERROR,
+        code: import_api3.SpanStatusCode.ERROR,
         message: error instanceof Error ? error.message : String(error)
       });
       span2.recordException(
@@ -2698,23 +2741,23 @@ async function trace2(options, fn) {
     }
   };
   if (shouldCreateRootTrace) {
-    logger5.debug(`[trace] Creating NEW root trace '${name}' (sessionId=${sessionId})`);
-    return tracer.startActiveSpan(name, {}, import_api2.ROOT_CONTEXT, spanCallback);
+    logger6.debug(`[trace] Creating NEW root trace '${name}' (sessionId=${sessionId})`);
+    return tracer.startActiveSpan(name, {}, import_api3.ROOT_CONTEXT, spanCallback);
   } else {
-    logger5.debug(`[trace] Creating child span '${name}'`);
+    logger6.debug(`[trace] Creating child span '${name}'`);
     return tracer.startActiveSpan(name, {}, ctx, spanCallback);
   }
 }
 
 // src/core/crewai-task-registry.ts
-var logger6 = getLogger();
+var logger7 = getLogger();
 var _registry = /* @__PURE__ */ new Map();
 function registerCrewaiTask(task, userTpl, vars) {
   const taskId = String(task.id);
   const tplStr = String(userTpl.template);
   const varsJson = vars && Object.keys(vars).length > 0 ? JSON.stringify(vars, (_key, val) => typeof val === "undefined" ? null : val) : null;
   _registry.set(taskId, [tplStr, varsJson]);
-  logger6.debug(`Registered CrewAI task ${taskId}`);
+  logger7.debug(`Registered CrewAI task ${taskId}`);
 }
 function popEntry(taskId) {
   const entry = _registry.get(taskId);
@@ -3856,7 +3899,7 @@ var attribute_mapping_default = {
 };
 
 // src/config/attribute-mapper.ts
-var logger7 = getLogger();
+var logger8 = getLogger();
 function flattenSources(sources) {
   if (!sources) return [];
   if (Array.isArray(sources)) return sources;
@@ -4177,7 +4220,7 @@ var AttributeMapper = class {
 };
 
 // src/core/span-processor.ts
-var logger8 = getLogger();
+var logger9 = getLogger();
 function resolveLogFilePath(configuredPath) {
   return path.isAbsolute(configuredPath) ? configuredPath : path.join(process.cwd(), configuredPath);
 }
@@ -4190,7 +4233,7 @@ function createLogStream(configuredPath) {
     const stream = fs.createWriteStream(logPath, { fd, autoClose: true });
     fd = null;
     stream.on("error", (error) => {
-      logger8.warn(`Failed to write span log file ${logPath}: ${error}`);
+      logger9.warn(`Failed to write span log file ${logPath}: ${error}`);
       stream.destroy();
     });
     return stream;
@@ -4201,7 +4244,7 @@ function createLogStream(configuredPath) {
       } catch {
       }
     }
-    logger8.warn(`Failed to open span log file ${logPath}: ${error}`);
+    logger9.warn(`Failed to open span log file ${logPath}: ${error}`);
     return null;
   }
 }
@@ -4222,11 +4265,11 @@ async function closeLogStream(stream, description) {
     };
     const closeHandler = settle;
     const errorHandler = (error) => {
-      logger8.warn(`Failed to close ${description} log file handle: ${error}`);
+      logger9.warn(`Failed to close ${description} log file handle: ${error}`);
       settle();
     };
     const timer = setTimeout(() => {
-      logger8.warn(
+      logger9.warn(
         `Timed out waiting for ${description} log stream to close; destroying`
       );
       stream.destroy();
@@ -4237,7 +4280,7 @@ async function closeLogStream(stream, description) {
     try {
       stream.end();
     } catch (error) {
-      logger8.warn(`Failed to close ${description} log file handle: ${error}`);
+      logger9.warn(`Failed to close ${description} log file handle: ${error}`);
       settle();
     }
   });
@@ -4316,7 +4359,7 @@ var NeatlogsSpanProcessor = class {
       const rawPath = process.env.NEATLOGS_LOG_RAW_SPANS_FILE ?? "spans_raw_optimized.log";
       this._rawLogStream = createLogStream(rawPath);
       if (this._rawLogStream) {
-        logger8.info(
+        logger9.info(
           `Raw span logging enabled: ${resolveLogFilePath(rawPath)}`
         );
       }
@@ -4328,7 +4371,7 @@ var NeatlogsSpanProcessor = class {
       const processedPath = process.env.NEATLOGS_LOG_SPANS_FILE ?? "spans_optimized.log";
       this._processedLogStream = createLogStream(processedPath);
       if (this._processedLogStream) {
-        logger8.info(
+        logger9.info(
           `Processed span logging enabled: ${resolveLogFilePath(processedPath)}`
         );
       }
@@ -4343,7 +4386,7 @@ var NeatlogsSpanProcessor = class {
       const spanName = typeof span2.name === "string" ? span2.name : "";
       const isLlmSpan = spanKind === "LLM" || LLM_NAME_PATTERNS.test(spanName);
       if (!isLlmSpan) return;
-      const ctx = import_api3.context.active();
+      const ctx = import_api4.context.active();
       let variablesJson = ctx.getValue(PROMPT_VARIABLES_KEY);
       let template = ctx.getValue(PROMPT_TEMPLATE_KEY);
       const versionVal = ctx.getValue(PROMPT_VERSION_KEY);
@@ -4374,14 +4417,14 @@ var NeatlogsSpanProcessor = class {
         }
       }
       if (this.debug) {
-        logger8.debug(
+        logger9.debug(
           `[SpanProcessor.onStart] LLM span '${spanName}' starting`
         );
-        logger8.debug(`  variables_json from context: ${variablesJson}`);
-        logger8.debug(`  template from context: ${template}`);
-        logger8.debug(`  version from context: ${versionVal}`);
-        logger8.debug(`  user_template from context: ${userTemplate}`);
-        logger8.debug(
+        logger9.debug(`  variables_json from context: ${variablesJson}`);
+        logger9.debug(`  template from context: ${template}`);
+        logger9.debug(`  version from context: ${versionVal}`);
+        logger9.debug(`  user_template from context: ${userTemplate}`);
+        logger9.debug(
           `  user_variables_json from context: ${userVariablesJson}`
         );
       }
@@ -4416,7 +4459,7 @@ var NeatlogsSpanProcessor = class {
     this.perfStats.spansProcessed += 1;
     try {
       if (this.debug) {
-        logger8.debug(`[SpanProcessor.onEnd] Span ending: ${span2.name}`);
+        logger9.debug(`[SpanProcessor.onEnd] Span ending: ${span2.name}`);
       }
       if (this._rawLogStream && !this._rawLogStream.destroyed) {
         try {
@@ -4424,7 +4467,7 @@ var NeatlogsSpanProcessor = class {
             JSON.stringify(spanToDict(span2)) + "\n"
           );
         } catch (e) {
-          logger8.warn(`Failed to write span to raw log file: ${e}`);
+          logger9.warn(`Failed to write span to raw log file: ${e}`);
         }
       }
       if (this.sampleRate < 1 && Math.random() > this.sampleRate) {
@@ -4447,7 +4490,7 @@ var NeatlogsSpanProcessor = class {
           delete unifiedAttrs[key];
         }
         if (this.debug && keysToRemove.length > 0) {
-          logger8.debug(
+          logger9.debug(
             `[EMBEDDING Filter] Removed ${keysToRemove.length} large attribute keys from ${nlKind} span (skip_output=${skipOutput})`
           );
         }
@@ -4474,7 +4517,7 @@ var NeatlogsSpanProcessor = class {
           this._retrieversToSuppress.delete(spanId2);
           unifiedAttrs["neatlogs.internal"] = true;
           if (this.debug) {
-            logger8.debug(
+            logger9.debug(
               `[Retriever Merge] Marked OI retriever '${span2.name}' as internal (had neatlogs retriever child)`
             );
           }
@@ -4492,7 +4535,7 @@ var NeatlogsSpanProcessor = class {
           }
         }
         if (this.debug && "neatlogs.tags" in resourceAttrs) {
-          logger8.debug(
+          logger9.debug(
             `[Tags] Span ${span2.name}: resource.neatlogs.tags = ${resourceAttrs["neatlogs.tags"]}`
           );
         }
@@ -4502,7 +4545,7 @@ var NeatlogsSpanProcessor = class {
       let parentSpanId = span2.parentSpanId ?? null;
       if (parentSpanId === spanId) {
         if (this.debug) {
-          logger8.warn(
+          logger9.warn(
             `[SpanProcessor] Detected self-parenting span. trace_id=${traceId} span_id=${spanId} name=${span2.name}. Setting parent_span_id=None.`
           );
         }
@@ -4523,7 +4566,7 @@ var NeatlogsSpanProcessor = class {
         attributes: unifiedAttrs,
         resource: { attributes: resourceAttrs },
         status: {
-          code: import_api3.SpanStatusCode[span2.status.code] ?? String(span2.status.code),
+          code: import_api4.SpanStatusCode[span2.status.code] ?? String(span2.status.code),
           description: span2.status.message ?? null
         },
         events: span2.events ? span2.events.map((e) => ({
@@ -4565,7 +4608,7 @@ var NeatlogsSpanProcessor = class {
         }
       } catch (wbExc) {
         if (this.debug) {
-          logger8.debug(
+          logger9.debug(
             `[SpanProcessor] Attr write-back failed: ${wbExc}`
           );
         }
@@ -4576,7 +4619,7 @@ var NeatlogsSpanProcessor = class {
             JSON.stringify(spanData) + "\n"
           );
         } catch (e) {
-          logger8.warn(`Failed to write span to processed log file: ${e}`);
+          logger9.warn(`Failed to write span to processed log file: ${e}`);
         }
       }
       this.perfStats.spansExported += 1;
@@ -4594,11 +4637,11 @@ var NeatlogsSpanProcessor = class {
         traceId: rootSpan.spanContext().traceId,
         spanId: rootSpan.spanContext().spanId,
         isRemote: false,
-        traceFlags: import_api3.TraceFlags.SAMPLED
+        traceFlags: import_api4.TraceFlags.SAMPLED
       };
-      const wrappedSpan = import_api3.trace.wrapSpanContext(spanCtx);
-      const ctx = import_api3.trace.setSpan(import_api3.context.active(), wrappedSpan);
-      const tracer = import_api3.trace.getTracer("neatlogs.internal");
+      const wrappedSpan = import_api4.trace.wrapSpanContext(spanCtx);
+      const ctx = import_api4.trace.setSpan(import_api4.context.active(), wrappedSpan);
+      const tracer = import_api4.trace.getTracer("neatlogs.internal");
       const marker = tracer.startSpan("neatlogs.trace.complete", void 0, ctx);
       marker.setAttribute("neatlogs.trace.complete", true);
       marker.setAttribute("neatlogs.internal", true);
@@ -4608,12 +4651,12 @@ var NeatlogsSpanProcessor = class {
       }
       marker.end();
       if (this.debug) {
-        logger8.debug(
+        logger9.debug(
           `[SpanProcessor] Emitted completion marker for trace ${traceId}`
         );
       }
     } catch (e) {
-      logger8.warn(`[SpanProcessor] Failed to emit completion marker: ${e}`);
+      logger9.warn(`[SpanProcessor] Failed to emit completion marker: ${e}`);
     }
   }
   // ── Framework span name normalization ─────────────────
@@ -4680,7 +4723,7 @@ var NeatlogsSpanProcessor = class {
         if (respMeta?.model_name && respMeta.model_name !== currentModel) {
           attrs["neatlogs.llm.model_name"] = respMeta.model_name;
           if (this.debug) {
-            logger8.debug(
+            logger9.debug(
               `[ModelResolve] LangChain span: ${currentModel} \u2192 ${respMeta.model_name}`
             );
           }
@@ -4690,13 +4733,13 @@ var NeatlogsSpanProcessor = class {
       if (output?.model && output.model !== currentModel) {
         attrs["neatlogs.llm.model_name"] = output.model;
         if (this.debug) {
-          logger8.debug(
+          logger9.debug(
             `[ModelResolve] Direct response: ${currentModel} \u2192 ${output.model}`
           );
         }
       }
     } catch (e) {
-      logger8.warn(`[ModelResolve] Failed to parse LLM output for model extraction: ${e}`);
+      logger9.warn(`[ModelResolve] Failed to parse LLM output for model extraction: ${e}`);
     }
   }
   // ── forceFlush / shutdown ─────────────────────────────
@@ -4717,7 +4760,7 @@ var NeatlogsSpanProcessor = class {
     const totalTime = stats.onStartTime + stats.onEndTime;
     const avgMs = totalTime / stats.spansProcessed;
     try {
-      logger8.info(
+      logger9.info(
         `Neatlogs overhead: ${totalTime.toFixed(2)}ms total, ${avgMs.toFixed(3)}ms/span (${stats.spansProcessed} spans processed, ${stats.spansExported} spans logged)`
       );
     } catch {
@@ -4759,7 +4802,7 @@ var FilteringExporter = class {
 };
 
 // src/core/exporter.ts
-var logger9 = getLogger();
+var logger10 = getLogger();
 var NeatlogsExporter = class {
   baseUrl;
   apiKey;
@@ -4788,7 +4831,7 @@ var NeatlogsExporter = class {
     this.buffer.push(spanData);
     if (this.buffer.length >= this.batchSize) {
       this.flush().catch((err) => {
-        logger9.warn(`Failed to flush batch: ${err}`);
+        logger10.warn(`Failed to flush batch: ${err}`);
       });
     }
   }
@@ -4807,15 +4850,15 @@ var NeatlogsExporter = class {
         body: JSON.stringify({ spans: batch })
       });
       if (!response.ok) {
-        logger9.warn(
+        logger10.warn(
           `Failed to export batch: ${response.status} ${response.statusText}`
         );
         this._requeueBatch(batch);
       } else {
-        logger9.debug(`Exported ${batch.length} log spans`);
+        logger10.debug(`Exported ${batch.length} log spans`);
       }
     } catch (err) {
-      logger9.warn(`Failed to export batch: ${err}`);
+      logger10.warn(`Failed to export batch: ${err}`);
       this._requeueBatch(batch);
     }
   }
@@ -4842,8 +4885,8 @@ var fs2 = __toESM(require("fs"));
 var path2 = __toESM(require("path"));
 
 // node_modules/@opentelemetry/core/build/esm/trace/suppress-tracing.js
-var import_api4 = require("@opentelemetry/api");
-var SUPPRESS_TRACING_KEY = (0, import_api4.createContextKey)("OpenTelemetry SDK Context Key SUPPRESS_TRACING");
+var import_api5 = require("@opentelemetry/api");
+var SUPPRESS_TRACING_KEY = (0, import_api5.createContextKey)("OpenTelemetry SDK Context Key SUPPRESS_TRACING");
 function suppressTracing(context3) {
   return context3.setValue(SUPPRESS_TRACING_KEY, true);
 }
@@ -4856,7 +4899,7 @@ var ExportResultCode;
 })(ExportResultCode || (ExportResultCode = {}));
 
 // src/core/log-exporter.ts
-var logger10 = getLogger();
+var logger11 = getLogger();
 var NeatlogsLogExporter = class {
   exporter;
   logFileHandle = null;
@@ -4871,9 +4914,9 @@ var NeatlogsLogExporter = class {
       const filePath = path2.resolve(process.cwd(), logFile);
       try {
         this.logFileHandle = fs2.openSync(filePath, "a");
-        logger10.info(`Log record logging enabled: ${filePath}`);
+        logger11.info(`Log record logging enabled: ${filePath}`);
       } catch (err) {
-        logger10.warn(`Failed to open log file ${filePath}: ${err}`);
+        logger11.warn(`Failed to open log file ${filePath}: ${err}`);
       }
     }
   }
@@ -4886,7 +4929,7 @@ var NeatlogsLogExporter = class {
       }
       resultCallback({ code: ExportResultCode.SUCCESS });
     } catch (err) {
-      logger10.warn(`Failed to export log records: ${err}`);
+      logger11.warn(`Failed to export log records: ${err}`);
       resultCallback({ code: ExportResultCode.FAILED });
     }
   }
@@ -4937,8 +4980,8 @@ var NeatlogsLogExporter = class {
 };
 
 // src/core/log.ts
-var import_api5 = require("@opentelemetry/api");
-var logger11 = getLogger();
+var import_api6 = require("@opentelemetry/api");
+var logger12 = getLogger();
 var _otelLogger = null;
 var _debugMode = false;
 function _setOtelLogger(otelLogger, debug) {
@@ -4955,7 +4998,7 @@ function log(msgTemplate, options) {
     console.log(`[neatlogs:log] ${rendered}`);
   }
   if (_otelLogger) {
-    const activeSpan = import_api5.trace.getSpan(import_api5.context.active());
+    const activeSpan = import_api6.trace.getSpan(import_api6.context.active());
     const spanContext = activeSpan?.spanContext();
     const attributes = {
       "log.template": msgTemplate,
@@ -4971,7 +5014,7 @@ function log(msgTemplate, options) {
         ...spanContext ? { spanContext } : {}
       });
     } catch (err) {
-      logger11.warn(`Failed to emit log record: ${err}`);
+      logger12.warn(`Failed to emit log record: ${err}`);
     }
   }
 }
@@ -5400,7 +5443,7 @@ function getLibraryInfo(library) {
 }
 
 // src/instrumentation/manager.ts
-var logger12 = getLogger();
+var logger13 = getLogger();
 var InstrumentationManager = class {
   provider;
   _instrumented = [];
@@ -5419,7 +5462,7 @@ var InstrumentationManager = class {
     for (const lib of libraries) {
       const info = getLibraryInfo(lib);
       if (!info) {
-        logger12.warn(
+        logger13.warn(
           `Unknown library '${lib}' \u2014 not in instrumentation registry. Skipping.`
         );
         continue;
@@ -5435,7 +5478,7 @@ var InstrumentationManager = class {
             if (typeof instrumentor.instrument === "function") {
               instrumentor.instrument({ tracerProvider: this.provider });
               this._instrumented.push(lib);
-              logger12.debug(
+              logger13.debug(
                 `Instrumented '${lib}' via neatlogs custom instrumentor`
               );
               continue;
@@ -5448,23 +5491,23 @@ var InstrumentationManager = class {
                   const targetMod = await import(info.npm_package);
                   instrumentor.patchEager(targetMod);
                 } catch (e) {
-                  logger12.debug(
+                  logger13.debug(
                     `Eager patch for '${lib}' skipped \u2014 ${info.npm_package} not available: ${e}`
                   );
                 }
               }
               this._instrumented.push(lib);
-              logger12.debug(
+              logger13.debug(
                 `Instrumented '${lib}' via neatlogs OTel instrumentor`
               );
               continue;
             }
           }
-          logger12.debug(
+          logger13.debug(
             `neatlogs instrumentor for '${lib}' loaded but has no instrument() method \u2014 trying OpenInference`
           );
         } catch (err) {
-          logger12.debug(
+          logger13.debug(
             `neatlogs instrumentor for '${lib}' failed to load: ${err} \u2014 trying OpenInference`
           );
         }
@@ -5480,7 +5523,7 @@ var InstrumentationManager = class {
             if (typeof instrumentor.instrument === "function") {
               instrumentor.instrument({ tracerProvider: this.provider });
               this._instrumented.push(lib);
-              logger12.debug(`Instrumented '${lib}' via OpenInference`);
+              logger13.debug(`Instrumented '${lib}' via OpenInference`);
               continue;
             }
             if (typeof instrumentor.setTracerProvider === "function" && typeof instrumentor.manuallyInstrument === "function") {
@@ -5490,16 +5533,16 @@ var InstrumentationManager = class {
                   const targetMod = await import(info.npm_package);
                   instrumentor.manuallyInstrument(targetMod);
                   this._instrumented.push(lib);
-                  logger12.debug(`Instrumented '${lib}' via OpenInference (manual patch)`);
+                  logger13.debug(`Instrumented '${lib}' via OpenInference (manual patch)`);
                   continue;
                 } catch (importErr) {
-                  logger12.debug(
+                  logger13.debug(
                     `Could not import '${info.npm_package}' for manual instrumentation of '${lib}': ${importErr}`
                   );
                 }
               }
               this._instrumented.push(lib);
-              logger12.debug(`Instrumented '${lib}' via OpenInference (tracer set, awaiting module hook)`);
+              logger13.debug(`Instrumented '${lib}' via OpenInference (tracer set, awaiting module hook)`);
               continue;
             }
           }
@@ -5508,32 +5551,32 @@ var InstrumentationManager = class {
               tracerProvider: this.provider
             });
             this._instrumented.push(lib);
-            logger12.debug(`Instrumented '${lib}' via OpenInference`);
+            logger13.debug(`Instrumented '${lib}' via OpenInference`);
             continue;
           }
-          logger12.warn(
+          logger13.warn(
             `OpenInference package for '${lib}' loaded but could not find instrumentor class`
           );
         } catch (err) {
-          logger12.debug(
+          logger13.debug(
             `OpenInference instrumentor for '${lib}' not available: ${err}`
           );
         }
       }
       if (!info.openinference && !info.neatlogs) {
-        logger12.debug(
+        logger13.debug(
           `'${lib}' instrumentation not yet available for TypeScript \u2014 skipping`
         );
       }
     }
     if (this._instrumented.length > 0) {
-      logger12.info(`Instrumented: ${this._instrumented.join(", ")}`);
+      logger13.info(`Instrumented: ${this._instrumented.join(", ")}`);
     }
   }
 };
 
 // src/prompt/client.ts
-var import_api6 = require("@opentelemetry/api");
+var import_api7 = require("@opentelemetry/api");
 var PromptClientError = class extends Error {
   constructor(message) {
     super(message);
@@ -5843,8 +5886,8 @@ var PromptClient = class {
     };
     let response;
     try {
-      const suppressedContext = suppressTracing(import_api6.context.active());
-      response = await import_api6.context.with(suppressedContext, () => fetch(url, fetchOptions));
+      const suppressedContext = suppressTracing(import_api7.context.active());
+      response = await import_api7.context.with(suppressedContext, () => fetch(url, fetchOptions));
     } catch {
       response = await fetch(url, fetchOptions);
     }
@@ -5899,10 +5942,10 @@ async function removeTag(name, tag) {
 }
 
 // src/version.ts
-var __version__ = "1.0.9";
+var __version__ = "1.1.0";
 
 // src/init.ts
-var logger13 = getLogger();
+var logger14 = getLogger();
 var _initialized = false;
 var _tracerProvider = null;
 var _meterProvider = null;
@@ -5931,7 +5974,7 @@ function _randomHex(bytes) {
 }
 async function init(options = {}) {
   if (_initialized) {
-    logger13.warn("Neatlogs already initialized, skipping re-initialization");
+    logger14.warn("Neatlogs already initialized, skipping re-initialization");
     return;
   }
   let resolvedKey;
@@ -5947,7 +5990,7 @@ async function init(options = {}) {
     disableExportResolved = true;
     resolvedKey = "disabled";
     if (options.debug) {
-      logger13.warn(
+      logger14.warn(
         "No NEATLOGS_API_KEY set; HTTP export disabled. Set NEATLOGS_API_KEY (or pass apiKey) to send spans to the backend."
       );
     }
@@ -5961,7 +6004,7 @@ async function init(options = {}) {
   if (!sessionId && options.autoSession) {
     sessionId = `session_${Date.now()}_${_randomHex(4)}`;
     if (options.debug) {
-      logger13.debug(`Auto-generated session_id: ${sessionId}`);
+      logger14.debug(`Auto-generated session_id: ${sessionId}`);
     }
   }
   const endpoint = options.endpoint ?? "https://staging-cloud.neatlogs.com";
@@ -5983,6 +6026,13 @@ async function init(options = {}) {
   };
   if (sessionId) resourceAttrs["session.id"] = sessionId;
   if (options.userId) resourceAttrs["user.id"] = options.userId;
+  if (options.endUserId) {
+    resourceAttrs[END_USER_ID_KEY] = String(options.endUserId);
+  }
+  if (options.endUserMetadata) {
+    const euMeta = normalizeEndUserMetadata(options.endUserMetadata);
+    if (euMeta) resourceAttrs[END_USER_METADATA_KEY] = euMeta;
+  }
   const tags = options.tags;
   if (tags !== void 0) {
     if (!Array.isArray(tags) || !tags.every((t) => typeof t === "string")) {
@@ -6021,25 +6071,25 @@ async function init(options = {}) {
     });
     provider.addSpanProcessor(batchProcessor);
     if (options.debug) {
-      logger13.debug(`OTLP trace exporter configured: ${tracesEndpoint}`);
+      logger14.debug(`OTLP trace exporter configured: ${tracesEndpoint}`);
     }
   } else if (options.debug) {
-    logger13.debug("Export disabled \u2014 spans will not be sent to backend");
+    logger14.debug("Export disabled \u2014 spans will not be sent to backend");
   }
   provider.register();
   _tracerProvider = provider;
   if (options.debug) {
-    logger13.debug("Neatlogs tracer provider initialized");
+    logger14.debug("Neatlogs tracer provider initialized");
   }
   try {
     _meterProvider = new import_sdk_metrics.MeterProvider({ resource });
-    import_api7.metrics.setGlobalMeterProvider(_meterProvider);
+    import_api8.metrics.setGlobalMeterProvider(_meterProvider);
     if (options.debug) {
-      logger13.debug("Neatlogs meter provider initialized");
+      logger14.debug("Neatlogs meter provider initialized");
     }
   } catch {
     if (options.debug) {
-      logger13.debug("MeterProvider not available \u2014 skipping");
+      logger14.debug("MeterProvider not available \u2014 skipping");
     }
   }
   const captureLogs = options.captureLogs ?? false;
@@ -6065,17 +6115,17 @@ async function init(options = {}) {
         new import_sdk_logs.BatchLogRecordProcessor(otlpLogExporter)
       );
       if (options.debug) {
-        logger13.debug(`OTLP log exporter configured: ${logsEndpoint}`);
+        logger14.debug(`OTLP log exporter configured: ${logsEndpoint}`);
       }
     }
     import_api_logs.logs.setGlobalLoggerProvider(_logProvider);
     const otelLogger = _logProvider.getLogger("neatlogs");
     _setOtelLogger(otelLogger, options.debug ?? false);
     if (options.debug) {
-      logger13.debug(`Neatlogs log capture enabled (endpoint: ${baseUrl}/v1/logs)`);
+      logger14.debug(`Neatlogs log capture enabled (endpoint: ${baseUrl}/v1/logs)`);
     }
   } else if (options.debug) {
-    logger13.debug("Log capture disabled (pass captureLogs: true to enable)");
+    logger14.debug("Log capture disabled (pass captureLogs: true to enable)");
   }
   const manager = new InstrumentationManager({
     provider,
@@ -6084,7 +6134,7 @@ async function init(options = {}) {
   if (options.instrumentations?.length) {
     await manager.instrument(options.instrumentations);
     if (options.debug) {
-      logger13.debug(`Instrumented libraries: ${manager.instrumented.join(", ")}`);
+      logger14.debug(`Instrumented libraries: ${manager.instrumented.join(", ")}`);
     }
   }
   if (!_sigHandlersRegistered) {
@@ -6095,45 +6145,45 @@ async function init(options = {}) {
   }
   _initialized = true;
   if (options.debug) {
-    logger13.info("Neatlogs SDK initialized successfully");
-    logger13.info(`Endpoint: ${endpoint}`);
-    logger13.info(`Workflow: ${resolvedWorkflowName}`);
-    logger13.info(`Session: ${sessionId ?? "(none)"}`);
-    logger13.info(`User: ${options.userId ?? "(none)"}`);
-    logger13.info(`Tags: ${tags ?? []}`);
-    logger13.info(`Instrumentations: ${manager.instrumented.join(", ") || "(none)"}`);
-    logger13.info(`Sample Rate: ${options.sampleRate ?? 1}`);
+    logger14.info("Neatlogs SDK initialized successfully");
+    logger14.info(`Endpoint: ${endpoint}`);
+    logger14.info(`Workflow: ${resolvedWorkflowName}`);
+    logger14.info(`Session: ${sessionId ?? "(none)"}`);
+    logger14.info(`User: ${options.userId ?? "(none)"}`);
+    logger14.info(`Tags: ${tags ?? []}`);
+    logger14.info(`Instrumentations: ${manager.instrumented.join(", ") || "(none)"}`);
+    logger14.info(`Sample Rate: ${options.sampleRate ?? 1}`);
   }
 }
 async function flush() {
   let success = true;
   if (_tracerProvider) {
     try {
-      logger13.debug("Flushing tracer provider...");
+      logger14.debug("Flushing tracer provider...");
       await _tracerProvider.forceFlush();
-      logger13.debug("Tracer provider flushed successfully");
+      logger14.debug("Tracer provider flushed successfully");
     } catch (e) {
-      logger13.error(`Error flushing spans: ${e}`);
+      logger14.error(`Error flushing spans: ${e}`);
       success = false;
     }
   }
   if (_meterProvider) {
     try {
-      logger13.debug("Flushing meter provider...");
+      logger14.debug("Flushing meter provider...");
       await _meterProvider.forceFlush();
-      logger13.debug("Meter provider flushed successfully");
+      logger14.debug("Meter provider flushed successfully");
     } catch (e) {
-      logger13.error(`Error flushing metrics: ${e}`);
+      logger14.error(`Error flushing metrics: ${e}`);
       success = false;
     }
   }
   if (_logSpanExporter) {
     try {
-      logger13.debug("Flushing log span exporter...");
+      logger14.debug("Flushing log span exporter...");
       await _logSpanExporter.flush();
-      logger13.debug("Log span exporter flushed successfully");
+      logger14.debug("Log span exporter flushed successfully");
     } catch (e) {
-      logger13.error(`Error flushing logs: ${e}`);
+      logger14.error(`Error flushing logs: ${e}`);
       success = false;
     }
   }
@@ -6149,41 +6199,41 @@ async function shutdown() {
   let success = true;
   if (_tracerProvider) {
     try {
-      logger13.debug("Shutting down tracer provider...");
+      logger14.debug("Shutting down tracer provider...");
       await _tracerProvider.shutdown();
-      logger13.debug("Tracer provider shut down successfully");
+      logger14.debug("Tracer provider shut down successfully");
     } catch (e) {
-      logger13.error(`Error shutting down tracer provider: ${e}`);
+      logger14.error(`Error shutting down tracer provider: ${e}`);
       success = false;
     }
   }
   if (_meterProvider) {
     try {
-      logger13.debug("Shutting down meter provider...");
+      logger14.debug("Shutting down meter provider...");
       await _meterProvider.shutdown();
-      logger13.debug("Meter provider shut down successfully");
+      logger14.debug("Meter provider shut down successfully");
     } catch (e) {
-      logger13.error(`Error shutting down meter provider: ${e}`);
+      logger14.error(`Error shutting down meter provider: ${e}`);
       success = false;
     }
   }
   if (_logProvider) {
     try {
-      logger13.debug("Shutting down log provider...");
+      logger14.debug("Shutting down log provider...");
       await _logProvider.shutdown();
-      logger13.debug("Log provider shut down successfully");
+      logger14.debug("Log provider shut down successfully");
     } catch (e) {
-      logger13.error(`Error shutting down log provider: ${e}`);
+      logger14.error(`Error shutting down log provider: ${e}`);
       success = false;
     }
   }
   if (_logSpanExporter) {
     try {
-      logger13.debug("Shutting down log span exporter...");
+      logger14.debug("Shutting down log span exporter...");
       await _logSpanExporter.shutdown();
-      logger13.debug("Log span exporter shut down successfully");
+      logger14.debug("Log span exporter shut down successfully");
     } catch (e) {
-      logger13.error(`Error shutting down log span exporter: ${e}`);
+      logger14.error(`Error shutting down log span exporter: ${e}`);
       success = false;
     }
   }
@@ -6195,7 +6245,7 @@ async function shutdown() {
   _spanProcessor = null;
   _debugMode2 = false;
   _setSessionConfig({});
-  logger13.info("Neatlogs SDK shutdown complete");
+  logger14.info("Neatlogs SDK shutdown complete");
   return success;
 }
 function getTracerProvider() {
@@ -6211,7 +6261,7 @@ function isDebugEnabled() {
 }
 
 // src/decorators/orchestration.ts
-var logger14 = getLogger();
+var logger15 = getLogger();
 function span(options, fn) {
   if (!VALID_SPAN_KINDS.has(options.kind)) {
     throw new Error(
@@ -6372,7 +6422,7 @@ async function getMastraObservability() {
 }
 
 // src/ai-sdk.ts
-var import_api8 = require("@opentelemetry/api");
+var import_api9 = require("@opentelemetry/api");
 var TRACER_NAME2 = "neatlogs.ai-sdk";
 function createAITelemetry(opts = {}) {
   const userMeta = opts.metadata ?? {};
@@ -6380,7 +6430,7 @@ function createAITelemetry(opts = {}) {
     isEnabled: true,
     recordInputs: true,
     recordOutputs: true,
-    tracer: import_api8.trace.getTracer(TRACER_NAME2),
+    tracer: import_api9.trace.getTracer(TRACER_NAME2),
     metadata: { ...userMeta, neatlogsWrapped: true }
   };
 }
@@ -6451,18 +6501,18 @@ function rootSpanKind(name) {
   return "WORKFLOW";
 }
 function getParentContext() {
-  const activeSpan = import_api8.trace.getActiveSpan();
+  const activeSpan = import_api9.trace.getActiveSpan();
   if (activeSpan) {
     const instrScope = activeSpan.instrumentationLibrary?.name ?? "";
     if (instrScope === "next.js") {
-      return import_api8.ROOT_CONTEXT;
+      return import_api9.ROOT_CONTEXT;
     }
   }
-  return import_api8.context.active();
+  return import_api9.context.active();
 }
 function createAsyncWrapper(name, original) {
   return async function wrappedAsyncFn(opts) {
-    const tracer = import_api8.trace.getTracer(TRACER_NAME2);
+    const tracer = import_api9.trace.getTracer(TRACER_NAME2);
     return tracer.startActiveSpan(
       `ai.${name}`,
       { attributes: { "openinference.span.kind": rootSpanKind(name) } },
@@ -6494,7 +6544,7 @@ function createAsyncWrapper(name, original) {
 }
 function createSyncWrapper(name, original) {
   return function wrappedSyncFn(opts) {
-    const tracer = import_api8.trace.getTracer(TRACER_NAME2);
+    const tracer = import_api9.trace.getTracer(TRACER_NAME2);
     return tracer.startActiveSpan(`ai.${name}`, { attributes: { "openinference.span.kind": rootSpanKind(name) } }, getParentContext(), (span2) => {
       try {
         setInputValue(span2, opts);
@@ -6524,22 +6574,116 @@ function mergeTelemetry(opts) {
 }
 function recordSpanError(span2, err) {
   if (err instanceof Error) {
-    span2.setStatus({ code: import_api8.SpanStatusCode.ERROR, message: err.message });
+    span2.setStatus({ code: import_api9.SpanStatusCode.ERROR, message: err.message });
     span2.recordException(err);
   } else {
-    span2.setStatus({ code: import_api8.SpanStatusCode.ERROR, message: String(err) });
+    span2.setStatus({ code: import_api9.SpanStatusCode.ERROR, message: String(err) });
   }
 }
 
 // src/openai.ts
-var import_api9 = require("@opentelemetry/api");
+var import_api11 = require("@opentelemetry/api");
+
+// src/core/auto-root.ts
+var import_api10 = 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() {
+  try {
+    const name = getSessionConfig()?.workflowName;
+    if (typeof name === "string" && name.trim()) return name;
+  } catch {
+  }
+  return "workflow";
+}
+function wrapSpanWithRoot(child, root) {
+  let ended = false;
+  return 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;
+    }
+  });
+}
+function maybeOpenAutoRoot(tracer, kind, baseCtx) {
+  const k = String(kind ?? "").toLowerCase();
+  const existing = import_api10.trace.getSpan(baseCtx);
+  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
+  );
+  return { root, ctx: import_api10.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, context3) {
+    const kind = String(
+      options?.attributes?.["neatlogs.span.kind"] ?? ""
+    ).toLowerCase();
+    const ctx = context3 ?? import_api10.context.active();
+    const parent = import_api10.trace.getSpan(ctx);
+    const needsRoot = autoRootEnabled() && !ROOT_KINDS.has(kind) && !(parent !== void 0 && parent.isRecording());
+    if (!needsRoot) {
+      return this._tracer.startSpan(name, options, context3);
+    }
+    const root = this._tracer.startSpan(
+      resolveRootWorkflowName(),
+      { attributes: { "neatlogs.span.kind": "workflow", "neatlogs.auto_root": true } },
+      ctx
+    );
+    const childCtx = import_api10.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(import_api10.trace.getTracer(name));
+}
+
+// src/openai.ts
 var TRACER_NAME3 = "neatlogs.openai";
 function wrapOpenAI(client) {
   return wrapNamespace(client, []);
 }
 function traceTool(name, fn) {
   return async function tracedTool(args) {
-    const tracer = import_api9.trace.getTracer(TRACER_NAME3);
+    const tracer = import_api11.trace.getTracer(TRACER_NAME3);
     return tracer.startActiveSpan(
       `tool.${name}`,
       {
@@ -6549,12 +6693,12 @@ function traceTool(name, fn) {
           "input.value": safeStringify3(args)
         }
       },
-      import_api9.context.active(),
+      import_api11.context.active(),
       async (span2) => {
         try {
           const result = await fn(args);
           span2.setAttribute("output.value", safeStringify3(result));
-          span2.setStatus({ code: import_api9.SpanStatusCode.OK });
+          span2.setStatus({ code: import_api11.SpanStatusCode.OK });
           return result;
         } catch (err) {
           recordError(span2, err);
@@ -6593,7 +6737,7 @@ function isNamespace(path4) {
 }
 function tracedChatCompletionsCreate(original) {
   return function(opts, ...rest) {
-    const tracer = import_api9.trace.getTracer(TRACER_NAME3);
+    const tracer = getProviderTracer(TRACER_NAME3);
     const model = opts?.model ?? "";
     const messages = opts?.messages ?? [];
     const isStream = opts?.stream === true;
@@ -6605,7 +6749,7 @@ function tracedChatCompletionsCreate(original) {
         "neatlogs.llm.model_name": model,
         "neatlogs.llm.is_streaming": isStream
       }
-    }, import_api9.context.active());
+    }, import_api11.context.active());
     for (let i = 0; i < messages.length; i++) {
       const msg = messages[i];
       span2.setAttribute(`neatlogs.llm.input_messages.${i}.role`, msg.role ?? "");
@@ -6634,8 +6778,8 @@ function tracedChatCompletionsCreate(original) {
         opts.stream_options = { ...streamOpts, include_usage: true };
       }
     }
-    const ctx = import_api9.trace.setSpan(import_api9.context.active(), span2);
-    const promise = import_api9.context.with(ctx, () => original(opts, ...rest));
+    const ctx = import_api11.trace.setSpan(import_api11.context.active(), span2);
+    const promise = import_api11.context.with(ctx, () => original(opts, ...rest));
     return promise.then(
       (response) => {
         if (isStream) {
@@ -6653,7 +6797,7 @@ function tracedChatCompletionsCreate(original) {
 }
 function tracedResponsesCreate(original) {
   return function(opts, ...rest) {
-    const tracer = import_api9.trace.getTracer(TRACER_NAME3);
+    const tracer = getProviderTracer(TRACER_NAME3);
     const model = opts?.model ?? "";
     const span2 = tracer.startSpan("openai.responses.create", {
       attributes: {
@@ -6663,9 +6807,9 @@ function tracedResponsesCreate(original) {
         "neatlogs.llm.model_name": model,
         "input.value": safeStringify3(opts?.input ?? "")
       }
-    }, import_api9.context.active());
-    const ctx = import_api9.trace.setSpan(import_api9.context.active(), span2);
-    const promise = import_api9.context.with(ctx, () => original(opts, ...rest));
+    }, import_api11.context.active());
+    const ctx = import_api11.trace.setSpan(import_api11.context.active(), span2);
+    const promise = import_api11.context.with(ctx, () => original(opts, ...rest));
     return promise.then(
       (response) => {
         if (response?.output_text) {
@@ -6677,7 +6821,7 @@ function tracedResponsesCreate(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_api9.SpanStatusCode.OK });
+        span2.setStatus({ code: import_api11.SpanStatusCode.OK });
         span2.end();
         return response;
       },
@@ -6692,7 +6836,7 @@ function wrapAsyncIterableStream(stream, span2) {
   const chunks = [];
   const originalAsyncIterator = stream[Symbol.asyncIterator]?.bind(stream);
   if (!originalAsyncIterator) {
-    span2.setStatus({ code: import_api9.SpanStatusCode.OK });
+    span2.setStatus({ code: import_api11.SpanStatusCode.OK });
     span2.end();
     return stream;
   }
@@ -6778,7 +6922,7 @@ function finalizeStreamChunks(span2, chunks) {
       span2.setAttribute("neatlogs.llm.token_count.reasoning", usage.completion_tokens_details.reasoning_tokens);
     }
   }
-  span2.setStatus({ code: import_api9.SpanStatusCode.OK });
+  span2.setStatus({ code: import_api11.SpanStatusCode.OK });
   span2.end();
 }
 function finalizeChatResponse(span2, response) {
@@ -6815,7 +6959,7 @@ function finalizeChatResponse(span2, response) {
     }
   }
   if (response?.model) span2.setAttribute("neatlogs.llm.model_name", response.model);
-  span2.setStatus({ code: import_api9.SpanStatusCode.OK });
+  span2.setStatus({ code: import_api11.SpanStatusCode.OK });
   span2.end();
 }
 function setInvocationParams(span2, opts) {
@@ -6835,23 +6979,23 @@ function safeStringify3(value) {
 }
 function recordError(span2, err) {
   if (err instanceof Error) {
-    span2.setStatus({ code: import_api9.SpanStatusCode.ERROR, message: err.message });
+    span2.setStatus({ code: import_api11.SpanStatusCode.ERROR, message: err.message });
     span2.recordException(err);
   } else {
-    span2.setStatus({ code: import_api9.SpanStatusCode.ERROR, message: String(err) });
+    span2.setStatus({ code: import_api11.SpanStatusCode.ERROR, message: String(err) });
   }
   span2.end();
 }
 
 // src/anthropic.ts
-var import_api10 = require("@opentelemetry/api");
+var import_api12 = require("@opentelemetry/api");
 var TRACER_NAME4 = "neatlogs.anthropic";
 function wrapAnthropic(client) {
   return wrapNamespace2(client, []);
 }
 function traceTool2(name, fn) {
   return async function tracedTool(input) {
-    const tracer = import_api10.trace.getTracer(TRACER_NAME4);
+    const tracer = getProviderTracer(TRACER_NAME4);
     return tracer.startActiveSpan(
       `tool.${name}`,
       {
@@ -6861,12 +7005,12 @@ function traceTool2(name, fn) {
           "input.value": safeStringify4(input)
         }
       },
-      import_api10.context.active(),
+      import_api12.context.active(),
       async (span2) => {
         try {
           const result = await fn(input);
           span2.setAttribute("output.value", safeStringify4(result));
-          span2.setStatus({ code: import_api10.SpanStatusCode.OK });
+          span2.setStatus({ code: import_api12.SpanStatusCode.OK });
           return result;
         } catch (err) {
           recordError2(span2, err);
@@ -6905,7 +7049,7 @@ function isNamespace2(path4) {
 }
 function tracedMessagesCreate(original) {
   return function(opts, ...rest) {
-    const tracer = import_api10.trace.getTracer(TRACER_NAME4);
+    const tracer = getProviderTracer(TRACER_NAME4);
     const model = opts?.model ?? "";
     const messages = opts?.messages ?? [];
     const isStream = opts?.stream === true;
@@ -6917,12 +7061,12 @@ function tracedMessagesCreate(original) {
         "neatlogs.llm.model_name": model,
         "neatlogs.llm.is_streaming": isStream
       }
-    }, import_api10.context.active());
+    }, import_api12.context.active());
     setInputMessages(span2, opts?.system, messages);
     setTools(span2, opts?.tools);
     setInvocationParams2(span2, opts);
-    const ctx = import_api10.trace.setSpan(import_api10.context.active(), span2);
-    const promise = import_api10.context.with(ctx, () => original(opts, ...rest));
+    const ctx = import_api12.trace.setSpan(import_api12.context.active(), span2);
+    const promise = import_api12.context.with(ctx, () => original(opts, ...rest));
     return promise.then(
       (response) => {
         if (isStream) {
@@ -6940,7 +7084,7 @@ function tracedMessagesCreate(original) {
 }
 function tracedMessagesStream(original) {
   return function(opts, ...rest) {
-    const tracer = import_api10.trace.getTracer(TRACER_NAME4);
+    const tracer = getProviderTracer(TRACER_NAME4);
     const model = opts?.model ?? "";
     const messages = opts?.messages ?? [];
     const span2 = tracer.startSpan("anthropic.messages.stream", {
@@ -6951,12 +7095,12 @@ function tracedMessagesStream(original) {
         "neatlogs.llm.model_name": model,
         "neatlogs.llm.is_streaming": true
       }
-    }, import_api10.context.active());
+    }, import_api12.context.active());
     setInputMessages(span2, opts?.system, messages);
     setTools(span2, opts?.tools);
     setInvocationParams2(span2, opts);
-    const ctx = import_api10.trace.setSpan(import_api10.context.active(), span2);
-    const messageStream = import_api10.context.with(ctx, () => original(opts, ...rest));
+    const ctx = import_api12.trace.setSpan(import_api12.context.active(), span2);
+    const messageStream = import_api12.context.with(ctx, () => original(opts, ...rest));
     return wrapMessageStream(messageStream, span2);
   };
 }
@@ -6964,7 +7108,7 @@ function wrapStreamIterable(stream, span2) {
   const events = [];
   const originalAsyncIterator = stream[Symbol.asyncIterator]?.bind(stream);
   if (!originalAsyncIterator) {
-    span2.setStatus({ code: import_api10.SpanStatusCode.OK });
+    span2.setStatus({ code: import_api12.SpanStatusCode.OK });
     span2.end();
     return stream;
   }
@@ -7013,7 +7157,7 @@ function wrapMessageStream(messageStream, span2) {
       if (finalMsg) {
         finalizeMessageResponse(span2, finalMsg);
       } else {
-        span2.setStatus({ code: import_api10.SpanStatusCode.OK });
+        span2.setStatus({ code: import_api12.SpanStatusCode.OK });
         span2.end();
       }
     });
@@ -7091,7 +7235,7 @@ function finalizeStreamEvents(span2, events) {
   if (model) span2.setAttribute("neatlogs.llm.model_name", model);
   if (stopReason) span2.setAttribute("neatlogs.llm.stop_reason", stopReason);
   setUsageAttrs(span2, usage);
-  span2.setStatus({ code: import_api10.SpanStatusCode.OK });
+  span2.setStatus({ code: import_api12.SpanStatusCode.OK });
   span2.end();
 }
 function finalizeMessageResponse(span2, response) {
@@ -7125,7 +7269,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_api10.SpanStatusCode.OK });
+  span2.setStatus({ code: import_api12.SpanStatusCode.OK });
   span2.end();
 }
 function setInputMessages(span2, system, messages) {
@@ -7178,16 +7322,16 @@ function safeStringify4(value) {
 }
 function recordError2(span2, err) {
   if (err instanceof Error) {
-    span2.setStatus({ code: import_api10.SpanStatusCode.ERROR, message: err.message });
+    span2.setStatus({ code: import_api12.SpanStatusCode.ERROR, message: err.message });
     span2.recordException(err);
   } else {
-    span2.setStatus({ code: import_api10.SpanStatusCode.ERROR, message: String(err) });
+    span2.setStatus({ code: import_api12.SpanStatusCode.ERROR, message: String(err) });
   }
   span2.end();
 }
 
 // src/azure-openai.ts
-var import_api11 = require("@opentelemetry/api");
+var import_api13 = require("@opentelemetry/api");
 var TRACER_NAME5 = "neatlogs.azure_openai";
 var PROVIDER = "azure";
 var SYSTEM = "azure";
@@ -7196,7 +7340,7 @@ function wrapAzureOpenAI(client) {
 }
 function traceTool3(name, fn) {
   return async function tracedTool(args) {
-    const tracer = import_api11.trace.getTracer(TRACER_NAME5);
+    const tracer = getProviderTracer(TRACER_NAME5);
     return tracer.startActiveSpan(
       `tool.${name}`,
       {
@@ -7206,12 +7350,12 @@ function traceTool3(name, fn) {
           "input.value": safeStringify5(args)
         }
       },
-      import_api11.context.active(),
+      import_api13.context.active(),
       async (span2) => {
         try {
           const result = await fn(args);
           span2.setAttribute("output.value", safeStringify5(result));
-          span2.setStatus({ code: import_api11.SpanStatusCode.OK });
+          span2.setStatus({ code: import_api13.SpanStatusCode.OK });
           return result;
         } catch (err) {
           recordError3(span2, err);
@@ -7250,7 +7394,7 @@ function isNamespace3(path4) {
 }
 function tracedChatCompletionsCreate2(original) {
   return function(opts, ...rest) {
-    const tracer = import_api11.trace.getTracer(TRACER_NAME5);
+    const tracer = getProviderTracer(TRACER_NAME5);
     const model = opts?.model ?? "";
     const messages = opts?.messages ?? [];
     const isStream = opts?.stream === true;
@@ -7262,7 +7406,7 @@ function tracedChatCompletionsCreate2(original) {
         "neatlogs.llm.model_name": model,
         "neatlogs.llm.is_streaming": isStream
       }
-    }, import_api11.context.active());
+    }, import_api13.context.active());
     for (let i = 0; i < messages.length; i++) {
       const msg = messages[i];
       span2.setAttribute(`neatlogs.llm.input_messages.${i}.role`, msg.role ?? "");
@@ -7291,8 +7435,8 @@ function tracedChatCompletionsCreate2(original) {
         opts.stream_options = { ...streamOpts, include_usage: true };
       }
     }
-    const ctx = import_api11.trace.setSpan(import_api11.context.active(), span2);
-    const promise = import_api11.context.with(ctx, () => original(opts, ...rest));
+    const ctx = import_api13.trace.setSpan(import_api13.context.active(), span2);
+    const promise = import_api13.context.with(ctx, () => original(opts, ...rest));
     return promise.then(
       (response) => {
         if (isStream) {
@@ -7310,7 +7454,7 @@ function tracedChatCompletionsCreate2(original) {
 }
 function tracedResponsesCreate2(original) {
   return function(opts, ...rest) {
-    const tracer = import_api11.trace.getTracer(TRACER_NAME5);
+    const tracer = getProviderTracer(TRACER_NAME5);
     const model = opts?.model ?? "";
     const span2 = tracer.startSpan("azure_openai.responses.create", {
       attributes: {
@@ -7320,9 +7464,9 @@ function tracedResponsesCreate2(original) {
         "neatlogs.llm.model_name": model,
         "input.value": safeStringify5(opts?.input ?? "")
       }
-    }, import_api11.context.active());
-    const ctx = import_api11.trace.setSpan(import_api11.context.active(), span2);
-    const promise = import_api11.context.with(ctx, () => original(opts, ...rest));
+    }, import_api13.context.active());
+    const ctx = import_api13.trace.setSpan(import_api13.context.active(), span2);
+    const promise = import_api13.context.with(ctx, () => original(opts, ...rest));
     return promise.then(
       (response) => {
         if (response?.output_text) {
@@ -7334,7 +7478,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_api11.SpanStatusCode.OK });
+        span2.setStatus({ code: import_api13.SpanStatusCode.OK });
         span2.end();
         return response;
       },
@@ -7349,7 +7493,7 @@ function wrapAsyncIterableStream2(stream, span2) {
   const chunks = [];
   const originalAsyncIterator = stream?.[Symbol.asyncIterator]?.bind(stream);
   if (!originalAsyncIterator) {
-    span2.setStatus({ code: import_api11.SpanStatusCode.OK });
+    span2.setStatus({ code: import_api13.SpanStatusCode.OK });
     span2.end();
     return stream;
   }
@@ -7435,7 +7579,7 @@ function finalizeStreamChunks2(span2, chunks) {
       span2.setAttribute("neatlogs.llm.token_count.reasoning", usage.completion_tokens_details.reasoning_tokens);
     }
   }
-  span2.setStatus({ code: import_api11.SpanStatusCode.OK });
+  span2.setStatus({ code: import_api13.SpanStatusCode.OK });
   span2.end();
 }
 function finalizeChatResponse2(span2, response) {
@@ -7472,7 +7616,7 @@ function finalizeChatResponse2(span2, response) {
     }
   }
   if (response?.model) span2.setAttribute("neatlogs.llm.model_name", response.model);
-  span2.setStatus({ code: import_api11.SpanStatusCode.OK });
+  span2.setStatus({ code: import_api13.SpanStatusCode.OK });
   span2.end();
 }
 function setInvocationParams3(span2, opts) {
@@ -7492,16 +7636,16 @@ function safeStringify5(value) {
 }
 function recordError3(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) });
   }
   span2.end();
 }
 
 // src/vertex-ai.ts
-var import_api12 = require("@opentelemetry/api");
+var import_api14 = require("@opentelemetry/api");
 var TRACER_NAME6 = "neatlogs.vertex_ai";
 var PROVIDER2 = "vertex_ai";
 var SYSTEM2 = "vertexai";
@@ -7510,7 +7654,7 @@ function wrapVertexAI(client) {
 }
 function traceTool4(name, fn) {
   return async function tracedTool(args) {
-    const tracer = import_api12.trace.getTracer(TRACER_NAME6);
+    const tracer = getProviderTracer(TRACER_NAME6);
     return tracer.startActiveSpan(
       `tool.${name}`,
       {
@@ -7520,12 +7664,12 @@ function traceTool4(name, fn) {
           "input.value": safeStringify6(args)
         }
       },
-      import_api12.context.active(),
+      import_api14.context.active(),
       async (span2) => {
         try {
           const result = await fn(args);
           span2.setAttribute("output.value", safeStringify6(result));
-          span2.setStatus({ code: import_api12.SpanStatusCode.OK });
+          span2.setStatus({ code: import_api14.SpanStatusCode.OK });
           return result;
         } catch (err) {
           recordError4(span2, err);
@@ -7586,7 +7730,7 @@ function wrapVertexAIChat(chat) {
   return chat;
 }
 function tracedChatSend(original, chat, params, rest, isStream) {
-  const tracer = import_api12.trace.getTracer(TRACER_NAME6);
+  const tracer = getProviderTracer(TRACER_NAME6);
   const model = chat?.model ?? chat?.modelVersion ?? "";
   const span2 = tracer.startSpan("vertex_ai.chat.send_message", {
     attributes: {
@@ -7596,15 +7740,15 @@ function tracedChatSend(original, chat, params, rest, isStream) {
       "neatlogs.llm.model_name": model,
       "neatlogs.llm.is_streaming": isStream
     }
-  }, import_api12.context.active());
+  }, import_api14.context.active());
   const message = params?.message ?? params;
   span2.setAttribute("neatlogs.llm.input_messages.0.role", "user");
   span2.setAttribute(
     "neatlogs.llm.input_messages.0.content",
     typeof message === "string" ? message : safeStringify6(message)
   );
-  const ctx = import_api12.trace.setSpan(import_api12.context.active(), span2);
-  const result = import_api12.context.with(ctx, () => original(params, ...rest));
+  const ctx = import_api14.trace.setSpan(import_api14.context.active(), span2);
+  const result = import_api14.context.with(ctx, () => original(params, ...rest));
   return Promise.resolve(result).then(
     (response) => {
       if (isStream) return wrapStream(response, span2);
@@ -7619,7 +7763,7 @@ function tracedChatSend(original, chat, params, rest, isStream) {
 }
 function tracedEmbedContent(original) {
   return function(opts, ...rest) {
-    const tracer = import_api12.trace.getTracer(TRACER_NAME6);
+    const tracer = getProviderTracer(TRACER_NAME6);
     const span2 = tracer.startSpan("vertex_ai.models.embed_content", {
       attributes: {
         "neatlogs.span.kind": "EMBEDDING",
@@ -7627,9 +7771,9 @@ function tracedEmbedContent(original) {
         "neatlogs.embedding.model_name": opts?.model ?? "",
         "neatlogs.embedding.text": safeStringify6(opts?.contents ?? "")
       }
-    }, import_api12.context.active());
-    const ctx = import_api12.trace.setSpan(import_api12.context.active(), span2);
-    const result = import_api12.context.with(ctx, () => original(opts, ...rest));
+    }, import_api14.context.active());
+    const ctx = import_api14.trace.setSpan(import_api14.context.active(), span2);
+    const result = import_api14.context.with(ctx, () => original(opts, ...rest));
     return Promise.resolve(result).then(
       (response) => {
         const embeddings = response?.embeddings;
@@ -7638,7 +7782,7 @@ function tracedEmbedContent(original) {
           const vals = embeddings[0]?.values;
           if (Array.isArray(vals)) span2.setAttribute("neatlogs.embedding.dimensions", vals.length);
         }
-        span2.setStatus({ code: import_api12.SpanStatusCode.OK });
+        span2.setStatus({ code: import_api14.SpanStatusCode.OK });
         span2.end();
         return response;
       },
@@ -7651,7 +7795,7 @@ function tracedEmbedContent(original) {
 }
 function tracedCountTokens(original) {
   return function(opts, ...rest) {
-    const tracer = import_api12.trace.getTracer(TRACER_NAME6);
+    const tracer = getProviderTracer(TRACER_NAME6);
     const span2 = tracer.startSpan("vertex_ai.models.count_tokens", {
       attributes: {
         "neatlogs.span.kind": "LLM",
@@ -7659,13 +7803,13 @@ function tracedCountTokens(original) {
         "neatlogs.llm.task": "count_tokens",
         "neatlogs.llm.model_name": opts?.model ?? ""
       }
-    }, import_api12.context.active());
-    const ctx = import_api12.trace.setSpan(import_api12.context.active(), span2);
-    const result = import_api12.context.with(ctx, () => original(opts, ...rest));
+    }, import_api14.context.active());
+    const ctx = import_api14.trace.setSpan(import_api14.context.active(), span2);
+    const result = import_api14.context.with(ctx, () => original(opts, ...rest));
     return Promise.resolve(result).then(
       (response) => {
         if (response?.totalTokens != null) span2.setAttribute("neatlogs.llm.token_count.prompt", response.totalTokens);
-        span2.setStatus({ code: import_api12.SpanStatusCode.OK });
+        span2.setStatus({ code: import_api14.SpanStatusCode.OK });
         span2.end();
         return response;
       },
@@ -7678,7 +7822,7 @@ function tracedCountTokens(original) {
 }
 function tracedGenerateContent(original, isStream) {
   return function(opts, ...rest) {
-    const tracer = import_api12.trace.getTracer(TRACER_NAME6);
+    const tracer = getProviderTracer(TRACER_NAME6);
     const model = opts?.model ?? "";
     const span2 = tracer.startSpan("vertex_ai.models.generate_content", {
       attributes: {
@@ -7688,10 +7832,10 @@ function tracedGenerateContent(original, isStream) {
         "neatlogs.llm.model_name": model,
         "neatlogs.llm.is_streaming": isStream
       }
-    }, import_api12.context.active());
+    }, import_api14.context.active());
     setInputAttributes(span2, opts);
-    const ctx = import_api12.trace.setSpan(import_api12.context.active(), span2);
-    const result = import_api12.context.with(ctx, () => original(opts, ...rest));
+    const ctx = import_api14.trace.setSpan(import_api14.context.active(), span2);
+    const result = import_api14.context.with(ctx, () => original(opts, ...rest));
     return Promise.resolve(result).then(
       (response) => {
         if (isStream) {
@@ -7838,7 +7982,7 @@ function finalizeStreamChunks3(span2, chunks) {
   }
   if (finishReason) span2.setAttribute("neatlogs.llm.finish_reason", String(finishReason));
   setUsage(span2, usage);
-  span2.setStatus({ code: import_api12.SpanStatusCode.OK });
+  span2.setStatus({ code: import_api14.SpanStatusCode.OK });
   span2.end();
 }
 function finalizeResponse(span2, response) {
@@ -7864,7 +8008,7 @@ function finalizeResponse(span2, response) {
     span2.setAttribute("neatlogs.llm.output_messages.0.content", textParts.join(""));
   }
   setUsage(span2, response?.usageMetadata);
-  span2.setStatus({ code: import_api12.SpanStatusCode.OK });
+  span2.setStatus({ code: import_api14.SpanStatusCode.OK });
   span2.end();
 }
 function setUsage(span2, usage) {
@@ -7884,21 +8028,21 @@ function safeStringify6(value) {
 }
 function recordError4(span2, err) {
   if (err instanceof Error) {
-    span2.setStatus({ code: import_api12.SpanStatusCode.ERROR, message: err.message });
+    span2.setStatus({ code: import_api14.SpanStatusCode.ERROR, message: err.message });
     span2.recordException(err);
   } else {
-    span2.setStatus({ code: import_api12.SpanStatusCode.ERROR, message: String(err) });
+    span2.setStatus({ code: import_api14.SpanStatusCode.ERROR, message: String(err) });
   }
   span2.end();
 }
 
 // src/bedrock.ts
-var import_api13 = require("@opentelemetry/api");
+var import_api15 = require("@opentelemetry/api");
 var TRACER_NAME7 = "neatlogs.bedrock";
 var PROVIDER3 = "bedrock";
 function traceTool5(name, fn) {
   return async function tracedTool(args) {
-    const tracer = import_api13.trace.getTracer(TRACER_NAME7);
+    const tracer = getProviderTracer(TRACER_NAME7);
     return tracer.startActiveSpan(
       `tool.${name}`,
       {
@@ -7908,12 +8052,12 @@ function traceTool5(name, fn) {
           "input.value": safeStringify7(args)
         }
       },
-      import_api13.context.active(),
+      import_api15.context.active(),
       async (span2) => {
         try {
           const result = await fn(args);
           span2.setAttribute("output.value", safeStringify7(result));
-          span2.setStatus({ code: import_api13.SpanStatusCode.OK });
+          span2.setStatus({ code: import_api15.SpanStatusCode.OK });
           return result;
         } catch (err) {
           recordError5(span2, err);
@@ -7959,7 +8103,7 @@ function vendorFromModel(modelId) {
   return vendor || "bedrock";
 }
 function startSpan(name, modelId, isStream) {
-  return import_api13.trace.getTracer(TRACER_NAME7).startSpan(name, {
+  return getProviderTracer(TRACER_NAME7).startSpan(name, {
     attributes: {
       "neatlogs.span.kind": "LLM",
       "neatlogs.llm.provider": PROVIDER3,
@@ -7967,7 +8111,7 @@ function startSpan(name, modelId, isStream) {
       "neatlogs.llm.model_name": String(modelId ?? ""),
       "neatlogs.llm.is_streaming": isStream
     }
-  }, import_api13.context.active());
+  }, import_api15.context.active());
 }
 function tracedConverse(originalSend, command, input, rest, isStream) {
   const span2 = startSpan(
@@ -7976,8 +8120,8 @@ function tracedConverse(originalSend, command, input, rest, isStream) {
     isStream
   );
   setConverseInput(span2, input);
-  const ctx = import_api13.trace.setSpan(import_api13.context.active(), span2);
-  const promise = import_api13.context.with(ctx, () => originalSend(command, ...rest));
+  const ctx = import_api15.trace.setSpan(import_api15.context.active(), span2);
+  const promise = import_api15.context.with(ctx, () => originalSend(command, ...rest));
   return promise.then(
     (response) => {
       if (isStream) {
@@ -8057,7 +8201,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_api13.SpanStatusCode.OK });
+  span2.setStatus({ code: import_api15.SpanStatusCode.OK });
   span2.end();
 }
 function setConverseUsage(span2, usage) {
@@ -8071,7 +8215,7 @@ function setConverseUsage(span2, usage) {
 function wrapConverseStream(response, span2) {
   const stream = response?.stream;
   if (!stream || typeof stream[Symbol.asyncIterator] !== "function") {
-    span2.setStatus({ code: import_api13.SpanStatusCode.OK });
+    span2.setStatus({ code: import_api15.SpanStatusCode.OK });
     span2.end();
     return response;
   }
@@ -8139,7 +8283,7 @@ function finalizeConverseStream(span2, textParts, toolCalls, finishReason, usage
   }
   if (finishReason) span2.setAttribute("neatlogs.llm.finish_reason", String(finishReason));
   setConverseUsage(span2, usage);
-  span2.setStatus({ code: import_api13.SpanStatusCode.OK });
+  span2.setStatus({ code: import_api15.SpanStatusCode.OK });
   span2.end();
 }
 function isEmbeddingModel(modelId) {
@@ -8151,13 +8295,13 @@ function tracedInvokeModel(originalSend, command, input, rest, isStream) {
   const bodyIn = decodeBody(input?.body);
   let span2;
   if (isEmbedding) {
-    span2 = import_api13.trace.getTracer(TRACER_NAME7).startSpan("bedrock.invoke_model", {
+    span2 = getProviderTracer(TRACER_NAME7).startSpan("bedrock.invoke_model", {
       attributes: {
         "neatlogs.span.kind": "EMBEDDING",
         "neatlogs.llm.provider": PROVIDER3,
         "neatlogs.embedding.model_name": String(input?.modelId ?? "")
       }
-    }, import_api13.context.active());
+    }, import_api15.context.active());
     const text = bodyIn?.inputText ?? bodyIn?.texts ?? bodyIn?.input_text;
     if (text) {
       span2.setAttribute("neatlogs.embedding.text", typeof text === "string" ? text : safeStringify7(text));
@@ -8170,8 +8314,8 @@ function tracedInvokeModel(originalSend, command, input, rest, isStream) {
     );
     setInvokeInput(span2, vendor, bodyIn);
   }
-  const ctx = import_api13.trace.setSpan(import_api13.context.active(), span2);
-  const promise = import_api13.context.with(ctx, () => originalSend(command, ...rest));
+  const ctx = import_api15.trace.setSpan(import_api15.context.active(), span2);
+  const promise = import_api15.context.with(ctx, () => originalSend(command, ...rest));
   return promise.then(
     (response) => {
       if (isStream) {
@@ -8184,7 +8328,7 @@ function tracedInvokeModel(originalSend, command, input, rest, isStream) {
           finalizeInvoke(span2, vendor, decodeBody(response?.body));
         }
       } catch {
-        span2.setStatus({ code: import_api13.SpanStatusCode.OK });
+        span2.setStatus({ code: import_api15.SpanStatusCode.OK });
         span2.end();
       }
       return response;
@@ -8209,7 +8353,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_api13.SpanStatusCode.OK });
+  span2.setStatus({ code: import_api15.SpanStatusCode.OK });
   span2.end();
 }
 function decodeBody(body) {
@@ -8317,13 +8461,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_api13.SpanStatusCode.OK });
+  span2.setStatus({ code: import_api15.SpanStatusCode.OK });
   span2.end();
 }
 function wrapInvokeStream(response, span2, vendor) {
   const body = response?.body;
   if (!body || typeof body[Symbol.asyncIterator] !== "function") {
-    span2.setStatus({ code: import_api13.SpanStatusCode.OK });
+    span2.setStatus({ code: import_api15.SpanStatusCode.OK });
     span2.end();
     return response;
   }
@@ -8341,7 +8485,7 @@ function wrapInvokeStream(response, span2, vendor) {
     if (promptTokens != null) span2.setAttribute("neatlogs.llm.token_count.prompt", promptTokens);
     if (completionTokens != null) span2.setAttribute("neatlogs.llm.token_count.completion", completionTokens);
     if (finishReason) span2.setAttribute("neatlogs.llm.finish_reason", String(finishReason));
-    span2.setStatus({ code: import_api13.SpanStatusCode.OK });
+    span2.setStatus({ code: import_api15.SpanStatusCode.OK });
     span2.end();
   };
   const wrappedBody = {
@@ -8394,16 +8538,16 @@ function safeStringify7(value) {
 }
 function recordError5(span2, err) {
   if (err instanceof Error) {
-    span2.setStatus({ code: import_api13.SpanStatusCode.ERROR, message: err.message });
+    span2.setStatus({ code: import_api15.SpanStatusCode.ERROR, message: err.message });
     span2.recordException(err);
   } else {
-    span2.setStatus({ code: import_api13.SpanStatusCode.ERROR, message: String(err) });
+    span2.setStatus({ code: import_api15.SpanStatusCode.ERROR, message: String(err) });
   }
   span2.end();
 }
 
 // src/langchain.ts
-var import_api14 = require("@opentelemetry/api");
+var import_api16 = require("@opentelemetry/api");
 var TRACER_NAME8 = "neatlogs.langchain";
 function langchainHandler(opts) {
   return new NeatlogsCallbackHandler(opts);
@@ -8411,16 +8555,42 @@ function langchainHandler(opts) {
 var NeatlogsCallbackHandler = class {
   name = "neatlogs";
   _spans = /* @__PURE__ */ new Map();
+  // Auto-root spans keyed by the run-id of the child that triggered them.
+  _autoRoots = /* @__PURE__ */ new Map();
   _workflowName;
   constructor(opts) {
     this._workflowName = opts?.workflowName;
   }
+  // --- Self-rooting ----------------------------------------------------------
+  //
+  // A LangChain run can begin with ANY callback. When it begins with a non-root
+  // kind (a bare `llm.invoke()` fires handleChatModelStart/handleLLMStart with no
+  // chain above it; a standalone tool/retriever similarly), the span we create is
+  // parentless and non-root -> the backend can't anchor the trace and it never
+  // renders. Open a WORKFLOW root transparently in that case so just adding the
+  // handler yields a complete trace. A top-level CHAIN is already root-eligible.
+  _startCtx(parentRunId, runId, kind) {
+    const parentSpan = parentRunId ? this._spans.get(parentRunId) : void 0;
+    if (parentSpan) {
+      return import_api16.trace.setSpan(import_api16.context.active(), parentSpan);
+    }
+    const tracer = import_api16.trace.getTracer(TRACER_NAME8);
+    const { root, ctx } = maybeOpenAutoRoot(tracer, kind, import_api16.context.active());
+    if (root) this._autoRoots.set(runId, root);
+    return ctx;
+  }
+  _endAutoRoot(runId) {
+    const root = this._autoRoots.get(runId);
+    if (root) {
+      endAutoRoot(root);
+      this._autoRoots.delete(runId);
+    }
+  }
   // --- Chain/Graph callbacks ---
   async handleChainStart(serialized, inputs, runId, parentRunId, tags, metadata) {
-    const tracer = import_api14.trace.getTracer(TRACER_NAME8);
+    const tracer = import_api16.trace.getTracer(TRACER_NAME8);
     const name = serialized?.name ?? serialized?.id?.at(-1) ?? "chain";
-    const parentSpan = parentRunId ? this._spans.get(parentRunId) : void 0;
-    const parentCtx = parentSpan ? import_api14.trace.setSpan(import_api14.context.active(), parentSpan) : import_api14.context.active();
+    const parentCtx = this._startCtx(parentRunId, runId, "chain");
     const attrs = {
       "neatlogs.span.kind": "CHAIN",
       "neatlogs.chain.name": name
@@ -8435,24 +8605,25 @@ var NeatlogsCallbackHandler = class {
     const span2 = this._spans.get(runId);
     if (!span2) return;
     if (outputs) span2.setAttribute("output.value", safeStringify8(outputs));
-    span2.setStatus({ code: import_api14.SpanStatusCode.OK });
+    span2.setStatus({ code: import_api16.SpanStatusCode.OK });
     span2.end();
     this._spans.delete(runId);
+    this._endAutoRoot(runId);
   }
   async handleChainError(error, runId) {
     const span2 = this._spans.get(runId);
     if (!span2) return;
-    span2.setStatus({ code: import_api14.SpanStatusCode.ERROR, message: error.message });
+    span2.setStatus({ code: import_api16.SpanStatusCode.ERROR, message: error.message });
     span2.recordException(error);
     span2.end();
     this._spans.delete(runId);
+    this._endAutoRoot(runId);
   }
   // --- LLM callbacks ---
   async handleLLMStart(serialized, prompts, runId, parentRunId, extraParams) {
-    const tracer = import_api14.trace.getTracer(TRACER_NAME8);
+    const tracer = import_api16.trace.getTracer(TRACER_NAME8);
     const model = serialized?.kwargs?.model_name ?? serialized?.kwargs?.model ?? serialized?.name ?? "";
-    const parentSpan = parentRunId ? this._spans.get(parentRunId) : void 0;
-    const parentCtx = parentSpan ? import_api14.trace.setSpan(import_api14.context.active(), parentSpan) : import_api14.context.active();
+    const parentCtx = this._startCtx(parentRunId, runId, "llm");
     const attrs = {
       "neatlogs.span.kind": "LLM",
       "neatlogs.llm.provider": detectProvider(model),
@@ -8472,10 +8643,9 @@ var NeatlogsCallbackHandler = class {
     this._spans.set(runId, span2);
   }
   async handleChatModelStart(serialized, messages, runId, parentRunId, extraParams) {
-    const tracer = import_api14.trace.getTracer(TRACER_NAME8);
+    const tracer = import_api16.trace.getTracer(TRACER_NAME8);
     const model = serialized?.kwargs?.model_name ?? serialized?.kwargs?.model ?? serialized?.name ?? "";
-    const parentSpan = parentRunId ? this._spans.get(parentRunId) : void 0;
-    const parentCtx = parentSpan ? import_api14.trace.setSpan(import_api14.context.active(), parentSpan) : import_api14.context.active();
+    const parentCtx = this._startCtx(parentRunId, runId, "llm");
     const attrs = {
       "neatlogs.span.kind": "LLM",
       "neatlogs.llm.provider": detectProvider(model),
@@ -8533,26 +8703,27 @@ var NeatlogsCallbackHandler = class {
         span2.setAttribute("neatlogs.llm.token_count.total", usage.totalTokens ?? usage.total_tokens);
       }
     }
-    span2.setStatus({ code: import_api14.SpanStatusCode.OK });
+    span2.setStatus({ code: import_api16.SpanStatusCode.OK });
     span2.end();
     this._spans.delete(runId);
+    this._endAutoRoot(runId);
   }
   async handleLLMNewToken(_token, _idx, _runId) {
   }
   async handleLLMError(error, runId) {
     const span2 = this._spans.get(runId);
     if (!span2) return;
-    span2.setStatus({ code: import_api14.SpanStatusCode.ERROR, message: error.message });
+    span2.setStatus({ code: import_api16.SpanStatusCode.ERROR, message: error.message });
     span2.recordException(error);
     span2.end();
     this._spans.delete(runId);
+    this._endAutoRoot(runId);
   }
   // --- Tool callbacks ---
   async handleToolStart(serialized, input, runId, parentRunId, _tags, _metadata, runName, toolCallId) {
-    const tracer = import_api14.trace.getTracer(TRACER_NAME8);
+    const tracer = import_api16.trace.getTracer(TRACER_NAME8);
     const name = serialized?.name || runName || (Array.isArray(serialized?.id) ? serialized.id[serialized.id.length - 1] : void 0) || "tool";
-    const parentSpan = parentRunId ? this._spans.get(parentRunId) : void 0;
-    const parentCtx = parentSpan ? import_api14.trace.setSpan(import_api14.context.active(), parentSpan) : import_api14.context.active();
+    const parentCtx = this._startCtx(parentRunId, runId, "tool");
     const attrs = {
       "neatlogs.span.kind": "TOOL",
       "neatlogs.tool.name": name,
@@ -8566,24 +8737,25 @@ var NeatlogsCallbackHandler = class {
     const span2 = this._spans.get(runId);
     if (!span2) return;
     span2.setAttribute("output.value", String(output));
-    span2.setStatus({ code: import_api14.SpanStatusCode.OK });
+    span2.setStatus({ code: import_api16.SpanStatusCode.OK });
     span2.end();
     this._spans.delete(runId);
+    this._endAutoRoot(runId);
   }
   async handleToolError(error, runId) {
     const span2 = this._spans.get(runId);
     if (!span2) return;
-    span2.setStatus({ code: import_api14.SpanStatusCode.ERROR, message: error.message });
+    span2.setStatus({ code: import_api16.SpanStatusCode.ERROR, message: error.message });
     span2.recordException(error);
     span2.end();
     this._spans.delete(runId);
+    this._endAutoRoot(runId);
   }
   // --- Retriever callbacks ---
   async handleRetrieverStart(serialized, query, runId, parentRunId) {
-    const tracer = import_api14.trace.getTracer(TRACER_NAME8);
+    const tracer = import_api16.trace.getTracer(TRACER_NAME8);
     const name = serialized?.name ?? "retriever";
-    const parentSpan = parentRunId ? this._spans.get(parentRunId) : void 0;
-    const parentCtx = parentSpan ? import_api14.trace.setSpan(import_api14.context.active(), parentSpan) : import_api14.context.active();
+    const parentCtx = this._startCtx(parentRunId, runId, "retriever");
     const attrs = {
       "neatlogs.span.kind": "RETRIEVER",
       "neatlogs.retriever.name": name,
@@ -8604,17 +8776,19 @@ var NeatlogsCallbackHandler = class {
         }
       }
     }
-    span2.setStatus({ code: import_api14.SpanStatusCode.OK });
+    span2.setStatus({ code: import_api16.SpanStatusCode.OK });
     span2.end();
     this._spans.delete(runId);
+    this._endAutoRoot(runId);
   }
   async handleRetrieverError(error, runId) {
     const span2 = this._spans.get(runId);
     if (!span2) return;
-    span2.setStatus({ code: import_api14.SpanStatusCode.ERROR, message: error.message });
+    span2.setStatus({ code: import_api16.SpanStatusCode.ERROR, message: error.message });
     span2.recordException(error);
     span2.end();
     this._spans.delete(runId);
+    this._endAutoRoot(runId);
   }
 };
 function detectProvider(model) {
@@ -8783,7 +8957,7 @@ function safeStringify9(value) {
 }
 
 // src/openai-agents.ts
-var import_api15 = require("@opentelemetry/api");
+var import_api17 = require("@opentelemetry/api");
 var TRACER_NAME9 = "neatlogs.openai_agents";
 function openaiAgentsProcessor() {
   return new NeatlogsTraceProcessor();
@@ -8793,13 +8967,13 @@ var NeatlogsTraceProcessor = class {
   _startTimes = /* @__PURE__ */ new Map();
   // The @openai/agents SDK passes a Trace object: { traceId, name, groupId, metadata }.
   onTraceStart(traceData) {
-    const tracer = import_api15.trace.getTracer(TRACER_NAME9);
+    const tracer = import_api17.trace.getTracer(TRACER_NAME9);
     const attrs = { "neatlogs.span.kind": "WORKFLOW" };
     const workflowName = traceData?.name ?? traceData?.workflow_name;
     if (workflowName) attrs["neatlogs.workflow.name"] = workflowName;
     const traceId = traceData?.traceId ?? traceData?.trace_id;
     if (traceId) attrs["neatlogs.agent.trace_id"] = String(traceId);
-    const span2 = tracer.startSpan("openai_agents.trace", { attributes: attrs }, import_api15.context.active());
+    const span2 = tracer.startSpan("openai_agents.trace", { attributes: attrs }, import_api17.context.active());
     const key = String(traceId ?? `trace_${Date.now()}`);
     this._spans.set(key, span2);
     this._startTimes.set(key, Date.now());
@@ -8812,7 +8986,7 @@ var NeatlogsTraceProcessor = class {
     if (startTime) {
       span2.setAttribute("neatlogs.metrics.duration_ms", Date.now() - startTime);
     }
-    span2.setStatus({ code: import_api15.SpanStatusCode.OK });
+    span2.setStatus({ code: import_api17.SpanStatusCode.OK });
     span2.end();
     this._spans.delete(key);
     this._startTimes.delete(key);
@@ -8820,13 +8994,13 @@ var NeatlogsTraceProcessor = class {
   // The SDK passes a Span object: { type, spanId, traceId, parentId?, spanData: {...} }.
   // The meaningful payload (type, name, input, output, usage, ...) lives in `spanData`.
   onSpanStart(span2) {
-    const tracer = import_api15.trace.getTracer(TRACER_NAME9);
+    const tracer = import_api17.trace.getTracer(TRACER_NAME9);
     const data = span2?.spanData ?? span2 ?? {};
     const spanType = data?.type ?? data?.span_type ?? span2?.type ?? "";
     const spanId = String(span2?.spanId ?? span2?.span_id ?? data?.span_id ?? `span_${Date.now()}`);
     const parentKey = String(span2?.parentId ?? span2?.traceId ?? span2?.trace_id ?? "");
     const parentSpan = this._spans.get(parentKey);
-    const parentCtx = parentSpan ? import_api15.trace.setSpan(import_api15.context.active(), parentSpan) : import_api15.context.active();
+    const parentCtx = parentSpan ? import_api17.trace.setSpan(import_api17.context.active(), parentSpan) : import_api17.context.active();
     let otelSpan;
     if (spanType === "agent" || spanType === "agent_run") {
       const agentName = data?.name ?? data?.agent_name ?? "agent";
@@ -8935,13 +9109,13 @@ var NeatlogsTraceProcessor = class {
     const error = data?.error ?? span2?.error;
     if (error) {
       if (error instanceof Error) {
-        otelSpan.setStatus({ code: import_api15.SpanStatusCode.ERROR, message: error.message });
+        otelSpan.setStatus({ code: import_api17.SpanStatusCode.ERROR, message: error.message });
         otelSpan.recordException(error);
       } else {
-        otelSpan.setStatus({ code: import_api15.SpanStatusCode.ERROR, message: String(error) });
+        otelSpan.setStatus({ code: import_api17.SpanStatusCode.ERROR, message: String(error) });
       }
     } else {
-      otelSpan.setStatus({ code: import_api15.SpanStatusCode.OK });
+      otelSpan.setStatus({ code: import_api17.SpanStatusCode.OK });
     }
     if (startTime) {
       otelSpan.setAttribute("neatlogs.llm.metrics.duration_ms", Date.now() - startTime);
@@ -8952,7 +9126,7 @@ var NeatlogsTraceProcessor = class {
   }
   shutdown() {
     for (const [, span2] of this._spans) {
-      span2.setStatus({ code: import_api15.SpanStatusCode.ERROR, message: "Processor shutdown before span completed" });
+      span2.setStatus({ code: import_api17.SpanStatusCode.ERROR, message: "Processor shutdown before span completed" });
       span2.end();
     }
     this._spans.clear();
@@ -8970,7 +9144,7 @@ function safeStringify10(value) {
 }
 
 // src/mastra-wrap.ts
-var import_api16 = require("@opentelemetry/api");
+var import_api18 = require("@opentelemetry/api");
 var TRACER_NAME10 = "neatlogs.mastra";
 var PATCH_FLAG2 = "_neatlogs_patched";
 function wrapMastra(entity) {
@@ -9037,11 +9211,11 @@ function patchAgentMethod(agent, method, streaming) {
     }
     if (streaming) attrs["neatlogs.llm.is_streaming"] = true;
     if (streaming) {
-      const tracer = import_api16.trace.getTracer(TRACER_NAME10);
-      const span2 = tracer.startSpan(`mastra.agent.${agentName}`, { attributes: attrs }, import_api16.context.active());
-      const ctx = import_api16.trace.setSpan(import_api16.context.active(), span2);
+      const tracer = import_api18.trace.getTracer(TRACER_NAME10);
+      const span2 = tracer.startSpan(`mastra.agent.${agentName}`, { attributes: attrs }, import_api18.context.active());
+      const ctx = import_api18.trace.setSpan(import_api18.context.active(), span2);
       try {
-        const result = await import_api16.context.with(ctx, () => orig(input, opts));
+        const result = await import_api18.context.with(ctx, () => orig(input, opts));
         return wrapStreamingOutput(result, span2, ctx);
       } catch (err) {
         recordError6(span2, err);
@@ -9245,7 +9419,7 @@ function wrapRootMastra(mastra) {
 }
 function wrapStreamingOutput(output, span2, ctx) {
   if (!output) {
-    span2.setStatus({ code: import_api16.SpanStatusCode.OK });
+    span2.setStatus({ code: import_api18.SpanStatusCode.OK });
     span2.end();
     return output;
   }
@@ -9254,7 +9428,7 @@ function wrapStreamingOutput(output, span2, ctx) {
     if (ended) return;
     ended = true;
     if (err) recordError6(span2, err);
-    else span2.setStatus({ code: import_api16.SpanStatusCode.OK });
+    else span2.setStatus({ code: import_api18.SpanStatusCode.OK });
     span2.end();
   };
   if (output.text && typeof output.text.then === "function") {
@@ -9345,7 +9519,7 @@ function rebindStreamContext(output, ctx) {
         const origIterator = value[Symbol.asyncIterator].bind(value);
         return {
           [Symbol.asyncIterator]() {
-            return import_api16.context.with(ctx, () => origIterator());
+            return import_api18.context.with(ctx, () => origIterator());
           }
         };
       }
@@ -9455,13 +9629,13 @@ function recordUsage(span2, usage) {
   }
 }
 function withActiveSpan(name, attrs, fn) {
-  const tracer = import_api16.trace.getTracer(TRACER_NAME10);
-  const span2 = tracer.startSpan(name, { attributes: attrs }, import_api16.context.active());
-  const ctx = import_api16.trace.setSpan(import_api16.context.active(), span2);
-  return import_api16.context.with(ctx, async () => {
+  const tracer = import_api18.trace.getTracer(TRACER_NAME10);
+  const span2 = tracer.startSpan(name, { attributes: attrs }, import_api18.context.active());
+  const ctx = import_api18.trace.setSpan(import_api18.context.active(), span2);
+  return import_api18.context.with(ctx, async () => {
     try {
       const result = await fn(span2);
-      span2.setStatus({ code: import_api16.SpanStatusCode.OK });
+      span2.setStatus({ code: import_api18.SpanStatusCode.OK });
       return result;
     } catch (err) {
       recordError6(span2, err);
@@ -9496,15 +9670,15 @@ function safeStringify11(value) {
 }
 function recordError6(span2, err) {
   if (err instanceof Error) {
-    span2.setStatus({ code: import_api16.SpanStatusCode.ERROR, message: err.message });
+    span2.setStatus({ code: import_api18.SpanStatusCode.ERROR, message: err.message });
     span2.recordException(err);
   } else {
-    span2.setStatus({ code: import_api16.SpanStatusCode.ERROR, message: String(err) });
+    span2.setStatus({ code: import_api18.SpanStatusCode.ERROR, message: String(err) });
   }
 }
 
 // src/pi-agent.ts
-var import_api17 = require("@opentelemetry/api");
+var import_api19 = require("@opentelemetry/api");
 var TRACER_NAME11 = "neatlogs.pi-agent";
 var PATCH_FLAG3 = "_neatlogs_patched";
 function piAgentHooks(agent) {
@@ -9512,7 +9686,7 @@ function piAgentHooks(agent) {
   const a = agent;
   if (typeof a.subscribe !== "function") return agent;
   const state = { toolSpans: /* @__PURE__ */ new Map(), inputMessages: [] };
-  const tracer = import_api17.trace.getTracer(TRACER_NAME11);
+  const tracer = import_api19.trace.getTracer(TRACER_NAME11);
   a.subscribe((event) => {
     try {
       handleEvent(tracer, state, event);
@@ -9528,10 +9702,10 @@ function handleEvent(tracer, state, event) {
       const span2 = tracer.startSpan(
         "pi_agent.run",
         { attributes: { "neatlogs.span.kind": "AGENT" } },
-        import_api17.context.active()
+        import_api19.context.active()
       );
       state.agentSpan = span2;
-      state.agentCtx = import_api17.trace.setSpan(import_api17.context.active(), span2);
+      state.agentCtx = import_api19.trace.setSpan(import_api19.context.active(), span2);
       state.inputMessages = [];
       break;
     }
@@ -9550,7 +9724,7 @@ function handleEvent(tracer, state, event) {
       break;
     }
     case "tool_execution_start": {
-      const parent = state.agentCtx ?? import_api17.context.active();
+      const parent = state.agentCtx ?? import_api19.context.active();
       const span2 = tracer.startSpan(
         `pi_agent.tool.${event.toolName ?? "tool"}`,
         {
@@ -9572,10 +9746,10 @@ function handleEvent(tracer, state, event) {
         span2.setAttribute("output.value", safeStringify12(event.result));
       }
       if (event.isError) {
-        span2.setStatus({ code: import_api17.SpanStatusCode.ERROR });
+        span2.setStatus({ code: import_api19.SpanStatusCode.ERROR });
         span2.setAttribute("neatlogs.tool.is_error", true);
       } else {
-        span2.setStatus({ code: import_api17.SpanStatusCode.OK });
+        span2.setStatus({ code: import_api19.SpanStatusCode.OK });
       }
       span2.end();
       if (event.toolCallId) state.toolSpans.delete(event.toolCallId);
@@ -9594,7 +9768,7 @@ function handleEvent(tracer, state, event) {
         if (firstUser) state.agentSpan.setAttribute("input.value", firstUser.content);
         const finalText = lastAssistantText(event.messages);
         if (finalText) state.agentSpan.setAttribute("output.value", finalText);
-        state.agentSpan.setStatus({ code: import_api17.SpanStatusCode.OK });
+        state.agentSpan.setStatus({ code: import_api19.SpanStatusCode.OK });
         state.agentSpan.end();
         state.agentSpan = void 0;
         state.agentCtx = void 0;
@@ -9646,13 +9820,13 @@ function emitLlmSpan(tracer, state, msg) {
     if (usage.cacheRead) attrs["neatlogs.llm.token_count.cache_read"] = usage.cacheRead;
     if (usage.cacheWrite) attrs["neatlogs.llm.token_count.cache_write"] = usage.cacheWrite;
   }
-  const parent = state.agentCtx ?? import_api17.context.active();
+  const parent = state.agentCtx ?? import_api19.context.active();
   const span2 = tracer.startSpan(
     `pi_agent.llm.${msg.model || "model"}`,
     { attributes: attrs },
     parent
   );
-  span2.setStatus({ code: import_api17.SpanStatusCode.OK });
+  span2.setStatus({ code: import_api19.SpanStatusCode.OK });
   span2.end();
 }
 function splitAssistantContent(content) {
@@ -9713,7 +9887,7 @@ function safeStringify12(value) {
 }
 
 // src/claude-agent-sdk.ts
-var import_api18 = require("@opentelemetry/api");
+var import_api20 = require("@opentelemetry/api");
 var TRACER_NAME12 = "neatlogs.claude_agent_sdk";
 var ROOT_SCOPE = "__root__";
 function wrapClaudeAgentSDK(sdk, options = {}) {
@@ -9734,13 +9908,13 @@ function wrapClaudeAgentSDK(sdk, options = {}) {
 }
 function wrapQuery(original, options) {
   return function(params, ...rest) {
-    const tracer = import_api18.trace.getTracer(TRACER_NAME12);
+    const tracer = import_api20.trace.getTracer(TRACER_NAME12);
     const workflowName = options.workflowName ?? "claude_agent.query";
     const promptRef = { text: "" };
     const agentSpan = tracer.startSpan(
       "claude_agent.query",
       { attributes: { "neatlogs.span.kind": "AGENT", "neatlogs.workflow.name": workflowName } },
-      import_api18.context.active()
+      import_api20.context.active()
     );
     const promptText = extractPromptText(params?.prompt);
     if (promptText) {
@@ -9749,8 +9923,8 @@ function wrapQuery(original, options) {
     } else if (params && isAsyncIterable(params.prompt)) {
       params = { ...params, prompt: tapPromptStream(params.prompt, promptRef) };
     }
-    const agentCtx = import_api18.trace.setSpan(import_api18.context.active(), agentSpan);
-    const queryObj = import_api18.context.with(agentCtx, () => original(params, ...rest));
+    const agentCtx = import_api20.trace.setSpan(import_api20.context.active(), agentSpan);
+    const queryObj = import_api20.context.with(agentCtx, () => original(params, ...rest));
     return instrumentQueryIterable(queryObj, agentSpan, agentCtx, tracer, promptRef);
   };
 }
@@ -9769,7 +9943,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_api18.SpanStatusCode.OK });
+    agentSpan.setStatus({ code: import_api20.SpanStatusCode.OK });
     agentSpan.end();
     return queryObj;
   }
@@ -9806,7 +9980,7 @@ function instrumentQueryIterable(queryObj, agentSpan, agentCtx, tracer, promptRe
     if (status === "error") {
       recordError7(agentSpan, err);
     } else {
-      agentSpan.setStatus({ code: import_api18.SpanStatusCode.OK });
+      agentSpan.setStatus({ code: import_api20.SpanStatusCode.OK });
       agentSpan.end();
     }
   };
@@ -9817,7 +9991,7 @@ function instrumentQueryIterable(queryObj, agentSpan, agentCtx, tracer, promptRe
     return {
       async next() {
         try {
-          const result = await import_api18.context.with(agentCtx, () => iterator.next());
+          const result = await import_api20.context.with(agentCtx, () => iterator.next());
           if (result.done) {
             finalizeAgent("ok");
             return result;
@@ -9848,7 +10022,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_api18.SpanStatusCode.OK : import_api18.SpanStatusCode.ERROR });
+    scope.span.setStatus({ code: status === "ok" ? import_api20.SpanStatusCode.OK : import_api20.SpanStatusCode.ERROR });
     scope.span.end();
   } catch {
   }
@@ -9863,7 +10037,7 @@ function getScope(tracer, state, msg) {
     flushAssistantTurn(tracer, root, state);
   }
   const parentToolSpan = state.toolSpans.get(parentId);
-  const parentCtx = parentToolSpan ? import_api18.trace.setSpan(import_api18.context.active(), parentToolSpan) : state.scopes.get(ROOT_SCOPE).ctx;
+  const parentCtx = parentToolSpan ? import_api20.trace.setSpan(import_api20.context.active(), parentToolSpan) : state.scopes.get(ROOT_SCOPE).ctx;
   const subType = msg?.subagent_type ? String(msg.subagent_type) : "subagent";
   const attrs = {
     "neatlogs.span.kind": "AGENT",
@@ -9873,7 +10047,7 @@ function getScope(tracer, state, msg) {
   const span2 = tracer.startSpan(`claude_agent.subagent.${subType}`, { attributes: attrs }, parentCtx);
   const scope = {
     span: span2,
-    ctx: import_api18.trace.setSpan(import_api18.context.active(), span2),
+    ctx: import_api20.trace.setSpan(import_api20.context.active(), span2),
     inputMessages: msg?.task_description ? [{ role: "user", content: String(msg.task_description) }] : [],
     assistantBuffer: null,
     finalText: "",
@@ -9997,7 +10171,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) setUsage2(span2, buf.usage);
-  span2.setStatus({ code: import_api18.SpanStatusCode.OK });
+  span2.setStatus({ code: import_api20.SpanStatusCode.OK });
   span2.end();
   if (outText) scope.finalText = outText;
   const turnParts = [];
@@ -10032,10 +10206,10 @@ function closeToolSpansFromUser(state, scope, msg) {
     if (!span2) continue;
     span2.setAttribute("output.value", outText);
     if (block.is_error) {
-      span2.setStatus({ code: import_api18.SpanStatusCode.ERROR });
+      span2.setStatus({ code: import_api20.SpanStatusCode.ERROR });
       span2.setAttribute("neatlogs.tool.is_error", true);
     } else {
-      span2.setStatus({ code: import_api18.SpanStatusCode.OK });
+      span2.setStatus({ code: import_api20.SpanStatusCode.OK });
     }
     span2.end();
     state.toolSpans.delete(id);
@@ -10082,16 +10256,16 @@ function safeStringify13(value) {
 }
 function recordError7(span2, err) {
   if (err instanceof Error) {
-    span2.setStatus({ code: import_api18.SpanStatusCode.ERROR, message: err.message });
+    span2.setStatus({ code: import_api20.SpanStatusCode.ERROR, message: err.message });
     span2.recordException(err);
   } else {
-    span2.setStatus({ code: import_api18.SpanStatusCode.ERROR, message: String(err) });
+    span2.setStatus({ code: import_api20.SpanStatusCode.ERROR, message: String(err) });
   }
   span2.end();
 }
 
 // src/openrouter-agent.ts
-var import_api19 = require("@opentelemetry/api");
+var import_api21 = require("@opentelemetry/api");
 var TRACER_NAME13 = "neatlogs.openrouter_agent";
 var PROVIDER4 = "openrouter";
 function wrapOpenRouterAgent(client) {
@@ -10110,21 +10284,21 @@ function wrapOpenRouterAgent(client) {
 function wrapCallModel(callModel) {
   return function(clientArg, opts, ...rest) {
     const span2 = startLlmSpan(opts);
-    const ctx = import_api19.trace.setSpan(import_api19.context.active(), span2);
-    const result = import_api19.context.with(ctx, () => callModel.call(this, clientArg, opts, ...rest));
+    const ctx = import_api21.trace.setSpan(import_api21.context.active(), span2);
+    const result = import_api21.context.with(ctx, () => callModel.call(this, clientArg, opts, ...rest));
     return instrumentModelResult(result, span2);
   };
 }
 function tracedCallModel(original) {
   return function(opts, ...rest) {
     const span2 = startLlmSpan(opts);
-    const ctx = import_api19.trace.setSpan(import_api19.context.active(), span2);
-    const result = import_api19.context.with(ctx, () => original(opts, ...rest));
+    const ctx = import_api21.trace.setSpan(import_api21.context.active(), span2);
+    const result = import_api21.context.with(ctx, () => original(opts, ...rest));
     return instrumentModelResult(result, span2);
   };
 }
 function startLlmSpan(opts) {
-  const tracer = import_api19.trace.getTracer(TRACER_NAME13);
+  const tracer = getProviderTracer(TRACER_NAME13);
   const model = opts?.model ?? "";
   const span2 = tracer.startSpan("openrouter.call_model", {
     attributes: {
@@ -10133,7 +10307,7 @@ function startLlmSpan(opts) {
       "neatlogs.llm.system": PROVIDER4,
       "neatlogs.llm.model_name": model
     }
-  }, import_api19.context.active());
+  }, import_api21.context.active());
   const messages = Array.isArray(opts?.messages) ? opts.messages : Array.isArray(opts?.input) ? opts.input : [];
   if (messages.length) {
     messages.forEach((msg, i) => {
@@ -10185,7 +10359,7 @@ function startLlmSpan(opts) {
 }
 function instrumentModelResult(result, span2) {
   if (!result || typeof result !== "object" && typeof result !== "function") {
-    span2.setStatus({ code: import_api19.SpanStatusCode.OK });
+    span2.setStatus({ code: import_api21.SpanStatusCode.OK });
     span2.end();
     return result;
   }
@@ -10196,7 +10370,7 @@ function instrumentModelResult(result, span2) {
     try {
       finalizeLlm(span2, resolved);
     } catch {
-      span2.setStatus({ code: import_api19.SpanStatusCode.OK });
+      span2.setStatus({ code: import_api21.SpanStatusCode.OK });
       span2.end();
     }
   };
@@ -10299,7 +10473,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_api19.SpanStatusCode.OK });
+  span2.setStatus({ code: import_api21.SpanStatusCode.OK });
   span2.end();
 }
 function extractOpenResponsesText(result) {
@@ -10325,10 +10499,10 @@ function safeStringify14(value) {
 }
 function recordError8(span2, err) {
   if (err instanceof Error) {
-    span2.setStatus({ code: import_api19.SpanStatusCode.ERROR, message: err.message });
+    span2.setStatus({ code: import_api21.SpanStatusCode.ERROR, message: err.message });
     span2.recordException(err);
   } else {
-    span2.setStatus({ code: import_api19.SpanStatusCode.ERROR, message: String(err) });
+    span2.setStatus({ code: import_api21.SpanStatusCode.ERROR, message: String(err) });
   }
   span2.end();
 }
@@ -10966,7 +11140,7 @@ function safeStringify15(value) {
 }
 
 // src/core/llm-binder.ts
-var logger15 = getLogger();
+var logger16 = getLogger();
 function bindTemplates(llm, systemTpl, userTpl, compiledVars) {
   const systemStr = String(systemTpl.template);
   const userStr = userTpl ? String(userTpl.template) : null;
@@ -10978,7 +11152,7 @@ function bindTemplates(llm, systemTpl, userTpl, compiledVars) {
       llmCopy = structuredClone(llm);
     } catch {
       llmCopy = llm;
-      logger15.debug(
+      logger16.debug(
         `LLM type ${llm?.constructor?.name ?? "unknown"} is not copyable \u2014 binding in place.`
       );
     }
@@ -10989,7 +11163,7 @@ function bindTemplates(llm, systemTpl, userTpl, compiledVars) {
   } else if (typeof llmCopy.call === "function") {
     methodName = "call";
   } else {
-    logger15.warn(
+    logger16.warn(
       `LLM type ${llm?.constructor?.name ?? "unknown"} has neither invoke() nor call() \u2014 prompt templates will not be captured on spans.`
     );
     return llmCopy;
@@ -11009,7 +11183,7 @@ function bindTemplates(llm, systemTpl, userTpl, compiledVars) {
       }
     }
   };
-  logger15.debug(
+  logger16.debug(
     `Wrapped ${llm?.constructor?.name ?? "unknown"}.${methodName}() with template injection.`
   );
   return llmCopy;