neatlogs 1.1.12 → 1.1.13

package/dist/pi-agent.cjs

@@ -20,7 +20,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/pi-agent.ts
 var pi_agent_exports = {};
 __export(pi_agent_exports, {
-  piAgentHooks: () => piAgentHooks
+  piAgentHooks: () => piAgentHooks,
+  tracePiAgentEvents: () => tracePiAgentEvents,
+  tracePiStream: () => tracePiStream
 });
 module.exports = __toCommonJS(pi_agent_exports);
 var import_api2 = require("@opentelemetry/api");
@@ -62,22 +64,342 @@ function getNeatlogsParentContext(baseContext) {
 // src/pi-agent.ts
 var TRACER_NAME = "neatlogs.pi-agent";
 var PATCH_FLAG = "_neatlogs_patched";
+var HARNESS_METHOD_FLAG = "_neatlogs_harness_methods_patched";
 function piAgentHooks(agent) {
   if (!agent || agent[PATCH_FLAG]) return agent;
   const a = agent;
   if (typeof a.subscribe !== "function") return agent;
-  const state = { toolSpans: /* @__PURE__ */ new Map(), inputMessages: [] };
+  const listener = tracePiAgentEvents(() => a.state?.messages);
+  a.subscribe((event) => listener(event));
+  wrapHarnessModelOperations(a);
+  markPatched(a);
+  return agent;
+}
+function wrapHarnessModelOperations(harness) {
+  if (harness[HARNESS_METHOD_FLAG]) return;
+  const isHarness = typeof harness.compact === "function" && typeof harness.navigateTree === "function" && typeof harness.getModel === "function";
+  if (!isHarness) return;
+  patchHarnessMethod(harness, "compact", (args) => ({ customInstructions: args[0] }));
+  patchHarnessMethod(harness, "navigateTree", (args) => ({ targetId: args[0], options: args[1] }));
+  try {
+    Object.defineProperty(harness, HARNESS_METHOD_FLAG, { value: true });
+  } catch {
+    harness[HARNESS_METHOD_FLAG] = true;
+  }
+}
+function patchHarnessMethod(harness, method, inputOf) {
+  const original = harness[method].bind(harness);
+  harness[method] = async (...args) => {
+    const startedAt = Date.now();
+    const parent = getNeatlogsParentContext();
+    const input = inputOf(args);
+    let observedModelCall;
+    let stopObserving;
+    try {
+      stopObserving = harness.subscribe((event) => {
+        if (method === "compact" && event?.type === "session_compact") {
+          observedModelCall = !event.fromHook;
+        } else if (method === "navigateTree" && event?.type === "session_tree") {
+          observedModelCall = Boolean(event.summaryEntry) && !event.fromHook;
+        }
+      });
+    } catch {
+    }
+    let result;
+    let failure;
+    try {
+      result = await original(...args);
+      return result;
+    } catch (err) {
+      failure = err;
+      throw err;
+    } finally {
+      stopObserving?.();
+      try {
+        emitHarnessOperation(
+          method,
+          input,
+          result,
+          failure,
+          harness.getModel?.(),
+          parent,
+          startedAt,
+          Date.now(),
+          observedModelCall
+        );
+      } catch {
+      }
+    }
+  };
+}
+function emitHarnessOperation(method, input, result, failure, model, capturedParent, startedAt, endedAt, observedModelCall) {
+  const tracer = getNeatlogsTracer(TRACER_NAME);
+  let parent = capturedParent;
+  let root;
+  const inputText = safeStringify(input ?? {});
+  const outputText = failure ? `[error] ${failure instanceof Error ? failure.message : String(failure)}` : harnessOperationOutput(method, result);
+  if (!import_api2.trace.getSpan(parent)?.isRecording()) {
+    root = tracer.startSpan(
+      `pi_agent.harness.${method}`,
+      {
+        startTime: startedAt,
+        attributes: {
+          "neatlogs.span.kind": "WORKFLOW",
+          "input.value": inputText
+        }
+      },
+      parent
+    );
+    parent = import_api2.trace.setSpan(parent, root);
+  }
+  const chain = tracer.startSpan(
+    `pi_agent.harness.${method}`,
+    {
+      startTime: startedAt,
+      attributes: {
+        "neatlogs.span.kind": "CHAIN",
+        "neatlogs.pi.operation": method,
+        "input.value": inputText
+      }
+    },
+    parent
+  );
+  const chainCtx = import_api2.trace.setSpan(parent, chain);
+  const usage = harnessOperationUsage(method, result);
+  const madeModelCall = observedModelCall ?? (failure ? isHarnessSummarizationFailure(failure) : method === "compact" ? Boolean(result?.usage) : Boolean(result?.summaryEntry) && result.summaryEntry.fromHook !== true);
+  if (madeModelCall || failure) {
+    const llm = openLlmSpan(
+      tracer,
+      {
+        toolSpans: /* @__PURE__ */ new Map(),
+        inputMessages: [{ role: "user", content: inputText }],
+        turnIndex: 0,
+        turnCtx: chainCtx,
+        turnStartEpochMs: startedAt
+      },
+      {
+        role: "assistant",
+        model: model?.id ?? model?.model,
+        provider: model?.provider,
+        timestamp: startedAt
+      }
+    );
+    if (failure) {
+      closeLlmFailure(llm, failure, endedAt);
+    } else {
+      finishLlmSpan(
+        llm,
+        {
+          role: "assistant",
+          model: model?.id ?? model?.model,
+          provider: model?.provider,
+          content: outputText ? [{ type: "text", text: outputText }] : [],
+          usage,
+          stopReason: "stop"
+        },
+        endedAt
+      );
+    }
+  }
+  if (outputText) chain.setAttribute("output.value", outputText);
+  if (failure) {
+    const message = failure instanceof Error ? failure.message : String(failure);
+    chain.setAttribute("neatlogs.error.message", message);
+    chain.setStatus({ code: import_api2.SpanStatusCode.ERROR, message });
+  } else {
+    chain.setStatus({ code: import_api2.SpanStatusCode.OK });
+  }
+  chain.end(endedAt);
+  if (root) {
+    if (outputText) root.setAttribute("output.value", outputText);
+    if (failure) {
+      const message = failure instanceof Error ? failure.message : String(failure);
+      root.setAttribute("neatlogs.error.message", message);
+      root.setStatus({ code: import_api2.SpanStatusCode.ERROR, message });
+    } else {
+      root.setStatus({ code: import_api2.SpanStatusCode.OK });
+    }
+    root.end(endedAt);
+  }
+}
+function isHarnessSummarizationFailure(failure) {
+  let current = failure;
+  const seen = /* @__PURE__ */ new Set();
+  while (current && !seen.has(current)) {
+    seen.add(current);
+    if (current.code === "summarization_failed") return true;
+    current = current.cause;
+  }
+  return false;
+}
+function harnessOperationOutput(method, result) {
+  if (method === "compact") return typeof result?.summary === "string" ? result.summary : safeStringify(result ?? {});
+  const summary = result?.summaryEntry?.summary;
+  return typeof summary === "string" ? summary : safeStringify(result ?? {});
+}
+function harnessOperationUsage(method, result) {
+  return method === "compact" ? result?.usage : result?.summaryEntry?.usage;
+}
+function closeLlmFailure(llm, failure, endedAt) {
+  const message = failure instanceof Error ? failure.message : String(failure);
+  llm.span.setAttribute("output.value", `[error] ${message}`);
+  llm.span.setAttribute("neatlogs.error.message", message);
+  llm.span.setStatus({ code: import_api2.SpanStatusCode.ERROR, message });
+  llm.span.end(endedAt);
+}
+function tracePiAgentEvents(getTranscript) {
+  const state = { toolSpans: /* @__PURE__ */ new Map(), inputMessages: [], turnIndex: 0 };
   const tracer = getNeatlogsTracer(TRACER_NAME);
-  a.subscribe((event) => {
+  return (event) => {
     try {
-      handleEvent(tracer, state, event);
+      handleEvent(tracer, state, event, getTranscript);
     } catch {
     }
+  };
+}
+function tracePiStream(streamFn) {
+  const tracer = getNeatlogsTracer(TRACER_NAME);
+  return ((model, context, options) => {
+    let llm;
+    let root;
+    try {
+      const state = { toolSpans: /* @__PURE__ */ new Map(), inputMessages: [], turnIndex: 0 };
+      state.inputMessages = promptMessagesOf(context);
+      let parent = getNeatlogsParentContext();
+      if (!import_api2.trace.getSpan(parent)?.isRecording()) {
+        root = tracer.startSpan(
+          "pi_agent.stream",
+          { attributes: { "neatlogs.span.kind": "WORKFLOW" } },
+          parent
+        );
+        parent = import_api2.trace.setSpan(parent, root);
+        const rootInput = state.inputMessages.length ? safeStringify({ messages: state.inputMessages }) : void 0;
+        if (rootInput) root.setAttribute("input.value", rootInput);
+      }
+      state.turnCtx = parent;
+      llm = openLlmSpan(tracer, state, {
+        role: "assistant",
+        model: model?.id ?? model?.model,
+        provider: model?.provider
+      });
+    } catch {
+    }
+    let returned;
+    try {
+      returned = streamFn(model, context, options);
+    } catch (err) {
+      closeStreamFailure(llm, root, err);
+      throw err;
+    }
+    if (isThenable(returned)) {
+      return returned.then(
+        (stream) => attachStreamResult(stream, llm, root),
+        (err) => {
+          closeStreamFailure(llm, root, err);
+          throw err;
+        }
+      );
+    }
+    return attachStreamResult(returned, llm, root);
   });
-  markPatched(a);
-  return agent;
 }
-function handleEvent(tracer, state, event) {
+function attachStreamResult(stream, llm, root) {
+  if (!llm || !stream || typeof stream.result !== "function") {
+    closeStreamRoot(root);
+    return stream;
+  }
+  observeStreamDeltas(stream, llm);
+  stream.result().then(
+    (msg) => {
+      const message = msg ?? { role: "assistant" };
+      finishLlmSpan(llm, message);
+      closeStreamRoot(root, message);
+    },
+    (err) => closeStreamFailure(llm, root, err)
+  );
+  return stream;
+}
+function observeStreamDeltas(stream, llm) {
+  const original = stream?.[Symbol.asyncIterator];
+  if (typeof original !== "function" || original.__neatlogsObserved) return;
+  const observed = function() {
+    const iterator = original.call(this);
+    return {
+      next: async (...args) => {
+        const item = await iterator.next(...args);
+        if (!item.done && isContentDelta(item.value?.type)) markFirstStreamDelta(llm);
+        return item;
+      },
+      return: iterator.return?.bind(iterator),
+      throw: iterator.throw?.bind(iterator)
+    };
+  };
+  Object.defineProperty(observed, "__neatlogsObserved", { value: true });
+  try {
+    stream[Symbol.asyncIterator] = observed;
+  } catch {
+  }
+}
+function markFirstStreamDelta(llm) {
+  llm.span.setAttribute("neatlogs.llm.is_streaming", true);
+  if (llm.ttftMs !== void 0) return;
+  llm.ttftMs = llm.callStartEpochMs !== void 0 ? Date.now() - llm.callStartEpochMs : nowMs() - llm.startHr;
+}
+function closeStreamFailure(llm, root, err) {
+  const message = err instanceof Error ? err.message : String(err);
+  try {
+    llm?.span.setAttribute("output.value", `[error] ${message}`);
+    llm?.span.setAttribute("neatlogs.error.message", message);
+    llm?.span.setStatus({ code: import_api2.SpanStatusCode.ERROR, message });
+    llm?.span.end();
+  } catch {
+  }
+  closeStreamRoot(root, void 0, message);
+}
+function isThenable(value) {
+  return value != null && typeof value.then === "function";
+}
+function closeStreamRoot(root, msg, error) {
+  if (!root) return;
+  try {
+    if (msg) {
+      const { text, toolCalls } = splitAssistantContent(msg.content);
+      const out = text || toolCalls.map((tc) => `${tc.name}(${safeStringify(tc.arguments)})`).join("\n") || terminalSummary(msg);
+      if (out) root.setAttribute("output.value", out);
+      applyStopReasonStatus(root, msg);
+    } else if (error) {
+      root.setAttribute("output.value", `[error] ${error}`);
+      root.setAttribute("neatlogs.error.message", error);
+      root.setStatus({ code: import_api2.SpanStatusCode.ERROR, message: error });
+    }
+    root.end();
+  } catch {
+  }
+}
+function transcriptRows(messages) {
+  if (!Array.isArray(messages)) return [];
+  const rows = [];
+  for (const m of messages) {
+    const content = messageText(m);
+    if (!content) continue;
+    rows.push({ role: m?.role === "toolResult" ? "tool" : String(m?.role ?? "user"), content });
+  }
+  return rows;
+}
+function promptMessagesOf(context) {
+  const rows = [];
+  if (typeof context?.systemPrompt === "string" && context.systemPrompt) {
+    rows.push({ role: "system", content: context.systemPrompt });
+  }
+  if (Array.isArray(context?.messages)) {
+    for (const m of context.messages) {
+      const content = messageText(m);
+      if (content) rows.push({ role: String(m?.role ?? "user"), content });
+    }
+  }
+  return rows;
+}
+function handleEvent(tracer, state, event, getTranscript) {
   switch (event.type) {
     case "agent_start": {
       const base = getNeatlogsParentContext();
@@ -88,31 +410,98 @@ function handleEvent(tracer, state, event) {
       );
       state.agentSpan = span;
       state.agentCtx = import_api2.trace.setSpan(base, span);
-      state.inputMessages = [];
+      state.inputMessages = transcriptRows(getTranscript?.());
+      state.turnIndex = 0;
+      state.runInput = void 0;
+      state.runError = void 0;
+      break;
+    }
+    case "turn_start": {
+      const parent = state.agentCtx ?? getNeatlogsParentContext();
+      state.turnIndex += 1;
+      const pending = state.inputMessages[state.inputMessages.length - 1];
+      const priorInput = pending && (pending.role === "user" || pending.role === "tool") ? pending.content : void 0;
+      const span = tracer.startSpan(
+        `pi_agent.turn.${state.turnIndex}`,
+        {
+          attributes: {
+            "neatlogs.span.kind": "CHAIN",
+            "neatlogs.chain.turn_index": state.turnIndex,
+            ...priorInput ? { "input.value": priorInput } : {}
+          }
+        },
+        parent
+      );
+      state.turnSpan = span;
+      state.turnCtx = import_api2.trace.setSpan(parent, span);
+      state.turnHasInput = !!priorInput;
+      state.turnStartEpochMs = Date.now();
+      break;
+    }
+    case "turn_end": {
+      if (!state.turnSpan) break;
+      const msg = event.message;
+      const { text, toolCalls } = splitAssistantContent(msg?.content);
+      const out = text || toolCalls.map((tc) => `${tc.name}(${safeStringify(tc.arguments)})`).join("\n") || terminalSummary(msg);
+      if (out) state.turnSpan.setAttribute("output.value", out);
+      if (Array.isArray(event.toolResults) && event.toolResults.length) {
+        state.turnSpan.setAttribute("neatlogs.chain.tool_result_count", event.toolResults.length);
+      }
+      applyStopReasonStatus(state.turnSpan, msg);
+      state.turnSpan.end();
+      state.turnSpan = void 0;
+      state.turnCtx = void 0;
+      state.turnHasInput = false;
+      state.turnStartEpochMs = void 0;
+      break;
+    }
+    case "message_start": {
+      const msg = event.message;
+      if (!msg || msg.role !== "assistant") break;
+      state.llm = openLlmSpan(tracer, state, msg);
+      break;
+    }
+    case "message_update": {
+      const llm = state.llm;
+      if (!llm) break;
+      llm.span.setAttribute("neatlogs.llm.is_streaming", true);
+      if (llm.ttftMs === void 0 && isContentDelta(event.assistantMessageEvent?.type)) {
+        llm.ttftMs = llm.callStartEpochMs !== void 0 ? Date.now() - llm.callStartEpochMs : nowMs() - llm.startHr;
+      }
       break;
     }
     case "message_end": {
       const msg = event.message;
       if (!msg) return;
       if (msg.role === "assistant") {
-        emitLlmSpan(tracer, state, msg);
+        const llm = state.llm ?? openLlmSpan(tracer, state, msg);
+        state.llm = void 0;
+        state.runError = finishLlmSpan(llm, msg) ?? state.runError;
         const { text } = splitAssistantContent(msg.content);
         if (text) state.inputMessages.push({ role: "assistant", content: text });
       } else {
         const role = msg.role === "toolResult" ? "tool" : String(msg.role || "user");
         const content = messageText(msg);
-        if (content) state.inputMessages.push({ role, content });
+        if (content) {
+          state.inputMessages.push({ role, content });
+          if (role === "user" && state.runInput === void 0) state.runInput = content;
+          if (state.turnSpan && !state.turnHasInput) {
+            state.turnSpan.setAttribute("input.value", content);
+            state.turnHasInput = true;
+          }
+        }
       }
       break;
     }
     case "tool_execution_start": {
-      const parent = state.agentCtx ?? getNeatlogsParentContext();
+      const parent = state.turnCtx ?? state.agentCtx ?? getNeatlogsParentContext();
       const span = tracer.startSpan(
         `pi_agent.tool.${event.toolName ?? "tool"}`,
         {
           attributes: {
             "neatlogs.span.kind": "TOOL",
             ...event.toolName ? { "neatlogs.tool.name": String(event.toolName) } : {},
+            ...event.toolCallId ? { "neatlogs.tool.call_id": String(event.toolCallId) } : {},
             ...event.args !== void 0 ? { "input.value": safeStringify(event.args) } : {}
           }
         },
@@ -121,6 +510,12 @@ function handleEvent(tracer, state, event) {
       if (event.toolCallId) state.toolSpans.set(event.toolCallId, span);
       break;
     }
+    case "tool_execution_update": {
+      const span = event.toolCallId ? state.toolSpans.get(event.toolCallId) : void 0;
+      if (!span) break;
+      span.setAttribute("neatlogs.tool.is_streaming", true);
+      break;
+    }
     case "tool_execution_end": {
       const span = event.toolCallId ? state.toolSpans.get(event.toolCallId) : void 0;
       if (!span) return;
@@ -128,7 +523,7 @@ function handleEvent(tracer, state, event) {
         span.setAttribute("output.value", safeStringify(event.result));
       }
       if (event.isError) {
-        span.setStatus({ code: import_api2.SpanStatusCode.ERROR });
+        span.setStatus({ code: import_api2.SpanStatusCode.ERROR, message: toolErrorText(event.result) });
         span.setAttribute("neatlogs.tool.is_error", true);
       } else {
         span.setStatus({ code: import_api2.SpanStatusCode.OK });
@@ -140,17 +535,47 @@ function handleEvent(tracer, state, event) {
     case "agent_end": {
       for (const ts of state.toolSpans.values()) {
         try {
+          ts.setStatus({ code: import_api2.SpanStatusCode.ERROR, message: "run ended before tool completed" });
           ts.end();
         } catch {
         }
       }
       state.toolSpans.clear();
+      if (state.llm) {
+        try {
+          state.llm.span.setAttribute("output.value", "[incomplete] run ended mid-stream");
+          state.llm.span.setStatus({ code: import_api2.SpanStatusCode.ERROR, message: "run ended mid-stream" });
+          state.llm.span.end();
+        } catch {
+        }
+        state.llm = void 0;
+      }
+      if (state.turnSpan) {
+        try {
+          state.turnSpan.end();
+        } catch {
+        }
+        state.turnSpan = void 0;
+        state.turnCtx = void 0;
+        state.turnStartEpochMs = void 0;
+      }
       if (state.agentSpan) {
-        const firstUser = state.inputMessages.find((m) => m.role === "user");
-        if (firstUser) state.agentSpan.setAttribute("input.value", firstUser.content);
+        const input = state.runInput ?? lastUserTextFrom(event.messages) ?? lastUserTextFrom(getTranscript?.());
+        if (input) state.agentSpan.setAttribute("input.value", input);
         const finalText = lastAssistantText(event.messages);
-        if (finalText) state.agentSpan.setAttribute("output.value", finalText);
-        state.agentSpan.setStatus({ code: import_api2.SpanStatusCode.OK });
+        const err = state.runError ?? terminalErrorFrom(event.messages);
+        if (finalText) {
+          state.agentSpan.setAttribute("output.value", finalText);
+        } else if (err) {
+          state.agentSpan.setAttribute("output.value", `[${err.stopReason}]${err.message ? ` ${err.message}` : ""}`);
+        }
+        if (err) {
+          state.agentSpan.setAttribute("neatlogs.agent.stop_reason", err.stopReason);
+          if (err.message) state.agentSpan.setAttribute("neatlogs.error.message", err.message);
+          state.agentSpan.setStatus({ code: import_api2.SpanStatusCode.ERROR, message: err.message ?? err.stopReason });
+        } else {
+          state.agentSpan.setStatus({ code: import_api2.SpanStatusCode.OK });
+        }
         state.agentSpan.end();
         state.agentSpan = void 0;
         state.agentCtx = void 0;
@@ -161,55 +586,158 @@ function handleEvent(tracer, state, event) {
       break;
   }
 }
-function emitLlmSpan(tracer, state, msg) {
-  const attrs = { "neatlogs.span.kind": "LLM" };
-  if (msg.model) attrs["neatlogs.llm.model_name"] = String(msg.model);
-  if (msg.provider) attrs["neatlogs.llm.provider"] = String(msg.provider);
-  if (msg.stopReason) attrs["neatlogs.llm.stop_reason"] = String(msg.stopReason);
-  const inMsgs = state.inputMessages;
+function openLlmSpan(tracer, state, msg) {
+  const parent = state.turnCtx ?? state.agentCtx ?? getNeatlogsParentContext();
+  const startTime = callStartFrom(msg, state.turnStartEpochMs);
+  const span = tracer.startSpan(
+    `pi_agent.llm.${msg.model || "model"}`,
+    {
+      ...startTime !== void 0 ? { startTime } : {},
+      attributes: {
+        "neatlogs.span.kind": "LLM",
+        // Pi streams by default; message_update deltas confirm it per call.
+        "neatlogs.llm.is_streaming": false,
+        ...msg.model ? { "neatlogs.llm.model_name": String(msg.model) } : {},
+        ...msg.provider ? { "neatlogs.llm.provider": String(msg.provider) } : {}
+      }
+    },
+    parent
+  );
+  return {
+    span,
+    startHr: nowMs(),
+    callStartEpochMs: startTime,
+    inputMessages: state.inputMessages.slice()
+  };
+}
+function callStartFrom(msg, turnStart) {
+  const ts = msg.timestamp;
+  if (typeof ts !== "number" || !Number.isFinite(ts)) return void 0;
+  const now = Date.now();
+  const age = now - ts;
+  if (age < 0 || age > MAX_CALL_AGE_MS) return void 0;
+  return turnStart !== void 0 ? Math.max(ts, turnStart) : ts;
+}
+var MAX_CALL_AGE_MS = 30 * 6e4;
+function terminalSummary(msg) {
+  const reason = msg?.stopReason;
+  if (reason !== "aborted" && reason !== "error") return "";
+  return `[${reason}]${msg?.errorMessage ? ` ${msg.errorMessage}` : ""}`;
+}
+function applyStopReasonStatus(span, msg) {
+  const reason = msg?.stopReason;
+  if (reason === "aborted" || reason === "error") {
+    span.setStatus({ code: import_api2.SpanStatusCode.ERROR, message: msg?.errorMessage ?? reason });
+  } else {
+    span.setStatus({ code: import_api2.SpanStatusCode.OK });
+  }
+}
+function isContentDelta(type) {
+  return type === "text_delta" || type === "thinking_delta" || type === "toolcall_delta";
+}
+function nowMs() {
+  const p = globalThis.performance;
+  return typeof p?.now === "function" ? p.now() : Date.now();
+}
+function toolErrorText(result) {
+  if (!result || typeof result !== "object") return "tool error";
+  const content = result.content;
+  if (Array.isArray(content)) {
+    const text = content.map((b) => typeof b?.text === "string" ? b.text : "").filter(Boolean).join(" ").trim();
+    if (text) return text;
+  }
+  return "tool error";
+}
+function lastUserTextFrom(messages) {
+  if (!Array.isArray(messages)) return void 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (m && m.role === "user") {
+      const text = messageText(m);
+      if (text) return text;
+    }
+  }
+  return void 0;
+}
+function terminalErrorFrom(messages) {
+  if (!Array.isArray(messages)) return void 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (m && m.role === "assistant") {
+      if (m.stopReason === "aborted" || m.stopReason === "error") {
+        return { stopReason: m.stopReason, message: m.errorMessage };
+      }
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function finishLlmSpan(llm, msg, endTime) {
+  const span = llm.span;
+  if (msg.model) span.setAttribute("neatlogs.llm.model_name", String(msg.model));
+  if (msg.provider) span.setAttribute("neatlogs.llm.provider", String(msg.provider));
+  if (msg.responseModel) span.setAttribute("neatlogs.llm.response_model", String(msg.responseModel));
+  if (msg.api) span.setAttribute("neatlogs.llm.api", String(msg.api));
+  if (msg.stopReason) span.setAttribute("neatlogs.llm.stop_reason", String(msg.stopReason));
+  const inMsgs = llm.inputMessages;
   if (inMsgs.length) {
     inMsgs.forEach((m, i) => {
-      attrs[`neatlogs.llm.input_messages.${i}.role`] = m.role;
-      attrs[`neatlogs.llm.input_messages.${i}.content`] = m.content;
+      span.setAttribute(`neatlogs.llm.input_messages.${i}.role`, m.role);
+      span.setAttribute(`neatlogs.llm.input_messages.${i}.content`, m.content);
     });
-    attrs["neatlogs.llm.input"] = safeStringify({ messages: inMsgs });
-    attrs["input.value"] = safeStringify({ messages: inMsgs });
+    const inBlob = safeStringify({ messages: inMsgs });
+    span.setAttribute("neatlogs.llm.input", inBlob);
+    span.setAttribute("input.value", inBlob);
   }
   const { text, toolCalls } = splitAssistantContent(msg.content);
-  const outText = text || toolCalls.map((tc) => `${tc.name}(${safeStringify(tc.arguments)})`).join("\n");
+  const outText = text || toolCalls.map((tc) => `${tc.name}(${safeStringify(tc.arguments)})`).join("\n") || terminalSummary(msg);
   if (outText || toolCalls.length) {
-    attrs["neatlogs.llm.output_messages.0.role"] = "assistant";
-    attrs["neatlogs.llm.output_messages.0.content"] = outText || "";
+    span.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
+    span.setAttribute("neatlogs.llm.output_messages.0.content", outText || "");
     const outBlob = { role: "assistant", content: outText || "" };
     if (toolCalls.length) {
       outBlob.tool_calls = toolCalls.map((tc) => ({ name: tc.name, arguments: tc.arguments }));
       toolCalls.forEach((tc, j) => {
-        if (tc.name) attrs[`neatlogs.llm.tool_calls.${j}.name`] = tc.name;
+        if (tc.name) span.setAttribute(`neatlogs.llm.tool_calls.${j}.name`, tc.name);
         if (tc.arguments !== void 0)
-          attrs[`neatlogs.llm.tool_calls.${j}.arguments`] = safeStringify(tc.arguments);
-        if (tc.id) attrs[`neatlogs.llm.tool_calls.${j}.id`] = String(tc.id);
+          span.setAttribute(`neatlogs.llm.tool_calls.${j}.arguments`, safeStringify(tc.arguments));
+        if (tc.id) span.setAttribute(`neatlogs.llm.tool_calls.${j}.id`, String(tc.id));
       });
     }
-    attrs["neatlogs.llm.output"] = safeStringify(outBlob);
-    attrs["output.value"] = outText || "";
+    span.setAttribute("neatlogs.llm.output", safeStringify(outBlob));
+    span.setAttribute("output.value", outText || "");
   }
   const usage = msg.usage;
   if (usage) {
-    if (usage.input != null) attrs["neatlogs.llm.token_count.prompt"] = usage.input;
-    if (usage.output != null) attrs["neatlogs.llm.token_count.completion"] = usage.output;
+    if (usage.input != null) span.setAttribute("neatlogs.llm.token_count.prompt", usage.input);
+    if (usage.output != null) span.setAttribute("neatlogs.llm.token_count.completion", usage.output);
     const total = usage.totalTokens ?? (usage.input ?? 0) + (usage.output ?? 0);
-    if (total) attrs["neatlogs.llm.token_count.total"] = total;
-    if (usage.cacheRead) attrs["neatlogs.llm.token_count.cache_read"] = usage.cacheRead;
-    if (usage.cacheWrite) attrs["neatlogs.llm.token_count.cache_write"] = usage.cacheWrite;
+    if (total) span.setAttribute("neatlogs.llm.token_count.total", total);
+    if (usage.cacheRead) span.setAttribute("neatlogs.llm.token_count.cache_read", usage.cacheRead);
+    if (usage.cacheWrite) span.setAttribute("neatlogs.llm.token_count.cache_write", usage.cacheWrite);
+    const cost = usage.cost;
+    if (cost) {
+      const totalCost = cost.total ?? [cost.input, cost.output, cacheReadOf(cost), cost.cacheWrite].reduce(
+        (sum, v) => sum + (typeof v === "number" ? v : 0),
+        0
+      );
+      if (typeof totalCost === "number" && totalCost > 0) {
+        span.setAttribute("neatlogs.llm.cost_usd", totalCost);
+      }
+      if (typeof cost.input === "number") span.setAttribute("neatlogs.llm.cost.prompt", cost.input);
+      if (typeof cost.output === "number") span.setAttribute("neatlogs.llm.cost.completion", cost.output);
+    }
   }
-  const parent = state.agentCtx ?? getNeatlogsParentContext();
-  const span = tracer.startSpan(
-    `pi_agent.llm.${msg.model || "model"}`,
-    { attributes: attrs },
-    parent
-  );
-  span.setStatus({ code: import_api2.SpanStatusCode.OK });
-  span.end();
+  if (llm.ttftMs !== void 0) {
+    span.setAttribute("neatlogs.llm.metrics.ttft_ms", Math.round(llm.ttftMs));
+  }
+  if (msg.errorMessage) span.setAttribute("neatlogs.error.message", String(msg.errorMessage));
+  applyStopReasonStatus(span, msg);
+  span.end(endTime);
+  return msg.stopReason === "aborted" || msg.stopReason === "error" ? { stopReason: msg.stopReason, message: msg.errorMessage } : void 0;
+}
+function cacheReadOf(cost) {
+  return typeof cost.cacheRead === "number" ? cost.cacheRead : cost.cacheReads;
 }
 function splitAssistantContent(content) {
   const texts = [];
@@ -269,6 +797,8 @@ function safeStringify(value) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  piAgentHooks
+  piAgentHooks,
+  tracePiAgentEvents,
+  tracePiStream
 });
 //# sourceMappingURL=pi-agent.cjs.map