neatlogs 1.0.6 → 1.0.8

package/dist/index.cjs

@@ -30,6 +30,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  NeatlogsOpencodePlugin: () => NeatlogsOpencodePlugin,
   PromptApiError: () => PromptApiError,
   PromptClient: () => PromptClient,
   PromptClientError: () => PromptClientError,
@@ -63,12 +64,22 @@ __export(index_exports, {
   strandsHooks: () => strandsHooks,
   trace: () => trace2,
   traceToolAnthropic: () => traceTool2,
+  traceToolAzureOpenAI: () => traceTool3,
+  traceToolBedrock: () => traceTool5,
   traceToolOpenAI: () => traceTool,
+  traceToolVertexAI: () => traceTool4,
   updatePrompt: () => updatePrompt,
   wrapAISDK: () => wrapAISDK,
   wrapAnthropic: () => wrapAnthropic,
+  wrapAzureOpenAI: () => wrapAzureOpenAI,
+  wrapBedrock: () => wrapBedrock,
+  wrapCallModel: () => wrapCallModel,
+  wrapClaudeAgentSDK: () => wrapClaudeAgentSDK,
   wrapMastra: () => wrapMastra,
-  wrapOpenAI: () => wrapOpenAI
+  wrapOpenAI: () => wrapOpenAI,
+  wrapOpenRouterAgent: () => wrapOpenRouterAgent,
+  wrapVertexAI: () => wrapVertexAI,
+  wrapVertexAIChat: () => wrapVertexAIChat
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -1440,7 +1451,7 @@ var UnifiedAttributeProcessor = class {
             attrs["mcp.server.version"] = info.version ?? "";
           }
           if ("capabilities" in output) {
-            attrs["mcp.server.capabilities"] = JSON.stringify(output.capabilities).slice(0, 2e3);
+            attrs["mcp.server.capabilities"] = JSON.stringify(output.capabilities);
           }
         }
       } catch {
@@ -2046,7 +2057,7 @@ var UnifiedAttributeProcessor = class {
       if (typeof r !== "string" || r.toLowerCase() !== role) continue;
       const c = unified[`${prefix}.${i}.content`];
       if (typeof c === "string" && c.toLowerCase().includes("thought:")) {
-        texts.push(c.slice(0, 2e4));
+        texts.push(c);
       }
     }
     return texts;
@@ -4970,6 +4981,7 @@ var INSTRUMENTATION_REGISTRY = {
   tags: {
     llm: [
       "azure_ai_inference",
+      "azure_openai",
       "openai",
       "anthropic",
       "cohere",
@@ -5018,7 +5030,10 @@ var INSTRUMENTATION_REGISTRY = {
       "smolagents",
       "strands",
       "pipecat",
-      "ai_sdk"
+      "ai_sdk",
+      "claude_agent_sdk",
+      "openrouter_agent",
+      "opencode"
     ],
     tool: ["langchain", "llamaindex", "haystack", "mcp"],
     http: ["requests", "httpx", "urllib3", "aiohttp"],
@@ -5063,7 +5078,15 @@ var INSTRUMENTATION_REGISTRY = {
     bedrock: {
       openinference: "@arizeai/openinference-instrumentation-bedrock",
       openllmetry: null,
-      neatlogs: null,
+      // The wrapper is opt-in per call site (wrapBedrock); this entry keeps
+      // scope detection and tagging consistent.
+      neatlogs: "neatlogs/bedrock",
+      default_span_kind: "LLM"
+    },
+    azure_openai: {
+      openinference: null,
+      openllmetry: null,
+      neatlogs: "neatlogs/azure-openai",
       default_span_kind: "LLM"
     },
     groq: {
@@ -5081,7 +5104,7 @@ var INSTRUMENTATION_REGISTRY = {
     vertexai: {
       openinference: null,
       openllmetry: null,
-      neatlogs: null,
+      neatlogs: "neatlogs/vertex-ai",
       default_span_kind: "LLM"
     },
     google_generativeai: {
@@ -5354,7 +5377,20 @@ var INSTRUMENTATION_REGISTRY = {
     claude_agent_sdk: {
       openinference: "@arizeai/openinference-instrumentation-claude-agent-sdk",
       openllmetry: null,
-      neatlogs: null,
+      // Opt-in wrapper (wrapClaudeAgentSDK); entry kept for scope detection/tagging.
+      neatlogs: "neatlogs/claude-agent-sdk",
+      default_span_kind: "AGENT"
+    },
+    openrouter_agent: {
+      openinference: null,
+      openllmetry: null,
+      neatlogs: "neatlogs/openrouter-agent",
+      default_span_kind: "AGENT"
+    },
+    opencode: {
+      openinference: null,
+      openllmetry: null,
+      neatlogs: "neatlogs/opencode",
       default_span_kind: "AGENT"
     }
   }
@@ -5863,7 +5899,7 @@ async function removeTag(name, tag) {
 }
 
 // src/version.ts
-var __version__ = "1.0.6";
+var __version__ = "1.0.8";
 
 // src/init.ts
 var logger13 = getLogger();
@@ -7150,238 +7186,302 @@ function recordError2(span2, err) {
   span2.end();
 }
 
-// src/langchain.ts
+// src/azure-openai.ts
 var import_api11 = require("@opentelemetry/api");
-var TRACER_NAME5 = "neatlogs.langchain";
-function langchainHandler(opts) {
-  return new NeatlogsCallbackHandler(opts);
+var TRACER_NAME5 = "neatlogs.azure_openai";
+var PROVIDER = "azure";
+var SYSTEM = "azure";
+function wrapAzureOpenAI(client) {
+  return wrapNamespace3(client, []);
 }
-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) {
+function traceTool3(name, fn) {
+  return async function tracedTool(args) {
     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;
+    return tracer.startActiveSpan(
+      `tool.${name}`,
+      {
+        attributes: {
+          "neatlogs.span.kind": "TOOL",
+          "neatlogs.tool.name": name,
+          "input.value": safeStringify5(args)
+        }
+      },
+      import_api11.context.active(),
+      async (span2) => {
+        try {
+          const result = await fn(args);
+          span2.setAttribute("output.value", safeStringify5(result));
+          span2.setStatus({ code: import_api11.SpanStatusCode.OK });
+          return result;
+        } catch (err) {
+          recordError3(span2, err);
+          throw err;
+        } finally {
+          span2.end();
+        }
+      }
+    );
+  };
+}
+function wrapNamespace3(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 tracedChatCompletionsCreate2(value.bind(obj));
+      }
+      if (pathStr === "responses.create" && typeof value === "function") {
+        return tracedResponsesCreate2(value.bind(obj));
+      }
+      if (value && typeof value === "object" && !Array.isArray(value) && isNamespace3(currentPath)) {
+        return wrapNamespace3(value, currentPath);
+      }
+      return value;
     }
-    const span2 = tracer.startSpan("langchain.llm", { attributes: attrs }, parentCtx);
-    this._spans.set(runId, span2);
-  }
-  async handleChatModelStart(serialized, messages, runId, parentRunId, extraParams) {
+  });
+}
+function isNamespace3(path4) {
+  if (path4.length > 3) return false;
+  const key = path4[path4.length - 1];
+  return ["chat", "completions", "responses", "beta"].includes(key);
+}
+function tracedChatCompletionsCreate2(original) {
+  return function(opts, ...rest) {
     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);
+    const model = opts?.model ?? "";
+    const messages = opts?.messages ?? [];
+    const isStream = opts?.stream === true;
+    const span2 = tracer.startSpan("azure_openai.chat.completions.create", {
+      attributes: {
+        "neatlogs.span.kind": "LLM",
+        "neatlogs.llm.provider": PROVIDER,
+        "neatlogs.llm.system": SYSTEM,
+        "neatlogs.llm.model_name": model,
+        "neatlogs.llm.is_streaming": isStream
+      }
+    }, import_api11.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`, safeStringify5(msg.content));
+      }
+      if (msg.tool_call_id) {
+        span2.setAttribute(`neatlogs.llm.input_messages.${i}.tool_call_id`, msg.tool_call_id);
+      }
     }
-    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;
+    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`, safeStringify5(fn.parameters));
+      }
     }
-    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 ?? "");
-          }
-        }
+    setInvocationParams3(span2, opts);
+    if (isStream) {
+      opts = { ...opts };
+      const streamOpts = opts.stream_options ?? {};
+      if (!streamOpts.include_usage) {
+        opts.stream_options = { ...streamOpts, include_usage: true };
       }
     }
-    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);
+    const ctx = import_api11.trace.setSpan(import_api11.context.active(), span2);
+    const promise = import_api11.context.with(ctx, () => original(opts, ...rest));
+    return promise.then(
+      (response) => {
+        if (isStream) {
+          return wrapAsyncIterableStream2(response, span2);
+        }
+        finalizeChatResponse2(span2, response);
+        return response;
+      },
+      (err) => {
+        recordError3(span2, err);
+        throw err;
       }
-      if (usage.completionTokens != null || usage.completion_tokens != null) {
-        span2.setAttribute("neatlogs.llm.token_count.completion", usage.completionTokens ?? usage.completion_tokens);
+    );
+  };
+}
+function tracedResponsesCreate2(original) {
+  return function(opts, ...rest) {
+    const tracer = import_api11.trace.getTracer(TRACER_NAME5);
+    const model = opts?.model ?? "";
+    const span2 = tracer.startSpan("azure_openai.responses.create", {
+      attributes: {
+        "neatlogs.span.kind": "LLM",
+        "neatlogs.llm.provider": PROVIDER,
+        "neatlogs.llm.system": SYSTEM,
+        "neatlogs.llm.model_name": model,
+        "input.value": safeStringify5(opts?.input ?? "")
       }
-      if (usage.totalTokens != null || usage.total_tokens != null) {
-        span2.setAttribute("neatlogs.llm.token_count.total", usage.totalTokens ?? usage.total_tokens);
+    }, import_api11.context.active());
+    const ctx = import_api11.trace.setSpan(import_api11.context.active(), span2);
+    const promise = import_api11.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_api11.SpanStatusCode.OK });
+        span2.end();
+        return response;
+      },
+      (err) => {
+        recordError3(span2, err);
+        throw err;
       }
-    }
+    );
+  };
+}
+function wrapAsyncIterableStream2(stream, span2) {
+  const chunks = [];
+  const originalAsyncIterator = stream?.[Symbol.asyncIterator]?.bind(stream);
+  if (!originalAsyncIterator) {
     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);
+    return stream;
   }
-  // --- 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);
+  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) {
+            finalizeStreamChunks2(span2, chunks);
+            return result;
+          }
+          chunks.push(result.value);
+          return result;
+        } catch (err) {
+          recordError3(span2, err);
+          throw err;
+        }
+      },
+      async return(value) {
+        finalizeStreamChunks2(span2, chunks);
+        return iterator.return?.(value) ?? { done: true, value: void 0 };
+      },
+      async throw(err) {
+        recordError3(span2, err);
+        return iterator.throw?.(err) ?? { done: true, value: void 0 };
+      }
+    };
+  };
+  return wrapped;
+}
+function finalizeStreamChunks2(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;
   }
-  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);
+  const fullText = textParts.join("");
+  if (fullText) {
+    span2.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
+    span2.setAttribute("neatlogs.llm.output_messages.0.content", fullText);
   }
-  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);
+  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++;
   }
-  // --- 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);
+  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);
+    }
   }
-  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();
+}
+function finalizeChatResponse2(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 ?? "");
       }
     }
-    span2.setStatus({ code: import_api11.SpanStatusCode.OK });
-    span2.end();
-    this._spans.delete(runId);
+    if (choices[i].finish_reason) {
+      span2.setAttribute("neatlogs.llm.finish_reason", choices[i].finish_reason);
+    }
   }
-  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);
+  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);
+    }
   }
-};
-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";
+  if (response?.model) span2.setAttribute("neatlogs.llm.model_name", response.model);
+  span2.setStatus({ code: import_api11.SpanStatusCode.OK });
+  span2.end();
 }
