neatlogs 1.0.8 → 1.0.10

package/dist/index.cjs

@@ -5899,7 +5899,7 @@ async function removeTag(name, tag) {
 }
 
 // src/version.ts
-var __version__ = "1.0.8";
+var __version__ = "1.0.10";
 
 // src/init.ts
 var logger13 = getLogger();
@@ -6532,14 +6532,108 @@ function recordSpanError(span2, err) {
 }
 
 // src/openai.ts
+var import_api10 = require("@opentelemetry/api");
+
+// src/core/auto-root.ts
 var import_api9 = 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_api9.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_api9.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_api9.context.active();
+    const parent = import_api9.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_api9.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_api9.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_api10.trace.getTracer(TRACER_NAME3);
     return tracer.startActiveSpan(
       `tool.${name}`,
       {
@@ -6549,12 +6643,12 @@ function traceTool(name, fn) {
           "input.value": safeStringify3(args)
         }
       },
-      import_api9.context.active(),
+      import_api10.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_api10.SpanStatusCode.OK });
           return result;
         } catch (err) {
           recordError(span2, err);
@@ -6593,7 +6687,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 +6699,7 @@ function tracedChatCompletionsCreate(original) {
         "neatlogs.llm.model_name": model,
         "neatlogs.llm.is_streaming": isStream
       }
-    }, import_api9.context.active());
+    }, import_api10.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 +6728,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_api10.trace.setSpan(import_api10.context.active(), span2);
+    const promise = import_api10.context.with(ctx, () => original(opts, ...rest));
     return promise.then(
       (response) => {
         if (isStream) {
@@ -6653,7 +6747,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 +6757,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_api10.context.active());
+    const ctx = import_api10.trace.setSpan(import_api10.context.active(), span2);
+    const promise = import_api10.context.with(ctx, () => original(opts, ...rest));
     return promise.then(
       (response) => {
         if (response?.output_text) {
@@ -6677,7 +6771,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_api10.SpanStatusCode.OK });
         span2.end();
         return response;
       },
@@ -6692,7 +6786,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_api10.SpanStatusCode.OK });
     span2.end();
     return stream;
   }
@@ -6778,7 +6872,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_api10.SpanStatusCode.OK });
   span2.end();
 }
 function finalizeChatResponse(span2, response) {
@@ -6815,7 +6909,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_api10.SpanStatusCode.OK });
   span2.end();
 }
 function setInvocationParams(span2, opts) {
@@ -6835,23 +6929,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_api10.SpanStatusCode.ERROR, message: err.message });
     span2.recordException(err);
   } else {
-    span2.setStatus({ code: import_api9.SpanStatusCode.ERROR, message: String(err) });
+    span2.setStatus({ code: import_api10.SpanStatusCode.ERROR, message: String(err) });
   }
   span2.end();
 }
 
 // src/anthropic.ts
-var import_api10 = require("@opentelemetry/api");
+var import_api11 = 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 +6955,12 @@ function traceTool2(name, fn) {
           "input.value": safeStringify4(input)
         }
       },
-      import_api10.context.active(),
+      import_api11.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_api11.SpanStatusCode.OK });
           return result;
         } catch (err) {
           recordError2(span2, err);
@@ -6905,7 +6999,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 +7011,12 @@ function tracedMessagesCreate(original) {
         "neatlogs.llm.model_name": model,
         "neatlogs.llm.is_streaming": isStream
       }
-    }, import_api10.context.active());
+    }, import_api11.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_api11.trace.setSpan(import_api11.context.active(), span2);
+    const promise = import_api11.context.with(ctx, () => original(opts, ...rest));
     return promise.then(
       (response) => {
         if (isStream) {
@@ -6940,7 +7034,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 +7045,12 @@ function tracedMessagesStream(original) {
         "neatlogs.llm.model_name": model,
         "neatlogs.llm.is_streaming": true
       }
-    }, import_api10.context.active());
+    }, import_api11.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_api11.trace.setSpan(import_api11.context.active(), span2);
+    const messageStream = import_api11.context.with(ctx, () => original(opts, ...rest));
     return wrapMessageStream(messageStream, span2);
   };
 }
@@ -6964,7 +7058,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_api11.SpanStatusCode.OK });
     span2.end();
     return stream;
   }
@@ -7013,7 +7107,7 @@ function wrapMessageStream(messageStream, span2) {
       if (finalMsg) {
         finalizeMessageResponse(span2, finalMsg);
       } else {
-        span2.setStatus({ code: import_api10.SpanStatusCode.OK });
+        span2.setStatus({ code: import_api11.SpanStatusCode.OK });
         span2.end();
       }
     });
@@ -7091,7 +7185,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_api11.SpanStatusCode.OK });
   span2.end();
 }
 function finalizeMessageResponse(span2, response) {
@@ -7125,7 +7219,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_api11.SpanStatusCode.OK });
   span2.end();
 }
 function setInputMessages(span2, system, messages) {
@@ -7178,16 +7272,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_api11.SpanStatusCode.ERROR, message: err.message });
     span2.recordException(err);
   } else {
-    span2.setStatus({ code: import_api10.SpanStatusCode.ERROR, message: String(err) });
+    span2.setStatus({ code: import_api11.SpanStatusCode.ERROR, message: String(err) });
   }
   span2.end();
 }
 
 // src/azure-openai.ts
-var import_api11 = require("@opentelemetry/api");
+var import_api12 = require("@opentelemetry/api");
 var TRACER_NAME5 = "neatlogs.azure_openai";
 var PROVIDER = "azure";
 var SYSTEM = "azure";
@@ -7196,7 +7290,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 +7300,12 @@ function traceTool3(name, fn) {
           "input.value": safeStringify5(args)
         }
       },
-      import_api11.context.active(),
+      import_api12.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_api12.SpanStatusCode.OK });
           return result;
         } catch (err) {
           recordError3(span2, err);
@@ -7250,7 +7344,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 +7356,7 @@ function tracedChatCompletionsCreate2(original) {
         "neatlogs.llm.model_name": model,
         "neatlogs.llm.is_streaming": isStream
       }
-    }, import_api11.context.active());
+    }, import_api12.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 +7385,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_api12.trace.setSpan(import_api12.context.active(), span2);
+    const promise = import_api12.context.with(ctx, () => original(opts, ...rest));
     return promise.then(
       (response) => {
         if (isStream) {
@@ -7310,7 +7404,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 +7414,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_api12.context.active());
+    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 (response?.output_text) {
@@ -7334,7 +7428,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_api12.SpanStatusCode.OK });
         span2.end();
         return response;
       },
@@ -7349,7 +7443,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_api12.SpanStatusCode.OK });
     span2.end();
     return stream;
   }
@@ -7435,7 +7529,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_api12.SpanStatusCode.OK });
   span2.end();
 }
 function finalizeChatResponse2(span2, response) {
@@ -7472,7 +7566,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_api12.SpanStatusCode.OK });
   span2.end();
 }
 function setInvocationParams3(span2, opts) {
@@ -7492,16 +7586,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_api12.SpanStatusCode.ERROR, message: err.message });
     span2.recordException(err);
   } else {
-    span2.setStatus({ code: import_api11.SpanStatusCode.ERROR, message: String(err) });
+    span2.setStatus({ code: import_api12.SpanStatusCode.ERROR, message: String(err) });
   }
   span2.end();
 }
 
 // src/vertex-ai.ts
