effect-browserbase 0.1.0-beta.102

package/dist/Acquisition-WBafHwXH.mjs

@@ -0,0 +1,280 @@
+import { Identifier, SessionReference } from "./References.mjs";
+import { AllocationError, ContextError, SessionError } from "./Errors.mjs";
+import { t as BrowserbaseClient } from "./Client-D1_xYM9o.mjs";
+import { t as compileLaunch } from "./Launch-BHcAEq05.mjs";
+import { ProviderSession } from "./SessionData.mjs";
+import { CleanupIssue, CleanupResult } from "./Cleanup.mjs";
+import { i as requireContextWriterPermit } from "./ContextWriter-BrQmoXRg.mjs";
+import { n as nowMillis, r as until, t as deadlineAfter } from "./Deadline-CrViaogr.mjs";
+import { t as BrowserbaseSessions } from "./Sessions-CtbseWEh.mjs";
+import { Cause, Clock, Data, Effect, ErrorReporter, Exit, Option, Redacted, Schema, Scope } from "effect";
+//#region src/internal/provider/Connection.ts
+const Connection = Schema.Struct({
+	...ProviderSession.fields,
+	connectUrl: Schema.String.check(Schema.isMaxLength(16384))
+});
+/** A provider-issued endpoint is authority, not a persisted session identifier. */
+const connectionUrl = Schema.String.check(Schema.isMaxLength(16384), Schema.makeFilter((value) => {
+	try {
+		const url = new URL(value);
+		return url.protocol === "wss:" && !url.username && !url.password && !url.port && !url.hash && url.hostname.endsWith(".browserbase.com");
+	} catch {
+		return false;
+	}
+}));
+const connectionAddress = Effect.fnUntraced(function* (client, sessions, reference, timeoutMillis) {
+	const fail = (reason) => SessionError.make({
+		operation: "session-connect",
+		reason
+	});
+	const ref = yield* Schema.decodeEffect(SessionReference)(reference).pipe(Effect.mapError(() => fail("configuration")));
+	if (ref.projectId !== client.projectId) return yield* fail("authorization");
+	const deadline = yield* deadlineAfter(timeoutMillis);
+	yield* sessions.waitUntilRunning(ref, { timeoutMillis });
+	if ((yield* nowMillis) >= deadline) return yield* fail("timeout");
+	const raw = yield* until(client.json("GET", `/v1/sessions/${encodeURIComponent(ref.sessionId)}`, void 0, deadline), deadline, () => fail("timeout")).pipe(Effect.mapError((error) => fail(error.reason)));
+	const value = yield* Schema.decodeUnknownEffect(Connection)(raw).pipe(Effect.mapError(() => fail("malformed")));
+	if (value.id !== ref.sessionId || value.projectId !== ref.projectId) return yield* fail("malformed");
+	if (value.status !== "RUNNING") return yield* fail("expired");
+	const url = yield* Schema.decodeEffect(connectionUrl)(value.connectUrl).pipe(Effect.mapError(() => fail("unsafe-url")));
+	return Redacted.make(url);
+});
+//#endregion
+//#region src/internal/session/Cleanup.ts
+const noLocalConnection = {
+	fence: Effect.void,
+	capture: Effect.void,
+	initialization: Effect.void,
+	disconnect: Effect.succeed("not-connected")
+};
+/** Bounded host notification of canonical facts. Reporting never changes them. */
+const reported = (effect) => effect.pipe(Effect.interruptible, Effect.timeoutOrElse({
+	duration: 2e3,
+	orElse: () => Effect.void
+}), Effect.ignore);
+const defaultCleanupLimits = {
+	localStepMillis: 3e3,
+	releaseMillis: 4e3,
+	terminalMillis: 4e3
+};
+/**
+* Close is one uninterruptible, bounded transaction over *local cleanup evidence*, not
+* a transaction over the remote browser. Each step observes its own Exit so failures
+* cannot suppress a later disconnect, release request, or exact-session status read.
+*/
+const makeCleanup = Effect.fnUntraced(function* (reference, ownership, sessions, local, report, limits = defaultCleanupLimits) {
+	let latest;
+	return {
+		close: yield* Effect.cached(Effect.uninterruptible(Effect.gen(function* () {
+			const issues = [];
+			const step = (name, action, milliseconds) => action.pipe(Effect.interruptible, Effect.timeoutOrElse({
+				duration: milliseconds,
+				orElse: () => Effect.fail(CleanupIssue.make({
+					step: name,
+					reason: "timeout"
+				}))
+			}), Effect.exit, Effect.tap((exit) => Effect.sync(() => {
+				if (Exit.isSuccess(exit)) return;
+				const reason = Cause.findErrorOption(exit.cause);
+				issues.push(CleanupIssue.make({
+					step: name,
+					reason: Option.isSome(reason) && reason.value instanceof CleanupIssue ? reason.value.reason : Cause.hasInterrupts(exit.cause) ? "interrupted" : "failed"
+				}));
+			})));
+			yield* step("fence", local.fence, limits.localStepMillis);
+			yield* step("capture", local.capture, limits.localStepMillis);
+			yield* step("initialization", local.initialization, limits.localStepMillis);
+			const disconnected = yield* step("disconnect", local.disconnect, limits.localStepMillis);
+			const localState = Exit.isSuccess(disconnected) ? disconnected.value : "failed";
+			let releaseRequested = false;
+			let remote = ownership === "borrowed" ? "not-owned" : "unknown";
+			let observedStatus;
+			if (ownership === "owned") {
+				const requested = yield* step("release", sessions.requestRelease(reference), limits.releaseMillis);
+				releaseRequested = Exit.isSuccess(requested);
+				const terminal = yield* step("status", sessions.waitForTerminal(reference, { timeoutMillis: limits.terminalMillis }), limits.terminalMillis);
+				if (Exit.isSuccess(terminal)) {
+					remote = "confirmed";
+					observedStatus = terminal.value.status;
+				} else if (Exit.isSuccess(requested)) remote = "pending";
+			}
+			const result = CleanupResult.make({
+				reference,
+				ownership,
+				releaseRequested,
+				remote,
+				local: localState,
+				...observedStatus === void 0 ? {} : { observedStatus },
+				issues
+			});
+			Object.freeze(result.issues);
+			latest = Object.freeze(result);
+			report(latest);
+			return latest;
+		}))),
+		result: Effect.sync(() => Option.fromNullishOr(latest))
+	};
+});
+//#endregion
+//#region src/internal/session/Diagnostics.ts
+/**
+* Operator-visible evidence that a session's fate was not settled. It carries identity and
+* outcome labels only: no provider body, connection URL, credential or page content. The
+* transport deliberately disables tracing where credentials travel, so without this an
+* unconfirmed release or an allocation of unknown outcome would leave no trace for anyone who
+* did not register a callback.
+*/
+var SessionUnsettled = class extends Data.TaggedError("BrowserbaseSessionUnsettled") {
+	[ErrorReporter.severity] = "Warn";
+	get [ErrorReporter.attributes]() {
+		return this.details;
+	}
+};
+const surface = (message, details) => Effect.logWarning(message).pipe(Effect.annotateLogs(details), Effect.andThen(ErrorReporter.report(Cause.fail(new SessionUnsettled({
+	message,
+	details
+})))));
+/** A borrowed scope never owns release, so only its local teardown can be unsettled. */
+const reportCleanup = (result) => {
+	if (!(result.ownership === "owned" && (result.remote !== "confirmed" || !result.releaseRequested)) && result.local !== "failed" && result.issues.length === 0) return Effect.void;
+	return surface("Browserbase session cleanup ended without confirmation", {
+		projectId: result.reference.projectId,
+		sessionId: result.reference.sessionId,
+		ownership: result.ownership,
+		remote: result.remote,
+		local: result.local,
+		observedStatus: result.observedStatus ?? "unobserved",
+		issues: result.issues.map((issue) => `${issue.step}:${issue.reason}`).join(",") || "none"
+	});
+};
+/** The provider may have allocated a session this process has no reference for. */
+const reportAllocationUncertain = (attempt) => surface("Browserbase allocation outcome is unknown", {
+	projectId: attempt.projectId,
+	attemptId: attempt.attemptId,
+	requestedAtMillis: attempt.requestedAtMillis
+});
+//#endregion
+//#region src/internal/session/Acquisition.ts
+const AllocatedIdentity = Schema.Struct({
+	id: Identifier,
+	projectId: Identifier
+});
+/**
+* The remote lease is registered before POST. Local connection work is supplied by
+* the same browser owner; the control plane never invents a second operation owner.
+*/
+const acquireRemote = Effect.fnUntraced(function* (options, local = noLocalConnection, limits) {
+	const client = yield* BrowserbaseClient;
+	const sessions = yield* BrowserbaseSessions;
+	const parent = yield* Scope.Scope;
+	const launch = yield* compileLaunch(options.launch, {
+		projectId: client.projectId,
+		attemptId: globalThis.crypto.randomUUID(),
+		requestedAtMillis: yield* Clock.currentTimeMillis
+	});
+	const attempt = launch.attempt;
+	let writer;
+	if (launch.context?.persist) {
+		if (options.contextWriter === void 0) return yield* ContextError.make({
+			operation: "writer-authority",
+			reason: "authorization",
+			outcome: "undispatched"
+		});
+		writer = yield* requireContextWriterPermit(options.contextWriter, {
+			provider: "browserbase",
+			projectId: client.projectId,
+			contextId: launch.context.id
+		});
+	} else if (options.contextWriter !== void 0) return yield* ContextError.make({
+		operation: "writer-authority",
+		reason: "configuration",
+		outcome: "undispatched"
+	});
+	return yield* Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+		const resourceScope = yield* Scope.make();
+		let reference;
+		let admitted = false;
+		let knownRejection = false;
+		let closing = false;
+		let cleanup;
+		let uncertainReported = false;
+		const allocationUncertain = Effect.suspend(() => {
+			if (uncertainReported) return Effect.void;
+			uncertainReported = true;
+			return reportAllocationUncertain(attempt).pipe(Effect.andThen(options.onAllocationUncertain === void 0 ? Effect.void : reported(options.onAllocationUncertain(attempt))));
+		});
+		const terminate = yield* Effect.cached(Effect.uninterruptible(Effect.gen(function* () {
+			closing = true;
+			if (reference === void 0) {
+				if (admitted && !knownRejection) {
+					writer?.uncertain(attempt);
+					yield* allocationUncertain;
+				}
+				return;
+			}
+			yield* (yield* makeCleanup(reference, "owned", sessions, local, (result) => {
+				cleanup = result;
+				writer?.completed(attempt, result);
+			}, limits)).close;
+			if (cleanup !== void 0) yield* reportCleanup(cleanup);
+			if (cleanup !== void 0 && options.onCleanup !== void 0) yield* reported(options.onCleanup(cleanup));
+		})));
+		const closeScope = yield* Effect.cached(Scope.close(resourceScope, Exit.void));
+		yield* Scope.addFinalizer(resourceScope, terminate);
+		yield* Scope.addFinalizer(parent, closeScope);
+		const failedAllocation = (error) => {
+			knownRejection = error.outcome === "rejected" || error.outcome === "undispatched";
+			if (knownRejection) writer?.rejected(attempt);
+			else writer?.uncertain(attempt);
+			const reason = error.reason;
+			return AllocationError.make({
+				attempt,
+				outcome: knownRejection ? "rejected" : "unknown",
+				reason: reason === "authorization" || reason === "rate-limited" || reason === "configuration" || reason === "transport" || reason === "timeout" || reason === "malformed" ? reason : "provider",
+				...error.status === void 0 ? {} : { status: error.status },
+				...error.retryAfterMillis === void 0 ? {} : { retryAfterMillis: error.retryAfterMillis }
+			});
+		};
+		return yield* Effect.gen(function* () {
+			if (writer !== void 0) yield* writer.recordAttempt(attempt);
+			admitted = true;
+			const raw = yield* restore(client.json("POST", "/v1/sessions", launch.body, options.allocationDeadline)).pipe(Effect.mapError(failedAllocation));
+			const identity = yield* Schema.decodeUnknownEffect(AllocatedIdentity)(raw).pipe(Effect.mapError(() => AllocationError.make({
+				attempt,
+				outcome: "unknown",
+				reason: "malformed"
+			})));
+			reference = Object.freeze(SessionReference.make({
+				provider: "browserbase",
+				projectId: identity.projectId,
+				sessionId: identity.id
+			}));
+			writer?.recordSession(attempt, reference);
+			if (reference.projectId !== client.projectId) return yield* AllocationError.make({
+				attempt,
+				reference,
+				outcome: "unknown",
+				reason: "malformed"
+			});
+			const ref = reference;
+			return {
+				reference: ref,
+				attempt,
+				launch,
+				resourceScope,
+				isClosed: () => closing,
+				connection: (timeoutMillis) => Effect.suspend(() => closing ? Effect.fail(SessionError.make({
+					operation: "session-connect",
+					reason: "expired",
+					outcome: "undispatched"
+				})) : connectionAddress(client, sessions, ref, timeoutMillis)),
+				release: closeScope.pipe(Effect.andThen(Effect.suspend(() => cleanup === void 0 ? Effect.die(/* @__PURE__ */ new Error("Owned session closed without cleanup evidence")) : Effect.succeed(cleanup)))),
+				cleanupResult: Effect.sync(() => Option.fromNullishOr(cleanup))
+			};
+		}).pipe(Effect.onError(() => closeScope), Effect.onInterrupt(() => closeScope));
+	}));
+});
+//#endregion
+export { reported as a, noLocalConnection as i, reportCleanup as n, connectionAddress as o, makeCleanup as r, acquireRemote as t };
+
+//# sourceMappingURL=Acquisition-WBafHwXH.mjs.map

