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

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-LxN0pWBY.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-BKinfQHD.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-B7-TO5Cy.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-CUxvL7k9.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-Bq6Sf8vt.mjs → decorators-BKinfQHD.mjs}

@@ -1,5 +1,5 @@
 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-CUxvL7k9.mjs";
 import { A as SPAN_OUTPUT, C as PARENT_SPAN_PATH, D as SPAN_INPUT, E as SPAN_IDS_PATH, F as TRACE_TYPE, I as USER_ID, M as SPAN_SDK_VERSION, N as SPAN_TYPE, O as SPAN_INSTRUMENTATION_SOURCE, P as TRACE_HAS_BROWSER_SESSION, S as PARENT_SPAN_IDS_PATH, T as SESSION_ID, _ as validateTracingConfig, c as loadEnv, g as tryToOtelSpanContext, h as parseOtelHeaders, j as SPAN_PATH, k as SPAN_LANGUAGE_VERSION, l as metadataToAttributes, m as otelTraceIdToUUID, o as getOtelEnvVar, p as otelSpanIdToUUID, r as deserializeLaminarSpanContext, s as initializeLogger, t as NIL_UUID, u as newUUID, v as ASSOCIATION_PROPERTIES, w as ROLLOUT_SESSION_ID, x as LaminarAttributes, y as ASSOCIATION_PROPERTIES_OVERRIDES } from "./utils-CHJ0KZUR.mjs";
 import { DiagConsoleLogger, DiagLogLevel, ROOT_CONTEXT, SpanStatusCode, context, createContextKey, diag, isSpanContextValid, trace } from "@opentelemetry/api";
 import { AsyncLocalStorageContextManager } from "@opentelemetry/context-async-hooks";
@@ -2170,7 +2170,7 @@ const injectScript = (sessionRecordingOptions, stringifyCallbackArgs) => {
 	};
 	if (!window.lmnrStartedRecordingEvents) {
 		setInterval(sendBatchIfReady, BATCH_TIMEOUT);
-		const recordOptions = {
+		window.lmnrRrweb.record({
 			emit(event) {
 				window.lmnrRrwebEventsBatch.push(event);
 			},
@@ -2186,17 +2186,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;
 	}
@@ -2925,14 +2920,26 @@ function shouldSkipUrl(url) {
 	return SKIP_URL_PATTERNS.some((pattern) => url.startsWith(pattern));
 }
 /**
+* Send a CDP command to the given page. Works across Stagehand 3.0.x and 3.1.x+.
+*
+* `page.sendCDP` was added in Stagehand 3.1.0. On 3.0.x we fall back to
+* `getSessionForFrame(mainFrameId()).send(...)` (both methods are public on
+* the 3.0.x Page; `mainSession` is not).
+*/
+async function sendCDP(page, method, params) {
+	if (typeof page.sendCDP === "function") return await page.sendCDP(method, params);
+	if (typeof page.getSessionForFrame === "function") return await page.getSessionForFrame(page.mainFrameId()).send(method, params);
+	throw new Error("Stagehand page does not expose sendCDP or getSessionForFrame; unable to send CDP commands");
+}
+/**
 * Create an isolated world for a page and return the execution context ID
 */
 async function getOrCreateIsolatedWorld(page) {
 	try {
-		const frameTreeResult = await Promise.race([page.sendCDP("Page.getFrameTree"), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("Timeout getting frame tree")), CDP_OPERATION_TIMEOUT_MS))]);
+		const frameTreeResult = await Promise.race([sendCDP(page, "Page.getFrameTree"), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("Timeout getting frame tree")), CDP_OPERATION_TIMEOUT_MS))]);
 		if (!frameTreeResult) return null;
 		const frameId = frameTreeResult.frameTree.frame.id;
