stagehand 4.0.3a0.dev1474__tar.gz → 4.0.3a0.dev1475__tar.gz

{stagehand-4.0.3a0.dev1474 → stagehand-4.0.3a0.dev1475}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stagehand
-Version: 4.0.3a0.dev1474
+Version: 4.0.3a0.dev1475
 Summary: Browserbase's SDK for building browser agents
 Keywords: ai,browser,automation,web-scraping,testing
 Author: Browserbase

{stagehand-4.0.3a0.dev1474 → stagehand-4.0.3a0.dev1475}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "stagehand"
-version = "4.0.3a0.dev1474"
+version = "4.0.3a0.dev1475"
 description = "Browserbase's SDK for building browser agents"
 readme = "README.md"
 requires-python = ">=3.11"

{stagehand-4.0.3a0.dev1474 → stagehand-4.0.3a0.dev1475}/src/stagehand/_extension/service-worker.js

@@ -7359,7 +7359,7 @@ function isRecord$1(value) {
 }
 var package_default$1 = {
 	name: "@browserbasehq/stagehand-protocol",
-	version: "2.0.0-alpha-d49d643ce9311f16b3ab21289c3bcc01bf0eb097",
+	version: "2.0.0-alpha-341433acac46a305ad6c2f9a0445e907675f4fb4",
 	"private": true,
 	type: "module",
 	scripts: {
@@ -11460,7 +11460,9 @@ var RPCClient = class {
 			});
 			return;
 		}
+		let releaseStagehandInstanceRequest;
 		try {
+			if (request.data.method !== StagehandMethods.stagehandInit.name && request.data.method !== StagehandMethods.stagehandClose.name) releaseStagehandInstanceRequest = this.router.runtime.acquireStagehandInstanceRequest();
 			const result = await this.router.handle(stagehandRequest.data, runtimeAttachments);
 			const parsedResult = method.result.safeParse(result);
 			if (!parsedResult.success) {
@@ -11470,6 +11472,7 @@ var RPCClient = class {
 				});
 				return;
 			}