-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 setInvocationParams3(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", safeStringify5(opts.stop));
 }
 function safeStringify5(value) {
   try {
@@ -7390,325 +7490,901 @@ function safeStringify5(value) {
     return "";
   }
 }
+function recordError3(span2, err) {
+  if (err instanceof Error) {
+    span2.setStatus({ code: import_api11.SpanStatusCode.ERROR, message: err.message });
+    span2.recordException(err);
+  } else {
+    span2.setStatus({ code: import_api11.SpanStatusCode.ERROR, message: String(err) });
+  }
+  span2.end();
+}
 
-// 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;
+// src/vertex-ai.ts
+var import_api12 = require("@opentelemetry/api");
+var TRACER_NAME6 = "neatlogs.vertex_ai";
+var PROVIDER2 = "vertex_ai";
+var SYSTEM2 = "vertexai";
+function wrapVertexAI(client) {
+  return wrapNamespace4(client, []);
+}
+function traceTool4(name, fn) {
+  return async function tracedTool(args) {
+    const tracer = import_api12.trace.getTracer(TRACER_NAME6);
+    return tracer.startActiveSpan(
+      `tool.${name}`,
+      {
+        attributes: {
+          "neatlogs.span.kind": "TOOL",
+          "neatlogs.tool.name": name,
+          "input.value": safeStringify6(args)
+        }
+      },
+      import_api12.context.active(),
+      async (span2) => {
+        try {
+          const result = await fn(args);
+          span2.setAttribute("output.value", safeStringify6(result));
+          span2.setStatus({ code: import_api12.SpanStatusCode.OK });
+          return result;
+        } catch (err) {
+          recordError4(span2, err);
+          throw err;
+        } finally {
+          span2.end();
+        }
+      }
+    );
+  };
+}
+function wrapNamespace4(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 === "models.generateContent" && typeof value === "function") {
+        return tracedGenerateContent(value.bind(obj), false);
+      }
+      if (pathStr === "models.generateContentStream" && typeof value === "function") {
+        return tracedGenerateContent(value.bind(obj), true);
+      }
+      if (pathStr === "models.embedContent" && typeof value === "function") {
+        return tracedEmbedContent(value.bind(obj));
+      }
+      if (pathStr === "models.countTokens" && typeof value === "function") {
+        return tracedCountTokens(value.bind(obj));
+      }
+      if (value && typeof value === "object" && !Array.isArray(value) && isNamespace4(currentPath)) {
+        return wrapNamespace4(value, currentPath);
+      }
+      return value;
     }
+  });
+}
+function isNamespace4(path4) {
+  if (path4.length > 2) return false;
+  return ["models", "chats"].includes(path4[path4.length - 1]);
+}
+function wrapVertexAIChat(chat) {
+  const c = chat;
+  if (!c || c._neatlogsVertexPatched) return chat;
+  if (typeof c.sendMessage === "function") {
+    const orig = c.sendMessage.bind(c);
+    c.sendMessage = (params, ...rest) => tracedChatSend(orig, c, params, rest, false);
   }
-  return agent;
+  if (typeof c.sendMessageStream === "function") {
+    const orig = c.sendMessageStream.bind(c);
+    c.sendMessageStream = (params, ...rest) => tracedChatSend(orig, c, params, rest, true);
+  }
+  try {
+    Object.defineProperty(c, "_neatlogsVertexPatched", { value: true, enumerable: false, configurable: true });
+  } catch {
+    c._neatlogsVertexPatched = true;
+  }
+  return chat;
 }
-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 {
+function tracedChatSend(original, chat, params, rest, isStream) {
+  const tracer = import_api12.trace.getTracer(TRACER_NAME6);
+  const model = chat?.model ?? chat?.modelVersion ?? "";
+  const span2 = tracer.startSpan("vertex_ai.chat.send_message", {
+    attributes: {
+      "neatlogs.span.kind": "LLM",
+      "neatlogs.llm.provider": PROVIDER2,
+      "neatlogs.llm.system": SYSTEM2,
+      "neatlogs.llm.model_name": model,
+      "neatlogs.llm.is_streaming": isStream
+    }
+  }, import_api12.context.active());
+  const message = params?.message ?? params;
+  span2.setAttribute("neatlogs.llm.input_messages.0.role", "user");
+  span2.setAttribute(
+    "neatlogs.llm.input_messages.0.content",
+    typeof message === "string" ? message : safeStringify6(message)
+  );
+  const ctx = import_api12.trace.setSpan(import_api12.context.active(), span2);
+  const result = import_api12.context.with(ctx, () => original(params, ...rest));
+  return Promise.resolve(result).then(
+    (response) => {
+      if (isStream) return wrapStream(response, span2);
+      finalizeResponse(span2, response);
+      return response;
+    },
+    (err) => {
+      recordError4(span2, err);
+      throw err;
     }
-    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);
+function tracedEmbedContent(original) {
+  return function(opts, ...rest) {
+    const tracer = import_api12.trace.getTracer(TRACER_NAME6);
+    const span2 = tracer.startSpan("vertex_ai.models.embed_content", {
+      attributes: {
+        "neatlogs.span.kind": "EMBEDDING",
+        "neatlogs.llm.provider": PROVIDER2,
+        "neatlogs.embedding.model_name": opts?.model ?? "",
+        "neatlogs.embedding.text": safeStringify6(opts?.contents ?? "")
+      }
+    }, import_api12.context.active());
+    const ctx = import_api12.trace.setSpan(import_api12.context.active(), span2);
+    const result = import_api12.context.with(ctx, () => original(opts, ...rest));
+    return Promise.resolve(result).then(
+      (response) => {
+        const embeddings = response?.embeddings;
+        if (Array.isArray(embeddings)) {
+          span2.setAttribute("neatlogs.embedding.count", embeddings.length);
+          const vals = embeddings[0]?.values;
+          if (Array.isArray(vals)) span2.setAttribute("neatlogs.embedding.dimensions", vals.length);
+        }
+        span2.setStatus({ code: import_api12.SpanStatusCode.OK });
+        span2.end();
+        return response;
+      },
+      (err) => {
+        recordError4(span2, err);
+        throw err;
+      }
+    );
+  };
+}
+function tracedCountTokens(original) {
+  return function(opts, ...rest) {
+    const tracer = import_api12.trace.getTracer(TRACER_NAME6);
+    const span2 = tracer.startSpan("vertex_ai.models.count_tokens", {
+      attributes: {
+        "neatlogs.span.kind": "LLM",
+        "neatlogs.llm.provider": PROVIDER2,
+        "neatlogs.llm.task": "count_tokens",
+        "neatlogs.llm.model_name": opts?.model ?? ""
+      }
+    }, import_api12.context.active());
+    const ctx = import_api12.trace.setSpan(import_api12.context.active(), span2);
+    const result = import_api12.context.with(ctx, () => original(opts, ...rest));
+    return Promise.resolve(result).then(
+      (response) => {
+        if (response?.totalTokens != null) span2.setAttribute("neatlogs.llm.token_count.prompt", response.totalTokens);
+        span2.setStatus({ code: import_api12.SpanStatusCode.OK });
+        span2.end();
+        return response;
+      },
+      (err) => {
+        recordError4(span2, err);
+        throw err;
+      }
+    );
+  };
+}
+function tracedGenerateContent(original, isStream) {
+  return function(opts, ...rest) {
+    const tracer = import_api12.trace.getTracer(TRACER_NAME6);
+    const model = opts?.model ?? "";
+    const span2 = tracer.startSpan("vertex_ai.models.generate_content", {
+      attributes: {
+        "neatlogs.span.kind": "LLM",
+        "neatlogs.llm.provider": PROVIDER2,
+        "neatlogs.llm.system": SYSTEM2,
+        "neatlogs.llm.model_name": model,
+        "neatlogs.llm.is_streaming": isStream
+      }
+    }, import_api12.context.active());
+    setInputAttributes(span2, opts);
+    const ctx = import_api12.trace.setSpan(import_api12.context.active(), span2);
+    const result = import_api12.context.with(ctx, () => original(opts, ...rest));
+    return Promise.resolve(result).then(
+      (response) => {
+        if (isStream) {
+          return wrapStream(response, span2);
+        }
+        finalizeResponse(span2, response);
+        return response;
+      },
+      (err) => {
+        recordError4(span2, err);
+        throw err;
+      }
+    );
+  };
+}
+function setInputAttributes(span2, opts) {
+  let idx = 0;
+  const config = opts?.config;
+  const systemInstruction = config?.systemInstruction ?? config?.system_instruction;
+  if (systemInstruction) {
+    span2.setAttribute(`neatlogs.llm.input_messages.${idx}.role`, "system");
+    span2.setAttribute(
+      `neatlogs.llm.input_messages.${idx}.content`,
+      typeof systemInstruction === "string" ? systemInstruction : safeStringify6(systemInstruction)
+    );
+    idx++;
+  }
+  const contents = opts?.contents;
+  if (typeof contents === "string") {
+    span2.setAttribute(`neatlogs.llm.input_messages.${idx}.role`, "user");
+    span2.setAttribute(`neatlogs.llm.input_messages.${idx}.content`, contents);
+  } else if (Array.isArray(contents)) {
+    for (const item of contents) {
+      if (typeof item === "string") {
+        span2.setAttribute(`neatlogs.llm.input_messages.${idx}.role`, "user");
+        span2.setAttribute(`neatlogs.llm.input_messages.${idx}.content`, item);
+        idx++;
+      } else if (item && typeof item === "object") {
+        const role = item.role ?? "user";
+        span2.setAttribute(`neatlogs.llm.input_messages.${idx}.role`, role);
+        const parts = item.parts ?? [];
+        const textParts = [];
+        for (const part of parts) {
+          if (typeof part === "string") textParts.push(part);
+          else if (part?.text) textParts.push(part.text);
+        }
+        span2.setAttribute(
+          `neatlogs.llm.input_messages.${idx}.content`,
+          textParts.length ? textParts.join("\n") : safeStringify6(parts)
+        );
+        idx++;
       }
     }
-    return;
+  } else if (contents) {
+    span2.setAttribute(`neatlogs.llm.input_messages.${idx}.role`, "user");
+    span2.setAttribute(`neatlogs.llm.input_messages.${idx}.content`, safeStringify6(contents));
   }
-  if (eventName === "gen_ai.choice") {
-    const out = flattenStrandsContent(attrs.message);
-    if (out) setOutput(span2, isTool, out);
-    return;
+  const tools = config?.tools;
+  if (Array.isArray(tools)) {
+    let t = 0;
+    for (const tool of tools) {
+      const decls = tool?.functionDeclarations ?? tool?.function_declarations ?? [];
+      for (const fn of decls) {
+        span2.setAttribute(`neatlogs.llm.tools.${t}.name`, fn?.name ?? "");
+        if (fn?.description) span2.setAttribute(`neatlogs.llm.tools.${t}.description`, fn.description);
+        if (fn?.parameters) span2.setAttribute(`neatlogs.llm.tools.${t}.input_schema`, safeStringify6(fn.parameters));
+        t++;
+      }
+    }
   }
-  if (eventName === "gen_ai.client.inference.operation.details") {
-    const out = flattenStrandsContent(attrs["gen_ai.output.messages"]);
-    if (out) setOutput(span2, isTool, out);
+  if (config) {
+    if (config.temperature != null) span2.setAttribute("neatlogs.llm.temperature", config.temperature);
+    if (config.topP != null) span2.setAttribute("neatlogs.llm.top_p", config.topP);
+    if (config.topK != null) span2.setAttribute("neatlogs.llm.top_k", config.topK);
+    const maxTokens = config.maxOutputTokens ?? config.max_output_tokens;
+    if (maxTokens != null) span2.setAttribute("neatlogs.llm.max_tokens", maxTokens);
+    const params = {};
+    if (config.temperature != null) params.temperature = config.temperature;
+    if (config.topP != null) params.top_p = config.topP;
+    if (config.topK != null) params.top_k = config.topK;
+    if (maxTokens != null) params.max_tokens = maxTokens;
+    if (config.frequencyPenalty != null) params.frequency_penalty = config.frequencyPenalty;
+    if (config.presencePenalty != null) params.presence_penalty = config.presencePenalty;
+    if (Object.keys(params).length > 0) {
+      span2.setAttribute("neatlogs.llm.invocation_parameters", JSON.stringify(params));
+    }
   }
 }
-function setOutput(span2, isTool, out) {
-  span2.setAttribute("output.value", out);
-  if (isTool) {
-    span2.setAttribute("neatlogs.tool.output", out);
-  } else {
+function wrapStream(stream, span2) {
+  const chunks = [];
+  const originalAsyncIterator = stream?.[Symbol.asyncIterator]?.bind(stream);
+  if (!originalAsyncIterator) {
+    finalizeStreamChunks3(span2, chunks);
+    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) {
+            finalizeStreamChunks3(span2, chunks);
+            return result;
+          }
+          chunks.push(result.value);
+          return result;
+        } catch (err) {
+          recordError4(span2, err);
+          throw err;
+        }
+      },
+      async return(value) {
+        finalizeStreamChunks3(span2, chunks);
+        return iterator.return?.(value) ?? { done: true, value: void 0 };
+      },
+      async throw(err) {
+        recordError4(span2, err);
+        return iterator.throw?.(err) ?? { done: true, value: void 0 };
+      }
+    };
+  };
+  return wrapped;
+}
+function finalizeStreamChunks3(span2, chunks) {
+  const textParts = [];
+  let finishReason = "";
+  let usage = null;
+  for (const chunk of chunks) {
+    for (const candidate of chunk?.candidates ?? []) {
+      for (const part of candidate?.content?.parts ?? []) {
+        if (part?.text && !part?.thought) textParts.push(part.text);
+      }
+      if (candidate?.finishReason) finishReason = candidate.finishReason;
+    }
+    if (chunk?.usageMetadata) usage = chunk.usageMetadata;
+  }
+  const fullText = textParts.join("");
+  if (fullText) {
     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 }));
+    span2.setAttribute("neatlogs.llm.output_messages.0.content", fullText);
   }