-var import_api12 = require("@opentelemetry/api");
+var import_api13 = require("@opentelemetry/api");
 var TRACER_NAME6 = "neatlogs.vertex_ai";
 var PROVIDER2 = "vertex_ai";
 var SYSTEM2 = "vertexai";
@@ -7510,7 +7604,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 +7614,12 @@ function traceTool4(name, fn) {
           "input.value": safeStringify6(args)
         }
       },
-      import_api12.context.active(),
+      import_api13.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_api13.SpanStatusCode.OK });
           return result;
         } catch (err) {
           recordError4(span2, err);
@@ -7586,7 +7680,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 +7690,15 @@ function tracedChatSend(original, chat, params, rest, isStream) {
       "neatlogs.llm.model_name": model,
       "neatlogs.llm.is_streaming": isStream
     }
-  }, import_api12.context.active());
+  }, import_api13.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_api13.trace.setSpan(import_api13.context.active(), span2);
+  const result = import_api13.context.with(ctx, () => original(params, ...rest));
   return Promise.resolve(result).then(
     (response) => {
       if (isStream) return wrapStream(response, span2);
@@ -7619,7 +7713,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 +7721,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_api13.context.active());
+    const ctx = import_api13.trace.setSpan(import_api13.context.active(), span2);
+    const result = import_api13.context.with(ctx, () => original(opts, ...rest));
     return Promise.resolve(result).then(
       (response) => {
         const embeddings = response?.embeddings;
@@ -7638,7 +7732,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_api13.SpanStatusCode.OK });
         span2.end();
         return response;
       },
@@ -7651,7 +7745,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 +7753,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_api13.context.active());
+    const ctx = import_api13.trace.setSpan(import_api13.context.active(), span2);
+    const result = import_api13.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_api13.SpanStatusCode.OK });
         span2.end();
         return response;
       },
@@ -7678,7 +7772,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 +7782,10 @@ function tracedGenerateContent(original, isStream) {
         "neatlogs.llm.model_name": model,
         "neatlogs.llm.is_streaming": isStream
       }
-    }, import_api12.context.active());
+    }, import_api13.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_api13.trace.setSpan(import_api13.context.active(), span2);
+    const result = import_api13.context.with(ctx, () => original(opts, ...rest));
     return Promise.resolve(result).then(
       (response) => {
         if (isStream) {
@@ -7838,7 +7932,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_api13.SpanStatusCode.OK });
   span2.end();
 }
 function finalizeResponse(span2, response) {
@@ -7864,7 +7958,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_api13.SpanStatusCode.OK });
   span2.end();
 }
 function setUsage(span2, usage) {
@@ -7884,21 +7978,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_api13.SpanStatusCode.ERROR, message: err.message });
     span2.recordException(err);
   } else {
-    span2.setStatus({ code: import_api12.SpanStatusCode.ERROR, message: String(err) });
+    span2.setStatus({ code: import_api13.SpanStatusCode.ERROR, message: String(err) });
   }
   span2.end();
 }
 
 // src/bedrock.ts
-var import_api13 = require("@opentelemetry/api");
+var import_api14 = 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 +8002,12 @@ function traceTool5(name, fn) {
           "input.value": safeStringify7(args)
         }
       },
-      import_api13.context.active(),
+      import_api14.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_api14.SpanStatusCode.OK });
           return result;
         } catch (err) {
           recordError5(span2, err);
@@ -7959,7 +8053,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 +8061,7 @@ function startSpan(name, modelId, isStream) {
       "neatlogs.llm.model_name": String(modelId ?? ""),
       "neatlogs.llm.is_streaming": isStream
     }
-  }, import_api13.context.active());
+  }, import_api14.context.active());
 }
 function tracedConverse(originalSend, command, input, rest, isStream) {
   const span2 = startSpan(
@@ -7976,8 +8070,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_api14.trace.setSpan(import_api14.context.active(), span2);
+  const promise = import_api14.context.with(ctx, () => originalSend(command, ...rest));
   return promise.then(
     (response) => {
       if (isStream) {
@@ -8057,7 +8151,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_api14.SpanStatusCode.OK });
   span2.end();
 }
 function setConverseUsage(span2, usage) {
@@ -8071,7 +8165,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_api14.SpanStatusCode.OK });
     span2.end();
     return response;
   }
@@ -8139,7 +8233,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_api14.SpanStatusCode.OK });
   span2.end();
 }
 function isEmbeddingModel(modelId) {
@@ -8151,13 +8245,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_api14.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 +8264,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_api14.trace.setSpan(import_api14.context.active(), span2);
+  const promise = import_api14.context.with(ctx, () => originalSend(command, ...rest));
   return promise.then(
     (response) => {
       if (isStream) {
@@ -8184,7 +8278,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_api14.SpanStatusCode.OK });
         span2.end();
       }
       return response;
@@ -8209,7 +8303,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_api14.SpanStatusCode.OK });
   span2.end();
 }
 function decodeBody(body) {
@@ -8317,13 +8411,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_api14.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_api14.SpanStatusCode.OK });
     span2.end();
     return response;
   }
@@ -8341,7 +8435,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_api14.SpanStatusCode.OK });
     span2.end();
   };
   const wrappedBody = {
@@ -8394,16 +8488,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_api14.SpanStatusCode.ERROR, message: err.message });
     span2.recordException(err);
   } else {
-    span2.setStatus({ code: import_api13.SpanStatusCode.ERROR, message: String(err) });
+    span2.setStatus({ code: import_api14.SpanStatusCode.ERROR, message: String(err) });
   }
   span2.end();
 }
 
 // src/langchain.ts
-var import_api14 = require("@opentelemetry/api");
+var import_api15 = require("@opentelemetry/api");
 var TRACER_NAME8 = "neatlogs.langchain";
 function langchainHandler(opts) {
   return new NeatlogsCallbackHandler(opts);
@@ -8411,16 +8505,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_api15.trace.setSpan(import_api15.context.active(), parentSpan);
+    }
+    const tracer = import_api15.trace.getTracer(TRACER_NAME8);
+    const { root, ctx } = maybeOpenAutoRoot(tracer, kind, import_api15.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_api15.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 +8555,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_api15.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_api15.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_api15.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 +8593,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_api15.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 +8653,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_api15.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_api15.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_api15.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 +8687,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_api15.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_api15.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_api15.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 +8726,19 @@ var NeatlogsCallbackHandler = class {
         }
       }
     }
-    span2.setStatus({ code: import_api14.SpanStatusCode.OK });
+    span2.setStatus({ code: import_api15.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_api15.SpanStatusCode.ERROR, message: error.message });
     span2.recordException(error);
     span2.end();
     this._spans.delete(runId);
