neatlogs 1.0.8 → 1.0.9

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.9";
 
 // src/init.ts
 var logger13 = getLogger();
@@ -10333,189 +10333,615 @@ function recordError8(span2, 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 +10961,7 @@ function safeStringify15(value) {
   try {
     return JSON.stringify(value) ?? "";
   } catch {
-    return "";
+    return String(value);
   }
 }