netra-sdk 1.1.0-beta → 1.1.0

package/dist/index.js

@@ -1,5 +1,5 @@
 import { __toESM, require_decamelize, require_camelcase, init_esm_node, __publicField, v7_default, __require } from './chunk-WMQRYJGR.js';
-import { createContextKey, propagation, trace, SpanKind, context, SpanStatusCode, ROOT_CONTEXT } from '@opentelemetry/api';
+import { createContextKey, propagation, context, trace, SpanKind, SpanStatusCode, ROOT_CONTEXT } from '@opentelemetry/api';
 import { createRequire } from 'module';
 import { AsyncLocalStorage } from 'async_hooks';
 import { ConsoleSpanExporter } from '@opentelemetry/sdk-trace-base';
@@ -39,6 +39,37 @@ var Logger = class {
   }
 };
 Logger._debugMode = false;
+function injectTraceContextHeaders(headers) {
+  const carrier = { ...headers };
+  try {
+    propagation.inject(context.active(), carrier);
+  } catch {
+    Logger.warn("netra: Failed to inject trace context headers");
+    return headers;
+  }
+  return carrier;
+}
+function extractContextFromHeaders(headers) {
+  const carrier = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (typeof value === "string") {
+      carrier[key.toLowerCase()] = value;
+    } else if (Array.isArray(value) && value.length > 0) {
+      carrier[key.toLowerCase()] = value[0];
+    }
+  }
+  return propagation.extract(context.active(), carrier);
+}
+function runWithExtractedContext(headers, fn) {
+  const extractedCtx = extractContextFromHeaders(headers);
+  return context.with(extractedCtx, fn);
+}
+function netraExpressMiddleware() {
+  return (req, _res, next) => {
+    const extractedCtx = extractContextFromHeaders(req.headers);
+    context.with(extractedCtx, next);
+  };
+}
 
 // src/api/http-client.ts
 var NetraHttpClient = class {
@@ -112,7 +143,7 @@ var NetraHttpClient = class {
       );
       const response = await fetch(url.toString(), {
         method: "GET",
-        headers: this.headers,
+        headers: injectTraceContextHeaders(this.headers),
         signal: controller.signal
       });
       clearTimeout(timeoutId);
@@ -141,7 +172,7 @@ var NetraHttpClient = class {
       );
       const response = await fetch(url.toString(), {
         method: "POST",
-        headers: this.headers,
+        headers: injectTraceContextHeaders(this.headers),
         body: body ? JSON.stringify(body) : void 0,
         signal: controller.signal
       });
@@ -1694,13 +1725,13 @@ async function runSingleEvaluator(params) {
   if (config2) {
     expectedName = config2.name;
   }
-  const context14 = {
+  const context16 = {
     input: itemInput,
     taskOutput,
     expectedOutput,
     metadata
   };
-  let result = evaluator.evaluate(context14);
+  let result = evaluator.evaluate(context16);
   if (result instanceof Promise) {
     result = await result;
   }
@@ -2054,10 +2085,14 @@ var Evaluation = class {
         ctx.spanId = formatSpanId(spanContext.spanId);
       }
       ctx.sessionId = getSessionIdFromBaggage();
-      const { output, status } = await executeTask(task2, ctx.itemInput);
+      const { output, status } = await span2.withActive(
+        () => executeTask(task2, ctx.itemInput)
+      );
       ctx.taskOutput = output;
       ctx.status = status;
-      ctx.testRunItemId = await this.postCompletedStatus(runId, ctx);
+      ctx.testRunItemId = await span2.withActive(
+        () => this.postCompletedStatus(runId, ctx)
+      );
       if (evaluators && ctx.status === "completed") {
         const evalTask = this.runEvaluatorsForItem(runId, ctx, evaluators);
         bgEvalTasks.push(evalTask);
@@ -3671,6 +3706,10 @@ function setModelParams(span2, kwargs) {
 function buildInputMessages(kwargs, requestType) {
   const messages = [];
   if (requestType === "chat") {
+    if (hasContent(kwargs.system)) {
+      const systemContent = typeof kwargs.system === "string" ? kwargs.system : safeStringify(kwargs.system);
+      messages.push({ role: "system", content: systemContent });
+    }
     const rawMessages = kwargs.messages;
     if (!Array.isArray(rawMessages)) return messages;
     for (const msg of rawMessages) {
@@ -3995,7 +4034,7 @@ function anthropicWrapper(tracer, spanName, requestType) {
           return (async () => {
             try {
               const stream = await response;
-              return new AsyncStreamingWrapper(span2, stream, startTime, kwargs);
+              return new AsyncStreamingWrapper(span2, stream, startTime, kwargs, spanContext);
             } catch (error) {
               Logger.error("netra.instrumentation.anthropic:", error);
               span2.setStatus({
@@ -4008,7 +4047,7 @@ function anthropicWrapper(tracer, spanName, requestType) {
             }
           })();
         } else {
-          return new AsyncStreamingWrapper(span2, response, startTime, kwargs);
+          return new AsyncStreamingWrapper(span2, response, startTime, kwargs, spanContext);
         }
       } catch (error) {
         Logger.error("netra.instrumentation.anthropic:", error);
@@ -4137,7 +4176,7 @@ var LISTENER_REGISTRATION_METHODS = /* @__PURE__ */ new Set(["on", "once", "addL
 var COMPLETION_METHODS = /* @__PURE__ */ new Set(["finalMessage", "done", "finalText"]);
 var TRACKED_STREAM_EVENTS = /* @__PURE__ */ new Set(["message", "contentBlock", "text", "finalMessage"]);
 var MessageStreamWrapper = class {
-  constructor(span2, messageStream, startTime, requestKwargs) {
+  constructor(span2, messageStream, startTime, requestKwargs, spanContext) {
     this.completeResponse = {
       content: [],
       model: "",
@@ -4147,6 +4186,7 @@ var MessageStreamWrapper = class {
     defineHidden(this, "messageStream", messageStream);
     defineHidden(this, "startTime", startTime);
     defineHidden(this, "requestKwargs", requestKwargs);
+    defineHidden(this, "spanContext", spanContext || trace.setSpan(context.active(), span2));
     return new Proxy(this, {
       get(target, prop, receiver) {
         if (prop === "toJSON") {
@@ -4223,6 +4263,9 @@ var MessageStreamWrapper = class {
       throw err;
     }
   }
+  getSpanContext() {
+    return this.spanContext;
+  }
   processEventData(eventType, data) {
     switch (eventType) {
       case "message":
@@ -4267,10 +4310,20 @@ var MessageStreamWrapper = class {
         if (!this.completeResponse.content) {
           this.completeResponse.content = [];
         }
-        this.completeResponse.content.push({
-          type: chunk.content_block.type,
-          text: ""
-        });
+        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": {
@@ -4278,11 +4331,27 @@ var MessageStreamWrapper = class {
           this.completeResponse.content = [{ type: "text", text: "" }];
         }
         const lastBlock = this.completeResponse.content[this.completeResponse.content.length - 1];
-        if (lastBlock && chunk.delta?.text) {
+        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 = {
@@ -4325,7 +4394,7 @@ var MessageStreamWrapper = class {
   }
 };
 var AsyncStreamingWrapper = class {
-  constructor(span2, response, startTime, requestKwargs) {
+  constructor(span2, response, startTime, requestKwargs, spanContext) {
     this.iterator = null;
     this.completeResponse = {
       choices: [],
@@ -4335,6 +4404,7 @@ var AsyncStreamingWrapper = class {
     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;
@@ -4353,7 +4423,7 @@ var AsyncStreamingWrapper = class {
           throw new Error("Response is not iterable");
         }
       }
-      const result = await this.iterator.next();
+      const result = await context.with(this.spanContext, () => this.iterator.next());
       if (result.done) {
         this.finalizeSpan(SpanStatusCode.OK);
         return result;
@@ -4379,10 +4449,20 @@ var AsyncStreamingWrapper = class {
       case "content_block_start": {
         const content = this.completeResponse.content || [];
         this.completeResponse.content = content;
-        content.push({
-          type: chunk.content_block.type,
-          text: ""
-        });
+        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;
       }
       case "content_block_delta": {
@@ -4392,11 +4472,27 @@ var AsyncStreamingWrapper = class {
           this.completeResponse.content = content;
         }
         const lastBlock = content[content.length - 1];
-        if (lastBlock && chunk.delta?.text) {
+        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 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);
+            }
+          }
+        }
+        break;
+      }
       case "message_delta": {
         if (chunk.delta?.usage) {
           const currentUsage = this.completeResponse.usage || {};
@@ -4437,19 +4533,29 @@ var INSTRUMENTATION_NAME = "netra.instrumentation.anthropic";
 var INSTRUMENTS = ["anthropic >= 0.71.2"];
 var originalMethods = /* @__PURE__ */ new Map();
 var isInstrumented = false;
-var AnthropicClass = null;
+var anthropicClasses = [];
 async function resolveAnthropicAsync() {
-  if (AnthropicClass) return AnthropicClass;
+  if (anthropicClasses.length > 0) return anthropicClasses;
   try {
     const anthropicModule = await import('@anthropic-ai/sdk');
-    AnthropicClass = anthropicModule.Anthropic || anthropicModule.default || anthropicModule;
-    return AnthropicClass;
+    anthropicClasses.push(anthropicModule.Anthropic || anthropicModule.default || anthropicModule);
   } catch {
-    return null;
+    Logger.warn("Failed to resolve Anthropic ESM module");
+  }
+  try {
+    const req = createRequire(import.meta.url);
+    const mod = req("@anthropic-ai/sdk");
+    const cjsClass = mod.Anthropic || mod.default || mod;
+    if (!anthropicClasses.includes(cjsClass)) {
+      anthropicClasses.push(cjsClass);
+    }
+  } catch {
+    Logger.warn("Failed to resolve Anthropic CJS module");
   }
+  return anthropicClasses;
 }
 function resolveAnthropic() {
-  return AnthropicClass;
+  return anthropicClasses;
 }
 var NetraAnthropicInstrumentor = class {
   constructor() {
@@ -4463,8 +4569,8 @@ var NetraAnthropicInstrumentor = class {
       Logger.warn("Anthropic is already instrumented");
       return this;
     }
-    const Anthropic = await resolveAnthropicAsync();
-    if (!Anthropic) {
+    const classes = await resolveAnthropicAsync();
+    if (classes.length === 0) {
       return this;
     }
     try {
@@ -4481,9 +4587,11 @@ var NetraAnthropicInstrumentor = class {
       Logger.error(`Failed to initialize tracer: ${error}`);
       return this;
     }
-    this._instrumentMessages();
-    this._instrumentBetaMessages();
-    this._instrumentBatchMessages();
+    classes.forEach((AnthropicSDK, index) => {
+      this._instrumentMessages(AnthropicSDK, index);
+      this._instrumentBetaMessages(AnthropicSDK, index);
+      this._instrumentBatchMessages(AnthropicSDK, index);
+    });
     isInstrumented = true;
     return this;
   }
@@ -4492,27 +4600,25 @@ var NetraAnthropicInstrumentor = class {
       Logger.warn("Anthropic is not instrumented");
       return;
     }
-    this._uninstrumentMessages();
-    this._uninstrumentBetaMessages();
-    this._uninstrumentBatchMessages();
+    const classes = resolveAnthropic();
+    classes.forEach((AnthropicSDK, index) => {
+      this._uninstrumentMessages(AnthropicSDK, index);
+      this._uninstrumentBetaMessages(AnthropicSDK, index);
+      this._uninstrumentBatchMessages(AnthropicSDK, index);
+    });
     originalMethods.clear();
-    AnthropicClass = null;
+    anthropicClasses = [];
     isInstrumented = false;
   }
   isInstrumented() {
     return isInstrumented;
   }
-  _instrumentMessages() {
+  _instrumentMessages(AnthropicSDK, index) {
     if (!this.tracer) {
       Logger.warn("Anthropic instrumentation: No tracer available");
       return;
     }
     try {
-      const AnthropicSDK = resolveAnthropic();
-      if (!AnthropicSDK) {
-        Logger.warn("Anthropic instrumentation: Anthropic SDK not available");
-        return;
-      }
       const MessagesClass = AnthropicSDK.Messages;
       if (!MessagesClass) {
         Logger.error(
@@ -4522,11 +4628,12 @@ var NetraAnthropicInstrumentor = class {
       }
       if (MessagesClass?.prototype?.stream) {
         const originalStream = MessagesClass.prototype.stream;
-        originalMethods.set("messages.stream", originalStream);
+        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: {
@@ -4534,17 +4641,18 @@ var NetraAnthropicInstrumentor = class {
               "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");
+          const originalCreate = originalMethods.get(`messages.create-${index}`);
           if (originalCreate) {
             this.create = originalCreate;
           }
           try {
-            const messageStream = original(...args);
-            return new MessageStreamWrapper(span2, messageStream, startTime, kwargs);
+            const messageStream = context.with(spanContext, () => original(...args));
+            return new MessageStreamWrapper(span2, messageStream, startTime, kwargs, spanContext);
           } finally {
             if (originalCreate) {
               this.create = instrumentedCreate;
@@ -4554,7 +4662,7 @@ var NetraAnthropicInstrumentor = class {
       }
       if (MessagesClass?.prototype?.create) {
         const originalCreate = MessagesClass.prototype.create;
-        originalMethods.set("messages.create", originalCreate);
+        originalMethods.set(`messages.create-${index}`, originalCreate);
         const tracer = this.tracer;
         const wrapper = chatWrapper(tracer);
         MessagesClass.prototype.create = function(...args) {
@@ -4572,17 +4680,12 @@ var NetraAnthropicInstrumentor = class {
       Logger.error(`Failed to instrument messages: ${error}`);
     }
   }
-  _instrumentBetaMessages() {
+  _instrumentBetaMessages(AnthropicSDK, index) {
     if (!this.tracer) {
       Logger.warn("Anthropic instrumentation: No tracer available");
       return;
     }
     try {
-      const AnthropicSDK = resolveAnthropic();
-      if (!AnthropicSDK) {
-        Logger.warn("Anthropic instrumentation: Anthropic SDK not available");
-        return;
-      }
       const BetaMessagesClass = AnthropicSDK.Beta?.Messages;
       if (!BetaMessagesClass) {
         Logger.error(
@@ -4592,7 +4695,7 @@ var NetraAnthropicInstrumentor = class {
       }
       if (BetaMessagesClass?.prototype?.create) {
         const originalCreate = BetaMessagesClass.prototype.create;
-        originalMethods.set("beta.messages.create", originalCreate);
+        originalMethods.set(`beta.messages.create-${index}`, originalCreate);
         const tracer = this.tracer;
         const wrapper = betaWrapper(tracer);
         BetaMessagesClass.prototype.create = function(...args) {
@@ -4610,17 +4713,12 @@ var NetraAnthropicInstrumentor = class {
       Logger.error(`Failed to instrument beta: ${error}`);
     }
   }
-  _instrumentBatchMessages() {
+  _instrumentBatchMessages(AnthropicSDK, index) {
     if (!this.tracer) {
       Logger.warn("Anthropic instrumentation: No tracer available");
       return;
     }
     try {
-      const AnthropicSDK = resolveAnthropic();
-      if (!AnthropicSDK) {
-        Logger.warn("Anthropic instrumentation: Anthropic SDK not available");
-        return;
-      }
       const BatchMessageClass = AnthropicSDK.Messages?.Batches;
       if (!BatchMessageClass) {
         Logger.error(
@@ -4630,7 +4728,7 @@ var NetraAnthropicInstrumentor = class {
       }
       if (BatchMessageClass?.prototype?.create) {
         const originalCreate = BatchMessageClass.prototype.create;
-        originalMethods.set("batch.messages.create", originalCreate);
+        originalMethods.set(`batch.messages.create-${index}`, originalCreate);
         const tracer = this.tracer;
         const wrapper = batchesWrapper(tracer);
         BatchMessageClass.prototype.create = function(...args) {
@@ -4648,25 +4746,25 @@ var NetraAnthropicInstrumentor = class {
       Logger.error(`Failed to instrument batches: ${error}`);
     }
   }
-  _uninstrumentMessages() {
+  _uninstrumentMessages(AnthropicSDK, index) {
     try {
-      const AnthropicSDK = resolveAnthropic();
-      if (!AnthropicSDK) return;
       const MessagesClass = AnthropicSDK.Messages;
-      const originalCreate = originalMethods.get("messages.create");
+      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;
+      }
     } catch (error) {
       Logger.error(`Failed to uninstrument messages: ${error}`);
     }
   }
-  _uninstrumentBetaMessages() {
+  _uninstrumentBetaMessages(AnthropicSDK, index) {
     try {
-      const AnthropicSDK = resolveAnthropic();
-      if (!AnthropicSDK) return;
       const BetaMessagesClass = AnthropicSDK.Beta?.Messages;
-      const originalCreate = originalMethods.get("beta.messages.create");
+      const originalCreate = originalMethods.get(`beta.messages.create-${index}`);
       if (originalCreate && BetaMessagesClass?.prototype) {
         BetaMessagesClass.prototype.create = originalCreate;
       }
@@ -4674,12 +4772,10 @@ var NetraAnthropicInstrumentor = class {
       Logger.error(`Failed to uninstrument beta: ${error}`);
     }
   }
-  _uninstrumentBatchMessages() {
+  _uninstrumentBatchMessages(AnthropicSDK, index) {
     try {
-      const AnthropicSDK = resolveAnthropic();
-      if (!AnthropicSDK) return;
       const BatchMessagesClass = AnthropicSDK.Messages?.Batches;
-      const originalCreate = originalMethods.get("batch.messages.create");
+      const originalCreate = originalMethods.get(`batch.messages.create-${index}`);
       if (originalCreate && BatchMessagesClass?.prototype) {
         BatchMessagesClass.prototype.create = originalCreate;
       }
@@ -4701,6 +4797,16 @@ function safeStringify2(value) {
     return String(value);
   }
 }
+function extractModelName(model) {
+  if (model && model.startsWith("models/")) {
+    return model.replace(/^models\//, "");
+  }
+  return model;
+}
+function normalizeGenAIRole(raw) {
+  const rawLower = raw.toLowerCase();
+  return rawLower === "model" ? "assistant" : rawLower;
+}
 function setRequestAttributes3(span2, kwargs, requestType, args) {
   span2._netra_kwargs = kwargs;
   if (!span2.isRecording()) {
@@ -4818,6 +4924,26 @@ function _setPromptAttributes(span2, kwargs, args) {
       promptIndex++;
     }
   }
+  if (kwargs.history && Array.isArray(kwargs.history)) {
+    for (const turn of kwargs.history) {
+      const role = normalizeGenAIRole(String(turn.role ?? "user"));
+      const parts = turn.parts;
+      if (Array.isArray(parts)) {
+        const textContent = parts.filter((p) => p.text !== void 0).map((p) => String(p.text)).join("");
+        if (textContent) {
+          span2.setAttribute(
+            `${SpanAttributes2.LLM_PROMPTS}.${promptIndex}.role`,
+            role
+          );
+          span2.setAttribute(
+            `${SpanAttributes2.LLM_PROMPTS}.${promptIndex}.content`,
+            textContent
+          );
+          promptIndex++;
+        }
+      }
+    }
+  }
   if (!args) return;
   if (typeof args === "string") {
     span2.setAttribute(
@@ -5022,7 +5148,7 @@ function _setCompletionAttributes(span2, response) {
     const candidate = candidates[i];
     const content = candidate.content;
     if (!content) continue;
-    const role = String(content.role ?? "model");
+    const role = normalizeGenAIRole(String(content.role ?? "model"));
     const parts = content.parts;
     if (!Array.isArray(parts)) continue;
     const textContent = parts.filter((p) => p.text !== void 0).map((p) => String(p.text)).join("");
@@ -5080,12 +5206,16 @@ function googleGenAIWrapper(tracer, spanName, requestType) {
       const modelInstance = this;
       const modelName = modelInstance.model;
       const systemInstruction = modelInstance.systemInstruction;
+      const history = modelInstance.history;
       if (modelName) {
-        kwargs.model = modelName;
+        kwargs.model = extractModelName(modelName);
       }
       if (systemInstruction) {
         kwargs.systemInstruction = systemInstruction;
       }
+      if (history) {
+        kwargs.history = history;
+      }
       const currentContext = context.active();
       return tracer.startActiveSpan(
         spanName,
@@ -5163,8 +5293,10 @@ function googleGenAIStreamWrapper(tracer, spanName, requestType) {
       const modelInstance = this;
       const modelName = modelInstance.model;
       const systemInstruction = modelInstance.systemInstruction;
-      if (modelName) kwargs.model = modelName;
+      const history = modelInstance.history;
+      if (modelName) kwargs.model = extractModelName(modelName);
       if (systemInstruction) kwargs.systemInstruction = systemInstruction;
+      if (history) kwargs.history = history;
       const currentContext = context.active();
       return tracer.startActiveSpan(
         spanName,
@@ -5303,25 +5435,75 @@ function googleGenAIStreamWrapper(tracer, spanName, requestType) {
     };
   };
 }
+function googleGenAIStartChatWrapper(tracer, spanName, requestType) {
+  const sendMessageWrapperFn = googleGenAIWrapper(tracer, spanName, requestType);
+  const sendMessageStreamWrapperFn = googleGenAIStreamWrapper(tracer, spanName, requestType);
+  return function wrapper(original) {
+    return function(...args) {
+      const chatSession = original.apply(this, args);
+      if (!chatSession) return chatSession;
+      const modelInstance = this;
+      const modelName = modelInstance.model;
+      const systemInstruction = modelInstance.systemInstruction;
+      const chatHistory = args[0]?.history;
+      if (typeof chatSession.sendMessage === "function" && !chatSession.__netra_patched) {
+        const originalSendMessage = chatSession.sendMessage.bind(chatSession);
+        const wrappedSendMessage = sendMessageWrapperFn(originalSendMessage);
+        chatSession.sendMessage = function(...sendArgs) {
+          const ctx = this;
+          if (modelName) ctx.model = modelName;
+          if (systemInstruction) ctx.systemInstruction = systemInstruction;
+          if (chatHistory) ctx.history = chatHistory;
+          return wrappedSendMessage.apply(this, sendArgs);
+        };
+        if (typeof chatSession.sendMessageStream === "function") {
+          const originalSendStream = chatSession.sendMessageStream.bind(chatSession);
+          const wrappedSendStream = sendMessageStreamWrapperFn(originalSendStream);
+          chatSession.sendMessageStream = function(...sendArgs) {
+            const ctx = this;
+            if (modelName) ctx.model = modelName;
+            if (systemInstruction) ctx.systemInstruction = systemInstruction;
+            if (chatHistory) ctx.history = chatHistory;
+            return wrappedSendStream.apply(this, sendArgs);
+          };
+        }
+        chatSession.__netra_patched = true;
+      }
+      return chatSession;
+    };
+  };
+}
 var chatWrapper2 = (tracer) => googleGenAIWrapper(tracer, CHAT_SPAN_NAME2, "chat");
 var embeddingsWrapper = (tracer) => googleGenAIWrapper(tracer, EMBEDDING_SPAN_NAME, "embedding");
 var chatStreamWrapper = (tracer) => googleGenAIStreamWrapper(tracer, CHAT_SPAN_NAME2, "chat");
-var GenerativeModel = null;
+var startChatWrapper = (tracer) => googleGenAIStartChatWrapper(tracer, CHAT_SPAN_NAME2, "chat");
 var INSTRUMENTATION_NAME2 = "netra.instrumentation.google_genai";
 var INSTRUMENTS2 = ["@google/genai >= 0.24.1"];
 var isInstrumented2 = false;
+var generativeModelClasses = [];
 async function resolveGoogleGenerativeAIAsync() {
-  if (GenerativeModel) return GenerativeModel;
+  if (generativeModelClasses.length > 0) return generativeModelClasses;
   try {
     const googleGenAIModule = await import('@google/generative-ai');
-    GenerativeModel = googleGenAIModule.GenerativeModel || googleGenAIModule.default?.GenerativeModel || googleGenAIModule.default || googleGenAIModule;
-    return GenerativeModel;
+    const esmClass = googleGenAIModule.GenerativeModel || googleGenAIModule.default?.GenerativeModel || googleGenAIModule.default || googleGenAIModule;
+    generativeModelClasses.push(esmClass);
   } catch {
-    return null;
+    Logger.warn("Failed to resolve Google GenAI ESM module");
   }
+  try {
+    const req = createRequire(import.meta.url);
+    const mod = req("@google/generative-ai");
+    const cjsClass = mod.GenerativeModel || mod.default?.GenerativeModel || mod.default || mod;
+    if (!generativeModelClasses.includes(cjsClass)) {
+      generativeModelClasses.push(cjsClass);
+    }
+  } catch {
+    Logger.warn("Failed to resolve Google GenAI CJS module");
+  }
+  return generativeModelClasses;
 }
 function resolveGoogleGenerativeAI() {
-  return GenerativeModel;
+  return generativeModelClasses;
 }
 var NetraGoogleGenerativeAIInstrumentor = class {
   constructor() {
@@ -5335,16 +5517,15 @@ var NetraGoogleGenerativeAIInstrumentor = class {
   }
   /**
    * Instrument Google GenAI client methods (async version)
-   * Uses dynamic import() to ensure we get the same ES module instance
-   * that the application uses.
+   * Tries both ESM and CJS resolution to cover dual-package setups.
    */
   async instrumentAsync(options = {}) {
     if (isInstrumented2) {
       Logger.warn("Google GenAI is already instrumented");
       return this;
     }
-    const model = await resolveGoogleGenerativeAIAsync();
-    if (!model) {
+    const classes = await resolveGoogleGenerativeAIAsync();
+    if (classes.length === 0) {
       return this;
     }
     try {
@@ -5354,7 +5535,7 @@ var NetraGoogleGenerativeAIInstrumentor = class {
       Logger.error(`Failed to initialize tracer: ${error}`);
       return this;
     }
-    this._instrumentGenerativeModel();
+    classes.forEach((model) => this._instrumentGenerativeModel(model));
     isInstrumented2 = true;
     return this;
   }
@@ -5366,7 +5547,8 @@ var NetraGoogleGenerativeAIInstrumentor = class {
       Logger.warn("Google GenAI is already instrumented");
       return this;
     }
-    if (!resolveGoogleGenerativeAI()) {
+    const classes = resolveGoogleGenerativeAI();
+    if (classes.length === 0) {
       this.instrumentAsync(options).catch((e) => {
         Logger.error("Failed to instrument Google GenAI:", e);
       });
@@ -5379,7 +5561,7 @@ var NetraGoogleGenerativeAIInstrumentor = class {
       Logger.error(`Failed to initialize tracer: ${error}`);
       return this;
     }
-    this._instrumentGenerativeModel();
+    classes.forEach((model) => this._instrumentGenerativeModel(model));
     isInstrumented2 = true;
     return this;
   }
@@ -5391,8 +5573,9 @@ var NetraGoogleGenerativeAIInstrumentor = class {
       Logger.warn("Google GenAI is not instrumented");
       return;
     }
-    this._uninstrumentGenerativeModel();
-    GenerativeModel = null;
+    const classes = resolveGoogleGenerativeAI();
+    classes.forEach((model) => this._uninstrumentGenerativeModel(model));
+    generativeModelClasses = [];
     isInstrumented2 = false;
   }
   /**
@@ -5401,10 +5584,10 @@ var NetraGoogleGenerativeAIInstrumentor = class {
   isInstrumented() {
     return isInstrumented2;
   }
-  _instrumentGenerativeModel() {
+  _instrumentGenerativeModel(GenerativeModel) {
     if (!this.tracer) return;
     try {
-      if (!GenerativeModel) {
+      if (!GenerativeModel?.prototype) {
         Logger.error(
           "Failed to find Google GenAI GenerativeModel to instrument"
         );
@@ -5426,14 +5609,22 @@ var NetraGoogleGenerativeAIInstrumentor = class {
         "embedContent",
         embeddingsWrapper(tracer)
       );
+      if (typeof GenerativeModel.prototype.startChat === "function") {
+        shimmer.wrap(
+          GenerativeModel.prototype,
+          "startChat",
+          startChatWrapper(tracer)
+        );
+      }
     } catch (error) {
       Logger.debug(
         `Google GenAI instrumentation: failed to instrument: ${error}`
       );
     }
   }
-  _uninstrumentGenerativeModel() {
+  _uninstrumentGenerativeModel(GenerativeModel) {
     try {
+      if (!GenerativeModel?.prototype) return;
       if (typeof GenerativeModel.prototype.generateContent === "function") {
         shimmer.unwrap(GenerativeModel.prototype, "generateContent");
       }
@@ -5443,6 +5634,9 @@ var NetraGoogleGenerativeAIInstrumentor = class {
       if (typeof GenerativeModel.prototype.embedContent === "function") {
         shimmer.unwrap(GenerativeModel.prototype, "embedContent");
       }
+      if (typeof GenerativeModel.prototype.startChat === "function") {
+        shimmer.unwrap(GenerativeModel.prototype, "startChat");
+      }
     } catch (error) {
       Logger.debug(`Failed to uninstrument Google GenAI: ${error}`);
     }
@@ -5806,19 +6000,29 @@ var INSTRUMENTATION_NAME3 = "netra.instrumentation.groq";
 var INSTRUMENTS3 = ["groq-sdk >= 0.3.0"];
 var originalMethods2 = /* @__PURE__ */ new Map();
 var isInstrumented3 = false;
-var GroqClass = null;
+var groqClasses = [];
 async function resolveGroqAsync() {
-  if (GroqClass) return GroqClass;
+  if (groqClasses.length > 0) return groqClasses;
   try {
     const groqModule = await import('groq-sdk');
-    GroqClass = groqModule.Groq || groqModule.default || groqModule;
-    return GroqClass;
+    groqClasses.push(groqModule.Groq || groqModule.default || groqModule);
   } catch {
-    return null;
+    Logger.warn("Failed to resolve Groq ESM module");
   }
+  try {
+    const req = createRequire(import.meta.url);
+    const mod = req("groq-sdk");
+    const cjsClass = mod.Groq || mod.default || mod;
+    if (!groqClasses.includes(cjsClass)) {
+      groqClasses.push(cjsClass);
+    }
+  } catch {
+    Logger.warn("Failed to resolve Groq CJS module");
+  }
+  return groqClasses;
 }
 function resolveGroq() {
-  return GroqClass;
+  return groqClasses;
 }
 var NetraGroqInstrumentor = class {
   constructor() {
@@ -5829,16 +6033,15 @@ var NetraGroqInstrumentor = class {
   }
   /**
    * Instrument Groq client methods (async version)
-   * Uses dynamic import() to ensure we get the same ES module instance
-   * that the application uses.
+   * Tries both ESM and CJS resolution to cover dual-package setups.
    */
   async instrumentAsync(options = {}) {
     if (isInstrumented3) {
       Logger.warn("Groq is already instrumented");
       return this;
     }
-    const Groq = await resolveGroqAsync();
-    if (!Groq) {
+    const classes = await resolveGroqAsync();
+    if (classes.length === 0) {
       return this;
     }
     try {
@@ -5855,21 +6058,23 @@ var NetraGroqInstrumentor = class {
       Logger.error(`Failed to initialize tracer: ${error}`);
       return this;
     }
-    this._instrumentChatCompletions(Groq);
+    classes.forEach((Groq, index) => {
+      this._instrumentChatCompletions(Groq, index);
+    });
     isInstrumented3 = true;
     return this;
   }
   /**
    * Instrument Groq client methods (sync version - for backwards compatibility)
-   * Note: This uses a cached Groq class. Call instrumentAsync() for proper initialization.
+   * Note: This uses cached Groq classes. Call instrumentAsync() for proper initialization.
    */
   instrument(options = {}) {
     if (isInstrumented3) {
       Logger.warn("Groq is already instrumented");
       return this;
     }
-    const Groq = resolveGroq();
-    if (!Groq) {
+    const classes = resolveGroq();
+    if (classes.length === 0) {
       this.instrumentAsync(options).catch((e) => {
         Logger.error("Failed to instrument Groq:", e);
       });
@@ -5889,7 +6094,9 @@ var NetraGroqInstrumentor = class {
       Logger.error(`Failed to initialize tracer: ${error}`);
       return this;
     }
-    this._instrumentChatCompletions(Groq);
+    classes.forEach((Groq, index) => {
+      this._instrumentChatCompletions(Groq, index);
+    });
     isInstrumented3 = true;
     return this;
   }
@@ -5898,18 +6105,18 @@ var NetraGroqInstrumentor = class {
       Logger.warn("Groq is not instrumented");
       return;
     }
-    const Groq = resolveGroq();
-    if (Groq) {
-      this._uninstrumentChatCompletions(Groq);
-    }
+    const classes = resolveGroq();
+    classes.forEach((Groq, index) => {
+      this._uninstrumentChatCompletions(Groq, index);
+    });
     originalMethods2.clear();
-    GroqClass = null;
+    groqClasses = [];
     isInstrumented3 = false;
   }
   isInstrumented() {
     return isInstrumented3;
   }
-  _instrumentChatCompletions(Groq) {
+  _instrumentChatCompletions(Groq, index) {
     if (!this.tracer) {
       Logger.warn("Groq instrumentation: No tracer available");
       return;
@@ -5923,7 +6130,7 @@ var NetraGroqInstrumentor = class {
         return;
       }
       const originalCreate = CompletionsClass.prototype.create;
-      originalMethods2.set("chat.completions.create", originalCreate);
+      originalMethods2.set(`chat.completions.create-${index}`, originalCreate);
       const tracer = this.tracer;
       const wrapper = chatWrapper3(tracer);
       CompletionsClass.prototype.create = function(...args) {
@@ -5938,10 +6145,10 @@ var NetraGroqInstrumentor = class {
       );
     }
   }
-  _uninstrumentChatCompletions(Groq) {
+  _uninstrumentChatCompletions(Groq, index) {
     try {
       const CompletionsClass = Groq.Chat?.Completions;
-      const originalCreate = originalMethods2.get("chat.completions.create");
+      const originalCreate = originalMethods2.get(`chat.completions.create-${index}`);
       if (originalCreate && CompletionsClass?.prototype) {
         CompletionsClass.prototype.create = originalCreate;
       }
@@ -7436,19 +7643,31 @@ var INSTRUMENTATION_NAME5 = "netra.instrumentation.mistral_ai";
 var INSTRUMENTS5 = ["@mistralai/mistralai >= 1.0.0"];
 var originalMethods4 = /* @__PURE__ */ new Map();
 var isInstrumented5 = false;
-var MistralClass = null;
+var mistralClasses = [];
 async function resolveMistralAsync() {
-  if (MistralClass) return MistralClass;
+  if (mistralClasses.length > 0) return mistralClasses;
   try {
     const mistralModule = await import('@mistralai/mistralai');
-    MistralClass = mistralModule.Mistral || mistralModule.default || mistralModule;
-    return MistralClass;
+    mistralClasses.push(
+      mistralModule.Mistral || mistralModule.default || mistralModule
+    );
   } catch {
-    return null;
+    Logger.warn("Failed to resolve MistralAI ESM module");
   }
+  try {
+    const req = createRequire(import.meta.url);
+    const mod = req("@mistralai/mistralai");
+    const cjsClass = mod.Mistral || mod.default || mod;
+    if (!mistralClasses.includes(cjsClass)) {
+      mistralClasses.push(cjsClass);
+    }
+  } catch {
+    Logger.warn("Failed to resolve MistralAI CJS module");
+  }
+  return mistralClasses;
 }
 function resolveMistral() {
-  return MistralClass;
+  return mistralClasses;
 }
 var NetraMistralAIInstrumentor = class {
   constructor() {
@@ -7463,16 +7682,15 @@ var NetraMistralAIInstrumentor = class {
   }
   /**
    * Instrument MistralAI client methods (async version)
-   * Uses dynamic import() to ensure we get the same ES module instance
-   * that the application uses.
+   * Tries both ESM and CJS resolution to cover dual-package setups.
    */
   async instrumentAsync(options = {}) {
     if (isInstrumented5) {
       Logger.warn("MistralAI is already instrumented");
       return this;
     }
-    const Mistral = await resolveMistralAsync();
-    if (!Mistral) {
+    const classes = await resolveMistralAsync();
+    if (classes.length === 0) {
       return this;
     }
     try {
@@ -7489,11 +7707,16 @@ var NetraMistralAIInstrumentor = class {
       Logger.error(`Failed to initialize tracer: ${error}`);
       return this;
     }
-    const patchedChat = this._instrumentChat(Mistral);
-    const patchedEmbeddings = this._instrumentEmbeddings(Mistral);
-    const patchedFIM = this._instrumentFIM(Mistral);
-    const patchedAgents = this._instrumentAgents(Mistral);
-    const didPatch = patchedChat || patchedEmbeddings || patchedFIM || patchedAgents;
+    let didPatch = false;
+    classes.forEach((Mistral, index) => {
+      const patchedChat = this._instrumentChat(Mistral, index);
+      const patchedEmbeddings = this._instrumentEmbeddings(Mistral, index);
+      const patchedFIM = this._instrumentFIM(Mistral, index);
+      const patchedAgents = this._instrumentAgents(Mistral, index);
+      if (patchedChat || patchedEmbeddings || patchedFIM || patchedAgents) {
+        didPatch = true;
+      }
+    });
     if (!didPatch) {
       Logger.warn(
         "MistralAI instrumentation initialized but no methods were patched. Is '@mistralai/mistralai' installed and compatible?"
@@ -7505,15 +7728,15 @@ var NetraMistralAIInstrumentor = class {
   }
   /**
    * Instrument MistralAI client methods (sync version - for backwards compatibility)
-   * Note: This uses a cached Mistral class. Call instrumentAsync() for proper initialization.
+   * Note: This uses cached Mistral classes. Call instrumentAsync() for proper initialization.
    */
   instrument(options = {}) {
     if (isInstrumented5) {
       Logger.warn("MistralAI is already instrumented");
       return this;
     }
-    const Mistral = resolveMistral();
-    if (!Mistral) {
+    const classes = resolveMistral();
+    if (classes.length === 0) {
       this.instrumentAsync(options).catch((e) => {
         Logger.error("Failed to instrument MistralAI:", e);
       });
@@ -7533,11 +7756,16 @@ var NetraMistralAIInstrumentor = class {
       Logger.error(`Failed to initialize tracer: ${error}`);
       return this;
     }
-    const patchedChat = this._instrumentChat(Mistral);
-    const patchedEmbeddings = this._instrumentEmbeddings(Mistral);
-    const patchedFIM = this._instrumentFIM(Mistral);
-    const patchedAgents = this._instrumentAgents(Mistral);
-    const didPatch = patchedChat || patchedEmbeddings || patchedFIM || patchedAgents;
+    let didPatch = false;
+    classes.forEach((Mistral, index) => {
+      const patchedChat = this._instrumentChat(Mistral, index);
+      const patchedEmbeddings = this._instrumentEmbeddings(Mistral, index);
+      const patchedFIM = this._instrumentFIM(Mistral, index);
+      const patchedAgents = this._instrumentAgents(Mistral, index);
+      if (patchedChat || patchedEmbeddings || patchedFIM || patchedAgents) {
+        didPatch = true;
+      }
+    });
     if (!didPatch) {
       Logger.warn(
         "MistralAI instrumentation initialized but no methods were patched. Is '@mistralai/mistralai' installed and compatible?"
@@ -7555,15 +7783,15 @@ var NetraMistralAIInstrumentor = class {
       Logger.warn("MistralAI is not instrumented");
       return;
     }
-    const Mistral = resolveMistral();
-    if (Mistral) {
-      this._uninstrumentChat(Mistral);
-      this._uninstrumentEmbeddings(Mistral);
-      this._uninstrumentFIM(Mistral);
-      this._uninstrumentAgents(Mistral);
-    }
+    const classes = resolveMistral();
+    classes.forEach((Mistral, index) => {
+      this._uninstrumentChat(Mistral, index);
+      this._uninstrumentEmbeddings(Mistral, index);
+      this._uninstrumentFIM(Mistral, index);
+      this._uninstrumentAgents(Mistral, index);
+    });
     originalMethods4.clear();
-    MistralClass = null;
+    mistralClasses = [];
     isInstrumented5 = false;
   }
   /**
@@ -7601,14 +7829,14 @@ var NetraMistralAIInstrumentor = class {
     this._ensureResourceCtors(Mistral);
     return this.resourceCtors[name] ?? null;
   }
-  _instrumentChat(Mistral) {
+  _instrumentChat(Mistral, index) {
     if (!this.tracer) return false;
     try {
       const ChatClass = this._getCtor(Mistral, "chat");
       let didPatch = false;
       if (ChatClass?.prototype?.complete) {
         const originalComplete = ChatClass.prototype.complete;
-        originalMethods4.set("chat.complete", originalComplete);
+        originalMethods4.set(`chat.complete-${index}`, originalComplete);
         const tracer = this.tracer;
         const wrapper = chatWrapper4(tracer);
         ChatClass.prototype.complete = function(...args) {
@@ -7625,7 +7853,7 @@ var NetraMistralAIInstrumentor = class {
       }
       if (ChatClass?.prototype?.stream) {
         const originalStream = ChatClass.prototype.stream;
-        originalMethods4.set("chat.stream", originalStream);
+        originalMethods4.set(`chat.stream-${index}`, originalStream);
         const tracer = this.tracer;
         const wrapper = chatStreamWrapper2(tracer);
         ChatClass.prototype.stream = function(...args) {
@@ -7646,14 +7874,14 @@ var NetraMistralAIInstrumentor = class {
       return false;
     }
   }
-  _instrumentEmbeddings(Mistral) {
+  _instrumentEmbeddings(Mistral, index) {
     if (!this.tracer) return false;
     try {
       const EmbeddingsClass = this._getCtor(Mistral, "embeddings");
       let didPatch = false;
       if (EmbeddingsClass?.prototype?.create) {
         const originalCreate = EmbeddingsClass.prototype.create;
-        originalMethods4.set("embeddings.create", originalCreate);
+        originalMethods4.set(`embeddings.create-${index}`, originalCreate);
         const tracer = this.tracer;
         const wrapper = embeddingsWrapper2(tracer);
         EmbeddingsClass.prototype.create = function(...args) {
@@ -7674,14 +7902,14 @@ var NetraMistralAIInstrumentor = class {
       return false;
     }
   }
-  _instrumentFIM(Mistral) {
+  _instrumentFIM(Mistral, index) {
     if (!this.tracer) return false;
     try {
       const FimClass = this._getCtor(Mistral, "fim");
       let didPatch = false;
       if (FimClass?.prototype?.complete) {
         const originalComplete = FimClass.prototype.complete;
-        originalMethods4.set("fim.complete", originalComplete);
+        originalMethods4.set(`fim.complete-${index}`, originalComplete);
         const tracer = this.tracer;
         const wrapper = fimWrapper(tracer);
         FimClass.prototype.complete = function(...args) {
@@ -7698,7 +7926,7 @@ var NetraMistralAIInstrumentor = class {
       }
       if (FimClass?.prototype?.stream) {
         const originalStream = FimClass.prototype.stream;
-        originalMethods4.set("fim.stream", originalStream);
+        originalMethods4.set(`fim.stream-${index}`, originalStream);
         const tracer = this.tracer;
         const wrapper = fimStreamWrapper(tracer);
         FimClass.prototype.stream = function(...args) {
@@ -7719,14 +7947,14 @@ var NetraMistralAIInstrumentor = class {
       return false;
     }
   }
-  _instrumentAgents(Mistral) {
+  _instrumentAgents(Mistral, index) {
     if (!this.tracer) return false;
     try {
       const AgentsClass = this._getCtor(Mistral, "agents");
       let didPatch = false;
       if (AgentsClass?.prototype?.complete) {
         const originalComplete = AgentsClass.prototype.complete;
-        originalMethods4.set("agents.complete", originalComplete);
+        originalMethods4.set(`agents.complete-${index}`, originalComplete);
         const tracer = this.tracer;
         const wrapper = agentsWrapper(tracer);
         AgentsClass.prototype.complete = function(...args) {
@@ -7743,7 +7971,7 @@ var NetraMistralAIInstrumentor = class {
       }
       if (AgentsClass?.prototype?.stream) {
         const originalStream = AgentsClass.prototype.stream;
-        originalMethods4.set("agents.stream", originalStream);
+        originalMethods4.set(`agents.stream-${index}`, originalStream);
         const tracer = this.tracer;
         const wrapper = agentsStreamWrapper(tracer);
         AgentsClass.prototype.stream = function(...args) {
@@ -7764,14 +7992,14 @@ var NetraMistralAIInstrumentor = class {
       return false;
     }
   }
-  _uninstrumentChat(Mistral) {
+  _uninstrumentChat(Mistral, index) {
     try {
       const ChatClass = this._getCtor(Mistral, "chat");
-      const originalComplete = originalMethods4.get("chat.complete");
+      const originalComplete = originalMethods4.get(`chat.complete-${index}`);
       if (originalComplete && ChatClass?.prototype) {
         ChatClass.prototype.complete = originalComplete;
       }
-      const originalStream = originalMethods4.get("chat.stream");
+      const originalStream = originalMethods4.get(`chat.stream-${index}`);
       if (originalStream && ChatClass?.prototype) {
         ChatClass.prototype.stream = originalStream;
       }
@@ -7779,10 +8007,10 @@ var NetraMistralAIInstrumentor = class {
       Logger.error(`Failed to uninstrument MistralAI chat: ${error}`);
     }
   }
-  _uninstrumentEmbeddings(Mistral) {
+  _uninstrumentEmbeddings(Mistral, index) {
     try {
       const EmbeddingsClass = this._getCtor(Mistral, "embeddings");
-      const originalCreate = originalMethods4.get("embeddings.create");
+      const originalCreate = originalMethods4.get(`embeddings.create-${index}`);
       if (originalCreate && EmbeddingsClass?.prototype) {
         EmbeddingsClass.prototype.create = originalCreate;
       }
@@ -7790,14 +8018,14 @@ var NetraMistralAIInstrumentor = class {
       Logger.error(`Failed to uninstrument MistralAI embeddings: ${error}`);
     }
   }
-  _uninstrumentFIM(Mistral) {
+  _uninstrumentFIM(Mistral, index) {
     try {
       const FimClass = this._getCtor(Mistral, "fim");
-      const originalComplete = originalMethods4.get("fim.complete");
+      const originalComplete = originalMethods4.get(`fim.complete-${index}`);
       if (originalComplete && FimClass?.prototype) {
         FimClass.prototype.complete = originalComplete;
       }
-      const originalStream = originalMethods4.get("fim.stream");
+      const originalStream = originalMethods4.get(`fim.stream-${index}`);
       if (originalStream && FimClass?.prototype) {
         FimClass.prototype.stream = originalStream;
       }
@@ -7805,14 +8033,14 @@ var NetraMistralAIInstrumentor = class {
       Logger.error(`Failed to uninstrument MistralAI FIM: ${error}`);
     }
   }
-  _uninstrumentAgents(Mistral) {
+  _uninstrumentAgents(Mistral, index) {
     try {
       const AgentsClass = this._getCtor(Mistral, "agents");
-      const originalComplete = originalMethods4.get("agents.complete");
+      const originalComplete = originalMethods4.get(`agents.complete-${index}`);
       if (originalComplete && AgentsClass?.prototype) {
         AgentsClass.prototype.complete = originalComplete;
       }
-      const originalStream = originalMethods4.get("agents.stream");
+      const originalStream = originalMethods4.get(`agents.stream-${index}`);
       if (originalStream && AgentsClass?.prototype) {
         AgentsClass.prototype.stream = originalStream;
       }
@@ -9807,10 +10035,10 @@ function disableTraceloopLangchainCallbackHandler() {
   } catch {
   }
 }
-function resolveRootInstrumentNames(rootInstruments, blockInstruments2) {
+function resolveRootInstrumentNames(rootInstruments, blockInstruments) {
   const allSentinel = "__all__" /* ALL */;
   const rootHasAll = rootInstruments != null && rootInstruments.has(allSentinel);
-  const blockHasAll = blockInstruments2 != null && blockInstruments2.has(allSentinel);
+  const blockHasAll = blockInstruments != null && blockInstruments.has(allSentinel);
   if (blockHasAll) {
     if (rootHasAll) {
       Logger.error(
@@ -9828,9 +10056,9 @@ function resolveRootInstrumentNames(rootInstruments, blockInstruments2) {
   let blockedValues;
   if (blockHasAll) {
     blockedValues = new Set(allInstrumentValues);
-  } else if (blockInstruments2 && blockInstruments2.size > 0) {
+  } else if (blockInstruments && blockInstruments.size > 0) {
     blockedValues = new Set(
-      [...blockInstruments2].filter((m) => m !== allSentinel).map((m) => m.valueOf())
+      [...blockInstruments].filter((m) => m !== allSentinel).map((m) => m.valueOf())
     );
   } else {
     blockedValues = /* @__PURE__ */ new Set();
@@ -9858,11 +10086,11 @@ function resolveRootInstrumentNames(rootInstruments, blockInstruments2) {
   }
   return resolved;
 }
-function initInstrumentations(config2, instruments2, blockInstruments2, rootInstruments) {
-  const enableAll = instruments2 != null && instruments2.has("__all__" /* ALL */);
+function initInstrumentations(config2, instruments, blockInstruments, rootInstruments) {
+  const enableAll = instruments != null && instruments.has("__all__" /* ALL */);
   const resolvedRootNames = resolveRootInstrumentNames(
     rootInstruments,
-    blockInstruments2
+    blockInstruments
   );
   const instrumentModules = {};
   const customInstrumentModules = {
@@ -9872,7 +10100,7 @@ function initInstrumentations(config2, instruments2, blockInstruments2, rootInst
     langgraph: false,
     googleGenAI: false,
     anthropic: false};
-  const resolved = enableAll ? new Set(Object.values(NetraInstruments).filter((v) => v !== "__all__" /* ALL */)) : instruments2 && instruments2.size > 0 ? instruments2 : DEFAULT_INSTRUMENTS;
+  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;
   instrumentModules.llamaIndex = false;
@@ -9919,21 +10147,21 @@ function initInstrumentations(config2, instruments2, blockInstruments2, rootInst
   if (resolved.has("anthropic" /* ANTHROPIC */)) {
     customInstrumentModules.anthropic = true;
   }
-  if (blockInstruments2 && blockInstruments2.size > 0) {
-    const blockAll = blockInstruments2.has("__all__" /* ALL */);
-    if (blockAll || blockInstruments2.has("openai" /* OPENAI */)) customInstrumentModules.openai = false;
-    if (blockAll || blockInstruments2.has("groq" /* GROQ */)) customInstrumentModules.groq = false;
-    if (blockAll || blockInstruments2.has("mistral_ai" /* MISTRAL */)) customInstrumentModules.mistral = false;
-    if (blockAll || blockInstruments2.has("langgraph" /* LANGGRAPH */)) customInstrumentModules.langgraph = false;
-    if (blockAll || blockInstruments2.has("google_genai" /* GOOGLE_GENERATIVE_AI */)) customInstrumentModules.googleGenAI = false;
-    if (blockAll || blockInstruments2.has("anthropic" /* ANTHROPIC */)) customInstrumentModules.anthropic = false;
-    if (blockAll || blockInstruments2.has("vertexai" /* VERTEX_AI */)) instrumentModules.google_vertexai = false;
-    if (blockAll || blockInstruments2.has("langchain" /* LANGCHAIN */)) instrumentModules.langchain = false;
-    if (blockAll || blockInstruments2.has("llama_index" /* LLAMA_INDEX */)) instrumentModules.llamaIndex = false;
-    if (blockAll || blockInstruments2.has("pinecone" /* PINECONE */)) instrumentModules.pinecone = false;
-    if (blockAll || blockInstruments2.has("qdrant" /* QDRANT */)) instrumentModules.qdrant = false;
-    if (blockAll || blockInstruments2.has("chromadb" /* CHROMADB */)) instrumentModules.chromadb = false;
-    if (blockAll || blockInstruments2.has("together" /* TOGETHER */)) instrumentModules.together = false;
+  if (blockInstruments && blockInstruments.size > 0) {
+    const blockAll = blockInstruments.has("__all__" /* ALL */);
+    if (blockAll || blockInstruments.has("openai" /* OPENAI */)) customInstrumentModules.openai = false;
+    if (blockAll || blockInstruments.has("groq" /* GROQ */)) customInstrumentModules.groq = false;
+    if (blockAll || blockInstruments.has("mistral_ai" /* MISTRAL */)) customInstrumentModules.mistral = false;
+    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("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;
+    if (blockAll || blockInstruments.has("pinecone" /* PINECONE */)) instrumentModules.pinecone = false;
+    if (blockAll || blockInstruments.has("qdrant" /* QDRANT */)) instrumentModules.qdrant = false;
+    if (blockAll || blockInstruments.has("chromadb" /* CHROMADB */)) instrumentModules.chromadb = false;
+    if (blockAll || blockInstruments.has("together" /* TOGETHER */)) instrumentModules.together = false;
   }
   config2.setTraceloopEnv();
   Logger.debug("Netra SDK Configuration:");
@@ -9990,16 +10218,17 @@ function initInstrumentations(config2, instruments2, blockInstruments2, rootInst
   instrumentationsReady = initCustomInstrumentationsAsync(
     config2,
     tracerProvider,
-    customInstrumentModules
+    customInstrumentModules,
+    blockInstruments
   );
-  initOpenTelemetryInstrumentations(config2, resolved, blockInstruments2);
+  initOpenTelemetryInstrumentations(config2, resolved, blockInstruments);
   return effectiveProvider;
 }
-function isBlocked(instrument, blockInstruments2) {
-  if (!blockInstruments2 || blockInstruments2.size === 0) return false;
-  return blockInstruments2.has("__all__" /* ALL */) || blockInstruments2.has(instrument);
+function isBlocked(instrument, blockInstruments) {
+  if (!blockInstruments || blockInstruments.size === 0) return false;
+  return blockInstruments.has("__all__" /* ALL */) || blockInstruments.has(instrument);
 }
-async function initCustomInstrumentationsAsync(config2, tracerProvider, customInstrumentModules) {
+async function initCustomInstrumentationsAsync(config2, tracerProvider, customInstrumentModules, blockInstruments) {
   if (customInstrumentModules.mistral) {
     try {
       await mistralAIInstrumentor.instrumentAsync({ tracerProvider });
@@ -10057,21 +10286,21 @@ async function initCustomInstrumentationsAsync(config2, tracerProvider, customIn
     }
   }
 }
-function initOpenTelemetryInstrumentations(config2, resolved, blockInstruments2) {
+function initOpenTelemetryInstrumentations(config2, resolved, blockInstruments) {
   let netraHost = "";
   try {
     if (config2.otlpEndpoint) {
       netraHost = new URL(config2.otlpEndpoint).host;
     }
   } catch {
-    console.debug(`OTEL_NODE_EXCLUDED_URLS: malformed otlpEndpoint '${config2.otlpEndpoint}', skipping host-based exclusion`);
+    Logger.debug(`OTEL_NODE_EXCLUDED_URLS: malformed otlpEndpoint '${config2.otlpEndpoint}', skipping host-based exclusion`);
   }
   const excludeRegexes = (process.env.OTEL_NODE_EXCLUDED_URLS || "").split(",").map((s) => s.trim()).filter(Boolean).map((pattern) => {
     try {
       return new RegExp(pattern);
     } catch {
       if (config2.debugMode) {
-        console.debug(
+        Logger.debug(
           `Invalid OTEL_NODE_EXCLUDED_URLS pattern skipped: ${pattern}`
         );
       }
@@ -10082,7 +10311,7 @@ function initOpenTelemetryInstrumentations(config2, resolved, blockInstruments2)
     if (netraHost && url.includes(netraHost)) return true;
     return excludeRegexes.some((re) => re.test(url));
   };
-  if (!isBlocked("http" /* HTTP */, blockInstruments2) && (resolved.has("http" /* HTTP */) || resolved.has("express" /* EXPRESS */))) {
+  if (!isBlocked("http" /* HTTP */, blockInstruments) && (resolved.has("http" /* HTTP */) || resolved.has("express" /* EXPRESS */))) {
     try {
       const { HttpInstrumentation } = require3("@opentelemetry/instrumentation-http");
       const { registerInstrumentations } = require3("@opentelemetry/instrumentation");
@@ -10100,7 +10329,7 @@ function initOpenTelemetryInstrumentations(config2, resolved, blockInstruments2)
       Logger.debug("HTTP instrumentation not available:", e);
     }
   }
-  const fetchEnabled = !blockInstruments2?.has(NetraInstruments.FETCH) && (!instruments || instruments.has(NetraInstruments.FETCH));
+  const fetchEnabled = !isBlocked("http" /* HTTP */, blockInstruments) && resolved.has("http" /* HTTP */);
   if (fetchEnabled) {
     try {
       const { UndiciInstrumentation } = require3("@opentelemetry/instrumentation-undici");
@@ -10113,29 +10342,29 @@ function initOpenTelemetryInstrumentations(config2, resolved, blockInstruments2)
       });
       registerInstrumentations({ instrumentations: [_undiciInstrumentation] });
       if (config2.debugMode) {
-        console.debug("Undici/fetch instrumentation enabled");
+        Logger.debug("Undici/fetch instrumentation enabled");
       }
     } catch (e) {
       if (config2.debugMode) {
-        console.debug("Undici/fetch instrumentation not available:", e);
+        Logger.debug("Undici/fetch instrumentation not available:", e);
       }
     }
   }
-  if (!isBlocked("prisma" /* PRISMA */, blockInstruments2) && resolved.has("prisma" /* PRISMA */) && isPackageInstalled("@prisma/instrumentation")) {
+  if (!isBlocked("prisma" /* PRISMA */, blockInstruments) && resolved.has("prisma" /* PRISMA */) && isPackageInstalled("@prisma/instrumentation")) {
     try {
       const { PrismaInstrumentation } = require3("@prisma/instrumentation");
     } catch (e) {
       Logger.debug("Prisma instrumentation not available:", e);
     }
   }
-  if (!isBlocked("typeorm" /* TYPEORM */, blockInstruments2) && resolved.has("typeorm" /* TYPEORM */) && isPackageInstalled("typeorm")) {
+  if (!isBlocked("typeorm" /* TYPEORM */, blockInstruments) && resolved.has("typeorm" /* TYPEORM */) && isPackageInstalled("typeorm")) {
     typeORMInstrumentor.instrument().then(() => {
       Logger.debug("TypeORM instrumentation successfully initialized");
     }).catch((e) => {
       Logger.debug("TypeORM instrumentation error:", e);
     });
   }
-  if (!isBlocked("express" /* EXPRESS */, blockInstruments2) && resolved.has("express" /* EXPRESS */)) {
+  if (!isBlocked("express" /* EXPRESS */, blockInstruments) && resolved.has("express" /* EXPRESS */)) {
     try {
       const { ExpressInstrumentation } = require3("@opentelemetry/instrumentation-express");
       const { registerInstrumentations } = require3("@opentelemetry/instrumentation");
@@ -10282,19 +10511,19 @@ async function uninstrumentAll() {
     if (_httpInstrumentation) {
       _httpInstrumentation.disable();
       _httpInstrumentation = null;
-      console.debug("HTTP instrumentation disabled");
+      Logger.debug("HTTP instrumentation disabled");
     }
   } catch (e) {
-    console.debug("Failed to uninstrument HTTP:", e);
+    Logger.debug("Failed to uninstrument HTTP:", e);
   }
   try {
     if (_undiciInstrumentation) {
       _undiciInstrumentation.disable();
       _undiciInstrumentation = null;
-      console.debug("Undici/fetch instrumentation disabled");
+      Logger.debug("Undici/fetch instrumentation disabled");
     }
   } catch (e) {
-    console.debug("Failed to uninstrument undici:", e);
+    Logger.debug("Failed to uninstrument undici:", e);
   }
 }
 var LOG_PREFIX = "netra.simulation";
@@ -10317,11 +10546,20 @@ var SimulationHttpClient = class {
     const headers = this._buildHeaders(config2);
     const timeout = this._getTimeout();
     try {
-      return axios.create({
+      const instance = axios.create({
         baseURL,
         headers,
         timeout
       });
+      instance.interceptors.request.use(
+        (config3) => {
+          const traceHeaders = injectTraceContextHeaders({});
+          Object.assign(config3.headers, traceHeaders);
+          return config3;
+        },
+        (error) => Promise.reject(error)
+      );
+      return instance;
     } catch (error) {
       Logger.error(`${LOG_PREFIX}: Failed to create HTTP client:`, error);
       return null;
@@ -10367,7 +10605,7 @@ var SimulationHttpClient = class {
   /**
    * Create a new simulation run for the specified dataset.
    */
-  async createRun(name, datasetId, context14) {
+  async createRun(name, datasetId, context16) {
     if (!this.client) {
       Logger.error(`${LOG_PREFIX}: Client not initialized`);
       return null;
@@ -10377,7 +10615,7 @@ var SimulationHttpClient = class {
       const payload = {
         name,
         datasetId,
-        context: context14 || {}
+        context: context16 || {}
       };
       const response = await this.client.post(url, payload);
       const data = response.data;
@@ -10561,14 +10799,14 @@ var Simulation = class {
       name,
       datasetId,
       task: task2,
-      context: context14,
+      context: context16,
       maxConcurrency = 5
     } = options;
     if (!validateSimulationInputs(datasetId, task2)) {
       return null;
     }
     const startTime = Date.now();
-    const runResult = await this._client.createRun(name, datasetId, context14);
+    const runResult = await this._client.createRun(name, datasetId, context16);
     if (!runResult) {
       return null;
     }
@@ -10680,24 +10918,23 @@ var Simulation = class {
     let turnId = initialTurnId;
     let sessionId = null;
     while (true) {
+      const span2 = new SpanWrapper(SPAN_NAME, {}, LOG_PREFIX3);
+      span2.start();
       try {
-        const span2 = new SpanWrapper(SPAN_NAME, {}, LOG_PREFIX3);
-        span2.start();
         const traceId = span2.getCurrentSpan()?.spanContext().traceId ?? "";
-        const [responseMessage, taskSessionId] = await executeTask2(
-          task2,
-          message,
-          sessionId
+        const [responseMessage, taskSessionId] = await span2.withActive(
+          () => executeTask2(task2, message, sessionId)
         );
         if (taskSessionId) {
           sessionId = taskSessionId;
         }
-        span2.end();
-        const response = await this._client.triggerConversation(
-          responseMessage,
-          turnId,
-          sessionId || "",
-          traceId
+        const response = await span2.withActive(
+          () => this._client.triggerConversation(
+            responseMessage,
+            turnId,
+            sessionId || "",
+            traceId
+          )
         );
         if (response === null) {
           const errorMsg = "Failed to get conversation response";
@@ -10732,6 +10969,8 @@ var Simulation = class {
           error: errorMsg,
           turnId
         };
+      } finally {
+        span2.end();
       }
     }
   }
@@ -10745,20 +10984,33 @@ var Tracer17 = class {
     }
   }
 };
-function serializeValue2(value) {
+function safeStringify3(value, maxLen = 1e3) {
+  const seen = /* @__PURE__ */ new WeakSet();
   try {
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null || value === void 0) {
-      return String(value);
-    } else if (Array.isArray(value) || typeof value === "object") {
-      return JSON.stringify(value).substring(0, 1e3);
-    } else {
-      return String(value).substring(0, 1e3);
-    }
-  } catch (e) {
-    Logger.warn("serializeValue: serialization failed, falling back to type name:", e);
-    return String(typeof value);
+    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"]) {
@@ -10772,12 +11024,8 @@ function spanHasOutput(span2) {
 }
 function addInputAttributes(span2, args, entityType) {
   span2.setAttribute(`${Config.LIBRARY_NAME}.entity.type`, entityType);
-  try {
-    if (args.length > 0) {
-      span2.setAttribute("input", JSON.stringify(args));
-    }
-  } catch (e) {
-    span2.setAttribute("input_error", String(e));
+  if (args.length > 0) {
+    span2.setAttribute("input", safeStringify3(args));
   }
 }
 function addOutputAttributes(span2, result) {
@@ -11269,6 +11517,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, openaiAgentsInstrumentor, span, task, workflow };
+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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map