+  if (finishReason) span2.setAttribute("neatlogs.llm.finish_reason", String(finishReason));
+  setUsage(span2, usage);
+  span2.setStatus({ code: import_api12.SpanStatusCode.OK });
+  span2.end();
 }
-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 finalizeResponse(span2, response) {
+  const textParts = [];
+  let toolIdx = 0;
+  for (const candidate of response?.candidates ?? []) {
+    for (const part of candidate?.content?.parts ?? []) {
+      if (part?.text && !part?.thought) {
+        textParts.push(part.text);
+      } else if (part?.thought && part?.text) {
+        span2.setAttribute("neatlogs.llm.output_messages.0.thinking", part.text);
+      } else if (part?.functionCall) {
+        const fc = part.functionCall;
+        span2.setAttribute(`neatlogs.llm.tool_calls.${toolIdx}.name`, fc?.name ?? "");
+        span2.setAttribute(`neatlogs.llm.tool_calls.${toolIdx}.arguments`, safeStringify6(fc?.args ?? {}));
+        toolIdx++;
+      }
+    }
+    if (candidate?.finishReason) span2.setAttribute("neatlogs.llm.finish_reason", String(candidate.finishReason));
+  }
+  if (textParts.length) {
+    span2.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
+    span2.setAttribute("neatlogs.llm.output_messages.0.content", textParts.join(""));
+  }
+  setUsage(span2, response?.usageMetadata);
+  span2.setStatus({ code: import_api12.SpanStatusCode.OK });
+  span2.end();
 }
-function readSpanOp(span2) {
+function setUsage(span2, usage) {
+  if (!usage) return;
+  if (usage.promptTokenCount != null) span2.setAttribute("neatlogs.llm.token_count.prompt", usage.promptTokenCount);
+  if (usage.candidatesTokenCount != null) span2.setAttribute("neatlogs.llm.token_count.completion", usage.candidatesTokenCount);
+  if (usage.totalTokenCount != null) span2.setAttribute("neatlogs.llm.token_count.total", usage.totalTokenCount);
+  if (usage.cachedContentTokenCount != null) span2.setAttribute("neatlogs.llm.token_count.cache_read", usage.cachedContentTokenCount);
+  if (usage.thoughtsTokenCount != null) span2.setAttribute("neatlogs.llm.token_count.reasoning", usage.thoughtsTokenCount);
+}
+function safeStringify6(value) {
   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() : "";
+    return typeof value === "string" ? value : JSON.stringify(value);
   } 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;
+function recordError4(span2, err) {
+  if (err instanceof Error) {
+    span2.setStatus({ code: import_api12.SpanStatusCode.ERROR, message: err.message });
+    span2.recordException(err);
+  } else {
+    span2.setStatus({ code: import_api12.SpanStatusCode.ERROR, message: String(err) });
+  }
+  span2.end();
+}
+
+// src/bedrock.ts
+var import_api13 = require("@opentelemetry/api");
+var TRACER_NAME7 = "neatlogs.bedrock";
+var PROVIDER3 = "bedrock";
+function traceTool5(name, fn) {
+  return async function tracedTool(args) {
+    const tracer = import_api13.trace.getTracer(TRACER_NAME7);
+    return tracer.startActiveSpan(
+      `tool.${name}`,
+      {
+        attributes: {
+          "neatlogs.span.kind": "TOOL",
+          "neatlogs.tool.name": name,
+          "input.value": safeStringify7(args)
+        }
+      },
+      import_api13.context.active(),
+      async (span2) => {
+        try {
+          const result = await fn(args);
+          span2.setAttribute("output.value", safeStringify7(result));
+          span2.setStatus({ code: import_api13.SpanStatusCode.OK });
+          return result;
+        } catch (err) {
+          recordError5(span2, err);
+          throw err;
+        } finally {
+          span2.end();
+        }
+      }
+    );
+  };
+}
+function wrapBedrock(client) {
+  const c = client;
+  if (c._neatlogsBedrockPatched) return client;
+  if (typeof c.send !== "function") return client;
+  const originalSend = c.send.bind(c);
+  c.send = function(command, ...rest) {
+    const name = command?.constructor?.name ?? "";
+    const input = command?.input ?? {};
+    if (name === "ConverseCommand") {
+      return tracedConverse(originalSend, command, input, rest, false);
+    }
+    if (name === "ConverseStreamCommand") {
+      return tracedConverse(originalSend, command, input, rest, true);
     }
+    if (name === "InvokeModelCommand") {
+      return tracedInvokeModel(originalSend, command, input, rest, false);
+    }
+    if (name === "InvokeModelWithResponseStreamCommand") {
+      return tracedInvokeModel(originalSend, command, input, rest, true);
+    }
+    return originalSend(command, ...rest);
+  };
+  c._neatlogsBedrockPatched = true;
+  return client;
+}
+function vendorFromModel(modelId) {
+  let tail = String(modelId ?? "").split("/").pop() ?? "";
+  for (const prefix of ["us.", "eu.", "apac.", "us-gov."]) {
+    if (tail.startsWith(prefix)) tail = tail.slice(prefix.length);
   }
-  return flattenBlocks(val);
+  const vendor = tail.includes(".") ? tail.split(".")[0] : "";
+  return vendor || "bedrock";
 }
-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;
+function startSpan(name, modelId, isStream) {
+  return import_api13.trace.getTracer(TRACER_NAME7).startSpan(name, {
+    attributes: {
+      "neatlogs.span.kind": "LLM",
+      "neatlogs.llm.provider": PROVIDER3,
+      "neatlogs.llm.system": vendorFromModel(modelId),
+      "neatlogs.llm.model_name": String(modelId ?? ""),
+      "neatlogs.llm.is_streaming": isStream
+    }
+  }, import_api13.context.active());
+}
+function tracedConverse(originalSend, command, input, rest, isStream) {
+  const span2 = startSpan(
+    isStream ? "bedrock.converse_stream" : "bedrock.converse",
+    input?.modelId,
+    isStream
+  );
+  setConverseInput(span2, input);
+  const ctx = import_api13.trace.setSpan(import_api13.context.active(), span2);
+  const promise = import_api13.context.with(ctx, () => originalSend(command, ...rest));
+  return promise.then(
+    (response) => {
+      if (isStream) {
+        return wrapConverseStream(response, span2);
+      }
+      finalizeConverse(span2, response);
+      return response;
+    },
+    (err) => {
+      recordError5(span2, err);
+      throw err;
     }
-    if (!item || typeof item !== "object") {
-      if (item != null) out.push(String(item));
-      continue;
+  );
+}
+function setConverseInput(span2, input) {
+  let idx = 0;
+  if (Array.isArray(input?.system)) {
+    const text = input.system.map((b) => b?.text ?? "").join(" ").trim();
+    if (text) {
+      span2.setAttribute(`neatlogs.llm.input_messages.${idx}.role`, "system");
+      span2.setAttribute(`neatlogs.llm.input_messages.${idx}.content`, text);
+      idx++;
     }
-    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");
+  for (const msg of input?.messages ?? []) {
+    span2.setAttribute(`neatlogs.llm.input_messages.${idx}.role`, msg?.role ?? "user");
+    span2.setAttribute(`neatlogs.llm.input_messages.${idx}.content`, converseBlocksToText(msg?.content));
+    idx++;
+  }
+  const cfg = input?.inferenceConfig ?? {};
+  if (cfg.temperature != null) span2.setAttribute("neatlogs.llm.temperature", cfg.temperature);
+  if (cfg.topP != null) span2.setAttribute("neatlogs.llm.top_p", cfg.topP);
+  if (cfg.maxTokens != null) span2.setAttribute("neatlogs.llm.max_tokens", cfg.maxTokens);
+  const tools = input?.toolConfig?.tools ?? [];
+  for (let i = 0; i < tools.length; i++) {
+    const spec = tools[i]?.toolSpec ?? {};
+    if (spec.name) span2.setAttribute(`neatlogs.llm.tools.${i}.name`, spec.name);
+    if (spec.description) span2.setAttribute(`neatlogs.llm.tools.${i}.description`, spec.description);
+    if (spec.inputSchema) span2.setAttribute(`neatlogs.llm.tools.${i}.input_schema`, safeStringify7(spec.inputSchema));
+  }
 }
-function safeStringify6(value) {
-  if (typeof value === "string") return value;
-  try {
-    return JSON.stringify(value) ?? "";
-  } catch {
-    return "";
+function converseBlocksToText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return safeStringify7(content);
+  const parts = [];
+  for (const block of content) {
+    if (block && typeof block === "object") {
+      if ("text" in block) parts.push(String(block.text));
+      else if ("toolResult" in block) parts.push(safeStringify7(block.toolResult));
+      else if ("toolUse" in block) parts.push(safeStringify7(block.toolUse));
+      else parts.push(safeStringify7(block));
+    } else {
+      parts.push(String(block));
+    }
   }
+  return parts.join("\n");
 }
-
-// src/openai-agents.ts
-var import_api12 = require("@opentelemetry/api");
-var TRACER_NAME6 = "neatlogs.openai_agents";
-function openaiAgentsProcessor() {
-  return new NeatlogsTraceProcessor();
+function finalizeConverse(span2, response) {
+  const content = response?.output?.message?.content ?? [];
+  const textParts = [];
+  let toolIdx = 0;
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+    if ("text" in block) {
+      textParts.push(String(block.text));
+    } else if ("toolUse" in block) {
+      const tu = block.toolUse;
+      span2.setAttribute(`neatlogs.llm.tool_calls.${toolIdx}.id`, String(tu?.toolUseId ?? ""));
+      span2.setAttribute(`neatlogs.llm.tool_calls.${toolIdx}.name`, String(tu?.name ?? ""));
+      span2.setAttribute(`neatlogs.llm.tool_calls.${toolIdx}.arguments`, safeStringify7(tu?.input ?? {}));
+      toolIdx++;
+    }
+  }
+  if (textParts.length) {
+    span2.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
+    span2.setAttribute("neatlogs.llm.output_messages.0.content", textParts.join(""));
+  }
+  if (response?.stopReason) span2.setAttribute("neatlogs.llm.finish_reason", String(response.stopReason));
+  setConverseUsage(span2, response?.usage);
+  span2.setStatus({ code: import_api13.SpanStatusCode.OK });
+  span2.end();
 }
-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 });
+function setConverseUsage(span2, usage) {
+  if (!usage) return;
+  if (usage.inputTokens != null) span2.setAttribute("neatlogs.llm.token_count.prompt", usage.inputTokens);
+  if (usage.outputTokens != null) span2.setAttribute("neatlogs.llm.token_count.completion", usage.outputTokens);
+  if (usage.totalTokens != null) span2.setAttribute("neatlogs.llm.token_count.total", usage.totalTokens);
+  if (usage.cacheReadInputTokens != null) span2.setAttribute("neatlogs.llm.token_count.cache_read", usage.cacheReadInputTokens);
+  if (usage.cacheWriteInputTokens != null) span2.setAttribute("neatlogs.llm.token_count.cache_write", usage.cacheWriteInputTokens);
+}
+function wrapConverseStream(response, span2) {
+  const stream = response?.stream;
+  if (!stream || typeof stream[Symbol.asyncIterator] !== "function") {
+    span2.setStatus({ code: import_api13.SpanStatusCode.OK });
     span2.end();
-    this._spans.delete(key);
-    this._startTimes.delete(key);
+    return response;
   }
-  // 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);
+  const originalIterator = stream[Symbol.asyncIterator].bind(stream);
+  const textParts = [];
+  const toolCalls = {};
+  let finishReason = "";
+  let usage = null;
+  const wrappedStream = {
+    [Symbol.asyncIterator]() {
+      const iterator = originalIterator();
+      return {
+        async next() {
+          try {
+            const result = await iterator.next();
+            if (result.done) {
+              finalizeConverseStream(span2, textParts, toolCalls, finishReason, usage);
+              return result;
+            }
+            const ev = result.value;
+            const delta = ev?.contentBlockDelta?.delta;
+            if (delta?.text) textParts.push(delta.text);
+            if (delta?.toolUse?.input) {
+              const idx = ev.contentBlockDelta.contentBlockIndex ?? 0;
+              toolCalls[idx] = toolCalls[idx] ?? { id: "", name: "", arguments: "" };
+              toolCalls[idx].arguments += delta.toolUse.input;
+            }
+            const startBlk = ev?.contentBlockStart?.start?.toolUse;
+            if (startBlk) {
+              const idx = ev.contentBlockStart.contentBlockIndex ?? 0;
+              toolCalls[idx] = toolCalls[idx] ?? { id: "", name: "", arguments: "" };
+              toolCalls[idx].name = startBlk.name ?? "";
+              toolCalls[idx].id = startBlk.toolUseId ?? "";
+            }
+            if (ev?.messageStop?.stopReason) finishReason = ev.messageStop.stopReason;
+            if (ev?.metadata?.usage) usage = ev.metadata.usage;
+            return result;
+          } catch (err) {
+            recordError5(span2, err);
+            throw err;
+          }
+        },
+        async return(value) {
+          finalizeConverseStream(span2, textParts, toolCalls, finishReason, usage);
+          return iterator.return?.(value) ?? { done: true, value: void 0 };
         }
-      }
-      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);
+    }
+  };
+  response.stream = wrappedStream;
+  return response;
+}
+function finalizeConverseStream(span2, textParts, toolCalls, finishReason, usage) {
+  const full = textParts.join("");
+  if (full) {
+    span2.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
+    span2.setAttribute("neatlogs.llm.output_messages.0.content", full);
+  }
+  let j = 0;
+  for (const tc of Object.values(toolCalls)) {
+    if (tc.id) 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 (finishReason) span2.setAttribute("neatlogs.llm.finish_reason", String(finishReason));
+  setConverseUsage(span2, usage);
+  span2.setStatus({ code: import_api13.SpanStatusCode.OK });
+  span2.end();
+}
+function isEmbeddingModel(modelId) {
+  return String(modelId ?? "").toLowerCase().includes("embed");
+}
+function tracedInvokeModel(originalSend, command, input, rest, isStream) {
+  const vendor = vendorFromModel(input?.modelId);
+  const isEmbedding = !isStream && isEmbeddingModel(input?.modelId);
+  const bodyIn = decodeBody(input?.body);
+  let span2;
+  if (isEmbedding) {
+    span2 = import_api13.trace.getTracer(TRACER_NAME7).startSpan("bedrock.invoke_model", {
+      attributes: {
+        "neatlogs.span.kind": "EMBEDDING",
+        "neatlogs.llm.provider": PROVIDER3,
+        "neatlogs.embedding.model_name": String(input?.modelId ?? "")
       }
-      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);
+    }, import_api13.context.active());
+    const text = bodyIn?.inputText ?? bodyIn?.texts ?? bodyIn?.input_text;
+    if (text) {
+      span2.setAttribute("neatlogs.embedding.text", typeof text === "string" ? text : safeStringify7(text));
     }
-    this._spans.set(spanId, otelSpan);
-    this._startTimes.set(spanId, Date.now());
+  } else {
+    span2 = startSpan(
+      isStream ? "bedrock.invoke_model_with_response_stream" : "bedrock.invoke_model",
+      input?.modelId,
+      isStream
+    );
+    setInvokeInput(span2, vendor, bodyIn);
   }
-  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 ctx = import_api13.trace.setSpan(import_api13.context.active(), span2);
+  const promise = import_api13.context.with(ctx, () => originalSend(command, ...rest));
+  return promise.then(
+    (response) => {
+      if (isStream) {
+        return wrapInvokeStream(response, span2, vendor);
       }
-      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);
+      try {
+        if (isEmbedding) {
+          finalizeInvokeEmbedding(span2, decodeBody(response?.body));
+        } else {
+          finalizeInvoke(span2, vendor, decodeBody(response?.body));
         }
+      } catch {
+        span2.setStatus({ code: import_api13.SpanStatusCode.OK });
+        span2.end();
       }
-    } 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 });
+      return response;
+    },
+    (err) => {
+      recordError5(span2, err);
+      throw err;
     }
