netra-sdk 1.2.0 → 1.4.0

package/dist/index.js

@@ -4,8 +4,8 @@ import { createRequire } from 'module';
 import { AsyncLocalStorage } from 'async_hooks';
 import { ConsoleSpanExporter } from '@opentelemetry/sdk-trace-base';
 import { initialize } from '@traceloop/node-server-sdk';
-import * as dotenv from 'dotenv';
 import shimmer from 'shimmer';
+import * as dotenv from 'dotenv';
 import { CompositePropagator, W3CTraceContextPropagator, W3CBaggagePropagator, ExportResultCode } from '@opentelemetry/core';
 import * as http from 'http';
 import * as https from 'https';
@@ -22,6 +22,9 @@ var Logger = class {
   static get isDebug() {
     return this._debugMode || ["1", "true"].includes((process.env.NETRA_DEBUG ?? "").toLowerCase());
   }
+  static isDebugMode() {
+    return this.isDebug;
+  }
   static debug(...args) {
     if (this.isDebug) console.debug(PREFIX, ...args);
   }
@@ -575,6 +578,9 @@ var Usage = class {
   }
 };
 
+// src/version.ts
+var SDK_VERSION = "1.4.0";
+
 // src/config.ts
 var NetraInstruments = /* @__PURE__ */ ((NetraInstruments2) => {
   NetraInstruments2["ALL"] = "__all__";
@@ -610,7 +616,8 @@ var DEFAULT_INSTRUMENTS_FOR_ROOT = /* @__PURE__ */ new Set([
   // AI frameworks
   "langchain" /* LANGCHAIN */,
   "langgraph" /* LANGGRAPH */,
-  "llama_index" /* LLAMA_INDEX */
+  "llama_index" /* LLAMA_INDEX */,
+  "openai_agents" /* OPENAI_AGENTS */
 ]);
 var DEFAULT_INSTRUMENTS = /* @__PURE__ */ new Set([
   ...DEFAULT_INSTRUMENTS_FOR_ROOT,
@@ -772,11 +779,34 @@ var Config = class {
       const headerStr = Object.entries(this.headers).map(([k, v]) => `${k}=${v}`).join(",");
       process.env.TRACELOOP_HEADERS = headerStr;
     }
+    this._setResourceAttributesEnv();
+  }
+  _setResourceAttributesEnv() {
+    const attrs = {
+      "deployment.environment": this.environment,
+      "service.name": this.appName
+    };
+    for (const [k, v] of Object.entries(this.resourceAttributes)) {
+      attrs[k] = String(v);
+    }
+    const existing = process.env.OTEL_RESOURCE_ATTRIBUTES;
+    if (existing) {
+      for (const pair of existing.split(",")) {
+        const eqIdx = pair.indexOf("=");
+        if (eqIdx <= 0) continue;
+        const key = decodeURIComponent(pair.slice(0, eqIdx).trim());
+        if (key) {
+          attrs[key] = decodeURIComponent(pair.slice(eqIdx + 1).trim());
+        }
+      }
+    }
+    const encodeAttrValue = (s) => encodeURIComponent(s);
+    process.env.OTEL_RESOURCE_ATTRIBUTES = Object.entries(attrs).map(([k, v]) => `${encodeAttrValue(k)}=${encodeAttrValue(v)}`).join(",");
   }
 };
 Config.SDK_NAME = "netra";
 Config.LIBRARY_NAME = "netra";
-Config.LIBRARY_VERSION = "1.0.0";
+Config.LIBRARY_VERSION = SDK_VERSION;
 Config.TRIAL_BLOCK_DURATION_SECONDS = 900;
 // 15 minutes
 Config.ATTRIBUTE_MAX_LEN = parseInt(
@@ -785,6 +815,9 @@ Config.ATTRIBUTE_MAX_LEN = parseInt(
 Config.CONVERSATION_MAX_LEN = parseInt(
   process.env.NETRA_CONVERSATION_CONTENT_MAX_LEN || "50000"
 );
+Config.SPAN_ATTRIBUTE_MAX_SIZE = parseInt(
+  process.env.NETRA_SPAN_ATTRIBUTE_MAX_SIZE || "30000"
+);
 
 // src/utils/pattern-matching.ts
 function compilePatterns(patterns) {
@@ -1046,6 +1079,57 @@ var ConversationType = /* @__PURE__ */ ((ConversationType3) => {
   return ConversationType3;
 })(ConversationType || {});
 
+// src/utils/serialization.ts
+var ELLIPSIS = "...";
+function truncate(s, maxLength) {
+  if (s.length <= maxLength) return s;
+  if (maxLength <= ELLIPSIS.length) return s.slice(0, maxLength);
+  return s.slice(0, maxLength - ELLIPSIS.length) + ELLIPSIS;
+}
+function safeStringify(value, maxLength) {
+  if (typeof value === "string") {
+    if (maxLength && value.length > maxLength) {
+      return truncate(value, maxLength);
+    }
+    return value;
+  }
+  const seen = /* @__PURE__ */ new WeakSet();
+  let result;
+  try {
+    result = JSON.stringify(value, (_key, val) => {
+      if (typeof val === "function")
+        return `[Function: ${val.name || "anonymous"}]`;
+      if (typeof val === "symbol") return val.toString();
+      if (typeof val === "bigint") return val.toString();
+      if (val !== null && typeof val === "object") {
+        if (seen.has(val)) return "[Circular]";
+        seen.add(val);
+        const name = val.constructor?.name;
+        if (name && name !== "Object" && name !== "Array" && Object.keys(val).length > 20) {
+          return `[${name}]`;
+        }
+      }
+      return val;
+    }) ?? String(value);
+  } catch {
+    result = value?.constructor?.name ? `[${value.constructor.name}]` : String(value);
+  }
+  if (maxLength && result.length > maxLength) {
+    return truncate(result, maxLength);
+  }
+  return result;
+}
+function serializeValue(value, maxLength) {
+  if (value === null || value === void 0) return String(value);
+  const t = typeof value;
+  if (t === "string" || t === "number" || t === "boolean") {
+    const s = String(value);
+    if (maxLength && s.length > maxLength) return truncate(s, maxLength);
+    return s;
+  }
+  return safeStringify(value, maxLength);
+}
+
 // src/session-manager.ts
 var MODULE_NAME = "netra.session-manager";
 var entityStorage = new AsyncLocalStorage();
@@ -1059,12 +1143,6 @@ var globalFallbackContext = {
 function getEntityContext() {
   return entityStorage.getStore() ?? globalFallbackContext;
 }
-function serializeValue(value) {
-  if (typeof value === "string") {
-    return value.substring(0, Config.ATTRIBUTE_MAX_LEN);
-  }
-  return JSON.stringify(value).substring(0, Config.ATTRIBUTE_MAX_LEN);
-}
 var SessionManager = class _SessionManager {
   // Span registry (name → stack)
   static registerSpan(name, span2) {
@@ -1179,7 +1257,10 @@ var SessionManager = class _SessionManager {
    */
   static setInput(value) {
     try {
-      _SessionManager.setAttributeOnActiveSpan("netra.user.input", serializeValue(value));
+      _SessionManager.setAttributeOnActiveSpan(
+        "netra.user.input",
+        serializeValue(value, Config.ATTRIBUTE_MAX_LEN)
+      );
     } catch (e) {
       Logger.error("setInput failed:", e);
     }
@@ -1191,7 +1272,10 @@ var SessionManager = class _SessionManager {
    */
   static setOutput(value) {
     try {
-      _SessionManager.setAttributeOnActiveSpan("netra.user.output", serializeValue(value));
+      _SessionManager.setAttributeOnActiveSpan(
+        "netra.user.output",
+        serializeValue(value, Config.ATTRIBUTE_MAX_LEN)
+      );
     } catch (e) {
       Logger.error("setOutput failed:", e);
     }
@@ -1203,7 +1287,10 @@ var SessionManager = class _SessionManager {
    */
   static setRootInput(value) {
     try {
-      RootSpanProcessor.setAttributeOnRootSpan("netra.user.input", serializeValue(value));
+      RootSpanProcessor.setAttributeOnRootSpan(
+        "netra.user.input",
+        serializeValue(value, Config.ATTRIBUTE_MAX_LEN)
+      );
     } catch (e) {
       Logger.error("setRootInput failed:", e);
     }
@@ -1215,7 +1302,10 @@ var SessionManager = class _SessionManager {
    */
   static setRootOutput(value) {
     try {
-      RootSpanProcessor.setAttributeOnRootSpan("netra.user.output", serializeValue(value));
+      RootSpanProcessor.setAttributeOnRootSpan(
+        "netra.user.output",
+        serializeValue(value, Config.ATTRIBUTE_MAX_LEN)
+      );
     } catch (e) {
       Logger.error("setRootOutput failed:", e);
     }
@@ -2782,6 +2872,58 @@ var Prompts = class {
   }
 };
 
+// src/processors/attribute-size-limit-processor.ts
+var DEFAULT_MAX_ATTRIBUTE_SIZE = 32e3;
+var AttributeSizeLimitProcessor = class {
+  constructor(maxAttributeSize) {
+    this.maxAttributeSize = maxAttributeSize ?? DEFAULT_MAX_ATTRIBUTE_SIZE;
+  }
+  onStart(span2, _parentContext) {
+    try {
+      this._wrapSetAttribute(span2);
+    } catch (e) {
+      Logger.debug("AttributeSizeLimitProcessor.onStart error:", e);
+    }
+  }
+  onEnd(_span) {
+  }
+  shutdown() {
+    return Promise.resolve();
+  }
+  forceFlush() {
+    return Promise.resolve();
+  }
+  _wrapSetAttribute(span2) {
+    const original = span2.setAttribute.bind(span2);
+    const maxLen = this.maxAttributeSize;
+    const patched = (key, value) => {
+      try {
+        return original(key, truncateValue(value, maxLen));
+      } catch {
+        try {
+          return original(key, value);
+        } catch {
+          return span2;
+        }
+      }
+    };
+    span2.setAttribute = patched;
+  }
+};
+function truncateValue(value, maxLen) {
+  if (typeof value === "string") {
+    return value.length > maxLen ? value.substring(0, maxLen) : value;
+  }
+  if (Array.isArray(value)) {
+    const serialized = JSON.stringify(value);
+    if (serialized.length > maxLen) {
+      return serialized.substring(0, maxLen);
+    }
+    return value;
+  }
+  return value;
+}
+
 // src/processors/instrumentation-span-processor.ts
 var ALLOWED_INSTRUMENTATION_NAMES = /* @__PURE__ */ new Set([
   "openai",
@@ -3187,6 +3329,9 @@ function setSessionBaggage(key, value) {
   }
 }
 var SessionSpanProcessor = class {
+  constructor(environment = "local") {
+    this.environment = environment;
+  }
   /**
    * Called when a span starts. Adds session and entity context attributes.
    */
@@ -3195,6 +3340,7 @@ var SessionSpanProcessor = class {
       span2.setAttribute("library.name", Config.LIBRARY_NAME);
       span2.setAttribute("library.version", Config.LIBRARY_VERSION);
       span2.setAttribute("sdk.name", Config.SDK_NAME);
+      span2.setAttribute("deployment.environment", this.environment);
       const ctxToUse = parentContext || context.active();
       const baggage = propagation.getBaggage(ctxToUse);
       const sessionId = baggage?.getEntry("session_id")?.value ?? sessionValues.get("session_id");
@@ -3601,6 +3747,184 @@ var SpanIOProcessor = class {
   }
 };
 
+// src/instrumentation/anthropic/version.ts
+var __version__ = "1.0.0";
+
+// src/utils/response-handler.ts
+function isAsyncIterable(value) {
+  return value != null && typeof value[Symbol.asyncIterator] === "function";
+}
+function isPromise(value) {
+  return value != null && typeof value.then === "function";
+}
+var ITERATOR_METHODS = /* @__PURE__ */ new Set(["next", "return", "throw"]);
+function wrapAsyncIterable(source, callbacks) {
+  function createWrappedIterator() {
+    const iterator = source[Symbol.asyncIterator]();
+    let done = false;
+    const safeFinalize = (status) => {
+      if (done) return;
+      done = true;
+      try {
+        callbacks.finalize(status);
+      } catch (e) {
+        Logger.error("netra: finalize callback error", e);
+      }
+    };
+    return {
+      async next(value) {
+        try {
+          const result = await callbacks.withContext(() => iterator.next(value));
+          if (!result.done) {
+            try {
+              callbacks.onChunk?.(result.value);
+            } catch (e) {
+              Logger.error("netra: onChunk callback error", e);
+            }
+          } else {
+            safeFinalize("ok");
+          }
+          return result;
+        } catch (e) {
+          try {
+            callbacks.onError(e);
+          } catch {
+            Logger.error("netra: onError callback error", e);
+          }
+          safeFinalize("error");
+          throw e;
+        }
+      },
+      async return(value) {
+        try {
+          const result = await callbacks.withContext(
+            () => iterator.return?.(value) ?? { done: true, value }
+          );
+          safeFinalize("ok");
+          return result;
+        } catch (e) {
+          try {
+            callbacks.onError(e);
+          } catch {
+            Logger.error("netra: onError callback error", e);
+          }
+          safeFinalize("error");
+          throw e;
+        }
+      },
+      async throw(e) {
+        try {
+          const result = await callbacks.withContext(() => {
+            if (iterator.throw) return iterator.throw(e);
+            throw e;
+          });
+          if (result.done) safeFinalize("ok");
+          return result;
+        } catch (err) {
+          try {
+            callbacks.onError(err);
+          } catch {
+            Logger.error("netra: onError callback error", err);
+          }
+          safeFinalize("error");
+          throw err;
+        }
+      }
+    };
+  }
+  let directIterator = null;
+  return new Proxy(source, {
+    get(target, prop) {
+      if (prop === Symbol.asyncIterator) {
+        return () => createWrappedIterator();
+      }
+      if (typeof prop === "string" && ITERATOR_METHODS.has(prop)) {
+        if (!directIterator) directIterator = createWrappedIterator();
+        return directIterator[prop].bind(directIterator);
+      }
+      const value = target[prop];
+      if (typeof value === "function") return value.bind(target);
+      return value;
+    }
+  });
+}
+function wrapPromise(promise, callbacks, options) {
+  let finalized = false;
+  function safeFinalize(status) {
+    if (finalized) return;
+    finalized = true;
+    try {
+      callbacks.finalize(status);
+    } catch (e) {
+      Logger.error("netra: finalize callback error", e);
+    }
+  }
+  const instrumentedPromise = (async () => {
+    try {
+      const value = await promise;
+      if (isAsyncIterable(value)) {
+        return wrapAsyncIterable(value, callbacks);
+      }
+      try {
+        callbacks.onSuccess?.(value);
+      } catch (e) {
+        Logger.error("netra: onSuccess callback error", e);
+      }
+      safeFinalize("ok");
+      return value;
+    } catch (error) {
+      try {
+        callbacks.onError(error);
+      } catch {
+        Logger.error("netra: onError callback error", error);
+      }
+      safeFinalize("error");
+      throw error;
+    }
+  })();
+  if (!options?.preserveOriginal) {
+    return instrumentedPromise;
+  }
+  const original = options.preserveOriginal;
+  return new Proxy(instrumentedPromise, {
+    get(target, prop, receiver) {
+      if (prop === "then" || prop === "catch" || prop === "finally") {
+        const value2 = Reflect.get(target, prop, receiver);
+        if (typeof value2 === "function") return value2.bind(target);
+        return value2;
+      }
+      const originalValue = original[prop];
+      if (originalValue !== void 0) {
+        if (typeof originalValue === "function")
+          return originalValue.bind(original);
+        return originalValue;
+      }
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value === "function") return value.bind(target);
+      return value;
+    }
+  });
+}
+function wrapResponse(response, callbacks, options) {
+  if (isAsyncIterable(response)) {
+    return wrapAsyncIterable(response, callbacks);
+  }
+  if (isPromise(response)) {
+    return wrapPromise(response, callbacks, options);
+  }
+  try {
+    callbacks.onSuccess?.(response);
+  } catch (e) {
+    Logger.error("netra: onSuccess callback error", e);
+  }
+  try {
+    callbacks.finalize("ok");
+  } catch (e) {
+    Logger.error("netra: finalize callback error", e);
+  }
+  return response;
+}
+
 // src/instrumentation/span-attributes.ts
 var SpanAttributes2 = {
   LLM_SYSTEM: "gen_ai.system",
@@ -3611,10 +3935,14 @@ var SpanAttributes2 = {
   LLM_REQUEST_TOP_P: "gen_ai.request.top_p",
   LLM_REQUEST_REASONING: "gen_ai.request.reasoning",
   LLM_REQUEST_REASONING_EFFORT: "gen_ai.request.reasoning_effort",
+  LLM_REQUEST_TOOL_NAME: "gen_ai.request.tool.name",
+  LLM_REQUEST_TOOL_ID: "gen_ai.request.tool.id",
   LLM_RESPONSE_MODEL: "gen_ai.response.model",
+  LLM_RESPONSE_FINISH_REASON: "llm.response.finish_reason",
   LLM_USAGE_PROMPT_TOKENS: "gen_ai.usage.prompt_tokens",
   LLM_USAGE_COMPLETION_TOKENS: "gen_ai.usage.completion_tokens",
   LLM_USAGE_CACHE_READ_INPUT_TOKENS: "gen_ai.usage.cache_read_input_tokens",
+  LLM_USAGE_CACHE_CREATION_INPUT_TOKENS: "gen_ai.usage.cache_creation_input_tokens",
   LLM_USAGE_REASONING_TOKENS: "gen_ai.usage.reasoning_tokens",
   LLM_USAGE_TOTAL_TOKENS: "llm.usage.total_tokens",
   LLM_FREQUENCY_PENALTY: "llm.frequency_penalty",
@@ -3624,16 +3952,18 @@ var SpanAttributes2 = {
   LLM_COMPLETIONS: "gen_ai.completion",
   LLM_PROMPTS: "gen_ai.prompt"
 };
-
-// src/instrumentation/utils.ts
+var VALID_NATIVE_TRACING_MODES = /* @__PURE__ */ new Set(["both", "netra", "netra-strict"]);
+function parseNativeTracingEnv(name) {
+  const val = process.env[name];
+  if (val === void 0 || val === "") return void 0;
+  if (VALID_NATIVE_TRACING_MODES.has(val)) return val;
+  return void 0;
+}
 var SUPPRESS_INSTRUMENTATION_KEY = /* @__PURE__ */ Symbol("netra.suppress_instrumentation");
 function shouldSuppressInstrumentation() {
   const ctx = context.active();
   return ctx.getValue(SUPPRESS_INSTRUMENTATION_KEY) === true;
 }
-function isPromise(value) {
-  return value instanceof Promise;
-}
 function defineHidden(target, key, value) {
   Object.defineProperty(target, key, {
     value,
@@ -3663,18 +3993,6 @@ function isTraceContentEnabled() {
   const raw = process.env.TRACELOOP_TRACE_CONTENT ?? process.env.NETRA_TRACE_CONTENT ?? "";
   return ["1", "true"].includes(String(raw).toLowerCase());
 }
-function safeStringify(value) {
-  if (typeof value === "string") return value;
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
-  }
-}
-function truncate(value, maxLen) {
-  if (!value || value.length <= maxLen) return value;
-  return value.slice(0, maxLen) + "...(truncated)";
-}
 function hasContent(value) {
   if (value === void 0 || value === null) return false;
   if (typeof value === "string") return value.length > 0;
@@ -3705,7 +4023,7 @@ function setModelParams(span2, kwargs) {
 }
 function buildInputMessages(kwargs, requestType) {
   const messages = [];
-  if (requestType === "chat") {
+  if (requestType === "chat" || requestType === "beta") {
     if (hasContent(kwargs.system)) {
       const systemContent = typeof kwargs.system === "string" ? kwargs.system : safeStringify(kwargs.system);
       messages.push({ role: "system", content: systemContent });
@@ -3713,12 +4031,34 @@ function buildInputMessages(kwargs, requestType) {
     const rawMessages = kwargs.messages;
     if (!Array.isArray(rawMessages)) return messages;
     for (const msg of rawMessages) {
-      if (!isDict(msg)) continue;
-      if (hasContent(msg.role) && hasContent(msg.content)) {
+      if (!isDict(msg) || !hasContent(msg.role) || !hasContent(msg.content)) {
+        continue;
+      }
+      if (msg.role !== "user" || !Array.isArray(msg.content)) {
         messages.push({
           role: msg.role,
           content: safeStringify(msg.content)
         });
+        continue;
+      }
+      const isToolResult = (b) => isDict(b) && b.type === "tool_result";
+      const userBlocks = msg.content.filter((b) => !isToolResult(b));
+      if (userBlocks.length) {
+        messages.push({
+          role: "user",
+          content: safeStringify(userBlocks)
+        });
+      }
+      for (const block of msg.content) {
+        if (!isToolResult(block)) continue;
+        messages.push({
+          role: "tool",
+          content: safeStringify({
+            tool_use_id: block.tool_use_id,
+            content: block.content,
+            is_error: block.is_error ?? false
+          }, Config.CONVERSATION_MAX_LEN)
+        });
       }
     }
   } else if (requestType === "response") {
@@ -3747,10 +4087,7 @@ function buildInputMessages(kwargs, requestType) {
   } else {
     const input = kwargs.input ?? kwargs.inputs;
     if (hasContent(input)) {
-      const content = truncate(
-        safeStringify(input),
-        Config.CONVERSATION_MAX_LEN
-      );
+      const content = safeStringify(input, Config.CONVERSATION_MAX_LEN);
       messages.push({ role: "user", content });
     }
   }
@@ -3817,7 +4154,7 @@ function buildOutputMessages(response) {
       } else if (block.type === "tool_use" && block.name) {
         messages.push({
           role: "tool",
-          content: JSON.stringify({ name: block.name, input: block.input })
+          content: JSON.stringify({ id: block.id, name: block.name, input: block.input })
         });
       }
     }
@@ -3827,13 +4164,14 @@ function buildOutputMessages(response) {
 function writePromptAttributes(span2, messages) {
   if (messages.length === 0) return;
   for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
     span2.setAttribute(
       `${SpanAttributes2.LLM_PROMPTS}.${i}.role`,
-      messages[i].role
+      msg.role
     );
     span2.setAttribute(
       `${SpanAttributes2.LLM_PROMPTS}.${i}.content`,
-      messages[i].content
+      msg.content
     );
   }
   span2.setAttribute("input", JSON.stringify(messages));
@@ -3885,6 +4223,9 @@ function setRequestAttributes(span2, kwargs, requestType, system) {
     span2.setAttribute(SpanAttributes2.LLM_REQUEST_MODEL, String(kwargs.model));
   }
   setModelParams(span2, kwargs);
+  if (Array.isArray(kwargs.tools)) {
+    span2.setAttribute("tools", safeStringify(kwargs.tools, Config.ATTRIBUTE_MAX_LEN));
+  }
   if (kwargs.reasoning !== void 0) {
     span2.setAttribute(
       SpanAttributes2.LLM_REQUEST_REASONING,
@@ -3897,7 +4238,7 @@ function setRequestAttributes(span2, kwargs, requestType, system) {
     if (kwargs.suffix !== void 0) {
       span2.setAttribute(
         "llm.request.suffix",
-        truncate(safeStringify(kwargs.suffix), Config.CONVERSATION_MAX_LEN)
+        safeStringify(kwargs.suffix, Config.CONVERSATION_MAX_LEN)
       );
     }
   }
@@ -3920,12 +4261,20 @@ function setResponseAttributes(span2, response) {
   }
 }
 function setFinishReason(span2, response) {
+  if (response.stop_reason) {
+    span2.setAttribute(
+      SpanAttributes2.LLM_RESPONSE_FINISH_REASON,
+      String(response.stop_reason)
+    );
+    span2.setAttribute("gen_ai.response.finish_reason", String(response.stop_reason));
+  }
   const choices = response.choices;
-  if (!Array.isArray(choices) || choices.length === 0) return;
-  const reason = choices[0].finish_reason ?? choices[0].finishReason;
-  if (reason) {
-    span2.setAttribute("gen_ai.response.finish_reason", String(reason));
-    span2.setAttribute("llm.response.finish_reason", String(reason));
+  if (Array.isArray(choices) && choices.length > 0) {
+    const reason = choices[0].finish_reason ?? choices[0].finishReason;
+    if (reason) {
+      span2.setAttribute(SpanAttributes2.LLM_RESPONSE_FINISH_REASON, String(reason));
+      span2.setAttribute("gen_ai.response.finish_reason", String(reason));
+    }
   }
 }
 function setUsageAttributes(span2, response) {
@@ -3952,11 +4301,18 @@ function setUsageAttributes(span2, response) {
       Number(totalTokens)
     );
   }
-  const cacheTokens = (usage.prompt_tokens_details ?? usage.input_tokens_details)?.cached_tokens;
-  if (cacheTokens !== void 0) {
+  const cacheReadTokens = usage.cache_read_input_tokens ?? (usage.prompt_tokens_details ?? usage.input_tokens_details)?.cached_tokens;
+  if (cacheReadTokens !== void 0) {
     span2.setAttribute(
       SpanAttributes2.LLM_USAGE_CACHE_READ_INPUT_TOKENS,
-      Number(cacheTokens)
+      Number(cacheReadTokens)
+    );
+  }
+  const cacheCreationTokens = usage.cache_creation_input_tokens;
+  if (cacheCreationTokens !== void 0) {
+    span2.setAttribute(
+      SpanAttributes2.LLM_USAGE_CACHE_CREATION_INPUT_TOKENS,
+      Number(cacheCreationTokens)
     );
   }
   const reasoningTokens = (usage.completion_tokens_details ?? usage.output_tokens_details)?.reasoning_tokens;
@@ -3978,188 +4334,181 @@ function setEmbeddingResponseMeta(span2, response) {
   }
 }
 
-// src/instrumentation/anthropic/utils.ts
-function setRequestAttributes2(span2, kwargs, requestType) {
-  if (!span2.isRecording()) {
-    Logger.log("Span is not recording");
-    return;
-  }
-  setRequestAttributes(span2, kwargs, requestType, "anthropic");
-}
-function setResponseAttributes2(span2, response) {
-  if (!span2.isRecording()) {
-    Logger.log("Span is not recording");
-    return;
-  }
-  if (response?.type === "message_batch") {
-    span2.setAttribute("status", response?.processing_status);
-  }
-  setResponseAttributes(span2, response);
-}
+// src/instrumentation/anthropic/types.ts
+var SPAN_NAMES = {
+  CHAT: "anthropic.chat",
+  STREAM: "anthropic.stream",
+  BATCHES: "anthropic.batches",
+  BETA: "anthropic.beta",
+  BETA_STREAM: "anthropic.beta.stream",
+  BETA_TOOL_RUNNER: "anthropic.beta.tool.runner"
+};
 
-// src/instrumentation/anthropic/version.ts
-var __version__ = "1.0.0";
-var CHAT_SPAN_NAME = "anthropic.chat";
-var BETA_SPAN_NAME = "anthropic.beta";
-var BATCHES_SPAN_NAME = "anthropic.batches";
-var STREAM_ENABLED_REQUESTS = ["chat", "beta"];
-function anthropicWrapper(tracer, spanName, requestType) {
-  return function wrapper(wrapped, instance, args, kwargs) {
-    if (shouldSuppressInstrumentation()) {
-      const result = wrapped.call(instance, ...args);
-      return isPromise(result) ? result.then((value) => value) : result;
-    }
-    const currentContext = context.active();
-    const isStreaming = args[0]?.stream === true;
-    const activeSpan = trace.getSpan(context.active());
-    Logger.debug(`Anthropic invoke (${requestType}). Active TraceId: ${activeSpan?.spanContext().traceId}, SpanId: ${activeSpan?.spanContext().spanId}`);
-    if (isStreaming && STREAM_ENABLED_REQUESTS.includes(requestType)) {
-      const span2 = tracer.startSpan(
-        spanName + ".create",
-        {
-          kind: SpanKind.CLIENT,
-          attributes: {
-            "llm.request.type": requestType,
-            "llm.streaming": true
-          }
-        },
-        currentContext
-      );
-      try {
-        setRequestAttributes2(span2, kwargs, requestType);
-        const startTime = Date.now();
-        const spanContext = trace.setSpan(currentContext, span2);
-        const response = context.with(spanContext, () => wrapped.call(instance, ...args));
-        if (isPromise(response)) {
-          return (async () => {
-            try {
-              const stream = await response;
-              return new AsyncStreamingWrapper(span2, stream, startTime, kwargs, spanContext);
-            } catch (error) {
-              Logger.error("netra.instrumentation.anthropic:", error);
-              span2.setStatus({
-                code: SpanStatusCode.ERROR,
-                message: error instanceof Error ? error.message : String(error)
-              });
-              span2.recordException(error);
-              span2.end();
-              throw error;
-            }
-          })();
-        } else {
-          return new AsyncStreamingWrapper(span2, response, startTime, kwargs, spanContext);
+// src/instrumentation/anthropic/utils.ts
+function processStreamChunk(completeResponse, chunk, span2) {
+  try {
+    switch (chunk.type) {
+      case "message_start": {
+        if (chunk.message?.model) {
+          completeResponse.model = chunk.message.model;
         }
-      } catch (error) {
-        Logger.error("netra.instrumentation.anthropic:", error);
-        span2.setStatus({
-          code: SpanStatusCode.ERROR,
-          message: error instanceof Error ? error.message : String(error)
-        });
-        span2.recordException(error);
-        span2.end();
-        throw error;
+        if (chunk.message?.usage) {
+          completeResponse.usage = chunk.message.usage;
+        }
+        break;
       }
-    } else {
-      return tracer.startActiveSpan(
-        spanName,
-        {
-          kind: SpanKind.CLIENT,
-          attributes: { "llm.request.type": requestType }
-        },
-        (span2) => {
-          try {
-            setRequestAttributes2(span2, kwargs, requestType);
-            const startTime = Date.now();
-            const spanContext = trace.setSpan(currentContext, span2);
-            const response = context.with(spanContext, () => wrapped.call(instance, ...args));
-            if (isPromise(response)) {
-              const instrumentedPromise = (async () => {
-                try {
-                  const value = await response;
-                  const endTime = Date.now();
-                  const responseDict = modelAsDict(value);
-                  setResponseAttributes2(span2, responseDict);
-                  span2.setAttribute(
-                    "llm.response.duration",
-                    (endTime - startTime) / 1e3
-                  );
-                  span2.setStatus({ code: SpanStatusCode.OK });
-                  span2.end();
-                  return value;
-                } catch (error) {
-                  Logger.error("netra.instrumentation.anthropic:", error);
-                  span2.setStatus({
-                    code: SpanStatusCode.ERROR,
-                    message: error instanceof Error ? error.message : String(error)
-                  });
-                  span2.recordException(error);
-                  span2.end();
-                  throw error;
-                }
-              })();
-              return new Proxy(instrumentedPromise, {
-                get(target, prop, receiver) {
-                  if (prop === "then" || prop === "catch" || prop === "finally") {
-                    const value2 = Reflect.get(target, prop, receiver);
-                    if (typeof value2 === "function") {
-                      return value2.bind(target);
-                    }
-                    return value2;
-                  }
-                  const responseValue = response[prop];
-                  if (responseValue !== void 0) {
-                    if (typeof responseValue === "function") {
-                      return responseValue.bind(response);
-                    }
-                    return responseValue;
-                  }
-                  const value = Reflect.get(target, prop, receiver);
-                  if (typeof value === "function") {
-                    return value.bind(target);
-                  }
-                  return value;
-                }
-              });
-            } else {
-              const endTime = Date.now();
-              const responseDict = modelAsDict(response);
-              setResponseAttributes2(span2, responseDict);
-              span2.setAttribute(
-                "llm.response.duration",
-                (endTime - startTime) / 1e3
+      case "content_block_start": {
+        if (!completeResponse.content) {
+          completeResponse.content = [];
+        }
+        const block = chunk.content_block;
+        if (!block) break;
+        if (block.type === "tool_use") {
+          completeResponse.content.push({
+            type: "tool_use",
+            id: block.id,
+            name: block.name,
+            input: ""
+          });
+        } else {
+          completeResponse.content.push({
+            type: block.type,
+            text: ""
+          });
+        }
+        break;
+      }
+      case "content_block_delta": {
+        if (!completeResponse.content || completeResponse.content.length === 0) {
+          completeResponse.content = [{ type: "text", text: "" }];
+        }
+        const targetIndex = chunk.index ?? completeResponse.content.length - 1;
+        const targetBlock = completeResponse.content[targetIndex];
+        if (!targetBlock) break;
+        if (chunk.delta?.type === "input_json_delta" && targetBlock.type === "tool_use") {
+          targetBlock.input += chunk.delta.partial_json ?? "";
+        } else if (chunk.delta?.text) {
+          targetBlock.text += chunk.delta.text;
+        }
+        break;
+      }
+      case "content_block_stop": {
+        const blocks = completeResponse.content;
+        if (blocks && blocks.length > 0) {
+          const finishedBlock = blocks[blocks.length - 1];
+          if (finishedBlock?.type === "tool_use" && typeof finishedBlock.input === "string") {
+            try {
+              finishedBlock.input = JSON.parse(finishedBlock.input);
+            } catch {
+              Logger.warn(
+                "netra.instrumentation.anthropic: Failed to parse tool use input"
               );
-              span2.setStatus({ code: SpanStatusCode.OK });
-              span2.end();
-              return response;
             }
-          } catch (error) {
-            Logger.error("netra.instrumentation.anthropic:", error);
-            span2.setStatus({
-              code: SpanStatusCode.ERROR,
-              message: error instanceof Error ? error.message : String(error)
-            });
-            span2.recordException(error);
-            span2.end();
-            throw error;
           }
         }
-      );
+        break;
+      }
+      case "message_delta": {
+        if (chunk.delta?.stop_reason) {
+          completeResponse.stop_reason = chunk.delta.stop_reason;
+        }
+        const usageData = chunk.usage ?? chunk.delta?.usage;
+        if (usageData) {
+          completeResponse.usage = {
+            ...completeResponse.usage ?? {},
+            ...usageData
+          };
+        }
+        break;
+      }
+      case "message_stop": {
+        if (chunk.usage) {
+          completeResponse.usage = {
+            ...completeResponse.usage ?? {},
+            ...chunk.usage
+          };
+        }
+        break;
+      }
     }
-  };
+    if (Logger.isDebugMode()) {
+      span2.addEvent("llm.content.completion.chunk", {
+        "chunk.type": chunk.type
+      });
+    }
+  } catch (e) {
+    Logger.error(
+      "netra.instrumentation.anthropic: processStreamChunk error",
+      e
+    );
+  }
 }
-var chatWrapper = (tracer) => anthropicWrapper(tracer, CHAT_SPAN_NAME, "chat");
-var betaWrapper = (tracer) => anthropicWrapper(tracer, BETA_SPAN_NAME, "beta");
-var batchesWrapper = (tracer) => anthropicWrapper(tracer, BATCHES_SPAN_NAME, "batches");
+function finalizeStreamSpan(span2, completeResponse, startTime, code) {
+  try {
+    const endTime = Date.now();
+    setResponseAttributes2(span2, {
+      model: completeResponse.model,
+      content: completeResponse.content,
+      usage: completeResponse.usage,
+      stop_reason: completeResponse.stop_reason
+    });
+    span2.setAttribute("llm.response.duration", (endTime - startTime) / 1e3);
+    span2.setStatus({ code });
+  } catch (e) {
+    Logger.error(
+      "netra.instrumentation.anthropic: finalizeStreamSpan error",
+      e
+    );
+  } finally {
+    span2.end();
+  }
+}
+function setRequestAttributes2(span2, kwargs, requestType) {
+  try {
+    if (!span2.isRecording()) {
+      Logger.log("Span is not recording");
+      return;
+    }
+    setRequestAttributes(span2, kwargs, requestType, "anthropic");
+  } catch (e) {
+    Logger.error(
+      "netra.instrumentation.anthropic: setRequestAttributes error",
+      e
+    );
+  }
+}
+function setResponseAttributes2(span2, response) {
+  try {
+    if (!span2.isRecording()) {
+      Logger.log("Span is not recording");
+      return;
+    }
+    if (response?.type === "message_batch") {
+      span2.setAttribute("status", response?.processing_status);
+    }
+    setResponseAttributes(span2, response);
+  } catch (e) {
+    Logger.error(
+      "netra.instrumentation.anthropic: setResponseAttributes error",
+      e
+    );
+  }
+}
+
+// src/instrumentation/anthropic/wrappers.ts
 var WRAPPER_OWN_PROPS = /* @__PURE__ */ new Set([
   "span",
   "messageStream",
   "startTime",
   "requestKwargs",
   "completeResponse",
-  "processChunk",
-  "finalizeSpan",
+  "finalizeSpanOnce",
   "processEventData",
-  "finalizeSpanFromMessage"
+  "finalizeSpanFromMessage",
+  "parentContext",
+  "spanFinalized",
+  "completionPending",
+  "listenerMap"
 ]);
 var EVENT_EMITTER_METHODS = /* @__PURE__ */ new Set([
   "on",
@@ -4173,20 +4522,90 @@ var EVENT_EMITTER_METHODS = /* @__PURE__ */ new Set([
   "listenerCount"
 ]);
 var LISTENER_REGISTRATION_METHODS = /* @__PURE__ */ new Set(["on", "once", "addListener"]);
+var LISTENER_REMOVAL_METHODS = /* @__PURE__ */ new Set(["off", "removeListener"]);
 var COMPLETION_METHODS = /* @__PURE__ */ new Set(["finalMessage", "done", "finalText"]);
-var TRACKED_STREAM_EVENTS = /* @__PURE__ */ new Set(["message", "contentBlock", "text", "finalMessage"]);
+var TRACKED_STREAM_EVENTS = /* @__PURE__ */ new Set([
+  "message",
+  "contentBlock",
+  "text",
+  "finalMessage"
+]);
+var MAX_TOOL_ATTR_LENGTH = 4096;
+function wrapRunnableTools(tools, tracer, parentContext) {
+  return tools.map((tool) => {
+    if (typeof tool.run !== "function") return tool;
+    const originalRun = tool.run;
+    const toolName = tool.name ?? "unknown_tool";
+    const wrappedRun = async function(input, runContext) {
+      const toolUseId = runContext?.toolUse?.id ?? runContext?.toolUseBlock?.id;
+      const traceContent = isTraceContentEnabled();
+      const attrs = {
+        "netra.span.type": "TOOL",
+        [SpanAttributes2.LLM_REQUEST_TOOL_NAME]: toolName
+      };
+      if (toolUseId) attrs[SpanAttributes2.LLM_REQUEST_TOOL_ID] = toolUseId;
+      if (traceContent) {
+        attrs.input = safeStringify(input, MAX_TOOL_ATTR_LENGTH);
+      }
+      const span2 = tracer.startSpan(
+        toolName,
+        { kind: SpanKind.INTERNAL, attributes: attrs },
+        parentContext
+      );
+      const spanCtx = trace.setSpan(parentContext, span2);
+      try {
+        const result = await context.with(
+          spanCtx,
+          () => originalRun.call(this, input, runContext)
+        );
+        if (traceContent) {
+          span2.setAttribute(
+            "output",
+            safeStringify(result, MAX_TOOL_ATTR_LENGTH)
+          );
+        }
+        span2.setStatus({ code: SpanStatusCode.OK });
+        return result;
+      } catch (error) {
+        span2.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: error instanceof Error ? error.message : String(error)
+        });
+        span2.recordException(error);
+        throw error;
+      } finally {
+        span2.end();
+      }
+    };
+    const wrapped = Object.create(
+      Object.getPrototypeOf(tool),
+      Object.getOwnPropertyDescriptors(tool)
+    );
+    wrapped.run = wrappedRun;
+    return wrapped;
+  });
+}
 var MessageStreamWrapper = class {
-  constructor(span2, messageStream, startTime, requestKwargs, spanContext) {
+  constructor(span2, messageStream, startTime, requestKwargs, spanContext, parentContext) {
     this.completeResponse = {
       content: [],
       model: "",
       usage: {}
     };
+    this.spanFinalized = false;
+    this.completionPending = false;
+    this.listenerMap = /* @__PURE__ */ new WeakMap();
     defineHidden(this, "span", span2);
     defineHidden(this, "messageStream", messageStream);
     defineHidden(this, "startTime", startTime);
     defineHidden(this, "requestKwargs", requestKwargs);
-    defineHidden(this, "spanContext", spanContext || trace.setSpan(context.active(), span2));
+    defineHidden(
+      this,
+      "spanContext",
+      spanContext || trace.setSpan(context.active(), span2)
+    );
+    defineHidden(this, "parentContext", parentContext || context.active());
+    this.registerSafetyNetListeners();
     return new Proxy(this, {
       get(target, prop, receiver) {
         if (prop === "toJSON") {
@@ -4200,67 +4619,135 @@ var MessageStreamWrapper = class {
         }
         if (typeof prop === "string" && EVENT_EMITTER_METHODS.has(prop)) {
           const method = target.messageStream[prop];
-          if (typeof method === "function") {
-            if (LISTENER_REGISTRATION_METHODS.has(prop)) {
-              return function(event, listener) {
-                const wrappedListener = (...args) => {
+          if (typeof method !== "function") return method;
+          if (LISTENER_REGISTRATION_METHODS.has(prop)) {
+            return function(event, listener) {
+              const wrappedListener = (...args) => {
+                try {
                   target.span.addEvent(`messagestream.event.${event}`, {
                     "event.type": event
                   });
-                  if (TRACKED_STREAM_EVENTS.has(event)) {
-                    if (args[0]) {
-                      target.processEventData(event, args[0]);
-                    }
+                  if (TRACKED_STREAM_EVENTS.has(event) && args[0]) {
+                    target.processEventData(event, args[0]);
                   }
-                  return listener(...args);
-                };
-                return method.call(target.messageStream, event, wrappedListener);
+                } catch (e) {
+                  Logger.error(
+                    "netra.instrumentation.anthropic: event tracking error",
+                    e
+                  );
+                }
+                return listener(...args);
               };
-            }
-            return method.bind(target.messageStream);
+              let eventMap = target.listenerMap.get(listener);
+              if (!eventMap) {
+                eventMap = /* @__PURE__ */ new Map();
+                target.listenerMap.set(listener, eventMap);
+              }
+              let wrappers = eventMap.get(event);
+              if (!wrappers) {
+                wrappers = [];
+                eventMap.set(event, wrappers);
+              }
+              wrappers.push(wrappedListener);
+              return method.call(target.messageStream, event, wrappedListener);
+            };
+          }
+          if (LISTENER_REMOVAL_METHODS.has(prop)) {
+            return function(event, listener) {
+              const eventMap = target.listenerMap.get(listener);
+              const wrappers = eventMap?.get(event);
+              const wrapped = wrappers?.shift() ?? listener;
+              if (wrappers && wrappers.length === 0) eventMap?.delete(event);
+              return method.call(target.messageStream, event, wrapped);
+            };
           }
-          return method;
+          if (prop === "removeAllListeners") {
+            return function(event) {
+              target.listenerMap = /* @__PURE__ */ new WeakMap();
+              return method.call(target.messageStream, event);
+            };
+          }
+          return method.bind(target.messageStream);
         }
         if (typeof prop === "string" && COMPLETION_METHODS.has(prop)) {
           const method = target.messageStream[prop];
-          if (typeof method === "function") {
-            return async function(...args) {
-              try {
-                const result = await method.call(target.messageStream, ...args);
-                if (prop === "finalMessage" || prop === "done") {
-                  target.finalizeSpanFromMessage(result);
+          if (typeof method !== "function") return method;
+          return async function(...args) {
+            target.completionPending = true;
+            try {
+              const result = await method.call(target.messageStream, ...args);
+              if (prop === "finalMessage" || prop === "done") {
+                target.finalizeSpanFromMessage(result);
+              } else if (prop === "finalText") {
+                if (typeof result === "string" && result.length > 0) {
+                  target.completeResponse.content = [
+                    { type: "text", text: result }
+                  ];
+                } else {
+                  target.flushCurrentText();
                 }
-                return result;
-              } catch (error) {
-                target.finalizeSpan(SpanStatusCode.ERROR);
-                throw error;
+                target.finalizeSpanOnce(SpanStatusCode.OK);
               }
-            };
-          }
-          return method;
+              return result;
+            } catch (error) {
+              target.finalizeSpanOnce(SpanStatusCode.ERROR);
+              throw error;
+            }
+          };
         }
         const value = target.messageStream[prop];
-        if (typeof value === "function") {
+        if (typeof value === "function")
           return value.bind(target.messageStream);
-        }
         return value;
       }
     });
   }
+  registerSafetyNetListeners() {
+    try {
+      if (typeof this.messageStream?.on !== "function") return;
+      this.messageStream.on("end", () => {
+        if (!this.completionPending) {
+          this.finalizeSpanOnce(SpanStatusCode.OK);
+        }
+      });
+      this.messageStream.on("error", (err) => {
+        if (err && !this.spanFinalized) {
+          this.span.setStatus({
+            code: SpanStatusCode.ERROR,
+            message: err instanceof Error ? err.message : String(err)
+          });
+          this.span.recordException(
+            err instanceof Error ? err : new Error(String(err))
+          );
+        }
+        this.finalizeSpanOnce(SpanStatusCode.ERROR);
+      });
+    } catch (e) {
+      Logger.error(
+        "netra.instrumentation.anthropic: safety net listener registration failed",
+        e
+      );
+    }
+  }
   toJSON() {
     return this.completeResponse;
   }
   async *[Symbol.asyncIterator]() {
+    let errorOccurred = false;
     try {
       for await (const chunk of this.messageStream) {
-        this.processChunk(chunk);
+        processStreamChunk(this.completeResponse, chunk, this.span);
         yield chunk;
       }
-      this.finalizeSpan(SpanStatusCode.OK);
     } catch (err) {
+      errorOccurred = true;
       Logger.error("netra.instrumentation.anthropic: Stream error", err);
-      this.finalizeSpan(SpanStatusCode.ERROR);
+      this.finalizeSpanOnce(SpanStatusCode.ERROR);
       throw err;
+    } finally {
+      if (!errorOccurred) {
+        this.finalizeSpanOnce(SpanStatusCode.OK);
+      }
     }
   }
   getSpanContext() {
@@ -4269,12 +4756,8 @@ var MessageStreamWrapper = class {
   processEventData(eventType, data) {
     switch (eventType) {
       case "message":
-        if (data.model) {
-          this.completeResponse.model = data.model;
-        }
-        if (data.usage) {
-          this.completeResponse.usage = data.usage;
-        }
+        if (data.model) this.completeResponse.model = data.model;
+        if (data.usage) this.completeResponse.usage = data.usage;
         break;
       case "text":
         if (!this.completeResponse.currentText) {
@@ -4295,250 +4778,359 @@ var MessageStreamWrapper = class {
         break;
     }
   }
-  processChunk(chunk) {
-    switch (chunk.type) {
-      case "message_start": {
-        if (chunk.message?.model) {
-          this.completeResponse.model = chunk.message.model;
-        }
-        if (chunk.message?.usage) {
-          this.completeResponse.usage = chunk.message.usage;
-        }
-        break;
-      }
-      case "content_block_start": {
-        if (!this.completeResponse.content) {
-          this.completeResponse.content = [];
-        }
-        const block = chunk.content_block;
-        if (block.type === "tool_use") {
-          this.completeResponse.content.push({
-            type: "tool_use",
-            id: block.id,
-            name: block.name,
-            input: ""
-          });
-        } else {
-          this.completeResponse.content.push({
-            type: block.type,
-            text: ""
-          });
-        }
-        break;
-      }
-      case "content_block_delta": {
-        if (!this.completeResponse.content || this.completeResponse.content.length === 0) {
-          this.completeResponse.content = [{ type: "text", text: "" }];
-        }
-        const lastBlock = this.completeResponse.content[this.completeResponse.content.length - 1];
-        if (chunk.delta?.type === "input_json_delta" && lastBlock?.type === "tool_use") {
-          lastBlock.input += chunk.delta.partial_json ?? "";
-        } else if (lastBlock && chunk.delta?.text) {
-          lastBlock.text += chunk.delta.text;
-        }
-        break;
-      }
-      case "content_block_stop": {
-        const blocks = this.completeResponse.content;
-        if (blocks && blocks.length > 0) {
-          const finishedBlock = blocks[blocks.length - 1];
-          if (finishedBlock?.type === "tool_use" && typeof finishedBlock.input === "string") {
-            try {
-              finishedBlock.input = JSON.parse(finishedBlock.input);
-            } catch {
-              Logger.warn("netra.instrumentation.anthropic: Failed to parse tool use input", finishedBlock.input);
-            }
-          }
-        }
-        break;
-      }
-      case "message_delta": {
-        if (chunk.delta?.usage) {
-          this.completeResponse.usage = {
-            ...this.completeResponse.usage,
-            ...chunk.delta.usage
-          };
-        }
-        break;
-      }
-      case "message_stop": {
-        if (chunk.usage) {
-          this.completeResponse.usage = chunk.usage;
-        }
-        break;
-      }
+  flushCurrentText() {
+    if (this.completeResponse.currentText && (!this.completeResponse.content || this.completeResponse.content.length === 0)) {
+      this.completeResponse.content = [
+        { type: "text", text: this.completeResponse.currentText }
+      ];
     }
-    this.span.addEvent("llm.content.completion.chunk", {
-      "chunk.type": chunk.type
-    });
   }
   finalizeSpanFromMessage(message) {
     if (message) {
       if (message.model) this.completeResponse.model = message.model;
       if (message.content) this.completeResponse.content = message.content;
       if (message.usage) this.completeResponse.usage = message.usage;
+      if (message.stop_reason)
+        this.completeResponse.stop_reason = message.stop_reason;
     }
-    this.finalizeSpan(SpanStatusCode.OK);
+    this.finalizeSpanOnce(SpanStatusCode.OK);
   }
-  finalizeSpan(code) {
-    const endTime = Date.now();
-    const duration = (endTime - this.startTime) / 1e3;
-    setResponseAttributes2(this.span, {
-      model: this.completeResponse.model,
-      content: this.completeResponse.content,
-      usage: this.completeResponse.usage
-    });
-    this.span.setAttribute("llm.response.duration", duration);
-    this.span.setStatus({ code });
-    this.span.end();
+  finalizeSpanOnce(code) {
+    if (this.spanFinalized) return;
+    this.spanFinalized = true;
+    finalizeStreamSpan(this.span, this.completeResponse, this.startTime, code);
   }
 };
-var AsyncStreamingWrapper = class {
-  constructor(span2, response, startTime, requestKwargs, spanContext) {
-    this.iterator = null;
-    this.completeResponse = {
-      choices: [],
-      model: ""
-    };
-    defineHidden(this, "span", span2);
-    defineHidden(this, "response", response);
-    defineHidden(this, "startTime", startTime);
-    defineHidden(this, "requestKwargs", requestKwargs);
-    defineHidden(this, "spanContext", spanContext || trace.setSpan(context.active(), span2));
-  }
-  toJSON() {
-    return this.completeResponse;
-  }
-  [Symbol.asyncIterator]() {
-    return this;
-  }
-  async next() {
-    try {
-      if (!this.iterator) {
-        if (Symbol.asyncIterator in this.response) {
-          this.iterator = this.response[Symbol.asyncIterator]();
-        } else if (typeof this.response.next === "function") {
-          this.iterator = this.response;
-        } else {
-          throw new Error("Response is not iterable");
-        }
-      }
-      const result = await context.with(this.spanContext, () => this.iterator.next());
-      if (result.done) {
-        this.finalizeSpan(SpanStatusCode.OK);
-        return result;
-      }
-      this.processChunk(result.value);
-      return result;
-    } catch (error) {
-      this.finalizeSpan(SpanStatusCode.ERROR);
-      throw error;
-    }
-  }
-  processChunk(chunk) {
-    switch (chunk.type) {
-      case "message_start": {
-        if (chunk.message?.model) {
-          this.completeResponse.model = chunk.message.model;
-        }
-        if (chunk.message?.usage) {
-          this.completeResponse.usage = chunk.message.usage;
-        }
-        break;
-      }
-      case "content_block_start": {
-        const content = this.completeResponse.content || [];
-        this.completeResponse.content = content;
-        const block = chunk.content_block;
-        if (block.type === "tool_use") {
-          content.push({
-            type: "tool_use",
-            id: block.id,
-            name: block.name,
-            input: ""
-          });
-        } else {
-          content.push({
-            type: block.type,
-            text: ""
-          });
-        }
-        break;
+function anthropicWrapper(tracer, spanName, requestType) {
+  return function wrapper(original) {
+    return function(...args) {
+      if (shouldSuppressInstrumentation()) {
+        return original.apply(this, args);
       }
-      case "content_block_delta": {
-        const content = this.completeResponse.content || [];
-        if (content.length === 0) {
-          content.push({ type: "text", text: "" });
-          this.completeResponse.content = content;
-        }
-        const lastBlock = content[content.length - 1];
-        if (chunk.delta?.type === "input_json_delta" && lastBlock?.type === "tool_use") {
-          lastBlock.input += chunk.delta.partial_json ?? "";
-        } else if (lastBlock && chunk.delta?.text) {
-          lastBlock.text += chunk.delta.text;
+      const attributes = args[0] || {};
+      const currentContext = context.active();
+      const isStreaming = attributes.stream === true;
+      const activeSpan = trace.getSpan(currentContext);
+      Logger.debug(
+        `Anthropic invoke (${requestType}). Active TraceId: ${activeSpan?.spanContext().traceId}, SpanId: ${activeSpan?.spanContext().spanId}`
+      );
+      return tracer.startActiveSpan(
+        spanName,
+        {
+          kind: SpanKind.CLIENT,
+          attributes: { "llm.request.type": requestType }
+        },
+        (span2) => {
+          try {
+            setRequestAttributes2(span2, attributes, requestType);
+            if (isStreaming) {
+              span2.setAttribute("llm.streaming", true);
+            }
+            const startTime = Date.now();
+            const spanContext = trace.setSpan(currentContext, span2);
+            const response = context.with(
+              spanContext,
+              () => original.apply(this, args)
+            );
+            const completeResponse = {
+              content: [],
+              model: "",
+              usage: {}
+            };
+            return wrapResponse(
+              response,
+              {
+                withContext: (fn) => context.with(spanContext, fn),
+                onChunk: (chunk) => processStreamChunk(completeResponse, chunk, span2),
+                onError: (error) => {
+                  Logger.error("netra.instrumentation.anthropic:", error);
+                  span2.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: error instanceof Error ? error.message : String(error)
+                  });
+                  span2.recordException(error);
+                },
+                onSuccess: (value) => {
+                  const endTime = Date.now();
+                  const responseDict = modelAsDict(value);
+                  setResponseAttributes2(span2, responseDict);
+                  span2.setAttribute(
+                    "llm.response.duration",
+                    (endTime - startTime) / 1e3
+                  );
+                },
+                finalize: (status) => {
+                  const hasStreamData = completeResponse.content?.length || completeResponse.model || completeResponse.usage?.input_tokens !== void 0 || completeResponse.usage?.output_tokens !== void 0;
+                  if (status === "ok" && hasStreamData) {
+                    finalizeStreamSpan(
+                      span2,
+                      completeResponse,
+                      startTime,
+                      SpanStatusCode.OK
+                    );
+                  } else {
+                    if (status === "ok") {
+                      span2.setStatus({ code: SpanStatusCode.OK });
+                    }
+                    span2.end();
+                  }
+                }
+              },
+              { preserveOriginal: response }
+            );
+          } catch (error) {
+            Logger.error("netra.instrumentation.anthropic:", error);
+            span2.setStatus({
+              code: SpanStatusCode.ERROR,
+              message: error instanceof Error ? error.message : String(error)
+            });
+            span2.recordException(error);
+            span2.end();
+            throw error;
+          }
         }
-        break;
+      );
+    };
+  };
+}
+function streamWrapper(tracer, spanName, requestType, originalCreate) {
+  return function wrapper(original) {
+    return function(...args) {
+      if (shouldSuppressInstrumentation()) {
+        return original.apply(this, args);
       }
-      case "content_block_stop": {
-        const content = this.completeResponse.content || [];
-        if (content.length > 0) {
-          const finishedBlock = content[content.length - 1];
-          if (finishedBlock?.type === "tool_use" && typeof finishedBlock.input === "string") {
-            try {
-              finishedBlock.input = JSON.parse(finishedBlock.input);
-            } catch {
-              Logger.warn("netra.instrumentation.anthropic: Failed to parse tool use input", finishedBlock.input);
-            }
+      const attributes = args[0] || {};
+      const currentContext = context.active();
+      const span2 = tracer.startSpan(
+        spanName,
+        {
+          kind: SpanKind.CLIENT,
+          attributes: {
+            "llm.request.type": requestType,
+            "llm.streaming": true,
+            "llm.operation": "stream"
           }
+        },
+        currentContext
+      );
+      const spanContext = trace.setSpan(currentContext, span2);
+      setRequestAttributes2(span2, attributes, requestType);
+      const startTime = Date.now();
+      const callTarget = originalCreate ? new Proxy(this, {
+        get(target, prop) {
+          if (prop === "create") return originalCreate.bind(target);
+          const value = target[prop];
+          if (typeof value === "function") return value.bind(target);
+          return value;
         }
-        break;
+      }) : this;
+      try {
+        const messageStream = context.with(
+          spanContext,
+          () => original.call(callTarget, ...args)
+        );
+        return new MessageStreamWrapper(
+          span2,
+          messageStream,
+          startTime,
+          attributes,
+          spanContext,
+          currentContext
+        );
+      } catch (error) {
+        span2.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: error instanceof Error ? error.message : String(error)
+        });
+        span2.recordException(error);
+        span2.end();
+        throw error;
       }
-      case "message_delta": {
-        if (chunk.delta?.usage) {
-          const currentUsage = this.completeResponse.usage || {};
-          this.completeResponse.usage = {
-            ...currentUsage,
-            ...chunk.delta.usage
-          };
-        }
-        break;
+    };
+  };
+}
+function toolRunnerWrapper(tracer, spanName, requestType) {
+  return function wrapper(original) {
+    return function(...args) {
+      if (shouldSuppressInstrumentation()) {
+        return original.apply(this, args);
       }
-      case "message_stop": {
-        if (chunk.usage) {
-          this.completeResponse.usage = chunk.usage;
+      const attributes = args[0] || {};
+      const currentContext = context.active();
+      const span2 = tracer.startSpan(
+        spanName,
+        {
+          kind: SpanKind.CLIENT,
+          attributes: {
+            "llm.request.type": requestType,
+            "netra.span.type": "AGENT",
+            "llm.operation": "tool.runner"
+          }
+        },
+        currentContext
+      );
+      let spanEnded = false;
+      const endSpanOnce = (code, error) => {
+        if (spanEnded) return;
+        spanEnded = true;
+        if (error) {
+          span2.setStatus({ code, message: error.message });
+          span2.recordException(error);
+        } else {
+          span2.setStatus({ code });
         }
-        break;
+        span2.end();
+      };
+      try {
+        setRequestAttributes2(span2, attributes, "beta");
+        const spanContext = trace.setSpan(currentContext, span2);
+        const wrappedTools = Array.isArray(attributes.tools) ? wrapRunnableTools(attributes.tools, tracer, spanContext) : attributes.tools;
+        const wrappedArgs = [
+          { ...attributes, tools: wrappedTools },
+          ...args.slice(1)
+        ];
+        const runner = context.with(
+          spanContext,
+          () => original.apply(this, wrappedArgs)
+        );
+        if (runner == null) {
+          endSpanOnce(SpanStatusCode.OK);
+          return runner;
+        }
+        return new Proxy(runner, {
+          get(target, prop, receiver) {
+            if (prop === Symbol.asyncIterator) {
+              return function() {
+                const originalIterator = target[Symbol.asyncIterator]();
+                return {
+                  [Symbol.asyncIterator]() {
+                    return this;
+                  },
+                  async next() {
+                    try {
+                      const result = await context.with(
+                        spanContext,
+                        () => originalIterator.next()
+                      );
+                      if (result.done) endSpanOnce(SpanStatusCode.OK);
+                      return result;
+                    } catch (error) {
+                      endSpanOnce(SpanStatusCode.ERROR, error);
+                      throw error;
+                    }
+                  },
+                  async return(value2) {
+                    try {
+                      const result = await (originalIterator.return?.(
+                        value2
+                      ) ?? {
+                        done: true,
+                        value: value2
+                      });
+                      return result;
+                    } finally {
+                      endSpanOnce(SpanStatusCode.OK);
+                    }
+                  },
+                  async throw(error) {
+                    const err = error instanceof Error ? error : new Error(String(error));
+                    if (originalIterator.throw) {
+                      try {
+                        const result = await originalIterator.throw(error);
+                        if (result.done) {
+                          endSpanOnce(SpanStatusCode.ERROR, err);
+                        }
+                        return result;
+                      } catch (e) {
+                        endSpanOnce(
+                          SpanStatusCode.ERROR,
+                          e instanceof Error ? e : new Error(String(e))
+                        );
+                        throw e;
+                      }
+                    }
+                    endSpanOnce(SpanStatusCode.ERROR, err);
+                    throw error;
+                  }
+                };
+              };
+            }
+            if (prop === "then" || prop === "catch" || prop === "finally") {
+              const originalMethod = target[prop];
+              if (typeof originalMethod !== "function") return originalMethod;
+              if (prop === "then") {
+                return function(onFulfilled, onRejected) {
+                  return originalMethod.call(
+                    target,
+                    (v) => {
+                      endSpanOnce(SpanStatusCode.OK);
+                      return onFulfilled ? onFulfilled(v) : v;
+                    },
+                    (e) => {
+                      endSpanOnce(
+                        SpanStatusCode.ERROR,
+                        e instanceof Error ? e : new Error(String(e))
+                      );
+                      if (onRejected) return onRejected(e);
+                      throw e;
+                    }
+                  );
+                };
+              }
+              if (prop === "catch") {
+                return function(onRejected) {
+                  return receiver.then(void 0, onRejected);
+                };
+              }
+              if (prop === "finally") {
+                return function(onFinally) {
+                  return receiver.then(
+                    (v) => {
+                      onFinally?.();
+                      return v;
+                    },
+                    (e) => {
+                      onFinally?.();
+                      throw e;
+                    }
+                  );
+                };
+              }
+            }
+            const value = target[prop];
+            if (typeof value === "function") return value.bind(target);
+            return value;
+          }
+        });
+      } catch (error) {
+        endSpanOnce(
+          SpanStatusCode.ERROR,
+          error instanceof Error ? error : new Error(String(error))
+        );
+        throw error;
       }
-    }
-    this.span.addEvent("llm.content.completion.chunk", {
-      "chunk.type": chunk.type
-    });
-  }
-  finalizeSpan(code) {
-    const endTime = Date.now();
-    const duration = (endTime - this.startTime) / 1e3;
-    setResponseAttributes2(this.span, {
-      model: this.completeResponse.model,
-      content: this.completeResponse.content,
-      usage: this.completeResponse.usage
-    });
-    this.span.setAttribute("llm.response.duration", duration);
-    this.span.setStatus({ code });
-    this.span.end();
-  }
-};
+    };
+  };
+}
+var chatWrapper = (tracer) => anthropicWrapper(tracer, SPAN_NAMES.CHAT, "chat");
+var betaWrapper = (tracer) => anthropicWrapper(tracer, SPAN_NAMES.BETA, "beta");
+var batchesWrapper = (tracer) => anthropicWrapper(tracer, SPAN_NAMES.BATCHES, "batches");
+var chatStreamWrapper = (tracer, originalCreate) => streamWrapper(tracer, SPAN_NAMES.STREAM, "chat", originalCreate);
+var betaStreamWrapper = (tracer, originalCreate) => streamWrapper(tracer, SPAN_NAMES.BETA_STREAM, "beta", originalCreate);
+var betaToolRunnerWrapper = (tracer) => toolRunnerWrapper(tracer, SPAN_NAMES.BETA_TOOL_RUNNER, "beta");
 
 // src/instrumentation/anthropic/index.ts
 var INSTRUMENTATION_NAME = "netra.instrumentation.anthropic";
 var INSTRUMENTS = ["anthropic >= 0.71.2"];
-var originalMethods = /* @__PURE__ */ new Map();
 var isInstrumented = false;
 var anthropicClasses = [];
-async function resolveAnthropicAsync() {
+async function resolveAnthropic() {
   if (anthropicClasses.length > 0) return anthropicClasses;
   try {
     const anthropicModule = await import('@anthropic-ai/sdk');
-    anthropicClasses.push(anthropicModule.Anthropic || anthropicModule.default || anthropicModule);
+    anthropicClasses.push(
+      anthropicModule.Anthropic || anthropicModule.default || anthropicModule
+    );
   } catch {
     Logger.warn("Failed to resolve Anthropic ESM module");
   }
@@ -4554,9 +5146,6 @@ async function resolveAnthropicAsync() {
   }
   return anthropicClasses;
 }
-function resolveAnthropic() {
-  return anthropicClasses;
-}
 var NetraAnthropicInstrumentor = class {
   constructor() {
     this.tracer = null;
@@ -4564,15 +5153,13 @@ var NetraAnthropicInstrumentor = class {
   instrumentationDependencies() {
     return INSTRUMENTS;
   }
-  async instrumentAsync(options = {}) {
+  async instrument(options = {}) {
     if (isInstrumented) {
       Logger.warn("Anthropic is already instrumented");
       return this;
     }
-    const classes = await resolveAnthropicAsync();
-    if (classes.length === 0) {
-      return this;
-    }
+    const classes = await resolveAnthropic();
+    if (classes.length === 0) return this;
     try {
       this.tracerProvider = options.tracerProvider;
       if (this.tracerProvider) {
@@ -4587,10 +5174,10 @@ var NetraAnthropicInstrumentor = class {
       Logger.error(`Failed to initialize tracer: ${error}`);
       return this;
     }
-    classes.forEach((AnthropicSDK, index) => {
-      this._instrumentMessages(AnthropicSDK, index);
-      this._instrumentBetaMessages(AnthropicSDK, index);
-      this._instrumentBatchMessages(AnthropicSDK, index);
+    classes.forEach((AnthropicSDK) => {
+      this._instrumentMessages(AnthropicSDK);
+      this._instrumentBetaMessages(AnthropicSDK);
+      this._instrumentBatchMessages(AnthropicSDK);
     });
     isInstrumented = true;
     return this;
@@ -4600,185 +5187,137 @@ var NetraAnthropicInstrumentor = class {
       Logger.warn("Anthropic is not instrumented");
       return;
     }
-    const classes = resolveAnthropic();
-    classes.forEach((AnthropicSDK, index) => {
-      this._uninstrumentMessages(AnthropicSDK, index);
-      this._uninstrumentBetaMessages(AnthropicSDK, index);
-      this._uninstrumentBatchMessages(AnthropicSDK, index);
+    anthropicClasses.forEach((AnthropicSDK) => {
+      this._uninstrumentMessages(AnthropicSDK);
+      this._uninstrumentBetaMessages(AnthropicSDK);
+      this._uninstrumentBatchMessages(AnthropicSDK);
     });
-    originalMethods.clear();
     anthropicClasses = [];
     isInstrumented = false;
   }
   isInstrumented() {
     return isInstrumented;
   }
-  _instrumentMessages(AnthropicSDK, index) {
+  _instrumentMessages(AnthropicSDK) {
     if (!this.tracer) {
       Logger.warn("Anthropic instrumentation: No tracer available");
       return;
     }
     try {
       const MessagesClass = AnthropicSDK.Messages;
-      if (!MessagesClass) {
+      if (!MessagesClass?.prototype) {
         Logger.error(
-          "Anthropic instrumentation: Could not find Anthropic Messages class to instrument"
+          "Anthropic instrumentation: Could not find Messages class"
         );
         return;
       }
-      if (MessagesClass?.prototype?.stream) {
-        const originalStream = MessagesClass.prototype.stream;
-        originalMethods.set(`messages.stream-${index}`, originalStream);
-        const tracer = this.tracer;
-        MessagesClass.prototype.stream = function(...args) {
-          const original = originalStream.bind(this);
-          const kwargs = args[0] || {};
-          const currentContext = context.active();
-          const span2 = tracer.startSpan("anthropic.stream", {
-            kind: SpanKind.CLIENT,
-            attributes: {
-              "llm.request.type": "chat",
-              "llm.streaming": true,
-              "llm.operation": "stream"
-            }
-          }, currentContext);
-          const spanContext = trace.setSpan(currentContext, span2);
-          setRequestAttributes2(span2, kwargs, "chat");
-          const startTime = Date.now();
-          const instrumentedCreate = this.create;
-          const originalCreate = originalMethods.get(`messages.create-${index}`);
-          if (originalCreate) {
-            this.create = originalCreate;
-          }
-          try {
-            const messageStream = context.with(spanContext, () => original(...args));
-            return new MessageStreamWrapper(span2, messageStream, startTime, kwargs, spanContext);
-          } finally {
-            if (originalCreate) {
-              this.create = instrumentedCreate;
-            }
-          }
-        };
+      const originalCreate = MessagesClass.prototype.create;
+      if (typeof MessagesClass.prototype.create === "function") {
+        shimmer.wrap(
+          MessagesClass.prototype,
+          "create",
+          chatWrapper(this.tracer)
+        );
       }
-      if (MessagesClass?.prototype?.create) {
-        const originalCreate = MessagesClass.prototype.create;
-        originalMethods.set(`messages.create-${index}`, originalCreate);
-        const tracer = this.tracer;
-        const wrapper = chatWrapper(tracer);
-        MessagesClass.prototype.create = function(...args) {
-          const original = originalCreate.bind(this);
-          const kwargs = args[0] || {};
-          return wrapper(
-            (...a) => original(...a),
-            this,
-            args,
-            kwargs
-          );
-        };
+      if (typeof MessagesClass.prototype.stream === "function") {
+        shimmer.wrap(
+          MessagesClass.prototype,
+          "stream",
+          chatStreamWrapper(this.tracer, originalCreate)
+        );
       }
     } catch (error) {
       Logger.error(`Failed to instrument messages: ${error}`);
     }
   }
-  _instrumentBetaMessages(AnthropicSDK, index) {
+  _instrumentBetaMessages(AnthropicSDK) {
     if (!this.tracer) {
       Logger.warn("Anthropic instrumentation: No tracer available");
       return;
     }
     try {
       const BetaMessagesClass = AnthropicSDK.Beta?.Messages;
-      if (!BetaMessagesClass) {
+      if (!BetaMessagesClass?.prototype) {
         Logger.error(
-          "Anthropic instrumentation: Could not find Anthropic Beta Messages class to instrument"
+          "Anthropic instrumentation: Could not find Beta Messages class"
         );
         return;
       }
-      if (BetaMessagesClass?.prototype?.create) {
-        const originalCreate = BetaMessagesClass.prototype.create;
-        originalMethods.set(`beta.messages.create-${index}`, originalCreate);
-        const tracer = this.tracer;
-        const wrapper = betaWrapper(tracer);
-        BetaMessagesClass.prototype.create = function(...args) {
-          const original = originalCreate.bind(this);
-          const kwargs = args[0] || {};
-          return wrapper(
-            (...a) => original(...a),
-            this,
-            args,
-            kwargs
-          );
-        };
+      const originalCreate = BetaMessagesClass.prototype.create;
+      if (typeof BetaMessagesClass.prototype.create === "function") {
+        shimmer.wrap(
+          BetaMessagesClass.prototype,
+          "create",
+          betaWrapper(this.tracer)
+        );
+      }
+      if (typeof BetaMessagesClass.prototype.stream === "function") {
+        shimmer.wrap(
+          BetaMessagesClass.prototype,
+          "stream",
+          betaStreamWrapper(this.tracer, originalCreate)
+        );
+      }
+      if (typeof BetaMessagesClass.prototype.toolRunner === "function") {
+        shimmer.wrap(
+          BetaMessagesClass.prototype,
+          "toolRunner",
+          betaToolRunnerWrapper(this.tracer)
+        );
       }
     } catch (error) {
       Logger.error(`Failed to instrument beta: ${error}`);
     }
   }
-  _instrumentBatchMessages(AnthropicSDK, index) {
+  _instrumentBatchMessages(AnthropicSDK) {
     if (!this.tracer) {
       Logger.warn("Anthropic instrumentation: No tracer available");
       return;
     }
     try {
       const BatchMessageClass = AnthropicSDK.Messages?.Batches;
-      if (!BatchMessageClass) {
-        Logger.error(
-          "Anthropic instrumentation: Could not find Anthropic Batches class to instrument"
-        );
+      if (!BatchMessageClass?.prototype) {
+        Logger.error("Anthropic instrumentation: Could not find Batches class");
         return;
       }
-      if (BatchMessageClass?.prototype?.create) {
-        const originalCreate = BatchMessageClass.prototype.create;
-        originalMethods.set(`batch.messages.create-${index}`, originalCreate);
-        const tracer = this.tracer;
-        const wrapper = batchesWrapper(tracer);
-        BatchMessageClass.prototype.create = function(...args) {
-          const original = originalCreate.bind(this);
-          const kwargs = args[0] || {};
-          return wrapper(
-            (...a) => original(...a),
-            this,
-            args,
-            kwargs
-          );
-        };
+      if (typeof BatchMessageClass.prototype.create === "function") {
+        shimmer.wrap(
+          BatchMessageClass.prototype,
+          "create",
+          batchesWrapper(this.tracer)
+        );
       }
     } catch (error) {
       Logger.error(`Failed to instrument batches: ${error}`);
     }
   }
-  _uninstrumentMessages(AnthropicSDK, index) {
+  _uninstrumentMessages(AnthropicSDK) {
     try {
-      const MessagesClass = AnthropicSDK.Messages;
-      const originalCreate = originalMethods.get(`messages.create-${index}`);
-      if (originalCreate && MessagesClass?.prototype) {
-        MessagesClass.prototype.create = originalCreate;
-      }
-      const originalStream = originalMethods.get(`messages.stream-${index}`);
-      if (originalStream && MessagesClass?.prototype) {
-        MessagesClass.prototype.stream = originalStream;
-      }
+      const proto = AnthropicSDK.Messages?.prototype;
+      if (!proto) return;
+      if (typeof proto.create === "function") shimmer.unwrap(proto, "create");
+      if (typeof proto.stream === "function") shimmer.unwrap(proto, "stream");
     } catch (error) {
       Logger.error(`Failed to uninstrument messages: ${error}`);
     }
   }
-  _uninstrumentBetaMessages(AnthropicSDK, index) {
+  _uninstrumentBetaMessages(AnthropicSDK) {
     try {
-      const BetaMessagesClass = AnthropicSDK.Beta?.Messages;
-      const originalCreate = originalMethods.get(`beta.messages.create-${index}`);
-      if (originalCreate && BetaMessagesClass?.prototype) {
-        BetaMessagesClass.prototype.create = originalCreate;
-      }
+      const proto = AnthropicSDK.Beta?.Messages?.prototype;
+      if (!proto) return;
+      if (typeof proto.create === "function") shimmer.unwrap(proto, "create");
+      if (typeof proto.stream === "function") shimmer.unwrap(proto, "stream");
+      if (typeof proto.toolRunner === "function")
+        shimmer.unwrap(proto, "toolRunner");
     } catch (error) {
       Logger.error(`Failed to uninstrument beta: ${error}`);
     }
   }
-  _uninstrumentBatchMessages(AnthropicSDK, index) {
+  _uninstrumentBatchMessages(AnthropicSDK) {
     try {
-      const BatchMessagesClass = AnthropicSDK.Messages?.Batches;
-      const originalCreate = originalMethods.get(`batch.messages.create-${index}`);
-      if (originalCreate && BatchMessagesClass?.prototype) {
-        BatchMessagesClass.prototype.create = originalCreate;
-      }
+      const proto = AnthropicSDK.Messages?.Batches?.prototype;
+      if (!proto) return;
+      if (typeof proto.create === "function") shimmer.unwrap(proto, "create");
     } catch (error) {
       Logger.error(`Failed to uninstrument batches: ${error}`);
     }
@@ -5194,7 +5733,7 @@ function _setEmbeddingResponseAttributes(span2, response) {
 }
 
 // src/instrumentation/google-genai/wrappers.ts
-var CHAT_SPAN_NAME2 = "google_genai.chat";
+var CHAT_SPAN_NAME = "google_genai.chat";
 var EMBEDDING_SPAN_NAME = "google_genai.embedding";
 function googleGenAIWrapper(tracer, spanName, requestType) {
   return function wrapper(original) {
@@ -5473,10 +6012,10 @@ function googleGenAIStartChatWrapper(tracer, spanName, requestType) {
     };
   };
 }
-var chatWrapper2 = (tracer) => googleGenAIWrapper(tracer, CHAT_SPAN_NAME2, "chat");
+var chatWrapper2 = (tracer) => googleGenAIWrapper(tracer, CHAT_SPAN_NAME, "chat");
 var embeddingsWrapper = (tracer) => googleGenAIWrapper(tracer, EMBEDDING_SPAN_NAME, "embedding");
-var chatStreamWrapper = (tracer) => googleGenAIStreamWrapper(tracer, CHAT_SPAN_NAME2, "chat");
-var startChatWrapper = (tracer) => googleGenAIStartChatWrapper(tracer, CHAT_SPAN_NAME2, "chat");
+var chatStreamWrapper2 = (tracer) => googleGenAIStreamWrapper(tracer, CHAT_SPAN_NAME, "chat");
+var startChatWrapper = (tracer) => googleGenAIStartChatWrapper(tracer, CHAT_SPAN_NAME, "chat");
 var INSTRUMENTATION_NAME2 = "netra.instrumentation.google_genai";
 var INSTRUMENTS2 = ["@google/genai >= 0.24.1"];
 var isInstrumented2 = false;
@@ -5602,7 +6141,7 @@ var NetraGoogleGenerativeAIInstrumentor = class {
       shimmer.wrap(
         GenerativeModel.prototype,
         "generateContentStream",
-        chatStreamWrapper(tracer)
+        chatStreamWrapper2(tracer)
       );
       shimmer.wrap(
         GenerativeModel.prototype,
@@ -5664,8 +6203,8 @@ function setResponseAttributes4(span2, response) {
 }
 
 // src/instrumentation/groq/wrappers.ts
-var CHAT_SPAN_NAME3 = "groq.chat";
-var STREAM_ENABLED_REQUESTS2 = ["chat"];
+var CHAT_SPAN_NAME2 = "groq.chat";
+var STREAM_ENABLED_REQUESTS = ["chat"];
 function groqWrapper(tracer, spanName, requestType) {
   return function wrapper(wrapped, instance, args, kwargs) {
     if (shouldSuppressInstrumentation()) {
@@ -5673,7 +6212,7 @@ function groqWrapper(tracer, spanName, requestType) {
       return isPromise(result) ? result.then((value) => value) : result;
     }
     const isStreaming = kwargs.stream === true;
-    if (isStreaming && STREAM_ENABLED_REQUESTS2.includes(requestType)) {
+    if (isStreaming && STREAM_ENABLED_REQUESTS.includes(requestType)) {
       const currentContext = context.active();
       const span2 = tracer.startSpan(
         spanName,
@@ -5691,7 +6230,7 @@ function groqWrapper(tracer, spanName, requestType) {
           return (async () => {
             try {
               const stream = await response;
-              return new AsyncStreamingWrapper2(span2, stream, startTime, kwargs);
+              return new AsyncStreamingWrapper(span2, stream, startTime, kwargs);
             } catch (error) {
               Logger.error("netra.instrumentation.groq:", error);
               span2.setStatus({
@@ -5780,7 +6319,7 @@ function groqWrapper(tracer, spanName, requestType) {
     }
   };
 }
-var chatWrapper3 = (tracer) => groqWrapper(tracer, CHAT_SPAN_NAME3, "chat");
+var chatWrapper3 = (tracer) => groqWrapper(tracer, CHAT_SPAN_NAME2, "chat");
 var StreamingWrapper = class {
   constructor(span2, response, startTime, requestKwargs) {
     this.iterator = null;
@@ -5878,7 +6417,7 @@ var StreamingWrapper = class {
     this.span.end();
   }
 };
-var AsyncStreamingWrapper2 = class {
+var AsyncStreamingWrapper = class {
   constructor(span2, response, startTime, requestKwargs) {
     this.iterator = null;
     this.completeResponse = {
@@ -5998,7 +6537,7 @@ var AsyncStreamingWrapper2 = class {
 // src/instrumentation/groq/index.ts
 var INSTRUMENTATION_NAME3 = "netra.instrumentation.groq";
 var INSTRUMENTS3 = ["groq-sdk >= 0.3.0"];
-var originalMethods2 = /* @__PURE__ */ new Map();
+var originalMethods = /* @__PURE__ */ new Map();
 var isInstrumented3 = false;
 var groqClasses = [];
 async function resolveGroqAsync() {
@@ -6109,7 +6648,7 @@ var NetraGroqInstrumentor = class {
     classes.forEach((Groq, index) => {
       this._uninstrumentChatCompletions(Groq, index);
     });
-    originalMethods2.clear();
+    originalMethods.clear();
     groqClasses = [];
     isInstrumented3 = false;
   }
@@ -6130,7 +6669,7 @@ var NetraGroqInstrumentor = class {
         return;
       }
       const originalCreate = CompletionsClass.prototype.create;
-      originalMethods2.set(`chat.completions.create-${index}`, originalCreate);
+      originalMethods.set(`chat.completions.create-${index}`, originalCreate);
       const tracer = this.tracer;
       const wrapper = chatWrapper3(tracer);
       CompletionsClass.prototype.create = function(...args) {
@@ -6148,7 +6687,7 @@ var NetraGroqInstrumentor = class {
   _uninstrumentChatCompletions(Groq, index) {
     try {
       const CompletionsClass = Groq.Chat?.Completions;
-      const originalCreate = originalMethods2.get(`chat.completions.create-${index}`);
+      const originalCreate = originalMethods.get(`chat.completions.create-${index}`);
       if (originalCreate && CompletionsClass?.prototype) {
         CompletionsClass.prototype.create = originalCreate;
       }
@@ -6987,7 +7526,7 @@ var INSTRUMENTATION_NAME4 = "netra.instrumentation.langgraph";
 var INSTRUMENTS4 = ["langgraph >= 1.1.1"];
 var isInstrumented4 = false;
 var LanggraphClass = null;
-var originalMethods3 = /* @__PURE__ */ new Map();
+var originalMethods2 = /* @__PURE__ */ new Map();
 function findModuleInCache(moduleName) {
   if (typeof __require !== "undefined" && __require.cache) {
     const cache = __require.cache;
@@ -7083,7 +7622,7 @@ var NetraLanggraphInstrumentor = class {
       this._uninstrumentInvoke(Langgraph);
       this._uninstrumentStream(Langgraph);
     }
-    originalMethods3.clear();
+    originalMethods2.clear();
     LanggraphClass = null;
     isInstrumented4 = false;
   }
@@ -7100,8 +7639,8 @@ var NetraLanggraphInstrumentor = class {
       }
       Logger.debug(`Found invoke on prototype: ${targetProto.constructor?.name}`);
       const originalInvoke = targetProto.invoke;
-      originalMethods3.set("langgraph.graph.invoke", originalInvoke);
-      originalMethods3.set("langgraph.graph.invoke.proto", targetProto);
+      originalMethods2.set("langgraph.graph.invoke", originalInvoke);
+      originalMethods2.set("langgraph.graph.invoke.proto", targetProto);
       const tracer = this.tracer;
       const wrapper = new LanggraphWrapper(tracer);
       const patchedInvoke = async function(input, config2, ...rest) {
@@ -7135,8 +7674,8 @@ var NetraLanggraphInstrumentor = class {
       }
       Logger.debug(`Found stream on prototype: ${targetProto.constructor?.name}`);
       const originalStream = targetProto.stream;
-      originalMethods3.set("langgraph.graph.stream", originalStream);
-      originalMethods3.set("langgraph.graph.stream.proto", targetProto);
+      originalMethods2.set("langgraph.graph.stream", originalStream);
+      originalMethods2.set("langgraph.graph.stream.proto", targetProto);
       const tracer = this.tracer;
       const wrapper = new LanggraphWrapper(tracer);
       targetProto.stream = async function(input, config2, ...rest) {
@@ -7156,8 +7695,8 @@ var NetraLanggraphInstrumentor = class {
   }
   _uninstrumentInvoke(Langgraph) {
     try {
-      const originalInvoke = originalMethods3.get("langgraph.graph.invoke");
-      const targetProto = originalMethods3.get("langgraph.graph.invoke.proto") || Langgraph?.prototype;
+      const originalInvoke = originalMethods2.get("langgraph.graph.invoke");
+      const targetProto = originalMethods2.get("langgraph.graph.invoke.proto") || Langgraph?.prototype;
       if (originalInvoke && targetProto?.invoke) {
         targetProto.invoke = originalInvoke;
       }
@@ -7168,8 +7707,8 @@ var NetraLanggraphInstrumentor = class {
   }
   _uninstrumentStream(Langgraph) {
     try {
-      const originalStream = originalMethods3.get("langgraph.graph.stream");
-      const targetProto = originalMethods3.get("langgraph.graph.stream.proto") || Langgraph?.prototype;
+      const originalStream = originalMethods2.get("langgraph.graph.stream");
+      const targetProto = originalMethods2.get("langgraph.graph.stream.proto") || Langgraph?.prototype;
       if (originalStream && targetProto?.stream) {
         targetProto.stream = originalStream;
       }
@@ -7209,11 +7748,11 @@ function setResponseAttributes5(span2, response) {
 }
 
 // src/instrumentation/mistralai/wrappers.ts
-var CHAT_SPAN_NAME4 = "mistralai.chat";
+var CHAT_SPAN_NAME3 = "mistralai.chat";
 var EMBEDDING_SPAN_NAME2 = "mistralai.embedding";
 var FIM_SPAN_NAME = "mistralai.fim";
 var AGENTS_SPAN_NAME = "mistralai.agents";
-var CHAT_STREAM_SPAN_NAME = CHAT_SPAN_NAME4;
+var CHAT_STREAM_SPAN_NAME = CHAT_SPAN_NAME3;
 var FIM_STREAM_SPAN_NAME = FIM_SPAN_NAME;
 var AGENTS_STREAM_SPAN_NAME = AGENTS_SPAN_NAME;
 function mistralWrapper(tracer, spanName, requestType) {
@@ -7308,7 +7847,7 @@ function mistralStreamWrapper(tracer, spanName, requestType) {
           try {
             const stream = await response;
             if (stream && typeof stream === "object" && Symbol.asyncIterator in stream) {
-              return new AsyncStreamingWrapper3(span2, stream, startTime, kwargs);
+              return new AsyncStreamingWrapper2(span2, stream, startTime, kwargs);
             }
             return new StreamingWrapper2(span2, stream, startTime, kwargs);
           } catch (error) {
@@ -7324,7 +7863,7 @@ function mistralStreamWrapper(tracer, spanName, requestType) {
         })();
       }
       if (response && typeof response === "object" && Symbol.asyncIterator in response) {
-        return new AsyncStreamingWrapper3(span2, response, startTime, kwargs);
+        return new AsyncStreamingWrapper2(span2, response, startTime, kwargs);
       }
       return new StreamingWrapper2(span2, response, startTime, kwargs);
     } catch (error) {
@@ -7339,8 +7878,8 @@ function mistralStreamWrapper(tracer, spanName, requestType) {
     }
   };
 }
-var chatWrapper4 = (tracer) => mistralWrapper(tracer, CHAT_SPAN_NAME4, "chat");
-var chatStreamWrapper2 = (tracer) => mistralStreamWrapper(tracer, CHAT_STREAM_SPAN_NAME, "chat");
+var chatWrapper4 = (tracer) => mistralWrapper(tracer, CHAT_SPAN_NAME3, "chat");
+var chatStreamWrapper3 = (tracer) => mistralStreamWrapper(tracer, CHAT_STREAM_SPAN_NAME, "chat");
 var embeddingsWrapper2 = (tracer) => mistralWrapper(tracer, EMBEDDING_SPAN_NAME2, "embedding");
 var fimWrapper = (tracer) => mistralWrapper(tracer, FIM_SPAN_NAME, "fim");
 var fimStreamWrapper = (tracer) => mistralStreamWrapper(tracer, FIM_STREAM_SPAN_NAME, "fim");
@@ -7491,7 +8030,7 @@ var StreamingWrapper2 = class {
     this.span.end();
   }
 };
-var AsyncStreamingWrapper3 = class {
+var AsyncStreamingWrapper2 = class {
   constructor(span2, response, startTime, requestKwargs) {
     this.iterator = null;
     defineHidden(this, "span", span2);
@@ -7641,7 +8180,7 @@ var AsyncStreamingWrapper3 = class {
 // src/instrumentation/mistralai/index.ts
 var INSTRUMENTATION_NAME5 = "netra.instrumentation.mistral_ai";
 var INSTRUMENTS5 = ["@mistralai/mistralai >= 1.0.0"];
-var originalMethods4 = /* @__PURE__ */ new Map();
+var originalMethods3 = /* @__PURE__ */ new Map();
 var isInstrumented5 = false;
 var mistralClasses = [];
 async function resolveMistralAsync() {
@@ -7790,7 +8329,7 @@ var NetraMistralAIInstrumentor = class {
       this._uninstrumentFIM(Mistral, index);
       this._uninstrumentAgents(Mistral, index);
     });
-    originalMethods4.clear();
+    originalMethods3.clear();
     mistralClasses = [];
     isInstrumented5 = false;
   }
@@ -7836,7 +8375,7 @@ var NetraMistralAIInstrumentor = class {
       let didPatch = false;
       if (ChatClass?.prototype?.complete) {
         const originalComplete = ChatClass.prototype.complete;
-        originalMethods4.set(`chat.complete-${index}`, originalComplete);
+        originalMethods3.set(`chat.complete-${index}`, originalComplete);
         const tracer = this.tracer;
         const wrapper = chatWrapper4(tracer);
         ChatClass.prototype.complete = function(...args) {
@@ -7853,9 +8392,9 @@ var NetraMistralAIInstrumentor = class {
       }
       if (ChatClass?.prototype?.stream) {
         const originalStream = ChatClass.prototype.stream;
-        originalMethods4.set(`chat.stream-${index}`, originalStream);
+        originalMethods3.set(`chat.stream-${index}`, originalStream);
         const tracer = this.tracer;
-        const wrapper = chatStreamWrapper2(tracer);
+        const wrapper = chatStreamWrapper3(tracer);
         ChatClass.prototype.stream = function(...args) {
           const original = originalStream.bind(this);
           const kwargs = args[0] || {};
@@ -7881,7 +8420,7 @@ var NetraMistralAIInstrumentor = class {
       let didPatch = false;
       if (EmbeddingsClass?.prototype?.create) {
         const originalCreate = EmbeddingsClass.prototype.create;
-        originalMethods4.set(`embeddings.create-${index}`, originalCreate);
+        originalMethods3.set(`embeddings.create-${index}`, originalCreate);
         const tracer = this.tracer;
         const wrapper = embeddingsWrapper2(tracer);
         EmbeddingsClass.prototype.create = function(...args) {
@@ -7909,7 +8448,7 @@ var NetraMistralAIInstrumentor = class {
       let didPatch = false;
       if (FimClass?.prototype?.complete) {
         const originalComplete = FimClass.prototype.complete;
-        originalMethods4.set(`fim.complete-${index}`, originalComplete);
+        originalMethods3.set(`fim.complete-${index}`, originalComplete);
         const tracer = this.tracer;
         const wrapper = fimWrapper(tracer);
         FimClass.prototype.complete = function(...args) {
@@ -7926,7 +8465,7 @@ var NetraMistralAIInstrumentor = class {
       }
       if (FimClass?.prototype?.stream) {
         const originalStream = FimClass.prototype.stream;
-        originalMethods4.set(`fim.stream-${index}`, originalStream);
+        originalMethods3.set(`fim.stream-${index}`, originalStream);
         const tracer = this.tracer;
         const wrapper = fimStreamWrapper(tracer);
         FimClass.prototype.stream = function(...args) {
@@ -7954,7 +8493,7 @@ var NetraMistralAIInstrumentor = class {
       let didPatch = false;
       if (AgentsClass?.prototype?.complete) {
         const originalComplete = AgentsClass.prototype.complete;
-        originalMethods4.set(`agents.complete-${index}`, originalComplete);
+        originalMethods3.set(`agents.complete-${index}`, originalComplete);
         const tracer = this.tracer;
         const wrapper = agentsWrapper(tracer);
         AgentsClass.prototype.complete = function(...args) {
@@ -7971,7 +8510,7 @@ var NetraMistralAIInstrumentor = class {
       }
       if (AgentsClass?.prototype?.stream) {
         const originalStream = AgentsClass.prototype.stream;
-        originalMethods4.set(`agents.stream-${index}`, originalStream);
+        originalMethods3.set(`agents.stream-${index}`, originalStream);
         const tracer = this.tracer;
         const wrapper = agentsStreamWrapper(tracer);
         AgentsClass.prototype.stream = function(...args) {
@@ -7995,11 +8534,11 @@ var NetraMistralAIInstrumentor = class {
   _uninstrumentChat(Mistral, index) {
     try {
       const ChatClass = this._getCtor(Mistral, "chat");
-      const originalComplete = originalMethods4.get(`chat.complete-${index}`);
+      const originalComplete = originalMethods3.get(`chat.complete-${index}`);
       if (originalComplete && ChatClass?.prototype) {
         ChatClass.prototype.complete = originalComplete;
       }
-      const originalStream = originalMethods4.get(`chat.stream-${index}`);
+      const originalStream = originalMethods3.get(`chat.stream-${index}`);
       if (originalStream && ChatClass?.prototype) {
         ChatClass.prototype.stream = originalStream;
       }
@@ -8010,7 +8549,7 @@ var NetraMistralAIInstrumentor = class {
   _uninstrumentEmbeddings(Mistral, index) {
     try {
       const EmbeddingsClass = this._getCtor(Mistral, "embeddings");
-      const originalCreate = originalMethods4.get(`embeddings.create-${index}`);
+      const originalCreate = originalMethods3.get(`embeddings.create-${index}`);
       if (originalCreate && EmbeddingsClass?.prototype) {
         EmbeddingsClass.prototype.create = originalCreate;
       }
@@ -8021,11 +8560,11 @@ var NetraMistralAIInstrumentor = class {
   _uninstrumentFIM(Mistral, index) {
     try {
       const FimClass = this._getCtor(Mistral, "fim");
-      const originalComplete = originalMethods4.get(`fim.complete-${index}`);
+      const originalComplete = originalMethods3.get(`fim.complete-${index}`);
       if (originalComplete && FimClass?.prototype) {
         FimClass.prototype.complete = originalComplete;
       }
-      const originalStream = originalMethods4.get(`fim.stream-${index}`);
+      const originalStream = originalMethods3.get(`fim.stream-${index}`);
       if (originalStream && FimClass?.prototype) {
         FimClass.prototype.stream = originalStream;
       }
@@ -8036,11 +8575,11 @@ var NetraMistralAIInstrumentor = class {
   _uninstrumentAgents(Mistral, index) {
     try {
       const AgentsClass = this._getCtor(Mistral, "agents");
-      const originalComplete = originalMethods4.get(`agents.complete-${index}`);
+      const originalComplete = originalMethods3.get(`agents.complete-${index}`);
       if (originalComplete && AgentsClass?.prototype) {
         AgentsClass.prototype.complete = originalComplete;
       }
-      const originalStream = originalMethods4.get(`agents.stream-${index}`);
+      const originalStream = originalMethods3.get(`agents.stream-${index}`);
       if (originalStream && AgentsClass?.prototype) {
         AgentsClass.prototype.stream = originalStream;
       }
@@ -8068,7 +8607,7 @@ function setResponseAttributes6(span2, response) {
 }
 
 // src/instrumentation/openai/wrappers.ts
-var SPAN_NAMES = {
+var SPAN_NAMES2 = {
   chat: "openai.chat",
   embedding: "openai.embedding",
   response: "openai.response"
@@ -8209,7 +8748,7 @@ var StreamingWrapper3 = class extends BaseStreamHandler {
     throw new Error("Response is not iterable");
   }
 };
-var AsyncStreamingWrapper4 = class extends BaseStreamHandler {
+var AsyncStreamingWrapper3 = class extends BaseStreamHandler {
   constructor(span2, response, startTime, requestKwargs) {
     super(span2, startTime, requestKwargs);
     this.iterator = null;
@@ -8265,7 +8804,7 @@ function executeStreaming(span2, ctx, kwargs, requestType, call) {
       return (async () => {
         try {
           const stream = await response;
-          return new AsyncStreamingWrapper4(span2, stream, startTime, kwargs);
+          return new AsyncStreamingWrapper3(span2, stream, startTime, kwargs);
         } catch (error) {
           handleSpanError(span2, error);
           throw error;
@@ -8303,7 +8842,7 @@ function executeNonStreaming(span2, kwargs, requestType, call) {
   }
 }
 function openAIWrapper(tracer, requestType) {
-  const spanName = SPAN_NAMES[requestType];
+  const spanName = SPAN_NAMES2[requestType];
   const spanOpts = { kind: SpanKind.CLIENT, attributes: { "llm.request.type": requestType } };
   return (wrapped, instance, args, kwargs) => {
     if (shouldSuppressInstrumentation()) {
@@ -9132,6 +9671,8 @@ var cachedAgentsModule = null;
 var isInstrumented6 = false;
 var activeTracer = null;
 var activeProcessor = null;
+var originalProcessors = null;
+var didReplaceProcessors = false;
 async function resolveAgentsModule() {
   if (cachedAgentsModule) return cachedAgentsModule;
   try {
@@ -9184,20 +9725,51 @@ var NetraOpenAIAgentsInstrumentor = class {
     }
     const systemName = options.systemName ?? DEFAULT_LLM_SYSTEM;
     activeProcessor = new NetraAgentsTracingProcessor(activeTracer, systemName);
+    const mode = options.nativeTracing ?? parseNativeTracingEnv("NATIVE_TRACING_MODE") ?? "netra-strict";
+    const canSet = typeof agentsModule.setTraceProcessors === "function";
+    const canAdd = typeof agentsModule.addTraceProcessor === "function";
+    let strategy;
+    if (mode === "both" || mode === "netra" && !canSet) {
+      strategy = "append";
+    } else if (canSet) {
+      strategy = "replace";
+    } else {
+      strategy = "skip";
+    }
     try {
-      if (typeof agentsModule.addTraceProcessor === "function") {
-        agentsModule.addTraceProcessor(activeProcessor);
-      } else if (typeof agentsModule.setTraceProcessors === "function") {
-        const existing = typeof agentsModule.getTraceProcessors === "function" ? agentsModule.getTraceProcessors() : [];
-        agentsModule.setTraceProcessors([...existing, activeProcessor]);
-      } else {
-        Logger.warn(
-          "OpenAI Agents SDK does not expose addTraceProcessor or setTraceProcessors.",
-          "Tracing integration may not work."
-        );
-        activeProcessor = null;
-        activeTracer = null;
-        return this;
+      switch (strategy) {
+        case "replace":
+          if (typeof agentsModule.getTraceProcessors === "function") {
+            originalProcessors = agentsModule.getTraceProcessors();
+          }
+          agentsModule.setTraceProcessors([activeProcessor]);
+          didReplaceProcessors = true;
+          Logger.debug("OpenAI Agents native tracing disabled \u2014 traces will only be sent to Netra.");
+          break;
+        case "append":
+          if (canAdd) {
+            agentsModule.addTraceProcessor(activeProcessor);
+          } else {
+            Logger.warn("OpenAI Agents SDK does not expose addTraceProcessor or setTraceProcessors.");
+            activeProcessor = null;
+            activeTracer = null;
+            return this;
+          }
+          if (mode === "netra") {
+            Logger.warn(
+              "Cannot exclusively replace native trace processors in this @openai/agents version.",
+              "Traces may still be sent to OpenAI."
+            );
+          }
+          break;
+        case "skip":
+          Logger.warn(
+            'nativeTracing is "netra-strict" but the installed @openai/agents version',
+            "does not support processor replacement. Skipping instrumentation."
+          );
+          activeProcessor = null;
+          activeTracer = null;
+          return this;
       }
     } catch (error) {
       Logger.warn("Failed to register trace processor with @openai/agents:", error);
@@ -9217,6 +9789,21 @@ var NetraOpenAIAgentsInstrumentor = class {
       activeProcessor.shutdown();
       activeProcessor = null;
     }
+    if (didReplaceProcessors && cachedAgentsModule) {
+      try {
+        if (originalProcessors && typeof cachedAgentsModule.setTraceProcessors === "function") {
+          cachedAgentsModule.setTraceProcessors(originalProcessors);
+          Logger.debug("Restored original OpenAI Agents trace processors");
+        } else if (typeof cachedAgentsModule.setDefaultOpenAITracingExporter === "function") {
+          cachedAgentsModule.setDefaultOpenAITracingExporter();
+          Logger.debug("Restored default OpenAI Agents tracing exporter");
+        }
+      } catch (error) {
+        Logger.debug("Failed to restore original trace processors:", error);
+      }
+    }
+    originalProcessors = null;
+    didReplaceProcessors = false;
     activeTracer = null;
     cachedAgentsModule = null;
     isInstrumented6 = false;
@@ -9481,7 +10068,7 @@ function repositoryQueryWrapper(tracer) {
 var __version__8 = "1.0.0";
 var require2 = createRequire(import.meta.url);
 var INSTRUMENTATION_NAME8 = "netra.instrumentation.typeorm";
-var originalMethods5 = /* @__PURE__ */ new Map();
+var originalMethods4 = /* @__PURE__ */ new Map();
 var isInstrumented7 = false;
 var NetraTypeORMInstrumentor = class {
   constructor() {
@@ -9515,7 +10102,7 @@ var NetraTypeORMInstrumentor = class {
     });
     this._uninstrumentRepository().catch(() => {
     });
-    originalMethods5.clear();
+    originalMethods4.clear();
     isInstrumented7 = false;
   }
   isInstrumented() {
@@ -9534,7 +10121,7 @@ var NetraTypeORMInstrumentor = class {
       }
       if (DataSource.prototype?.query) {
         const originalQuery = DataSource.prototype.query;
-        originalMethods5.set("DataSource.prototype.query", originalQuery);
+        originalMethods4.set("DataSource.prototype.query", originalQuery);
         const tracer = this.tracer;
         const wrapper = queryWrapper(tracer);
         DataSource.prototype.query = function(...args) {
@@ -9559,7 +10146,7 @@ var NetraTypeORMInstrumentor = class {
       }
       if (EntityManager.prototype?.query) {
         const originalQuery = EntityManager.prototype.query;
-        originalMethods5.set("EntityManager.prototype.query", originalQuery);
+        originalMethods4.set("EntityManager.prototype.query", originalQuery);
         const tracer = this.tracer;
         const wrapper = managerQueryWrapper(tracer);
         EntityManager.prototype.query = function(...args) {
@@ -9584,7 +10171,7 @@ var NetraTypeORMInstrumentor = class {
       }
       if (Repository.prototype?.query) {
         const originalQuery = Repository.prototype.query;
-        originalMethods5.set("Repository.prototype.query", originalQuery);
+        originalMethods4.set("Repository.prototype.query", originalQuery);
         const tracer = this.tracer;
         const wrapper = repositoryQueryWrapper(tracer);
         Repository.prototype.query = function(...args) {
@@ -9600,7 +10187,7 @@ var NetraTypeORMInstrumentor = class {
     try {
       const typeorm = require2("typeorm");
       const DataSource = typeorm.DataSource || typeorm.default?.DataSource;
-      const originalQuery = originalMethods5.get("DataSource.prototype.query");
+      const originalQuery = originalMethods4.get("DataSource.prototype.query");
       if (originalQuery && DataSource?.prototype) {
         DataSource.prototype.query = originalQuery;
       }
@@ -9612,7 +10199,7 @@ var NetraTypeORMInstrumentor = class {
     try {
       const typeorm = require2("typeorm");
       const EntityManager = typeorm.EntityManager || typeorm.default?.EntityManager;
-      const originalQuery = originalMethods5.get("EntityManager.prototype.query");
+      const originalQuery = originalMethods4.get("EntityManager.prototype.query");
       if (originalQuery && EntityManager?.prototype) {
         EntityManager.prototype.query = originalQuery;
       }
@@ -9624,7 +10211,7 @@ var NetraTypeORMInstrumentor = class {
     try {
       const typeorm = require2("typeorm");
       const Repository = typeorm.Repository || typeorm.default?.Repository;
-      const originalQuery = originalMethods5.get("Repository.prototype.query");
+      const originalQuery = originalMethods4.get("Repository.prototype.query");
       if (originalQuery && Repository?.prototype) {
         Repository.prototype.query = originalQuery;
       }
@@ -10099,7 +10686,9 @@ function initInstrumentations(config2, instruments, blockInstruments, rootInstru
     mistral: false,
     langgraph: false,
     googleGenAI: false,
-    anthropic: false};
+    anthropic: false,
+    openAiAgents: false
+  };
   const resolved = enableAll ? new Set(Object.values(NetraInstruments).filter((v) => v !== "__all__" /* ALL */)) : instruments && instruments.size > 0 ? instruments : DEFAULT_INSTRUMENTS;
   instrumentModules.google_vertexai = false;
   instrumentModules.langchain = false;
@@ -10147,6 +10736,9 @@ function initInstrumentations(config2, instruments, blockInstruments, rootInstru
   if (resolved.has("anthropic" /* ANTHROPIC */)) {
     customInstrumentModules.anthropic = true;
   }
+  if (resolved.has("openai_agents" /* OPENAI_AGENTS */)) {
+    customInstrumentModules.openAiAgents = true;
+  }
   if (blockInstruments && blockInstruments.size > 0) {
     const blockAll = blockInstruments.has("__all__" /* ALL */);
     if (blockAll || blockInstruments.has("openai" /* OPENAI */)) customInstrumentModules.openai = false;
@@ -10155,6 +10747,7 @@ function initInstrumentations(config2, instruments, blockInstruments, rootInstru
     if (blockAll || blockInstruments.has("langgraph" /* LANGGRAPH */)) customInstrumentModules.langgraph = false;
     if (blockAll || blockInstruments.has("google_genai" /* GOOGLE_GENERATIVE_AI */)) customInstrumentModules.googleGenAI = false;
     if (blockAll || blockInstruments.has("anthropic" /* ANTHROPIC */)) customInstrumentModules.anthropic = false;
+    if (blockAll || blockInstruments.has("openai_agents" /* OPENAI_AGENTS */)) customInstrumentModules.openAiAgents = false;
     if (blockAll || blockInstruments.has("vertexai" /* VERTEX_AI */)) instrumentModules.google_vertexai = false;
     if (blockAll || blockInstruments.has("langchain" /* LANGCHAIN */)) instrumentModules.langchain = false;
     if (blockAll || blockInstruments.has("llama_index" /* LLAMA_INDEX */)) instrumentModules.llamaIndex = false;
@@ -10271,13 +10864,13 @@ async function initCustomInstrumentationsAsync(config2, tracerProvider, customIn
   }
   if (customInstrumentModules.anthropic) {
     try {
-      await anthropicInstrumentor.instrumentAsync({ tracerProvider });
+      await anthropicInstrumentor.instrument({ tracerProvider });
       Logger.debug("Custom Anthropic instrumentation enabled");
     } catch (e) {
       Logger.debug("Failed to initialize custom Anthropic instrumentation:", e);
     }
   }
-  if (customInstrumentModules.openaiAgents && !blockInstruments?.has("openai_agents" /* OPENAI_AGENTS */)) {
+  if (customInstrumentModules.openAiAgents && !blockInstruments?.has("openai_agents" /* OPENAI_AGENTS */)) {
     try {
       await openaiAgentsInstrumentor.instrument({ tracerProvider });
       Logger.debug("Custom OpenAI Agents SDK instrumentation enabled");
@@ -10423,7 +11016,7 @@ function addCustomSpanProcessors(tracerProvider, config2, rootInstrumentNames) {
     }
     const instrumentationProcessor = new InstrumentationSpanProcessor();
     provider.addSpanProcessor(instrumentationProcessor);
-    const sessionProcessor = new SessionSpanProcessor();
+    const sessionProcessor = new SessionSpanProcessor(config2.environment);
     provider.addSpanProcessor(sessionProcessor);
     const spanIOProcessor = new SpanIOProcessor();
     provider.addSpanProcessor(spanIOProcessor);
@@ -10435,6 +11028,10 @@ function addCustomSpanProcessors(tracerProvider, config2, rootInstrumentNames) {
       const scrubbingProcessor = new ScrubbingSpanProcessor();
       provider.addSpanProcessor(scrubbingProcessor);
     }
+    const sizeLimitProcessor = new AttributeSizeLimitProcessor(
+      Config.SPAN_ATTRIBUTE_MAX_SIZE
+    );
+    provider.addSpanProcessor(sizeLimitProcessor);
     Logger.debug("Custom span processors registered successfully");
     return provider;
   } catch (e) {
@@ -11083,33 +11680,6 @@ var Tracer17 = class {
     }
   }
 };
-function safeStringify3(value, maxLen = 1e3) {
-  const seen = /* @__PURE__ */ new WeakSet();
-  try {
-    return JSON.stringify(value, (_key, val) => {
-      if (typeof val === "function") return `[Function: ${val.name || "anonymous"}]`;
-      if (typeof val === "symbol") return val.toString();
-      if (typeof val === "bigint") return val.toString();
-      if (val !== null && typeof val === "object") {
-        if (seen.has(val)) return "[Circular]";
-        seen.add(val);
-        const name = val.constructor?.name;
-        if (name && name !== "Object" && name !== "Array" && Object.keys(val).length > 20) {
-          return `[${name}]`;
-        }
-      }
-      return val;
-    }).substring(0, maxLen);
-  } catch {
-    return value?.constructor?.name ? `[${value.constructor.name}]` : String(typeof value);
-  }
-}
-function serializeValue2(value) {
-  if (value === null || value === void 0) return String(value);
-  const t = typeof value;
-  if (t === "string" || t === "number" || t === "boolean") return String(value);
-  return safeStringify3(value);
-}
 function spanHasOutput(span2) {
   try {
     for (const field of ["attributes", "_attributes"]) {
@@ -11124,13 +11694,13 @@ function spanHasOutput(span2) {
 function addInputAttributes(span2, args, entityType) {
   span2.setAttribute(`${Config.LIBRARY_NAME}.entity.type`, entityType);
   if (args.length > 0) {
-    span2.setAttribute("input", safeStringify3(args));
+    span2.setAttribute("input", safeStringify(args, Config.ATTRIBUTE_MAX_LEN));
   }
 }
 function addOutputAttributes(span2, result) {
   if (spanHasOutput(span2)) return;
   try {
-    span2.setAttribute("output", serializeValue2(result));
+    span2.setAttribute("output", serializeValue(result, Config.ATTRIBUTE_MAX_LEN));
   } catch (e) {
     span2.setAttribute("output_error", String(e));
   }
@@ -11150,69 +11720,63 @@ function createFunctionWrapper(func, entityType, name, asType = "SPAN" /* SPAN *
     span2.setAttribute("netra.span.type", asType);
     SessionManager.registerSpan(spanName, span2);
   };
-  const handleError = (span2, e) => {
+  const recordError = (span2, e) => {
     span2.setAttribute(`${Config.LIBRARY_NAME}.entity.error`, String(e));
     span2.setStatus({
       code: SpanStatusCode.ERROR,
       message: e instanceof Error ? e.message : String(e)
     });
     span2.recordException(e);
-    throw e;
   };
   const cleanup = (span2) => {
     span2.end();
     SessionManager.unregisterSpan(spanName, span2);
     SessionManager.popEntity(entityType);
   };
-  if (isAsync) {
-    const wrapper = async function(...args) {
-      SessionManager.pushEntity(entityType, spanName);
-      const tracer = trace.getTracer(moduleName);
-      return tracer.startActiveSpan(spanName, async (span2) => {
-        try {
-          initSpan(span2);
-          addInputAttributes(span2, args, entityType);
-          const result = await func.call(this, ...args);
-          addOutputAttributes(span2, result);
-          return result;
-        } catch (e) {
-          handleError(span2, e);
-        } finally {
-          cleanup(span2);
-        }
-      });
-    };
-    return wrapper;
-  } else {
-    const wrapper = function(...args) {
-      SessionManager.pushEntity(entityType, spanName);
-      const tracer = trace.getTracer(moduleName);
-      return tracer.startActiveSpan(spanName, (span2) => {
-        let returnedPromise = false;
-        try {
-          initSpan(span2);
-          addInputAttributes(span2, args, entityType);
-          const result = func.call(this, ...args);
-          if (result != null && typeof result.then === "function") {
-            returnedPromise = true;
-            return result.then((resolved) => {
-              addOutputAttributes(span2, resolved);
-              return resolved;
-            }).catch((e) => handleError(span2, e)).finally(() => cleanup(span2));
-          }
-          addOutputAttributes(span2, result);
-          return result;
-        } catch (e) {
-          handleError(span2, e);
-        } finally {
-          if (!returnedPromise) {
-            cleanup(span2);
-          }
-        }
-      });
-    };
-    return wrapper;
-  }
+  const wrapperFn = isAsync ? async function(...args) {
+    SessionManager.pushEntity(entityType, spanName);
+    const tracer = trace.getTracer(moduleName);
+    return tracer.startActiveSpan(spanName, async (span2) => {
+      try {
+        initSpan(span2);
+        addInputAttributes(span2, args, entityType);
+        const result = await func.call(this, ...args);
+        const spanCtx = trace.setSpan(context.active(), span2);
+        return wrapResponse(result, {
+          withContext: (fn) => context.with(spanCtx, fn),
+          onError: (e) => recordError(span2, e),
+          onSuccess: (value) => addOutputAttributes(span2, value),
+          finalize: () => cleanup(span2)
+        });
+      } catch (e) {
+        recordError(span2, e);
+        cleanup(span2);
+        throw e;
+      }
+    });
+  } : function(...args) {
+    SessionManager.pushEntity(entityType, spanName);
+    const tracer = trace.getTracer(moduleName);
+    return tracer.startActiveSpan(spanName, (span2) => {
+      try {
+        initSpan(span2);
+        addInputAttributes(span2, args, entityType);
+        const result = func.call(this, ...args);
+        const spanCtx = trace.setSpan(context.active(), span2);
+        return wrapResponse(result, {
+          withContext: (fn) => context.with(spanCtx, fn),
+          onError: (e) => recordError(span2, e),
+          onSuccess: (value) => addOutputAttributes(span2, value),
+          finalize: () => cleanup(span2)
+        });
+      } catch (e) {
+        recordError(span2, e);
+        cleanup(span2);
+        throw e;
+      }
+    });
+  };
+  return wrapperFn;
 }
 var SKIP_STATIC_PROPS = /* @__PURE__ */ new Set([
   "length",
@@ -11599,14 +12163,11 @@ Received ${signal}. Shutting down Netra SDK...`);
         spanWrapper.end();
         throw e;
       }
-      if (result instanceof Promise) {
-        return result.catch((e) => {
-          spanWrapper.setError(e instanceof Error ? e.message : String(e));
-          throw e;
-        }).finally(() => spanWrapper.end());
-      }
-      spanWrapper.end();
-      return result;
+      return wrapResponse(result, {
+        withContext: (fn2) => spanWrapper.withActive(fn2),
+        onError: (e) => spanWrapper.setError(e instanceof Error ? e.message : String(e)),
+        finalize: () => spanWrapper.end()
+      });
     });
   }
 };
@@ -11616,6 +12177,6 @@ Netra._metricsEnabled = false;
 Netra.withBlockedSpansLocal = withBlockedSpansLocal;
 var index_default = Netra;
 
-export { Aggregation, BaseTask, ChartType, Config, ConversationType, DEFAULT_INSTRUMENTS, DEFAULT_INSTRUMENTS_FOR_ROOT, Dashboard, DimensionField, EntryStatus, Evaluation, FilterField, FilterType, FilteringSpanExporter, GroupBy, InstrumentationSpanProcessor, Measure, Netra, NetraAgentsTracingProcessor, NetraInstruments, NetraOpenAIAgentsInstrumentor, Operator, Prompts, RunEntryContext, RunStatus, Scope, ScrubbingSpanProcessor, SessionSpanProcessor, Simulation, SpanIOProcessor, SpanType, TrialAwareOTLPExporter, Usage, agent, index_default as default, metadataField, mistralAIInstrumentor, netraExpressMiddleware, openaiAgentsInstrumentor, runWithExtractedContext, span, task, workflow };
+export { Aggregation, AttributeSizeLimitProcessor, BaseTask, ChartType, Config, ConversationType, DEFAULT_INSTRUMENTS, DEFAULT_INSTRUMENTS_FOR_ROOT, Dashboard, DimensionField, EntryStatus, Evaluation, FilterField, FilterType, FilteringSpanExporter, GroupBy, InstrumentationSpanProcessor, Measure, Netra, NetraAgentsTracingProcessor, NetraInstruments, NetraOpenAIAgentsInstrumentor, Operator, Prompts, RunEntryContext, RunStatus, Scope, ScrubbingSpanProcessor, SessionSpanProcessor, Simulation, SpanIOProcessor, SpanType, TrialAwareOTLPExporter, Usage, agent, index_default as default, metadataField, mistralAIInstrumentor, netraExpressMiddleware, openaiAgentsInstrumentor, runWithExtractedContext, span, task, workflow };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map