-		const isolatedWorldResult = await Promise.race([page.sendCDP("Page.createIsolatedWorld", {
+		const isolatedWorldResult = await Promise.race([sendCDP(page, "Page.createIsolatedWorld", {
 			frameId,
 			worldName: "laminar-recorder"
 		}), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("Timeout creating isolated world")), CDP_OPERATION_TIMEOUT_MS))]);
@@ -2951,7 +2958,7 @@ async function getOrCreateIsolatedWorld(page) {
 */
 async function isRecorderPresent(page, contextId) {
 	try {
-		const result = await Promise.race([page.sendCDP("Runtime.evaluate", {
+		const result = await Promise.race([sendCDP(page, "Runtime.evaluate", {
 			expression: "typeof window.lmnrRrweb !== 'undefined'",
 			contextId,
 			returnByValue: true
@@ -2994,7 +3001,7 @@ async function injectRecorderViaCDP(page, state, conn, sessionRecordingOptions,
 			return contextId;
 		}
 		try {
-			await page.sendCDP("Runtime.evaluate", {
+			await sendCDP(page, "Runtime.evaluate", {
 				expression: RECORDER,
 				contextId
 			});
@@ -3005,7 +3012,7 @@ async function injectRecorderViaCDP(page, state, conn, sessionRecordingOptions,
 		const optionsJson = JSON.stringify(sessionRecordingOptions ?? {});
 		const injectExpression = `(${injectScript.toString()})(${optionsJson}, true);`;
 		try {
-			await page.sendCDP("Runtime.evaluate", {
+			await sendCDP(page, "Runtime.evaluate", {
 				expression: injectExpression,
 				contextId
 			});
@@ -3014,7 +3021,7 @@ async function injectRecorderViaCDP(page, state, conn, sessionRecordingOptions,
 			return null;
 		}
 		try {
-			await page.sendCDP("Runtime.addBinding", { name: "lmnrSendEvents" });
+			await sendCDP(page, "Runtime.addBinding", { name: "lmnrSendEvents" });
 			logger$8.debug(`Added binding 'lmnrSendEvents' for page ${frameId}, context ${contextId}`);
 		} catch (error) {
 			logger$8.debug(`Binding may already exist: ${error instanceof Error ? error.message : String(error)}`);
@@ -3119,29 +3126,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 InstrumentationBase {
 	constructor(sessionRecordingOptions) {
 		super("@lmnr/browserbase-stagehand-instrumentation", version, { enabled: true });
@@ -3193,28 +3177,21 @@ var StagehandInstrumentation = class extends InstrumentationBase {
 	}
 	unpatch(moduleExports, moduleVersion) {
 		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;
 	}
@@ -3246,9 +3223,9 @@ var StagehandInstrumentation = class extends InstrumentationBase {
 			const otelTraceId = parentSpan.spanContext().traceId;
 			const traceId = 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);
@@ -3257,10 +3234,9 @@ var StagehandInstrumentation = class extends InstrumentationBase {
 					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) => {
@@ -3395,8 +3371,8 @@ var StagehandInstrumentation = class extends InstrumentationBase {
 		};
 	}
 	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) {
@@ -3425,7 +3401,7 @@ var StagehandInstrumentation = class extends InstrumentationBase {
 		};
 	}
 	patchExtractHandler(extractHandler) {
-		safeWrap(this, extractHandler, "extract", this.patchExtractHandlerExtract());
+		this._wrap(extractHandler, "extract", this.patchExtractHandlerExtract());
 	}
 	patchExtractHandlerExtract() {
 		return (original) => async function extract(...args) {
@@ -3449,7 +3425,7 @@ var StagehandInstrumentation = class extends InstrumentationBase {
 		};
 	}
 	patchObserveHandler(observeHandler) {
-		safeWrap(this, observeHandler, "observe", this.patchObserveHandlerObserve());
+		this._wrap(observeHandler, "observe", this.patchObserveHandlerObserve());
 	}
 	patchObserveHandlerObserve() {
 		return (original) => async function observe$1(...args) {
@@ -3477,7 +3453,7 @@ var StagehandInstrumentation = class extends InstrumentationBase {
 		};
 	}
 	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
@@ -3544,7 +3520,8 @@ var StagehandInstrumentation = class extends InstrumentationBase {
 		};
 	}
 	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 = trace.getSpan(LaminarContextManager.getContext()) ?? trace.getActiveSpan();
 			return await Laminar.withSpan(currentSpan ?? parentSpan, async () => await observe({
 				name: `stagehand.agent.${methodName}`,
@@ -3566,77 +3543,13 @@ var StagehandInstrumentation = class extends InstrumentationBase {
 			"keyPress",
 			"keyDown",
 			"keyUp"
-		]) safeWrap(this, page, methodName, (original) => async function method(...args) {
-			const currentSpan = trace.getSpan(LaminarContextManager.getContext()) ?? 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 = trace.getSpan(LaminarContextManager.getContext()) ?? 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 = trace.getSpan(LaminarContextManager.getContext()) ?? trace.getActiveSpan();
-					span?.setAttribute(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
@@ -5875,6 +5788,6 @@ function observeExperimentalDecorator(config) {
 	};
 }
 //#endregion
-export { getSpanProcessor as a, LaminarSpanProcessor as c, Laminar as d, instrumentClaudeAgentQuery as f, stringifyPromptForTelemetry as g, consumeStreamResult as h, withTracingLevel as i, getLangVersion as l, TracingLevel as m, observeDecorator as n, getTracer as o, LaminarContextManager as p, observeExperimentalDecorator as r, getTracerProvider as s, observe as t, initializeLaminarInstrumentations as u };
+export { stringifyPromptForTelemetry as _, getSpanProcessor as a, LaminarSpanProcessor as c, Laminar as d, instrumentClaudeAgentQuery as f, consumeStreamResult as g, TracingLevel as h, withTracingLevel as i, getLangVersion as l, LaminarContextManager as m, observeDecorator as n, getTracer as o, ASSOCIATION_PROPERTIES_KEY as p, observeExperimentalDecorator as r, getTracerProvider as s, observe as t, initializeLaminarInstrumentations as u };
 
-//# sourceMappingURL=decorators-Bq6Sf8vt.mjs.map
+//# sourceMappingURL=decorators-BKinfQHD.mjs.map