+    this._endAutoRoot(runId);
   }
 };
 function detectProvider(model) {
@@ -8783,7 +8907,7 @@ function safeStringify9(value) {
 }
 
 // src/openai-agents.ts
-var import_api15 = require("@opentelemetry/api");
+var import_api16 = require("@opentelemetry/api");
 var TRACER_NAME9 = "neatlogs.openai_agents";
 function openaiAgentsProcessor() {
   return new NeatlogsTraceProcessor();
@@ -8793,13 +8917,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_api16.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_api16.context.active());
     const key = String(traceId ?? `trace_${Date.now()}`);
     this._spans.set(key, span2);
     this._startTimes.set(key, Date.now());
@@ -8812,7 +8936,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_api16.SpanStatusCode.OK });
     span2.end();
     this._spans.delete(key);
     this._startTimes.delete(key);
@@ -8820,13 +8944,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_api16.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_api16.trace.setSpan(import_api16.context.active(), parentSpan) : import_api16.context.active();
     let otelSpan;
     if (spanType === "agent" || spanType === "agent_run") {
       const agentName = data?.name ?? data?.agent_name ?? "agent";
@@ -8935,13 +9059,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_api16.SpanStatusCode.ERROR, message: error.message });
         otelSpan.recordException(error);
       } else {
-        otelSpan.setStatus({ code: import_api15.SpanStatusCode.ERROR, message: String(error) });
+        otelSpan.setStatus({ code: import_api16.SpanStatusCode.ERROR, message: String(error) });
       }
     } else {
-      otelSpan.setStatus({ code: import_api15.SpanStatusCode.OK });
+      otelSpan.setStatus({ code: import_api16.SpanStatusCode.OK });
     }
     if (startTime) {
       otelSpan.setAttribute("neatlogs.llm.metrics.duration_ms", Date.now() - startTime);
@@ -8952,7 +9076,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_api16.SpanStatusCode.ERROR, message: "Processor shutdown before span completed" });
       span2.end();
     }
     this._spans.clear();
@@ -8970,7 +9094,7 @@ function safeStringify10(value) {
 }
 
 // src/mastra-wrap.ts
-var import_api16 = require("@opentelemetry/api");
+var import_api17 = require("@opentelemetry/api");
 var TRACER_NAME10 = "neatlogs.mastra";
 var PATCH_FLAG2 = "_neatlogs_patched";
 function wrapMastra(entity) {
@@ -9037,11 +9161,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_api17.trace.getTracer(TRACER_NAME10);
+      const span2 = tracer.startSpan(`mastra.agent.${agentName}`, { attributes: attrs }, import_api17.context.active());
+      const ctx = import_api17.trace.setSpan(import_api17.context.active(), span2);
       try {
-        const result = await import_api16.context.with(ctx, () => orig(input, opts));
+        const result = await import_api17.context.with(ctx, () => orig(input, opts));
         return wrapStreamingOutput(result, span2, ctx);
       } catch (err) {
         recordError6(span2, err);
@@ -9245,7 +9369,7 @@ function wrapRootMastra(mastra) {
 }
 function wrapStreamingOutput(output, span2, ctx) {
   if (!output) {
-    span2.setStatus({ code: import_api16.SpanStatusCode.OK });
+    span2.setStatus({ code: import_api17.SpanStatusCode.OK });
     span2.end();
     return output;
   }
@@ -9254,7 +9378,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_api17.SpanStatusCode.OK });
     span2.end();
   };
   if (output.text && typeof output.text.then === "function") {
@@ -9345,7 +9469,7 @@ function rebindStreamContext(output, ctx) {
         const origIterator = value[Symbol.asyncIterator].bind(value);
         return {
           [Symbol.asyncIterator]() {
-            return import_api16.context.with(ctx, () => origIterator());
+            return import_api17.context.with(ctx, () => origIterator());
           }
         };
       }
@@ -9455,13 +9579,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_api17.trace.getTracer(TRACER_NAME10);
+  const span2 = tracer.startSpan(name, { attributes: attrs }, import_api17.context.active());
+  const ctx = import_api17.trace.setSpan(import_api17.context.active(), span2);
+  return import_api17.context.with(ctx, async () => {
     try {
       const result = await fn(span2);
-      span2.setStatus({ code: import_api16.SpanStatusCode.OK });
+      span2.setStatus({ code: import_api17.SpanStatusCode.OK });
       return result;
     } catch (err) {
       recordError6(span2, err);
@@ -9496,15 +9620,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_api17.SpanStatusCode.ERROR, message: err.message });
     span2.recordException(err);
   } else {
-    span2.setStatus({ code: import_api16.SpanStatusCode.ERROR, message: String(err) });
+    span2.setStatus({ code: import_api17.SpanStatusCode.ERROR, message: String(err) });
   }
 }
 
 // src/pi-agent.ts
-var import_api17 = require("@opentelemetry/api");
+var import_api18 = require("@opentelemetry/api");
 var TRACER_NAME11 = "neatlogs.pi-agent";
 var PATCH_FLAG3 = "_neatlogs_patched";
 function piAgentHooks(agent) {
@@ -9512,7 +9636,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_api18.trace.getTracer(TRACER_NAME11);
   a.subscribe((event) => {
     try {
       handleEvent(tracer, state, event);
@@ -9528,10 +9652,10 @@ function handleEvent(tracer, state, event) {
       const span2 = tracer.startSpan(
         "pi_agent.run",
         { attributes: { "neatlogs.span.kind": "AGENT" } },
-        import_api17.context.active()
+        import_api18.context.active()
       );
       state.agentSpan = span2;
-      state.agentCtx = import_api17.trace.setSpan(import_api17.context.active(), span2);
+      state.agentCtx = import_api18.trace.setSpan(import_api18.context.active(), span2);
       state.inputMessages = [];
       break;
     }
@@ -9550,7 +9674,7 @@ function handleEvent(tracer, state, event) {
       break;
     }
     case "tool_execution_start": {
-      const parent = state.agentCtx ?? import_api17.context.active();
+      const parent = state.agentCtx ?? import_api18.context.active();
       const span2 = tracer.startSpan(
         `pi_agent.tool.${event.toolName ?? "tool"}`,
         {
@@ -9572,10 +9696,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_api18.SpanStatusCode.ERROR });
         span2.setAttribute("neatlogs.tool.is_error", true);
       } else {
-        span2.setStatus({ code: import_api17.SpanStatusCode.OK });
+        span2.setStatus({ code: import_api18.SpanStatusCode.OK });
       }
       span2.end();
       if (event.toolCallId) state.toolSpans.delete(event.toolCallId);
@@ -9594,7 +9718,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_api18.SpanStatusCode.OK });
         state.agentSpan.end();
         state.agentSpan = void 0;
         state.agentCtx = void 0;
@@ -9646,13 +9770,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_api18.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_api18.SpanStatusCode.OK });
   span2.end();
 }
 function splitAssistantContent(content) {
@@ -9713,7 +9837,7 @@ function safeStringify12(value) {
 }
 
 // src/claude-agent-sdk.ts
-var import_api18 = require("@opentelemetry/api");
+var import_api19 = require("@opentelemetry/api");
 var TRACER_NAME12 = "neatlogs.claude_agent_sdk";
 var ROOT_SCOPE = "__root__";
 function wrapClaudeAgentSDK(sdk, options = {}) {
@@ -9734,13 +9858,13 @@ function wrapClaudeAgentSDK(sdk, options = {}) {
 }
 function wrapQuery(original, options) {
   return function(params, ...rest) {
-    const tracer = import_api18.trace.getTracer(TRACER_NAME12);
+    const tracer = import_api19.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_api19.context.active()
     );
     const promptText = extractPromptText(params?.prompt);
     if (promptText) {
@@ -9749,8 +9873,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_api19.trace.setSpan(import_api19.context.active(), agentSpan);
+    const queryObj = import_api19.context.with(agentCtx, () => original(params, ...rest));
     return instrumentQueryIterable(queryObj, agentSpan, agentCtx, tracer, promptRef);
   };
 }
@@ -9769,7 +9893,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_api19.SpanStatusCode.OK });
     agentSpan.end();
     return queryObj;
   }
