@lmnr-ai/lmnr 0.7.5-alpha.2 → 0.7.5

package/dist/index.js

@@ -551,7 +551,7 @@ var AgentResource = class extends BaseResource {
 };
 
 // package.json
-var version = "0.7.5-alpha.2";
+var version = "0.7.5";
 
 // src/version.ts
 var getLangVersion = () => {
@@ -1077,8 +1077,15 @@ var import_instrumentation_azure = require("@traceloop/instrumentation-azure");
 var import_instrumentation_bedrock = require("@traceloop/instrumentation-bedrock");
 var import_instrumentation_chromadb = require("@traceloop/instrumentation-chromadb");
 var import_instrumentation_cohere = require("@traceloop/instrumentation-cohere");
+var import_instrumentation_langchain = require("@traceloop/instrumentation-langchain");
+var import_instrumentation_llamaindex = require("@traceloop/instrumentation-llamaindex");
+var import_instrumentation_openai = require("@traceloop/instrumentation-openai");
+var import_instrumentation_pinecone = require("@traceloop/instrumentation-pinecone");
+var import_instrumentation_qdrant = require("@traceloop/instrumentation-qdrant");
+var import_instrumentation_together = require("@traceloop/instrumentation-together");
+var import_instrumentation_vertexai = require("@traceloop/instrumentation-vertexai");
 
-// src/opentelemetry-lib/instrumentation/kernel.ts
+// src/browser/playwright.ts
 var import_api5 = require("@opentelemetry/api");
 var import_instrumentation = require("@opentelemetry/instrumentation");
 
@@ -1720,202 +1727,6 @@ var _Laminar = class _Laminar {
 _Laminar.isInitialized = false;
 var Laminar = _Laminar;
 
-// src/opentelemetry-lib/instrumentation/kernel.ts
-var WRAPPED_BROWSER_METHODS = [
-  "create",
-  "retrieve",
-  "list",
-  "delete",
-  "deleteByID",
-  "loadExtensions"
-];
-var WRAPPED_COMPUTER_METHODS = [
-  "captureScreenshot",
-  "clickMouse",
-  "dragMouse",
-  "moveMouse",
-  "pressKey",
-  "scroll",
-  "typeText"
-];
-var WRAPPED_PROCESS_METHODS = [
-  "exec",
-  "kill",
-  "spawn",
-  "status",
-  "stdin",
-  "stdoutStream"
-];
-var KernelInstrumentation = class extends import_instrumentation.InstrumentationBase {
-  constructor() {
-    super(
-      "@lmnr/kernel-instrumentation",
-      version,
-      {
-        enabled: true
-      }
-    );
-  }
-  init() {
-    const module2 = new import_instrumentation.InstrumentationNodeModuleDefinition(
-      "@onkernel/sdk",
-      [">=0.7.0"],
-      this.patch.bind(this),
-      this.unpatch.bind(this)
-    );
-    return module2;
-  }
-  manuallyInstrument(kernelModule) {
-    for (const wrappedMethod of WRAPPED_BROWSER_METHODS) {
-      this._wrap(
-        kernelModule.Kernel.Browsers.prototype,
-        wrappedMethod,
-        this.patchMethod("Browser", wrappedMethod, "DEFAULT")
-      );
-    }
-    for (const wrappedMethod of WRAPPED_COMPUTER_METHODS) {
-      if (wrappedMethod === "captureScreenshot") {
-        this._wrap(
-          kernelModule.Kernel.Browsers.Computer.prototype,
-          wrappedMethod,
-          this.patchTakeScreenshot()
-        );
-      } else {
-        this._wrap(
-          kernelModule.Kernel.Browsers.Computer.prototype,
-          wrappedMethod,
-          this.patchMethod("Computer", wrappedMethod, "TOOL")
-        );
-      }
-    }
-    for (const wrappedMethod of WRAPPED_PROCESS_METHODS) {
-      this._wrap(
-        kernelModule.Kernel.Browsers.Process.prototype,
-        wrappedMethod,
-        this.patchProcessMethod(wrappedMethod)
-      );
-    }
-    this._wrap(
-      kernelModule.Kernel.prototype,
-      "app",
-      this.patchAppFactory()
-    );
-  }
-  patchMethod(className, method, spanType) {
-    return (original) => async function(...args) {
-      return await observe(
-        {
-          name: `${className}.${method}`,
-          spanType
-        },
-        async (innerArgs) => await original.bind(this).apply(this, innerArgs),
-        args
-      );
-    };
-  }
-  patchTakeScreenshot() {
-    return (original) => async function(...args) {
-      const span = Laminar.startSpan({
-        name: `Computer.captureScreenshot`,
-        spanType: "TOOL",
-        input: args
-      });
-      try {
-        const result = await original.bind(this).apply(this, args);
-        span.setAttribute("lmnr.span.output", "<BASE64_ENCODED_IMAGE>");
-        return result;
-      } finally {
-        span.end();
-      }
-    };
-  }
-  patchProcessMethod(method) {
-    return (original) => async function(...args) {
-      const span = Laminar.startSpan({
-        name: `Process.${method}`,
-        spanType: "TOOL",
-        input: args
-      });
-      try {
-        const result = await original.bind(this).apply(this, args);
-        const output = {
-          ...result?.stderr_b64 ? { stderr: Buffer.from(result.stderr_b64, "base64").toString("utf-8") } : {},
-          ...result?.stdout_b64 ? { stdout: Buffer.from(result.stdout_b64, "base64").toString("utf-8") } : {},
-          ...result
-        };
-        span.setAttribute("lmnr.span.output", JSON.stringify(output));
-        return result;
-      } finally {
-        span.end();
-      }
-    };
-  }
-  patchAppFactory() {
-    const plugin = this;
-    return (original) => function(name) {
-      const kernelApp = original.call(this, name);
-      plugin._wrap(
-        kernelApp,
-        "action",
-        plugin.patchKernelAppAction()
-      );
-      return kernelApp;
-    };
-  }
-  patchKernelAppAction() {
-    return (original) => function(name, handler) {
-      const wrappedHandler = async (context6, payload) => {
-        const result = await observe(
-          {
-            name: `action.${name}`,
-            spanType: "DEFAULT"
-          },
-          async (innerCtx, innerPayload) => {
-            const result2 = await handler(innerCtx, innerPayload);
-            return result2;
-          },
-          context6,
-          payload
-        );
-        await Laminar.flush();
-        return result;
-      };
-      return original.call(this, name, wrappedHandler);
-    };
-  }
-  patch(moduleExports) {
-    import_api5.diag.debug("Patching @onkernel/sdk");
-    this.manuallyInstrument(moduleExports);
-    return moduleExports;
-  }
-  unpatch(moduleExports) {
-    import_api5.diag.debug("Unpatching @onkernel/sdk");
-    for (const wrappedMethod of WRAPPED_BROWSER_METHODS) {
-      this._unwrap(moduleExports.Kernel.Browsers.prototype, wrappedMethod);
-    }
-    for (const wrappedMethod of WRAPPED_COMPUTER_METHODS) {
-      this._unwrap(moduleExports.Kernel.Browsers.Computer.prototype, wrappedMethod);
-    }
-    for (const wrappedMethod of WRAPPED_PROCESS_METHODS) {
-      this._unwrap(moduleExports.Kernel.Browsers.Process.prototype, wrappedMethod);
-    }
-    this._unwrap(moduleExports.Kernel.prototype, "app");
-  }
-};
-
-// src/opentelemetry-lib/tracing/instrumentations.ts
-var import_instrumentation_langchain = require("@traceloop/instrumentation-langchain");
-var import_instrumentation_llamaindex = require("@traceloop/instrumentation-llamaindex");
-var import_instrumentation_openai = require("@traceloop/instrumentation-openai");
-var import_instrumentation_pinecone = require("@traceloop/instrumentation-pinecone");
-var import_instrumentation_qdrant = require("@traceloop/instrumentation-qdrant");
-var import_instrumentation_together = require("@traceloop/instrumentation-together");
-var import_instrumentation_vertexai = require("@traceloop/instrumentation-vertexai");
-
-// src/browser/playwright.ts
-var import_api6 = require("@opentelemetry/api");
-var import_instrumentation2 = require("@opentelemetry/instrumentation");
-
 // src/browser/utils.ts
 var import_v3 = require("zod/v3");
 
@@ -2275,8 +2086,13 @@ var modelToProvider = (model) => {
 var injectScript = (sessionRecordingOptions) => {
   const BATCH_TIMEOUT = 2e3;
   const MAX_WORKER_PROMISES = 50;
-  const HEARTBEAT_INTERVAL = 1e3;
+  const HEARTBEAT_INTERVAL = 2e3;
+  const CHUNK_SIZE = 256 * 1024;
+  const CHUNK_SEND_DELAY = 100;
   window.lmnrRrwebEventsBatch = [];
+  window.lmnrChunkQueue = [];
+  window.lmnrChunkSequence = 0;
+  window.lmnrCurrentBatchId = null;
   const createCompressionWorker = () => {
     const workerCode = `
         self.onmessage = async (e) => {
@@ -2330,6 +2146,22 @@ var injectScript = (sessionRecordingOptions) => {
   let compressionWorker = null;
   const workerPromises = /* @__PURE__ */ new Map();
   let workerId = 0;
+  let workerSupported = null;
+  const testWorkerSupport = () => {
+    if (workerSupported !== null) {
+      return workerSupported;
+    }
+    try {
+      const testWorker = createCompressionWorker();
+      testWorker.terminate();
+      workerSupported = true;
+      return true;
+    } catch (error) {
+      console.warn("Web Workers blocked by CSP, will use main thread compression:", error);
+      workerSupported = false;
+      return false;
+    }
+  };
   const cleanupWorker = () => {
     if (compressionWorker) {
       compressionWorker.terminate();
@@ -2420,6 +2252,9 @@ var injectScript = (sessionRecordingOptions) => {
   };
   const compressLargeObjectTransferable = async (data) => {
     try {
+      if (!testWorkerSupport()) {
+        return compressSmallObject(data);
+      }
       cleanupStalePromises();
       const jsonString = await stringifyNonBlocking(data);
       const encoder = new TextEncoder();
@@ -2443,6 +2278,7 @@ var injectScript = (sessionRecordingOptions) => {
           compressionWorker.onerror = (error) => {
             console.error("Compression worker error:", error);
             cleanupWorker();
+            compressSmallObject(data).then(resolve, reject);
           };
         }
         const id = ++workerId;
@@ -2469,60 +2305,113 @@ var injectScript = (sessionRecordingOptions) => {
       return await compressLargeObjectTransferable(data);
     } catch (error) {
       console.warn("Transferable failed, falling back to string method:", error);
-      const jsonString = await stringifyNonBlocking(data);
-      return new Promise((resolve, reject) => {
-        if (!compressionWorker) {
-          compressionWorker = createCompressionWorker();
-          compressionWorker.onmessage = (e) => {
-            const { id: id2, success, data: result, error: error2 } = e.data;
-            const promise = workerPromises.get(id2);
-            if (promise) {
-              workerPromises.delete(id2);
-              if (success) {
-                promise.resolve(result);
-              } else {
-                promise.reject(new Error(error2));
+      try {
+        const jsonString = await stringifyNonBlocking(data);
+        return new Promise((resolve, reject) => {
+          if (!compressionWorker) {
+            compressionWorker = createCompressionWorker();
+            compressionWorker.onmessage = (e) => {
+              const { id: id2, success, data: result, error: error2 } = e.data;
+              const promise = workerPromises.get(id2);
+              if (promise) {
+                workerPromises.delete(id2);
+                if (success) {
+                  promise.resolve(result);
+                } else {
+                  promise.reject(new Error(error2));
+                }
               }
-            }
-          };
-          compressionWorker.onerror = (error2) => {
-            console.error("Compression worker error:", error2);
-            cleanupWorker();
-          };
-        }
-        const id = ++workerId;
-        workerPromises.set(id, { resolve, reject });
-        setTimeout(() => {
-          if (workerPromises.has(id)) {
-            workerPromises.delete(id);
-            reject(new Error("Compression timeout"));
+            };
+            compressionWorker.onerror = (error2) => {
+              console.error("Compression worker error:", error2);
+              cleanupWorker();
+            };
           }
-        }, 1e4);
-        compressionWorker.postMessage({ jsonString, id });
-      });
+          const id = ++workerId;
+          workerPromises.set(id, { resolve, reject });
+          setTimeout(() => {
+            if (workerPromises.has(id)) {
+              workerPromises.delete(id);
+              reject(new Error("Compression timeout"));
+            }
+          }, 1e4);
+          compressionWorker.postMessage({ jsonString, id });
+        });
+      } catch (workerError) {
+        logger5.warn(`Worker creation failed, falling back to main thread compression: ${workerError instanceof Error ? workerError.message : String(workerError)}`);
+        return await compressSmallObject(data);
+      }
     }
   };
   setInterval(cleanupWorker, 5e3);
   const isLargeEvent = (type) => {
     const LARGE_EVENT_TYPES = [
-      2,
+      2
       // FullSnapshot
-      3
-      // IncrementalSnapshot
     ];
     if (LARGE_EVENT_TYPES.includes(type)) {
       return true;
     }
     return false;
   };
+  const createChunks = (str, batchId) => {
+    const chunks = [];
+    const totalChunks = Math.ceil(str.length / CHUNK_SIZE);
+    for (let i = 0; i < str.length; i += CHUNK_SIZE) {
+      const chunk = str.slice(i, i + CHUNK_SIZE);
+      chunks.push({
+        batchId,
+        chunkIndex: chunks.length,
+        totalChunks,
+        data: chunk,
+        isFinal: chunks.length === totalChunks - 1
+      });
+    }
+    return chunks;
+  };
+  const sendChunks = async (chunks) => {
+    if (typeof window.lmnrSendEvents !== "function") {
+      return;
+    }
+    window.lmnrChunkQueue.push(...chunks);
+    while (window.lmnrChunkQueue.length > 0) {
+      const chunk = window.lmnrChunkQueue.shift();
+      try {
+        await window.lmnrSendEvents(chunk);
+        await new Promise((resolve) => setTimeout(resolve, CHUNK_SEND_DELAY));
+      } catch (error) {
+        console.error("Failed to send chunk:", error);
+        window.lmnrChunkQueue = window.lmnrChunkQueue.filter(
+          (c) => c.batchId !== chunk.batchId
+        );
+        break;
+      }
+    }
+  };
   const sendBatchIfReady = async () => {
     if (window.lmnrRrwebEventsBatch.length > 0 && typeof window.lmnrSendEvents === "function") {
       const events = window.lmnrRrwebEventsBatch;
       window.lmnrRrwebEventsBatch = [];
       try {
-        await window.lmnrSendEvents(events);
+        const batchId = `${Date.now()}_${window.lmnrChunkSequence++}`;
+        window.lmnrCurrentBatchId = batchId;
+        const batchString = JSON.stringify(events);
+        if (batchString.length <= CHUNK_SIZE) {
+          const chunk = {
+            batchId,
+            chunkIndex: 0,
+            totalChunks: 1,
+            data: batchString,
+            isFinal: true
+          };
+          await window.lmnrSendEvents(chunk);
+        } else {
+          const chunks = createChunks(batchString, batchId);
+          await sendChunks(chunks);
+        }
       } catch (error) {
-        logger5.error("Failed to send events:", error);
+        console.error("Failed to send events:", error);
+        window.lmnrRrwebEventsBatch = [];
       }
     }
   };
@@ -2534,38 +2423,101 @@ var injectScript = (sessionRecordingOptions) => {
     });
     return base64url.slice(base64url.indexOf(",") + 1);
   };
-  setInterval(sendBatchIfReady, BATCH_TIMEOUT);
-  setInterval(() => {
-    window.lmnrRrweb.record.addCustomEvent("heartbeat", {
-      title: document.title,
-      url: document.URL
-    });
-  }, HEARTBEAT_INTERVAL);
-  window.lmnrRrweb.record({
-    async emit(event) {
-      try {
-        const isLarge = isLargeEvent(event.type);
-        const compressedResult = isLarge ? await compressLargeObject(event.data) : await compressSmallObject(event.data);
-        const base64Data = await bufferToBase64(compressedResult);
-        const eventToSend = {
-          ...event,
-          data: base64Data
-        };
-        window.lmnrRrwebEventsBatch.push(eventToSend);
-      } catch (error) {
-        console.warn("Failed to push event to batch", error);
+  if (!window.lmnrStartedRecordingEvents) {
+    let heartbeat2 = function() {
+      setInterval(
+        () => {
+          window.lmnrRrweb.record.addCustomEvent("heartbeat", {
+            title: document.title,
+            url: document.URL
+          });
+        },
+        HEARTBEAT_INTERVAL
+      );
+    };
+    var heartbeat = heartbeat2;
+    setInterval(sendBatchIfReady, BATCH_TIMEOUT);
+    window.lmnrRrweb.record({
+      async emit(event) {
+        try {
+          const isLarge = isLargeEvent(event.type);
+          const compressedResult = isLarge ? await compressLargeObject(event.data) : await compressSmallObject(event.data);
+          const base64Data = await bufferToBase64(compressedResult);
+          const eventToSend = {
+            ...event,
+            data: base64Data
+          };
+          window.lmnrRrwebEventsBatch.push(eventToSend);
+        } catch (error) {
+          console.warn("Failed to push event to batch", error);
+        }
+      },
+      recordCanvas: true,
+      collectFonts: true,
+      recordCrossOriginIframes: true,
+      maskInputOptions: {
+        password: true,
+        textarea: sessionRecordingOptions?.maskInputOptions?.textarea || false,
+        text: sessionRecordingOptions?.maskInputOptions?.text || false,
+        number: sessionRecordingOptions?.maskInputOptions?.number || false,
+        select: sessionRecordingOptions?.maskInputOptions?.select || false,
+        email: sessionRecordingOptions?.maskInputOptions?.email || false,
+        tel: sessionRecordingOptions?.maskInputOptions?.tel || false
       }
-    },
-    recordCanvas: true,
-    collectFonts: true,
-    recordCrossOriginIframes: true,
-    maskInputOptions: sessionRecordingOptions?.maskInputOptions
-  });
+    });
+    heartbeat2();
+    window.lmnrStartedRecordingEvents = true;
+  }
 };
+var OLD_BUFFER_TIMEOUT = 6e4;
+async function sendEvents(chunk, client, chunkBuffers, sessionId, traceId) {
+  try {
+    const { batchId, chunkIndex, totalChunks, data } = chunk;
+    if (!sessionId || !traceId) {
+      logger5.debug("Missing sessionId or traceId in chunk");
+      return;
+    }
+    if (!chunkBuffers.has(batchId)) {
+      chunkBuffers.set(batchId, {
+        chunks: /* @__PURE__ */ new Map(),
+        total: totalChunks,
+        timestamp: Date.now()
+      });
+    }
+    const buffer = chunkBuffers.get(batchId);
+    buffer.chunks.set(chunkIndex, data);
+    if (buffer.chunks.size === totalChunks) {
+      let fullData = "";
+      for (let i = 0; i < totalChunks; i++) {
+        fullData += buffer.chunks.get(i);
+      }
+      const events = JSON.parse(fullData);
+      if (events && events.length > 0) {
+        await client.browserEvents.send({ sessionId, traceId, events }).catch((error) => {
+          logger5.debug(`Failed to send events: ${error instanceof Error ? error.message : String(error)}`);
+        });
+      }
+      chunkBuffers.delete(batchId);
+    }
+    const currentTime = Date.now();
+    const toDelete = [];
+    for (const [bid, buffer2] of chunkBuffers.entries()) {
+      if (currentTime - buffer2.timestamp > OLD_BUFFER_TIMEOUT) {
+        toDelete.push(bid);
+      }
+    }
+    for (const bid of toDelete) {
+      logger5.debug(`Cleaning up incomplete chunk buffer: ${bid}`);
+      chunkBuffers.delete(bid);
+    }
+  } catch (error) {
+    logger5.debug(`Could not send events: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
 
 // src/browser/playwright.ts
 var logger6 = initializeLogger();
-var PlaywrightInstrumentation = class extends import_instrumentation2.InstrumentationBase {
+var PlaywrightInstrumentation = class extends import_instrumentation.InstrumentationBase {
   constructor(client, sessionRecordingOptions) {
     super(
       "@lmnr/playwright-instrumentation",
@@ -2594,7 +2546,7 @@ var PlaywrightInstrumentation = class extends import_instrumentation2.Instrument
     return this._parentSpans.get(sessionId);
   }
   init() {
-    const module2 = new import_instrumentation2.InstrumentationNodeModuleDefinition(
+    const module2 = new import_instrumentation.InstrumentationNodeModuleDefinition(
       "playwright",
       // TODO: test if the older versions work
       [">=1.0.0"],
@@ -2632,7 +2584,7 @@ var PlaywrightInstrumentation = class extends import_instrumentation2.Instrument
     return pwModule;
   }
   patch(moduleExports, moduleVersion) {
-    import_api6.diag.debug(`patching playwright ${moduleVersion}`);
+    import_api5.diag.debug(`patching playwright ${moduleVersion}`);
     const browsers = ["chromium", "firefox", "webkit"];
     for (const browserType of browsers) {
       if (moduleExports[browserType]) {
@@ -2661,7 +2613,7 @@ var PlaywrightInstrumentation = class extends import_instrumentation2.Instrument
     return moduleExports;
   }
   unpatch(moduleExports, moduleVersion) {
-    import_api6.diag.debug(`unpatching playwright ${moduleVersion}`);
+    import_api5.diag.debug(`unpatching playwright ${moduleVersion}`);
     const browsers = ["chromium", "firefox", "webkit"];
     for (const browserType of browsers) {
       if (moduleExports[browserType]) {
@@ -2729,7 +2681,7 @@ var PlaywrightInstrumentation = class extends import_instrumentation2.Instrument
       await originalBringToFront();
       await takeFullSnapshot(page);
     };
-    const currentSpan = import_api6.trace.getSpan(LaminarContextManager.getContext()) ?? import_api6.trace.getActiveSpan();
+    const currentSpan = import_api5.trace.getSpan(LaminarContextManager.getContext()) ?? import_api5.trace.getActiveSpan();
     currentSpan?.setAttribute(TRACE_HAS_BROWSER_SESSION, true);
     const otelTraceId = currentSpan?.spanContext().traceId;
     const traceId = otelTraceId ? otelTraceIdToUUID(otelTraceId) : NIL_UUID;
@@ -2747,20 +2699,11 @@ var PlaywrightInstrumentation = class extends import_instrumentation2.Instrument
         logger6.error(`Error in onClose handler: ${error instanceof Error ? error.message : String(error)}`);
       }
     });
+    const chunkBuffers = /* @__PURE__ */ new Map();
     await injectSessionRecorder(page, this._sessionRecordingOptions);
     try {
-      await page.exposeFunction(LMNR_SEND_EVENTS_FUNCTION_NAME, async (events) => {
-        try {
-          if (events != null && events.length > 0) {
-            await this._client.browserEvents.send({
-              sessionId,
-              traceId,
-              events
-            });
-          }
-        } catch (error) {
-          logger6.debug(`Could not send events: ${error instanceof Error ? error.message : String(error)}`);
-        }
+      await page.exposeFunction(LMNR_SEND_EVENTS_FUNCTION_NAME, async (chunk) => {
+        await sendEvents(chunk, this._client, chunkBuffers, sessionId, traceId);
       });
     } catch (error) {
       logger6.debug("Could not expose function " + LMNR_SEND_EVENTS_FUNCTION_NAME + `: ${error instanceof Error ? error.message : String(error)}`);
@@ -2769,10 +2712,10 @@ var PlaywrightInstrumentation = class extends import_instrumentation2.Instrument
 };
 
 // src/browser/stagehand.ts
-var import_api7 = require("@opentelemetry/api");
-var import_instrumentation3 = require("@opentelemetry/instrumentation");
+var import_api6 = require("@opentelemetry/api");
+var import_instrumentation2 = require("@opentelemetry/instrumentation");
 var import_zod_to_json_schema = require("zod-to-json-schema");
-var StagehandInstrumentation = class extends import_instrumentation3.InstrumentationBase {
+var StagehandInstrumentation = class extends import_instrumentation2.InstrumentationBase {
   constructor(playwrightInstrumentation) {
     super(
       "@lmnr/browserbase-stagehand-instrumentation",
@@ -2787,7 +2730,7 @@ var StagehandInstrumentation = class extends import_instrumentation3.Instrumenta
     this.playwrightInstrumentation = playwrightInstrumentation;
   }
   init() {
-    const module2 = new import_instrumentation3.InstrumentationNodeModuleDefinition(
+    const module2 = new import_instrumentation2.InstrumentationNodeModuleDefinition(
       "@browserbasehq/stagehand",
       [">=1.0.0"],
       this.patch.bind(this),
@@ -2796,7 +2739,7 @@ var StagehandInstrumentation = class extends import_instrumentation3.Instrumenta
     return module2;
   }
   patch(moduleExports, moduleVersion) {
-    import_api7.diag.debug(`patching stagehand ${moduleVersion}`);
+    import_api6.diag.debug(`patching stagehand ${moduleVersion}`);
     const descriptor = Object.getOwnPropertyDescriptor(moduleExports, "Stagehand");
     if (descriptor && !descriptor.configurable) {
       const originalStagehand = moduleExports.Stagehand;
@@ -2819,7 +2762,7 @@ var StagehandInstrumentation = class extends import_instrumentation3.Instrumenta
     }
   }
   manuallyInstrument(Stagehand) {
-    import_api7.diag.debug("manually instrumenting stagehand");
+    import_api6.diag.debug("manually instrumenting stagehand");
     if (Stagehand && Stagehand.prototype) {
       this._wrap(
         Stagehand.prototype,
@@ -2834,7 +2777,7 @@ var StagehandInstrumentation = class extends import_instrumentation3.Instrumenta
     }
   }
   unpatch(moduleExports, moduleVersion) {
-    import_api7.diag.debug(`unpatching stagehand ${moduleVersion}`);
+    import_api6.diag.debug(`unpatching stagehand ${moduleVersion}`);
     this._unwrap(moduleExports, "Stagehand");
     if (moduleExports.Stagehand) {
       this._unwrap(moduleExports.Stagehand.prototype, "init");
@@ -3012,7 +2955,7 @@ var StagehandInstrumentation = class extends import_instrumentation3.Instrumenta
         try {
           prettySchema = prettyPrintZodSchema(schema);
         } catch (error) {
-          import_api7.diag.warn("Error pretty printing zod schema", { error });
+          import_api6.diag.warn("Error pretty printing zod schema", { error });
         }
         input[0] = { ...rest, schema: prettySchema };
       }
@@ -3099,7 +3042,7 @@ var StagehandInstrumentation = class extends import_instrumentation3.Instrumenta
       try {
         prettySchema = prettyPrintZodSchema(schema);
       } catch (error) {
-        import_api7.diag.warn("Error pretty printing zod schema", { error });
+        import_api6.diag.warn("Error pretty printing zod schema", { error });
       }
       return await observe(
         {
@@ -3124,7 +3067,7 @@ var StagehandInstrumentation = class extends import_instrumentation3.Instrumenta
       try {
         prettySchema = prettyPrintZodSchema(schema);
       } catch (error) {
-        import_api7.diag.warn("Error pretty printing zod schema", { error });
+        import_api6.diag.warn("Error pretty printing zod schema", { error });
       }
       return await observe(
         {
@@ -3171,7 +3114,7 @@ var StagehandInstrumentation = class extends import_instrumentation3.Instrumenta
         ignoreInput: true,
         ignoreOutput: true
       }, async () => {
-        const currentSpan = import_api7.trace.getSpan(LaminarContextManager.getContext()) ?? import_api7.trace.getActiveSpan();
+        const currentSpan = import_api6.trace.getSpan(LaminarContextManager.getContext()) ?? import_api6.trace.getActiveSpan();
         const span = currentSpan;
         const innerOptions = options.options;
         const recordedProvider = instrumentation.globalLLMClientOptions.get(this)?.provider;
@@ -3297,7 +3240,7 @@ var StagehandInstrumentation = class extends import_instrumentation3.Instrumenta
               spanType: "LLM"
             },
             async () => {
-              const span = import_api7.trace.getSpan(LaminarContextManager.getContext()) ?? import_api7.trace.getActiveSpan();
+              const span = import_api6.trace.getSpan(LaminarContextManager.getContext()) ?? import_api6.trace.getActiveSpan();
               const provider = instrumentation.globalAgentOptions.get(this)?.provider ?? instrumentation.globalLLMClientOptions.get(this)?.provider;
               const model = instrumentation.globalAgentOptions.get(this)?.model ?? instrumentation.globalLLMClientOptions.get(this)?.model;
               span?.setAttributes({
@@ -3352,10 +3295,10 @@ var StagehandInstrumentation = class extends import_instrumentation3.Instrumenta
 };
 
 // src/browser/puppeteer.ts
-var import_api8 = require("@opentelemetry/api");
-var import_instrumentation4 = require("@opentelemetry/instrumentation");
+var import_api7 = require("@opentelemetry/api");
+var import_instrumentation3 = require("@opentelemetry/instrumentation");
 var logger7 = initializeLogger();
-var PuppeteerInstrumentation = class extends import_instrumentation4.InstrumentationBase {
+var PuppeteerInstrumentation = class extends import_instrumentation3.InstrumentationBase {
   constructor(client, sessionRecordingOptions) {
     super(
       "@lmnr/puppeteer-instrumentation",
@@ -3369,7 +3312,7 @@ var PuppeteerInstrumentation = class extends import_instrumentation4.Instrumenta
     this._sessionRecordingOptions = sessionRecordingOptions;
   }
   init() {
-    const puppeteerInstrumentation = new import_instrumentation4.InstrumentationNodeModuleDefinition(
+    const puppeteerInstrumentation = new import_instrumentation3.InstrumentationNodeModuleDefinition(
       "puppeteer",
       // About two years before first writing this instrumentation
       // and apparently no big breaking changes afterwards
@@ -3378,7 +3321,7 @@ var PuppeteerInstrumentation = class extends import_instrumentation4.Instrumenta
       this.patch.bind(this),
       this.unpatch.bind(this)
     );
-    const puppeteerCoreInstrumentation = new import_instrumentation4.InstrumentationNodeModuleDefinition(
+    const puppeteerCoreInstrumentation = new import_instrumentation3.InstrumentationNodeModuleDefinition(
       "puppeteer-core",
       [">=19.0.0"],
       this.patch.bind(this),
@@ -3400,7 +3343,7 @@ var PuppeteerInstrumentation = class extends import_instrumentation4.Instrumenta
     return puppeteerModule;
   }
   patch(moduleExports, moduleVersion) {
-    import_api8.diag.debug(`patching puppeteer ${moduleVersion}`);
+    import_api7.diag.debug(`patching puppeteer ${moduleVersion}`);
     this._wrap(
       moduleExports,
       `launch`,
@@ -3434,7 +3377,7 @@ var PuppeteerInstrumentation = class extends import_instrumentation4.Instrumenta
     return moduleExports;
   }
   unpatch(moduleExports, moduleVersion) {
-    import_api8.diag.debug(`unpatching puppeteer ${moduleVersion}`);
+    import_api7.diag.debug(`unpatching puppeteer ${moduleVersion}`);
     this._unwrap(
       moduleExports,
       `launch`
@@ -3535,7 +3478,7 @@ var PuppeteerInstrumentation = class extends import_instrumentation4.Instrumenta
       await originalBringToFront();
       await takeFullSnapshot(page);
     };
-    const currentSpan = import_api8.trace.getSpan(LaminarContextManager.getContext()) ?? import_api8.trace.getActiveSpan();
+    const currentSpan = import_api7.trace.getSpan(LaminarContextManager.getContext()) ?? import_api7.trace.getActiveSpan();
     currentSpan?.setAttribute(TRACE_HAS_BROWSER_SESSION, true);
     const otelTraceId = currentSpan?.spanContext().traceId;
     const traceId = otelTraceId ? otelTraceIdToUUID(otelTraceId) : NIL_UUID;
@@ -3550,19 +3493,10 @@ var PuppeteerInstrumentation = class extends import_instrumentation4.Instrumenta
       });
     });
     await injectSessionRecorder(page, this._sessionRecordingOptions);
+    const chunkBuffers = /* @__PURE__ */ new Map();
     try {
-      await page.exposeFunction(LMNR_SEND_EVENTS_FUNCTION_NAME, async (events) => {
-        try {
-          if (events != null && events.length > 0) {
-            await this._client.browserEvents.send({
-              sessionId,
-              traceId,
-              events
-            });
-          }
-        } catch (error) {
-          logger7.debug(`Could not send events: ${error instanceof Error ? error.message : String(error)}`);
-        }
+      await page.exposeFunction(LMNR_SEND_EVENTS_FUNCTION_NAME, async (chunk) => {
+        await sendEvents(chunk, this._client, chunkBuffers, sessionId, traceId);
       });
     } catch (error) {
       logger7.debug("Could not expose function " + LMNR_SEND_EVENTS_FUNCTION_NAME + `: ${error instanceof Error ? error.message : String(error)}`);
@@ -3570,6 +3504,191 @@ var PuppeteerInstrumentation = class extends import_instrumentation4.Instrumenta
   }
 };
 
+// src/opentelemetry-lib/instrumentation/kernel.ts
+var import_api8 = require("@opentelemetry/api");
+var import_instrumentation4 = require("@opentelemetry/instrumentation");
+var WRAPPED_BROWSER_METHODS = [
+  "create",
+  "retrieve",
+  "list",
+  "delete",
+  "deleteByID",
+  "loadExtensions"
+];
+var WRAPPED_COMPUTER_METHODS = [
+  "captureScreenshot",
+  "clickMouse",
+  "dragMouse",
+  "moveMouse",
+  "pressKey",
+  "scroll",
+  "typeText"
+];
+var WRAPPED_PROCESS_METHODS = [
+  "exec",
+  "kill",
+  "spawn",
+  "status",
+  "stdin",
+  "stdoutStream"
+];
+var KernelInstrumentation = class extends import_instrumentation4.InstrumentationBase {
+  constructor() {
+    super(
+      "@lmnr/kernel-instrumentation",
+      version,
+      {
+        enabled: true
+      }
+    );
+  }
+  init() {
+    const module2 = new import_instrumentation4.InstrumentationNodeModuleDefinition(
+      "@onkernel/sdk",
+      [">=0.7.0"],
+      this.patch.bind(this),
+      this.unpatch.bind(this)
+    );
+    return module2;
+  }
+  manuallyInstrument(kernelModule) {
+    for (const wrappedMethod of WRAPPED_BROWSER_METHODS) {
+      this._wrap(
+        kernelModule.Kernel.Browsers.prototype,
+        wrappedMethod,
+        this.patchMethod("Browser", wrappedMethod, "DEFAULT")
+      );
+    }
+    for (const wrappedMethod of WRAPPED_COMPUTER_METHODS) {
+      if (wrappedMethod === "captureScreenshot") {
+        this._wrap(
+          kernelModule.Kernel.Browsers.Computer.prototype,
+          wrappedMethod,
+          this.patchTakeScreenshot()
+        );
+      } else {
+        this._wrap(
+          kernelModule.Kernel.Browsers.Computer.prototype,
+          wrappedMethod,
+          this.patchMethod("Computer", wrappedMethod, "TOOL")
+        );
+      }
+    }
+    for (const wrappedMethod of WRAPPED_PROCESS_METHODS) {
+      this._wrap(
+        kernelModule.Kernel.Browsers.Process.prototype,
+        wrappedMethod,
+        this.patchProcessMethod(wrappedMethod)
+      );
+    }
+    this._wrap(
+      kernelModule.Kernel.prototype,
+      "app",
+      this.patchAppFactory()
+    );
+  }
+  patchMethod(className, method, spanType) {
+    return (original) => async function(...args) {
+      return await observe(
+        {
+          name: `${className}.${method}`,
+          spanType
+        },
+        async (innerArgs) => await original.bind(this).apply(this, innerArgs),
+        args
+      );
+    };
+  }
+  patchTakeScreenshot() {
+    return (original) => async function(...args) {
+      const span = Laminar.startSpan({
+        name: `Computer.captureScreenshot`,
+        spanType: "TOOL",
+        input: args
+      });
+      try {
+        const res = await original.bind(this).apply(this, args);
+        span.setAttribute("lmnr.span.output", "<BASE64_ENCODED_IMAGE>");
+        return res;
+      } finally {
+        span.end();
+      }
+    };
+  }
+  patchProcessMethod(method) {
+    return (original) => async function(...args) {
+      const span = Laminar.startSpan({
+        name: `Process.${method}`,
+        spanType: "TOOL",
+        input: args
+      });
+      try {
+        const result = await original.bind(this).apply(this, args);
+        const output = {
+          ...result?.stderr_b64 ? { stderr: Buffer.from(result.stderr_b64, "base64").toString("utf-8") } : {},
+          ...result?.stdout_b64 ? { stdout: Buffer.from(result.stdout_b64, "base64").toString("utf-8") } : {},
+          ...result
+        };
+        span.setAttribute("lmnr.span.output", JSON.stringify(output));
+        return result;
+      } finally {
+        span.end();
+      }
+    };
+  }
+  patchAppFactory() {
+    const plugin = this;
+    return (original) => function(name) {
+      const kernelApp = original.call(this, name);
+      plugin._wrap(
+        kernelApp,
+        "action",
+        plugin.patchKernelAppAction()
+      );
+      return kernelApp;
+    };
+  }
+  patchKernelAppAction() {
+    return (original) => function(name, handler) {
+      const wrappedHandler = async (context6, payload) => {
+        const result = await observe(
+          {
+            name: `action.${name}`,
+            spanType: "DEFAULT"
+          },
+          async (innerCtx, innerPayload) => {
+            const result2 = await handler(innerCtx, innerPayload);
+            return result2;
+          },
+          context6,
+          payload
+        );
+        await Laminar.flush();
+        return result;
+      };
+      return original.call(this, name, wrappedHandler);
+    };
+  }
+  patch(moduleExports) {
+    import_api8.diag.debug("Patching @onkernel/sdk");
+    this.manuallyInstrument(moduleExports);
+    return moduleExports;
+  }
+  unpatch(moduleExports) {
+    import_api8.diag.debug("Unpatching @onkernel/sdk");
+    for (const wrappedMethod of WRAPPED_BROWSER_METHODS) {
+      this._unwrap(moduleExports.Kernel.Browsers.prototype, wrappedMethod);
+    }
+    for (const wrappedMethod of WRAPPED_COMPUTER_METHODS) {
+      this._unwrap(moduleExports.Kernel.Browsers.Computer.prototype, wrappedMethod);
+    }
+    for (const wrappedMethod of WRAPPED_PROCESS_METHODS) {
+      this._unwrap(moduleExports.Kernel.Browsers.Process.prototype, wrappedMethod);
+    }
+    this._unwrap(moduleExports.Kernel.prototype, "app");
+  }
+};
+
 // src/opentelemetry-lib/tracing/instrumentations.ts
 var initializeLaminarInstrumentations = (options = {}) => {
   const url = options.baseUrl ?? process?.env?.LMNR_BASE_URL ?? "https://api.lmnr.ai";
@@ -4461,15 +4580,15 @@ Error: ${error.message}
   }) {
     this.cliProgress.stop();
     const url = getEvaluationUrl(projectId, evaluationId, this.baseUrl);
-    process.stdout.write(`
-Check results at ${url}
-`);
+    process.stdout.write("\n");
     process.stdout.write("\nAverage scores:\n");
     for (const key in averageScores) {
-      process.stdout.write(`${key}: ${JSON.stringify(averageScores[key])}
+      process.stdout.write(`${key}: ${averageScores[key]}
 `);
     }
-    process.stdout.write("\n");
+    process.stdout.write(`
+Check results at ${url}
+`);
   }
 };
 var Evaluation = class {
@@ -4562,10 +4681,18 @@ var Evaluation = class {
     if (this.data instanceof LaminarDataset) {
       this.data.setClient(this.client);
     }
-    this.progressReporter.start({ length: await this.getLength() });
     let resultDatapoints;
     try {
       const evaluation = await this.client.evals.init(this.name, this.groupName, this.metadata);
+      const url = getEvaluationUrl(
+        evaluation.projectId,
+        evaluation.id,
+        this.progressReporter.baseUrl
+      );
+      process.stdout.write(`
+Check results at ${url}
+`);
+      this.progressReporter.start({ length: await this.getLength() });
       resultDatapoints = await this.evaluateInBatches(evaluation.id);
       const averageScores = getAverageScores(resultDatapoints);
       if (this.uploadPromises.length > 0) {
@@ -4578,11 +4705,22 @@ var Evaluation = class {
       });
       this.isFinished = true;
       await Laminar.shutdown();
-      return averageScores;
+      return {
+        averageScores,
+        projectId: evaluation.projectId,
+        evaluationId: evaluation.id,
+        url
+      };
     } catch (e) {
       this.progressReporter.stopWithError(e);
       this.isFinished = true;
-      return {};
+      return {
+        averageScores: {},
+        projectId: "",
+        evaluationId: "",
+        url: "",
+        errorMessage: e instanceof Error ? e.message : String(e)
+      };
     }
   }
   async evaluateInBatches(evalId) {
@@ -4730,7 +4868,7 @@ async function evaluate({
   if (globalThis._set_global_evaluation) {
     globalThis._evaluations = [...globalThis._evaluations ?? [], evaluation];
   } else {
-    await evaluation.run();
+    return await evaluation.run();
   }
 }