-    if (startTime) {
-      otelSpan.setAttribute("neatlogs.llm.metrics.duration_ms", Date.now() - startTime);
+  );
+}
+function finalizeInvokeEmbedding(span2, body) {
+  const emb = body?.embedding;
+  const embs = body?.embeddings;
+  if (Array.isArray(emb)) {
+    span2.setAttribute("neatlogs.embedding.count", 1);
+    span2.setAttribute("neatlogs.embedding.dimensions", emb.length);
+  } else if (Array.isArray(embs) && embs.length) {
+    span2.setAttribute("neatlogs.embedding.count", embs.length);
+    if (Array.isArray(embs[0])) span2.setAttribute("neatlogs.embedding.dimensions", embs[0].length);
+  }
+  if (body?.inputTextTokenCount != null) {
+    span2.setAttribute("neatlogs.llm.token_count.prompt", body.inputTextTokenCount);
+    span2.setAttribute("neatlogs.embedding.token_count", body.inputTextTokenCount);
+  }
+  span2.setStatus({ code: import_api13.SpanStatusCode.OK });
+  span2.end();
+}
+function decodeBody(body) {
+  try {
+    if (body == null) return {};
+    if (typeof body === "string") return JSON.parse(body);
+    if (body instanceof Uint8Array) return JSON.parse(new TextDecoder().decode(body));
+    if (typeof body === "object" && typeof body.byteLength === "number") {
+      return JSON.parse(new TextDecoder().decode(body));
     }
-    otelSpan.end();
-    this._spans.delete(spanId);
-    this._startTimes.delete(spanId);
+    if (typeof body === "object") return body;
+  } catch {
   }
-  shutdown() {
-    for (const [, span2] of this._spans) {
-      span2.setStatus({ code: import_api12.SpanStatusCode.ERROR, message: "Processor shutdown before span completed" });
-      span2.end();
+  return {};
+}
+function setInvokeInput(span2, vendor, body) {
+  let idx = 0;
+  if (body?.system) {
+    span2.setAttribute(`neatlogs.llm.input_messages.${idx}.role`, "system");
+    span2.setAttribute(
+      `neatlogs.llm.input_messages.${idx}.content`,
+      typeof body.system === "string" ? body.system : safeStringify7(body.system)
+    );
+    idx++;
+  }
+  if (Array.isArray(body?.messages)) {
+    for (const msg of body.messages) {
+      span2.setAttribute(`neatlogs.llm.input_messages.${idx}.role`, msg?.role ?? "user");
+      span2.setAttribute(
+        `neatlogs.llm.input_messages.${idx}.content`,
+        typeof msg?.content === "string" ? msg.content : safeStringify7(msg?.content)
+      );
+      idx++;
+    }
+  } else if (body?.prompt) {
+    span2.setAttribute(`neatlogs.llm.input_messages.${idx}.role`, "user");
+    span2.setAttribute(`neatlogs.llm.input_messages.${idx}.content`, String(body.prompt));
+  } else if (body?.inputText) {
+    span2.setAttribute(`neatlogs.llm.input_messages.${idx}.role`, "user");
+    span2.setAttribute(`neatlogs.llm.input_messages.${idx}.content`, String(body.inputText));
+  }
+  if (body?.temperature != null) span2.setAttribute("neatlogs.llm.temperature", body.temperature);
+  if (body?.top_p != null) span2.setAttribute("neatlogs.llm.top_p", body.top_p);
+  const maxTokens = body?.max_tokens ?? body?.maxTokens ?? body?.max_tokens_to_sample;
+  if (maxTokens != null) span2.setAttribute("neatlogs.llm.max_tokens", maxTokens);
+  const cfg = body?.textGenerationConfig;
+  if (cfg) {
+    if (cfg.temperature != null) span2.setAttribute("neatlogs.llm.temperature", cfg.temperature);
+    if (cfg.topP != null) span2.setAttribute("neatlogs.llm.top_p", cfg.topP);
+    if (cfg.maxTokenCount != null) span2.setAttribute("neatlogs.llm.max_tokens", cfg.maxTokenCount);
+  }
+}
+function finalizeInvoke(span2, vendor, body) {
+  let text;
+  let promptTokens;
+  let completionTokens;
+  let finishReason;
+  if (vendor === "anthropic") {
+    if (Array.isArray(body?.content)) {
+      text = body.content.filter((b) => b?.type === "text").map((b) => b.text).join("");
+      let toolIdx = 0;
+      for (const b of body.content) {
+        if (b?.type === "tool_use") {
+          span2.setAttribute(`neatlogs.llm.tool_calls.${toolIdx}.id`, String(b.id ?? ""));
+          span2.setAttribute(`neatlogs.llm.tool_calls.${toolIdx}.name`, String(b.name ?? ""));
+          span2.setAttribute(`neatlogs.llm.tool_calls.${toolIdx}.arguments`, safeStringify7(b.input ?? {}));
+          toolIdx++;
+        }
+      }
+    } else if (body?.completion != null) {
+      text = body.completion;
+    }
+    promptTokens = body?.usage?.input_tokens;
+    completionTokens = body?.usage?.output_tokens;
+    finishReason = body?.stop_reason;
+  } else if (vendor === "amazon") {
+    const r = Array.isArray(body?.results) ? body.results[0] : void 0;
+    if (r) {
+      text = r.outputText;
+      completionTokens = r.tokenCount;
+      finishReason = r.completionReason;
+    }
+    promptTokens = body?.inputTextTokenCount;
+  } else if (vendor === "meta") {
+    text = body?.generation;
+    promptTokens = body?.prompt_token_count;
+    completionTokens = body?.generation_token_count;
+    finishReason = body?.stop_reason;
+  } else if (vendor === "cohere") {
+    const g = Array.isArray(body?.generations) ? body.generations[0] : void 0;
+    if (g) {
+      text = g.text;
+      finishReason = g.finish_reason;
     }
-    this._spans.clear();
-    this._startTimes.clear();
+  } else {
+    text = body?.generation ?? body?.completion ?? body?.outputText;
   }
-  forceFlush() {
+  if (text) {
+    span2.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
+    span2.setAttribute("neatlogs.llm.output_messages.0.content", String(text));
   }
-};
+  if (promptTokens != null) span2.setAttribute("neatlogs.llm.token_count.prompt", promptTokens);
+  if (completionTokens != null) span2.setAttribute("neatlogs.llm.token_count.completion", completionTokens);
+  if (promptTokens != null && completionTokens != null) {
+    span2.setAttribute("neatlogs.llm.token_count.total", promptTokens + completionTokens);
+  }
+  if (finishReason) span2.setAttribute("neatlogs.llm.finish_reason", String(finishReason));
+  span2.setStatus({ code: import_api13.SpanStatusCode.OK });
+  span2.end();
+}
+function wrapInvokeStream(response, span2, vendor) {
+  const body = response?.body;
+  if (!body || typeof body[Symbol.asyncIterator] !== "function") {
+    span2.setStatus({ code: import_api13.SpanStatusCode.OK });
+    span2.end();
+    return response;
+  }
+  const originalIterator = body[Symbol.asyncIterator].bind(body);
+  const textParts = [];
+  let promptTokens;
+  let completionTokens;
+  let finishReason;
+  const finalize = () => {
+    const full = textParts.join("");
+    if (full) {
+      span2.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
+      span2.setAttribute("neatlogs.llm.output_messages.0.content", full);
+    }
+    if (promptTokens != null) span2.setAttribute("neatlogs.llm.token_count.prompt", promptTokens);
+    if (completionTokens != null) span2.setAttribute("neatlogs.llm.token_count.completion", completionTokens);
+    if (finishReason) span2.setAttribute("neatlogs.llm.finish_reason", String(finishReason));
+    span2.setStatus({ code: import_api13.SpanStatusCode.OK });
+    span2.end();
+  };
+  const wrappedBody = {
+    [Symbol.asyncIterator]() {
+      const iterator = originalIterator();
+      return {
+        async next() {
+          try {
+            const result = await iterator.next();
+            if (result.done) {
+              finalize();
+              return result;
+            }
+            const data = decodeBody(result.value?.chunk?.bytes);
+            if (data?.type === "content_block_delta") {
+              textParts.push(data?.delta?.text ?? "");
+            } else if (data?.type === "message_delta") {
+              if (data?.delta?.stop_reason) finishReason = data.delta.stop_reason;
+              if (data?.usage?.output_tokens != null) completionTokens = data.usage.output_tokens;
+            }
+            if (data?.outputText) textParts.push(data.outputText);
+            if (data?.generation) textParts.push(data.generation);
+            const metrics2 = data?.["amazon-bedrock-invocationMetrics"];
+            if (metrics2) {
+              promptTokens = metrics2.inputTokenCount ?? promptTokens;
+              completionTokens = metrics2.outputTokenCount ?? completionTokens;
+            }
+            return result;
+          } catch (err) {
+            recordError5(span2, err);
+            throw err;
+          }
+        },
+        async return(value) {
+          finalize();
+          return iterator.return?.(value) ?? { done: true, value: void 0 };
+        }
+      };
+    }
+  };
+  response.body = wrappedBody;
+  return response;
+}
 function safeStringify7(value) {
   try {
     return typeof value === "string" ? value : JSON.stringify(value);
@@ -7716,525 +8392,1687 @@ function safeStringify7(value) {
     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;
+function recordError5(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) });
   }
-  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);
+  span2.end();
+}
+
+// src/langchain.ts
+var import_api14 = require("@opentelemetry/api");
+var TRACER_NAME8 = "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_api14.trace.getTracer(TRACER_NAME8);
+    const name = serialized?.name ?? serialized?.id?.at(-1) ?? "chain";
+    const parentSpan = parentRunId ? this._spans.get(parentRunId) : void 0;
+    const parentCtx = parentSpan ? import_api14.trace.setSpan(import_api14.context.active(), parentSpan) : import_api14.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"] = safeStringify8(inputs);
+    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", safeStringify8(outputs));
+    span2.setStatus({ code: import_api14.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_api14.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_api14.trace.getTracer(TRACER_NAME8);
+    const model = serialized?.kwargs?.model_name ?? serialized?.kwargs?.model ?? serialized?.name ?? "";
+    const parentSpan = parentRunId ? this._spans.get(parentRunId) : void 0;
+    const parentCtx = parentSpan ? import_api14.trace.setSpan(import_api14.context.active(), parentSpan) : import_api14.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];
+    }
+    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_api14.trace.getTracer(TRACER_NAME8);
+    const model = serialized?.kwargs?.model_name ?? serialized?.kwargs?.model ?? serialized?.name ?? "";
+    const parentSpan = parentRunId ? this._spans.get(parentRunId) : void 0;
+    const parentCtx = parentSpan ? import_api14.trace.setSpan(import_api14.context.active(), parentSpan) : import_api14.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 : safeStringify8(msg?.content);
+      attrs[`neatlogs.llm.input_messages.${i}.role`] = mapRole(role);
+      attrs[`neatlogs.llm.input_messages.${i}.content`] = content;
+    }
+    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));
+        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 ? safeStringify8(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_api14.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_api14.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_api14.trace.getTracer(TRACER_NAME8);
+    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_api14.trace.setSpan(import_api14.context.active(), parentSpan) : import_api14.context.active();
+    const attrs = {
+      "neatlogs.span.kind": "TOOL",
+      "neatlogs.tool.name": name,
+      "input.value": String(input)
+    };
+    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));
+    span2.setStatus({ code: import_api14.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_api14.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_api14.trace.getTracer(TRACER_NAME8);
+    const name = serialized?.name ?? "retriever";
+    const parentSpan = parentRunId ? this._spans.get(parentRunId) : void 0;
+    const parentCtx = parentSpan ? import_api14.trace.setSpan(import_api14.context.active(), parentSpan) : import_api14.context.active();
+    const attrs = {
+      "neatlogs.span.kind": "RETRIEVER",
+      "neatlogs.retriever.name": name,
+      "input.value": query
+    };
+    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);
+        }
+      }
+    }
+    span2.setStatus({ code: import_api14.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_api14.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 safeStringify8(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", safeStringify9({ 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 = safeStringify9({ 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"}(${safeStringify9(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(safeStringify9(o));
+  }
+  return out.filter(Boolean).join("\n");
+}
+function safeStringify9(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return "";
+  }
+}
+
+// src/openai-agents.ts
+var import_api15 = require("@opentelemetry/api");
+var TRACER_NAME9 = "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_api15.trace.getTracer(TRACER_NAME9);
+    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_api15.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_api15.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_api15.trace.getTracer(TRACER_NAME9);
+    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_api15.trace.setSpan(import_api15.context.active(), parentSpan) : import_api15.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 : safeStringify10(content);
+        }
+      }
+      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 : safeStringify10(toolInput);
+      }
+      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);
+        }
+        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 : safeStringify10(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 : safeStringify10(c));
+      }
+      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 : safeStringify10(output));
+      }
+    } else if (spanType === "agent" || spanType === "agent_run") {
+      const output = data?.output;
+      if (output != null) {
+        otelSpan.setAttribute("output.value", typeof output === "string" ? output : safeStringify10(output));
+      }
+    }
+    const error = data?.error ?? span2?.error;
+    if (error) {
+      if (error instanceof Error) {
+        otelSpan.setStatus({ code: import_api15.SpanStatusCode.ERROR, message: error.message });
+        otelSpan.recordException(error);
+      } else {
+        otelSpan.setStatus({ code: import_api15.SpanStatusCode.ERROR, message: String(error) });
+      }
+    } else {
+      otelSpan.setStatus({ code: import_api15.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_api15.SpanStatusCode.ERROR, message: "Processor shutdown before span completed" });
+      span2.end();
+    }
+    this._spans.clear();
+    this._startTimes.clear();
+  }
+  forceFlush() {
+  }
+};
+function safeStringify10(value) {
+  try {
+    return typeof value === "string" ? value : JSON.stringify(value);
+  } catch {
+    return "";
+  }
+}
+
+// src/mastra-wrap.ts
+var import_api16 = require("@opentelemetry/api");
+var TRACER_NAME10 = "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;
+    }
+    if (streaming) attrs["neatlogs.llm.is_streaming"] = true;
+    if (streaming) {
+      const tracer = import_api16.trace.getTracer(TRACER_NAME10);
+      const span2 = tracer.startSpan(`mastra.agent.${agentName}`, { attributes: attrs }, import_api16.context.active());
+      const ctx = import_api16.trace.setSpan(import_api16.context.active(), span2);
+      try {
+        const result = await import_api16.context.with(ctx, () => orig(input, opts));
+        return wrapStreamingOutput(result, span2, ctx);
+      } catch (err) {
+        recordError6(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"] = safeStringify11(promptInput);
+      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": safeStringify11(params)
+    };
+    if (tool.description) attrs["neatlogs.tool.description"] = String(tool.description);
+    return withActiveSpan(`mastra.tool.${toolName}`, attrs, async (span2) => {
+      const result = await orig(params, options);
+      span2.setAttribute("output.value", safeStringify11(result));
+      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"] = safeStringify11(startOpts.inputData);
+    }
+    return withActiveSpan(`mastra.workflow.${workflowName}`, attrs, async (span2) => {
+      const result = await orig(startOpts);
+      if (result?.status) span2.setAttribute("neatlogs.metadata", safeStringify11({ status: result.status }));
+      if (result?.result !== void 0) {
+        span2.setAttribute("output.value", safeStringify11(result.result));
+      }
+      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": safeStringify11(params)
+    };
+    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", safeStringify11(result));
+      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": safeStringify11(args?.[0])
+      };
+      return withActiveSpan(`mastra.memory.${op}`, attrs, async (span2) => {
+        const result = await orig(...args);
+        span2.setAttribute("output.value", safeStringify11(result));
+        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_api16.SpanStatusCode.OK });
+    span2.end();
+    return output;
+  }
+  let ended = false;
+  const endOnce = (err) => {
+    if (ended) return;
+    ended = true;
+    if (err) recordError6(span2, err);
+    else span2.setStatus({ code: import_api16.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);
+        }
+        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(""));
+        }
+        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_api16.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));
   }