@@ -9806,7 +9930,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_api19.SpanStatusCode.OK });
       agentSpan.end();
     }
   };
@@ -9817,7 +9941,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_api19.context.with(agentCtx, () => iterator.next());
           if (result.done) {
             finalizeAgent("ok");
             return result;
@@ -9848,7 +9972,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_api19.SpanStatusCode.OK : import_api19.SpanStatusCode.ERROR });
     scope.span.end();
   } catch {
   }
@@ -9863,7 +9987,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_api19.trace.setSpan(import_api19.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 +9997,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_api19.trace.setSpan(import_api19.context.active(), span2),
     inputMessages: msg?.task_description ? [{ role: "user", content: String(msg.task_description) }] : [],
     assistantBuffer: null,
     finalText: "",
@@ -9997,7 +10121,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_api19.SpanStatusCode.OK });
   span2.end();
   if (outText) scope.finalText = outText;
   const turnParts = [];
@@ -10032,10 +10156,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_api19.SpanStatusCode.ERROR });
       span2.setAttribute("neatlogs.tool.is_error", true);
     } else {
-      span2.setStatus({ code: import_api18.SpanStatusCode.OK });
+      span2.setStatus({ code: import_api19.SpanStatusCode.OK });
     }
     span2.end();
     state.toolSpans.delete(id);
@@ -10082,16 +10206,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_api19.SpanStatusCode.ERROR, message: err.message });
     span2.recordException(err);
   } else {
-    span2.setStatus({ code: import_api18.SpanStatusCode.ERROR, message: String(err) });
+    span2.setStatus({ code: import_api19.SpanStatusCode.ERROR, message: String(err) });
   }
   span2.end();
 }
 
 // src/openrouter-agent.ts
-var import_api19 = require("@opentelemetry/api");
+var import_api20 = require("@opentelemetry/api");
 var TRACER_NAME13 = "neatlogs.openrouter_agent";
 var PROVIDER4 = "openrouter";
 function wrapOpenRouterAgent(client) {
@@ -10110,21 +10234,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_api20.trace.setSpan(import_api20.context.active(), span2);
+    const result = import_api20.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_api20.trace.setSpan(import_api20.context.active(), span2);
+    const result = import_api20.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 +10257,7 @@ function startLlmSpan(opts) {
       "neatlogs.llm.system": PROVIDER4,
       "neatlogs.llm.model_name": model
     }
-  }, import_api19.context.active());
+  }, import_api20.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 +10309,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_api20.SpanStatusCode.OK });
     span2.end();
     return result;
   }
@@ -10196,7 +10320,7 @@ function instrumentModelResult(result, span2) {
     try {
       finalizeLlm(span2, resolved);
     } catch {
-      span2.setStatus({ code: import_api19.SpanStatusCode.OK });
+      span2.setStatus({ code: import_api20.SpanStatusCode.OK });
       span2.end();
     }
   };
@@ -10299,7 +10423,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_api20.SpanStatusCode.OK });
   span2.end();
 }
 function extractOpenResponsesText(result) {
@@ -10325,197 +10449,623 @@ 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_api20.SpanStatusCode.ERROR, message: err.message });
     span2.recordException(err);
   } else {
-    span2.setStatus({ code: import_api19.SpanStatusCode.ERROR, message: String(err) });
+    span2.setStatus({ code: import_api20.SpanStatusCode.ERROR, message: String(err) });
   }
   span2.end();
 }
 
