netra-sdk 1.1.0-beta.1 → 1.2.0

package/dist/index.cjs

@@ -2462,14 +2462,14 @@ var require_otel = __commonJS({
       getActiveSpan() {
         return void 0;
       }
-      setSpan(context15, _span) {
-        return context15;
+      setSpan(context17, _span) {
+        return context17;
       }
       getSpan(_context) {
         return void 0;
       }
-      setSpanContext(context15, _spanContext) {
-        return context15;
+      setSpanContext(context17, _spanContext) {
+        return context17;
       }
       getTracerProvider() {
         return void 0;
@@ -3036,17 +3036,17 @@ var require_p_retry = __commonJS({
       }
       const retriesLeft = Number.isFinite(options.retries) ? Math.max(0, options.retries - retriesConsumed) : options.retries;
       const maxRetryTime = options.maxRetryTime ?? Number.POSITIVE_INFINITY;
-      const context15 = Object.freeze({
+      const context17 = Object.freeze({
         error: normalizedError,
         attemptNumber,
         retriesLeft,
         retriesConsumed
       });
-      await options.onFailedAttempt(context15);
+      await options.onFailedAttempt(context17);
       if (calculateRemainingTime(startTime, maxRetryTime) <= 0) {
         throw normalizedError;
       }
-      const consumeRetry = await options.shouldConsumeRetry(context15);
+      const consumeRetry = await options.shouldConsumeRetry(context17);
       const remainingTime = calculateRemainingTime(startTime, maxRetryTime);
       if (remainingTime <= 0 || retriesLeft <= 0) {
         throw normalizedError;
@@ -3058,7 +3058,7 @@ var require_p_retry = __commonJS({
         options.signal?.throwIfAborted();
         return false;
       }
-      if (!await options.shouldRetry(context15)) {
+      if (!await options.shouldRetry(context17)) {
         throw normalizedError;
       }
       if (!consumeRetry) {
@@ -3166,16 +3166,16 @@ var require_eventemitter3 = __commonJS({
       Events.prototype = /* @__PURE__ */ Object.create(null);
       if (!new Events().__proto__) prefix = false;
     }
-    function EE(fn, context15, once) {
+    function EE(fn, context17, once) {
       this.fn = fn;
-      this.context = context15;
+      this.context = context17;
       this.once = once || false;
     }
-    function addListener(emitter, event, fn, context15, once) {
+    function addListener(emitter, event, fn, context17, once) {
       if (typeof fn !== "function") {
         throw new TypeError("The listener must be a function");
       }
-      var listener = new EE(fn, context15 || emitter, once), evt = prefix ? prefix + event : event;
+      var listener = new EE(fn, context17 || emitter, once), evt = prefix ? prefix + event : event;
       if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
       else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
       else emitter._events[evt] = [emitter._events[evt], listener];
@@ -3266,13 +3266,13 @@ var require_eventemitter3 = __commonJS({
       }
       return true;
     };
-    EventEmitter.prototype.on = function on(event, fn, context15) {
-      return addListener(this, event, fn, context15, false);
+    EventEmitter.prototype.on = function on(event, fn, context17) {
+      return addListener(this, event, fn, context17, false);
     };
-    EventEmitter.prototype.once = function once(event, fn, context15) {
-      return addListener(this, event, fn, context15, true);
+    EventEmitter.prototype.once = function once(event, fn, context17) {
+      return addListener(this, event, fn, context17, true);
     };
-    EventEmitter.prototype.removeListener = function removeListener(event, fn, context15, once) {
+    EventEmitter.prototype.removeListener = function removeListener(event, fn, context17, once) {
       var evt = prefix ? prefix + event : event;
       if (!this._events[evt]) return this;
       if (!fn) {
@@ -3281,12 +3281,12 @@ var require_eventemitter3 = __commonJS({
       }
       var listeners = this._events[evt];
       if (listeners.fn) {
-        if (listeners.fn === fn && (!once || listeners.once) && (!context15 || listeners.context === context15)) {
+        if (listeners.fn === fn && (!once || listeners.once) && (!context17 || listeners.context === context17)) {
           clearEvent(this, evt);
         }
       } else {
         for (var i = 0, events = [], length = listeners.length; i < length; i++) {
-          if (listeners[i].fn !== fn || once && !listeners[i].once || context15 && listeners[i].context !== context15) {
+          if (listeners[i].fn !== fn || once && !listeners[i].once || context17 && listeners[i].context !== context17) {
             events.push(listeners[i]);
           }
         }
@@ -5845,7 +5845,7 @@ var require_error = __commonJS({
       }
     };
     exports$1.LangSmithConflictError = LangSmithConflictError;
-    async function raiseForStatus(response, context15, consumeOnSuccess) {
+    async function raiseForStatus(response, context17, consumeOnSuccess) {
       let errorBody;
       if (response.ok) {
         if (consumeOnSuccess) {
@@ -5873,7 +5873,7 @@ var require_error = __commonJS({
           errorBody = "";
         }
       }
-      const fullMessage = `Failed to ${context15}. Received status [${response.status}]: ${response.statusText}. Message: ${errorBody}`;
+      const fullMessage = `Failed to ${context17}. Received status [${response.status}]: ${response.statusText}. Message: ${errorBody}`;
       if (response.status === 409) {
         throw new LangSmithConflictError(fullMessage);
       }
@@ -7226,7 +7226,7 @@ var require_client = __commonJS({
         });
         return stream;
       }
-      async _sendMultipartRequest(parts, context15, options) {
+      async _sendMultipartRequest(parts, context17, options) {
         const boundary = "----LangSmithFormBoundary" + Math.random().toString(36).slice(2);
         const isNodeFetch = (0, fetch_js_1._globalFetchImplementationIsNodeFetch)();
         const buildBuffered = () => this._createNodeFetchBody(parts, boundary);
@@ -7268,14 +7268,14 @@ var require_client = __commonJS({
             res = await sendWithRetry(buildBuffered);
           }
           if ((!this.multipartStreamingDisabled || streamedAttempt) && res.status === 422 && (options?.apiUrl ?? this.apiUrl) !== DEFAULT_API_URL) {
-            console.warn(`Streaming multipart upload to ${options?.apiUrl ?? this.apiUrl}/runs/multipart failed. This usually means the host does not support chunked uploads. Retrying with a buffered upload for operation "${context15}".`);
+            console.warn(`Streaming multipart upload to ${options?.apiUrl ?? this.apiUrl}/runs/multipart failed. This usually means the host does not support chunked uploads. Retrying with a buffered upload for operation "${context17}".`);
             this.multipartStreamingDisabled = true;
             res = await sendWithRetry(buildBuffered);
           }
         } catch (e) {
           console.warn(`${e.message.trim()}
 
-Context: ${context15}`);
+Context: ${context17}`);
         }
       }
       async updateRun(runId, run, options) {
@@ -14510,6 +14510,37 @@ var Logger = class {
   }
 };
 Logger._debugMode = false;
+function injectTraceContextHeaders(headers) {
+  const carrier = { ...headers };
+  try {
+    api.propagation.inject(api.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 api.propagation.extract(api.context.active(), carrier);
+}
+function runWithExtractedContext(headers, fn) {
+  const extractedCtx = extractContextFromHeaders(headers);
+  return api.context.with(extractedCtx, fn);
+}
+function netraExpressMiddleware() {
+  return (req, _res, next) => {
+    const extractedCtx = extractContextFromHeaders(req.headers);
+    api.context.with(extractedCtx, next);
+  };
+}
 
 // src/api/http-client.ts
 var NetraHttpClient = class {
@@ -14583,7 +14614,7 @@ var NetraHttpClient = class {
       );
       const response = await fetch(url.toString(), {
         method: "GET",
-        headers: this.headers,
+        headers: injectTraceContextHeaders(this.headers),
         signal: controller.signal
       });
       clearTimeout(timeoutId);
@@ -14612,7 +14643,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
       });
@@ -16165,13 +16196,13 @@ async function runSingleEvaluator(params) {
   if (config2) {
     expectedName = config2.name;
   }
-  const context15 = {
+  const context17 = {
     input: itemInput,
     taskOutput,
     expectedOutput,
     metadata
   };
-  let result = evaluator.evaluate(context15);
+  let result = evaluator.evaluate(context17);
   if (result instanceof Promise) {
     result = await result;
   }
@@ -16525,10 +16556,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);
@@ -18142,6 +18177,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) {
@@ -18466,7 +18505,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({
@@ -18479,7 +18518,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);
@@ -18608,7 +18647,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: "",
@@ -18618,6 +18657,7 @@ var MessageStreamWrapper = class {
     defineHidden(this, "messageStream", messageStream);
     defineHidden(this, "startTime", startTime);
     defineHidden(this, "requestKwargs", requestKwargs);
+    defineHidden(this, "spanContext", spanContext || api.trace.setSpan(api.context.active(), span2));
     return new Proxy(this, {
       get(target, prop, receiver) {
         if (prop === "toJSON") {
@@ -18694,6 +18734,9 @@ var MessageStreamWrapper = class {
       throw err;
     }
   }
+  getSpanContext() {
+    return this.spanContext;
+  }
   processEventData(eventType, data) {
     switch (eventType) {
       case "message":
@@ -18738,10 +18781,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": {
@@ -18749,11 +18802,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 = {
@@ -18796,7 +18865,7 @@ var MessageStreamWrapper = class {
   }
 };
 var AsyncStreamingWrapper = class {
-  constructor(span2, response, startTime, requestKwargs) {
+  constructor(span2, response, startTime, requestKwargs, spanContext) {
     this.iterator = null;
     this.completeResponse = {
       choices: [],
@@ -18806,6 +18875,7 @@ var AsyncStreamingWrapper = class {
     defineHidden(this, "response", response);
     defineHidden(this, "startTime", startTime);
     defineHidden(this, "requestKwargs", requestKwargs);
+    defineHidden(this, "spanContext", spanContext || api.trace.setSpan(api.context.active(), span2));
   }
   toJSON() {
     return this.completeResponse;
@@ -18824,7 +18894,7 @@ var AsyncStreamingWrapper = class {
           throw new Error("Response is not iterable");
         }
       }
-      const result = await this.iterator.next();
+      const result = await api.context.with(this.spanContext, () => this.iterator.next());
       if (result.done) {
         this.finalizeSpan(api.SpanStatusCode.OK);
         return result;
@@ -18850,10 +18920,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": {
@@ -18863,11 +18943,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 || {};
@@ -18908,19 +19004,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 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+    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() {
@@ -18934,8 +19040,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 {
@@ -18952,9 +19058,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;
   }
@@ -18963,27 +19071,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(
@@ -18993,11 +19099,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 = api.context.active();
           const span2 = tracer.startSpan("anthropic.stream", {
             kind: api.SpanKind.CLIENT,
             attributes: {
@@ -19005,17 +19112,18 @@ var NetraAnthropicInstrumentor = class {
               "llm.streaming": true,
               "llm.operation": "stream"
             }
-          });
+          }, currentContext);
+          const spanContext = api.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 = api.context.with(spanContext, () => original(...args));
+            return new MessageStreamWrapper(span2, messageStream, startTime, kwargs, spanContext);
           } finally {
             if (originalCreate) {
               this.create = instrumentedCreate;
@@ -19025,7 +19133,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) {
@@ -19043,17 +19151,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(
@@ -19063,7 +19166,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) {
@@ -19081,17 +19184,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(
@@ -19101,7 +19199,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) {
@@ -19119,25 +19217,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;
       }
@@ -19145,12 +19243,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;
       }
@@ -19172,6 +19268,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()) {
@@ -19289,6 +19395,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(
@@ -19493,7 +19619,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("");
@@ -19551,12 +19677,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 = api.context.active();
       return tracer.startActiveSpan(
         spanName,
@@ -19634,8 +19764,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 = api.context.active();
       return tracer.startActiveSpan(
         spanName,
@@ -19774,25 +19906,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 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+    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() {
@@ -19806,16 +19988,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 {
@@ -19825,7 +20006,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;
   }
@@ -19837,7 +20018,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);
       });
@@ -19850,7 +20032,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;
   }
@@ -19862,8 +20044,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;
   }
   /**
@@ -19872,10 +20055,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"
         );
@@ -19897,14 +20080,22 @@ var NetraGoogleGenerativeAIInstrumentor = class {
         "embedContent",
         embeddingsWrapper(tracer)
       );
+      if (typeof GenerativeModel.prototype.startChat === "function") {
+        shimmer__default.default.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__default.default.unwrap(GenerativeModel.prototype, "generateContent");
       }
@@ -19914,6 +20105,9 @@ var NetraGoogleGenerativeAIInstrumentor = class {
       if (typeof GenerativeModel.prototype.embedContent === "function") {
         shimmer__default.default.unwrap(GenerativeModel.prototype, "embedContent");
       }
+      if (typeof GenerativeModel.prototype.startChat === "function") {
+        shimmer__default.default.unwrap(GenerativeModel.prototype, "startChat");
+      }
     } catch (error) {
       Logger.debug(`Failed to uninstrument Google GenAI: ${error}`);
     }
@@ -20277,19 +20471,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 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+    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() {
@@ -20300,16 +20504,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 {
@@ -20326,21 +20529,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);
       });
@@ -20360,7 +20565,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;
   }
@@ -20369,18 +20576,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;
@@ -20394,7 +20601,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) {
@@ -20409,10 +20616,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;
       }
@@ -21907,19 +22114,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 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+    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() {
@@ -21934,16 +22153,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 {
@@ -21960,11 +22178,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?"
@@ -21976,15 +22199,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);
       });
@@ -22004,11 +22227,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?"
@@ -22026,15 +22254,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;
   }
   /**
@@ -22072,14 +22300,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) {
@@ -22096,7 +22324,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) {
@@ -22117,14 +22345,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) {
@@ -22145,14 +22373,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) {
@@ -22169,7 +22397,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) {
@@ -22190,14 +22418,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) {
@@ -22214,7 +22442,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) {
@@ -22235,14 +22463,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;
       }
@@ -22250,10 +22478,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;
       }
@@ -22261,14 +22489,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;
       }
@@ -22276,14 +22504,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;
       }
@@ -24536,14 +24764,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}`
         );
       }
@@ -24585,11 +24813,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);
       }
     }
   }
@@ -24754,22 +24982,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__default.default.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__default.default.isCancel(error)) {
+      throw new Error(
+        `Download of '${fileData.fileName}' was cancelled`
+      );
+    }
+    const status = axios__default.default.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__default.default(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) {
@@ -24782,20 +25133,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__default.default.create({
+      const instance = axios__default.default.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;
     }
   }
@@ -24830,7 +25190,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;
     }
@@ -24839,9 +25199,9 @@ var SimulationHttpClient = class {
   /**
    * Create a new simulation run for the specified dataset.
    */
-  async createRun(name, datasetId, context15) {
+  async createRun(name, datasetId, context17) {
     if (!this.client) {
-      Logger.error(`${LOG_PREFIX}: Client not initialized`);
+      Logger.error(`${LOG_PREFIX2}: Client not initialized`);
       return null;
     }
     try {
@@ -24849,14 +25209,14 @@ var SimulationHttpClient = class {
       const payload = {
         name,
         datasetId,
-        context: context15 || {}
+        context: context17 || {}
       };
       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 || "";
@@ -24864,7 +25224,8 @@ var SimulationHttpClient = class {
         (msg) => ({
           runItemId: msg.testRunItemId || "",
           message: msg.userMessage || "",
-          turnId: msg.turnId || ""
+          turnId: msg.turnId || "",
+          files: parseFiles(msg.attachments)
         })
       );
       return {
@@ -24873,7 +25234,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;
     }
   }
@@ -24882,7 +25243,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 {
@@ -24905,7 +25266,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];
@@ -24913,11 +25274,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;
     }
   }
@@ -24926,17 +25288,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);
     }
   }
   /**
@@ -24945,7 +25307,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 };
     }
@@ -24955,14 +25317,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 };
@@ -24986,34 +25348,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";
@@ -25033,14 +25367,14 @@ var Simulation = class {
       name,
       datasetId,
       task: task2,
-      context: context15,
+      context: context17,
       maxConcurrency = 5
     } = options;
     if (!validateSimulationInputs(datasetId, task2)) {
       return null;
     }
     const startTime = Date.now();
-    const runResult = await this._client.createRun(name, datasetId, context15);
+    const runResult = await this._client.createRun(name, datasetId, context17);
     if (!runResult) {
       return null;
     }
@@ -25147,29 +25481,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";
@@ -25192,6 +25526,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(
@@ -25204,6 +25539,8 @@ var Simulation = class {
           error: errorMsg,
           turnId
         };
+      } finally {
+        span2.end();
       }
     }
   }
@@ -25787,7 +26124,9 @@ exports.agent = agent;
 exports.default = index_default;
 exports.metadataField = metadataField;
 exports.mistralAIInstrumentor = mistralAIInstrumentor;
+exports.netraExpressMiddleware = netraExpressMiddleware;
 exports.openaiAgentsInstrumentor = openaiAgentsInstrumentor;
+exports.runWithExtractedContext = runWithExtractedContext;
 exports.span = span;
 exports.task = task;
 exports.workflow = workflow;