-  markPatched(e);
-  return entity;
+  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 isRootMastra(e) {
-  return typeof e.getAgent === "function" && typeof e.getWorkflow === "function";
+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);
+  } 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);
+    }
+    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", safeStringify11(result.content));
+  }
+  if (result.usage) recordUsage(span2, result.usage);
+  span2.setAttribute("neatlogs.llm.stop_reason", normalizeFinishReason(result.finishReason));
 }
-function isAgent(e, className) {
-  return className === "Agent" || typeof e.generate === "function" || typeof e.stream === "function";
+function normalizeFinishReason(fr) {
+  if (fr == null) return "";
+  if (typeof fr === "string") return fr;
+  return String(fr.unified ?? fr.reason ?? fr.type ?? safeStringify11(fr));
 }
-function isWorkflow(e, className) {
-  return className === "Workflow" || typeof e.createRun === "function";
+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 isVector(e, className) {
-  return /Vector/.test(className) || typeof e.query === "function" && typeof e.upsert === "function";
+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"] = safeStringify11(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}`] = safeStringify11(callOpts.tools[i]);
+    }
+    invocation.toolChoice = callOpts.toolChoice;
+  }
+  if (Object.keys(invocation).length) {
+    attrs["neatlogs.llm.invocation_parameters"] = safeStringify11(invocation);
+  }
 }
-function isMemory(e, className) {
-  return /Memory/.test(className) || typeof e.recall === "function" && typeof e.saveMessages === "function";
+function setToolCall(span2, i, name, args, id) {
+  span2.setAttribute(`neatlogs.llm.tool_calls.${i}.name`, name ?? "");
+  span2.setAttribute(`neatlogs.llm.tool_calls.${i}.arguments`, safeStringify11(args ?? {}));
+  if (id) span2.setAttribute(`neatlogs.llm.tool_calls.${i}.id`, id);
 }
-function isDocument(e, className) {
-  return className === "MDocument" || typeof e.chunk === "function" && typeof e.getDocs === "function";
+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 patchAgent(agent) {
-  patchAgentMethod(agent, "generate", false);
-  patchAgentMethod(agent, "stream", true);
+function withActiveSpan(name, attrs, fn) {
+  const tracer = import_api16.trace.getTracer(TRACER_NAME10);
+  const span2 = tracer.startSpan(name, { attributes: attrs }, import_api16.context.active());
+  const ctx = import_api16.trace.setSpan(import_api16.context.active(), span2);
+  return import_api16.context.with(ctx, async () => {
+    try {
+      const result = await fn(span2);
+      span2.setStatus({ code: import_api16.SpanStatusCode.OK });
+      return result;
+    } catch (err) {
+      recordError6(span2, err);
+      throw err;
+    } finally {
+      span2.end();
+    }
+  });
 }
-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);
+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 : safeStringify11(input);
+}
+function safeStringify11(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return "";
+  }
+}
+function recordError6(span2, err) {
+  if (err instanceof Error) {
+    span2.setStatus({ code: import_api16.SpanStatusCode.ERROR, message: err.message });
+    span2.recordException(err);
+  } else {
+    span2.setStatus({ code: import_api16.SpanStatusCode.ERROR, message: String(err) });
+  }
+}
+
+// src/pi-agent.ts
+var import_api17 = require("@opentelemetry/api");
+var TRACER_NAME11 = "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_api17.trace.getTracer(TRACER_NAME11);
+  a.subscribe((event) => {
+    try {
+      handleEvent(tracer, state, event);
+    } catch {
     }
-    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;
+  });
+  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_api17.context.active()
+      );
+      state.agentSpan = span2;
+      state.agentCtx = import_api17.trace.setSpan(import_api17.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;
     }
-    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 {
+    case "tool_execution_start": {
+      const parent = state.agentCtx ?? import_api17.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": safeStringify12(event.args) } : {}
+          }
+        },
+        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", safeStringify12(event.result));
+      }
+      if (event.isError) {
+        span2.setStatus({ code: import_api17.SpanStatusCode.ERROR });
+        span2.setAttribute("neatlogs.tool.is_error", true);
+      } else {
+        span2.setStatus({ code: import_api17.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);
+        const finalText = lastAssistantText(event.messages);
+        if (finalText) state.agentSpan.setAttribute("output.value", finalText);
+        state.agentSpan.setStatus({ code: import_api17.SpanStatusCode.OK });
+        state.agentSpan.end();
+        state.agentSpan = void 0;
+        state.agentCtx = void 0;
       }
-      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;
-      });
-    };
+      break;
+    }
+    default:
+      break;
   }
 }
-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;
+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;
+    });
+    attrs["neatlogs.llm.input"] = safeStringify12({ messages: inMsgs });
+    attrs["input.value"] = safeStringify12({ messages: inMsgs });
   }
-  if (!tools || typeof tools !== "object") return;
-  agent.__neatlogs_tool_hook = true;
-  for (const [key, tool] of Object.entries(tools)) {
-    patchToolExecute(tool, key);
+  const { text, toolCalls } = splitAssistantContent(msg.content);
+  const outText = text || toolCalls.map((tc) => `${tc.name}(${safeStringify12(tc.arguments)})`).join("\n");
+  if (outText || toolCalls.length) {
+    attrs["neatlogs.llm.output_messages.0.role"] = "assistant";
+    attrs["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.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);
+      });
+    }
+    attrs["neatlogs.llm.output"] = safeStringify12(outBlob);
+    attrs["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;
+    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_api17.context.active();
+  const span2 = tracer.startSpan(
+    `pi_agent.llm.${msg.model || "model"}`,
+    { attributes: attrs },
+    parent
+  );
+  span2.setStatus({ code: import_api17.SpanStatusCode.OK });
+  span2.end();
 }
-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 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 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);
+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"}(${safeStringify12(block.arguments)})`);
     }
-    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;
-    });
-  };
+  }
+  return parts.join("");
 }