-// src/opencode-plugin.ts
-var import_api20 = require("@opentelemetry/api");
-var TRACER_NAME14 = "neatlogs.opencode";
-var _initialized2 = false;
-async function ensureInitialized() {
-  if (_initialized2) return;
-  _initialized2 = true;
-  try {
-    await init({
-      apiKey: process.env.NEATLOGS_API_KEY,
-      // The plugin bootstraps itself inside opencode's process — there is no user
-      // init() to pass an endpoint, so honor NEATLOGS_ENDPOINT from the env (e.g.
-      // a local backend). init() otherwise defaults to the hosted cloud.
-      ...process.env.NEATLOGS_ENDPOINT ? { endpoint: process.env.NEATLOGS_ENDPOINT } : {},
-      workflowName: process.env.NEATLOGS_WORKFLOW_NAME || "opencode",
-      // opencode is long-running and event-driven; keep auto session off so each
-      // span's conversation id is the opencode session id we set explicitly.
-      autoSession: false
-    });
-  } catch {
+// src/opencode-trace-shipper.ts
+var import_protobufjs = __toESM(require("protobufjs"));
+var PACKAGE_NAME = "neatlogs.opencode";
+var OTLP_PROTO_JSON = {
+  nested: {
+    opentelemetry: {
+      nested: {
+        proto: {
+          nested: {
+            common: {
+              nested: {
+                v1: {
+                  nested: {
+                    AnyValue: {
+                      oneofs: {
+                        value: {
+                          oneof: [
+                            "stringValue",
+                            "boolValue",
+                            "intValue",
+                            "doubleValue",
+                            "arrayValue",
+                            "kvlistValue",
+                            "bytesValue"
+                          ]
+                        }
+                      },
+                      fields: {
+                        stringValue: { type: "string", id: 1 },
+                        boolValue: { type: "bool", id: 2 },
+                        intValue: { type: "int64", id: 3 },
+                        doubleValue: { type: "double", id: 4 },
+                        arrayValue: { type: "ArrayValue", id: 5 },
+                        kvlistValue: { type: "KeyValueList", id: 6 },
+                        bytesValue: { type: "bytes", id: 7 }
+                      }
+                    },
+                    ArrayValue: { fields: { values: { rule: "repeated", type: "AnyValue", id: 1 } } },
+                    KeyValueList: { fields: { values: { rule: "repeated", type: "KeyValue", id: 1 } } },
+                    KeyValue: {
+                      fields: { key: { type: "string", id: 1 }, value: { type: "AnyValue", id: 2 } }
+                    },
+                    InstrumentationScope: {
+                      fields: { name: { type: "string", id: 1 }, version: { type: "string", id: 2 } }
+                    }
+                  }
+                }
+              }
+            },
+            resource: {
+              nested: {
+                v1: {
+                  nested: {
+                    Resource: {
+                      fields: {
+                        attributes: {
+                          rule: "repeated",
+                          type: "opentelemetry.proto.common.v1.KeyValue",
+                          id: 1
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            },
+            trace: {
+              nested: {
+                v1: {
+                  nested: {
+                    ResourceSpans: {
+                      fields: {
+                        resource: { type: "opentelemetry.proto.resource.v1.Resource", id: 1 },
+                        scopeSpans: { rule: "repeated", type: "ScopeSpans", id: 2 }
+                      }
+                    },
+                    ScopeSpans: {
+                      fields: {
+                        scope: { type: "opentelemetry.proto.common.v1.InstrumentationScope", id: 1 },
+                        spans: { rule: "repeated", type: "Span", id: 2 }
+                      }
+                    },
+                    Span: {
+                      fields: {
+                        traceId: { type: "bytes", id: 1 },
+                        spanId: { type: "bytes", id: 2 },
+                        traceState: { type: "string", id: 3 },
+                        parentSpanId: { type: "bytes", id: 4 },
+                        name: { type: "string", id: 5 },
+                        kind: { type: "SpanKind", id: 6 },
+                        startTimeUnixNano: { type: "fixed64", id: 7 },
+                        endTimeUnixNano: { type: "fixed64", id: 8 },
+                        attributes: {
+                          rule: "repeated",
+                          type: "opentelemetry.proto.common.v1.KeyValue",
+                          id: 9
+                        },
+                        droppedAttributesCount: { type: "uint32", id: 10 },
+                        status: { type: "Status", id: 15 }
+                      }
+                    },
+                    Status: {
+                      fields: { message: { type: "string", id: 2 }, code: { type: "StatusCode", id: 3 } }
+                    },
+                    StatusCode: {
+                      values: { STATUS_CODE_UNSET: 0, STATUS_CODE_OK: 1, STATUS_CODE_ERROR: 2 }
+                    },
+                    SpanKind: {
+                      values: {
+                        SPAN_KIND_UNSPECIFIED: 0,
+                        SPAN_KIND_INTERNAL: 1,
+                        SPAN_KIND_SERVER: 2,
+                        SPAN_KIND_CLIENT: 3,
+                        SPAN_KIND_PRODUCER: 4,
+                        SPAN_KIND_CONSUMER: 5
+                      }
+                    }
+                  }
+                }
+              }
+            },
+            collector: {
+              nested: {
+                trace: {
+                  nested: {
+                    v1: {
+                      nested: {
+                        ExportTraceServiceRequest: {
+                          fields: {
+                            resourceSpans: {
+                              rule: "repeated",
+                              type: "opentelemetry.proto.trace.v1.ResourceSpans",
+                              id: 1
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+};
+var protoRoot = import_protobufjs.default.Root.fromJSON(OTLP_PROTO_JSON);
+var ExportTraceServiceRequest = protoRoot.lookupType(
+  "opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest"
+);
+var SpanStatusCode16 = { UNSET: 0, OK: 1, ERROR: 2 };
+function randomBytes3(length) {
+  const out = new Uint8Array(length);
+  const crypto2 = globalThis.crypto;
+  if (crypto2 && typeof crypto2.getRandomValues === "function") {
+    crypto2.getRandomValues(out);
+    return out;
+  }
+  for (let i = 0; i < out.length; i++) out[i] = Math.floor(Math.random() * 256);
+  return out;
+}
+function generateTraceId() {
+  return randomBytes3(16);
+}
+function generateSpanId() {
+  return randomBytes3(8);
+}
+function nowNanoString() {
+  return (BigInt(Date.now()) * 1000000n).toString();
+}
+function msToNanoString(ms) {
+  return (BigInt(Math.floor(ms)) * 1000000n).toString();
+}
+function attrStr(key, value) {
+  if (value === void 0 || value === null) return void 0;
+  return { key, value: { stringValue: String(value) } };
+}
+function attrInt(key, value) {
+  if (value === void 0 || value === null || !Number.isFinite(value)) return void 0;
+  return { key, value: { intValue: String(Math.trunc(value)) } };
+}
+function attrDouble(key, value) {
+  if (value === void 0 || value === null || !Number.isFinite(value)) return void 0;
+  return { key, value: { doubleValue: value } };
+}
+var TraceShipper = class {
+  apiKey;
+  endpoint;
+  debug;
+  maxRetries;
+  workflowName;
+  queue = [];
+  prefix = "[neatlogs/opencode]";
+  constructor(opts) {
+    this.apiKey = opts.apiKey;
+    this.endpoint = opts.endpoint.endsWith("/") ? opts.endpoint.slice(0, -1) : opts.endpoint;
+    this.debug = !!opts.debug;
+    this.maxRetries = opts.maxRetries ?? 3;
+    this.workflowName = opts.workflowName || "";
+  }
+  enqueue(span2) {
+    this.queue.push(span2);
+  }
+  get pending() {
+    return this.queue.length;
   }
+  /**
+   * Ship all queued spans in a single awaited POST. Resolves only once the HTTP
+   * response is received (or all retries are exhausted) — so a short-lived host
+   * can safely exit immediately after awaiting this.
+   */
+  async flush() {
+    if (this.queue.length === 0) return;
+    if (!this.apiKey) {
+      this.queue = [];
+      return;
+    }
+    const spans = this.queue.splice(0);
+    const payload = this.buildProtobuf(spans);
+    const url = `${this.endpoint}/v1/traces`;
+    if (this.debug) console.log(`${this.prefix} Shipping ${spans.length} spans to ${url}`);
+    for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
+      try {
+        const resp = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/x-protobuf",
+            "x-api-key": this.apiKey
+          },
+          body: payload
+        });
+        if (resp.ok) {
+          if (this.debug) console.log(`${this.prefix} Shipped ${spans.length} spans`);
+          return;
+        }
+        if (resp.status === 401) {
+          console.warn(`${this.prefix} Invalid API key (401) \u2014 dropping ${spans.length} spans`);
+          return;
+        }
+        if (resp.status < 500 && resp.status !== 429) {
+          if (this.debug) console.warn(`${this.prefix} HTTP ${resp.status} \u2014 dropping spans`);
+          return;
+        }
+      } catch (err) {
+        if (this.debug) {
+          console.warn(
+            `${this.prefix} Attempt ${attempt}/${this.maxRetries}: ${err.message}`
+          );
+        }
+      }
+      if (attempt < this.maxRetries) {
+        await new Promise((r) => setTimeout(r, 500 * 2 ** (attempt - 1)));
+      }
+    }
+    console.warn(`${this.prefix} Failed to ship ${spans.length} spans after ${this.maxRetries} attempts`);
+  }
+  buildProtobuf(spans) {
+    const protoSpans = spans.map((span2) => ({
+      traceId: span2.traceId,
+      spanId: span2.spanId,
+      parentSpanId: span2.parentSpanId || void 0,
+      name: span2.name,
+      kind: span2.kind,
+      startTimeUnixNano: nanoToLong(span2.startTimeUnixNano),
+      endTimeUnixNano: nanoToLong(span2.endTimeUnixNano),
+      attributes: span2.attributes.map((a) => ({
+        key: a.key,
+        value: a.value.intValue !== void 0 ? { intValue: nanoToLong(a.value.intValue) } : a.value
+      })),
+      status: span2.status ? { code: span2.status.code, message: span2.status.message } : void 0
+    }));
+    const resourceAttributes = [
+      { key: "service.name", value: { stringValue: "neatlogs.opencode" } },
+      { key: "service.version", value: { stringValue: __version__ } }
+    ];
+    if (this.workflowName) {
+      resourceAttributes.push({
+        key: "neatlogs.workflow_name",
+        value: { stringValue: this.workflowName }
+      });
+    }
+    const message = {
+      resourceSpans: [
+        {
+          resource: { attributes: resourceAttributes },
+          scopeSpans: [
+            {
+              scope: { name: PACKAGE_NAME, version: __version__ },
+              spans: protoSpans
+            }
+          ]
+        }
+      ]
+    };
+    const errMsg = ExportTraceServiceRequest.verify(message);
+    if (errMsg && this.debug) console.warn(`${this.prefix} Proto verify: ${errMsg}`);
+    return ExportTraceServiceRequest.encode(ExportTraceServiceRequest.fromObject(message)).finish();
+  }
+};
+function nanoToLong(nanoStr) {
+  const big = BigInt(nanoStr);
+  const low = Number(big & 0xffffffffn);
+  const high = Number(big >> 32n & 0xffffffffn);
+  return { low, high, unsigned: true };
 }
+
+// src/opencode-plugin.ts
+var DEFAULT_ENDPOINT = "https://staging-cloud.neatlogs.com";
 var NeatlogsOpencodePlugin = async (_ctx) => {
-  await ensureInitialized();
-  const sessions = /* @__PURE__ */ new Map();
-  const tracer = import_api20.trace.getTracer(TRACER_NAME14);
+  const apiKey = (process.env.NEATLOGS_API_KEY ?? "").trim();
+  const endpoint = (process.env.NEATLOGS_ENDPOINT ?? DEFAULT_ENDPOINT).trim();
+  const workflowName = process.env.NEATLOGS_WORKFLOW_NAME || "opencode";
   const captureSystemPrompt = String(process.env.NEATLOGS_CAPTURE_SYSTEM_PROMPT || "").toLowerCase() === "true";
+  const debug = String(process.env.NEATLOGS_DEBUG || "").toLowerCase() === "true";
+  const shipper = new TraceShipper({ apiKey, endpoint, workflowName, debug });
+  const sessions = /* @__PURE__ */ new Map();
   function stateFor(sessionID) {
     let s = sessions.get(sessionID);
     if (!s) {
-      s = { toolSpans: /* @__PURE__ */ new Map(), messageText: /* @__PURE__ */ new Map(), emitted: /* @__PURE__ */ new Set(), lastUserText: "" };
+      s = {
+        traceId: generateTraceId(),
+        toolStarts: /* @__PURE__ */ new Map(),
+        outputParts: /* @__PURE__ */ new Map(),
+        toolCalls: /* @__PURE__ */ new Map(),
+        processed: /* @__PURE__ */ new Set(),
+        currentInput: "",
+        lastAssistantText: ""
+      };
       sessions.set(sessionID, s);
     }
     return s;
   }
+  function startRoot(st, sessionID) {
+    if (st.rootSpan) return;
+    st.rootSpan = {
+      spanId: generateSpanId(),
+      name: "opencode.session",
+      startNano: nowNanoString(),
+      attributes: [
+        { key: "neatlogs.span.kind", value: { stringValue: "AGENT" } },
+        { key: "neatlogs.agent.framework", value: { stringValue: "opencode" } },
+        { key: "neatlogs.conversation.id", value: { stringValue: sessionID } }
+      ]
+    };
+  }
+  async function closeAndFlush(st, sessionID) {
+    if (st.rootSpan) {
+      const attrs = st.rootSpan.attributes.slice();
+      setIO(attrs, "AGENT", st.currentInput || void 0, st.lastAssistantText || void 0);
+      shipper.enqueue({
+        traceId: st.traceId,
+        spanId: st.rootSpan.spanId,
+        name: st.rootSpan.name,
+        kind: 1,
+        startTimeUnixNano: st.rootSpan.startNano,
+        endTimeUnixNano: nowNanoString(),
+        attributes: attrs,
+        status: { code: SpanStatusCode16.OK }
+      });
+      const m = nowNanoString();
+      shipper.enqueue({
+        traceId: st.traceId,
+        spanId: generateSpanId(),
+        parentSpanId: st.rootSpan.spanId,
+        name: "neatlogs.trace.complete",
+        kind: 1,
+        startTimeUnixNano: m,
+        endTimeUnixNano: m,
+        attributes: [
+          { key: "neatlogs.trace.complete", value: { boolValue: true } },
+          { key: "neatlogs.internal", value: { boolValue: true } },
+          { key: "neatlogs.span.kind", value: { stringValue: "Neatlogs.INTERNAL" } }
+        ]
+      });
+      st.rootSpan = void 0;
+    }
+    await shipper.flush();
+    void sessionID;
+  }
   return {
-    /**
-     * Global event bus. opencode emits message + session lifecycle events here.
-     * We use it to emit an LLM span when an assistant message completes, and to
-     * track user-message text + assistant text from part updates.
-     */
+    /** Fired when the user submits a prompt — open the turn's AGENT root. */
+    "chat.message": async (_input, output) => {
+      try {
+        const sessionID = String(_input?.sessionID ?? output?.sessionID ?? "");
+        if (!sessionID) return;
+        const st = stateFor(sessionID);
+        const parts = output?.parts ?? [];
+        const text = Array.isArray(parts) ? parts.filter((p) => p?.type === "text" && typeof p.text === "string").map((p) => p.text).join("\n") : "";
+        if (text) st.currentInput = text;
+        startRoot(st, sessionID);
+      } catch {
+      }
+    },
+    /** Capture the system prompt (opt-in). */
+    "experimental.chat.system.transform": async (_input, output) => {
+      try {
+        if (!captureSystemPrompt) return;
+        const sessionID = String(_input?.sessionID ?? "");
+        const parts = output?.system ?? output?.parts ?? output;
+        const joined = Array.isArray(parts) ? parts.map((p) => typeof p === "string" ? p : p?.text ?? "").join("\n") : String(parts ?? "");
+        if (sessionID && joined) stateFor(sessionID).systemPrompt = joined;
+      } catch {
+      }
+    },
+    /** Global event bus — message parts, assistant completions, session idle. */
     event: async ({ event }) => {
       try {
-        await handleEvent2(tracer, sessions, stateFor, captureSystemPrompt, event);
+        await handleEvent2(shipper, sessions, stateFor, startRoot, closeAndFlush, event);
       } catch {
       }
     },
-    /** Fired before a tool runs: open a TOOL span keyed by callID. */
+    /** Tool start — record start time + args (span built atomically in `after`). */
     "tool.execute.before": async (input, output) => {
       try {
-        const sessionID = input?.sessionID ?? "";
-        const callID = input?.callID ?? input?.tool ?? "";
+        const sessionID = String(input?.sessionID ?? "");
+        if (!sessionID) return;
         const st = stateFor(sessionID);
-        const span2 = tracer.startSpan(
-          `opencode.tool.${input?.tool ?? "tool"}`,
-          {
-            attributes: {
-              "neatlogs.span.kind": "TOOL",
-              "neatlogs.tool.name": String(input?.tool ?? ""),
-              ...sessionID ? { "neatlogs.conversation.id": String(sessionID) } : {},
-              ...output?.args !== void 0 ? { "input.value": safeStringify15(output.args) } : {}
-            }
-          },
-          import_api20.context.active()
-        );
-        if (callID) st.toolSpans.set(String(callID), span2);
+        startRoot(st, sessionID);
+        const callID = String(input?.callID ?? input?.tool ?? "");
+        st.toolStarts.set(callID, {
+          spanId: generateSpanId(),
+          startNano: nowNanoString(),
+          tool: String(input?.tool ?? "tool"),
+          args: output?.args
+        });
       } catch {
       }
     },
-    /** Fired after a tool runs: close the matching TOOL span. */
-    "tool.execute.after": async (input, output) => {
+    /** Tool end — enqueue the completed TOOL span (parented to the turn root). */
+    "tool.execute.after": async (input, result) => {
       try {
-        const sessionID = input?.sessionID ?? "";
-        const callID = String(input?.callID ?? input?.tool ?? "");
+        const sessionID = String(input?.sessionID ?? "");
+        if (!sessionID) return;
         const st = stateFor(sessionID);
-        const span2 = st.toolSpans.get(callID);
-        if (!span2) return;
-        if (output?.title) span2.setAttribute("neatlogs.tool.title", String(output.title));
-        const out = output?.output ?? output?.result;
+        const callID = String(input?.callID ?? input?.tool ?? "");
+        const start = st.toolStarts.get(callID);
+        if (!start) return;
+        st.toolStarts.delete(callID);
+        const attrs = [
+          { key: "neatlogs.span.kind", value: { stringValue: "TOOL" } },
+          { key: "neatlogs.tool.name", value: { stringValue: start.tool } },
+          { key: "neatlogs.conversation.id", value: { stringValue: sessionID } }
+        ];
+        if (start.args !== void 0) {
+          setIO(attrs, "TOOL", safeStringify15(start.args), void 0);
+          push(attrs, attrStr("neatlogs.tool.input", safeStringify15(start.args)));
+        }
+        if (result?.title) push(attrs, attrStr("neatlogs.tool.title", String(result.title)));
+        const out = result?.output ?? result?.result;
         if (out !== void 0) {
-          span2.setAttribute("output.value", typeof out === "string" ? out : safeStringify15(out));
-        }
-        if (output?.metadata !== void 0) {
-          span2.setAttribute("neatlogs.tool.metadata", safeStringify15(output.metadata));
-        }
-        span2.setStatus({ code: import_api20.SpanStatusCode.OK });
-        span2.end();
-        st.toolSpans.delete(callID);
+          const o = typeof out === "string" ? out : safeStringify15(out);
+          setIO(attrs, "TOOL", void 0, o);
+          push(attrs, attrStr("neatlogs.tool.output", o));
+        }
+        if (result?.metadata !== void 0) {
+          push(attrs, attrStr("neatlogs.tool.metadata", safeStringify15(result.metadata)));
+        }
+        shipper.enqueue({
+          traceId: st.traceId,
+          spanId: start.spanId,
+          parentSpanId: st.rootSpan?.spanId,
+          name: `opencode.tool.${start.tool}`,
+          kind: 1,
+          startTimeUnixNano: start.startNano,
+          endTimeUnixNano: nowNanoString(),
+          attributes: attrs,
+          status: { code: SpanStatusCode16.OK }
+        });
       } catch {
       }
     }
   };
 };
-function handleEvent2(tracer, sessions, stateFor, captureSystemPrompt, event) {
+function handleEvent2(shipper, sessions, stateFor, startRoot, closeAndFlush, event) {
   const type = event?.type;
   const props = event?.properties ?? {};
   if (type === "message.part.updated" || type === "message.part.completed") {
     const part = props.part ?? props;
     const messageID = part?.messageID ?? part?.message_id;
     const sessionID = part?.sessionID ?? props.sessionID;
-    if (part?.type === "text" && typeof part?.text === "string" && messageID && sessionID) {
-      const st = stateFor(String(sessionID));
-      st.messageText.set(String(messageID), part.text);
+    if (!messageID || !sessionID) return void 0;
+    const st = stateFor(String(sessionID));
+    if (part?.type === "text" && typeof part?.text === "string") {
+      st.outputParts.set(String(messageID), part.text);
+    } else if (part?.type === "tool" && part?.tool) {
+      const list = st.toolCalls.get(String(messageID)) ?? [];
+      const callID = String(part.callID ?? part.tool);
+      const input = part?.state?.input ?? {};
+      const existing = list.find((t) => t.callID === callID);
+      if (existing) existing.input = input;
+      else list.push({ name: String(part.tool), input, callID });
+      st.toolCalls.set(String(messageID), list);
     }
-    return;
+    return void 0;
   }
   if (type === "message.updated" || type === "message.completed") {
     const info = props.info ?? props.message ?? props;
     const sessionID = info?.sessionID ?? info?.session_id;
-    if (!sessionID) return;
+    if (!sessionID) return void 0;
+    if (info?.role !== "assistant") return void 0;
+    const completed = info?.time?.completed ?? info?.completed;
+    const id = String(info?.id ?? "");
+    if (!completed || !id) return void 0;
     const st = stateFor(String(sessionID));
-    if (info?.role === "user") {
-      const text = messageText2(info) || st.messageText.get(String(info?.id)) || "";
-      if (text) st.lastUserText = text;
-      return;
-    }
-    if (info?.role === "assistant") {
-      const completed = info?.time?.completed ?? info?.completed;
-      const id = String(info?.id ?? "");
-      if (!completed || st.emitted.has(id)) return;
-      st.emitted.add(id);
-      emitLlmSpan2(tracer, st, captureSystemPrompt, info, String(sessionID));
-    }
-    return;
+    if (st.processed.has(id)) return void 0;
+    st.processed.add(id);
+    startRoot(st, String(sessionID));
+    emitLlmSpan2(shipper, st, info, String(sessionID));
+    return shipper.flush().catch(() => void 0);
   }
   if (type === "session.idle" || type === "session.deleted") {
     const sessionID = props.sessionID ?? props.info?.id;
     if (!sessionID) return void 0;
     const st = sessions.get(String(sessionID));
     if (!st) return void 0;
-    for (const ts of st.toolSpans.values()) {
-      try {
-        ts.end();
-      } catch {
-      }
-    }
-    st.toolSpans.clear();
+    st.toolStarts.clear();
+    const p = closeAndFlush(st, String(sessionID));
     if (type === "session.deleted") sessions.delete(String(sessionID));
-    return flush().catch(() => false);
+    return p;
   }
   return void 0;
 }
-function emitLlmSpan2(tracer, st, captureSystemPrompt, info, sessionID) {
+function emitLlmSpan2(shipper, st, info, sessionID) {
   const model = info?.modelID ?? info?.model ?? "";
   const provider = info?.providerID ?? info?.provider ?? "";
-  const attrs = {
-    "neatlogs.span.kind": "LLM",
-    "neatlogs.conversation.id": sessionID
-  };
-  if (model) attrs["neatlogs.llm.model_name"] = String(model);
-  if (provider) attrs["neatlogs.llm.provider"] = String(provider);
-  if (captureSystemPrompt && info?.system) {
-    const sys = Array.isArray(info.system) ? info.system.join("\n") : String(info.system);
-    attrs["neatlogs.llm.input_messages.0.role"] = "system";
-    attrs["neatlogs.llm.input_messages.0.content"] = sys;
-  }
-  let inIdx = captureSystemPrompt && info?.system ? 1 : 0;
-  if (st.lastUserText) {
-    attrs[`neatlogs.llm.input_messages.${inIdx}.role`] = "user";
-    attrs[`neatlogs.llm.input_messages.${inIdx}.content`] = st.lastUserText;
+  const attrs = [
+    { key: "neatlogs.span.kind", value: { stringValue: "LLM" } },
+    { key: "neatlogs.conversation.id", value: { stringValue: sessionID } }
+  ];
+  push(attrs, attrStr("neatlogs.llm.model_name", model ? String(model) : void 0));
+  push(attrs, attrStr("neatlogs.llm.provider", provider ? String(provider) : void 0));
+  let inIdx = 0;
+  if (st.systemPrompt) {
+    push(attrs, attrStr(`neatlogs.llm.input_messages.${inIdx}.role`, "system"));
+    push(attrs, attrStr(`neatlogs.llm.input_messages.${inIdx}.content`, st.systemPrompt));
     inIdx++;
   }
-  const outText = messageText2(info) || st.messageText.get(String(info?.id)) || "";
+  if (st.currentInput) {
+    push(attrs, attrStr(`neatlogs.llm.input_messages.${inIdx}.role`, "user"));
+    push(attrs, attrStr(`neatlogs.llm.input_messages.${inIdx}.content`, st.currentInput));
+    setIO(attrs, "LLM", st.currentInput, void 0);
+  }
+  const outText = st.outputParts.get(String(info?.id)) || messageText2(info) || "";
+  const toolCalls = st.toolCalls.get(String(info?.id)) ?? [];
   if (outText) {
-    attrs["neatlogs.llm.output_messages.0.role"] = "assistant";
-    attrs["neatlogs.llm.output_messages.0.content"] = outText;
+    push(attrs, attrStr("neatlogs.llm.output_messages.0.role", "assistant"));
+    push(attrs, attrStr("neatlogs.llm.output_messages.0.content", outText));
+    setIO(attrs, "LLM", void 0, outText);
+    st.lastAssistantText = outText;
+  }
+  if (toolCalls.length) {
+    toolCalls.forEach((tc, j) => {
+      push(attrs, attrStr(`neatlogs.llm.tool_calls.${j}.name`, tc.name));
+      push(attrs, attrStr(`neatlogs.llm.tool_calls.${j}.arguments`, safeStringify15(tc.input ?? {})));
+    });
+    if (!outText) {
+      const rendered = toolCalls.map((tc) => `\u2192 ${tc.name}(${safeStringify15(tc.input ?? {})})`).join("\n");
+      push(attrs, attrStr("neatlogs.llm.output_messages.0.role", "assistant"));
+      push(attrs, attrStr("neatlogs.llm.output_messages.0.content", rendered));
+      setIO(attrs, "LLM", void 0, rendered);
+    }
   }
   const tokens = info?.tokens;
   if (tokens) {
-    if (tokens.input != null) attrs["neatlogs.llm.token_count.prompt"] = tokens.input;
-    if (tokens.output != null) attrs["neatlogs.llm.token_count.completion"] = tokens.output;
+    push(attrs, attrInt("neatlogs.llm.token_count.prompt", tokens.input));
+    push(attrs, attrInt("neatlogs.llm.token_count.completion", tokens.output));
     if (tokens.input != null && tokens.output != null) {
-      attrs["neatlogs.llm.token_count.total"] = tokens.input + tokens.output;
-    }
-    if (tokens.reasoning != null) attrs["neatlogs.llm.token_count.reasoning"] = tokens.reasoning;
-    if (tokens.cache?.read != null) attrs["neatlogs.llm.token_count.cache_read"] = tokens.cache.read;
-    if (tokens.cache?.write != null) attrs["neatlogs.llm.token_count.cache_write"] = tokens.cache.write;
+      push(attrs, attrInt("neatlogs.llm.token_count.total", tokens.input + tokens.output));
+    }
+    push(attrs, attrInt("neatlogs.llm.token_count.reasoning", tokens.reasoning));
+    push(attrs, attrInt("neatlogs.llm.token_count.cache_read", tokens.cache?.read));
+    push(attrs, attrInt("neatlogs.llm.token_count.cache_write", tokens.cache?.write));
+  }
+  push(attrs, attrDouble("neatlogs.llm.cost_usd", info?.cost));
+  const createdMs = info?.time?.created;
+  const startNano = typeof createdMs === "number" ? msToNanoString(Math.floor(createdMs)) : nowNanoString();
+  shipper.enqueue({
+    traceId: st.traceId,
+    spanId: generateSpanId(),
+    parentSpanId: st.rootSpan?.spanId,
+    name: `opencode.llm.${model || "model"}`,
+    kind: 1,
+    startTimeUnixNano: startNano,
+    endTimeUnixNano: nowNanoString(),
+    attributes: attrs,
+    status: { code: SpanStatusCode16.OK }
+  });
+  if (info?.id) {
+    st.outputParts.delete(String(info.id));
+    st.toolCalls.delete(String(info.id));
+  }
+}
+function push(arr, kv) {
+  if (kv) arr.push(kv);
+}
+function setIO(arr, kind, input, output) {
+  const k = kind.toLowerCase();
+  if (input !== void 0) {
+    push(arr, attrStr("input.value", input));
+    push(arr, attrStr("neatlogs.input.value", input));
+    push(arr, attrStr(`neatlogs.${k}.input`, input));
+  }
+  if (output !== void 0) {
+    push(arr, attrStr("output.value", output));
+    push(arr, attrStr("neatlogs.output.value", output));
+    push(arr, attrStr(`neatlogs.${k}.output`, output));
   }
-  if (info?.cost != null) attrs["neatlogs.llm.cost_usd"] = info.cost;
-  const span2 = tracer.startSpan(`opencode.llm.${model || "model"}`, { attributes: attrs }, import_api20.context.active());
-  span2.setStatus({ code: import_api20.SpanStatusCode.OK });
-  span2.end();
-  if (info?.id) st.messageText.delete(String(info.id));
 }
 function messageText2(info) {
   if (!info) return "";
@@ -10535,7 +11085,7 @@ function safeStringify15(value) {
   try {
     return JSON.stringify(value) ?? "";
   } catch {
-    return "";
+    return String(value);
   }
 }