package/dist/Acquisition-WBafHwXH.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Acquisition-WBafHwXH.mjs","names":[],"sources":["../src/internal/provider/Connection.ts","../src/internal/session/Cleanup.ts","../src/internal/session/Diagnostics.ts","../src/internal/session/Acquisition.ts"],"sourcesContent":["import { Effect, Redacted, Schema } from \"effect\";\n\nimport type { BrowserbaseClient } from \"../../Client.ts\";\nimport { SessionError } from \"../../Errors.ts\";\nimport { SessionReference } from \"../../References.ts\";\nimport { ProviderSession } from \"../../SessionData.ts\";\nimport type { BrowserbaseSessions } from \"../../Sessions.ts\";\nimport { deadlineAfter, nowMillis, until } from \"../Deadline.ts\";\n\nconst Connection = Schema.Struct({\n  ...ProviderSession.fields,\n  connectUrl: Schema.String.check(Schema.isMaxLength(16384)),\n});\n\n/** A provider-issued endpoint is authority, not a persisted session identifier. */\nexport const connectionUrl = Schema.String.check(\n  Schema.isMaxLength(16384),\n  Schema.makeFilter((value) => {\n    try {\n      const url = new URL(value);\n\n      return (\n        url.protocol === \"wss:\" &&\n        !url.username &&\n        !url.password &&\n        !url.port &&\n        !url.hash &&\n        url.hostname.endsWith(\".browserbase.com\")\n      );\n    } catch {\n      return false;\n    }\n  }),\n);\n\nexport const connectionAddress = Effect.fnUntraced(function* (\n  client: BrowserbaseClient[\"Service\"],\n  sessions: BrowserbaseSessions[\"Service\"],\n  reference: SessionReference,\n  timeoutMillis: number,\n) {\n  const fail = (reason: SessionError[\"reason\"]) =>\n    SessionError.make({ operation: \"session-connect\", reason });\n\n  const ref = yield* Schema.decodeEffect(SessionReference)(reference).pipe(\n    Effect.mapError(() => fail(\"configuration\")),\n  );\n\n  if (ref.projectId !== client.projectId) return yield* fail(\"authorization\");\n  const deadline = yield* deadlineAfter(timeoutMillis);\n\n  yield* sessions.waitUntilRunning(ref, { timeoutMillis });\n  if ((yield* nowMillis) >= deadline) return yield* fail(\"timeout\");\n\n  const raw = yield* until(\n    client.json(\"GET\", `/v1/sessions/${encodeURIComponent(ref.sessionId)}`, undefined, deadline),\n    deadline,\n    () => fail(\"timeout\"),\n  ).pipe(Effect.mapError((error) => fail(error.reason)));\n\n  const value = yield* Schema.decodeUnknownEffect(Connection)(raw).pipe(\n    Effect.mapError(() => fail(\"malformed\")),\n  );\n\n  if (value.id !== ref.sessionId || value.projectId !== ref.projectId)\n    return yield* fail(\"malformed\");\n  if (value.status !== \"RUNNING\") return yield* fail(\"expired\");\n\n  const url = yield* Schema.decodeEffect(connectionUrl)(value.connectUrl).pipe(\n    Effect.mapError(() => fail(\"unsafe-url\")),\n  );\n\n  return Redacted.make(url);\n});\n","import { Cause, Effect, Exit, Option } from \"effect\";\n\nimport { CleanupIssue, CleanupResult } from \"../../Cleanup.ts\";\nimport type { BrowserError, InitializationError } from \"../../Errors.ts\";\nimport type { SessionReference } from \"../../References.ts\";\nimport type { SessionStatus } from \"../../SessionData.ts\";\nimport type { BrowserbaseSessions } from \"../../Sessions.ts\";\n\n/** All effects are captured by the owning connection; no native value is exported. */\nexport interface LocalCleanup {\n  readonly fence: Effect.Effect<void>;\n  readonly capture: Effect.Effect<void, BrowserError>;\n  readonly initialization: Effect.Effect<void, BrowserError | InitializationError>;\n  readonly disconnect: Effect.Effect<CleanupResult[\"local\"], BrowserError>;\n}\n\nexport const noLocalConnection: LocalCleanup = {\n  fence: Effect.void,\n  capture: Effect.void,\n  initialization: Effect.void,\n  disconnect: Effect.succeed(\"not-connected\"),\n};\n\n/** Bounded host notification of canonical facts. Reporting never changes them. */\nexport const reported = <A, E>(effect: Effect.Effect<A, E>) =>\n  effect.pipe(\n    Effect.interruptible,\n    Effect.timeoutOrElse({ duration: 2000, orElse: () => Effect.void }),\n    Effect.ignore,\n  );\n\n/** Internal limits, also injectable by deterministic failure tests. */\nexport interface CleanupLimits {\n  readonly localStepMillis: number;\n  readonly releaseMillis: number;\n  readonly terminalMillis: number;\n}\n\nexport const defaultCleanupLimits: CleanupLimits = {\n  localStepMillis: 3000,\n  releaseMillis: 4000,\n  terminalMillis: 4000,\n};\n\n/**\n * Close is one uninterruptible, bounded transaction over *local cleanup evidence*, not\n * a transaction over the remote browser. Each step observes its own Exit so failures\n * cannot suppress a later disconnect, release request, or exact-session status read.\n */\nexport const makeCleanup = Effect.fnUntraced(function* (\n  reference: SessionReference,\n  ownership: CleanupResult[\"ownership\"],\n  sessions: BrowserbaseSessions[\"Service\"],\n  local: LocalCleanup,\n  report: (result: CleanupResult) => void,\n  limits: CleanupLimits = defaultCleanupLimits,\n) {\n  let latest: CleanupResult | undefined;\n\n  const close = yield* Effect.cached(\n    Effect.uninterruptible(\n      Effect.gen(function* () {\n        const issues: CleanupIssue[] = [];\n\n        const step = <A, E>(\n          name: CleanupIssue[\"step\"],\n          action: Effect.Effect<A, E>,\n          milliseconds: number,\n        ) =>\n          action.pipe(\n            Effect.interruptible,\n            Effect.timeoutOrElse({\n              duration: milliseconds,\n              orElse: () => Effect.fail(CleanupIssue.make({ step: name, reason: \"timeout\" })),\n            }),\n            Effect.exit,\n            Effect.tap((exit) =>\n              Effect.sync(() => {\n                if (Exit.isSuccess(exit)) return;\n                const reason = Cause.findErrorOption(exit.cause);\n\n                issues.push(\n                  CleanupIssue.make({\n                    step: name,\n                    reason:\n                      Option.isSome(reason) && reason.value instanceof CleanupIssue\n                        ? reason.value.reason\n                        : Cause.hasInterrupts(exit.cause)\n                          ? \"interrupted\"\n                          : \"failed\",\n                  }),\n                );\n              }),\n            ),\n          );\n\n        // The fence runs synchronously before interruptible native teardown begins.\n        yield* step(\"fence\", local.fence, limits.localStepMillis);\n        yield* step(\"capture\", local.capture, limits.localStepMillis);\n        yield* step(\"initialization\", local.initialization, limits.localStepMillis);\n        const disconnected = yield* step(\"disconnect\", local.disconnect, limits.localStepMillis);\n        const localState = Exit.isSuccess(disconnected) ? disconnected.value : \"failed\";\n\n        let releaseRequested = false;\n        let remote: CleanupResult[\"remote\"] = ownership === \"borrowed\" ? \"not-owned\" : \"unknown\";\n        let observedStatus: SessionStatus | undefined;\n\n        if (ownership === \"owned\") {\n          const requested = yield* step(\n            \"release\",\n            sessions.requestRelease(reference),\n            limits.releaseMillis,\n          );\n\n          releaseRequested = Exit.isSuccess(requested);\n\n          // A POST response is never substituted for a passive terminal-state observation.\n          const terminal = yield* step(\n            \"status\",\n            sessions.waitForTerminal(reference, { timeoutMillis: limits.terminalMillis }),\n            limits.terminalMillis,\n          );\n\n          if (Exit.isSuccess(terminal)) {\n            remote = \"confirmed\";\n            observedStatus = terminal.value.status;\n          } else if (Exit.isSuccess(requested)) {\n            remote = \"pending\";\n          }\n        }\n\n        const result = CleanupResult.make({\n          reference,\n          ownership,\n          releaseRequested,\n          remote,\n          local: localState,\n          ...(observedStatus === undefined ? {} : { observedStatus }),\n          issues,\n        });\n\n        Object.freeze(result.issues);\n        latest = Object.freeze(result);\n        report(latest);\n\n        return latest;\n      }),\n    ),\n  );\n\n  return {\n    close,\n    result: Effect.sync(() => Option.fromNullishOr(latest)),\n  };\n});\n","import { Cause, Data, Effect, ErrorReporter } from \"effect\";\n\nimport type { CleanupResult } from \"../../Cleanup.ts\";\nimport type { AllocationAttempt } from \"../../References.ts\";\n\n/**\n * Operator-visible evidence that a session's fate was not settled. It carries identity and\n * outcome labels only: no provider body, connection URL, credential or page content. The\n * transport deliberately disables tracing where credentials travel, so without this an\n * unconfirmed release or an allocation of unknown outcome would leave no trace for anyone who\n * did not register a callback.\n */\nclass SessionUnsettled extends Data.TaggedError(\"BrowserbaseSessionUnsettled\")<{\n  readonly message: string;\n  readonly details: Readonly<Record<string, string | number>>;\n}> {\n  readonly [ErrorReporter.severity] = \"Warn\" as const;\n\n  get [ErrorReporter.attributes]() {\n    return this.details;\n  }\n}\n\nconst surface = (message: string, details: Readonly<Record<string, string | number>>) =>\n  Effect.logWarning(message).pipe(\n    Effect.annotateLogs(details),\n    Effect.andThen(ErrorReporter.report(Cause.fail(new SessionUnsettled({ message, details })))),\n  );\n\n/** A borrowed scope never owns release, so only its local teardown can be unsettled. */\nexport const reportCleanup = (result: CleanupResult): Effect.Effect<void> => {\n  const remoteUnsettled =\n    result.ownership === \"owned\" && (result.remote !== \"confirmed\" || !result.releaseRequested);\n\n  if (!remoteUnsettled && result.local !== \"failed\" && result.issues.length === 0)\n    return Effect.void;\n\n  return surface(\"Browserbase session cleanup ended without confirmation\", {\n    projectId: result.reference.projectId,\n    sessionId: result.reference.sessionId,\n    ownership: result.ownership,\n    remote: result.remote,\n    local: result.local,\n    observedStatus: result.observedStatus ?? \"unobserved\",\n    issues: result.issues.map((issue) => `${issue.step}:${issue.reason}`).join(\",\") || \"none\",\n  });\n};\n\n/** The provider may have allocated a session this process has no reference for. */\nexport const reportAllocationUncertain = (attempt: AllocationAttempt): Effect.Effect<void> =>\n  surface(\"Browserbase allocation outcome is unknown\", {\n    projectId: attempt.projectId,\n    attemptId: attempt.attemptId,\n    requestedAtMillis: attempt.requestedAtMillis,\n  });\n","import { Clock, Effect, Exit, Option, Schema, Scope } from \"effect\";\n\nimport type { CleanupResult } from \"../../Cleanup.ts\";\nimport { BrowserbaseClient } from \"../../Client.ts\";\nimport { AllocationError, ContextError, type ClientError, SessionError } from \"../../Errors.ts\";\nimport type { LaunchRecipe } from \"../../Launch.ts\";\nimport { type AllocationAttempt, Identifier, SessionReference } from \"../../References.ts\";\nimport { BrowserbaseSessions } from \"../../Sessions.ts\";\nimport { connectionAddress } from \"../provider/Connection.ts\";\nimport { compileLaunch } from \"../provider/Launch.ts\";\nimport {\n  makeCleanup,\n  noLocalConnection,\n  reported,\n  type CleanupLimits,\n  type LocalCleanup,\n} from \"./Cleanup.ts\";\nimport { requireContextWriterPermit, type ContextWriterPermitInternal } from \"./ContextWriter.ts\";\nimport { reportAllocationUncertain, reportCleanup } from \"./Diagnostics.ts\";\nimport type { ContextWriterPermit } from \"./WriterFacts.ts\";\n\nconst AllocatedIdentity = Schema.Struct({ id: Identifier, projectId: Identifier });\n\nexport interface AcquisitionOptions {\n  readonly launch: LaunchRecipe;\n  readonly contextWriter?: ContextWriterPermit;\n  readonly allocationDeadline?: number;\n  /** Bounded host notification of the canonical facts. Reporting never changes them. */\n  readonly onCleanup?: (result: CleanupResult) => Effect.Effect<void>;\n  /** Exactly one notification when a creation attempt's effect on the provider is unknown. */\n  readonly onAllocationUncertain?: (attempt: AllocationAttempt) => Effect.Effect<void>;\n}\n\n/**\n * The remote lease is registered before POST. Local connection work is supplied by\n * the same browser owner; the control plane never invents a second operation owner.\n */\nexport const acquireRemote = Effect.fnUntraced(function* (\n  options: AcquisitionOptions,\n  local: LocalCleanup = noLocalConnection,\n  limits?: CleanupLimits,\n) {\n  const client = yield* BrowserbaseClient;\n  const sessions = yield* BrowserbaseSessions;\n  const parent = yield* Scope.Scope;\n\n  const launch = yield* compileLaunch(options.launch, {\n    projectId: client.projectId,\n    attemptId: globalThis.crypto.randomUUID(),\n    requestedAtMillis: yield* Clock.currentTimeMillis,\n  });\n\n  const attempt = launch.attempt;\n  let writer: ContextWriterPermitInternal | undefined;\n\n  if (launch.context?.persist) {\n    if (options.contextWriter === undefined) {\n      return yield* ContextError.make({\n        operation: \"writer-authority\",\n        reason: \"authorization\",\n        outcome: \"undispatched\",\n      });\n    }\n    writer = yield* requireContextWriterPermit(options.contextWriter, {\n      provider: \"browserbase\",\n      projectId: client.projectId,\n      contextId: launch.context.id,\n    });\n  } else if (options.contextWriter !== undefined) {\n    return yield* ContextError.make({\n      operation: \"writer-authority\",\n      reason: \"configuration\",\n      outcome: \"undispatched\",\n    });\n  }\n\n  return yield* Effect.uninterruptibleMask((restore) =>\n    Effect.gen(function* () {\n      const resourceScope = yield* Scope.make();\n      let reference: SessionReference | undefined;\n      let admitted = false;\n      let knownRejection = false;\n      let closing = false;\n      let cleanup: CleanupResult | undefined;\n\n      let uncertainReported = false;\n\n      const allocationUncertain = Effect.suspend(() => {\n        if (uncertainReported) return Effect.void;\n        uncertainReported = true;\n\n        return reportAllocationUncertain(attempt).pipe(\n          Effect.andThen(\n            options.onAllocationUncertain === undefined\n              ? Effect.void\n              : reported(options.onAllocationUncertain(attempt)),\n          ),\n        );\n      });\n\n      const terminate = yield* Effect.cached(\n        Effect.uninterruptible(\n          Effect.gen(function* () {\n            closing = true;\n            if (reference === undefined) {\n              if (admitted && !knownRejection) {\n                writer?.uncertain(attempt);\n                yield* allocationUncertain;\n              }\n\n              return;\n            }\n\n            const coordinator = yield* makeCleanup(\n              reference,\n              \"owned\",\n              sessions,\n              local,\n              (result) => {\n                cleanup = result;\n                writer?.completed(attempt, result);\n              },\n              limits,\n            );\n\n            yield* coordinator.close;\n            if (cleanup !== undefined) yield* reportCleanup(cleanup);\n            if (cleanup !== undefined && options.onCleanup !== undefined)\n              yield* reported(options.onCleanup(cleanup));\n          }),\n        ),\n      );\n\n      const closeScope = yield* Effect.cached(Scope.close(resourceScope, Exit.void));\n\n      yield* Scope.addFinalizer(resourceScope, terminate);\n      yield* Scope.addFinalizer(parent, closeScope);\n\n      const failedAllocation = (error: ClientError): AllocationError => {\n        knownRejection = error.outcome === \"rejected\" || error.outcome === \"undispatched\";\n        if (knownRejection) writer?.rejected(attempt);\n        else writer?.uncertain(attempt);\n        const reason = error.reason;\n\n        return AllocationError.make({\n          attempt,\n          outcome: knownRejection ? \"rejected\" : \"unknown\",\n          reason:\n            reason === \"authorization\" ||\n            reason === \"rate-limited\" ||\n            reason === \"configuration\" ||\n            reason === \"transport\" ||\n            reason === \"timeout\" ||\n            reason === \"malformed\"\n              ? reason\n              : \"provider\",\n          ...(error.status === undefined ? {} : { status: error.status }),\n          ...(error.retryAfterMillis === undefined\n            ? {}\n            : { retryAfterMillis: error.retryAfterMillis }),\n        });\n      };\n\n      const allocate = Effect.gen(function* () {\n        if (writer !== undefined) yield* writer.recordAttempt(attempt);\n        admitted = true;\n\n        const raw = yield* restore(\n          client.json(\"POST\", \"/v1/sessions\", launch.body, options.allocationDeadline),\n        ).pipe(Effect.mapError(failedAllocation));\n\n        const identity = yield* Schema.decodeUnknownEffect(AllocatedIdentity)(raw).pipe(\n          Effect.mapError(() =>\n            AllocationError.make({ attempt, outcome: \"unknown\", reason: \"malformed\" }),\n          ),\n        );\n\n        // Save identity before interpreting any connection credentials or provider metadata.\n        reference = Object.freeze(\n          SessionReference.make({\n            provider: \"browserbase\",\n            projectId: identity.projectId,\n            sessionId: identity.id,\n          }),\n        );\n        writer?.recordSession(attempt, reference);\n        if (reference.projectId !== client.projectId) {\n          return yield* AllocationError.make({\n            attempt,\n            reference,\n            outcome: \"unknown\",\n            reason: \"malformed\",\n          });\n        }\n        const ref = reference;\n\n        return {\n          reference: ref,\n          attempt,\n          launch,\n          resourceScope,\n          isClosed: () => closing,\n          connection: (timeoutMillis: number) =>\n            Effect.suspend(() =>\n              closing\n                ? Effect.fail(\n                    SessionError.make({\n                      operation: \"session-connect\",\n                      reason: \"expired\",\n                      outcome: \"undispatched\",\n                    }),\n                  )\n                : connectionAddress(client, sessions, ref, timeoutMillis),\n            ),\n          release: closeScope.pipe(\n            Effect.andThen(\n              Effect.suspend(() =>\n                cleanup === undefined\n                  ? Effect.die(new Error(\"Owned session closed without cleanup evidence\"))\n                  : Effect.succeed(cleanup),\n              ),\n            ),\n          ),\n          cleanupResult: Effect.sync(() => Option.fromNullishOr(cleanup)),\n        };\n      });\n\n      return yield* allocate.pipe(\n        Effect.onError(() => closeScope),\n        Effect.onInterrupt(() => closeScope),\n      );\n    }),\n  );\n});\n\nexport type RemoteAcquisition = Effect.Success<ReturnType<typeof acquireRemote>>;\n"],"mappings":"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"}