-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 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 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;
-    });
-  };
+function markPatched2(e) {
+  try {
+    Object.defineProperty(e, PATCH_FLAG3, { value: true, enumerable: false, configurable: true });
+  } catch {
+    e[PATCH_FLAG3] = true;
+  }
 }
-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 safeStringify12(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return "";
   }
 }
-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;
+
+// src/claude-agent-sdk.ts
+var import_api18 = require("@opentelemetry/api");
+var TRACER_NAME12 = "neatlogs.claude_agent_sdk";
+var ROOT_SCOPE = "__root__";
+function wrapClaudeAgentSDK(sdk, options = {}) {
+  if (!sdk || typeof sdk.query !== "function") return sdk;
+  if (sdk._neatlogsWrapped) return sdk;
+  const wrapped = { ...sdk };
+  wrapped.query = wrapQuery(sdk.query.bind(sdk), options);
+  try {
+    Object.defineProperty(wrapped, "_neatlogsWrapped", {
+      value: true,
+      enumerable: false,
+      configurable: true
     });
-  };
-}
-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;
+  } catch {
+    wrapped._neatlogsWrapped = true;
   }
-  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();
+  return wrapped;
+}
+function wrapQuery(original, options) {
+  return function(params, ...rest) {
+    const tracer = import_api18.trace.getTracer(TRACER_NAME12);
+    const workflowName = options.workflowName ?? "claude_agent.query";
+    const promptRef = { text: "" };
+    const agentSpan = tracer.startSpan(
+      "claude_agent.query",
+      { attributes: { "neatlogs.span.kind": "AGENT", "neatlogs.workflow.name": workflowName } },
+      import_api18.context.active()
+    );
+    const promptText = extractPromptText(params?.prompt);
+    if (promptText) {
+      promptRef.text = promptText;
+      agentSpan.setAttribute("input.value", promptText);
+    } else if (params && isAsyncIterable(params.prompt)) {
+      params = { ...params, prompt: tapPromptStream(params.prompt, promptRef) };
+    }
+    const agentCtx = import_api18.trace.setSpan(import_api18.context.active(), agentSpan);
+    const queryObj = import_api18.context.with(agentCtx, () => original(params, ...rest));
+    return instrumentQueryIterable(queryObj, agentSpan, agentCtx, tracer, promptRef);
+  };
+}
+function isAsyncIterable(v) {
+  return Boolean(v) && typeof v[Symbol.asyncIterator] === "function";
+}
+async function* tapPromptStream(prompt, ref) {
+  for await (const message of prompt) {
+    if (!ref.text) {
+      const text = userMessageText(message);
+      if (text) ref.text = text;
+    }
+    yield message;
+  }
+}
+function instrumentQueryIterable(queryObj, agentSpan, agentCtx, tracer, promptRef) {
+  const originalAsyncIterator = queryObj?.[Symbol.asyncIterator]?.bind(queryObj);
+  if (!originalAsyncIterator) {
+    agentSpan.setStatus({ code: import_api18.SpanStatusCode.OK });
+    agentSpan.end();
+    return queryObj;
+  }
+  const rootScope = {
+    span: agentSpan,
+    ctx: agentCtx,
+    inputMessages: promptRef.text ? [{ role: "user", content: promptRef.text }] : [],
+    assistantBuffer: null,
+    finalText: "",
+    inputCaptured: Boolean(promptRef.text)
   };
-  if (output.text && typeof output.text.then === "function") {
-    const finalize = async () => {
+  const state = {
+    toolSpans: /* @__PURE__ */ new Map(),
+    scopes: /* @__PURE__ */ new Map([[ROOT_SCOPE, rootScope]]),
+    finished: false,
+    promptRef
+  };
+  const finalizeAgent = (status, err) => {
+    if (state.finished) return;
+    state.finished = true;
+    for (const scope of state.scopes.values()) flushAssistantTurn(tracer, scope, state);
+    for (const ts of state.toolSpans.values()) {
       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);
+        ts.end();
+      } catch {
       }
-    };
-    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() {
+    }
+    state.toolSpans.clear();
+    for (const [key, scope] of state.scopes) {
+      if (key === ROOT_SCOPE) continue;
+      closeScope(scope, "ok");
+    }
+    if (rootScope.finalText) agentSpan.setAttribute("output.value", rootScope.finalText);
+    if (status === "error") {
+      recordError7(agentSpan, err);
+    } else {
+      agentSpan.setStatus({ code: import_api18.SpanStatusCode.OK });
+      agentSpan.end();
+    }
+  };
+  const wrapped = Object.create(Object.getPrototypeOf(queryObj));
+  Object.assign(wrapped, queryObj);
+  wrapped[Symbol.asyncIterator] = function() {
+    const iterator = originalAsyncIterator();
+    return {
+      async next() {
+        try {
+          const result = await import_api18.context.with(agentCtx, () => iterator.next());
+          if (result.done) {
+            finalizeAgent("ok");
+            return result;
+          }
           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;
+            handleMessage(tracer, state, result.value, finalizeAgent);
+          } catch {
           }
-        },
-        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 result;
+        } catch (err) {
+          finalizeAgent("error", err);
+          throw err;
         }
-      };
+      },
+      async return(value) {
+        finalizeAgent("ok");
+        return iterator.return?.(value) ?? { done: true, value: void 0 };
+      },
+      async throw(err) {
+        finalizeAgent("error", err);
+        if (iterator.throw) return iterator.throw(err);
+        throw err;
+      }
     };
-    return wrapped;
-  }
-  if (typeof output.then === "function") {
-    return output.then((resolved) => {
-      finalizeAgentResult(span2, resolved);
-      endOnce();
-      return resolved;
-    }).catch((err) => {
-      endOnce(err);
-      throw err;
-    });
+  };
+  return wrapped;
+}
+function closeScope(scope, status) {
+  try {
+    if (scope.finalText) scope.span.setAttribute("output.value", scope.finalText);
+    scope.span.setStatus({ code: status === "ok" ? import_api18.SpanStatusCode.OK : import_api18.SpanStatusCode.ERROR });
+    scope.span.end();
+  } catch {
   }
-  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());
-          }
-        };
+function getScope(tracer, state, msg) {
+  const parentId = msg?.parent_tool_use_id ?? null;
+  if (!parentId) return state.scopes.get(ROOT_SCOPE);
+  const existing = state.scopes.get(parentId);
+  if (existing) return existing;
+  const root = state.scopes.get(ROOT_SCOPE);
+  if (!state.toolSpans.has(parentId) && root.assistantBuffer) {
+    flushAssistantTurn(tracer, root, state);
+  }
+  const parentToolSpan = state.toolSpans.get(parentId);
+  const parentCtx = parentToolSpan ? import_api18.trace.setSpan(import_api18.context.active(), parentToolSpan) : state.scopes.get(ROOT_SCOPE).ctx;
+  const subType = msg?.subagent_type ? String(msg.subagent_type) : "subagent";
+  const attrs = {
+    "neatlogs.span.kind": "AGENT",
+    "neatlogs.agent.name": subType
+  };
+  if (msg?.task_description) attrs["input.value"] = String(msg.task_description);
+  const span2 = tracer.startSpan(`claude_agent.subagent.${subType}`, { attributes: attrs }, parentCtx);
+  const scope = {
+    span: span2,
+    ctx: import_api18.trace.setSpan(import_api18.context.active(), span2),
+    inputMessages: msg?.task_description ? [{ role: "user", content: String(msg.task_description) }] : [],
+    assistantBuffer: null,
+    finalText: "",
+    inputCaptured: Boolean(msg?.task_description)
+  };
+  state.scopes.set(parentId, scope);
+  return scope;
+}
+function handleMessage(tracer, state, msg, finalizeAgent) {
+  if (!msg || typeof msg !== "object") return;
+  const rootScope = state.scopes.get(ROOT_SCOPE);
+  if (!rootScope.inputCaptured && state.promptRef.text) {
+    rootScope.inputCaptured = true;
+    rootScope.span.setAttribute("input.value", state.promptRef.text);
+  }
+  switch (msg.type) {
+    case "system": {
+      if (msg.session_id) {
+        state.sessionId = msg.session_id;
+        rootScope.span.setAttribute("neatlogs.conversation.id", String(msg.session_id));
+      }
+      if (msg.model) {
+        state.model = msg.model;
+        rootScope.span.setAttribute("neatlogs.agent.model", String(msg.model));
       }
-      if (typeof value === "function") return value.bind(target);
-      return value;
+      break;
     }
-  });
-}
-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);
+    case "user": {
+      const scope = getScope(tracer, state, msg);
+      flushAssistantTurn(tracer, scope, state);
+      const userText = userMessageText(msg);
+      if (userText) {
+        if (!scope.inputCaptured) {
+          scope.inputCaptured = true;
+          scope.span.setAttribute("input.value", userText);
+        }
+        scope.inputMessages.push({ role: "user", content: userText });
+      }
+      closeToolSpansFromUser(state, scope, msg);
+      break;
     }
-  }
-  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));
+    case "assistant": {
+      const scope = getScope(tracer, state, msg);
+      bufferAssistantMessage(scope, msg);
+      break;
     }
-    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);
+    case "result": {
+      flushAssistantTurn(tracer, rootScope, state);
+      const text = typeof msg.result === "string" ? msg.result : "";
+      if (text) rootScope.finalText = text;
+      if (msg.session_id && !state.sessionId) {
+        rootScope.span.setAttribute("neatlogs.conversation.id", String(msg.session_id));
+      }
+      const usage = msg.usage;
+      if (usage) setUsage2(rootScope.span, usage);
+      if (msg.total_cost_usd != null) rootScope.span.setAttribute("neatlogs.agent.cost_usd", msg.total_cost_usd);
+      if (msg.num_turns != null) rootScope.span.setAttribute("neatlogs.agent.num_turns", msg.num_turns);
+      if (msg.is_error) rootScope.span.setAttribute("neatlogs.agent.is_error", true);
+      finalizeAgent(msg.is_error ? "error" : "ok", msg.is_error ? new Error(String(text || "agent run failed")) : void 0);
+      break;
     }
-    span2.setAttribute("output.value", safeStringify8(result.content).slice(0, 1e4));
+    default:
+      break;
   }
-  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;
+function bufferAssistantMessage(scope, msg) {
+  const message = msg.message ?? msg;
+  const content = message?.content ?? [];
+  if (!scope.assistantBuffer) {
+    scope.assistantBuffer = { textParts: [], thinkingParts: [], toolCalls: [], usage: void 0 };
+  }
+  const buf = scope.assistantBuffer;
+  if (message?.model) buf.model = message.model;
+  if (message?.stop_reason) buf.stopReason = message.stop_reason;
+  if (message?.usage) buf.usage = message.usage;
+  for (const block of Array.isArray(content) ? content : []) {
+    if (!block || typeof block !== "object") continue;
+    if (block.type === "text" && typeof block.text === "string") buf.textParts.push(block.text);
+    else if (block.type === "thinking" && typeof block.thinking === "string") buf.thinkingParts.push(block.thinking);
+    else if (block.type === "tool_use") {
+      buf.toolCalls.push({ id: block.id ?? "", name: block.name ?? "", input: block.input });
     }
   }
-  if (Array.isArray(callOpts.stopSequences) && callOpts.stopSequences.length) {
-    attrs["neatlogs.llm.stop_sequences"] = safeStringify8(callOpts.stopSequences);
-    invocation.stopSequences = callOpts.stopSequences;
+}
+function flushAssistantTurn(tracer, scope, state) {
+  const buf = scope.assistantBuffer;
+  if (!buf) return;
+  scope.assistantBuffer = null;
+  const model = buf.model ?? state.model ?? "";
+  const attrs = {
+    "neatlogs.span.kind": "LLM",
+    "neatlogs.llm.provider": "anthropic",
+    "neatlogs.llm.system": "anthropic"
+  };
+  if (model) attrs["neatlogs.llm.model_name"] = String(model);
+  if (scope.inputMessages.length === 0 && state.promptRef.text) {
+    scope.inputMessages.push({ role: "user", content: state.promptRef.text });
   }
-  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;
+  scope.inputMessages.forEach((m, i) => {
+    attrs[`neatlogs.llm.input_messages.${i}.role`] = m.role;
+    attrs[`neatlogs.llm.input_messages.${i}.content`] = m.content;
+  });
+  if (scope.inputMessages.length) {
+    attrs["input.value"] = safeStringify13({ messages: scope.inputMessages });
   }
-  if (Object.keys(invocation).length) {
-    attrs["neatlogs.llm.invocation_parameters"] = safeStringify8(invocation).slice(0, 4e3);
+  const outText = buf.textParts.join("");
+  const outValue = outText || buf.toolCalls.map((tc) => `${tc.name}(${safeStringify13(tc.input ?? {})})`).join("\n");
+  if (outValue) {
+    attrs["neatlogs.llm.output_messages.0.role"] = "assistant";
+    attrs["neatlogs.llm.output_messages.0.content"] = outValue;
+    attrs["output.value"] = outValue;
   }
-}
-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);
+  if (buf.thinkingParts.length) {
+    attrs["neatlogs.llm.output_messages.0.thinking"] = buf.thinkingParts.join("");
   }
-}
-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();
-    }
+  buf.toolCalls.forEach((tc, j) => {
+    attrs[`neatlogs.llm.tool_calls.${j}.id`] = tc.id;
+    attrs[`neatlogs.llm.tool_calls.${j}.name`] = tc.name;
+    attrs[`neatlogs.llm.tool_calls.${j}.arguments`] = safeStringify13(tc.input ?? {});
   });
