neatlogs 1.1.13 → 1.1.14

package/dist/index.cjs

@@ -6023,7 +6023,7 @@ function _resetMastraCache() {
 }
 
 // src/version.ts
-var __version__ = "1.1.13";
+var __version__ = "1.1.14";
 
 // src/init.ts
 var logger13 = getLogger();
@@ -6912,29 +6912,25 @@ function tracedResponsesCreate(original) {
   return function(opts, ...rest) {
     const tracer = getProviderTracer(TRACER_NAME3);
     const model = opts?.model ?? "";
+    const isStream = opts?.stream === true;
     const span2 = tracer.startSpan("openai.responses.create", {
       attributes: {
         "neatlogs.span.kind": "LLM",
         "neatlogs.llm.provider": "openai",
         "neatlogs.llm.system": "openai",
         "neatlogs.llm.model_name": model,
+        "neatlogs.llm.is_streaming": isStream,
         "input.value": safeStringify3(opts?.input ?? "")
       }
     }, getNeatlogsParentContext());
+    setInvocationParams(span2, opts);
     const promise = withNeatlogsSpan(span2, () => original(opts, ...rest));
     return promise.then(
       (response) => {
-        if (response?.output_text) {
-          span2.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
-          span2.setAttribute("neatlogs.llm.output_messages.0.content", response.output_text);
-        }
-        if (response?.model) span2.setAttribute("neatlogs.llm.model_name", response.model);
-        if (response?.usage) {
-          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);
+        if (isStream) {
+          return wrapResponsesAsyncIterableStream(response, span2);
         }
-        span2.setStatus({ code: import_api10.SpanStatusCode.OK });
-        span2.end();
+        finalizeResponsesResponse(span2, response);
         return response;
       },
       (err) => {
@@ -6944,6 +6940,110 @@ function tracedResponsesCreate(original) {
     );
   };
 }
+function wrapResponsesAsyncIterableStream(stream, span2) {
+  const originalAsyncIterator = stream?.[Symbol.asyncIterator]?.bind(stream);
+  if (!originalAsyncIterator) {
+    finalizeResponsesResponse(span2, stream);
+    return stream;
+  }
+  const textParts = [];
+  let completedResponse;
+  let finalized = false;
+  const finalize = () => {
+    if (finalized) return;
+    finalized = true;
+    finalizeResponsesResponse(span2, completedResponse, textParts.join(""));
+  };
+  return new Proxy(stream, {
+    get(target, prop) {
+      if (prop === Symbol.asyncIterator) {
+        return () => {
+          const iterator = originalAsyncIterator();
+          return {
+            async next() {
+              try {
+                const result = await iterator.next();
+                if (result.done) {
+                  finalize();
+                  return result;
+                }
+                const event = result.value;
+                if (event?.type === "response.output_text.delta" && typeof event.delta === "string") {
+                  textParts.push(event.delta);
+                } else if (event?.type === "response.completed") {
+                  completedResponse = event.response;
+                }
+                return result;
+              } catch (err) {
+                if (!finalized) {
+                  finalized = true;
+                  recordError(span2, err);
+                }
+                throw err;
+              }
+            },
+            async return(value2) {
+              try {
+                return await (iterator.return?.(value2) ?? { done: true, value: value2 });
+              } finally {
+                finalize();
+              }
+            },
+            async throw(err) {
+              if (!finalized) {
+                finalized = true;
+                recordError(span2, err);
+              }
+              if (iterator.throw) return iterator.throw(err);
+              throw err;
+            }
+          };
+        };
+      }
+      const value = Reflect.get(target, prop, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+function finalizeResponsesResponse(span2, response, streamedText = "") {
+  const text = response?.output_text || streamedText || extractResponsesOutputText(response?.output);
+  if (text) {
+    span2.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
+    span2.setAttribute("neatlogs.llm.output_messages.0.content", text);
+    span2.setAttribute("output.value", text);
+  } else if (response?.output) {
+    span2.setAttribute("output.value", safeStringify3(response.output));
+  }
+  if (response?.model) span2.setAttribute("neatlogs.llm.model_name", response.model);
+  if (response?.status) span2.setAttribute("neatlogs.llm.finish_reason", response.status);
+  const usage = response?.usage;
+  if (usage) {
+    if (usage.input_tokens != null) span2.setAttribute("neatlogs.llm.token_count.prompt", usage.input_tokens);
+    if (usage.output_tokens != null) span2.setAttribute("neatlogs.llm.token_count.completion", usage.output_tokens);
+    if (usage.total_tokens != null) span2.setAttribute("neatlogs.llm.token_count.total", usage.total_tokens);
+    if (usage.input_tokens_details?.cached_tokens != null) {
+      span2.setAttribute("neatlogs.llm.token_count.cache_read", usage.input_tokens_details.cached_tokens);
+    }
+    if (usage.output_tokens_details?.reasoning_tokens != null) {
+      span2.setAttribute("neatlogs.llm.token_count.reasoning", usage.output_tokens_details.reasoning_tokens);
+    }
+  }
+  span2.setStatus({ code: import_api10.SpanStatusCode.OK });
+  span2.end();
+}
+function extractResponsesOutputText(output) {
+  if (!Array.isArray(output)) return "";
+  const parts = [];
+  for (const item of output) {
+    if (item?.type !== "message" || !Array.isArray(item.content)) continue;
+    for (const content of item.content) {
+      if (content?.type === "output_text" && typeof content.text === "string") {
+        parts.push(content.text);
+      }
+    }
+  }
+  return parts.join("");
+}
 function wrapAsyncIterableStream(stream, span2) {
   const chunks = [];
   const originalAsyncIterator = stream[Symbol.asyncIterator]?.bind(stream);