neatlogs 1.1.12 → 1.1.14

package/dist/index.cjs

@@ -66,6 +66,8 @@ __export(index_exports, {
   span: () => span,
   strandsHooks: () => strandsHooks,
   trace: () => trace,
+  tracePiAgentEvents: () => tracePiAgentEvents,
+  tracePiStream: () => tracePiStream,
   traceToolAnthropic: () => traceTool2,
   traceToolAzureOpenAI: () => traceTool3,
   traceToolBedrock: () => traceTool6,
@@ -4873,6 +4875,8 @@ var NeatlogsSpanProcessor = class {
     if (!currentModel) return;
     const llmOutput = attrs["neatlogs.llm.output"];
     if (!llmOutput) return;
+    const trimmed = llmOutput.trimStart();
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return;
     try {
       const output = JSON.parse(llmOutput);
       const generations = output?.generations;
@@ -4897,7 +4901,9 @@ var NeatlogsSpanProcessor = class {
         }
       }
     } catch (e) {
-      logger10.warn(`[ModelResolve] Failed to parse LLM output for model extraction: ${e}`);
+      if (this.debug) {
+        logger10.debug(`[ModelResolve] Failed to parse LLM output for model extraction: ${e}`);
+      }
     }
   }
   // ── forceFlush / shutdown ─────────────────────────────
@@ -5058,7 +5064,8 @@ var INSTRUMENTATION_REGISTRY = {
       "ai_sdk",
       "claude_agent_sdk",
       "openrouter_agent",
-      "opencode"
+      "opencode",
+      "pi_agent"
     ],
     tool: ["langchain", "llamaindex", "haystack", "mcp"],
     http: ["requests", "httpx", "urllib3", "aiohttp"],
@@ -5433,6 +5440,13 @@ var INSTRUMENTATION_REGISTRY = {
       neatlogs: "neatlogs/opencode",
       default_span_kind: "AGENT",
       explicitWrapper: "NeatlogsOpencodePlugin from 'neatlogs/opencode'"
+    },
+    pi_agent: {
+      openinference: null,
+      openllmetry: null,
+      neatlogs: "neatlogs/pi-agent",
+      default_span_kind: "AGENT",
+      explicitWrapper: "piAgentHooks() from 'neatlogs/pi-agent'"
     }
   }
 };
@@ -6009,7 +6023,7 @@ function _resetMastraCache() {
 }
 
 // src/version.ts
-var __version__ = "1.1.12";
+var __version__ = "1.1.14";
 
 // src/init.ts
 var logger13 = getLogger();
@@ -6898,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) => {
@@ -6930,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);
@@ -10273,22 +10387,342 @@ function recordError7(span2, err) {
 var import_api19 = require("@opentelemetry/api");
 var TRACER_NAME12 = "neatlogs.pi-agent";
 var PATCH_FLAG2 = "_neatlogs_patched";
+var HARNESS_METHOD_FLAG = "_neatlogs_harness_methods_patched";
 function piAgentHooks(agent) {
   if (!agent || agent[PATCH_FLAG2]) 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);
+  markPatched2(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_NAME12);
+  let parent = capturedParent;
+  let root;
+  const inputText = safeStringify12(input ?? {});
+  const outputText = failure ? `[error] ${failure instanceof Error ? failure.message : String(failure)}` : harnessOperationOutput(method, result);
+  if (!import_api19.trace.getSpan(parent)?.isRecording()) {
+    root = tracer.startSpan(
+      `pi_agent.harness.${method}`,
+      {
+        startTime: startedAt,
+        attributes: {
+          "neatlogs.span.kind": "WORKFLOW",
+          "input.value": inputText
+        }
+      },
+      parent
+    );
+    parent = import_api19.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_api19.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_api19.SpanStatusCode.ERROR, message });
+  } else {
+    chain.setStatus({ code: import_api19.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_api19.SpanStatusCode.ERROR, message });
+    } else {
+      root.setStatus({ code: import_api19.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 : safeStringify12(result ?? {});
+  const summary = result?.summaryEntry?.summary;
+  return typeof summary === "string" ? summary : safeStringify12(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_api19.SpanStatusCode.ERROR, message });
+  llm.span.end(endedAt);
+}
+function tracePiAgentEvents(getTranscript) {
+  const state = { toolSpans: /* @__PURE__ */ new Map(), inputMessages: [], turnIndex: 0 };
   const tracer = getNeatlogsTracer(TRACER_NAME12);
-  a.subscribe((event) => {
+  return (event) => {
     try {
-      handleEvent(tracer, state, event);
+      handleEvent(tracer, state, event, getTranscript);
     } catch {
     }
+  };
+}
+function tracePiStream(streamFn) {
+  const tracer = getNeatlogsTracer(TRACER_NAME12);
+  return ((model, context2, options) => {
+    let llm;
+    let root;
+    try {
+      const state = { toolSpans: /* @__PURE__ */ new Map(), inputMessages: [], turnIndex: 0 };
+      state.inputMessages = promptMessagesOf(context2);
+      let parent = getNeatlogsParentContext();
+      if (!import_api19.trace.getSpan(parent)?.isRecording()) {
+        root = tracer.startSpan(
+          "pi_agent.stream",
+          { attributes: { "neatlogs.span.kind": "WORKFLOW" } },
+          parent
+        );
+        parent = import_api19.trace.setSpan(parent, root);
+        const rootInput = state.inputMessages.length ? safeStringify12({ 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, context2, 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);
   });
-  markPatched2(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_api19.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}(${safeStringify12(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_api19.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(context2) {
+  const rows = [];
+  if (typeof context2?.systemPrompt === "string" && context2.systemPrompt) {
+    rows.push({ role: "system", content: context2.systemPrompt });
+  }
+  if (Array.isArray(context2?.messages)) {
+    for (const m of context2.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();
@@ -10299,31 +10733,98 @@ function handleEvent(tracer, state, event) {
       );
       state.agentSpan = span2;
       state.agentCtx = import_api19.trace.setSpan(base, span2);
-      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 span2 = 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 = span2;
+      state.turnCtx = import_api19.trace.setSpan(parent, span2);
+      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}(${safeStringify12(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 span2 = 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": safeStringify12(event.args) } : {}
           }
         },
@@ -10332,6 +10833,12 @@ function handleEvent(tracer, state, event) {
       if (event.toolCallId) state.toolSpans.set(event.toolCallId, span2);
       break;
     }
+    case "tool_execution_update": {
+      const span2 = event.toolCallId ? state.toolSpans.get(event.toolCallId) : void 0;
+      if (!span2) break;
+      span2.setAttribute("neatlogs.tool.is_streaming", true);
+      break;
+    }
     case "tool_execution_end": {
       const span2 = event.toolCallId ? state.toolSpans.get(event.toolCallId) : void 0;
       if (!span2) return;
@@ -10339,7 +10846,7 @@ function handleEvent(tracer, state, event) {
         span2.setAttribute("output.value", safeStringify12(event.result));
       }
       if (event.isError) {
-        span2.setStatus({ code: import_api19.SpanStatusCode.ERROR });
+        span2.setStatus({ code: import_api19.SpanStatusCode.ERROR, message: toolErrorText(event.result) });
         span2.setAttribute("neatlogs.tool.is_error", true);
       } else {
         span2.setStatus({ code: import_api19.SpanStatusCode.OK });
@@ -10351,17 +10858,47 @@ function handleEvent(tracer, state, event) {
     case "agent_end": {
       for (const ts of state.toolSpans.values()) {
         try {
+          ts.setStatus({ code: import_api19.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_api19.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_api19.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_api19.SpanStatusCode.ERROR, message: err.message ?? err.stopReason });
+        } else {
+          state.agentSpan.setStatus({ code: import_api19.SpanStatusCode.OK });
+        }
         state.agentSpan.end();
         state.agentSpan = void 0;
         state.agentCtx = void 0;
@@ -10372,55 +10909,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 span2 = 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: span2,
+    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(span2, msg) {
+  const reason = msg?.stopReason;
+  if (reason === "aborted" || reason === "error") {
+    span2.setStatus({ code: import_api19.SpanStatusCode.ERROR, message: msg?.errorMessage ?? reason });
+  } else {
+    span2.setStatus({ code: import_api19.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 span2 = llm.span;
+  if (msg.model) span2.setAttribute("neatlogs.llm.model_name", String(msg.model));
+  if (msg.provider) span2.setAttribute("neatlogs.llm.provider", String(msg.provider));
+  if (msg.responseModel) span2.setAttribute("neatlogs.llm.response_model", String(msg.responseModel));
+  if (msg.api) span2.setAttribute("neatlogs.llm.api", String(msg.api));
+  if (msg.stopReason) span2.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;
+      span2.setAttribute(`neatlogs.llm.input_messages.${i}.role`, m.role);
+      span2.setAttribute(`neatlogs.llm.input_messages.${i}.content`, m.content);
     });
-    attrs["neatlogs.llm.input"] = safeStringify12({ messages: inMsgs });
-    attrs["input.value"] = safeStringify12({ messages: inMsgs });
+    const inBlob = safeStringify12({ messages: inMsgs });
+    span2.setAttribute("neatlogs.llm.input", inBlob);
+    span2.setAttribute("input.value", inBlob);
   }
   const { text, toolCalls } = splitAssistantContent(msg.content);
-  const outText = text || toolCalls.map((tc) => `${tc.name}(${safeStringify12(tc.arguments)})`).join("\n");
+  const outText = text || toolCalls.map((tc) => `${tc.name}(${safeStringify12(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 || "";
+    span2.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
+    span2.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) span2.setAttribute(`neatlogs.llm.tool_calls.${j}.name`, tc.name);
         if (tc.arguments !== void 0)
-          attrs[`neatlogs.llm.tool_calls.${j}.arguments`] = safeStringify12(tc.arguments);
-        if (tc.id) attrs[`neatlogs.llm.tool_calls.${j}.id`] = String(tc.id);
+          span2.setAttribute(`neatlogs.llm.tool_calls.${j}.arguments`, safeStringify12(tc.arguments));
+        if (tc.id) span2.setAttribute(`neatlogs.llm.tool_calls.${j}.id`, String(tc.id));
       });
     }
-    attrs["neatlogs.llm.output"] = safeStringify12(outBlob);
-    attrs["output.value"] = outText || "";
+    span2.setAttribute("neatlogs.llm.output", safeStringify12(outBlob));
+    span2.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) span2.setAttribute("neatlogs.llm.token_count.prompt", usage.input);
+    if (usage.output != null) span2.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) span2.setAttribute("neatlogs.llm.token_count.total", total);
+    if (usage.cacheRead) span2.setAttribute("neatlogs.llm.token_count.cache_read", usage.cacheRead);
+    if (usage.cacheWrite) span2.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) {
+        span2.setAttribute("neatlogs.llm.cost_usd", totalCost);
+      }
+      if (typeof cost.input === "number") span2.setAttribute("neatlogs.llm.cost.prompt", cost.input);
+      if (typeof cost.output === "number") span2.setAttribute("neatlogs.llm.cost.completion", cost.output);
+    }
   }
-  const parent = state.agentCtx ?? getNeatlogsParentContext();
-  const span2 = tracer.startSpan(
-    `pi_agent.llm.${msg.model || "model"}`,
-    { attributes: attrs },
-    parent
-  );
-  span2.setStatus({ code: import_api19.SpanStatusCode.OK });
-  span2.end();
+  if (llm.ttftMs !== void 0) {
+    span2.setAttribute("neatlogs.llm.metrics.ttft_ms", Math.round(llm.ttftMs));
+  }
+  if (msg.errorMessage) span2.setAttribute("neatlogs.error.message", String(msg.errorMessage));
+  applyStopReasonStatus(span2, msg);
+  span2.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 = [];
@@ -11652,7 +12292,7 @@ function handleEvent2(shipper, sessions, stateFor, startRoot, closeAndFlush, eve
     if (st.processed.has(id)) return void 0;
     st.processed.add(id);
     startRoot(st, String(sessionID));
-    emitLlmSpan2(shipper, st, info, String(sessionID));
+    emitLlmSpan(shipper, st, info, String(sessionID));
     return shipper.flush().catch(() => void 0);
   }
   if (type === "session.idle" || type === "session.deleted") {
@@ -11667,7 +12307,7 @@ function handleEvent2(shipper, sessions, stateFor, startRoot, closeAndFlush, eve
   }
   return void 0;
 }
-function emitLlmSpan2(shipper, st, info, sessionID) {
+function emitLlmSpan(shipper, st, info, sessionID) {
   if (!st.traceId) return;
   const model = info?.modelID ?? info?.model ?? "";
   const provider = info?.providerID ?? info?.provider ?? "";
@@ -11864,6 +12504,8 @@ function bindTemplates(llm, systemTpl, userTpl, compiledVars) {
   span,
   strandsHooks,
   trace,
+  tracePiAgentEvents,
+  tracePiStream,
   traceToolAnthropic,
   traceToolAzureOpenAI,
   traceToolBedrock,