effect-browserbase 0.2.0-beta.0 → 0.2.0-beta.1

package/README.md

@@ -2,7 +2,7 @@
 
 `effect-browserbase` supplies Browserbase resources and hosted lifetimes to the shared browser runtime: account identity and transport, session, context and extension resources, one owned browser over Playwright/CDP — allocated or borrowed — with trusted registrations, modeled file selection, bounded live capture, explicit page holds, the provider's recordings, replays, uploads and website downloads, and the platform APIs outside a browser session (projects, certificates, Search, Fetch, Agents, Functions and webhooks).
 
-Its host supplies the required `effect-browser` peer, at the same coordinated `0.2.0-beta.0` version for this candidate; it has no Effect Agent dependency. Install both packages explicitly so the provider and application share one runtime instance. Playwright is an optional peer of the shared runtime and is loaded only when a browser connects; artifact-only consumers do not need it. The existing Effect peer range remains `^4.0.0-rc.115`, with only rc.115 qualified by this candidate. The package targets trusted Node and Bun hosts. It is an unpublished maintainer-review candidate: hosted provider behavior requires separate validation, and ordinary tests never create a paid Browserbase session or invoke a paid model.
+Its host supplies the required `effect-browser` peer, at the same coordinated `0.2.0-beta.1` version; it has no Effect Agent dependency. Install both packages explicitly so the provider and application share one runtime instance. Playwright is an optional peer of the shared runtime and is loaded only when a browser connects; artifact-only consumers do not need it. The existing Effect peer range remains `^4.0.0-rc.115`, with only rc.115 qualified. The package targets trusted Node and Bun hosts. It is published as a beta (`0.2.0-beta.0` on the `beta` dist-tag): hosted provider behavior requires separate validation, and ordinary tests never create a paid Browserbase session or invoke a paid model.
 
 ## One account, then resources
 
@@ -19,7 +19,7 @@ const account = Account.layerConfig({
 });
 ```
 
-`Account.layer({ projectId, apiKey: Redacted.make(key), ... })` takes the same authority explicitly. Either one bundles every resource service on a single Client, so credentials are composed once instead of per service; each service still exports its own `layer` when you want a narrower set. `BrowserbaseBrowser.layer` stays separate, because a browser also fixes budgets and a connection lifetime that an account does not. The Client uses Effect's `FetchHttpClient.Fetch` reference, which already defaults to `globalThis.fetch`; provide a different `fetch` only when you need one.
+`Account.layer({ projectId, apiKey: Redacted.make(key), ... })` takes the same authority explicitly. Either one bundles every resource service on a single Client, so credentials are composed once instead of per service; each service still exports its own `layer` when you want a narrower set. `BrowserbaseBrowser.layer` stays separate, because a browser also fixes budgets and a connection lifetime that an account does not. It also requires Effect's `Crypto` from the host platform (`NodeServices.layer`, `BunServices.layer` or `NodeCrypto.layer`), which supplies allocation attempt ids, connection ids and handoff tokens; the account services need no `Crypto`. The Client uses Effect's `FetchHttpClient.Fetch` reference, which already defaults to `globalThis.fetch`; provide a different `fetch` only when you need one.
 
 `artifactOrigins` is the exact set of HTTPS origins this client will fetch provider media from, and it is deliberately empty by default: recording downloads and replay media are refused with `unsafe-url` until you approve a host. Browserbase documents only a "signed CDN URL" and does not publish that origin, so discover your own rather than copying anyone's — request a recording for a completed session, read `downloadUrl` from `GET /v1/sessions/{id}/recording/downloads`, and approve exactly its origin. A hosted run on 21 September 2026 confirmed that a completed recording then downloads through this check rather than around it. The origin is an observation and not a contract: it may differ by project or region, the provider can re-point it without notice, and a BYOS project returns no signed URL at all. Treat a later `unsafe-url` as the delivery host having moved, not as a defect.
 
@@ -34,6 +34,7 @@ const account = Account.layerConfig({
 For the simplest post-session video path, opt in to Browserbase recording in the launch recipe:
 
 ```ts
+import { NodeServices } from "@effect/platform-node";
 import { BrowserbaseBrowser } from "effect-browserbase/browser";
 import * as Browser from "effect-browser/browser";
 import { BrowserPolicy, NavigateRequest } from "effect-browser/browser-data";