package/dist/Agents.d.mts

@@ -0,0 +1,156 @@
+import { n as ContextReference } from "./References-URDAtapt.mjs";
+import { PlatformError } from "./Errors.mjs";
+import { t as BrowserbaseClient } from "./Client-Ca0zSg1n.mjs";
+import { Context, Effect, Layer, Schema } from "effect";
+declare namespace Agents_d_exports {
+  export { AgentDefinition, AgentListQuery, AgentMessageQuery, AgentMessages, AgentMetadata, AgentRun, AgentRunListQuery, AgentRunMessage, AgentRunRequest, AgentRunStatus, AgentRunWaitOptions, AgentUpdate, BrowserbaseAgents, Page, isTerminalAgentRunStatus };
+}
+export declare const AgentRunStatus: Schema.Literals<readonly ["PENDING", "RUNNING", "COMPLETED", "FAILED", "STOPPED", "TIMED_OUT"]>;
+export type AgentRunStatus = typeof AgentRunStatus.Type;
+export declare const isTerminalAgentRunStatus: (status: AgentRunStatus) => boolean;
+declare const AgentMetadata_base: Schema.Class<AgentMetadata, Schema.Struct<{
+  readonly agentId: Schema.NonEmptyString;
+  readonly name: Schema.String;
+  readonly systemPrompt: Schema.optionalKey<Schema.String>;
+  readonly resultSchema: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+  readonly createdAt: Schema.String;
+  readonly updatedAt: Schema.String;
+}>, {}>;
+export declare class AgentMetadata extends AgentMetadata_base {}
+declare const AgentRun_base: Schema.Class<AgentRun, Schema.Struct<{
+  readonly runId: Schema.NonEmptyString;
+  readonly agentId: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly task: Schema.String;
+  readonly status: Schema.Literals<readonly ["PENDING", "RUNNING", "COMPLETED", "FAILED", "STOPPED", "TIMED_OUT"]>;
+  readonly sessionId: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly sandboxId: Schema.optionalKey<Schema.String>;
+  readonly resultSchema: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+  readonly result: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+  readonly cause: Schema.optionalKey<Schema.Struct<{
+    readonly code: Schema.String;
+    readonly message: Schema.optionalKey<Schema.String>;
+  }>>;
+  readonly startedAt: Schema.optionalKey<Schema.String>;
+  readonly endedAt: Schema.optionalKey<Schema.String>;
+  readonly createdAt: Schema.String;
+  readonly updatedAt: Schema.String;
+}>, {}>;
+export declare class AgentRun extends AgentRun_base {}
+declare const AgentRunMessage_base: Schema.Class<AgentRunMessage, Schema.Struct<{
+  readonly id: Schema.String;
+  readonly createdAt: Schema.String;
+  readonly role: Schema.Literals<readonly ["assistant", "tool"]>;
+  readonly content: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, {}>;
+export declare class AgentRunMessage extends AgentRunMessage_base {}
+export declare const AgentDefinition: Schema.Struct<{
+  readonly name: Schema.NonEmptyString;
+  readonly systemPrompt: Schema.optionalKey<Schema.String>;
+  readonly resultSchema: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+export type AgentDefinition = typeof AgentDefinition.Type;
+export declare const AgentUpdate: Schema.Struct<{
+  readonly name: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly systemPrompt: Schema.optionalKey<Schema.String>;
+  readonly resultSchema: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+export type AgentUpdate = typeof AgentUpdate.Type;
+export declare const AgentRunRequest: Schema.Struct<{
+  readonly task: Schema.NonEmptyString;
+  readonly agentId: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly resultSchema: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+  readonly variables: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+    readonly value: Schema.String;
+    readonly description: Schema.optionalKey<Schema.String>;
+  }>>>;
+  readonly browserSettings: Schema.optionalKey<Schema.Struct<{
+    /**
+     * A persisting run writes the Context from Browserbase's side, outside
+     * `ContextCoordination.withWriter`. It is refused while a local writer holds the
+     * Context, but nothing stops a later local writer from racing the hosted run.
+     */
+    readonly context: Schema.optionalKey<Schema.Struct<{
+      readonly reference: typeof ContextReference;
+      readonly persist: Schema.Boolean;
+    }>>;
+    readonly proxies: Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+      readonly type: Schema.Literal<"browserbase">;
+      readonly domainPattern: Schema.optionalKey<Schema.NonEmptyString>;
+      readonly geolocation: Schema.optionalKey<Schema.Struct<{
+        readonly country: Schema.String;
+        readonly state: Schema.optionalKey<Schema.String>;
+        readonly city: Schema.optionalKey<Schema.NonEmptyString>;
+      }>>;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"external">;
+      readonly server: Schema.NonEmptyString;
+      readonly domainPattern: Schema.optionalKey<Schema.NonEmptyString>;
+      readonly username: Schema.optionalKey<Schema.Redacted<Schema.String>>;
+      readonly password: Schema.optionalKey<Schema.Redacted<Schema.String>>;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"none">;
+      readonly domainPattern: Schema.optionalKey<Schema.NonEmptyString>;
+    }>]>>]>>;
+    readonly verified: Schema.optionalKey<Schema.Boolean>;
+  }>>;
+}>;
+export type AgentRunRequest = typeof AgentRunRequest.Type;
+export declare const AgentListQuery: Schema.Struct<{
+  readonly startAt: Schema.optionalKey<Schema.String>;
+  readonly endAt: Schema.optionalKey<Schema.String>;
+  readonly cursor: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly limit: Schema.optionalKey<Schema.Int>;
+}>;
+export type AgentListQuery = typeof AgentListQuery.Type;
+export declare const AgentRunListQuery: Schema.Struct<{
+  readonly startAt: Schema.optionalKey<Schema.String>;
+  readonly endAt: Schema.optionalKey<Schema.String>;
+  readonly cursor: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly status: Schema.optionalKey<Schema.Literals<readonly ["PENDING", "RUNNING", "COMPLETED", "FAILED", "STOPPED", "TIMED_OUT"]>>;
+  readonly agentId: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly limit: Schema.optionalKey<Schema.Int>;
+}>;
+export type AgentRunListQuery = typeof AgentRunListQuery.Type;
+export declare const AgentMessageQuery: Schema.Struct<{
+  readonly since: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly limit: Schema.optionalKey<Schema.Int>;
+  readonly all: Schema.optionalKey<Schema.Boolean>;
+}>;
+export type AgentMessageQuery = typeof AgentMessageQuery.Type;
+export declare const AgentRunWaitOptions: Schema.Struct<{
+  readonly timeoutMillis: Schema.Int;
+  readonly pollIntervalMillis: Schema.optionalKey<Schema.Int>;
+}>;
+export type AgentRunWaitOptions = typeof AgentRunWaitOptions.Type;
+export interface Page<A> {
+  readonly items: ReadonlyArray<A>;
+  readonly nextCursor: string | undefined;
+}
+export interface AgentMessages {
+  readonly messages: ReadonlyArray<AgentRunMessage>;
+  readonly nextSince: string | undefined;
+}
+declare const BrowserbaseAgents_base: Context.ServiceClass<BrowserbaseAgents, "effect-browserbase/Agents", {
+  readonly create: (definition: AgentDefinition) => Effect.Effect<AgentMetadata, PlatformError>;
+  readonly list: (query?: AgentListQuery) => Effect.Effect<Page<AgentMetadata>, PlatformError>;
+  readonly retrieve: (agentId: string) => Effect.Effect<AgentMetadata, PlatformError>;
+  readonly update: (agentId: string, update: AgentUpdate) => Effect.Effect<AgentMetadata, PlatformError>;
+  readonly delete: (agentId: string) => Effect.Effect<void, PlatformError>;
+  readonly run: (request: AgentRunRequest) => Effect.Effect<AgentRun, PlatformError>;
+  readonly retrieveRun: (runId: string) => Effect.Effect<AgentRun, PlatformError>;
+  readonly listRuns: (query?: AgentRunListQuery) => Effect.Effect<Page<AgentRun>, PlatformError>;
+  readonly stopRun: (runId: string) => Effect.Effect<AgentRun, PlatformError>;
+  readonly messages: (runId: string, query?: AgentMessageQuery) => Effect.Effect<AgentMessages, PlatformError>;
+  /** Polls until the run is terminal. Interrupting the wait does not stop the run. */
+  readonly waitForRun: (runId: string, options: AgentRunWaitOptions) => Effect.Effect<AgentRun, PlatformError>;
+}>;
+/**
+ * Browserbase Agents: hosted autonomous runs that allocate their own browser sessions and
+ * bill inference. Creating or stopping a run is never retried; a lost reply is `unknown`.
+ */
+export declare class BrowserbaseAgents extends BrowserbaseAgents_base {
+  static readonly layer: Layer.Layer<BrowserbaseAgents, never, BrowserbaseClient>;
+}
+//#endregion
+export { Agents_d_exports as t };
+//# sourceMappingURL=Agents.d.mts.map