neatlogs 1.1.9 → 1.1.10

package/dist/index.cjs

@@ -6009,7 +6009,7 @@ function _resetMastraCache() {
 }
 
 // src/version.ts
-var __version__ = "1.1.9";
+var __version__ = "1.1.10";
 
 // src/init.ts
 var logger13 = getLogger();
@@ -11278,6 +11278,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 +11298,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.
+   */
+  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 flush() {
+  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 +11493,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 +11705,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({