netra-sdk 1.1.0-beta.1 → 1.2.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;
       }
@@ -10065,14 +10293,14 @@ function initOpenTelemetryInstrumentations(config2, resolved, blockInstruments)
       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}`
         );
       }
@@ -10114,11 +10342,11 @@ function initOpenTelemetryInstrumentations(config2, resolved, blockInstruments)
       });
       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);
       }
     }
   }
@@ -10283,22 +10511,145 @@ 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);
   }
 }
+
+// src/simulation/task.ts
+var BaseTask = class {
+};
+
+// src/simulation/utils.ts
 var LOG_PREFIX = "netra.simulation";
+var DEFAULT_FILE_DOWNLOAD_TIMEOUT_S = 30;
+var MAX_FILE_DOWNLOAD_WORKERS = 8;
+var _cachedFileDownloadTimeoutMs = null;
+function validateSimulationInputs(datasetId, task2) {
+  if (!datasetId) {
+    Logger.error(`${LOG_PREFIX}: dataset_id is required`);
+    return false;
+  }
+  if (!(task2 instanceof BaseTask)) {
+    Logger.error(`${LOG_PREFIX}: task must be a BaseTask instance`);
+    return false;
+  }
+  return true;
+}
+function _getFileDownloadTimeout() {
+  if (_cachedFileDownloadTimeoutMs !== null) {
+    return _cachedFileDownloadTimeoutMs;
+  }
+  const envVal = process.env.NETRA_SIMULATION_FILE_DOWNLOAD_TIMEOUT;
+  if (envVal) {
+    const parsed = parseFloat(envVal);
+    if (!isNaN(parsed) && parsed > 0) {
+      _cachedFileDownloadTimeoutMs = parsed * 1e3;
+      return _cachedFileDownloadTimeoutMs;
+    }
+    Logger.warn(
+      `${LOG_PREFIX}: Invalid file download timeout '${envVal}', using default ${DEFAULT_FILE_DOWNLOAD_TIMEOUT_S}s`
+    );
+  }
+  _cachedFileDownloadTimeoutMs = DEFAULT_FILE_DOWNLOAD_TIMEOUT_S * 1e3;
+  return _cachedFileDownloadTimeoutMs;
+}
+async function _downloadSingleFile(fileData, timeoutMs, signal) {
+  try {
+    const response = await axios.get(fileData.downloadUrl, {
+      responseType: "arraybuffer",
+      timeout: timeoutMs,
+      signal
+    });
+    const encoded = Buffer.from(response.data).toString("base64");
+    return {
+      fileName: fileData.fileName,
+      contentType: fileData.contentType,
+      description: fileData.description,
+      data: encoded
+    };
+  } catch (error) {
+    if (axios.isCancel(error)) {
+      throw new Error(
+        `Download of '${fileData.fileName}' was cancelled`
+      );
+    }
+    const status = axios.isAxiosError(error) ? error.response?.status : void 0;
+    const reason = status ? `HTTP ${status}` : error instanceof Error ? error.message : String(error);
+    Logger.error(
+      `${LOG_PREFIX}: Failed to download file '${fileData.fileName}': ${reason}`
+    );
+    throw new Error(
+      `Failed to download file '${fileData.fileName}': ${reason}`
+    );
+  }
+}
+function parseFiles(rawFiles) {
+  if (!rawFiles) {
+    return [];
+  }
+  const parsed = [];
+  for (const entry of rawFiles) {
+    const fileName = entry.fileName || "";
+    const downloadUrl = entry.downloadUrl || "";
+    if (!fileName || !downloadUrl) {
+      Logger.warn(
+        `${LOG_PREFIX}: Skipping malformed file attachment (missing fileName or downloadUrl)`
+      );
+      continue;
+    }
+    parsed.push({
+      fileName,
+      contentType: entry.contentType || "",
+      description: entry.description || void 0,
+      downloadUrl
+    });
+  }
+  return parsed;
+}
+async function processFiles(files) {
+  if (!files || files.length === 0) {
+    return null;
+  }
+  const timeoutMs = _getFileDownloadTimeout();
+  const limit = pLimit(MAX_FILE_DOWNLOAD_WORKERS);
+  const controller = new AbortController();
+  const downloadPromises = files.map(
+    (file) => limit(() => _downloadSingleFile(file, timeoutMs, controller.signal))
+  );
+  try {
+    return await Promise.all(downloadPromises);
+  } catch (error) {
+    controller.abort();
+    limit.clearQueue();
+    throw error;
+  }
+}
+async function executeTask2(task2, message, sessionId, rawFiles) {
+  const processedFiles = rawFiles && rawFiles.length > 0 ? await processFiles(rawFiles) : null;
+  const result = task2.run(message, sessionId, processedFiles);
+  const resolvedResult = result instanceof Promise ? await result : result;
+  if (typeof resolvedResult === "object" && resolvedResult !== null && "message" in resolvedResult && "sessionId" in resolvedResult) {
+    return [resolvedResult.message, resolvedResult.sessionId];
+  }
+  throw new Error(
+    `Task must return TaskResult, got ${typeof resolvedResult}`
+  );
+}
+
+// src/simulation/client.ts
+var LOG_PREFIX2 = "netra.simulation";
 var DEFAULT_TIMEOUT = 1e4;
 var SimulationHttpClient = class {
   constructor(config2) {
@@ -10311,20 +10662,29 @@ var SimulationHttpClient = class {
   _createClient(config2) {
     const endpoint = (config2.otlpEndpoint || "").trim();
     if (!endpoint) {
-      Logger.error(`${LOG_PREFIX}: NETRA_OTLP_ENDPOINT is required`);
+      Logger.error(`${LOG_PREFIX2}: NETRA_OTLP_ENDPOINT is required`);
       return null;
     }
     const baseURL = this._resolveBaseUrl(endpoint);
     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);
+      Logger.error(`${LOG_PREFIX2}: Failed to create HTTP client:`, error);
       return null;
     }
   }
@@ -10359,7 +10719,7 @@ var SimulationHttpClient = class {
     const timeout = parseFloat(timeoutStr);
     if (isNaN(timeout)) {
       Logger.warn(
-        `${LOG_PREFIX}: Invalid timeout '${timeoutStr}', using default ${DEFAULT_TIMEOUT}ms`
+        `${LOG_PREFIX2}: Invalid timeout '${timeoutStr}', using default ${DEFAULT_TIMEOUT}ms`
       );
       return DEFAULT_TIMEOUT;
     }
@@ -10368,9 +10728,9 @@ 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`);
+      Logger.error(`${LOG_PREFIX2}: Client not initialized`);
       return null;
     }
     try {
@@ -10378,14 +10738,14 @@ var SimulationHttpClient = class {
       const payload = {
         name,
         datasetId,
-        context: context14 || {}
+        context: context16 || {}
       };
       const response = await this.client.post(url, payload);
       const data = response.data;
       const responseData = data.data || {};
       const userMessages = responseData.userMessages || [];
       if (userMessages.length === 0) {
-        Logger.warn(`${LOG_PREFIX}: No user messages returned from create_run`);
+        Logger.warn(`${LOG_PREFIX2}: No user messages returned from create_run`);
         return null;
       }
       const runId = responseData.id || "";
@@ -10393,7 +10753,8 @@ var SimulationHttpClient = class {
         (msg) => ({
           runItemId: msg.testRunItemId || "",
           message: msg.userMessage || "",
-          turnId: msg.turnId || ""
+          turnId: msg.turnId || "",
+          files: parseFiles(msg.attachments)
         })
       );
       return {
@@ -10402,7 +10763,7 @@ var SimulationHttpClient = class {
       };
     } catch (error) {
       const errorMsg = this._extractErrorMessage(error);
-      Logger.error(`${LOG_PREFIX}: Failed to create simulation run:`, errorMsg);
+      Logger.error(`${LOG_PREFIX2}: Failed to create simulation run:`, errorMsg);
       return null;
     }
   }
@@ -10411,7 +10772,7 @@ var SimulationHttpClient = class {
    */
   async triggerConversation(message, turnId, sessionId, traceId) {
     if (!this.client) {
-      Logger.error(`${LOG_PREFIX}: Client not initialized`);
+      Logger.error(`${LOG_PREFIX2}: Client not initialized`);
       return null;
     }
     try {
@@ -10434,7 +10795,7 @@ var SimulationHttpClient = class {
       }
       const userMessages = responseData.userMessages || [];
       if (userMessages.length === 0) {
-        Logger.warn(`${LOG_PREFIX}: No user messages in continue response`);
+        Logger.warn(`${LOG_PREFIX2}: No user messages in continue response`);
         return null;
       }
       const nextMsg = userMessages[0];
@@ -10442,11 +10803,12 @@ var SimulationHttpClient = class {
         decision,
         nextTurnId: nextMsg.turnId || "",
         nextUserMessage: nextMsg.userMessage || "",
-        nextRunItemId: nextMsg.testRunItemId || ""
+        nextRunItemId: nextMsg.testRunItemId || "",
+        nextFiles: parseFiles(nextMsg.attachments)
       };
     } catch (error) {
       const errorMsg = this._extractErrorMessage(error);
-      Logger.error(`${LOG_PREFIX}: Failed to trigger conversation:`, errorMsg);
+      Logger.error(`${LOG_PREFIX2}: Failed to trigger conversation:`, errorMsg);
       return null;
     }
   }
@@ -10455,17 +10817,17 @@ var SimulationHttpClient = class {
    */
   async reportFailure(runId, runItemId, error) {
     if (!this.client) {
-      Logger.error(`${LOG_PREFIX}: Client not initialized`);
+      Logger.error(`${LOG_PREFIX2}: Client not initialized`);
       return;
     }
     try {
       const url = `/evaluations/run/${runId}/item/${runItemId}/status`;
       const payload = { status: "failed", failureReason: error };
       await this.client.patch(url, payload);
-      Logger.info(`${LOG_PREFIX}: Reported failure - ${error}`);
+      Logger.info(`${LOG_PREFIX2}: Reported failure - ${error}`);
     } catch (err) {
       const errorMsg = this._extractErrorMessage(err);
-      Logger.error(`${LOG_PREFIX}: Failed to report failure:`, errorMsg);
+      Logger.error(`${LOG_PREFIX2}: Failed to report failure:`, errorMsg);
     }
   }
   /**
@@ -10474,7 +10836,7 @@ var SimulationHttpClient = class {
   async postRunStatus(runId, status) {
     if (!this.client) {
       Logger.error(
-        `${LOG_PREFIX}: Client not initialized; cannot post run status`
+        `${LOG_PREFIX2}: Client not initialized; cannot post run status`
       );
       return { success: false };
     }
@@ -10484,14 +10846,14 @@ var SimulationHttpClient = class {
       const response = await this.client.post(url, payload);
       const data = response.data;
       if (data && typeof data === "object" && "data" in data) {
-        Logger.info(`${LOG_PREFIX}: Completed test run successfully`);
+        Logger.info(`${LOG_PREFIX2}: Completed test run successfully`);
         return data.data || {};
       }
       return data;
     } catch (error) {
       const errorMsg = this._extractErrorMessage(error);
       Logger.error(
-        `${LOG_PREFIX}: Failed to post run status for run '${runId}':`,
+        `${LOG_PREFIX2}: Failed to post run status for run '${runId}':`,
         errorMsg
       );
       return { success: false };
@@ -10515,34 +10877,6 @@ var SimulationHttpClient = class {
   }
 };
 
-// src/simulation/task.ts
-var BaseTask = class {
-};
-
-// src/simulation/utils.ts
-var LOG_PREFIX2 = "netra.simulation";
-function validateSimulationInputs(datasetId, task2) {
-  if (!datasetId) {
-    Logger.error(`${LOG_PREFIX2}: dataset_id is required`);
-    return false;
-  }
-  if (!(task2 instanceof BaseTask)) {
-    Logger.error(`${LOG_PREFIX2}: task must be a BaseTask instance`);
-    return false;
-  }
-  return true;
-}
-async function executeTask2(task2, message, sessionId) {
-  const result = task2.run(message, sessionId);
-  const resolvedResult = result instanceof Promise ? await result : result;
-  if (typeof resolvedResult === "object" && resolvedResult !== null && "message" in resolvedResult && "sessionId" in resolvedResult) {
-    return [resolvedResult.message, resolvedResult.sessionId];
-  }
-  throw new Error(
-    `Task must return TaskResult, got ${typeof resolvedResult}`
-  );
-}
-
 // src/simulation/api.ts
 var LOG_PREFIX3 = "netra.simulation";
 var SPAN_NAME = "Netra.Simulation.TestRun";
@@ -10562,14 +10896,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;
     }
@@ -10676,29 +11010,29 @@ var Simulation = class {
    * Execute a multi-turn conversation for a single simulation item.
    */
   async _executeConversation(runId, runItem, task2) {
-    const { runItemId, message: initialMessage, turnId: initialTurnId } = runItem;
+    const { runItemId, message: initialMessage, turnId: initialTurnId, files: initialFiles } = runItem;
     let message = initialMessage;
     let turnId = initialTurnId;
     let sessionId = null;
+    let rawFiles = initialFiles ?? [];
     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, rawFiles)
         );
         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";
@@ -10721,6 +11055,7 @@ var Simulation = class {
         }
         message = response.nextUserMessage;
         turnId = response.nextTurnId;
+        rawFiles = response.nextFiles || [];
       } catch (error) {
         const errorMsg = error instanceof Error ? error.message : String(error);
         Logger.error(
@@ -10733,6 +11068,8 @@ var Simulation = class {
           error: errorMsg,
           turnId
         };
+      } finally {
+        span2.end();
       }
     }
   }
@@ -11279,6 +11616,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