neatlogs 1.1.9 → 1.1.11

package/dist/index.cjs

@@ -6009,7 +6009,7 @@ function _resetMastraCache() {
 }
 
 // src/version.ts
-var __version__ = "1.1.9";
+var __version__ = "1.1.11";
 
 // src/init.ts
 var logger13 = getLogger();
@@ -9621,6 +9621,7 @@ function patchModelInPlace(model) {
       if (isStream) attrs["neatlogs.llm.is_streaming"] = true;
       const promptInput = callOpts?.prompt ?? callOpts?.messages;
       if (promptInput !== void 0) attrs["input.value"] = safeStringify11(promptInput);
+      setModelInputMessages(attrs, promptInput);
       captureInvocationParams(attrs, callOpts);
       const spanName = `mastra.llm.${modelId || "model"}.${fn}`;
       if (isStream) {
@@ -10161,6 +10162,20 @@ function captureInvocationParams(attrs, callOpts) {
     attrs["neatlogs.llm.invocation_parameters"] = safeStringify11(invocation);
   }
 }
+function setModelInputMessages(attrs, promptInput) {
+  if (!Array.isArray(promptInput)) return;
+  for (let i = 0; i < promptInput.length; i++) {
+    const msg = promptInput[i];
+    if (!msg || typeof msg !== "object") continue;
+    attrs[`neatlogs.llm.input_messages.${i}.role`] = msg.role ?? "user";
+    attrs[`neatlogs.llm.input_messages.${i}.content`] = messagePartsToText(msg.content);
+  }
+}
+function messagePartsToText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter((p) => p?.type === "text" && typeof p.text === "string").map((p) => p.text).join("");
+}
 function setToolCall(span2, i, name, args, id) {
   span2.setAttribute(`neatlogs.llm.tool_calls.${i}.name`, name ?? "");
   span2.setAttribute(`neatlogs.llm.tool_calls.${i}.arguments`, safeStringify11(args ?? {}));
@@ -11278,6 +11293,9 @@ var TraceShipper = class {
   workflowName;
   queue = [];
   prefix = "[neatlogs/opencode]";
+  /** In-flight flush round-trips — awaited by `settle()` on dispose so a
+   * short-lived host (`opencode run`) can force pending exports to complete. */
+  inflight = /* @__PURE__ */ new Set();
   constructor(opts) {
     this.apiKey = opts.apiKey;
     this.endpoint = opts.endpoint.endsWith("/") ? opts.endpoint.slice(0, -1) : opts.endpoint;
@@ -11295,8 +11313,26 @@ var TraceShipper = class {
    * 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.
+   *
+   * The returned promise is also tracked in `inflight` so `settle()` can await
+   * it even when the caller (an un-awaited opencode `event` hook) drops it.
    */
-  async flush() {
+  flush() {
+    const p = this._flush().finally(() => this.inflight.delete(p));
+    this.inflight.add(p);
+    return p;
+  }
+  /**
+   * Await every flush started so far (including ones whose promise the caller
+   * discarded). Called from the plugin's `dispose` hook, which opencode DOES
+   * await on scope teardown — unlike the fire-and-forget `event` hook.
+   */
+  async settle() {
+    while (this.inflight.size > 0) {
+      await Promise.allSettled(Array.from(this.inflight));
+    }
+  }
+  async _flush() {
     if (this.queue.length === 0) return;
     if (!this.apiKey) {
       this.queue = [];
@@ -11472,6 +11508,22 @@ var NeatlogsOpencodePlugin = async (_ctx) => {
     void sessionID;
   }
   return {
+    /**
+     * Awaited by opencode on scope teardown (registered via an internal
+     * `addFinalizer`), unlike the fire-and-forget `event` hook. On a short-lived
+     * `opencode run`, `session.idle`'s `await shipper.flush()` is a dangling
+     * promise the process kills before the POST resolves — so we close any turn
+     * still open and `settle()` all in-flight flushes here, before exit.
+     */
+    dispose: async () => {
+      try {
+        for (const [sessionID, st] of sessions) {
+          if (st.rootSpan) await closeAndFlush(st, sessionID);
+        }
+        await shipper.settle();
+      } catch {
+      }
+    },
     /** Fired when the user submits a prompt — open the turn's AGENT root. */
     "chat.message": async (_input, output) => {
       try {
@@ -11668,6 +11720,7 @@ function emitLlmSpan2(shipper, st, info, sessionID) {
     push(attrs, attrInt("neatlogs.llm.token_count.cache_write", tokens.cache?.write));
   }
   push(attrs, attrDouble("neatlogs.llm.cost_usd", info?.cost));
+  push(attrs, attrStr("neatlogs.llm.finish_reason", info?.finish ? String(info.finish) : void 0));
   const createdMs = info?.time?.created;
   const startNano = typeof createdMs === "number" ? msToNanoString(Math.floor(createdMs)) : nowNanoString();
   shipper.enqueue({