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

package/dist/cli/worker/index.cjs

@@ -1,5 +1,5 @@
 const require_chunk = require("../../chunk-Do9eywBl.cjs");
-const require_decorators = require("../../decorators-Bb2owkCc.cjs");
+const require_decorators = require("../../decorators-CKzMiD2H.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-Bq6Sf8vt.mjs";
+import { d as Laminar, g as consumeStreamResult } from "../../decorators-DrWG-1Po.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-DZMJR04H.cjs");
+const require_dist = require("./dist-CzSNkDiM.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-TLHkfisO.mjs";
+import { n as version, t as LaminarClient } from "./dist-BXwORFgR.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-Bb2owkCc.cjs → decorators-CKzMiD2H.cjs}

@@ -1,5 +1,5 @@
 const require_chunk = require("./chunk-Do9eywBl.cjs");
-const require_dist = require("./dist-DZMJR04H.cjs");
+const require_dist = require("./dist-CzSNkDiM.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);
-		const recordOptions = {
+		window.lmnrRrweb.record({
 			emit(event) {
 				window.lmnrRrwebEventsBatch.push(event);
 			},
@@ -2190,17 +2190,12 @@ const injectScript = (sessionRecordingOptions, stringifyCallbackArgs) => {
 				email: sessionRecordingOptions?.maskInputOptions?.email || false,
 				tel: sessionRecordingOptions?.maskInputOptions?.tel || false
 			}
-		};
-		window.lmnrRrweb.record(recordOptions);
+		});
 		setInterval(() => {
-			try {
-				window.lmnrRrweb.record.addCustomEvent("heartbeat", {
-					title: document.title,
-					url: document.URL
-				});
-			} catch {
-				window.lmnrRrweb.record(recordOptions);
-			}
+			window.lmnrRrweb.record.addCustomEvent("heartbeat", {
+				title: document.title,
+				url: document.URL
+			});
 		}, HEARTBEAT_INTERVAL);
 		window.lmnrStartedRecordingEvents = true;
 	}
@@ -3123,29 +3118,6 @@ 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 });
@@ -3197,28 +3169,21 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 	}
 	unpatch(moduleExports, moduleVersion) {
 		_opentelemetry_api.diag.debug(`unpatching stagehand ${moduleVersion}`);
-		safeUnwrap(this, moduleExports, "Stagehand");
+		this._unwrap(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) {
-				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");
+				this._unwrap(prototype.actHandler, "act");
+				this._unwrap(prototype.actHandler, "actFromObserveResult");
 			}
+			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;
 	}
@@ -3250,9 +3215,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);
-			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));
+			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));
 			if (this.actHandler) instrumentation.patchActHandler(this.actHandler);
 			if (this.extractHandler) instrumentation.patchExtractHandler(this.extractHandler);
 			if (this.observeHandler) instrumentation.patchObserveHandler(this.observeHandler);
@@ -3261,10 +3226,9 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 					provider: this.llmClient.type,
 					model: this.llmClient.modelName
 				});
-				safeWrap(instrumentation, this.llmClient, "createChatCompletion", instrumentation.patchStagehandLLMClientCreateChatCompletion());
+				instrumentation._wrap(this.llmClient, "createChatCompletion", instrumentation.patchStagehandLLMClientCreateChatCompletion());
 			}
-			if (this.apiClient) instrumentation.patchStagehandApiClient(this.apiClient, sessionId, parentSpan, this);
-			safeWrap(instrumentation, this, "agent", instrumentation.patchStagehandAgentInitializer(sessionId, parentSpan));
+			instrumentation._wrap(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) => {
@@ -3399,8 +3363,8 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 		};
 	}
 	patchActHandler(actHandler) {
-		safeWrap(this, actHandler, "act", this.patchActHandlerAct());
-		safeWrap(this, actHandler, "actFromObserveResult", this.patchActHandlerActFromObserveResult());
+		this._wrap(actHandler, "act", this.patchActHandlerAct());
+		this._wrap(actHandler, "actFromObserveResult", this.patchActHandlerActFromObserveResult());
 	}
 	patchActHandlerAct() {
 		return (original) => async function act(...args) {
@@ -3429,7 +3393,7 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 		};
 	}
 	patchExtractHandler(extractHandler) {
-		safeWrap(this, extractHandler, "extract", this.patchExtractHandlerExtract());
+		this._wrap(extractHandler, "extract", this.patchExtractHandlerExtract());
 	}
 	patchExtractHandlerExtract() {
 		return (original) => async function extract(...args) {
@@ -3453,7 +3417,7 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 		};
 	}
 	patchObserveHandler(observeHandler) {
-		safeWrap(this, observeHandler, "observe", this.patchObserveHandlerObserve());
+		this._wrap(observeHandler, "observe", this.patchObserveHandlerObserve());
 	}
 	patchObserveHandlerObserve() {
 		return (original) => async function observe$1(...args) {
@@ -3481,7 +3445,7 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 		};
 	}
 	patchStagehandAgent(agent, sessionId, parentSpan) {
-		safeWrap(this, agent, "execute", this.patchStagehandAgentExecute(sessionId, parentSpan));
+		this._wrap(agent, "execute", this.patchStagehandAgentExecute(sessionId, parentSpan));
 		this.wrapAgentMethod(agent, "captureScreenshot", parentSpan, {
 			spanType: "TOOL",
 			ignoreOutput: true
@@ -3548,7 +3512,8 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 		};
 	}
 	wrapAgentMethod(agent, methodName, parentSpan, options) {
-		safeWrap(this, agent, methodName, (original) => async function method(...args) {
+		if (typeof agent[methodName] !== "function") return;
+		this._wrap(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}`,
@@ -3570,77 +3535,13 @@ var StagehandInstrumentation = class extends _opentelemetry_instrumentation.Inst
 			"keyPress",
 			"keyDown",
 			"keyUp"
-		]) 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) {
+		]) {
+			if (typeof page[methodName] !== "function") continue;
+			this._wrap(page, methodName, (original) => async function method(...args) {
 				const currentSpan = _opentelemetry_api.trace.getSpan(LaminarContextManager.getContext()) ?? _opentelemetry_api.trace.getActiveSpan();
-				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;
-				}));
+				return await Laminar.withSpan(currentSpan ?? parentSpan, async () => await observe({ name: `stagehand.page.${methodName}` }, async (argVals) => await original.bind(this).apply(this, argVals), args));
 			});
-		};
-		wrapApiMethod("act");
-		wrapApiMethod("extract");
-		wrapApiMethod("observe");
-		wrapApiMethod("agentExecute");
+		}
 	}
 };
 //#endregion
@@ -5879,6 +5780,12 @@ function observeExperimentalDecorator(config) {
 	};
 }
 //#endregion
+Object.defineProperty(exports, "ASSOCIATION_PROPERTIES_KEY", {
+	enumerable: true,
+	get: function() {
+		return ASSOCIATION_PROPERTIES_KEY;
+	}
+});
 Object.defineProperty(exports, "Laminar", {
 	enumerable: true,
 	get: function() {
@@ -5976,4 +5883,4 @@ Object.defineProperty(exports, "withTracingLevel", {
 	}
 });
 
-//# sourceMappingURL=decorators-Bb2owkCc.cjs.map
+//# sourceMappingURL=decorators-CKzMiD2H.cjs.map