@lmnr-ai/lmnr 0.8.21 → 0.8.22-alpha.1

package/dist/cli/worker/index.cjs

@@ -1,5 +1,5 @@
 const require_chunk = require("../../chunk-Do9eywBl.cjs");
-const require_decorators = require("../../decorators-CaTC0lJq.cjs");
+const require_decorators = require("../../decorators-Bb2owkCc.cjs");
 const require_cli_worker_build = require("./build.cjs");
 let readline = require("readline");
 readline = require_chunk.__toESM(readline);

package/dist/cli/worker/index.mjs

@@ -1,4 +1,4 @@
-import { d as Laminar, h as consumeStreamResult } from "../../decorators-BDFgXfgI.mjs";
+import { d as Laminar, h as consumeStreamResult } from "../../decorators-Bq6Sf8vt.mjs";
 import { buildFile, loadModule, selectRolloutFunction } from "./build.mjs";
 import * as readline from "readline";
 //#region src/cli/worker/index.ts

package/dist/cli.cjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 const require_chunk = require("./chunk-Do9eywBl.cjs");
-const require_dist = require("./dist-B5cKzRzq.cjs");
+const require_dist = require("./dist-DZMJR04H.cjs");
 const require_utils = require("./utils-C8Tl1vKD.cjs");
 const require_file_utils = require("./file-utils-yJ5ephze.cjs");
 const require_proxy_to_lmnr_cli = require("./proxy-to-lmnr-cli-OA7sXzcz.cjs");

package/dist/cli.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { r as __require } from "./chunk-BEJ448es.mjs";
-import { n as version, t as LaminarClient } from "./dist-B5CmOQ4s.mjs";
+import { n as version, t as LaminarClient } from "./dist-TLHkfisO.mjs";
 import { i as getDirname, s as initializeLogger } from "./utils-CHJ0KZUR.mjs";
 import { i as writeToFile, n as loadFromPaths, r as printToConsole } from "./file-utils-CHoR9VB8.mjs";
 import { t as proxyToLmnrCli } from "./proxy-to-lmnr-cli-DNDxudgt.mjs";

package/dist/{decorators-CaTC0lJq.cjs → decorators-Bb2owkCc.cjs}

@@ -1,5 +1,5 @@
 const require_chunk = require("./chunk-Do9eywBl.cjs");
-const require_dist = require("./dist-B5cKzRzq.cjs");
+const require_dist = require("./dist-DZMJR04H.cjs");
 const require_utils = require("./utils-C8Tl1vKD.cjs");
 let _opentelemetry_api = require("@opentelemetry/api");
 let _opentelemetry_context_async_hooks = require("@opentelemetry/context-async-hooks");
@@ -2174,7 +2174,7 @@ const injectScript = (sessionRecordingOptions, stringifyCallbackArgs) => {
 	};
 	if (!window.lmnrStartedRecordingEvents) {
 		setInterval(sendBatchIfReady, BATCH_TIMEOUT);
-		window.lmnrRrweb.record({
+		const recordOptions = {
 			emit(event) {
 				window.lmnrRrwebEventsBatch.push(event);
 			},
@@ -2190,12 +2190,17 @@ const injectScript = (sessionRecordingOptions, stringifyCallbackArgs) => {
 				email: sessionRecordingOptions?.maskInputOptions?.email || false,
 				tel: sessionRecordingOptions?.maskInputOptions?.tel || false
 			}
-		});
+		};
+		window.lmnrRrweb.record(recordOptions);
 		setInterval(() => {
-			window.lmnrRrweb.record.addCustomEvent("heartbeat", {
-				title: document.title,
-				url: document.URL
-			});
+			try {
+				window.lmnrRrweb.record.addCustomEvent("heartbeat", {
+					title: document.title,
+					url: document.URL
+				});
+			} catch {
+				window.lmnrRrweb.record(recordOptions);
+			}
 		}, HEARTBEAT_INTERVAL);
 		window.lmnrStartedRecordingEvents = true;
 	}
@@ -3118,6 +3123,29 @@ function createTargetInfoChangedHandler(context, state, sessionRecordingOptions)
 }
 //#endregion
 //#region src/browser/stagehand/v3/instrumentation.ts
+/**
+* Guarded _wrap: only wraps `target[methodName]` if it exists as a function.
+* Prevents the "Cannot wrap non-existent method" warning from
+* InstrumentationBase._wrap when a handler/method was renamed or removed
+* in the upstream library (e.g. Stagehand v2 vs v3 differences).
+*/
+const safeWrap = (instrumentation, target, methodName, wrapper) => {
+	if (!target) return false;
+	if (typeof target[methodName] !== "function") return false;
+	instrumentation._wrap(target, methodName, wrapper);
+	return true;
+};
+/**
+* Guarded _unwrap counterpart to safeWrap. Only unwraps when the target method
+* exists AND was previously wrapped via shimmer (has the `__original` marker).
+*/
+const safeUnwrap = (instrumentation, target, methodName) => {
+	if (!target) return;
+	const current = target[methodName];
+	if (typeof current !== "function") return;
+	if (!current.__original) return;
+	instrumentation._unwrap(target, methodName);
+};
 var StagehandInstrumentation = class extends _opentelemetry_instrumentation.InstrumentationBase {
 	constructor(sessionRecordingOptions) {
 		super("@lmnr/browserbase-stagehand-instrumentation", require_dist.version, { enabled: true });
@@ -3169,21 +3197,28 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 	}
 	unpatch(moduleExports, moduleVersion) {
 		_opentelemetry_api.diag.debug(`unpatching stagehand ${moduleVersion}`);
-		this._unwrap(moduleExports, "Stagehand");
+		safeUnwrap(this, moduleExports, "Stagehand");
 		if (moduleExports.Stagehand && moduleExports.Stagehand.prototype) {
-			this._unwrap(moduleExports.Stagehand.prototype, "init");
-			this._unwrap(moduleExports.Stagehand.prototype, "close");
-			this._unwrap(moduleExports.Stagehand.prototype, "act");
-			this._unwrap(moduleExports.Stagehand.prototype, "extract");
-			this._unwrap(moduleExports.Stagehand.prototype, "observe");
 			const prototype = moduleExports.Stagehand.prototype;
+			safeUnwrap(this, prototype, "init");
+			safeUnwrap(this, prototype, "close");
+			safeUnwrap(this, prototype, "act");
+			safeUnwrap(this, prototype, "extract");
+			safeUnwrap(this, prototype, "observe");
+			safeUnwrap(this, prototype, "agent");
 			if (prototype.actHandler) {
-				this._unwrap(prototype.actHandler, "act");
-				this._unwrap(prototype.actHandler, "actFromObserveResult");
+				safeUnwrap(this, prototype.actHandler, "act");
+				safeUnwrap(this, prototype.actHandler, "actFromObserveResult");
+			}
+			if (prototype.extractHandler) safeUnwrap(this, prototype.extractHandler, "extract");
+			if (prototype.observeHandler) safeUnwrap(this, prototype.observeHandler, "observe");
+			if (prototype.llmClient) safeUnwrap(this, prototype.llmClient, "createChatCompletion");
+			if (prototype.apiClient) {
+				safeUnwrap(this, prototype.apiClient, "act");
+				safeUnwrap(this, prototype.apiClient, "extract");
+				safeUnwrap(this, prototype.apiClient, "observe");
+				safeUnwrap(this, prototype.apiClient, "agentExecute");
 			}
-			if (prototype.extractHandler) this._unwrap(prototype.extractHandler, "extract");
-			if (prototype.observeHandler) this._unwrap(prototype.observeHandler, "observe");
-			if (prototype.llmClient) this._unwrap(prototype.llmClient, "createChatCompletion");
 		}
 		return moduleExports;
 	}
@@ -3215,9 +3250,9 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 			const otelTraceId = parentSpan.spanContext().traceId;
 			const traceId = require_utils.otelTraceIdToUUID(otelTraceId);
 			const result = await original.bind(this).apply(this);
-			instrumentation._wrap(this, "act", instrumentation.patchStagehandGlobalMethod("act", sessionId, parentSpan));
-			instrumentation._wrap(this, "extract", instrumentation.patchStagehandGlobalMethod("extract", sessionId, parentSpan));
-			instrumentation._wrap(this, "observe", instrumentation.patchStagehandGlobalMethod("observe", sessionId, parentSpan));
+			safeWrap(instrumentation, this, "act", instrumentation.patchStagehandGlobalMethod("act", sessionId, parentSpan));
+			safeWrap(instrumentation, this, "extract", instrumentation.patchStagehandGlobalMethod("extract", sessionId, parentSpan));
+			safeWrap(instrumentation, this, "observe", instrumentation.patchStagehandGlobalMethod("observe", sessionId, parentSpan));
 			if (this.actHandler) instrumentation.patchActHandler(this.actHandler);
 			if (this.extractHandler) instrumentation.patchExtractHandler(this.extractHandler);
 			if (this.observeHandler) instrumentation.patchObserveHandler(this.observeHandler);
@@ -3226,9 +3261,10 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 					provider: this.llmClient.type,
 					model: this.llmClient.modelName
 				});
-				instrumentation._wrap(this.llmClient, "createChatCompletion", instrumentation.patchStagehandLLMClientCreateChatCompletion());
+				safeWrap(instrumentation, this.llmClient, "createChatCompletion", instrumentation.patchStagehandLLMClientCreateChatCompletion());
 			}
-			instrumentation._wrap(this, "agent", instrumentation.patchStagehandAgentInitializer(sessionId, parentSpan));
+			if (this.apiClient) instrumentation.patchStagehandApiClient(this.apiClient, sessionId, parentSpan, this);
+			safeWrap(instrumentation, this, "agent", instrumentation.patchStagehandAgentInitializer(sessionId, parentSpan));
 			if (instrumentation._client) await instrumentation.setupSessionRecording(this, sessionId, traceId);
 			if (this.context && this.context.pages) for (const page of this.context.pages()) instrumentation.patchStagehandPage(page, parentSpan);
 			if (this.context && this.context.on) this.context.on("page", (page) => {
@@ -3363,8 +3399,8 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 		};
 	}
 	patchActHandler(actHandler) {
-		this._wrap(actHandler, "act", this.patchActHandlerAct());
-		this._wrap(actHandler, "actFromObserveResult", this.patchActHandlerActFromObserveResult());
+		safeWrap(this, actHandler, "act", this.patchActHandlerAct());
+		safeWrap(this, actHandler, "actFromObserveResult", this.patchActHandlerActFromObserveResult());
 	}
 	patchActHandlerAct() {
 		return (original) => async function act(...args) {
@@ -3393,7 +3429,7 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 		};
 	}
 	patchExtractHandler(extractHandler) {
-		this._wrap(extractHandler, "extract", this.patchExtractHandlerExtract());
+		safeWrap(this, extractHandler, "extract", this.patchExtractHandlerExtract());
 	}
 	patchExtractHandlerExtract() {
 		return (original) => async function extract(...args) {
@@ -3417,7 +3453,7 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 		};
 	}
 	patchObserveHandler(observeHandler) {
-		this._wrap(observeHandler, "observe", this.patchObserveHandlerObserve());
+		safeWrap(this, observeHandler, "observe", this.patchObserveHandlerObserve());
 	}
 	patchObserveHandlerObserve() {
 		return (original) => async function observe$1(...args) {
@@ -3445,7 +3481,7 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 		};
 	}
 	patchStagehandAgent(agent, sessionId, parentSpan) {
-		this._wrap(agent, "execute", this.patchStagehandAgentExecute(sessionId, parentSpan));
+		safeWrap(this, agent, "execute", this.patchStagehandAgentExecute(sessionId, parentSpan));
 		this.wrapAgentMethod(agent, "captureScreenshot", parentSpan, {
 			spanType: "TOOL",
 			ignoreOutput: true
@@ -3512,8 +3548,7 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 		};
 	}
 	wrapAgentMethod(agent, methodName, parentSpan, options) {
-		if (typeof agent[methodName] !== "function") return;
-		this._wrap(agent, methodName, (original) => async function method(...args) {
+		safeWrap(this, agent, methodName, (original) => async function method(...args) {
 			const currentSpan = _opentelemetry_api.trace.getSpan(LaminarContextManager.getContext()) ?? _opentelemetry_api.trace.getActiveSpan();
 			return await Laminar.withSpan(currentSpan ?? parentSpan, async () => await observe({
 				name: `stagehand.agent.${methodName}`,
@@ -3535,13 +3570,77 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 			"keyPress",
 			"keyDown",
 			"keyUp"
-		]) {
-			if (typeof page[methodName] !== "function") continue;
-			this._wrap(page, methodName, (original) => async function method(...args) {
+		]) safeWrap(this, page, methodName, (original) => async function method(...args) {
+			const currentSpan = _opentelemetry_api.trace.getSpan(LaminarContextManager.getContext()) ?? _opentelemetry_api.trace.getActiveSpan();
+			return await Laminar.withSpan(currentSpan ?? parentSpan, async () => await observe({ name: `stagehand.page.${methodName}` }, async (argVals) => await original.bind(this).apply(this, argVals), args));
+		});
+	}
+	/**
+	* In BROWSERBASE remote mode Stagehand's top-level `act`/`extract`/`observe`/
+	* agent `execute` are routed through an internal `StagehandAPIClient` which
+	* makes HTTP calls to the Stagehand Cloud API. The local `llmClient` and the
+	* local `actHandler`/`extractHandler`/`observeHandler` are therefore never
+	* invoked and our existing wrappers do not fire.
+	*
+	* Wrap the apiClient methods directly so we still emit child spans for the
+	* LLM-backed calls and surface token usage from the response where available.
+	*/
+	patchStagehandApiClient(apiClient, _sessionId, parentSpan, stagehandInstance) {
+		const instrumentation = this;
+		const baseProvider = stagehandInstance?.llmClient?.type;
+		const baseModel = stagehandInstance?.llmClient?.modelName;
+		const wrapApiMethod = (methodName) => {
+			safeWrap(instrumentation, apiClient, methodName, (original) => async function method(...args) {
 				const currentSpan = _opentelemetry_api.trace.getSpan(LaminarContextManager.getContext()) ?? _opentelemetry_api.trace.getActiveSpan();
-				return await Laminar.withSpan(currentSpan ?? parentSpan, async () => await observe({ name: `stagehand.page.${methodName}` }, async (argVals) => await original.bind(this).apply(this, argVals), args));
+				const input = nameArgsOrCopy(args);
+				const spanName = methodName === "agentExecute" ? "stagehand.apiClient.agentExecute" : `stagehand.apiClient.${methodName}`;
+				return await Laminar.withSpan(currentSpan ?? parentSpan, async () => await observe({
+					name: spanName,
+					input,
+					spanType: "LLM",
+					ignoreInput: true,
+					ignoreOutput: true
+				}, async () => {
+					const span = _opentelemetry_api.trace.getSpan(LaminarContextManager.getContext()) ?? _opentelemetry_api.trace.getActiveSpan();
+					span?.setAttribute(require_utils.TRACE_HAS_BROWSER_SESSION, true);
+					if (baseProvider) span?.setAttribute("gen_ai.system", baseProvider);
+					if (baseModel) span?.setAttribute("gen_ai.request.model", baseModel);
+					try {
+						const firstArg = args[0];
+						const instruction = typeof firstArg === "string" ? firstArg : firstArg?.input ?? firstArg?.instruction;
+						if (typeof instruction === "string" && instruction.length > 0) span?.setAttributes({
+							"gen_ai.prompt.0.role": "user",
+							"gen_ai.prompt.0.content": instruction
+						});
+					} catch {}
+					const result = await original.bind(this).apply(this, args);
+					try {
+						const usage = result?.usage;
+						if (usage) {
+							const inputTokens = usage.input_tokens ?? usage.prompt_tokens ?? 0;
+							const outputTokens = usage.output_tokens ?? usage.completion_tokens ?? 0;
+							span?.setAttributes({
+								"gen_ai.usage.input_tokens": inputTokens,
+								"gen_ai.usage.output_tokens": outputTokens,
+								"llm.usage.total_tokens": inputTokens + outputTokens
+							});
+						}
+						if (methodName === "agentExecute") {
+							const message = result?.message;
+							if (message) span?.setAttributes({
+								"gen_ai.completion.0.role": "assistant",
+								"gen_ai.completion.0.content": typeof message === "string" ? message : JSON.stringify(message)
+							});
+						}
+					} catch {}
+					return result;
+				}));
 			});
-		}
+		};
+		wrapApiMethod("act");
+		wrapApiMethod("extract");
+		wrapApiMethod("observe");
+		wrapApiMethod("agentExecute");
 	}
 };
 //#endregion
@@ -5877,4 +5976,4 @@ Object.defineProperty(exports, "withTracingLevel", {
 	}
 });
 
-//# sourceMappingURL=decorators-CaTC0lJq.cjs.map
+//# sourceMappingURL=decorators-Bb2owkCc.cjs.map