+  if (buf.stopReason) attrs["neatlogs.llm.finish_reason"] = String(buf.stopReason);
+  const span2 = tracer.startSpan(`claude_agent.llm.${model || "model"}`, { attributes: attrs }, scope.ctx);
+  if (buf.usage) setUsage2(span2, buf.usage);
+  span2.setStatus({ code: import_api18.SpanStatusCode.OK });
+  span2.end();
+  if (outText) scope.finalText = outText;
+  const turnParts = [];
+  if (outText) turnParts.push(outText);
+  for (const tc of buf.toolCalls) turnParts.push(`[tool_call ${tc.name} ${safeStringify13(tc.input ?? {})}]`);
+  if (turnParts.length) scope.inputMessages.push({ role: "assistant", content: turnParts.join("\n") });
+  for (const tc of buf.toolCalls) {
+    const toolSpan = tracer.startSpan(
+      `claude_agent.tool.${tc.name || "tool"}`,
+      {
+        attributes: {
+          "neatlogs.span.kind": "TOOL",
+          "neatlogs.tool.name": String(tc.name ?? ""),
+          ...tc.id ? { "neatlogs.tool_call.id": String(tc.id) } : {},
+          "input.value": safeStringify13(tc.input ?? {})
+        }
+      },
+      scope.ctx
+    );
+    if (tc.id) state.toolSpans.set(tc.id, toolSpan);
+  }
+}
+function closeToolSpansFromUser(state, scope, msg) {
+  const content = (msg.message ?? msg)?.content ?? [];
+  for (const block of Array.isArray(content) ? content : []) {
+    if (block?.type !== "tool_result") continue;
+    const id = block.tool_use_id ?? "";
+    const out = block.content;
+    const outText = typeof out === "string" ? out : safeStringify13(out);
+    if (outText) scope.inputMessages.push({ role: "tool", content: outText });
+    const span2 = state.toolSpans.get(id);
+    if (!span2) continue;
+    span2.setAttribute("output.value", outText);
+    if (block.is_error) {
+      span2.setStatus({ code: import_api18.SpanStatusCode.ERROR });
+      span2.setAttribute("neatlogs.tool.is_error", true);
+    } else {
+      span2.setStatus({ code: import_api18.SpanStatusCode.OK });
+    }
+    span2.end();
+    state.toolSpans.delete(id);
+  }
 }
