neatlogs 1.1.6 → 1.1.8

package/dist/mastra-wrap.cjs

@@ -24,7 +24,47 @@ __export(mastra_wrap_exports, {
   wrapMastraRerank: () => wrapMastraRerank
 });
 module.exports = __toCommonJS(mastra_wrap_exports);
+var import_api2 = require("@opentelemetry/api");
+
+// src/core/provider.ts
+var import_node_async_hooks = require("async_hooks");
 var import_api = require("@opentelemetry/api");
+var PRIVATE_SPAN_STORAGE_KEY = /* @__PURE__ */ Symbol.for(
+  "neatlogs.private_span_async_local_storage"
+);
+var PRIVATE_PROVIDER_STATE_KEY = /* @__PURE__ */ Symbol.for(
+  "neatlogs.private_provider_state"
+);
+var neatlogsGlobal = globalThis;
+var privateContextStorage = neatlogsGlobal[PRIVATE_SPAN_STORAGE_KEY] ?? (neatlogsGlobal[PRIVATE_SPAN_STORAGE_KEY] = new import_node_async_hooks.AsyncLocalStorage());
+var providerState = neatlogsGlobal[PRIVATE_PROVIDER_STATE_KEY] ?? (neatlogsGlobal[PRIVATE_PROVIDER_STATE_KEY] = {
+  provider: null
+});
+var preInitTracer = {
+  startSpan() {
+    return import_api.trace.wrapSpanContext(import_api.INVALID_SPAN_CONTEXT);
+  },
+  startActiveSpan(_name, arg2, arg3, arg4) {
+    const fn = typeof arg2 === "function" ? arg2 : typeof arg3 === "function" ? arg3 : arg4;
+    return fn(import_api.trace.wrapSpanContext(import_api.INVALID_SPAN_CONTEXT));
+  }
+};
+function getNeatlogsTracer(name) {
+  return providerState.provider?.getTracer(name) ?? preInitTracer;
+}
+function getNeatlogsActiveContext() {
+  return privateContextStorage.getStore() ?? import_api.ROOT_CONTEXT;
+}
+function getNeatlogsParentContext(baseContext) {
+  return baseContext ?? getNeatlogsActiveContext();
+}
+function withNeatlogsSpan(span, fn, baseContext) {
+  const base = baseContext ?? getNeatlogsActiveContext();
+  const ctx = import_api.trace.setSpan(base, span);
+  return privateContextStorage.run(ctx, fn);
+}
+
+// src/mastra-wrap.ts
 var TRACER_NAME = "neatlogs.mastra";
 var PATCH_FLAG = "_neatlogs_patched";
 function wrapMastra(entity) {
@@ -52,7 +92,14 @@ function wrapMastra(entity) {
 }
 function wrapMastraRerank(rerankFn) {
   return (async function tracedRerank(...args) {
-    return withSpan("mastra.rerank", { "neatlogs.span.kind": "RERANKER" }, (span) => {
+    return withSpan("mastra.rerank", {
+      "neatlogs.span.kind": "RERANKER",
+      "input.value": safeStringify({
+        documents: args?.[0],
+        query: args?.[1],
+        options: args?.[3]
+      })
+    }, (span) => {
       const results = args?.[0];
       const query = args?.[1];
       const options = args?.[3];
@@ -64,7 +111,7 @@ function wrapMastraRerank(rerankFn) {
       if (options?.topK != null) span.setAttribute("neatlogs.reranker.top_k", options.topK);
       return Promise.resolve(rerankFn(...args)).then((result) => {
         span.setAttribute("neatlogs.reranker.output_documents", safeStringify(result));
-        span.setAttribute("output.value", safeStringify(result));
+        span.setAttribute("output.value", toOutputValue(result));
         return result;
       });
     });
@@ -100,6 +147,7 @@ function patchAgentMethod(agent, method, streaming) {
     const model = extractModelId(agent.model);
     installAgentLlmHook(agent);
     installAgentToolHooks(agent);
+    patchDynamicToolsets(opts?.toolsets);
     const attrs = {
       "neatlogs.span.kind": "AGENT",
       "neatlogs.agent.name": agentName,
@@ -111,12 +159,15 @@ function patchAgentMethod(agent, method, streaming) {
     }
     if (streaming) attrs["neatlogs.llm.is_streaming"] = true;
     if (streaming) {
-      const tracer = import_api.trace.getTracer(TRACER_NAME);
-      const span = tracer.startSpan(`mastra.agent.${agentName}`, { attributes: attrs }, import_api.context.active());
-      const ctx = import_api.trace.setSpan(import_api.context.active(), span);
+      const tracer = getNeatlogsTracer(TRACER_NAME);
+      const span = tracer.startSpan(
+        `mastra.agent.${agentName}`,
+        { attributes: attrs },
+        getNeatlogsParentContext()
+      );
       try {
-        const result = await import_api.context.with(ctx, () => orig(input, opts));
-        return wrapStreamingOutput(result, span, ctx);
+        const result = await withNeatlogsSpan(span, () => orig(input, opts));
+        return wrapStreamingOutput(result, span);
       } catch (err) {
         recordError(span, err);
         span.end();
@@ -130,6 +181,15 @@ function patchAgentMethod(agent, method, streaming) {
     });
   };
 }
+function patchDynamicToolsets(toolsets) {
+  if (!toolsets || typeof toolsets !== "object") return;
+  for (const [toolsetName, tools] of Object.entries(toolsets)) {
+    if (!tools || typeof tools !== "object") continue;
+    for (const [key, tool] of Object.entries(tools)) {
+      patchToolExecute(tool, `${toolsetName}.${key}`);
+    }
+  }
+}
 function installAgentLlmHook(agent) {
   if (agent.__neatlogs_llm_hook || typeof agent.getLLM !== "function") return;
   agent.__neatlogs_llm_hook = true;
@@ -163,17 +223,19 @@ function patchModelInPlace(model) {
       const promptInput = callOpts?.prompt ?? callOpts?.messages;
       if (promptInput !== void 0) attrs["input.value"] = safeStringify(promptInput);
       captureInvocationParams(attrs, callOpts);
-      return withActiveSpan(`mastra.llm.${modelId || "model"}.${fn}`, attrs, async (span) => {
+      const spanName = `mastra.llm.${modelId || "model"}.${fn}`;
+      if (isStream) {
+        return traceStreamingModelCall(spanName, attrs, callOpts, orig);
+      }
+      return withActiveSpan(spanName, attrs, async (span) => {
         const result = await orig(callOpts);
-        if (!isStream) finalizeModelResult(span, result);
-        else if (result?.usage) recordUsage(span, result.usage);
+        finalizeModelResult(span, result);
         return result;
       });
     };
   }
 }
 function installAgentToolHooks(agent) {
-  if (agent.__neatlogs_tool_hook) return;
   let tools;
   try {
     tools = typeof agent.listTools === "function" ? agent.listTools() : void 0;
@@ -181,7 +243,6 @@ function installAgentToolHooks(agent) {
     tools = void 0;
   }
   if (!tools || typeof tools !== "object") return;
-  agent.__neatlogs_tool_hook = true;
   for (const [key, tool] of Object.entries(tools)) {
     patchToolExecute(tool, key);
   }
@@ -200,7 +261,7 @@ function patchToolExecute(tool, key) {
     if (tool.description) attrs["neatlogs.tool.description"] = String(tool.description);
     return withActiveSpan(`mastra.tool.${toolName}`, attrs, async (span) => {
       const result = await orig(params, options);
-      span.setAttribute("output.value", safeStringify(result));
+      span.setAttribute("output.value", toOutputValue(result));
       return result;
     });
   };
@@ -223,16 +284,17 @@ function patchRunMethod(run, method, workflowName) {
   run[method] = async function tracedRunMethod(startOpts) {
     const attrs = {
       "neatlogs.span.kind": "WORKFLOW",
-      "neatlogs.workflow.name": workflowName
+      "neatlogs.workflow.name": workflowName,
+      "input.value": safeStringify(startOpts ?? {})
     };
-    if (startOpts?.inputData !== void 0) {
-      attrs["input.value"] = safeStringify(startOpts.inputData);
-    }
+    if (startOpts?.inputData !== void 0) attrs["input.value"] = safeStringify(startOpts.inputData);
     return withActiveSpan(`mastra.workflow.${workflowName}`, attrs, async (span) => {
       const result = await orig(startOpts);
       if (result?.status) span.setAttribute("neatlogs.metadata", safeStringify({ status: result.status }));
       if (result?.result !== void 0) {
         span.setAttribute("output.value", safeStringify(result.result));
+      } else {
+        span.setAttribute("output.value", toOutputValue(result));
       }
       return result;
     });
@@ -260,7 +322,7 @@ function patchVectorOp(vector, op, kind) {
     if (kind === "RETRIEVER" && params?.topK != null) attrs["neatlogs.retriever.top_k"] = params.topK;
     return withActiveSpan(`mastra.vector.${op}`, attrs, async (span) => {
       const result = await orig(params);
-      span.setAttribute("output.value", safeStringify(result));
+      span.setAttribute("output.value", toOutputValue(result));
       return result;
     });
   };
@@ -278,23 +340,38 @@ function patchMemory(memory) {
       };
       return withActiveSpan(`mastra.memory.${op}`, attrs, async (span) => {
         const result = await orig(...args);
-        span.setAttribute("output.value", safeStringify(result));
+        span.setAttribute("output.value", summarizeMemoryOutput(op, args?.[0], result));
         return result;
       });
     };
   }
 }
+function summarizeMemoryOutput(op, input, result) {
+  if (result !== void 0) return toOutputValue(result);
+  const summary = { completed: true };
+  if (op === "saveMessages") {
+    summary.messageCount = Array.isArray(input?.messages) ? input.messages.length : 0;
+  } else if (op === "deleteMessages") {
+    const ids = input?.messageIds ?? input?.ids;
+    if (Array.isArray(ids)) summary.requestedCount = ids.length;
+  } else if (op === "recall") {
+    summary.resultCount = 0;
+  }
+  return safeStringify(summary);
+}
 function patchDocument(doc) {
   if (typeof doc.chunk !== "function") return;
   const orig = doc.chunk.bind(doc);
   doc.chunk = async function tracedChunk(...args) {
     const attrs = {
       "neatlogs.span.kind": "CHAIN",
-      "neatlogs.db.operation": "chunk"
+      "neatlogs.db.operation": "chunk",
+      "input.value": safeStringify(args)
     };
     return withActiveSpan("mastra.document.chunk", attrs, async (span) => {
       const result = await orig(...args);
       if (Array.isArray(result)) span.setAttribute("neatlogs.db.documents_count", result.length);
+      span.setAttribute("output.value", toOutputValue(result));
       return result;
     });
   };
@@ -317,9 +394,10 @@ function wrapRootMastra(mastra) {
     }
   });
 }
-function wrapStreamingOutput(output, span, ctx) {
+function wrapStreamingOutput(output, span) {
   if (!output) {
-    span.setStatus({ code: import_api.SpanStatusCode.OK });
+    span.setAttribute("output.value", toOutputValue(output));
+    span.setStatus({ code: import_api2.SpanStatusCode.OK });
     span.end();
     return output;
   }
@@ -328,7 +406,7 @@ function wrapStreamingOutput(output, span, ctx) {
     if (ended) return;
     ended = true;
     if (err) recordError(span, err);
-    else span.setStatus({ code: import_api.SpanStatusCode.OK });
+    else span.setStatus({ code: import_api2.SpanStatusCode.OK });
     span.end();
   };
   if (output.text && typeof output.text.then === "function") {
@@ -342,6 +420,11 @@ function wrapStreamingOutput(output, span, ctx) {
         if (typeof text === "string" && text) {
           span.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
           span.setAttribute("neatlogs.llm.output_messages.0.content", text);
+          span.setAttribute("output.value", text);
+        } else {
+          span.setAttribute("output.value", safeStringify({
+            finishReason: finishReason ?? "completed"
+          }));
         }
         if (usage) recordUsage(span, usage);
         if (finishReason) span.setAttribute("neatlogs.llm.stop_reason", normalizeFinishReason(finishReason));
@@ -351,7 +434,7 @@ function wrapStreamingOutput(output, span, ctx) {
       }
     };
     void finalize();
-    return rebindStreamContext(output, ctx);
+    return rebindStreamContext(output, span);
   }
   if (output[Symbol.asyncIterator]) {
     const origIterator = output[Symbol.asyncIterator].bind(output);
@@ -362,8 +445,12 @@ function wrapStreamingOutput(output, span, ctx) {
       const iterator = origIterator();
       const finish = () => {
         if (textParts.length) {
+          const text = textParts.join("");
           span.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
-          span.setAttribute("neatlogs.llm.output_messages.0.content", textParts.join(""));
+          span.setAttribute("neatlogs.llm.output_messages.0.content", text);
+          span.setAttribute("output.value", text);
+        } else {
+          span.setAttribute("output.value", safeStringify({ streamCompleted: true }));
         }
         endOnce();
       };
@@ -410,29 +497,62 @@ function wrapStreamingOutput(output, span, ctx) {
   endOnce();
   return output;
 }
-function rebindStreamContext(output, ctx) {
+function rebindStreamContext(output, span) {
   const STREAM_PROPS = /* @__PURE__ */ new Set(["textStream", "fullStream", "objectStream", "elementStream"]);
   return new Proxy(output, {
     get(target, prop, receiver) {
       const value = Reflect.get(target, prop, receiver);
       if (typeof prop === "string" && STREAM_PROPS.has(prop) && value && value[Symbol.asyncIterator]) {
-        const origIterator = value[Symbol.asyncIterator].bind(value);
-        return {
-          [Symbol.asyncIterator]() {
-            return import_api.context.with(ctx, () => origIterator());
+        return new Proxy(value, {
+          get(stream, streamProp, streamReceiver) {
+            if (streamProp === Symbol.asyncIterator) {
+              return () => wrapBoundIterator(stream[Symbol.asyncIterator](), span);
+            }
+            const streamValue = Reflect.get(stream, streamProp, streamReceiver);
+            if (streamProp === "getReader" && typeof streamValue === "function") {
+              return (...args) => {
+                const reader = Reflect.apply(streamValue, stream, args);
+                return new Proxy(reader, {
+                  get(readerTarget, readerProp, readerReceiver) {
+                    const readerValue = Reflect.get(readerTarget, readerProp, readerReceiver);
+                    if (typeof readerValue !== "function") return readerValue;
+                    if (readerProp === "read" || readerProp === "cancel") {
+                      return (...readerArgs) => withNeatlogsSpan(
+                        span,
+                        () => Reflect.apply(readerValue, readerTarget, readerArgs)
+                      );
+                    }
+                    return readerValue.bind(readerTarget);
+                  }
+                });
+              };
+            }
+            return typeof streamValue === "function" ? streamValue.bind(stream) : streamValue;
           }
-        };
+        });
       }
       if (typeof value === "function") return value.bind(target);
       return value;
     }
   });
 }
+function wrapBoundIterator(iterator, span) {
+  return {
+    next: (...args) => withNeatlogsSpan(span, () => iterator.next(...args)),
+    return: iterator.return ? (...args) => withNeatlogsSpan(span, () => iterator.return(...args)) : void 0,
+    throw: iterator.throw ? (...args) => withNeatlogsSpan(span, () => iterator.throw(...args)) : void 0
+  };
+}
 function finalizeAgentResult(span, result) {
-  if (!result) return;
+  if (result === void 0) {
+    span.setAttribute("output.value", toOutputValue(result));
+    return;
+  }
   if (result.text) {
+    const text = String(result.text);
     span.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
-    span.setAttribute("neatlogs.llm.output_messages.0.content", String(result.text));
+    span.setAttribute("neatlogs.llm.output_messages.0.content", text);
+    span.setAttribute("output.value", text);
   }
   if (Array.isArray(result.toolCalls)) {
     for (let i = 0; i < result.toolCalls.length; i++) {
@@ -440,16 +560,26 @@ function finalizeAgentResult(span, result) {
       const p = tc.payload ?? tc;
       setToolCall(span, i, p.toolName ?? p.name, p.args ?? p.arguments, p.toolCallId ?? p.id);
     }
+    if (!result.text) {
+      span.setAttribute("output.value", safeStringify({ toolCalls: result.toolCalls }));
+    }
   }
   if (result.usage) recordUsage(span, result.usage);
   if (result.finishReason) span.setAttribute("neatlogs.llm.stop_reason", normalizeFinishReason(result.finishReason));
   if (result.model) span.setAttribute("neatlogs.llm.model_name", result.model);
+  if (!result.text && !Array.isArray(result.toolCalls)) {
+    span.setAttribute("output.value", safeStringify(result));
+  }
 }
 function finalizeModelResult(span, result) {
-  if (!result) return;
+  if (result === void 0) {
+    span.setAttribute("output.value", toOutputValue(result));
+    return;
+  }
   if (typeof result.text === "string" && result.text) {
     span.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
     span.setAttribute("neatlogs.llm.output_messages.0.content", result.text);
+    span.setAttribute("output.value", result.text);
   } else if (Array.isArray(result.content)) {
     const text = result.content.filter((p) => p?.type === "text" && typeof p.text === "string").map((p) => p.text).join("");
     if (text) {
@@ -462,10 +592,131 @@ function finalizeModelResult(span, result) {
       setToolCall(span, i, tc.toolName, tc.input ?? tc.args, tc.toolCallId);
     }
     span.setAttribute("output.value", safeStringify(result.content));
+  } else {
+    span.setAttribute("output.value", safeStringify(result));
   }
   if (result.usage) recordUsage(span, result.usage);
   span.setAttribute("neatlogs.llm.stop_reason", normalizeFinishReason(result.finishReason));
 }
+async function traceStreamingModelCall(spanName, attrs, callOpts, orig) {
+  const tracer = getNeatlogsTracer(TRACER_NAME);
+  const span = tracer.startSpan(
+    spanName,
+    { attributes: attrs },
+    getNeatlogsParentContext()
+  );
+  try {
+    const result = await withNeatlogsSpan(span, () => orig(callOpts));
+    return wrapModelStreamingResult(result, span);
+  } catch (err) {
+    recordError(span, err);
+    span.end();
+    throw err;
+  }
+}
+function wrapModelStreamingResult(result, span) {
+  const stream = result?.stream;
+  if (!stream || typeof stream.getReader !== "function") {
+    if (result?.usage) recordUsage(span, result.usage);
+    span.setAttribute("output.value", safeStringify(result ?? { streamCompleted: true }));
+    span.setStatus({ code: import_api2.SpanStatusCode.OK });
+    span.end();
+    return result;
+  }
+  const capture = { textParts: [], toolCalls: [] };
+  let ended = false;
+  const endOnce = (err) => {
+    if (ended) return;
+    ended = true;
+    if (err) {
+      recordError(span, err);
+    } else {
+      finalizeModelStreamSpan(span, capture);
+      span.setStatus({ code: import_api2.SpanStatusCode.OK });
+    }
+    span.end();
+  };
+  const sourceReader = stream.getReader();
+  const wrappedStream = new ReadableStream({
+    async pull(controller) {
+      try {
+        const next = await withNeatlogsSpan(span, () => sourceReader.read());
+        if (next.done) {
+          endOnce();
+          controller.close();
+          return;
+        }
+        captureModelStreamPart(span, capture, next.value);
+        controller.enqueue(next.value);
+      } catch (err) {
+        endOnce(err);
+        controller.error(err);
+      }
+    },
+    async cancel(reason) {
+      try {
+        await withNeatlogsSpan(span, () => sourceReader.cancel(reason));
+        endOnce();
+      } catch (err) {
+        endOnce(err);
+        throw err;
+      }
+    }
+  });
+  return new Proxy(result, {
+    get(target, prop, receiver) {
+      if (prop === "stream") return wrappedStream;
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+function captureModelStreamPart(span, capture, part) {
+  const type = part?.type;
+  if (type === "text-delta") {
+    const text = part.delta ?? part.text ?? part.payload?.text;
+    if (typeof text === "string" && text) capture.textParts.push(text);
+  }
+  if (type === "tool-call") {
+    const index = capture.toolCalls.length;
+    const toolCall = {
+      id: part.toolCallId ?? part.id,
+      name: part.toolName ?? part.name,
+      arguments: part.input ?? part.args ?? part.arguments
+    };
+    capture.toolCalls.push(toolCall);
+    setToolCall(span, index, toolCall.name, toolCall.arguments, toolCall.id);
+  }
+  if (type === "finish") {
+    capture.finishReason = part.finishReason;
+    capture.usage = part.usage;
+  }
+  if (part?.usage) capture.usage = part.usage;
+  if (part?.finishReason !== void 0) capture.finishReason = part.finishReason;
+}
+function finalizeModelStreamSpan(span, capture) {
+  const text = capture.textParts.join("");
+  if (text) {
+    span.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
+    span.setAttribute("neatlogs.llm.output_messages.0.content", text);
+  }
+  if (capture.usage) recordUsage(span, capture.usage);
+  if (capture.finishReason !== void 0) {
+    span.setAttribute(
+      "neatlogs.llm.stop_reason",
+      normalizeFinishReason(capture.finishReason)
+    );
+  }
+  if (text && capture.toolCalls.length === 0) {
+    span.setAttribute("output.value", text);
+    return;
+  }
+  span.setAttribute("output.value", safeStringify({
+    ...text ? { text } : {},
+    ...capture.toolCalls.length ? { toolCalls: capture.toolCalls } : {},
+    finishReason: capture.finishReason ?? "completed"
+  }));
+}
 function normalizeFinishReason(fr) {
   if (fr == null) return "";
   if (typeof fr === "string") return fr;
@@ -521,21 +772,36 @@ function recordUsage(span, usage) {
   const prompt = tokenValue(usage.promptTokens ?? usage.inputTokens ?? usage.input_tokens);
   const completion = tokenValue(usage.completionTokens ?? usage.outputTokens ?? usage.output_tokens);
   const total = tokenValue(usage.totalTokens);
+  const reasoning = tokenValue(
+    usage.reasoningTokens ?? usage.outputTokens?.reasoning ?? usage.output_tokens?.reasoning
+  );
+  const cacheRead = tokenValue(
+    usage.cachedInputTokens ?? usage.cacheReadInputTokens ?? usage.cache_read_input_tokens ?? usage.inputTokens?.cacheRead ?? usage.input_tokens?.cache_read
+  );
+  const cacheWrite = tokenValue(
+    usage.cacheCreationInputTokens ?? usage.cacheWriteInputTokens ?? usage.cache_creation_input_tokens ?? usage.inputTokens?.cacheWrite ?? usage.input_tokens?.cache_write
+  );
   if (prompt != null) span.setAttribute("neatlogs.llm.token_count.prompt", prompt);
   if (completion != null) span.setAttribute("neatlogs.llm.token_count.completion", completion);
+  if (reasoning != null) span.setAttribute("neatlogs.llm.token_count.reasoning", reasoning);
+  if (cacheRead != null) span.setAttribute("neatlogs.llm.token_count.cache_read", cacheRead);
+  if (cacheWrite != null) span.setAttribute("neatlogs.llm.token_count.cache_write", cacheWrite);
   if (total != null) span.setAttribute("neatlogs.llm.token_count.total", total);
   else if (prompt != null && completion != null) {
     span.setAttribute("neatlogs.llm.token_count.total", prompt + completion);
   }
 }
 function withActiveSpan(name, attrs, fn) {
-  const tracer = import_api.trace.getTracer(TRACER_NAME);
-  const span = tracer.startSpan(name, { attributes: attrs }, import_api.context.active());
-  const ctx = import_api.trace.setSpan(import_api.context.active(), span);
-  return import_api.context.with(ctx, async () => {
+  const tracer = getNeatlogsTracer(TRACER_NAME);
+  const span = tracer.startSpan(
+    name,
+    { attributes: attrs },
+    getNeatlogsParentContext()
+  );
+  return withNeatlogsSpan(span, async () => {
     try {
       const result = await fn(span);
-      span.setStatus({ code: import_api.SpanStatusCode.OK });
+      span.setStatus({ code: import_api2.SpanStatusCode.OK });
       return result;
     } catch (err) {
       recordError(span, err);
@@ -546,10 +812,16 @@ function withActiveSpan(name, attrs, fn) {
   });
 }
 function withSpan(name, attrs, fn) {
-  const tracer = import_api.trace.getTracer(TRACER_NAME);
-  const span = tracer.startSpan(name, { attributes: attrs }, import_api.context.active());
-  return Promise.resolve().then(() => fn(span)).then((result) => {
-    span.setStatus({ code: import_api.SpanStatusCode.OK });
+  const tracer = getNeatlogsTracer(TRACER_NAME);
+  const span = tracer.startSpan(
+    name,
+    { attributes: attrs },
+    getNeatlogsParentContext()
+  );
+  return Promise.resolve(
+    withNeatlogsSpan(span, () => fn(span))
+  ).then((result) => {
+    span.setStatus({ code: import_api2.SpanStatusCode.OK });
     span.end();
     return result;
   }).catch((err) => {
@@ -575,18 +847,30 @@ function toInputValue(input) {
 }
 function safeStringify(value) {
   if (typeof value === "string") return value;
+  if (value === void 0) {
+    return JSON.stringify({ value_type: "undefined" });
+  }
   try {
     return JSON.stringify(value) ?? "";
   } catch {
-    return "";
+    return JSON.stringify({
+      serialization_error: "circular_or_unsupported_value",
+      value_type: typeof value
+    });
   }
 }
+function toOutputValue(value) {
+  return safeStringify(value === void 0 ? { completed: true } : value);
+}
 function recordError(span, err) {
+  span.setAttribute("output.value", safeStringify({
+    error: err instanceof Error ? { name: err.name, message: err.message } : { message: String(err) }
+  }));
   if (err instanceof Error) {
-    span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: err.message });
+    span.setStatus({ code: import_api2.SpanStatusCode.ERROR, message: err.message });
     span.recordException(err);
   } else {
-    span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: String(err) });
+    span.setStatus({ code: import_api2.SpanStatusCode.ERROR, message: String(err) });
   }
 }
 // Annotate the CommonJS export names for ESM import in node: