neatlogs 1.0.4 → 1.0.6

package/dist/index.cjs

@@ -50,16 +50,25 @@ __export(index_exports, {
   getSessionConfig: () => getSessionConfig,
   init: () => init,
   isDebugEnabled: () => isDebugEnabled,
+  langchainHandler: () => langchainHandler,
   listPrompts: () => listPrompts,
   log: () => log,
+  openaiAgentsProcessor: () => openaiAgentsProcessor,
+  piAgentHooks: () => piAgentHooks,
   registerCrewaiTask: () => registerCrewaiTask,
   removeTag: () => removeTag,
   saveAsVersion: () => saveAsVersion,
   shutdown: () => shutdown,
   span: () => span,
+  strandsHooks: () => strandsHooks,
   trace: () => trace2,
+  traceToolAnthropic: () => traceTool2,
+  traceToolOpenAI: () => traceTool,
   updatePrompt: () => updatePrompt,
-  wrapAISDK: () => wrapAISDK
+  wrapAISDK: () => wrapAISDK,
+  wrapAnthropic: () => wrapAnthropic,
+  wrapMastra: () => wrapMastra,
+  wrapOpenAI: () => wrapOpenAI
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -302,7 +311,6 @@ var VECTOR_DB_SYSTEMS = /* @__PURE__ */ new Set([
   "marqo",
   "weaviate",
   "lancedb",
-  "astra",
   "pgvector",
   "elasticsearch"
 ]);
@@ -328,8 +336,7 @@ var VECTOR_DB_NAMES = [
   "qdrant",
   "milvus",
   "lancedb",
-  "marqo",
-  "astra"
+  "marqo"
 ];
 
 // src/span-kinds/mapping.ts
@@ -3149,7 +3156,8 @@ var attribute_mapping_default = {
       tool: {
         name: {
           sources: [
-            "tool.name"
+            "tool.name",
+            "gen_ai.tool.name"
           ],
           target: "neatlogs.tool.name"
         },
@@ -3898,16 +3906,25 @@ var AttributeMapper = class {
         }
       }
     }
+    if (!spanKindValue && "neatlogs.span.kind" in attributes) {
+      spanKindValue = attributes["neatlogs.span.kind"];
+    }
     if (spanKindValue && spanKindValue in valuesMap) {
       return valuesMap[spanKindValue];
     }
+    if (spanKindValue && Object.values(valuesMap).includes(spanKindValue)) {
+      return spanKindValue;
+    }
     const isLlmSpan = [
       "llm.model_name",
       "gen_ai.request.model",
       "llm.token_count.prompt",
       "llm.token_count.completion",
       "gen_ai.usage.prompt_tokens",
-      "gen_ai.usage.completion_tokens"
+      "gen_ai.usage.completion_tokens",
+      "neatlogs.llm.model_name",
+      "neatlogs.llm.token_count.prompt",
+      "neatlogs.llm.token_count.completion"
     ].some((key) => key in attributes);
     if (isLlmSpan) {
       return "llm";
@@ -5846,7 +5863,7 @@ async function removeTag(name, tag) {
 }
 
 // src/version.ts
-var __version__ = "1.0.0";
+var __version__ = "1.0.6";
 
 // src/init.ts
 var logger13 = getLogger();
@@ -6478,6 +6495,1971 @@ function recordSpanError(span2, err) {
   }
 }
 
+// src/openai.ts
+var import_api9 = require("@opentelemetry/api");
+var TRACER_NAME3 = "neatlogs.openai";
+function wrapOpenAI(client) {
+  return wrapNamespace(client, []);
+}
+function traceTool(name, fn) {
+  return async function tracedTool(args) {
+    const tracer = import_api9.trace.getTracer(TRACER_NAME3);
+    return tracer.startActiveSpan(
+      `tool.${name}`,
+      {
+        attributes: {
+          "neatlogs.span.kind": "TOOL",
+          "neatlogs.tool.name": name,
+          "input.value": safeStringify3(args)
+        }
+      },
+      import_api9.context.active(),
+      async (span2) => {
+        try {
+          const result = await fn(args);
+          span2.setAttribute("output.value", safeStringify3(result));
+          span2.setStatus({ code: import_api9.SpanStatusCode.OK });
+          return result;
+        } catch (err) {
+          recordError(span2, err);
+          throw err;
+        } finally {
+          span2.end();
+        }
+      }
+    );
+  };
+}
+function wrapNamespace(target, path4) {
+  return new Proxy(target, {
+    get(obj, prop, receiver) {
+      const value = Reflect.get(obj, prop, receiver);
+      if (typeof prop === "symbol" || String(prop).startsWith("_")) return value;
+      const currentPath = [...path4, String(prop)];
+      const pathStr = currentPath.join(".");
+      if (pathStr === "chat.completions.create" && typeof value === "function") {
+        return tracedChatCompletionsCreate(value.bind(obj));
+      }
+      if (pathStr === "responses.create" && typeof value === "function") {
+        return tracedResponsesCreate(value.bind(obj));
+      }
+      if (value && typeof value === "object" && !Array.isArray(value) && isNamespace(currentPath)) {
+        return wrapNamespace(value, currentPath);
+      }
+      return value;
+    }
+  });
+}
+function isNamespace(path4) {
+  if (path4.length > 3) return false;
+  const key = path4[path4.length - 1];
+  return ["chat", "completions", "responses", "beta"].includes(key);
+}
+function tracedChatCompletionsCreate(original) {
+  return function(opts, ...rest) {
+    const tracer = import_api9.trace.getTracer(TRACER_NAME3);
+    const model = opts?.model ?? "";
+    const messages = opts?.messages ?? [];
+    const isStream = opts?.stream === true;
+    const span2 = tracer.startSpan("openai.chat.completions.create", {
+      attributes: {
+        "neatlogs.span.kind": "LLM",
+        "neatlogs.llm.provider": "openai",
+        "neatlogs.llm.system": "openai",
+        "neatlogs.llm.model_name": model,
+        "neatlogs.llm.is_streaming": isStream
+      }
+    }, import_api9.context.active());
+    for (let i = 0; i < messages.length; i++) {
+      const msg = messages[i];
+      span2.setAttribute(`neatlogs.llm.input_messages.${i}.role`, msg.role ?? "");
+      if (typeof msg.content === "string") {
+        span2.setAttribute(`neatlogs.llm.input_messages.${i}.content`, msg.content);
+      } else if (msg.content) {
+        span2.setAttribute(`neatlogs.llm.input_messages.${i}.content`, safeStringify3(msg.content));
+      }
+      if (msg.tool_call_id) {
+        span2.setAttribute(`neatlogs.llm.input_messages.${i}.tool_call_id`, msg.tool_call_id);
+      }
+    }
+    if (opts?.tools) {
+      for (let i = 0; i < opts.tools.length; i++) {
+        const fn = opts.tools[i]?.function ?? {};
+        span2.setAttribute(`neatlogs.llm.tools.${i}.name`, fn.name ?? "");
+        if (fn.description) span2.setAttribute(`neatlogs.llm.tools.${i}.description`, fn.description);
+        if (fn.parameters) span2.setAttribute(`neatlogs.llm.tools.${i}.input_schema`, safeStringify3(fn.parameters));
+      }
+    }
+    setInvocationParams(span2, opts);
+    if (isStream) {
+      opts = { ...opts };
+      const streamOpts = opts.stream_options ?? {};
+      if (!streamOpts.include_usage) {
+        opts.stream_options = { ...streamOpts, include_usage: true };
+      }
+    }
+    const ctx = import_api9.trace.setSpan(import_api9.context.active(), span2);
+    const promise = import_api9.context.with(ctx, () => original(opts, ...rest));
+    return promise.then(
+      (response) => {
+        if (isStream) {
+          return wrapAsyncIterableStream(response, span2);
+        }
+        finalizeChatResponse(span2, response);
+        return response;
+      },
+      (err) => {
+        recordError(span2, err);
+        throw err;
+      }
+    );
+  };
+}
+function tracedResponsesCreate(original) {
+  return function(opts, ...rest) {
+    const tracer = import_api9.trace.getTracer(TRACER_NAME3);
+    const model = opts?.model ?? "";
+    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,
+        "input.value": safeStringify3(opts?.input ?? "")
+      }
+    }, import_api9.context.active());
+    const ctx = import_api9.trace.setSpan(import_api9.context.active(), span2);
+    const promise = import_api9.context.with(ctx, () => 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);
+        }
+        span2.setStatus({ code: import_api9.SpanStatusCode.OK });
+        span2.end();
+        return response;
+      },
+      (err) => {
+        recordError(span2, err);
+        throw err;
+      }
+    );
+  };
+}
+function wrapAsyncIterableStream(stream, span2) {
+  const chunks = [];
+  const originalAsyncIterator = stream[Symbol.asyncIterator]?.bind(stream);
+  if (!originalAsyncIterator) {
+    span2.setStatus({ code: import_api9.SpanStatusCode.OK });
+    span2.end();
+    return stream;
+  }
+  const wrapped = Object.create(Object.getPrototypeOf(stream));
+  Object.assign(wrapped, stream);
+  wrapped[Symbol.asyncIterator] = function() {
+    const iterator = originalAsyncIterator();
+    return {
+      async next() {
+        try {
+          const result = await iterator.next();
+          if (result.done) {
+            finalizeStreamChunks(span2, chunks);
+            return result;
+          }
+          chunks.push(result.value);
+          return result;
+        } catch (err) {
+          recordError(span2, err);
+          throw err;
+        }
+      },
+      async return(value) {
+        finalizeStreamChunks(span2, chunks);
+        return iterator.return?.(value) ?? { done: true, value: void 0 };
+      },
+      async throw(err) {
+        recordError(span2, err);
+        return iterator.throw?.(err) ?? { done: true, value: void 0 };
+      }
+    };
+  };
+  return wrapped;
+}
+function finalizeStreamChunks(span2, chunks) {
+  const textParts = [];
+  const toolCallsAcc = {};
+  let finishReason = "";
+  let model = "";
+  let usage = null;
+  for (const chunk of chunks) {
+    if (!chunk?.choices?.length) {
+      if (chunk?.usage) usage = chunk.usage;
+      continue;
+    }
+    const choice = chunk.choices[0];
+    const delta = choice?.delta;
+    if (delta?.content) textParts.push(delta.content);
+    if (delta?.tool_calls) {
+      for (const tc of delta.tool_calls) {
+        const idx = tc.index ?? 0;
+        if (!toolCallsAcc[idx]) toolCallsAcc[idx] = { id: "", name: "", arguments: "" };
+        if (tc.id) toolCallsAcc[idx].id = tc.id;
+        if (tc.function?.name) toolCallsAcc[idx].name = tc.function.name;
+        if (tc.function?.arguments) toolCallsAcc[idx].arguments += tc.function.arguments;
+      }
+    }
+    if (choice?.finish_reason) finishReason = choice.finish_reason;
+    if (chunk?.model) model = chunk.model;
+  }
+  const fullText = textParts.join("");
+  if (fullText) {
+    span2.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
+    span2.setAttribute("neatlogs.llm.output_messages.0.content", fullText);
+  }
+  let j = 0;
+  for (const tc of Object.values(toolCallsAcc)) {
+    span2.setAttribute(`neatlogs.llm.tool_calls.${j}.id`, tc.id);
+    span2.setAttribute(`neatlogs.llm.tool_calls.${j}.name`, tc.name);
+    span2.setAttribute(`neatlogs.llm.tool_calls.${j}.arguments`, tc.arguments);
+    j++;
+  }
+  if (model) span2.setAttribute("neatlogs.llm.model_name", model);
+  if (finishReason) span2.setAttribute("neatlogs.llm.finish_reason", finishReason);
+  if (usage) {
+    if (usage.prompt_tokens != null) span2.setAttribute("neatlogs.llm.token_count.prompt", usage.prompt_tokens);
+    if (usage.completion_tokens != null) span2.setAttribute("neatlogs.llm.token_count.completion", usage.completion_tokens);
+    if (usage.total_tokens != null) span2.setAttribute("neatlogs.llm.token_count.total", usage.total_tokens);
+    if (usage.prompt_tokens_details?.cached_tokens != null) {
+      span2.setAttribute("neatlogs.llm.token_count.cache_read", usage.prompt_tokens_details.cached_tokens);
+    }
+    if (usage.completion_tokens_details?.reasoning_tokens != null) {
+      span2.setAttribute("neatlogs.llm.token_count.reasoning", usage.completion_tokens_details.reasoning_tokens);
+    }
+  }
+  span2.setStatus({ code: import_api9.SpanStatusCode.OK });
+  span2.end();
+}
+function finalizeChatResponse(span2, response) {
+  const choices = response?.choices ?? [];
+  for (let i = 0; i < choices.length; i++) {
+    const message = choices[i]?.message;
+    if (!message) continue;
+    span2.setAttribute(`neatlogs.llm.output_messages.${i}.role`, "assistant");
+    if (message.content) {
+      span2.setAttribute(`neatlogs.llm.output_messages.${i}.content`, message.content);
+    }
+    if (message.tool_calls) {
+      for (let j = 0; j < message.tool_calls.length; j++) {
+        const tc = message.tool_calls[j];
+        span2.setAttribute(`neatlogs.llm.tool_calls.${j}.id`, tc.id ?? "");
+        span2.setAttribute(`neatlogs.llm.tool_calls.${j}.name`, tc.function?.name ?? "");
+        span2.setAttribute(`neatlogs.llm.tool_calls.${j}.arguments`, tc.function?.arguments ?? "");
+      }
+    }
+    if (choices[i].finish_reason) {
+      span2.setAttribute("neatlogs.llm.finish_reason", choices[i].finish_reason);
+    }
+  }
+  const usage = response?.usage;
+  if (usage) {
+    if (usage.prompt_tokens != null) span2.setAttribute("neatlogs.llm.token_count.prompt", usage.prompt_tokens);
+    if (usage.completion_tokens != null) span2.setAttribute("neatlogs.llm.token_count.completion", usage.completion_tokens);
+    if (usage.total_tokens != null) span2.setAttribute("neatlogs.llm.token_count.total", usage.total_tokens);
+    if (usage.prompt_tokens_details?.cached_tokens != null) {
+      span2.setAttribute("neatlogs.llm.token_count.cache_read", usage.prompt_tokens_details.cached_tokens);
+    }
+    if (usage.completion_tokens_details?.reasoning_tokens != null) {
+      span2.setAttribute("neatlogs.llm.token_count.reasoning", usage.completion_tokens_details.reasoning_tokens);
+    }
+  }
+  if (response?.model) span2.setAttribute("neatlogs.llm.model_name", response.model);
+  span2.setStatus({ code: import_api9.SpanStatusCode.OK });
+  span2.end();
+}
+function setInvocationParams(span2, opts) {
+  if (opts?.temperature != null) span2.setAttribute("neatlogs.llm.temperature", opts.temperature);
+  if (opts?.top_p != null) span2.setAttribute("neatlogs.llm.top_p", opts.top_p);
+  if (opts?.max_tokens != null) span2.setAttribute("neatlogs.llm.max_tokens", opts.max_tokens);
+  if (opts?.frequency_penalty != null) span2.setAttribute("neatlogs.llm.frequency_penalty", opts.frequency_penalty);
+  if (opts?.presence_penalty != null) span2.setAttribute("neatlogs.llm.presence_penalty", opts.presence_penalty);
+  if (opts?.stop) span2.setAttribute("neatlogs.llm.stop_sequences", safeStringify3(opts.stop));
+}
+function safeStringify3(value) {
+  try {
+    return typeof value === "string" ? value : JSON.stringify(value);
+  } catch {
+    return "";
+  }
+}
+function recordError(span2, err) {
+  if (err instanceof Error) {
+    span2.setStatus({ code: import_api9.SpanStatusCode.ERROR, message: err.message });
+    span2.recordException(err);
+  } else {
+    span2.setStatus({ code: import_api9.SpanStatusCode.ERROR, message: String(err) });
+  }
+  span2.end();
+}
+
+// src/anthropic.ts
+var import_api10 = require("@opentelemetry/api");
+var TRACER_NAME4 = "neatlogs.anthropic";
+function wrapAnthropic(client) {
+  return wrapNamespace2(client, []);
+}
+function traceTool2(name, fn) {
+  return async function tracedTool(input) {
+    const tracer = import_api10.trace.getTracer(TRACER_NAME4);
+    return tracer.startActiveSpan(
+      `tool.${name}`,
+      {
+        attributes: {
+          "neatlogs.span.kind": "TOOL",
+          "neatlogs.tool.name": name,
+          "input.value": safeStringify4(input)
+        }
+      },
+      import_api10.context.active(),
+      async (span2) => {
+        try {
+          const result = await fn(input);
+          span2.setAttribute("output.value", safeStringify4(result));
+          span2.setStatus({ code: import_api10.SpanStatusCode.OK });
+          return result;
+        } catch (err) {
+          recordError2(span2, err);
+          throw err;
+        } finally {
+          span2.end();
+        }
+      }
+    );
+  };
+}
+function wrapNamespace2(target, path4) {
+  return new Proxy(target, {
+    get(obj, prop, receiver) {
+      const value = Reflect.get(obj, prop, receiver);
+      if (typeof prop === "symbol" || String(prop).startsWith("_")) return value;
+      const currentPath = [...path4, String(prop)];
+      const pathStr = currentPath.join(".");
+      if (pathStr === "messages.create" && typeof value === "function") {
+        return tracedMessagesCreate(value.bind(obj));
+      }
+      if (pathStr === "messages.stream" && typeof value === "function") {
+        return tracedMessagesStream(value.bind(obj));
+      }
+      if (value && typeof value === "object" && !Array.isArray(value) && isNamespace2(currentPath)) {
+        return wrapNamespace2(value, currentPath);
+      }
+      return value;
+    }
+  });
+}
+function isNamespace2(path4) {
+  if (path4.length > 3) return false;
+  const key = path4[path4.length - 1];
+  return ["messages", "beta"].includes(key);
+}
+function tracedMessagesCreate(original) {
+  return function(opts, ...rest) {
+    const tracer = import_api10.trace.getTracer(TRACER_NAME4);
+    const model = opts?.model ?? "";
+    const messages = opts?.messages ?? [];
+    const isStream = opts?.stream === true;
+    const span2 = tracer.startSpan("anthropic.messages.create", {
+      attributes: {
+        "neatlogs.span.kind": "LLM",
+        "neatlogs.llm.provider": "anthropic",
+        "neatlogs.llm.system": "anthropic",
+        "neatlogs.llm.model_name": model,
+        "neatlogs.llm.is_streaming": isStream
+      }
+    }, import_api10.context.active());
+    setInputMessages(span2, opts?.system, messages);
+    setTools(span2, opts?.tools);
+    setInvocationParams2(span2, opts);
+    const ctx = import_api10.trace.setSpan(import_api10.context.active(), span2);
+    const promise = import_api10.context.with(ctx, () => original(opts, ...rest));
+    return promise.then(
+      (response) => {
+        if (isStream) {
+          return wrapStreamIterable(response, span2);
+        }
+        finalizeMessageResponse(span2, response);
+        return response;
+      },
+      (err) => {
+        recordError2(span2, err);
+        throw err;
+      }
+    );
+  };
+}
+function tracedMessagesStream(original) {
+  return function(opts, ...rest) {
+    const tracer = import_api10.trace.getTracer(TRACER_NAME4);
+    const model = opts?.model ?? "";
+    const messages = opts?.messages ?? [];
+    const span2 = tracer.startSpan("anthropic.messages.stream", {
+      attributes: {
+        "neatlogs.span.kind": "LLM",
+        "neatlogs.llm.provider": "anthropic",
+        "neatlogs.llm.system": "anthropic",
+        "neatlogs.llm.model_name": model,
+        "neatlogs.llm.is_streaming": true
+      }
+    }, import_api10.context.active());
+    setInputMessages(span2, opts?.system, messages);
+    setTools(span2, opts?.tools);
+    setInvocationParams2(span2, opts);
+    const ctx = import_api10.trace.setSpan(import_api10.context.active(), span2);
+    const messageStream = import_api10.context.with(ctx, () => original(opts, ...rest));
+    return wrapMessageStream(messageStream, span2);
+  };
+}
+function wrapStreamIterable(stream, span2) {
+  const events = [];
+  const originalAsyncIterator = stream[Symbol.asyncIterator]?.bind(stream);
+  if (!originalAsyncIterator) {
+    span2.setStatus({ code: import_api10.SpanStatusCode.OK });
+    span2.end();
+    return stream;
+  }
+  const wrapped = Object.create(Object.getPrototypeOf(stream));
+  Object.assign(wrapped, stream);
+  wrapped[Symbol.asyncIterator] = function() {
+    const iterator = originalAsyncIterator();
+    return {
+      async next() {
+        try {
+          const result = await iterator.next();
+          if (result.done) {
+            finalizeStreamEvents(span2, events);
+            return result;
+          }
+          events.push(result.value);
+          return result;
+        } catch (err) {
+          recordError2(span2, err);
+          throw err;
+        }
+      },
+      async return(value) {
+        finalizeStreamEvents(span2, events);
+        return iterator.return?.(value) ?? { done: true, value: void 0 };
+      },
+      async throw(err) {
+        recordError2(span2, err);
+        return iterator.throw?.(err) ?? { done: true, value: void 0 };
+      }
+    };
+  };
+  if (typeof stream.finalMessage === "function") {
+    const origFinal = stream.finalMessage.bind(stream);
+    wrapped.finalMessage = async function() {
+      return origFinal();
+    };
+  }
+  return wrapped;
+}
+function wrapMessageStream(messageStream, span2) {
+  const origOn = messageStream.on?.bind(messageStream);
+  if (origOn) {
+    origOn("end", () => {
+      const finalMsg = messageStream._finalMessage ?? messageStream.currentMessage;
+      if (finalMsg) {
+        finalizeMessageResponse(span2, finalMsg);
+      } else {
+        span2.setStatus({ code: import_api10.SpanStatusCode.OK });
+        span2.end();
+      }
+    });
+    origOn("error", (err) => {
+      if (span2.isRecording()) recordError2(span2, err);
+    });
+  }
+  if (typeof messageStream.finalMessage === "function") {
+    const origFinal = messageStream.finalMessage.bind(messageStream);
+    messageStream.finalMessage = async function() {
+      const result = await origFinal();
+      if (span2.isRecording()) {
+        finalizeMessageResponse(span2, result);
+      }
+      return result;
+    };
+  }
+  return messageStream;
+}
+function finalizeStreamEvents(span2, events) {
+  const textParts = [];
+  const thinkingParts = [];
+  const toolCalls = [];
+  let currentToolInput = "";
+  let currentToolId = "";
+  let currentToolName = "";
+  let usage = null;
+  let model = "";
+  let stopReason = "";
+  for (const event of events) {
+    const type = event?.type ?? "";
+    if (type === "content_block_delta") {
+      const delta = event?.delta;
+      if (delta?.type === "text_delta" && delta.text) textParts.push(delta.text);
+      else if (delta?.type === "thinking_delta" && delta.thinking) thinkingParts.push(delta.thinking);
+      else if (delta?.type === "input_json_delta" && delta.partial_json) currentToolInput += delta.partial_json;
+    } else if (type === "content_block_start") {
+      const block = event?.content_block;
+      if (block?.type === "tool_use") {
+        currentToolId = block.id ?? "";
+        currentToolName = block.name ?? "";
+        currentToolInput = "";
+      }
+    } else if (type === "content_block_stop") {
+      if (currentToolName) {
+        toolCalls.push({ id: currentToolId, name: currentToolName, input: currentToolInput });
+        currentToolId = "";
+        currentToolName = "";
+        currentToolInput = "";
+      }
+    } else if (type === "message_start") {
+      const msg = event?.message;
+      if (msg?.model) model = msg.model;
+      if (msg?.usage) usage = msg.usage;
+    } else if (type === "message_delta") {
+      const delta = event?.delta;
+      if (delta?.stop_reason) stopReason = delta.stop_reason;
+      if (event?.usage) usage = { ...usage ?? {}, ...event.usage };
+    }
+  }
+  const fullText = textParts.join("");
+  if (fullText) {
+    span2.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
+    span2.setAttribute("neatlogs.llm.output_messages.0.content", fullText);
+  }
+  const thinking = thinkingParts.join("");
+  if (thinking) {
+    span2.setAttribute("neatlogs.llm.output_messages.0.thinking", thinking);
+  }
+  for (let j = 0; j < toolCalls.length; j++) {
+    span2.setAttribute(`neatlogs.llm.tool_calls.${j}.id`, toolCalls[j].id);
+    span2.setAttribute(`neatlogs.llm.tool_calls.${j}.name`, toolCalls[j].name);
+    span2.setAttribute(`neatlogs.llm.tool_calls.${j}.arguments`, toolCalls[j].input);
+  }
+  if (model) span2.setAttribute("neatlogs.llm.model_name", model);
+  if (stopReason) span2.setAttribute("neatlogs.llm.stop_reason", stopReason);
+  setUsageAttrs(span2, usage);
+  span2.setStatus({ code: import_api10.SpanStatusCode.OK });
+  span2.end();
+}
+function finalizeMessageResponse(span2, response) {
+  const content = response?.content ?? [];
+  const textParts = [];
+  const thinkingParts = [];
+  const toolCalls = [];
+  for (const block of content) {
+    if (block.type === "text" && block.text) textParts.push(block.text);
+    else if (block.type === "thinking" && block.thinking) thinkingParts.push(block.thinking);
+    else if (block.type === "tool_use") {
+      toolCalls.push({
+        id: block.id ?? "",
+        name: block.name ?? "",
+        input: safeStringify4(block.input ?? {})
+      });
+    }
+  }
+  if (textParts.length) {
+    span2.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
+    span2.setAttribute("neatlogs.llm.output_messages.0.content", textParts.join(""));
+  }
+  if (thinkingParts.length) {
+    span2.setAttribute("neatlogs.llm.output_messages.0.thinking", thinkingParts.join(""));
+  }
+  for (let j = 0; j < toolCalls.length; j++) {
+    span2.setAttribute(`neatlogs.llm.tool_calls.${j}.id`, toolCalls[j].id);
+    span2.setAttribute(`neatlogs.llm.tool_calls.${j}.name`, toolCalls[j].name);
+    span2.setAttribute(`neatlogs.llm.tool_calls.${j}.arguments`, toolCalls[j].input);
+  }
+  setUsageAttrs(span2, response?.usage);
+  if (response?.model) span2.setAttribute("neatlogs.llm.model_name", response.model);
+  if (response?.stop_reason) span2.setAttribute("neatlogs.llm.stop_reason", response.stop_reason);
+  span2.setStatus({ code: import_api10.SpanStatusCode.OK });
+  span2.end();
+}
+function setInputMessages(span2, system, messages) {
+  let idx = 0;
+  if (system) {
+    const content = typeof system === "string" ? system : safeStringify4(system);
+    span2.setAttribute(`neatlogs.llm.input_messages.${idx}.role`, "system");
+    span2.setAttribute(`neatlogs.llm.input_messages.${idx}.content`, content);
+    idx++;
+  }
+  for (const msg of messages) {
+    span2.setAttribute(`neatlogs.llm.input_messages.${idx}.role`, msg.role ?? "");
+    if (typeof msg.content === "string") {
+      span2.setAttribute(`neatlogs.llm.input_messages.${idx}.content`, msg.content);
+    } else if (msg.content) {
+      span2.setAttribute(`neatlogs.llm.input_messages.${idx}.content`, safeStringify4(msg.content));
+    }
+    idx++;
+  }
+}
+function setTools(span2, tools) {
+  if (!tools) return;
+  for (let i = 0; i < tools.length; i++) {
+    const tool = tools[i];
+    span2.setAttribute(`neatlogs.llm.tools.${i}.name`, tool.name ?? "");
+    if (tool.description) span2.setAttribute(`neatlogs.llm.tools.${i}.description`, tool.description);
+    if (tool.input_schema) span2.setAttribute(`neatlogs.llm.tools.${i}.input_schema`, safeStringify4(tool.input_schema));
+  }
+}
+function setInvocationParams2(span2, opts) {
+  if (opts?.temperature != null) span2.setAttribute("neatlogs.llm.temperature", opts.temperature);
+  if (opts?.top_p != null) span2.setAttribute("neatlogs.llm.top_p", opts.top_p);
+  if (opts?.top_k != null) span2.setAttribute("neatlogs.llm.top_k", opts.top_k);
+  if (opts?.max_tokens != null) span2.setAttribute("neatlogs.llm.max_tokens", opts.max_tokens);
+  if (opts?.stop_sequences) span2.setAttribute("neatlogs.llm.stop_sequences", safeStringify4(opts.stop_sequences));
+}
+function setUsageAttrs(span2, usage) {
+  if (!usage) return;
+  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.cache_read_input_tokens != null) span2.setAttribute("neatlogs.llm.token_count.cache_read", usage.cache_read_input_tokens);
+  if (usage.cache_creation_input_tokens != null) span2.setAttribute("neatlogs.llm.token_count.cache_write", usage.cache_creation_input_tokens);
+}
+function safeStringify4(value) {
+  try {
+    return typeof value === "string" ? value : JSON.stringify(value);
+  } catch {
+    return "";
+  }
+}
+function recordError2(span2, err) {
+  if (err instanceof Error) {
+    span2.setStatus({ code: import_api10.SpanStatusCode.ERROR, message: err.message });
+    span2.recordException(err);
+  } else {
+    span2.setStatus({ code: import_api10.SpanStatusCode.ERROR, message: String(err) });
+  }
+  span2.end();
+}
+
+// src/langchain.ts
+var import_api11 = require("@opentelemetry/api");
+var TRACER_NAME5 = "neatlogs.langchain";
+function langchainHandler(opts) {
+  return new NeatlogsCallbackHandler(opts);
+}
+var NeatlogsCallbackHandler = class {
+  name = "neatlogs";
+  _spans = /* @__PURE__ */ new Map();
+  _workflowName;
+  constructor(opts) {
+    this._workflowName = opts?.workflowName;
+  }
+  // --- Chain/Graph callbacks ---
+  async handleChainStart(serialized, inputs, runId, parentRunId, tags, metadata) {
+    const tracer = import_api11.trace.getTracer(TRACER_NAME5);
+    const name = serialized?.name ?? serialized?.id?.at(-1) ?? "chain";
+    const parentSpan = parentRunId ? this._spans.get(parentRunId) : void 0;
+    const parentCtx = parentSpan ? import_api11.trace.setSpan(import_api11.context.active(), parentSpan) : import_api11.context.active();
+    const attrs = {
+      "neatlogs.span.kind": "CHAIN",
+      "neatlogs.chain.name": name
+    };
+    if (this._workflowName) attrs["neatlogs.workflow.name"] = this._workflowName;
+    if (inputs) attrs["input.value"] = safeStringify5(inputs).slice(0, 1e4);
+    if (tags?.length) attrs["neatlogs.tags"] = tags.join(",");
+    const span2 = tracer.startSpan(`langchain.chain.${name}`, { attributes: attrs }, parentCtx);
+    this._spans.set(runId, span2);
+  }
+  async handleChainEnd(outputs, runId) {
+    const span2 = this._spans.get(runId);
+    if (!span2) return;
+    if (outputs) span2.setAttribute("output.value", safeStringify5(outputs).slice(0, 1e4));
+    span2.setStatus({ code: import_api11.SpanStatusCode.OK });
+    span2.end();
+    this._spans.delete(runId);
+  }
+  async handleChainError(error, runId) {
+    const span2 = this._spans.get(runId);
+    if (!span2) return;
+    span2.setStatus({ code: import_api11.SpanStatusCode.ERROR, message: error.message });
+    span2.recordException(error);
+    span2.end();
+    this._spans.delete(runId);
+  }
+  // --- LLM callbacks ---
+  async handleLLMStart(serialized, prompts, runId, parentRunId, extraParams) {
+    const tracer = import_api11.trace.getTracer(TRACER_NAME5);
+    const model = serialized?.kwargs?.model_name ?? serialized?.kwargs?.model ?? serialized?.name ?? "";
+    const parentSpan = parentRunId ? this._spans.get(parentRunId) : void 0;
+    const parentCtx = parentSpan ? import_api11.trace.setSpan(import_api11.context.active(), parentSpan) : import_api11.context.active();
+    const attrs = {
+      "neatlogs.span.kind": "LLM",
+      "neatlogs.llm.provider": detectProvider(model),
+      "neatlogs.llm.model_name": model
+    };
+    for (let i = 0; i < prompts.length; i++) {
+      attrs[`neatlogs.llm.input_messages.${i}.role`] = "user";
+      attrs[`neatlogs.llm.input_messages.${i}.content`] = prompts[i].slice(0, 1e4);
+    }
+    if (extraParams?.invocation_params) {
+      const p = extraParams.invocation_params;
+      if (p.temperature != null) attrs["neatlogs.llm.temperature"] = p.temperature;
+      if (p.max_tokens != null) attrs["neatlogs.llm.max_tokens"] = p.max_tokens;
+      if (p.model_name) attrs["neatlogs.llm.model_name"] = p.model_name;
+    }
+    const span2 = tracer.startSpan("langchain.llm", { attributes: attrs }, parentCtx);
+    this._spans.set(runId, span2);
+  }
+  async handleChatModelStart(serialized, messages, runId, parentRunId, extraParams) {
+    const tracer = import_api11.trace.getTracer(TRACER_NAME5);
+    const model = serialized?.kwargs?.model_name ?? serialized?.kwargs?.model ?? serialized?.name ?? "";
+    const parentSpan = parentRunId ? this._spans.get(parentRunId) : void 0;
+    const parentCtx = parentSpan ? import_api11.trace.setSpan(import_api11.context.active(), parentSpan) : import_api11.context.active();
+    const attrs = {
+      "neatlogs.span.kind": "LLM",
+      "neatlogs.llm.provider": detectProvider(model),
+      "neatlogs.llm.model_name": model
+    };
+    const flatMessages = messages.flat();
+    for (let i = 0; i < flatMessages.length; i++) {
+      const msg = flatMessages[i];
+      const role = msg?.role ?? msg?._getType?.() ?? msg?.constructor?.name ?? "unknown";
+      const content = typeof msg?.content === "string" ? msg.content : safeStringify5(msg?.content);
+      attrs[`neatlogs.llm.input_messages.${i}.role`] = mapRole(role);
+      attrs[`neatlogs.llm.input_messages.${i}.content`] = content.slice(0, 1e4);
+    }
+    if (extraParams?.invocation_params) {
+      const p = extraParams.invocation_params;
+      if (p.temperature != null) attrs["neatlogs.llm.temperature"] = p.temperature;
+      if (p.max_tokens != null) attrs["neatlogs.llm.max_tokens"] = p.max_tokens;
+      if (p.model_name) attrs["neatlogs.llm.model_name"] = p.model_name;
+    }
+    const span2 = tracer.startSpan("langchain.chat_model", { attributes: attrs }, parentCtx);
+    this._spans.set(runId, span2);
+  }
+  async handleLLMEnd(output, runId) {
+    const span2 = this._spans.get(runId);
+    if (!span2) return;
+    const generations = output?.generations ?? [];
+    for (let i = 0; i < generations.length; i++) {
+      const gen = generations[i];
+      if (!Array.isArray(gen)) continue;
+      for (let j = 0; j < gen.length; j++) {
+        const msg = gen[j]?.message ?? gen[j];
+        const content = msg?.content ?? msg?.text ?? "";
+        span2.setAttribute(`neatlogs.llm.output_messages.${i}.role`, "assistant");
+        span2.setAttribute(`neatlogs.llm.output_messages.${i}.content`, String(content).slice(0, 1e4));
+        const toolCalls = msg?.tool_calls ?? msg?.additional_kwargs?.tool_calls;
+        if (toolCalls && Array.isArray(toolCalls)) {
+          for (let k = 0; k < toolCalls.length; k++) {
+            const tc = toolCalls[k];
+            span2.setAttribute(`neatlogs.llm.tool_calls.${k}.id`, tc.id ?? "");
+            span2.setAttribute(`neatlogs.llm.tool_calls.${k}.name`, tc.name ?? tc.function?.name ?? "");
+            span2.setAttribute(`neatlogs.llm.tool_calls.${k}.arguments`, tc.args ? safeStringify5(tc.args) : tc.function?.arguments ?? "");
+          }
+        }
+      }
+    }
+    const usage = output?.llmOutput?.tokenUsage ?? output?.llmOutput?.usage;
+    if (usage) {
+      if (usage.promptTokens != null || usage.prompt_tokens != null) {
+        span2.setAttribute("neatlogs.llm.token_count.prompt", usage.promptTokens ?? usage.prompt_tokens);
+      }
+      if (usage.completionTokens != null || usage.completion_tokens != null) {
+        span2.setAttribute("neatlogs.llm.token_count.completion", usage.completionTokens ?? usage.completion_tokens);
+      }
+      if (usage.totalTokens != null || usage.total_tokens != null) {
+        span2.setAttribute("neatlogs.llm.token_count.total", usage.totalTokens ?? usage.total_tokens);
+      }
+    }
+    span2.setStatus({ code: import_api11.SpanStatusCode.OK });
+    span2.end();
+    this._spans.delete(runId);
+  }
+  async handleLLMNewToken(_token, _idx, _runId) {
+  }
+  async handleLLMError(error, runId) {
+    const span2 = this._spans.get(runId);
+    if (!span2) return;
+    span2.setStatus({ code: import_api11.SpanStatusCode.ERROR, message: error.message });
+    span2.recordException(error);
+    span2.end();
+    this._spans.delete(runId);
+  }
+  // --- Tool callbacks ---
+  async handleToolStart(serialized, input, runId, parentRunId, _tags, _metadata, runName, toolCallId) {
+    const tracer = import_api11.trace.getTracer(TRACER_NAME5);
+    const name = serialized?.name || runName || (Array.isArray(serialized?.id) ? serialized.id[serialized.id.length - 1] : void 0) || "tool";
+    const parentSpan = parentRunId ? this._spans.get(parentRunId) : void 0;
+    const parentCtx = parentSpan ? import_api11.trace.setSpan(import_api11.context.active(), parentSpan) : import_api11.context.active();
+    const attrs = {
+      "neatlogs.span.kind": "TOOL",
+      "neatlogs.tool.name": name,
+      "input.value": String(input).slice(0, 1e4)
+    };
+    if (toolCallId) attrs["neatlogs.tool_call.id"] = toolCallId;
+    const span2 = tracer.startSpan(`langchain.tool.${name}`, { attributes: attrs }, parentCtx);
+    this._spans.set(runId, span2);
+  }
+  async handleToolEnd(output, runId) {
+    const span2 = this._spans.get(runId);
+    if (!span2) return;
+    span2.setAttribute("output.value", String(output).slice(0, 1e4));
+    span2.setStatus({ code: import_api11.SpanStatusCode.OK });
+    span2.end();
+    this._spans.delete(runId);
+  }
+  async handleToolError(error, runId) {
+    const span2 = this._spans.get(runId);
+    if (!span2) return;
+    span2.setStatus({ code: import_api11.SpanStatusCode.ERROR, message: error.message });
+    span2.recordException(error);
+    span2.end();
+    this._spans.delete(runId);
+  }
+  // --- Retriever callbacks ---
+  async handleRetrieverStart(serialized, query, runId, parentRunId) {
+    const tracer = import_api11.trace.getTracer(TRACER_NAME5);
+    const name = serialized?.name ?? "retriever";
+    const parentSpan = parentRunId ? this._spans.get(parentRunId) : void 0;
+    const parentCtx = parentSpan ? import_api11.trace.setSpan(import_api11.context.active(), parentSpan) : import_api11.context.active();
+    const attrs = {
+      "neatlogs.span.kind": "RETRIEVER",
+      "neatlogs.retriever.name": name,
+      "input.value": query.slice(0, 1e4)
+    };
+    const span2 = tracer.startSpan(`langchain.retriever.${name}`, { attributes: attrs }, parentCtx);
+    this._spans.set(runId, span2);
+  }
+  async handleRetrieverEnd(documents, runId) {
+    const span2 = this._spans.get(runId);
+    if (!span2) return;
+    if (documents?.length) {
+      span2.setAttribute("neatlogs.retriever.document_count", documents.length);
+      for (let i = 0; i < Math.min(documents.length, 10); i++) {
+        const doc = documents[i];
+        if (doc?.pageContent) {
+          span2.setAttribute(`neatlogs.retriever.documents.${i}.content`, doc.pageContent.slice(0, 2e3));
+        }
+      }
+    }
+    span2.setStatus({ code: import_api11.SpanStatusCode.OK });
+    span2.end();
+    this._spans.delete(runId);
+  }
+  async handleRetrieverError(error, runId) {
+    const span2 = this._spans.get(runId);
+    if (!span2) return;
+    span2.setStatus({ code: import_api11.SpanStatusCode.ERROR, message: error.message });
+    span2.recordException(error);
+    span2.end();
+    this._spans.delete(runId);
+  }
+};
+function detectProvider(model) {
+  const m = model.toLowerCase();
+  if (m.includes("gpt") || m.includes("o1") || m.includes("o3") || m.includes("o4")) return "openai";
+  if (m.includes("claude")) return "anthropic";
+  if (m.includes("gemini")) return "google";
+  if (m.includes("command")) return "cohere";
+  if (m.includes("llama") || m.includes("mixtral")) return "meta";
+  return "unknown";
+}
+function mapRole(role) {
+  const r = role.toLowerCase();
+  if (r === "human" || r === "humanmessage") return "user";
+  if (r === "ai" || r === "aimessage") return "assistant";
+  if (r === "system" || r === "systemmessage") return "system";
+  if (r === "function" || r === "functionmessage") return "function";
+  if (r === "tool" || r === "toolmessage") return "tool";
+  return role;
+}
+function safeStringify5(value) {
+  try {
+    return typeof value === "string" ? value : JSON.stringify(value);
+  } catch {
+    return "";
+  }
+}
+
+// src/strands.ts
+var PATCH_FLAG = "_neatlogs_patched";
+function strandsHooks(agent) {
+  installEventHookFromAgent(agent);
+  if (agent && typeof agent === "object") {
+    try {
+      Object.defineProperty(agent, PATCH_FLAG, {
+        value: true,
+        enumerable: false,
+        configurable: true
+      });
+    } catch {
+      agent[PATCH_FLAG] = true;
+    }
+  }
+  return agent;
+}
+function installEventHookFromAgent(agent) {
+  const tracer = agent?._tracer;
+  const proto = tracer ? Object.getPrototypeOf(tracer) : void 0;
+  if (!proto || typeof proto._addEvent !== "function") return;
+  if (proto._addEvent[PATCH_FLAG]) return;
+  const orig = proto._addEvent;
+  function patchedAddEvent(span2, eventName, eventAttributes) {
+    const result = orig.call(this, span2, eventName, eventAttributes);
+    try {
+      enrichSpanFromEvent(span2, eventName, eventAttributes || {});
+    } catch {
+    }
+    return result;
+  }
+  patchedAddEvent[PATCH_FLAG] = true;
+  proto._addEvent = patchedAddEvent;
+}
+function enrichSpanFromEvent(span2, eventName, attrs) {
+  if (!span2 || typeof span2.setAttribute !== "function") return;
+  if (typeof span2.isRecording === "function" && !span2.isRecording()) return;
+  const isTool = readSpanOp(span2) === "execute_tool";
+  if (eventName.startsWith("gen_ai.") && eventName.endsWith(".message")) {
+    const role = eventName.slice("gen_ai.".length, -".message".length);
+    const content = flattenStrandsContent(attrs.content);
+    if (content) {
+      if (isTool) {
+        span2.setAttribute("input.value", content);
+        span2.setAttribute("neatlogs.tool.input", content);
+      } else {
+        appendInputMessage(span2, role, content);
+      }
+    }
+    return;
+  }
+  if (eventName === "gen_ai.choice") {
+    const out = flattenStrandsContent(attrs.message);
+    if (out) setOutput(span2, isTool, out);
+    return;
+  }
+  if (eventName === "gen_ai.client.inference.operation.details") {
+    const out = flattenStrandsContent(attrs["gen_ai.output.messages"]);
+    if (out) setOutput(span2, isTool, out);
+  }
+}
+function setOutput(span2, isTool, out) {
+  span2.setAttribute("output.value", out);
+  if (isTool) {
+    span2.setAttribute("neatlogs.tool.output", out);
+  } else {
+    span2.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
+    span2.setAttribute("neatlogs.llm.output_messages.0.content", out);
+    span2.setAttribute("neatlogs.llm.output", safeStringify6({ role: "assistant", content: out }));
+  }
+}
+function appendInputMessage(span2, role, content) {
+  const idx = span2.__neatlogs_in_idx ?? 0;
+  span2.setAttribute(`neatlogs.llm.input_messages.${idx}.role`, role);
+  span2.setAttribute(`neatlogs.llm.input_messages.${idx}.content`, content);
+  span2.__neatlogs_in_idx = idx + 1;
+  const existing = span2.__neatlogs_in_msgs ?? [];
+  existing.push({ role, content });
+  span2.__neatlogs_in_msgs = existing;
+  const blob = safeStringify6({ messages: existing });
+  span2.setAttribute("input.value", blob);
+  span2.setAttribute("neatlogs.llm.input", blob);
+}
+function readSpanOp(span2) {
+  try {
+    const a = span2.attributes;
+    if (!a) return "";
+    const v = typeof a.get === "function" ? a.get("gen_ai.operation.name") : a["gen_ai.operation.name"];
+    return typeof v === "string" ? v.toLowerCase() : "";
+  } catch {
+    return "";
+  }
+}
+function flattenStrandsContent(content) {
+  if (content == null) return "";
+  let val = content;
+  if (typeof val === "string") {
+    const s = val.trim();
+    if (!(s.startsWith("[") || s.startsWith("{"))) return val;
+    try {
+      val = JSON.parse(s);
+    } catch {
+      return val;
+    }
+  }
+  return flattenBlocks(val);
+}
+function flattenBlocks(val) {
+  const items = Array.isArray(val) ? val : [val];
+  const out = [];
+  for (const item of items) {
+    if (typeof item === "string") {
+      out.push(item);
+      continue;
+    }
+    if (!item || typeof item !== "object") {
+      if (item != null) out.push(String(item));
+      continue;
+    }
+    const o = item;
+    if (typeof o.text === "string") out.push(o.text);
+    else if (typeof o.content === "string") out.push(o.content);
+    else if (o.toolUse) out.push(`${o.toolUse.name ?? "tool"}(${safeStringify6(o.toolUse.input ?? {})})`);
+    else if (o.toolResult) out.push(flattenBlocks(o.toolResult.content ?? o.toolResult));
+    else if (Array.isArray(o.parts)) out.push(flattenBlocks(o.parts));
+    else if (Array.isArray(o.content)) out.push(flattenBlocks(o.content));
+    else out.push(safeStringify6(o));
+  }
+  return out.filter(Boolean).join("\n");
+}
+function safeStringify6(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return "";
+  }
+}
+
+// src/openai-agents.ts
+var import_api12 = require("@opentelemetry/api");
+var TRACER_NAME6 = "neatlogs.openai_agents";
+function openaiAgentsProcessor() {
+  return new NeatlogsTraceProcessor();
+}
+var NeatlogsTraceProcessor = class {
+  _spans = /* @__PURE__ */ new Map();
+  _startTimes = /* @__PURE__ */ new Map();
+  // The @openai/agents SDK passes a Trace object: { traceId, name, groupId, metadata }.
+  onTraceStart(traceData) {
+    const tracer = import_api12.trace.getTracer(TRACER_NAME6);
+    const attrs = { "neatlogs.span.kind": "WORKFLOW" };
+    const workflowName = traceData?.name ?? traceData?.workflow_name;
+    if (workflowName) attrs["neatlogs.workflow.name"] = workflowName;
+    const traceId = traceData?.traceId ?? traceData?.trace_id;
+    if (traceId) attrs["neatlogs.agent.trace_id"] = String(traceId);
+    const span2 = tracer.startSpan("openai_agents.trace", { attributes: attrs }, import_api12.context.active());
+    const key = String(traceId ?? `trace_${Date.now()}`);
+    this._spans.set(key, span2);
+    this._startTimes.set(key, Date.now());
+  }
+  onTraceEnd(traceData) {
+    const key = String(traceData?.traceId ?? traceData?.trace_id ?? "");
+    const span2 = this._spans.get(key);
+    if (!span2) return;
+    const startTime = this._startTimes.get(key);
+    if (startTime) {
+      span2.setAttribute("neatlogs.metrics.duration_ms", Date.now() - startTime);
+    }
+    span2.setStatus({ code: import_api12.SpanStatusCode.OK });
+    span2.end();
+    this._spans.delete(key);
+    this._startTimes.delete(key);
+  }
+  // The SDK passes a Span object: { type, spanId, traceId, parentId?, spanData: {...} }.
+  // The meaningful payload (type, name, input, output, usage, ...) lives in `spanData`.
+  onSpanStart(span2) {
+    const tracer = import_api12.trace.getTracer(TRACER_NAME6);
+    const data = span2?.spanData ?? span2 ?? {};
+    const spanType = data?.type ?? data?.span_type ?? span2?.type ?? "";
+    const spanId = String(span2?.spanId ?? span2?.span_id ?? data?.span_id ?? `span_${Date.now()}`);
+    const parentKey = String(span2?.parentId ?? span2?.traceId ?? span2?.trace_id ?? "");
+    const parentSpan = this._spans.get(parentKey);
+    const parentCtx = parentSpan ? import_api12.trace.setSpan(import_api12.context.active(), parentSpan) : import_api12.context.active();
+    let otelSpan;
+    if (spanType === "agent" || spanType === "agent_run") {
+      const agentName = data?.name ?? data?.agent_name ?? "agent";
+      const attrs = {
+        "neatlogs.span.kind": "AGENT",
+        "neatlogs.agent.name": agentName
+      };
+      if (Array.isArray(data?.tools) && data.tools.length) {
+        attrs["neatlogs.agent.available_tools"] = data.tools.join(",");
+      }
+      otelSpan = tracer.startSpan(`openai_agents.agent.${agentName}`, { attributes: attrs }, parentCtx);
+    } else if (spanType === "response" || spanType === "generation" || spanType === "llm") {
+      const attrs = {
+        "neatlogs.span.kind": "LLM",
+        "neatlogs.llm.provider": "openai"
+      };
+      const model = data?.model;
+      if (model) attrs["neatlogs.llm.model_name"] = model;
+      const inputMsgs = data?.input ?? data?.messages;
+      if (inputMsgs && Array.isArray(inputMsgs)) {
+        for (let i = 0; i < inputMsgs.length; i++) {
+          const msg = inputMsgs[i];
+          const role = typeof msg === "object" ? msg.role ?? "" : "";
+          const content = typeof msg === "object" ? msg.content ?? "" : String(msg);
+          if (role) attrs[`neatlogs.llm.input_messages.${i}.role`] = role;
+          if (content) attrs[`neatlogs.llm.input_messages.${i}.content`] = (typeof content === "string" ? content : safeStringify7(content)).slice(0, 1e4);
+        }
+      }
+      otelSpan = tracer.startSpan("openai_agents.generation", { attributes: attrs }, parentCtx);
+    } else if (spanType === "function" || spanType === "tool" || spanType === "tool_call") {
+      const toolName = data?.name ?? data?.function_name ?? "tool";
+      const attrs = {
+        "neatlogs.span.kind": "TOOL",
+        "neatlogs.tool.name": toolName
+      };
+      const toolInput = data?.input ?? data?.arguments;
+      if (toolInput !== void 0) {
+        attrs["input.value"] = (typeof toolInput === "string" ? toolInput : safeStringify7(toolInput)).slice(0, 1e4);
+      }
+      otelSpan = tracer.startSpan(`openai_agents.tool.${toolName}`, { attributes: attrs }, parentCtx);
+    } else if (spanType === "handoff") {
+      const attrs = { "neatlogs.span.kind": "AGENT" };
+      if (data?.from_agent) attrs["neatlogs.agent.handoff_from"] = String(data.from_agent);
+      if (data?.to_agent) attrs["neatlogs.agent.name"] = String(data.to_agent);
+      otelSpan = tracer.startSpan("openai_agents.handoff", { attributes: attrs }, parentCtx);
+    } else {
+      const attrs = { "neatlogs.span.kind": "CHAIN" };
+      otelSpan = tracer.startSpan(`openai_agents.${spanType || "span"}`, { attributes: attrs }, parentCtx);
+    }
+    this._spans.set(spanId, otelSpan);
+    this._startTimes.set(spanId, Date.now());
+  }
+  onSpanEnd(span2) {
+    const data = span2?.spanData ?? span2 ?? {};
+    const spanId = String(span2?.spanId ?? span2?.span_id ?? data?.span_id ?? "");
+    const otelSpan = this._spans.get(spanId);
+    if (!otelSpan) return;
+    const spanType = data?.type ?? data?.span_type ?? span2?.type ?? "";
+    const startTime = this._startTimes.get(spanId);
+    if (spanType === "response" || spanType === "generation" || spanType === "llm") {
+      const resp = data?._response ?? data?.response ?? {};
+      const model = data?.model ?? resp?.model;
+      if (model) otelSpan.setAttribute("neatlogs.llm.model_name", model);
+      const outputItems = data?.output ?? resp?.output;
+      if (Array.isArray(outputItems)) {
+        const text = outputItems.filter((o) => o?.type === "message" || o?.role === "assistant").flatMap((o) => Array.isArray(o.content) ? o.content : [o.content]).map((c) => typeof c === "string" ? c : c?.text ?? "").join("");
+        if (text) {
+          otelSpan.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
+          otelSpan.setAttribute("neatlogs.llm.output_messages.0.content", text.slice(0, 1e4));
+        }
+        const toolCalls = outputItems.filter((o) => o?.type === "function_call");
+        for (let i = 0; i < toolCalls.length; i++) {
+          const tc = toolCalls[i];
+          otelSpan.setAttribute(`neatlogs.llm.tool_calls.${i}.name`, tc.name ?? "");
+          otelSpan.setAttribute(`neatlogs.llm.tool_calls.${i}.arguments`, typeof tc.arguments === "string" ? tc.arguments : safeStringify7(tc.arguments ?? {}));
+          if (tc.callId ?? tc.id) otelSpan.setAttribute(`neatlogs.llm.tool_calls.${i}.id`, tc.callId ?? tc.id);
+        }
+      } else if (outputItems?.content) {
+        otelSpan.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
+        const c = outputItems.content;
+        otelSpan.setAttribute("neatlogs.llm.output_messages.0.content", (typeof c === "string" ? c : safeStringify7(c)).slice(0, 1e4));
+      }
+      const usage = data?.usage ?? resp?.usage;
+      if (usage) {
+        const inputTokens = usage.input_tokens ?? usage.prompt_tokens ?? usage.inputTokens;
+        const outputTokens = usage.output_tokens ?? usage.completion_tokens ?? usage.outputTokens;
+        const totalTokens = usage.total_tokens ?? usage.totalTokens;
+        if (inputTokens != null) otelSpan.setAttribute("neatlogs.llm.token_count.prompt", inputTokens);
+        if (outputTokens != null) otelSpan.setAttribute("neatlogs.llm.token_count.completion", outputTokens);
+        if (totalTokens != null) otelSpan.setAttribute("neatlogs.llm.token_count.total", totalTokens);
+        else if (inputTokens != null && outputTokens != null) {
+          otelSpan.setAttribute("neatlogs.llm.token_count.total", inputTokens + outputTokens);
+        }
+      }
+    } else if (spanType === "function" || spanType === "tool" || spanType === "tool_call") {
+      const output = data?.output ?? data?.result;
+      if (output != null) {
+        otelSpan.setAttribute("output.value", (typeof output === "string" ? output : safeStringify7(output)).slice(0, 1e4));
+      }
+    } else if (spanType === "agent" || spanType === "agent_run") {
+      const output = data?.output;
+      if (output != null) {
+        otelSpan.setAttribute("output.value", (typeof output === "string" ? output : safeStringify7(output)).slice(0, 1e4));
+      }
+    }
+    const error = data?.error ?? span2?.error;
+    if (error) {
+      if (error instanceof Error) {
+        otelSpan.setStatus({ code: import_api12.SpanStatusCode.ERROR, message: error.message });
+        otelSpan.recordException(error);
+      } else {
+        otelSpan.setStatus({ code: import_api12.SpanStatusCode.ERROR, message: String(error) });
+      }
+    } else {
+      otelSpan.setStatus({ code: import_api12.SpanStatusCode.OK });
+    }
+    if (startTime) {
+      otelSpan.setAttribute("neatlogs.llm.metrics.duration_ms", Date.now() - startTime);
+    }
+    otelSpan.end();
+    this._spans.delete(spanId);
+    this._startTimes.delete(spanId);
+  }
+  shutdown() {
+    for (const [, span2] of this._spans) {
+      span2.setStatus({ code: import_api12.SpanStatusCode.ERROR, message: "Processor shutdown before span completed" });
+      span2.end();
+    }
+    this._spans.clear();
+    this._startTimes.clear();
+  }
+  forceFlush() {
+  }
+};
+function safeStringify7(value) {
+  try {
+    return typeof value === "string" ? value : JSON.stringify(value);
+  } catch {
+    return "";
+  }
+}
+
+// src/mastra-wrap.ts
+var import_api13 = require("@opentelemetry/api");
+var TRACER_NAME7 = "neatlogs.mastra";
+var PATCH_FLAG2 = "_neatlogs_patched";
+function wrapMastra(entity) {
+  if (!entity || entity[PATCH_FLAG2]) return entity;
+  const e = entity;
+  const className = entity.constructor?.name ?? "";
+  if (isRootMastra(e)) {
+    const proxied = wrapRootMastra(e);
+    markPatched(proxied);
+    return proxied;
+  }
+  if (isAgent(e, className)) {
+    patchAgent(e);
+  } else if (isWorkflow(e, className)) {
+    patchWorkflow(e);
+  } else if (isVector(e, className)) {
+    patchVector(e);
+  } else if (isMemory(e, className)) {
+    patchMemory(e);
+  } else if (isDocument(e, className)) {
+    patchDocument(e);
+  }
+  markPatched(e);
+  return entity;
+}
+function isRootMastra(e) {
+  return typeof e.getAgent === "function" && typeof e.getWorkflow === "function";
+}
+function isAgent(e, className) {
+  return className === "Agent" || typeof e.generate === "function" || typeof e.stream === "function";
+}
+function isWorkflow(e, className) {
+  return className === "Workflow" || typeof e.createRun === "function";
+}
+function isVector(e, className) {
+  return /Vector/.test(className) || typeof e.query === "function" && typeof e.upsert === "function";
+}
+function isMemory(e, className) {
+  return /Memory/.test(className) || typeof e.recall === "function" && typeof e.saveMessages === "function";
+}
+function isDocument(e, className) {
+  return className === "MDocument" || typeof e.chunk === "function" && typeof e.getDocs === "function";
+}
+function patchAgent(agent) {
+  patchAgentMethod(agent, "generate", false);
+  patchAgentMethod(agent, "stream", true);
+}
+function patchAgentMethod(agent, method, streaming) {
+  if (typeof agent[method] !== "function") return;
+  const orig = agent[method].bind(agent);
+  agent[method] = async function tracedAgentMethod(input, opts) {
+    const agentName = agent.name ?? agent.id ?? "mastra_agent";
+    const model = extractModelId(agent.model);
+    installAgentLlmHook(agent);
+    installAgentToolHooks(agent);
+    const attrs = {
+      "neatlogs.span.kind": "AGENT",
+      "neatlogs.agent.name": agentName,
+      "input.value": toInputValue(input)
+    };
+    if (model) attrs["neatlogs.llm.model_name"] = model;
+    if (agent.instructions && typeof agent.instructions === "string") {
+      attrs["neatlogs.llm.system_prompt"] = agent.instructions.slice(0, 5e3);
+    }
+    if (streaming) attrs["neatlogs.llm.is_streaming"] = true;
+    if (streaming) {
+      const tracer = import_api13.trace.getTracer(TRACER_NAME7);
+      const span2 = tracer.startSpan(`mastra.agent.${agentName}`, { attributes: attrs }, import_api13.context.active());
+      const ctx = import_api13.trace.setSpan(import_api13.context.active(), span2);
+      try {
+        const result = await import_api13.context.with(ctx, () => orig(input, opts));
+        return wrapStreamingOutput(result, span2, ctx);
+      } catch (err) {
+        recordError3(span2, err);
+        span2.end();
+        throw err;
+      }
+    }
+    return withActiveSpan(`mastra.agent.${agentName}`, attrs, async (span2) => {
+      const result = await orig(input, opts);
+      finalizeAgentResult(span2, result);
+      return result;
+    });
+  };
+}
+function installAgentLlmHook(agent) {
+  if (agent.__neatlogs_llm_hook || typeof agent.getLLM !== "function") return;
+  agent.__neatlogs_llm_hook = true;
+  const origGetLLM = agent.getLLM.bind(agent);
+  agent.getLLM = function patchedGetLLM(...args) {
+    const out = origGetLLM(...args);
+    return Promise.resolve(out).then((llm) => {
+      try {
+        const model = typeof llm?.getModel === "function" ? llm.getModel() : llm;
+        patchModelInPlace(model);
+      } catch {
+      }
+      return llm;
+    });
+  };
+}
+function patchModelInPlace(model) {
+  if (!model || model.__neatlogs_model_patched) return;
+  model.__neatlogs_model_patched = true;
+  const modelId = model.modelId ?? model.modelName ?? "";
+  const provider = model.provider ?? "";
+  for (const fn of ["doGenerate", "doStream"]) {
+    if (typeof model[fn] !== "function") continue;
+    const orig = model[fn].bind(model);
+    const isStream = fn === "doStream";
+    model[fn] = function tracedModelCall(callOpts) {
+      const attrs = { "neatlogs.span.kind": "LLM" };
+      if (modelId) attrs["neatlogs.llm.model_name"] = modelId;
+      if (provider) attrs["neatlogs.llm.provider"] = provider;
+      if (isStream) attrs["neatlogs.llm.is_streaming"] = true;
+      const promptInput = callOpts?.prompt ?? callOpts?.messages;
+      if (promptInput !== void 0) attrs["input.value"] = safeStringify8(promptInput).slice(0, 1e4);
+      captureInvocationParams(attrs, callOpts);
+      return withActiveSpan(`mastra.llm.${modelId || "model"}.${fn}`, attrs, async (span2) => {
+        const result = await orig(callOpts);
+        if (!isStream) finalizeModelResult(span2, result);
+        else if (result?.usage) recordUsage(span2, result.usage);
+        return result;
+      });
+    };
+  }
+}
+function installAgentToolHooks(agent) {
+  if (agent.__neatlogs_tool_hook) return;
+  let tools;
+  try {
+    tools = typeof agent.listTools === "function" ? agent.listTools() : void 0;
+  } catch {
+    tools = void 0;
+  }
+  if (!tools || typeof tools !== "object") return;
+  agent.__neatlogs_tool_hook = true;
+  for (const [key, tool] of Object.entries(tools)) {
+    patchToolExecute(tool, key);
+  }
+}
+function patchToolExecute(tool, key) {
+  if (!tool || typeof tool.execute !== "function" || tool.__neatlogs_tool_patched) return;
+  tool.__neatlogs_tool_patched = true;
+  const toolName = tool.id ?? key;
+  const orig = tool.execute.bind(tool);
+  tool.execute = function tracedToolExecute(params, options) {
+    const attrs = {
+      "neatlogs.span.kind": "TOOL",
+      "neatlogs.tool.name": toolName,
+      "input.value": safeStringify8(params).slice(0, 1e4)
+    };
+    if (tool.description) attrs["neatlogs.tool.description"] = String(tool.description).slice(0, 2e3);
+    return withActiveSpan(`mastra.tool.${toolName}`, attrs, async (span2) => {
+      const result = await orig(params, options);
+      span2.setAttribute("output.value", safeStringify8(result).slice(0, 1e4));
+      return result;
+    });
+  };
+}
+function patchWorkflow(workflow) {
+  if (typeof workflow.createRun !== "function") return;
+  const origCreateRun = workflow.createRun.bind(workflow);
+  const workflowName = workflow.name ?? workflow.id ?? "mastra_workflow";
+  workflow.createRun = async function tracedCreateRun(...args) {
+    const run = await origCreateRun(...args);
+    if (!run) return run;
+    patchRunMethod(run, "start", workflowName);
+    patchRunMethod(run, "resume", workflowName);
+    return run;
+  };
+}
+function patchRunMethod(run, method, workflowName) {
+  if (typeof run[method] !== "function") return;
+  const orig = run[method].bind(run);
+  run[method] = async function tracedRunMethod(startOpts) {
+    const attrs = {
+      "neatlogs.span.kind": "WORKFLOW",
+      "neatlogs.workflow.name": workflowName
+    };
+    if (startOpts?.inputData !== void 0) {
+      attrs["input.value"] = safeStringify8(startOpts.inputData).slice(0, 1e4);
+    }
+    return withActiveSpan(`mastra.workflow.${workflowName}`, attrs, async (span2) => {
+      const result = await orig(startOpts);
+      if (result?.status) span2.setAttribute("neatlogs.metadata", safeStringify8({ status: result.status }));
+      if (result?.result !== void 0) {
+        span2.setAttribute("output.value", safeStringify8(result.result).slice(0, 1e4));
+      }
+      return result;
+    });
+  };
+}
+var VECTOR_READ_OPS = ["query"];
+var VECTOR_WRITE_OPS = ["upsert", "updateVector", "deleteVector", "createIndex", "deleteIndex"];
+function patchVector(vector) {
+  for (const op of VECTOR_READ_OPS) patchVectorOp(vector, op, "RETRIEVER");
+  for (const op of VECTOR_WRITE_OPS) patchVectorOp(vector, op, "VECTOR_STORE");
+}
+function patchVectorOp(vector, op, kind) {
+  if (typeof vector[op] !== "function") return;
+  const orig = vector[op].bind(vector);
+  const dbName = vector.constructor?.name ?? "vector";
+  vector[op] = async function tracedVectorOp(params) {
+    const attrs = {
+      "neatlogs.span.kind": kind,
+      "neatlogs.db.system": dbName,
+      "neatlogs.db.operation": op,
+      "input.value": safeStringify8(params).slice(0, 1e4)
+    };
+    const indexName = params?.indexName;
+    if (indexName) attrs["neatlogs.vectordb.index_name"] = String(indexName);
+    if (kind === "RETRIEVER" && params?.topK != null) attrs["neatlogs.retriever.top_k"] = params.topK;
+    return withActiveSpan(`mastra.vector.${op}`, attrs, async (span2) => {
+      const result = await orig(params);
+      span2.setAttribute("output.value", safeStringify8(result).slice(0, 1e4));
+      return result;
+    });
+  };
+}
+var MEMORY_OPS = ["recall", "saveMessages", "updateWorkingMemory", "deleteMessages"];
+function patchMemory(memory) {
+  for (const op of MEMORY_OPS) {
+    if (typeof memory[op] !== "function") continue;
+    const orig = memory[op].bind(memory);
+    memory[op] = async function tracedMemoryOp(...args) {
+      const attrs = {
+        "neatlogs.span.kind": "CHAIN",
+        "neatlogs.db.operation": op,
+        "input.value": safeStringify8(args?.[0]).slice(0, 1e4)
+      };
+      return withActiveSpan(`mastra.memory.${op}`, attrs, async (span2) => {
+        const result = await orig(...args);
+        span2.setAttribute("output.value", safeStringify8(result).slice(0, 8e3));
+        return result;
+      });
+    };
+  }
+}
+function patchDocument(doc) {
+  if (typeof doc.chunk !== "function") return;
+  const orig = doc.chunk.bind(doc);
+  doc.chunk = async function tracedChunk(...args) {
+    const attrs = {
+      "neatlogs.span.kind": "CHAIN",
+      "neatlogs.db.operation": "chunk"
+    };
+    return withActiveSpan("mastra.document.chunk", attrs, async (span2) => {
+      const result = await orig(...args);
+      if (Array.isArray(result)) span2.setAttribute("neatlogs.db.documents_count", result.length);
+      return result;
+    });
+  };
+}
+function wrapRootMastra(mastra) {
+  const AGENT_GETTERS = /* @__PURE__ */ new Set(["getAgent", "getAgentById"]);
+  const WORKFLOW_GETTERS = /* @__PURE__ */ new Set(["getWorkflow", "getWorkflowById"]);
+  return new Proxy(mastra, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value !== "function") return value;
+      const name = String(prop);
+      if (AGENT_GETTERS.has(name) || WORKFLOW_GETTERS.has(name)) {
+        return (...args) => {
+          const entity = value.apply(target, args);
+          return entity && typeof entity === "object" ? wrapMastra(entity) : entity;
+        };
+      }
+      return value.bind(target);
+    }
+  });
+}
+function wrapStreamingOutput(output, span2, ctx) {
+  if (!output) {
+    span2.setStatus({ code: import_api13.SpanStatusCode.OK });
+    span2.end();
+    return output;
+  }
+  let ended = false;
+  const endOnce = (err) => {
+    if (ended) return;
+    ended = true;
+    if (err) recordError3(span2, err);
+    else span2.setStatus({ code: import_api13.SpanStatusCode.OK });
+    span2.end();
+  };
+  if (output.text && typeof output.text.then === "function") {
+    const finalize = async () => {
+      try {
+        const [text, usage, finishReason] = await Promise.all([
+          Promise.resolve(output.text).catch(() => void 0),
+          Promise.resolve(output.usage).catch(() => void 0),
+          Promise.resolve(output.finishReason).catch(() => void 0)
+        ]);
+        if (typeof text === "string" && text) {
+          span2.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
+          span2.setAttribute("neatlogs.llm.output_messages.0.content", text.slice(0, 1e4));
+        }
+        if (usage) recordUsage(span2, usage);
+        if (finishReason) span2.setAttribute("neatlogs.llm.stop_reason", normalizeFinishReason(finishReason));
+        endOnce();
+      } catch (err) {
+        endOnce(err);
+      }
+    };
+    void finalize();
+    return rebindStreamContext(output, ctx);
+  }
+  if (output[Symbol.asyncIterator]) {
+    const origIterator = output[Symbol.asyncIterator].bind(output);
+    const textParts = [];
+    const wrapped = Object.create(Object.getPrototypeOf(output));
+    Object.assign(wrapped, output);
+    wrapped[Symbol.asyncIterator] = function() {
+      const iterator = origIterator();
+      const finish = () => {
+        if (textParts.length) {
+          span2.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
+          span2.setAttribute("neatlogs.llm.output_messages.0.content", textParts.join("").slice(0, 1e4));
+        }
+        endOnce();
+      };
+      return {
+        async next() {
+          try {
+            const r = await iterator.next();
+            if (r.done) {
+              finish();
+              return r;
+            }
+            const chunk = r.value;
+            if (typeof chunk === "string") textParts.push(chunk);
+            else if (chunk?.text) textParts.push(chunk.text);
+            else if (chunk?.delta) textParts.push(chunk.delta);
+            return r;
+          } catch (err) {
+            endOnce(err);
+            throw err;
+          }
+        },
+        async return(value) {
+          finish();
+          return iterator.return?.(value) ?? { done: true, value: void 0 };
+        },
+        async throw(err) {
+          endOnce(err);
+          return iterator.throw?.(err) ?? { done: true, value: void 0 };
+        }
+      };
+    };
+    return wrapped;
+  }
+  if (typeof output.then === "function") {
+    return output.then((resolved) => {
+      finalizeAgentResult(span2, resolved);
+      endOnce();
+      return resolved;
+    }).catch((err) => {
+      endOnce(err);
+      throw err;
+    });
+  }
+  endOnce();
+  return output;
+}
+function rebindStreamContext(output, ctx) {
+  const STREAM_PROPS = /* @__PURE__ */ new Set(["textStream", "fullStream", "objectStream", "elementStream"]);
+  return new Proxy(output, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof prop === "string" && STREAM_PROPS.has(prop) && value && value[Symbol.asyncIterator]) {
+        const origIterator = value[Symbol.asyncIterator].bind(value);
+        return {
+          [Symbol.asyncIterator]() {
+            return import_api13.context.with(ctx, () => origIterator());
+          }
+        };
+      }
+      if (typeof value === "function") return value.bind(target);
+      return value;
+    }
+  });
+}
+function finalizeAgentResult(span2, result) {
+  if (!result) return;
+  if (result.text) {
+    span2.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
+    span2.setAttribute("neatlogs.llm.output_messages.0.content", String(result.text).slice(0, 1e4));
+  }
+  if (Array.isArray(result.toolCalls)) {
+    for (let i = 0; i < result.toolCalls.length; i++) {
+      const tc = result.toolCalls[i];
+      const p = tc.payload ?? tc;
+      setToolCall(span2, i, p.toolName ?? p.name, p.args ?? p.arguments, p.toolCallId ?? p.id);
+    }
+  }
+  if (result.usage) recordUsage(span2, result.usage);
+  if (result.finishReason) span2.setAttribute("neatlogs.llm.stop_reason", normalizeFinishReason(result.finishReason));
+  if (result.model) span2.setAttribute("neatlogs.llm.model_name", result.model);
+}
+function finalizeModelResult(span2, result) {
+  if (!result) return;
+  if (typeof result.text === "string" && result.text) {
+    span2.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
+    span2.setAttribute("neatlogs.llm.output_messages.0.content", result.text.slice(0, 1e4));
+  } else if (Array.isArray(result.content)) {
+    const text = result.content.filter((p) => p?.type === "text" && typeof p.text === "string").map((p) => p.text).join("");
+    if (text) {
+      span2.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
+      span2.setAttribute("neatlogs.llm.output_messages.0.content", text.slice(0, 1e4));
+    }
+    const toolCalls = result.content.filter((p) => p?.type === "tool-call");
+    for (let i = 0; i < toolCalls.length; i++) {
+      const tc = toolCalls[i];
+      setToolCall(span2, i, tc.toolName, tc.input ?? tc.args, tc.toolCallId);
+    }
+    span2.setAttribute("output.value", safeStringify8(result.content).slice(0, 1e4));
+  }
+  if (result.usage) recordUsage(span2, result.usage);
+  span2.setAttribute("neatlogs.llm.stop_reason", normalizeFinishReason(result.finishReason));
+}
+function normalizeFinishReason(fr) {
+  if (fr == null) return "";
+  if (typeof fr === "string") return fr;
+  return String(fr.unified ?? fr.reason ?? fr.type ?? safeStringify8(fr));
+}
+function tokenValue(v) {
+  if (v == null) return void 0;
+  if (typeof v === "number") return v;
+  if (typeof v === "object" && typeof v.total === "number") return v.total;
+  const n = Number(v);
+  return Number.isFinite(n) ? n : void 0;
+}
+function captureInvocationParams(attrs, callOpts) {
+  if (!callOpts) return;
+  const map = [
+    ["temperature", "neatlogs.llm.temperature"],
+    ["maxOutputTokens", "neatlogs.llm.max_tokens"],
+    ["maxTokens", "neatlogs.llm.max_tokens"],
+    ["topP", "neatlogs.llm.top_p"],
+    ["topK", "neatlogs.llm.top_k"],
+    ["frequencyPenalty", "neatlogs.llm.frequency_penalty"],
+    ["presencePenalty", "neatlogs.llm.presence_penalty"]
+  ];
+  const invocation = {};
+  for (const [src, target] of map) {
+    const v = callOpts[src];
+    if (v != null) {
+      attrs[target] = v;
+      invocation[src] = v;
+    }
+  }
+  if (Array.isArray(callOpts.stopSequences) && callOpts.stopSequences.length) {
+    attrs["neatlogs.llm.stop_sequences"] = safeStringify8(callOpts.stopSequences);
+    invocation.stopSequences = callOpts.stopSequences;
+  }
+  if (Array.isArray(callOpts.tools)) {
+    for (let i = 0; i < callOpts.tools.length; i++) {
+      attrs[`neatlogs.llm.tools.${i}`] = safeStringify8(callOpts.tools[i]).slice(0, 4e3);
+    }
+    invocation.toolChoice = callOpts.toolChoice;
+  }
+  if (Object.keys(invocation).length) {
+    attrs["neatlogs.llm.invocation_parameters"] = safeStringify8(invocation).slice(0, 4e3);
+  }
+}
+function setToolCall(span2, i, name, args, id) {
+  span2.setAttribute(`neatlogs.llm.tool_calls.${i}.name`, name ?? "");
+  span2.setAttribute(`neatlogs.llm.tool_calls.${i}.arguments`, safeStringify8(args ?? {}));
+  if (id) span2.setAttribute(`neatlogs.llm.tool_calls.${i}.id`, id);
+}
+function recordUsage(span2, usage) {
+  if (!usage) return;
+  const prompt = tokenValue(usage.promptTokens ?? usage.inputTokens ?? usage.input_tokens);
+  const completion = tokenValue(usage.completionTokens ?? usage.outputTokens ?? usage.output_tokens);
+  const total = tokenValue(usage.totalTokens);
+  if (prompt != null) span2.setAttribute("neatlogs.llm.token_count.prompt", prompt);
+  if (completion != null) span2.setAttribute("neatlogs.llm.token_count.completion", completion);
+  if (total != null) span2.setAttribute("neatlogs.llm.token_count.total", total);
+  else if (prompt != null && completion != null) {
+    span2.setAttribute("neatlogs.llm.token_count.total", prompt + completion);
+  }
+}
+function withActiveSpan(name, attrs, fn) {
+  const tracer = import_api13.trace.getTracer(TRACER_NAME7);
+  const span2 = tracer.startSpan(name, { attributes: attrs }, import_api13.context.active());
+  const ctx = import_api13.trace.setSpan(import_api13.context.active(), span2);
+  return import_api13.context.with(ctx, async () => {
+    try {
+      const result = await fn(span2);
+      span2.setStatus({ code: import_api13.SpanStatusCode.OK });
+      return result;
+    } catch (err) {
+      recordError3(span2, err);
+      throw err;
+    } finally {
+      span2.end();
+    }
+  });
+}
+function markPatched(e) {
+  try {
+    Object.defineProperty(e, PATCH_FLAG2, { value: true, enumerable: false, configurable: true });
+  } catch {
+    e[PATCH_FLAG2] = true;
+  }
+}
+function extractModelId(model) {
+  if (!model) return "";
+  if (typeof model === "string") return model;
+  return model.modelId ?? model.name ?? "";
+}
+function toInputValue(input) {
+  return (typeof input === "string" ? input : safeStringify8(input)).slice(0, 1e4);
+}
+function safeStringify8(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return "";
+  }
+}
+function recordError3(span2, err) {
+  if (err instanceof Error) {
+    span2.setStatus({ code: import_api13.SpanStatusCode.ERROR, message: err.message });
+    span2.recordException(err);
+  } else {
+    span2.setStatus({ code: import_api13.SpanStatusCode.ERROR, message: String(err) });
+  }
+}
+
+// src/pi-agent.ts
+var import_api14 = require("@opentelemetry/api");
+var TRACER_NAME8 = "neatlogs.pi-agent";
+var PATCH_FLAG3 = "_neatlogs_patched";
+function piAgentHooks(agent) {
+  if (!agent || agent[PATCH_FLAG3]) return agent;
+  const a = agent;
+  if (typeof a.subscribe !== "function") return agent;
+  const state = { toolSpans: /* @__PURE__ */ new Map(), inputMessages: [] };
+  const tracer = import_api14.trace.getTracer(TRACER_NAME8);
+  a.subscribe((event) => {
+    try {
+      handleEvent(tracer, state, event);
+    } catch {
+    }
+  });
+  markPatched2(a);
+  return agent;
+}
+function handleEvent(tracer, state, event) {
+  switch (event.type) {
+    case "agent_start": {
+      const span2 = tracer.startSpan(
+        "pi_agent.run",
+        { attributes: { "neatlogs.span.kind": "AGENT" } },
+        import_api14.context.active()
+      );
+      state.agentSpan = span2;
+      state.agentCtx = import_api14.trace.setSpan(import_api14.context.active(), span2);
+      state.inputMessages = [];
+      break;
+    }
+    case "message_end": {
+      const msg = event.message;
+      if (!msg) return;
+      if (msg.role === "assistant") {
+        emitLlmSpan(tracer, state, msg);
+        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 });
+      }
+      break;
+    }
+    case "tool_execution_start": {
+      const parent = state.agentCtx ?? import_api14.context.active();
+      const span2 = tracer.startSpan(
+        `pi_agent.tool.${event.toolName ?? "tool"}`,
+        {
+          attributes: {
+            "neatlogs.span.kind": "TOOL",
+            ...event.toolName ? { "neatlogs.tool.name": String(event.toolName) } : {},
+            ...event.args !== void 0 ? { "input.value": safeStringify9(event.args).slice(0, 1e4) } : {}
+          }
+        },
+        parent
+      );
+      if (event.toolCallId) state.toolSpans.set(event.toolCallId, span2);
+      break;
+    }
+    case "tool_execution_end": {
+      const span2 = event.toolCallId ? state.toolSpans.get(event.toolCallId) : void 0;
+      if (!span2) return;
+      if (event.result !== void 0) {
+        span2.setAttribute("output.value", safeStringify9(event.result).slice(0, 1e4));
+      }
+      if (event.isError) {
+        span2.setStatus({ code: import_api14.SpanStatusCode.ERROR });
+        span2.setAttribute("neatlogs.tool.is_error", true);
+      } else {
+        span2.setStatus({ code: import_api14.SpanStatusCode.OK });
+      }
+      span2.end();
+      if (event.toolCallId) state.toolSpans.delete(event.toolCallId);
+      break;
+    }
+    case "agent_end": {
+      for (const ts of state.toolSpans.values()) {
+        try {
+          ts.end();
+        } catch {
+        }
+      }
+      state.toolSpans.clear();
+      if (state.agentSpan) {
+        const firstUser = state.inputMessages.find((m) => m.role === "user");
+        if (firstUser) state.agentSpan.setAttribute("input.value", firstUser.content.slice(0, 1e4));
+        const finalText = lastAssistantText(event.messages);
+        if (finalText) state.agentSpan.setAttribute("output.value", finalText.slice(0, 1e4));
+        state.agentSpan.setStatus({ code: import_api14.SpanStatusCode.OK });
+        state.agentSpan.end();
+        state.agentSpan = void 0;
+        state.agentCtx = void 0;
+      }
+      break;
+    }
+    default:
+      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;
+  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.slice(0, 1e4);
+    });
+    attrs["neatlogs.llm.input"] = safeStringify9({ messages: inMsgs }).slice(0, 2e4);
+    attrs["input.value"] = safeStringify9({ messages: inMsgs }).slice(0, 1e4);
+  }
+  const { text, toolCalls } = splitAssistantContent(msg.content);
+  const outText = text || toolCalls.map((tc) => `${tc.name}(${safeStringify9(tc.arguments)})`).join("\n");
+  if (outText || toolCalls.length) {
+    attrs["neatlogs.llm.output_messages.0.role"] = "assistant";
+    attrs["neatlogs.llm.output_messages.0.content"] = (outText || "").slice(0, 1e4);
+    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.arguments !== void 0)
+          attrs[`neatlogs.llm.tool_calls.${j}.arguments`] = safeStringify9(tc.arguments);
+        if (tc.id) attrs[`neatlogs.llm.tool_calls.${j}.id`] = String(tc.id);
+      });
+    }
+    attrs["neatlogs.llm.output"] = safeStringify9(outBlob).slice(0, 2e4);
+    attrs["output.value"] = (outText || "").slice(0, 1e4);
+  }
+  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;
+    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;
+  }
+  const parent = state.agentCtx ?? import_api14.context.active();
+  const span2 = tracer.startSpan(
+    `pi_agent.llm.${msg.model || "model"}`,
+    { attributes: attrs },
+    parent
+  );
+  span2.setStatus({ code: import_api14.SpanStatusCode.OK });
+  span2.end();
+}
+function splitAssistantContent(content) {
+  const texts = [];
+  const toolCalls = [];
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (!block || typeof block !== "object") continue;
+      if (block.type === "text" && typeof block.text === "string") texts.push(block.text);
+      else if (block.type === "toolCall")
+        toolCalls.push(block);
+    }
+  } else if (typeof content === "string") {
+    texts.push(content);
+  }
+  return { text: texts.join(""), toolCalls };
+}
+function messageText(msg) {
+  if (!msg) return "";
+  const c = msg.content;
+  if (typeof c === "string") return c;
+  if (!Array.isArray(c)) return "";
+  const parts = [];
+  for (const block of c) {
+    if (typeof block === "string") parts.push(block);
+    else if (block && typeof block === "object") {
+      if (typeof block.text === "string") parts.push(block.text);
+      else if (block.type === "toolCall") parts.push(`${block.name ?? "tool"}(${safeStringify9(block.arguments)})`);
+    }
+  }
+  return parts.join("");
+}
+function lastAssistantText(messages) {
+  if (!Array.isArray(messages)) return "";
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (m && m.role === "assistant") {
+      const { text } = splitAssistantContent(m.content);
+      if (text) return text;
+    }
+  }
+  return "";
+}
+function markPatched2(e) {
+  try {
+    Object.defineProperty(e, PATCH_FLAG3, { value: true, enumerable: false, configurable: true });
+  } catch {
+    e[PATCH_FLAG3] = true;
+  }
+}
+function safeStringify9(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return "";
+  }
+}
+
 // src/core/llm-binder.ts
 var logger15 = getLogger();
 function bindTemplates(llm, systemTpl, userTpl, compiledVars) {
@@ -6549,15 +8531,24 @@ function bindTemplates(llm, systemTpl, userTpl, compiledVars) {
   getSessionConfig,
   init,
   isDebugEnabled,
+  langchainHandler,
   listPrompts,
   log,
+  openaiAgentsProcessor,
+  piAgentHooks,
   registerCrewaiTask,
   removeTag,
   saveAsVersion,
   shutdown,
   span,
+  strandsHooks,
   trace,
+  traceToolAnthropic,
+  traceToolOpenAI,
   updatePrompt,
-  wrapAISDK
+  wrapAISDK,
+  wrapAnthropic,
+  wrapMastra,
+  wrapOpenAI
 });
 //# sourceMappingURL=index.cjs.map