-function markPatched(e) {
-  try {
-    Object.defineProperty(e, PATCH_FLAG2, { value: true, enumerable: false, configurable: true });
-  } catch {
-    e[PATCH_FLAG2] = true;
+function userMessageText(msg) {
+  const content = (msg.message ?? msg)?.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const block of content) {
+    if (typeof block === "string") parts.push(block);
+    else if (block && typeof block === "object" && block.type === "text" && typeof block.text === "string") {
+      parts.push(block.text);
+    }
   }
+  return parts.join("\n");
 }
-function extractModelId(model) {
-  if (!model) return "";
-  if (typeof model === "string") return model;
-  return model.modelId ?? model.name ?? "";
+function setUsage2(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.input_tokens != null && usage.output_tokens != null) {
+    span2.setAttribute("neatlogs.llm.token_count.total", usage.input_tokens + 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 toInputValue(input) {
-  return (typeof input === "string" ? input : safeStringify8(input)).slice(0, 1e4);
+function extractPromptText(prompt) {
+  if (typeof prompt === "string") return prompt;
+  return "";
 }
-function safeStringify8(value) {
+function safeStringify13(value) {
   if (typeof value === "string") return value;
   try {
     return JSON.stringify(value) ?? "";
@@ -8242,216 +10080,457 @@ function safeStringify8(value) {
     return "";
   }
 }
-function recordError3(span2, err) {
+function recordError7(span2, err) {
   if (err instanceof Error) {
-    span2.setStatus({ code: import_api13.SpanStatusCode.ERROR, message: err.message });
+    span2.setStatus({ code: import_api18.SpanStatusCode.ERROR, message: err.message });
     span2.recordException(err);
   } else {
-    span2.setStatus({ code: import_api13.SpanStatusCode.ERROR, message: String(err) });
+    span2.setStatus({ code: import_api18.SpanStatusCode.ERROR, message: String(err) });
   }
+  span2.end();
 }
 
-// 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 {
+// src/openrouter-agent.ts
+var import_api19 = require("@opentelemetry/api");
+var TRACER_NAME13 = "neatlogs.openrouter_agent";
+var PROVIDER4 = "openrouter";
+function wrapOpenRouterAgent(client) {
+  const c = client;
+  if (!c || c._neatlogsWrapped) return client;
+  return new Proxy(client, {
+    get(obj, prop, receiver) {
+      const value = Reflect.get(obj, prop, receiver);
+      if (prop === "callModel" && typeof value === "function") {
+        return tracedCallModel(value.bind(obj));
+      }
+      return value;
     }
   });
-  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;
+function wrapCallModel(callModel) {
+  return function(clientArg, opts, ...rest) {
+    const span2 = startLlmSpan(opts);
+    const ctx = import_api19.trace.setSpan(import_api19.context.active(), span2);
+    const result = import_api19.context.with(ctx, () => callModel.call(this, clientArg, opts, ...rest));
+    return instrumentModelResult(result, span2);
+  };
+}
+function tracedCallModel(original) {
+  return function(opts, ...rest) {
+    const span2 = startLlmSpan(opts);
+    const ctx = import_api19.trace.setSpan(import_api19.context.active(), span2);
+    const result = import_api19.context.with(ctx, () => original(opts, ...rest));
+    return instrumentModelResult(result, span2);
+  };
+}
+function startLlmSpan(opts) {
+  const tracer = import_api19.trace.getTracer(TRACER_NAME13);
+  const model = opts?.model ?? "";
+  const span2 = tracer.startSpan("openrouter.call_model", {
+    attributes: {
+      "neatlogs.span.kind": "LLM",
+      "neatlogs.llm.provider": PROVIDER4,
+      "neatlogs.llm.system": PROVIDER4,
+      "neatlogs.llm.model_name": model
     }
-    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
+  }, import_api19.context.active());
+  const messages = Array.isArray(opts?.messages) ? opts.messages : Array.isArray(opts?.input) ? opts.input : [];
+  if (messages.length) {
+    messages.forEach((msg, i) => {
+      span2.setAttribute(`neatlogs.llm.input_messages.${i}.role`, msg?.role ?? "user");
+      const content = msg?.content;
+      span2.setAttribute(
+        `neatlogs.llm.input_messages.${i}.content`,
+        typeof content === "string" ? content : safeStringify14(content)
       );
-      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.setAttribute("input.value", safeStringify14({ messages }));
+  } else if (typeof opts?.input === "string") {
+    span2.setAttribute("neatlogs.llm.input_messages.0.role", "user");
+    span2.setAttribute("neatlogs.llm.input_messages.0.content", opts.input);
+    span2.setAttribute("input.value", opts.input);
+  }
+  if (typeof opts?.instructions === "string" && opts.instructions) {
+    span2.setAttribute("neatlogs.llm.system_prompt", opts.instructions);
+  }
+  if (Array.isArray(opts?.tools)) {
+    for (let i = 0; i < opts.tools.length; i++) {
+      const t = opts.tools[i] ?? {};
+      const name = t.name ?? t.function?.name;
+      if (name) span2.setAttribute(`neatlogs.llm.tools.${i}.name`, name);
+      const desc = t.description ?? t.function?.description;
+      if (desc) span2.setAttribute(`neatlogs.llm.tools.${i}.description`, desc);
+    }
+  }
+  const temperature = opts?.temperature;
+  const topP = opts?.top_p ?? opts?.topP;
+  const maxTokens = opts?.max_tokens ?? opts?.maxTokens ?? opts?.max_output_tokens ?? opts?.maxOutputTokens;
+  const frequencyPenalty = opts?.frequency_penalty ?? opts?.frequencyPenalty;
+  const presencePenalty = opts?.presence_penalty ?? opts?.presencePenalty;
+  const topK = opts?.top_k ?? opts?.topK;
+  if (temperature != null) span2.setAttribute("neatlogs.llm.temperature", temperature);
+  if (topP != null) span2.setAttribute("neatlogs.llm.top_p", topP);
+  if (maxTokens != null) span2.setAttribute("neatlogs.llm.max_tokens", maxTokens);
+  const params = {};
+  if (temperature != null) params.temperature = temperature;
+  if (topP != null) params.top_p = topP;
+  if (maxTokens != null) params.max_tokens = maxTokens;
+  if (frequencyPenalty != null) params.frequency_penalty = frequencyPenalty;
+  if (presencePenalty != null) params.presence_penalty = presencePenalty;
+  if (topK != null) params.top_k = topK;
+  if (Object.keys(params).length) {
+    span2.setAttribute("neatlogs.llm.invocation_parameters", JSON.stringify(params));
+  }
+  return span2;
+}
+function instrumentModelResult(result, span2) {
+  if (!result || typeof result !== "object" && typeof result !== "function") {
+    span2.setStatus({ code: import_api19.SpanStatusCode.OK });
+    span2.end();
+    return result;
+  }
+  let finalized = false;
+  const finalizeFromResult = (resolved) => {
+    if (finalized) return;
+    finalized = true;
+    try {
+      finalizeLlm(span2, resolved);
+    } catch {
+      span2.setStatus({ code: import_api19.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 {
-        }
+  };
+  const finalizeError = (err) => {
+    if (finalized) return;
+    finalized = true;
+    recordError8(span2, err);
+  };
+  return new Proxy(result, {
+    get(obj, prop, receiver) {
+      const value = Reflect.get(obj, prop, receiver);
+      if (prop === "getResponse" && typeof value === "function") {
+        return function(...args) {
+          return Promise.resolve(value.apply(obj, args)).then(
+            (resp) => {
+              finalizeFromResult(resp);
+              return resp;
+            },
+            (err) => {
+              finalizeError(err);
+              throw err;
+            }
+          );
+        };
       }
-      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;
+      if (prop === "getText" && typeof value === "function") {
+        return function(...args) {
+          return Promise.resolve(value.apply(obj, args)).then(
+            async (textStr) => {
+              let resp;
+              if (typeof obj?.getResponse === "function") {
+                try {
+                  resp = await obj.getResponse();
+                } catch {
+                  resp = void 0;
+                }
+              }
+              finalizeFromResult(resp ? { ...resp, text: textStr } : { text: textStr });
+              return textStr;
+            },
+            (err) => {
+              finalizeError(err);
+              throw err;
+            }
+          );
+        };
       }
-      break;
+      if (prop === "then" && typeof value === "function") {
+        return function(onFulfilled, onRejected) {
+          return value.call(
+            obj,
+            (resolved) => {
+              finalizeFromResult(typeof resolved === "string" ? { text: resolved } : resolved ?? obj);
+              return onFulfilled ? onFulfilled(resolved) : resolved;
+            },
+            (err) => {
+              finalizeError(err);
+              return onRejected ? onRejected(err) : Promise.reject(err);
+            }
+          );
+        };
+      }
+      return value;
     }
-    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);
+function setOpenResponsesUsage(span2, resp) {
+  const u = resp?.usage ?? resp;
+  if (!u) return;
+  const input = u.inputTokens ?? u.input_tokens ?? u.prompt_tokens;
+  const output = u.outputTokens ?? u.output_tokens ?? u.completion_tokens;
+  const total = u.totalTokens ?? u.total_tokens;
+  const cached = u.cachedTokens ?? u.cached_tokens;
+  if (input != null) span2.setAttribute("neatlogs.llm.token_count.prompt", input);
+  if (output != null) span2.setAttribute("neatlogs.llm.token_count.completion", output);
+  if (total != null) span2.setAttribute("neatlogs.llm.token_count.total", total);
+  else if (input != null && output != null) span2.setAttribute("neatlogs.llm.token_count.total", input + output);
+  if (cached != null) span2.setAttribute("neatlogs.llm.token_count.cache_read", cached);
+}
+function finalizeLlm(span2, result) {
+  const text = result?.text ?? result?.output_text ?? result?.content ?? extractOpenResponsesText(result) ?? result?.choices?.[0]?.message?.content ?? result?.message?.content;
+  if (text) {
+    span2.setAttribute("neatlogs.llm.output_messages.0.role", "assistant");
+    span2.setAttribute("neatlogs.llm.output_messages.0.content", String(text));
+    span2.setAttribute("output.value", String(text));
+  }
+  const toolCalls = result?.toolCalls ?? result?.tool_calls ?? result?.choices?.[0]?.message?.tool_calls ?? result?.message?.tool_calls;
+  if (Array.isArray(toolCalls)) {
+    toolCalls.forEach((tc, j) => {
+      span2.setAttribute(`neatlogs.llm.tool_calls.${j}.id`, tc?.id ?? "");
+      span2.setAttribute(`neatlogs.llm.tool_calls.${j}.name`, tc?.function?.name ?? tc?.name ?? "");
+      const args = tc?.function?.arguments ?? tc?.arguments;
+      span2.setAttribute(`neatlogs.llm.tool_calls.${j}.arguments`, typeof args === "string" ? args : safeStringify14(args ?? {}));
     });
-    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);
-      });
+  const model = result?.model ?? result?.response?.model;
+  if (model) span2.setAttribute("neatlogs.llm.model_name", String(model));
+  const responseId = result?.id ?? result?.response?.id;
+  if (responseId) span2.setAttribute("neatlogs.llm.response_id", String(responseId));
+  const finishReason = result?.finishReason ?? result?.finish_reason ?? result?.choices?.[0]?.finish_reason;
+  if (finishReason) span2.setAttribute("neatlogs.llm.finish_reason", String(finishReason));
+  setOpenResponsesUsage(span2, result);
+  span2.setStatus({ code: import_api19.SpanStatusCode.OK });
+  span2.end();
+}
+function extractOpenResponsesText(result) {
+  const output = result?.output;
+  if (!Array.isArray(output)) return void 0;
+  const parts = [];
+  for (const item of output) {
+    if (item?.type === "message" && Array.isArray(item.content)) {
+      for (const c of item.content) {
+        if ((c?.type === "output_text" || c?.type === "text") && typeof c.text === "string") parts.push(c.text);
+      }
     }
-    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;
+  return parts.length ? parts.join("") : void 0;
+}
+function safeStringify14(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return "";
+  }
+}
+function recordError8(span2, err) {
+  if (err instanceof Error) {
+    span2.setStatus({ code: import_api19.SpanStatusCode.ERROR, message: err.message });
+    span2.recordException(err);
+  } else {
+    span2.setStatus({ code: import_api19.SpanStatusCode.ERROR, message: String(err) });
   }
-  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);
+
+// src/opencode-plugin.ts
+var import_api20 = require("@opentelemetry/api");
+var TRACER_NAME14 = "neatlogs.opencode";
+var _initialized2 = false;
+async function ensureInitialized() {
+  if (_initialized2) return;
+  _initialized2 = true;
+  try {
+    await init({
+      apiKey: process.env.NEATLOGS_API_KEY,
+      // The plugin bootstraps itself inside opencode's process — there is no user
+      // init() to pass an endpoint, so honor NEATLOGS_ENDPOINT from the env (e.g.
+      // a local backend). init() otherwise defaults to the hosted cloud.
+      ...process.env.NEATLOGS_ENDPOINT ? { endpoint: process.env.NEATLOGS_ENDPOINT } : {},
+      workflowName: process.env.NEATLOGS_WORKFLOW_NAME || "opencode",
+      // opencode is long-running and event-driven; keep auto session off so each
+      // span's conversation id is the opencode session id we set explicitly.
+      autoSession: false
+    });
+  } catch {
   }
-  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)})`);
+var NeatlogsOpencodePlugin = async (_ctx) => {
+  await ensureInitialized();
+  const sessions = /* @__PURE__ */ new Map();
+  const tracer = import_api20.trace.getTracer(TRACER_NAME14);
+  const captureSystemPrompt = String(process.env.NEATLOGS_CAPTURE_SYSTEM_PROMPT || "").toLowerCase() === "true";
+  function stateFor(sessionID) {
+    let s = sessions.get(sessionID);
+    if (!s) {
+      s = { toolSpans: /* @__PURE__ */ new Map(), messageText: /* @__PURE__ */ new Map(), emitted: /* @__PURE__ */ new Set(), lastUserText: "" };
+      sessions.set(sessionID, s);
     }
+    return s;
   }
-  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 {
+    /**
+     * Global event bus. opencode emits message + session lifecycle events here.
+     * We use it to emit an LLM span when an assistant message completes, and to
+     * track user-message text + assistant text from part updates.
+     */
+    event: async ({ event }) => {
+      try {
+        await handleEvent2(tracer, sessions, stateFor, captureSystemPrompt, event);
+      } catch {
+      }
+    },
+    /** Fired before a tool runs: open a TOOL span keyed by callID. */
+    "tool.execute.before": async (input, output) => {
+      try {
+        const sessionID = input?.sessionID ?? "";
+        const callID = input?.callID ?? input?.tool ?? "";
+        const st = stateFor(sessionID);
+        const span2 = tracer.startSpan(
+          `opencode.tool.${input?.tool ?? "tool"}`,
+          {
+            attributes: {
+              "neatlogs.span.kind": "TOOL",
+              "neatlogs.tool.name": String(input?.tool ?? ""),
+              ...sessionID ? { "neatlogs.conversation.id": String(sessionID) } : {},
+              ...output?.args !== void 0 ? { "input.value": safeStringify15(output.args) } : {}
+            }
+          },
+          import_api20.context.active()
+        );
+        if (callID) st.toolSpans.set(String(callID), span2);
+      } catch {
+      }
+    },
+    /** Fired after a tool runs: close the matching TOOL span. */
+    "tool.execute.after": async (input, output) => {
+      try {
+        const sessionID = input?.sessionID ?? "";
+        const callID = String(input?.callID ?? input?.tool ?? "");
+        const st = stateFor(sessionID);
+        const span2 = st.toolSpans.get(callID);
+        if (!span2) return;
+        if (output?.title) span2.setAttribute("neatlogs.tool.title", String(output.title));
+        const out = output?.output ?? output?.result;
+        if (out !== void 0) {
+          span2.setAttribute("output.value", typeof out === "string" ? out : safeStringify15(out));
+        }
+        if (output?.metadata !== void 0) {
+          span2.setAttribute("neatlogs.tool.metadata", safeStringify15(output.metadata));
+        }
+        span2.setStatus({ code: import_api20.SpanStatusCode.OK });
+        span2.end();
+        st.toolSpans.delete(callID);
+      } catch {
+      }
+    }
+  };
+};
+function handleEvent2(tracer, sessions, stateFor, captureSystemPrompt, event) {
+  const type = event?.type;
+  const props = event?.properties ?? {};
+  if (type === "message.part.updated" || type === "message.part.completed") {
+    const part = props.part ?? props;
+    const messageID = part?.messageID ?? part?.message_id;
+    const sessionID = part?.sessionID ?? props.sessionID;
+    if (part?.type === "text" && typeof part?.text === "string" && messageID && sessionID) {
+      const st = stateFor(String(sessionID));
+      st.messageText.set(String(messageID), part.text);
     }
+    return;
   }
-  return "";
+  if (type === "message.updated" || type === "message.completed") {
+    const info = props.info ?? props.message ?? props;
+    const sessionID = info?.sessionID ?? info?.session_id;
+    if (!sessionID) return;
+    const st = stateFor(String(sessionID));
+    if (info?.role === "user") {
+      const text = messageText2(info) || st.messageText.get(String(info?.id)) || "";
+      if (text) st.lastUserText = text;
+      return;
+    }
+    if (info?.role === "assistant") {
+      const completed = info?.time?.completed ?? info?.completed;
+      const id = String(info?.id ?? "");
+      if (!completed || st.emitted.has(id)) return;
+      st.emitted.add(id);
+      emitLlmSpan2(tracer, st, captureSystemPrompt, info, String(sessionID));
+    }
+    return;
+  }
+  if (type === "session.idle" || type === "session.deleted") {
+    const sessionID = props.sessionID ?? props.info?.id;
+    if (!sessionID) return void 0;
+    const st = sessions.get(String(sessionID));
+    if (!st) return void 0;
+    for (const ts of st.toolSpans.values()) {
+      try {
+        ts.end();
+      } catch {
+      }
+    }
+    st.toolSpans.clear();
+    if (type === "session.deleted") sessions.delete(String(sessionID));
+    return flush().catch(() => false);
+  }
+  return void 0;
 }
-function markPatched2(e) {
-  try {
-    Object.defineProperty(e, PATCH_FLAG3, { value: true, enumerable: false, configurable: true });
-  } catch {
-    e[PATCH_FLAG3] = true;
+function emitLlmSpan2(tracer, st, captureSystemPrompt, info, sessionID) {
+  const model = info?.modelID ?? info?.model ?? "";
+  const provider = info?.providerID ?? info?.provider ?? "";
+  const attrs = {
+    "neatlogs.span.kind": "LLM",
+    "neatlogs.conversation.id": sessionID
+  };
+  if (model) attrs["neatlogs.llm.model_name"] = String(model);
+  if (provider) attrs["neatlogs.llm.provider"] = String(provider);
+  if (captureSystemPrompt && info?.system) {
+    const sys = Array.isArray(info.system) ? info.system.join("\n") : String(info.system);
+    attrs["neatlogs.llm.input_messages.0.role"] = "system";
+    attrs["neatlogs.llm.input_messages.0.content"] = sys;
+  }
+  let inIdx = captureSystemPrompt && info?.system ? 1 : 0;
+  if (st.lastUserText) {
+    attrs[`neatlogs.llm.input_messages.${inIdx}.role`] = "user";
+    attrs[`neatlogs.llm.input_messages.${inIdx}.content`] = st.lastUserText;
+    inIdx++;
+  }
+  const outText = messageText2(info) || st.messageText.get(String(info?.id)) || "";
+  if (outText) {
+    attrs["neatlogs.llm.output_messages.0.role"] = "assistant";
+    attrs["neatlogs.llm.output_messages.0.content"] = outText;
+  }
+  const tokens = info?.tokens;
+  if (tokens) {
+    if (tokens.input != null) attrs["neatlogs.llm.token_count.prompt"] = tokens.input;
+    if (tokens.output != null) attrs["neatlogs.llm.token_count.completion"] = tokens.output;
+    if (tokens.input != null && tokens.output != null) {
+      attrs["neatlogs.llm.token_count.total"] = tokens.input + tokens.output;
+    }
+    if (tokens.reasoning != null) attrs["neatlogs.llm.token_count.reasoning"] = tokens.reasoning;
+    if (tokens.cache?.read != null) attrs["neatlogs.llm.token_count.cache_read"] = tokens.cache.read;
+    if (tokens.cache?.write != null) attrs["neatlogs.llm.token_count.cache_write"] = tokens.cache.write;
+  }
+  if (info?.cost != null) attrs["neatlogs.llm.cost_usd"] = info.cost;
+  const span2 = tracer.startSpan(`opencode.llm.${model || "model"}`, { attributes: attrs }, import_api20.context.active());
+  span2.setStatus({ code: import_api20.SpanStatusCode.OK });
+  span2.end();
+  if (info?.id) st.messageText.delete(String(info.id));
+}
+function messageText2(info) {
+  if (!info) return "";
+  if (typeof info.text === "string") return info.text;
+  const parts = info.parts ?? info.content;
+  if (typeof parts === "string") return parts;
+  if (!Array.isArray(parts)) return "";
+  const out = [];
+  for (const p of parts) {
+    if (typeof p === "string") out.push(p);
+    else if (p && typeof p === "object" && typeof p.text === "string") out.push(p.text);
   }
+  return out.join("");
 }
-function safeStringify9(value) {
+function safeStringify15(value) {
   if (typeof value === "string") return value;
   try {
     return JSON.stringify(value) ?? "";
@@ -8511,6 +10590,7 @@ function bindTemplates(llm, systemTpl, userTpl, compiledVars) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  NeatlogsOpencodePlugin,
   PromptApiError,
   PromptClient,
   PromptClientError,
@@ -8544,11 +10624,21 @@ function bindTemplates(llm, systemTpl, userTpl, compiledVars) {
   strandsHooks,
   trace,
   traceToolAnthropic,
+  traceToolAzureOpenAI,
+  traceToolBedrock,
   traceToolOpenAI,
+  traceToolVertexAI,
   updatePrompt,
   wrapAISDK,
   wrapAnthropic,
+  wrapAzureOpenAI,
+  wrapBedrock,
+  wrapCallModel,
+  wrapClaudeAgentSDK,
   wrapMastra,
-  wrapOpenAI
+  wrapOpenAI,
+  wrapOpenRouterAgent,
+  wrapVertexAI,
+  wrapVertexAIChat
 });
 //# sourceMappingURL=index.cjs.map