@@ -50,6 +51,7 @@ const policy = BrowserPolicy.unrestricted();
 
 const layers = Layer.merge(BrowserbaseBrowser.layer({ launch }), BrowserbaseRecordings.layer).pipe(
   Layer.provide(account),
+  Layer.provide(NodeServices.layer),
 );
 
 const program = Effect.gen(function* () {
@@ -116,7 +118,7 @@ Prefer provider recording when post-session MP4/HLS is enough. Use `capture` whe
 
 That split is why an agent can use one browser for many turns while provider artifacts remain accessible after the interactive scope ends. Importing a Layer does not allocate a browser.
 
-`Allocation.scoped(recipe)` allocates a session without connecting a browser, for a caller that drives the remote session with its own automation client. It is the same allocation path the browser owner uses, so the creation request is never retried, an unknown outcome is still reported exactly once, a persisting Context still needs a live writer permit, and no native peer is loaded. The scope owns the release: closing it releases the session whether or not anything ever connected. A reply naming another project is refused, and because a foreign reference is never acted on, the caller is handed that reference rather than a mutation attempted against it.
+`Allocation.scoped(recipe)` allocates a session without connecting a browser, for a caller that drives the remote session with its own automation client. It is the same allocation path the browser owner uses, so the creation request is never retried, an unknown outcome is still reported exactly once, a persisting Context still needs a live writer permit, and no native peer is loaded. The scope owns the release: closing it releases the session whether or not anything ever connected. A reply naming another project is refused, and because a foreign reference is never acted on, the caller is handed that reference rather than a mutation attempted against it. The attempt id comes from Effect's `Crypto`, so `Allocation.scoped` requires that service beside the account.
 
 The shared browser runtime delegates allocation and release to this provider lifetime. It supplies the local half of cleanup — fence, capture stop, initialization teardown, disconnect — and the canonical control plane owns the release request and the terminal status observation. A local disconnect, an accepted provider release request and provider-confirmed termination therefore stay distinct facts in one `CleanupResult`, together with the exact steps that failed.
 
@@ -223,6 +225,46 @@ A host that does this still selects `Unrestricted` here, and the containment cla
 
 What this package does check is input, not requests. `controlFacts` and an `admit` policy ([above](#what-is-on-screen-and-what-a-host-may-know-about-it)) let a host that drives the session refuse a link or a form by its resolved destination before anything is sent. That limits what the host's own automation acts on. It does not limit what a page loads, or where it redirects.
 
+## Testing against a scripted control plane
+
+`effect-browserbase/testing` supplies the provider side of a test the way `effect-browser/testing` supplies the browser side. `Testing.provider(script)` returns a `fetch` for `FetchHttpClient.Fetch` and a `ProviderControl` handle; the real `Client`, `Sessions`, `Uploads`, allocation and cleanup code parse its replies, apply their bounds and reconcile release against it. The script says how creation answers (`Accept`, `Reject` with a status the transport classifies and an optional `retryAfterMillis`, `Malformed`, or `Lost` after the request was sent, so the allocation outcome is unknown), whether a release request is `confirmed`, stays `pending` or fails, whether a Live View is issued, and whose identity a session's retrieval and release replies carry (`own`, `foreign-session` or `foreign-project`). Its secrets are marker strings, so evidence can be grepped for a leak, and nothing in it is a credential.
+
+`Testing.layer({ browser, provider?, launch?, options? })` composes that control plane under the real `Account.layer` and `BrowserbaseBrowser.layer`, with the scripted engine from `effect-browser/testing` as the `BrowserBinding` and its `sequentialCrypto` as the browser's `Crypto`, and adds a `ScriptedBrowserbase` service whose `provider` is the control handle and whose `browsers` are the engine control handles, one per provider session: a keep-alive reconnection or a borrowed attachment reaches the same scripted browser again, with the pages it kept. An application written against `BrowserbaseBrowser.open` runs unchanged:
+
+```ts
+import { expect, it } from "@effect/vitest";
+import { Effect } from "effect";
+import * as Browser from "effect-browser/browser";
+import { BrowserPolicy } from "effect-browser/browser-data";
+import { BrowserbaseBrowser } from "effect-browserbase/browser";
+import * as Testing from "effect-browserbase/testing";
+
+it.effect("release is requested once and confirmed", () =>
+  Effect.gen(function* () {
+    const scripted = yield* Testing.ScriptedBrowserbase;
+
+    const receipt = yield* Browser.scoped(
+      BrowserbaseBrowser.open(BrowserPolicy.unrestricted()),
+      (session) =>
+        Effect.gen(function* () {
+          yield* session.navigate({ url: "https://shop.test/" });
+
+          return yield* session.closeChecked;
+        }),
+    );
+
+    expect(receipt).toMatchObject({ releaseRequested: true, remote: "confirmed", local: "closed" });
+    expect(yield* scripted.provider.sessions).toMatchObject([
+      { id: "session-1", status: "COMPLETED", releaseRequests: 1 },
+    ]);
+  }).pipe(Effect.provide(Testing.layer({ browser: shop }))),
+);
+```
+
+Sessions are numbered `session-1`, `session-2`, … in creation order. A `pending` release leaves the session `RUNNING`, so checked close fails `Provider` with outcome `unknown` after the real status bound elapses, and the receipt carries `remote: "pending"`; under `it.effect` a `TestClock.adjust` reaches that bound with nothing real elapsing. A `Lost` creation makes `onAllocationUncertain` fire once, as it does when a real request is cut off. A `foreign-session` or `foreign-project` identity makes connection fail `Malformed` before any page is reached, and no reply about the other session can confirm this one's release, so its receipt carries `remote: "unknown"`. Borrowed attachment through `attach` makes a second connection to the owner's scripted browser, which its control lists under `connections`, and no release request. `Allocation.scoped`, `BrowserbaseSessions` and the other resource services run over the same `fetch` with `Testing.provider()` alone, with no browser at all; `Allocation.scoped` also takes a `Crypto`, and `sequentialCrypto` from `effect-browser/testing` keeps its attempt ids predictable.
+
+What a scripted control plane answers is what this repository has read of the provider API, replayed. It establishes that this package handles those answers correctly; it establishes nothing about what Browserbase answers today, which only the hosted checks in [Status](../../docs/STATUS.md) record.
+
 ## Beyond the browser session
 
 These services share the Client and its rules: strict input decoding, identity-checked replies, 1 MiB reply bounds, mutations that are never retried, and typed failures whose `outcome` says whether a request was sent. They are host APIs; none of them is exposed to a model by the adapter package.
@@ -251,6 +293,7 @@ An agent run or Function invocation that persists a Context writes it from Brows
 - `downloads` — ordinary website download metadata, provider-side filters, bounded byte streams and deletion, separate from provider recordings.
 - `projects`, `certificates` — project inspection and usage; proxy CA certificate administration.
 - `search`, `page-fetch`, `agents`, `functions`, `webhooks` — the Browserbase platform APIs outside a browser session.
+- `testing` — a scripted control plane as `fetch`, and the real account and browser Layers composed over it and over the scripted engine from `effect-browser/testing`.
 
 Every expected failure says three things. `operation` is what you asked for, from a closed vocabulary per error class: `BrowserError` names the browser operations, `SessionError` only session calls, and so on, so you can match on them exhaustively and a misspelling is a type error, not a string that happens to compile. `reason` is why it failed. `outcome`, when present, is whether the work was sent: `undispatched` is safe to retry, `rejected` was refused, and `unknown` means a mutation may have happened and is never replayed for you. Why an extension archive was refused is a `reason` (`limit`, `unsafe-filename`, `configuration`) of the one `extension-archive` operation. A native step's own name never appears: the driver raises a private failure, and the owner stamps the operation it admitted.
 
@@ -268,4 +311,4 @@ Live frames and page holds follow the common [capture guarantees](../browser/REA
 
 ## Development and evidence
 
-Read [Contributing](../../CONTRIBUTING.md) for the frozen compatibility workspace and required checks. Provider unit tests cover HTTP/resources and release reconciliation. Cross-package source regression tests live in `test/integration`. The `generic` and `agent-hosted` installed consumers run the maintained native suites against real Chromium with scripted provider HTTP; the `resources` consumer installs no Playwright or Effect Agent. Hosted evidence remains separately recorded in [Status](../../docs/STATUS.md) and never inferred from a local pass.
+Read [Contributing](../../CONTRIBUTING.md) for the frozen compatibility workspace and required checks. Provider unit tests cover HTTP/resources and release reconciliation; `test/testing.test.ts` runs the public scripted control plane and Layer through the real allocation and cleanup code. Provider regressions that need a browser, such as release reconciliation around a held teardown or a keep-alive reconnection, run over the same public entries in this package's `test/`. The `generic` and `agent-hosted` installed consumers run the maintained native suites against real Chromium with scripted provider HTTP; the `resources` consumer installs no Playwright or Effect Agent, and it also opens scripted browsers through both testing entry points from the packed tarballs. Hosted evidence remains separately recorded in [Status](../../docs/STATUS.md) and never inferred from a local pass.

package/dist/Account.d.mts

@@ -1,19 +1,19 @@
 import { ClientError } from "./Errors.mjs";
-import { BrowserbaseClient, ClientOptions } from "./Client.mjs";
-import { BrowserbaseAgents } from "./Agents.mjs";
-import { BrowserbaseCertificates } from "./Certificates.mjs";
-import { BrowserbaseContexts } from "./Contexts.mjs";
-import { t as BrowserbaseSessions } from "./Sessions-tFJYaXFq.mjs";
-import { BrowserbaseDownloads } from "./Downloads.mjs";
-import { BrowserbaseExtensions } from "./Extensions.mjs";
-import { BrowserbaseFunctions } from "./Functions.mjs";
-import { BrowserbasePageFetch } from "./PageFetch.mjs";
-import { BrowserbaseProjects } from "./Projects.mjs";
-import { BrowserbaseRecordings } from "./Recordings.mjs";
-import { BrowserbaseReplays } from "./Replays.mjs";
-import { BrowserbaseSearch } from "./Search.mjs";
-import { BrowserbaseUploads } from "./Uploads.mjs";
-import { BrowserbaseWebhooks } from "./Webhooks.mjs";
+import { r as ClientOptions, t as BrowserbaseClient } from "./Client-B_f6bBLT.mjs";
+import { p as BrowserbaseAgents } from "./Agents-5HpTp9YE.mjs";
+import { t as BrowserbaseCertificates } from "./Certificates-D4NQmyeA.mjs";
+import { t as BrowserbaseContexts } from "./Contexts-DqdL7cyX.mjs";
+import { t as BrowserbaseSessions } from "./Sessions-BpZgjteE.mjs";
+import { t as BrowserbaseDownloads } from "./Downloads-CdhiCO5X.mjs";
+import { t as BrowserbaseExtensions } from "./Extensions-DBXuVM1f.mjs";
+import { t as BrowserbaseFunctions } from "./Functions-CsKMMUuZ.mjs";
+import { t as BrowserbasePageFetch } from "./PageFetch-CAMqb5m8.mjs";
+import { t as BrowserbaseProjects } from "./Projects-tm5bTDH0.mjs";
+import { t as BrowserbaseRecordings } from "./Recordings-bVI33sTq.mjs";
+import { t as BrowserbaseReplays } from "./Replays-Bo-9xeLz.mjs";
+import { t as BrowserbaseSearch } from "./Search-1g6TUem7.mjs";
+import { t as BrowserbaseUploads } from "./Uploads-C2neBEpj.mjs";
+import { t as BrowserbaseWebhooks } from "./Webhooks-BoeRAxzG.mjs";
 import { Config, Layer } from "effect";
 //#region src/Account.d.ts
 /** Every resource service this package owns, on one account's authority. */

package/dist/Account.mjs

@@ -1,10 +1,10 @@
-import { t as BrowserbaseClient } from "./Client-BQteUePT.mjs";
+import { t as BrowserbaseClient } from "./Client-4RMKIpL2.mjs";
 import { BrowserbaseAgents } from "./Agents.mjs";
 import { BrowserbaseCertificates } from "./Certificates.mjs";
 import { BrowserbaseContexts } from "./Contexts.mjs";
-import { t as BrowserbaseSessions } from "./Sessions-DoQGg9nB.mjs";
+import { t as BrowserbaseSessions } from "./Sessions-suOLSym9.mjs";
 import { BrowserbaseDownloads } from "./Downloads.mjs";
-import { t as BrowserbaseExtensions } from "./Extensions-nMNMPGCc.mjs";
+import { t as BrowserbaseExtensions } from "./Extensions-Dg3jHOf0.mjs";
 import { BrowserbaseFunctions } from "./Functions.mjs";
 import { BrowserbasePageFetch } from "./PageFetch.mjs";
 import { BrowserbaseProjects } from "./Projects.mjs";

package/dist/{Acquisition-D8o4jtCg.mjs → Acquisition-CAsTTXp4.mjs}

@@ -1,12 +1,12 @@
 import { Identifier, SessionReference } from "./References.mjs";
 import { AllocationError, ContextError, SessionError } from "./Errors.mjs";
-import { t as BrowserbaseClient } from "./Client-BQteUePT.mjs";
-import { t as compileLaunch } from "./Launch-m0fxzJ49.mjs";
+import { t as BrowserbaseClient } from "./Client-4RMKIpL2.mjs";
+import { t as compileLaunch } from "./Launch-cAdE2rrZ.mjs";
 import { CleanupIssue, CleanupResult } from "./Cleanup.mjs";
-import { i as requireContextWriterPermit } from "./ContextWriter-BrQmoXRg.mjs";
-import { t as BrowserbaseSessions } from "./Sessions-DoQGg9nB.mjs";
-import { t as connectionAddress } from "./Connection-DcvJZEdc.mjs";
-import { Cause, Clock, Data, Effect, ErrorReporter, Exit, Option, Schema, Scope } from "effect";
+import { i as requireContextWriterPermit } from "./ContextWriter-oKWFLHuP.mjs";
+import { t as BrowserbaseSessions } from "./Sessions-suOLSym9.mjs";
+import { t as connectionAddress } from "./Connection-sxyxtwlk.mjs";
+import { Cause, Clock, Crypto, Data, Effect, ErrorReporter, Exit, Option, Schema, Scope } from "effect";
 import { cleanupStep, noConnection, reported } from "effect-browser/browser-runtime";
 //#region src/internal/session/Cleanup.ts
 const noLocalConnection = noConnection;
@@ -116,10 +116,11 @@ const AllocatedIdentity = Schema.Struct({
 const acquireRemote = Effect.fnUntraced(function* (options, local = noLocalConnection, limits) {
 	const client = yield* BrowserbaseClient;
 	const sessions = yield* BrowserbaseSessions;
+	const crypto = yield* Crypto.Crypto;
 	const parent = yield* Scope.Scope;
 	const launch = yield* compileLaunch(options.launch, {
 		projectId: client.projectId,
-		attemptId: globalThis.crypto.randomUUID(),
+		attemptId: yield* Effect.orDie(crypto.randomUUIDv4),
 		requestedAtMillis: yield* Clock.currentTimeMillis
 	});
 	const attempt = launch.attempt;
@@ -231,4 +232,4 @@ const acquireRemote = Effect.fnUntraced(function* (options, local = noLocalConne
 //#endregion
 export { reported as a, noLocalConnection as i, reportCleanup as n, makeCleanup as r, acquireRemote as t };
 
-//# sourceMappingURL=Acquisition-D8o4jtCg.mjs.map
+//# sourceMappingURL=Acquisition-CAsTTXp4.mjs.map

package/dist/Acquisition-CAsTTXp4.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Acquisition-CAsTTXp4.mjs","names":[],"sources":["../src/internal/session/Cleanup.ts","../src/internal/session/Diagnostics.ts","../src/internal/session/Acquisition.ts"],"sourcesContent":["import { Effect, Option } from \"effect\";\nimport { cleanupStep, noConnection, type ConnectionCleanup } from \"effect-browser/browser-runtime\";\n\nexport { reported } from \"effect-browser/browser-runtime\";\nexport type { ConnectionCleanup as LocalCleanup } from \"effect-browser/browser-runtime\";\n\nimport { CleanupIssue, CleanupResult } from \"../../Cleanup.ts\";\nimport type { SessionReference } from \"../../References.ts\";\nimport type { SessionStatus } from \"../../SessionData.ts\";\nimport type { BrowserbaseSessions } from \"../../Sessions.ts\";\n\nexport const noLocalConnection = noConnection;\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: ConnectionCleanup,\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          cleanupStep(action, milliseconds).pipe(\n            Effect.tap((result) =>\n              Effect.sync(() => {\n                if (result._tag === \"Failure\")\n                  issues.push(CleanupIssue.make({ step: name, reason: result.reason }));\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 = disconnected._tag === \"Success\" ? 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 = requested._tag === \"Success\";\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 (terminal._tag === \"Success\") {\n            remote = \"confirmed\";\n            observedStatus = terminal.value.status;\n          } else if (requested._tag === \"Success\") {\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  override readonly [ErrorReporter.severity] = \"Warn\" as const;\n\n  override 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, Crypto, 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 crypto = yield* Crypto.Crypto;\n  const parent = yield* Scope.Scope;\n\n  const launch = yield* compileLaunch(options.launch, {\n    projectId: client.projectId,\n    // Secure randomness is a platform precondition, so its failure is a defect, not an outcome.\n    attemptId: yield* Effect.orDie(crypto.randomUUIDv4),\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            const result = cleanup;\n            const notify = options.onCleanup;\n\n            if (result !== undefined) {\n              yield* reported(Effect.suspend(() => reportCleanup(result)));\n              if (notify !== undefined) yield* reported(Effect.suspend(() => notify(result)));\n            }\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-5HpTp9YE.d.mts

@@ -0,0 +1,155 @@
+import { n as ContextReference } from "./References-DOH3Wu44.mjs";
+import { PlatformError } from "./Errors.mjs";
+import { t as BrowserbaseClient } from "./Client-B_f6bBLT.mjs";
+import { Context, Effect, Layer, Schema } from "effect";
+//#region src/Agents.d.ts
+declare const AgentRunStatus: Schema.Literals<readonly ["PENDING", "RUNNING", "COMPLETED", "FAILED", "STOPPED", "TIMED_OUT"]>;
+type AgentRunStatus = typeof AgentRunStatus.Type;
+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;
+}>, {}>;
+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;
+}>, {}>;
+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>;
+}>, {}>;
+declare class AgentRunMessage extends AgentRunMessage_base {}
+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>>>;
+}>;
+type AgentDefinition = typeof AgentDefinition.Type;
+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>>>;
+}>;
+type AgentUpdate = typeof AgentUpdate.Type;
+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>;
+  }>>;
+}>;
+type AgentRunRequest = typeof AgentRunRequest.Type;
+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>;
+}>;
+type AgentListQuery = typeof AgentListQuery.Type;
+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>;
+}>;
+type AgentRunListQuery = typeof AgentRunListQuery.Type;
+declare const AgentMessageQuery: Schema.Struct<{
+  readonly since: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly limit: Schema.optionalKey<Schema.Int>;
+  readonly all: Schema.optionalKey<Schema.Boolean>;
+}>;
+type AgentMessageQuery = typeof AgentMessageQuery.Type;
+declare const AgentRunWaitOptions: Schema.Struct<{
+  readonly timeoutMillis: Schema.Int;
+  readonly pollIntervalMillis: Schema.optionalKey<Schema.Int>;
+}>;
+type AgentRunWaitOptions = typeof AgentRunWaitOptions.Type;
+interface Page<A> {
+  readonly items: ReadonlyArray<A>;
+  readonly nextCursor: string | undefined;
+}
+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`.
+ */
+declare class BrowserbaseAgents extends BrowserbaseAgents_base {
+  static readonly layer: Layer.Layer<BrowserbaseAgents, never, BrowserbaseClient>;
+}
+//#endregion
+export { AgentMetadata as a, AgentRunMessage as c, AgentRunWaitOptions as d, AgentUpdate as f, isTerminalAgentRunStatus as h, AgentMessages as i, AgentRunRequest as l, Page as m, AgentListQuery as n, AgentRun as o, BrowserbaseAgents as p, AgentMessageQuery as r, AgentRunListQuery as s, AgentDefinition as t, AgentRunStatus as u };
+export {};
+//# sourceMappingURL=Agents-5HpTp9YE.d.mts.map

package/dist/Agents.d.mts

@@ -1,154 +1,3 @@
-import { n as ContextReference } from "./References-DOH3Wu44.mjs";
-import { PlatformError } from "./Errors.mjs";
-import { BrowserbaseClient } from "./Client.mjs";
-import { Context, Effect, Layer, Schema } from "effect";
-//#region src/Agents.d.ts
-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 {};
-//# sourceMappingURL=Agents.d.mts.map
+import { a as AgentMetadata, c as AgentRunMessage, d as AgentRunWaitOptions, f as AgentUpdate, h as isTerminalAgentRunStatus, i as AgentMessages, l as AgentRunRequest, m as Page, n as AgentListQuery, o as AgentRun, p as BrowserbaseAgents, r as AgentMessageQuery, s as AgentRunListQuery, t as AgentDefinition, u as AgentRunStatus } from "./Agents-5HpTp9YE.mjs";
+export { AgentDefinition, AgentListQuery, AgentMessageQuery, AgentMessages, AgentMetadata, AgentRun, AgentRunListQuery, AgentRunMessage, AgentRunRequest, AgentRunStatus, AgentRunWaitOptions, AgentUpdate, BrowserbaseAgents, Page, isTerminalAgentRunStatus };
+export {};

package/dist/Agents.mjs

@@ -1,10 +1,10 @@
 import { ContextReference, Identifier } from "./References.mjs";
 import { PlatformError } from "./Errors.mjs";
-import { t as BrowserbaseClient } from "./Client-BQteUePT.mjs";
+import { t as BrowserbaseClient } from "./Client-4RMKIpL2.mjs";
 import { t as resource } from "./Resource-DBksC4zB.mjs";
 import { ProxyRule } from "./Launch.mjs";
-import { n as proxy } from "./Launch-m0fxzJ49.mjs";
-import { n as isContextWriterBusy } from "./ContextWriter-BrQmoXRg.mjs";
+import { n as proxy } from "./Launch-cAdE2rrZ.mjs";
+import { n as isContextWriterBusy } from "./ContextWriter-oKWFLHuP.mjs";
 import { Clock, Context, Effect, Layer, Schema } from "effect";
 //#region src/Agents.ts
 const Timestamp = Schema.String.check(Schema.isMaxLength(64));

package/dist/Allocation.d.mts

@@ -1,9 +1,9 @@
 import { a as SessionReference, n as ContextReference, r as ExtensionReference, t as AllocationAttempt } from "./References-DOH3Wu44.mjs";
 import { AllocationError, ContextError } from "./Errors.mjs";
-import { BrowserbaseClient } from "./Client.mjs";
-import { t as BrowserbaseSessions } from "./Sessions-tFJYaXFq.mjs";
+import { t as BrowserbaseClient } from "./Client-B_f6bBLT.mjs";
+import { t as BrowserbaseSessions } from "./Sessions-BpZgjteE.mjs";
 import { n as CleanupResult } from "./Cleanup-DMTDBir8.mjs";
-import { n as ContextWriterPermit } from "./WriterFacts-5CPBGG1P.mjs";
+import { n as ContextWriterPermit } from "./WriterFacts-BBJRDZYY.mjs";
 import "./ContextCoordination.mjs";
 import { Effect, Option } from "effect";
 //#region src/Allocation.d.ts
@@ -91,7 +91,7 @@ export declare const scoped: (launch: {
       readonly [x: string]: import("effect/Schema").Json;
     } | undefined;
   };
-}, options?: AllocationOptions | undefined) => Effect.Effect<AllocatedSession, AllocationError | import("effect-browser/errors").BrowserError | ContextError, BrowserbaseClient | BrowserbaseSessions | import("effect/Scope").Scope>;
+}, options?: AllocationOptions | undefined) => Effect.Effect<AllocatedSession, AllocationError | import("effect-browser/errors").BrowserError | ContextError, BrowserbaseClient | BrowserbaseSessions | import("effect/Crypto").Crypto | import("effect/Scope").Scope>;
 //#endregion
 export {};
 //# sourceMappingURL=Allocation.d.mts.map

package/dist/Allocation.mjs

@@ -1,4 +1,4 @@
-import { t as acquireRemote } from "./Acquisition-D8o4jtCg.mjs";
+import { t as acquireRemote } from "./Acquisition-CAsTTXp4.mjs";
 import { Effect } from "effect";
 //#region src/Allocation.ts
 /**