+			await this.router.beforeResponse(stagehandRequest.data);
 			await this.runtime.send(JSONRPCSuccessResponseSchema.parse({
 				jsonrpc: "2.0",
 				id: request.data.id,
@@ -11484,6 +11487,8 @@ var RPCClient = class {
 				return;
 			}
 			await this.sendError(request.data.id, JSONRPCErrorCodes.internalError, error instanceof Error ? error.message : String(error), { name: error instanceof Error ? error.name : "Error" });
+		} finally {
+			releaseStagehandInstanceRequest?.();
 		}
 	}
 	receiveResponse(response) {
@@ -50846,13 +50851,13 @@ async function observe({ params, page, model, clientLLMGenerate, logger, systemP
 //#endregion
 //#region controllers/stagehandController.ts
 function createStagehandController(runtime, options = {}) {
-	const closeRuntime = options.close ?? (() => runtime.close());
+	const closeRuntime = options.close ?? (() => runtime.disposeStagehandInstance());
 	async function runOperation(name, { logger, telemetryScope }, run) {
 		return await logger.span(name, {}, (logger) => runtime.runWithTelemetryContext(telemetryScope, logger, () => run(logger)));
 	}
 	async function init(params, { logger }) {
 		const compatibility = checkProtocolCompatibility(params.protocolVersion, STAGEHAND_PROTOCOL_VERSION);
-		if (!compatibility.compatible) throw new StagehandProtocolCompatibilityError(compatibility.reason);
+		if (compatibility.compatible === false) throw new StagehandProtocolCompatibilityError(compatibility.reason);
 		logger.setLevel(params.logLevel);
 		logger.info("stagehand.init", {});
 		return options.initialize ? await options.initialize(params) : await runtime.initialize(params, logger);
@@ -50961,7 +50966,7 @@ var RPCRouter = class {
 	}
 	async handle(request, runtimeAttachments) {
 		const initParams = request.method === StagehandMethods.stagehandInit.name ? request.params : void 0;
-		if (initParams) this.runtime.tracing.configure(initParams.telemetry, initParams.clientInfo);
+		if (initParams) await this.runtime.tracing.configure(initParams.telemetry, initParams.clientInfo);
 		const parentContext = W3C_TRACE_CONTEXT_PROPAGATOR.extract(ROOT_CONTEXT, request, {
 			get(carrier, key) {
 				if (key === "traceparent" || key === "tracestate") return carrier[key];
@@ -50996,9 +51001,12 @@ var RPCRouter = class {
 			throw error;
 		} finally {
 			span.end();
-			if (request.method === StagehandMethods.stagehandClose.name) await this.runtime.tracing.shutdown();
 		}
 	}
+	async beforeResponse(request) {
+		if (request.method !== StagehandMethods.stagehandClose.name) return;
+		await this.runtime.tracing.forceFlush().catch(() => void 0);
+	}
 	async route(request, context, parsedInitParams) {
 		switch (request.method) {
 			case "stagehand.init": return this.stagehandController.init(parsedInitParams ?? parseParams(StagehandMethods.stagehandInit, request.params), context);
@@ -51260,14 +51268,10 @@ var StagehandLogger = class StagehandLogger {
 };
 //#endregion
 //#region runtimeState.ts
-var StagehandRuntimeStateSchema = discriminatedUnion("status", [
-	strictObject({ status: literal("created") }),
-	strictObject({
-		status: literal("initialized"),
-		initParams: StagehandInitParamsSchema
-	}),
-	strictObject({ status: literal("closed") })
-]);
+var StagehandRuntimeStateSchema = discriminatedUnion("status", [strictObject({ status: literal("idle") }), strictObject({
+	status: literal("initialized"),
+	initParams: StagehandInitParamsSchema
+})]);
 //#endregion
 //#region ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.220.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/otlp-exporter-base/build/esm/OTLPExporterBase.js
 var OTLPExporterBase = class {
@@ -53443,7 +53447,7 @@ var WebTracerProvider = class extends BasicTracerProvider {
 };
 var package_default = {
 	name: "@browserbasehq/stagehand-extension",
-	version: "1.0.2-alpha-d49d643ce9311f16b3ab21289c3bcc01bf0eb097",
+	version: "1.0.2-alpha-341433acac46a305ad6c2f9a0445e907675f4fb4",
 	"private": true,
 	type: "module",
 	scripts: {
@@ -53518,22 +53522,48 @@ function createStagehandTracing(options = {}, dependencies = DEFAULT_TRACING_RUN
 	const pendingTracer = trace.getTracer(STAGEHAND_TRACER_NAME);
 	let runtime;
 	let shutDown = false;
+	let globalsRegistered = false;
+	let lifecycleTail = Promise.resolve();
+	let activeTelemetry;
+	let activeClientInfo;
+	function enqueueLifecycle(run) {
+		const result = lifecycleTail.then(run, run);
+		lifecycleTail = result.catch(() => void 0);
+		return result;
+	}
 	return {
 		get tracer() {
 			return runtime?.tracer ?? pendingTracer;
 		},
 		configure(telemetry, clientInfo) {
-			if (runtime || shutDown) return;
-			runtime = createStagehandTracingRuntime({
-				...options,
-				clientName: clientInfo.name,
-				clientVersion: clientInfo.version
-			}, { spanProcessors: [...dependencies.spanProcessors, createOtlpSpanProcessor(telemetry.traces)] });
+			return enqueueLifecycle(async () => {
+				if (shutDown) return;
+				if (runtime && telemetry === activeTelemetry && clientInfo === activeClientInfo) return;
+				const previousRuntime = runtime;
+				runtime = void 0;
+				await previousRuntime?.shutdown();
+				const registerGlobals = options.registerGlobals !== false && !globalsRegistered;
+				runtime = createStagehandTracingRuntime({
+					...options,
+					clientName: clientInfo.name,
+					clientVersion: clientInfo.version,
+					registerGlobals
+				}, { spanProcessors: [...dependencies.spanProcessors, createOtlpSpanProcessor(telemetry.traces)] });
+				activeTelemetry = telemetry;
+				activeClientInfo = clientInfo;
+				globalsRegistered ||= registerGlobals;
+			});
 		},
-		forceFlush: () => runtime?.forceFlush() ?? Promise.resolve(),
+		forceFlush: () => enqueueLifecycle(() => runtime?.forceFlush() ?? Promise.resolve()),
 		shutdown: () => {
 			shutDown = true;
-			return runtime?.shutdown() ?? Promise.resolve();
+			return enqueueLifecycle(async () => {
+				const activeRuntime = runtime;
+				runtime = void 0;
+				activeTelemetry = void 0;
+				activeClientInfo = void 0;
+				await activeRuntime?.shutdown();
+			});
 		}
 	};
 }
@@ -56822,6 +56852,9 @@ var StagehandMetricsAccumulator = class {
 	snapshot() {
 		return { ...this.values };
 	}
+	reset() {
+		Object.assign(this.values, EMPTY_METRICS);
+	}
 };
 //#endregion
 //#region responseHandleTable.ts
@@ -56909,10 +56942,13 @@ var StagehandRuntime = class {
 		this.tracing = tracing;
 		this.metrics = new StagehandMetricsAccumulator();
 		this.responseHandles = new ResponseHandleTable();
-		this.state = createStore()(() => StagehandRuntimeStateSchema.parse({ status: "created" }));
+		this.state = createStore()(() => StagehandRuntimeStateSchema.parse({ status: "idle" }));
 		this.pagesById = /* @__PURE__ */ new Map();
 		this.pageEventSubscriptions = /* @__PURE__ */ new Map();
 		this.initializationInProgress = false;
+		this.lifecycleTail = Promise.resolve();
+		this.stagehandInstanceClosing = false;
+		this.activeStagehandInstanceRequests = 0;
 		this.logger = new StagehandLogger(tracing, adapters.emitLog);
 	}
 	async replaceBrowserConnection(params, bootstrapLogger) {
@@ -56932,29 +56968,31 @@ var StagehandRuntime = class {
 		}
 	}
 	async initialize(params, logger = this.logger) {
-		const state = this.state.getState();
-		if (state.status === "closed") throw new Error("Stagehand has been closed and cannot be initialized again");
 		if (this.initializationInProgress) throw new Error("Stagehand initialization is already in progress");
 		this.initializationInProgress = true;
 		try {
-			this.logger.setLevel(params.logLevel);
-			if (!this.browserSession) {
-				if (!params.browserCdpUrl) throw new Error("stagehand.init requires browserCdpUrl until resident mode is active");
-				await this.replaceBrowserConnection({ cdpUrl: params.browserCdpUrl }, logger);
-			}
-			const pages = await this.runWithTelemetryContext(Symbol("stagehand.init"), logger, async () => {
-				if (state.status === "created") await this.browserSession?.prepareForInitialization?.();
-				return await this.contextPages();
-			});
-			this.tracing.configure(params.telemetry, params.clientInfo);
-			this.state.setState(StagehandRuntimeStateSchema.parse({
-				status: "initialized",
-				initParams: params
-			}), true);
-			return {
-				initialized: true,
-				pages
-			};
+			return await this.enqueueLifecycle(async () => {
+				const state = this.state.getState();
+				if (state.status !== "idle") throw new Error("A Stagehand instance is already initialized");
+				this.logger.setLevel(params.logLevel);
+				if (!this.browserSession?.connected) {
+					if (!params.browserCdpUrl) throw new Error("stagehand.init requires browserCdpUrl until resident mode is active");
+					await this.replaceBrowserConnection({ cdpUrl: params.browserCdpUrl }, logger);
+				}
+				const pages = await this.runWithTelemetryContext(Symbol("stagehand.init"), logger, async () => {
+					if (state.status === "idle") await this.browserSession?.prepareForInitialization?.();
+					return await this.contextPages();
+				});
+				await this.tracing.configure(params.telemetry, params.clientInfo);
+				this.state.setState(StagehandRuntimeStateSchema.parse({
+					status: "initialized",
+					initParams: params
+				}), true);
+				return {
+					initialized: true,
+					pages
+				};
+			});
 		} finally {
 			this.initializationInProgress = false;
 		}
@@ -57291,16 +57329,64 @@ var StagehandRuntime = class {
 		return { set: true };
 	}
 	async close() {
-		const session = this.browserSession;
-		this.browserSession = void 0;
+		await this.enqueueLifecycle(async () => {
+			const session = this.browserSession;
+			this.browserSession = void 0;
+			this.clearStagehandInstance();
+			await session?.close();
+		});
+	}
+	async disposeStagehandInstance() {
+		if (this.stagehandInstanceDisposal) return await this.stagehandInstanceDisposal;
+		this.stagehandInstanceClosing = true;
+		const disposal = this.enqueueLifecycle(async () => {
+			await this.waitForStagehandInstanceRequests();
+			this.clearStagehandInstance();
+		});
+		this.stagehandInstanceDisposal = disposal.finally(() => {
+			this.stagehandInstanceClosing = false;
+			this.stagehandInstanceDisposal = void 0;
+		});
+		return await this.stagehandInstanceDisposal;
+	}
+	acquireStagehandInstanceRequest() {
+		if (this.stagehandInstanceClosing) throw new Error("Stagehand instance is closing");
+		this.activeStagehandInstanceRequests += 1;
+		let released = false;
+		return () => {
+			if (released) return;
+			released = true;
+			this.activeStagehandInstanceRequests -= 1;
+			if (this.activeStagehandInstanceRequests !== 0) return;
+			this.stagehandInstanceRequestsDrained?.resolve();
+			this.stagehandInstanceRequestsDrained = void 0;
+		};
+	}
+	clearStagehandInstance() {
 		this.disposeAllPageEventSubscriptions();
 		this.pagesById.clear();
 		this.responseHandles.clear();
-		try {
-			await session?.close();
-		} finally {
-			this.state.setState(StagehandRuntimeStateSchema.parse({ status: "closed" }), true);
+		this.metrics.reset();
+		this.state.setState(StagehandRuntimeStateSchema.parse({ status: "idle" }), true);
+	}
+	enqueueLifecycle(run) {
+		const result = this.lifecycleTail.then(run, run);
+		this.lifecycleTail = result.then(() => void 0, () => void 0);
+		return result;
+	}
+	waitForStagehandInstanceRequests() {
+		if (this.activeStagehandInstanceRequests === 0) return Promise.resolve();
+		if (!this.stagehandInstanceRequestsDrained) {
+			let resolve;
+			const promise = new Promise((drained) => {
+				resolve = drained;
+			});
+			this.stagehandInstanceRequestsDrained = {
+				promise,
+				resolve
+			};
 		}
+		return this.stagehandInstanceRequestsDrained.promise;
 	}
 	pageRefForId(pageId) {
 		return pageRefFromUnderstudyPage(this.resolvePage(pageId));

{stagehand-4.0.3a0.dev1474 → stagehand-4.0.3a0.dev1475}/src/stagehand/_generated/protocol_version.py

@@ -1,4 +1,4 @@
 """Generated from packages/protocol/package.json. Do not edit."""
 
 PROTOCOL_SEMVER_PATTERN = '^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[A-Za-z-][0-9A-Za-z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[A-Za-z-][0-9A-Za-z-]*))*))?(?:\\+([0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?$'
-STAGEHAND_PROTOCOL_VERSION = '2.0.0-alpha-d49d643ce9311f16b3ab21289c3bcc01bf0eb097'
+STAGEHAND_PROTOCOL_VERSION = '2.0.0-alpha-341433acac46a305ad6c2f9a0445e907675f4fb4'

{stagehand-4.0.3a0.dev1474 → stagehand-4.0.3a0.dev1475}/src/stagehand/stagehand.py

@@ -450,6 +450,7 @@ class Stagehand:
 
     async def close(self) -> None:
         async def close_impl() -> None:
+            release_browser_claim = not self._initialized
             try:
                 if self._initialized and self._rpc_client is not None:
                     try:
@@ -458,10 +459,15 @@ class Stagehand:
                             EmptyParams(),
                             StagehandCloseResult,
                         )
+                        release_browser_claim = True
                     except CDPConnectionClosedError:
-                        pass
+                        release_browser_claim = True
             finally:
-                await asyncio.shield(self._release_resources())
+                try:
+                    await asyncio.shield(self._release_resources())
+                finally:
+                    if release_browser_claim:
+                        _release_browser(self._browser_handle)
 
         if self._close_task is None:
             self._close_task = asyncio.create_task(