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

package/dist/{decorators-BDFgXfgI.mjs → decorators-Bq6Sf8vt.mjs}

@@ -1,5 +1,5 @@
 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 { 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);
-		window.lmnrRrweb.record({
+		const recordOptions = {
 			emit(event) {
 				window.lmnrRrwebEventsBatch.push(event);
 			},
@@ -2186,12 +2186,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;
 	}
@@ -3114,6 +3119,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 InstrumentationBase {
 	constructor(sessionRecordingOptions) {
 		super("@lmnr/browserbase-stagehand-instrumentation", version, { enabled: true });
@@ -3165,21 +3193,28 @@ var StagehandInstrumentation = class extends InstrumentationBase {
 	}
 	unpatch(moduleExports, moduleVersion) {
 		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;
 	}
@@ -3211,9 +3246,9 @@ var StagehandInstrumentation = class extends InstrumentationBase {
 			const otelTraceId = parentSpan.spanContext().traceId;
 			const traceId = 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);
@@ -3222,9 +3257,10 @@ var StagehandInstrumentation = class extends InstrumentationBase {
 					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) => {
@@ -3359,8 +3395,8 @@ var StagehandInstrumentation = class extends InstrumentationBase {
 		};
 	}
 	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) {
@@ -3389,7 +3425,7 @@ var StagehandInstrumentation = class extends InstrumentationBase {
 		};
 	}
 	patchExtractHandler(extractHandler) {
-		this._wrap(extractHandler, "extract", this.patchExtractHandlerExtract());
+		safeWrap(this, extractHandler, "extract", this.patchExtractHandlerExtract());
 	}
 	patchExtractHandlerExtract() {
 		return (original) => async function extract(...args) {
@@ -3413,7 +3449,7 @@ var StagehandInstrumentation = class extends InstrumentationBase {
 		};
 	}
 	patchObserveHandler(observeHandler) {
-		this._wrap(observeHandler, "observe", this.patchObserveHandlerObserve());
+		safeWrap(this, observeHandler, "observe", this.patchObserveHandlerObserve());
 	}
 	patchObserveHandlerObserve() {
 		return (original) => async function observe$1(...args) {
@@ -3441,7 +3477,7 @@ var StagehandInstrumentation = class extends InstrumentationBase {
 		};
 	}
 	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
@@ -3508,8 +3544,7 @@ var StagehandInstrumentation = class extends InstrumentationBase {
 		};
 	}
 	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 = trace.getSpan(LaminarContextManager.getContext()) ?? trace.getActiveSpan();
 			return await Laminar.withSpan(currentSpan ?? parentSpan, async () => await observe({
 				name: `stagehand.agent.${methodName}`,
@@ -3531,13 +3566,77 @@ var StagehandInstrumentation = class extends InstrumentationBase {
 			"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 = 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) {
 				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));
+				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;
+				}));
 			});
-		}
+		};
+		wrapApiMethod("act");
+		wrapApiMethod("extract");
+		wrapApiMethod("observe");
+		wrapApiMethod("agentExecute");
 	}
 };
 //#endregion
@@ -5778,4 +5877,4 @@ 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 };
 
-//# sourceMappingURL=decorators-BDFgXfgI.mjs.map
+//# sourceMappingURL=decorators-Bq6Sf8vt.mjs.map