@conto_finance/sdk 0.3.1 → 0.5.0

package/dist/browserbase.mjs

@@ -0,0 +1,608 @@
+import {
+  createGuardedPlaywrightCheckoutRuntimeHost
+} from "./chunk-HM4EG5MH.mjs";
+import "./chunk-O5RAAB2U.mjs";
+import "./chunk-B7F5QLE5.mjs";
+
+// src/browserbase.ts
+import { createHmac, timingSafeEqual } from "crypto";
+var BROWSERBASE_API_ORIGIN = "https://api.browserbase.com";
+var BROWSERBASE_CONNECT_ORIGINS = Object.freeze([
+  "wss://connect.browserbase.com",
+  "wss://connect.usw2.browserbase.com"
+]);
+var BROWSERBASE_LIVE_VIEW_DOMAIN = "browserbase.com";
+var DEFAULT_SESSION_TIMEOUT_SECONDS = 900;
+var MIN_SESSION_TIMEOUT_SECONDS = 60;
+var MAX_SESSION_TIMEOUT_SECONDS = 21600;
+var DEFAULT_REQUEST_TIMEOUT_MS = 1e4;
+var MAX_REQUEST_TIMEOUT_MS = 6e4;
+var MAX_PROVIDER_RESPONSE_BYTES = 64 * 1024;
+var MAX_HANDOFF_ASSERTION_TTL_MS = 5 * 60 * 1e3;
+var HANDOFF_ASSERTION_VERSION = "bbh1";
+var BrowserbaseSessionError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "BrowserbaseSessionError";
+  }
+};
+function handoffKey(value) {
+  if (value === void 0) return void 0;
+  const key = Buffer.from(value);
+  if (key.length !== 32) {
+    fail("BROWSERBASE_CONFIG_INVALID", "browserbase.handoffKey must contain exactly 32 bytes.");
+  }
+  return key;
+}
+function handoffExpiresAt(value) {
+  const normalized = requiredText(value, "handoff.expiresAt", 100);
+  const milliseconds = Date.parse(normalized);
+  if (!Number.isFinite(milliseconds)) {
+    fail("BROWSERBASE_CONFIG_INVALID", "handoff.expiresAt is invalid.");
+  }
+  return new Date(milliseconds).toISOString();
+}
+function handoffPayload(input) {
+  return JSON.stringify([
+    HANDOFF_ASSERTION_VERSION,
+    sessionId(input.browserSessionId),
+    requiredText(input.projectId, "handoff.projectId"),
+    requiredText(input.organizationId, "handoff.organizationId"),
+    requiredText(input.agentId, "handoff.agentId"),
+    handoffExpiresAt(input.expiresAt)
+  ]);
+}
+function createBrowserbaseSessionHandoffAssertion(input, keyValue) {
+  const key = handoffKey(keyValue);
+  if (!key) fail("BROWSERBASE_CONFIG_INVALID", "A Browserbase handoff key is required.");
+  const expiresAt = handoffExpiresAt(input.expiresAt);
+  const signature = createHmac("sha256", key).update(handoffPayload({ ...input, expiresAt })).digest("base64url");
+  return `${HANDOFF_ASSERTION_VERSION}.${Date.parse(expiresAt)}.${signature}`;
+}
+function verifyBrowserbaseSessionHandoffAssertion(assertionValue, input, key, now) {
+  if (typeof assertionValue !== "string" || assertionValue.length > 512) return false;
+  const match = /^bbh1\.([0-9]{13})\.([A-Za-z0-9_-]{43})$/.exec(assertionValue);
+  if (!match) return false;
+  const expiresAtMilliseconds = Number(match[1]);
+  if (!Number.isSafeInteger(expiresAtMilliseconds) || expiresAtMilliseconds <= now.getTime() || expiresAtMilliseconds > now.getTime() + MAX_HANDOFF_ASSERTION_TTL_MS) {
+    return false;
+  }
+  const expiresAt = new Date(expiresAtMilliseconds).toISOString();
+  const expected = createHmac("sha256", key).update(handoffPayload({ ...input, expiresAt })).digest();
+  const received = Buffer.from(match[2], "base64url");
+  return received.length === expected.length && timingSafeEqual(received, expected);
+}
+function lifecycleOwner(binding) {
+  return binding.lifecycleOwner === "AGENT_HOST" ? "AGENT_HOST" : "CONTO_RUNTIME";
+}
+function fail(code, message) {
+  throw new BrowserbaseSessionError(code, message);
+}
+function requiredText(value, field, maxLength = 255) {
+  if (typeof value !== "string") fail("BROWSERBASE_CONFIG_INVALID", `${field} is invalid.`);
+  const normalized = value.trim();
+  if (!normalized || normalized.length > maxLength || /[\u0000-\u001f\u007f]/.test(normalized)) {
+    fail("BROWSERBASE_CONFIG_INVALID", `${field} is invalid.`);
+  }
+  return normalized;
+}
+function providerText(value, field, maxLength = 255) {
+  if (typeof value !== "string") {
+    fail("BROWSERBASE_PROVIDER_RESPONSE_INVALID", `Browserbase returned an invalid ${field}.`);
+  }
+  const normalized = value.trim();
+  if (!normalized || normalized.length > maxLength || /[\u0000-\u001f\u007f]/.test(normalized)) {
+    fail("BROWSERBASE_PROVIDER_RESPONSE_INVALID", `Browserbase returned an invalid ${field}.`);
+  }
+  return normalized;
+}
+function sessionId(value, source = "config") {
+  const code = source === "config" ? "BROWSERBASE_CONFIG_INVALID" : "BROWSERBASE_PROVIDER_RESPONSE_INVALID";
+  if (typeof value !== "string" || !/^[A-Za-z0-9_-]{1,200}$/.test(value)) {
+    fail(code, "The Browserbase session ID is invalid.");
+  }
+  return value;
+}
+function timestamp(value, field) {
+  const normalized = providerText(value, field, 100);
+  const milliseconds = Date.parse(normalized);
+  if (!Number.isFinite(milliseconds)) {
+    fail("BROWSERBASE_PROVIDER_RESPONSE_INVALID", `Browserbase returned an invalid ${field}.`);
+  }
+  return new Date(milliseconds).toISOString();
+}
+function timeoutSeconds(value) {
+  const normalized = value ?? DEFAULT_SESSION_TIMEOUT_SECONDS;
+  if (!Number.isSafeInteger(normalized) || normalized < MIN_SESSION_TIMEOUT_SECONDS || normalized > MAX_SESSION_TIMEOUT_SECONDS) {
+    fail(
+      "BROWSERBASE_CONFIG_INVALID",
+      `timeoutSeconds must be an integer from ${MIN_SESSION_TIMEOUT_SECONDS} to ${MAX_SESSION_TIMEOUT_SECONDS}.`
+    );
+  }
+  return normalized;
+}
+function requestTimeoutMs(value) {
+  const normalized = value ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  if (!Number.isSafeInteger(normalized) || normalized < 1 || normalized > MAX_REQUEST_TIMEOUT_MS) {
+    fail(
+      "BROWSERBASE_CONFIG_INVALID",
+      `requestTimeoutMs must be an integer from 1 to ${MAX_REQUEST_TIMEOUT_MS}.`
+    );
+  }
+  return normalized;
+}
+function secureConnectUrl(value) {
+  const normalized = providerText(value, "connectUrl", 4096);
+  try {
+    const url = new URL(normalized);
+    if (url.protocol !== "wss:" || !BROWSERBASE_CONNECT_ORIGINS.includes(url.origin) || url.username || url.password || url.hash) {
+      throw new Error("unsafe Browserbase connect URL");
+    }
+    return url.toString();
+  } catch {
+    fail(
+      "BROWSERBASE_PROVIDER_RESPONSE_INVALID",
+      "Browserbase returned an untrusted connection URL."
+    );
+  }
+}
+function secureLiveViewUrl(value) {
+  const normalized = providerText(value, "debuggerFullscreenUrl", 8192);
+  try {
+    const url = new URL(normalized);
+    const trustedHostname = url.hostname === BROWSERBASE_LIVE_VIEW_DOMAIN || url.hostname.endsWith(`.${BROWSERBASE_LIVE_VIEW_DOMAIN}`);
+    if (url.protocol !== "https:" || !trustedHostname || url.username || url.password || url.port && url.port !== "443") {
+      throw new Error("unsafe Browserbase live view URL");
+    }
+    return url.toString();
+  } catch {
+    fail(
+      "BROWSERBASE_PROVIDER_RESPONSE_INVALID",
+      "Browserbase returned an untrusted live view URL."
+    );
+  }
+}
+function parseProviderSession(value, expectedProjectId, expectedSessionId) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    fail("BROWSERBASE_PROVIDER_RESPONSE_INVALID", "Browserbase returned an invalid session.");
+  }
+  const record = value;
+  const id = sessionId(record.id, "provider");
+  const projectId = providerText(record.projectId, "projectId");
+  const status = record.status;
+  if (!["PENDING", "RUNNING", "ERROR", "TIMED_OUT", "COMPLETED"].includes(
+    typeof status === "string" ? status : ""
+  )) {
+    fail(
+      "BROWSERBASE_PROVIDER_RESPONSE_INVALID",
+      "Browserbase returned an invalid session status."
+    );
+  }
+  if (projectId !== expectedProjectId || expectedSessionId && id !== expectedSessionId) {
+    fail("BROWSERBASE_PROVIDER_RESPONSE_INVALID", "Browserbase returned a mismatched session.");
+  }
+  const createdAt = timestamp(record.createdAt, "createdAt");
+  const expiresAt = timestamp(record.expiresAt, "expiresAt");
+  if (Date.parse(expiresAt) <= Date.parse(createdAt)) {
+    fail(
+      "BROWSERBASE_PROVIDER_RESPONSE_INVALID",
+      "Browserbase returned invalid session timestamps."
+    );
+  }
+  return Object.freeze({
+    id,
+    projectId,
+    status,
+    createdAt,
+    expiresAt,
+    connectUrl: secureConnectUrl(record.connectUrl)
+  });
+}
+async function readProviderJson(response) {
+  let body;
+  try {
+    body = await response.text();
+  } catch {
+    fail("BROWSERBASE_PROVIDER_RESPONSE_INVALID", "Browserbase returned an unreadable response.");
+  }
+  if (body.length > MAX_PROVIDER_RESPONSE_BYTES) {
+    fail("BROWSERBASE_PROVIDER_RESPONSE_INVALID", "Browserbase returned an oversized response.");
+  }
+  try {
+    return JSON.parse(body);
+  } catch {
+    fail("BROWSERBASE_PROVIDER_RESPONSE_INVALID", "Browserbase returned invalid JSON.");
+  }
+}
+function activeProviderSession(session, now) {
+  return (session.status === "PENDING" || session.status === "RUNNING") && Date.parse(session.expiresAt) > now.getTime();
+}
+function validBinding(value, ownership, expectedSessionId, now) {
+  if (!value || typeof value !== "object") return false;
+  return value.browserSessionId === expectedSessionId && value.organizationId === ownership.organizationId && value.agentId === ownership.agentId && value.projectId === ownership.projectId && value.state === "ACTIVE" && Number.isFinite(Date.parse(value.expiresAt)) && Date.parse(value.expiresAt) > now.getTime();
+}
+function createBrowserbaseSessionManager(config) {
+  if (!config || typeof config !== "object") {
+    fail("BROWSERBASE_CONFIG_INVALID", "The Browserbase configuration is required.");
+  }
+  const apiKey = requiredText(config.apiKey, "browserbase.apiKey", 1024);
+  if (apiKey.startsWith("conto_")) {
+    fail("BROWSERBASE_CONFIG_INVALID", "A Browserbase API key is required.");
+  }
+  const projectId = requiredText(config.projectId, "browserbase.projectId");
+  const organizationId = requiredText(config.organizationId, "browserbase.organizationId");
+  const agentId = requiredText(config.agentId, "browserbase.agentId");
+  const contextId = config.contextId === void 0 ? void 0 : requiredText(config.contextId, "browserbase.contextId");
+  const sessionHandoffKey = handoffKey(config.handoffKey);
+  if (!config.bindingStore || typeof config.bindingStore.create !== "function" || typeof config.bindingStore.get !== "function" || typeof config.bindingStore.revoke !== "function") {
+    fail("BROWSERBASE_CONFIG_INVALID", "A durable Browserbase session binding store is required.");
+  }
+  if (contextId && typeof config.bindingStore.releaseContextLease !== "function") {
+    fail(
+      "BROWSERBASE_CONFIG_INVALID",
+      "A durable Browserbase Context lease store is required when contextId is configured."
+    );
+  }
+  const fetchImpl = config.fetch ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    fail("BROWSERBASE_CONFIG_INVALID", "A fetch implementation is required.");
+  }
+  const durationSeconds = timeoutSeconds(config.timeoutSeconds);
+  const providerRequestTimeoutMs = requestTimeoutMs(config.requestTimeoutMs);
+  const now = config.now ?? (() => /* @__PURE__ */ new Date());
+  const ownership = Object.freeze({ organizationId, agentId, projectId });
+  async function providerRequest(path, init) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), providerRequestTimeoutMs);
+    try {
+      return await fetchImpl(`${BROWSERBASE_API_ORIGIN}${path}`, {
+        ...init,
+        redirect: "error",
+        cache: "no-store",
+        signal: controller.signal,
+        headers: {
+          Accept: "application/json",
+          "X-BB-API-Key": apiKey,
+          ...init.headers
+        }
+      });
+    } catch {
+      fail("BROWSERBASE_PROVIDER_UNAVAILABLE", "Browserbase could not be reached.");
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  async function releaseProviderSession(browserSessionId) {
+    const response = await providerRequest(`/v1/sessions/${encodeURIComponent(browserSessionId)}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ status: "REQUEST_RELEASE" })
+    });
+    if (!response.ok) {
+      fail("BROWSERBASE_SESSION_RELEASE_FAILED", "Browserbase did not release the session.");
+    }
+  }
+  return Object.freeze({
+    async createSession() {
+      const response = await providerRequest("/v1/sessions", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          projectId,
+          timeout: durationSeconds,
+          keepAlive: true,
+          ...contextId ? {
+            browserSettings: {
+              context: { id: contextId, persist: true }
+            }
+          } : {}
+        })
+      });
+      if (response.status !== 201) {
+        fail("BROWSERBASE_PROVIDER_UNAVAILABLE", "Browserbase did not create a session.");
+      }
+      const providerSession = parseProviderSession(await readProviderJson(response), projectId);
+      if (!activeProviderSession(providerSession, now())) {
+        try {
+          await releaseProviderSession(providerSession.id);
+        } catch {
+        }
+        fail("BROWSERBASE_PROVIDER_RESPONSE_INVALID", "Browserbase returned an inactive session.");
+      }
+      const binding = Object.freeze({
+        browserSessionId: providerSession.id,
+        ...ownership,
+        lifecycleOwner: "CONTO_RUNTIME",
+        state: "ACTIVE",
+        createdAt: providerSession.createdAt,
+        expiresAt: providerSession.expiresAt
+      });
+      let created = false;
+      try {
+        created = await config.bindingStore.create(binding);
+      } catch {
+      }
+      if (!created) {
+        try {
+          await releaseProviderSession(providerSession.id);
+        } catch {
+        }
+        fail(
+          "BROWSERBASE_SESSION_BINDING_FAILED",
+          "The Browserbase session ownership binding could not be stored."
+        );
+      }
+      return Object.freeze({
+        browserSessionId: providerSession.id,
+        status: providerSession.status,
+        expiresAt: providerSession.expiresAt
+      });
+    },
+    async attachSession(input) {
+      if (!sessionHandoffKey) {
+        fail(
+          "BROWSERBASE_SESSION_HANDOFF_DISABLED",
+          "Browserbase session handoff is not configured."
+        );
+      }
+      if (!input || typeof input !== "object") {
+        fail("BROWSERBASE_SESSION_HANDOFF_INVALID", "The Browserbase session handoff is invalid.");
+      }
+      if (typeof input.browserSessionId !== "string" || !/^[A-Za-z0-9_-]{1,200}$/.test(input.browserSessionId)) {
+        fail("BROWSERBASE_SESSION_HANDOFF_INVALID", "The Browserbase session handoff is invalid.");
+      }
+      const browserSessionId = input.browserSessionId;
+      if (!verifyBrowserbaseSessionHandoffAssertion(
+        input.handoffAssertion,
+        { browserSessionId, ...ownership },
+        sessionHandoffKey,
+        now()
+      )) {
+        fail("BROWSERBASE_SESSION_HANDOFF_INVALID", "The Browserbase session handoff is invalid.");
+      }
+      const response = await providerRequest(
+        `/v1/sessions/${encodeURIComponent(browserSessionId)}`,
+        { method: "GET" }
+      );
+      if (response.status === 404) {
+        fail("BROWSERBASE_SESSION_NOT_OWNED", "The Browserbase session is not owned.");
+      }
+      if (!response.ok) {
+        fail("BROWSERBASE_PROVIDER_UNAVAILABLE", "Browserbase could not verify the session.");
+      }
+      const providerSession = parseProviderSession(
+        await readProviderJson(response),
+        projectId,
+        browserSessionId
+      );
+      const currentTime = now();
+      if (!activeProviderSession(providerSession, currentTime)) {
+        fail("BROWSERBASE_SESSION_NOT_OWNED", "The Browserbase session is not active.");
+      }
+      const binding = Object.freeze({
+        browserSessionId,
+        ...ownership,
+        lifecycleOwner: "AGENT_HOST",
+        state: "ACTIVE",
+        createdAt: providerSession.createdAt,
+        expiresAt: providerSession.expiresAt
+      });
+      let created = false;
+      try {
+        created = await config.bindingStore.create(binding);
+      } catch {
+      }
+      if (!created) {
+        let existing = null;
+        try {
+          existing = await config.bindingStore.get(browserSessionId);
+        } catch {
+        }
+        if (!validBinding(existing, ownership, browserSessionId, currentTime) || lifecycleOwner(existing) !== "AGENT_HOST" || existing.createdAt !== providerSession.createdAt || existing.expiresAt !== providerSession.expiresAt) {
+          fail(
+            "BROWSERBASE_SESSION_BINDING_FAILED",
+            "The Browserbase session ownership binding could not be stored."
+          );
+        }
+      }
+      return Object.freeze({
+        browserSessionId,
+        status: providerSession.status,
+        expiresAt: providerSession.expiresAt,
+        lifecycleOwner: "AGENT_HOST"
+      });
+    },
+    async connectUrlForSession(browserSessionIdValue) {
+      const browserSessionId = sessionId(browserSessionIdValue);
+      let binding;
+      try {
+        binding = await config.bindingStore.get(browserSessionId);
+      } catch {
+        return null;
+      }
+      if (!validBinding(binding, ownership, browserSessionId, now())) return null;
+      const response = await providerRequest(
+        `/v1/sessions/${encodeURIComponent(browserSessionId)}`,
+        {
+          method: "GET"
+        }
+      );
+      if (!response.ok) return null;
+      const providerSession = parseProviderSession(
+        await readProviderJson(response),
+        projectId,
+        browserSessionId
+      );
+      if (!activeProviderSession(providerSession, now())) return null;
+      let currentBinding;
+      try {
+        currentBinding = await config.bindingStore.get(browserSessionId);
+      } catch {
+        return null;
+      }
+      if (!validBinding(currentBinding, ownership, browserSessionId, now()) || providerSession.expiresAt !== binding.expiresAt || providerSession.expiresAt !== currentBinding.expiresAt) {
+        return null;
+      }
+      return providerSession.connectUrl;
+    },
+    async liveViewForSession(browserSessionIdValue) {
+      const browserSessionId = sessionId(browserSessionIdValue);
+      let binding;
+      try {
+        binding = await config.bindingStore.get(browserSessionId);
+      } catch {
+        fail("BROWSERBASE_LIVE_VIEW_UNAVAILABLE", "The Browserbase live view is unavailable.");
+      }
+      if (!validBinding(binding, ownership, browserSessionId, now())) {
+        fail("BROWSERBASE_SESSION_NOT_OWNED", "The Browserbase session is not owned.");
+      }
+      const response = await providerRequest(
+        `/v1/sessions/${encodeURIComponent(browserSessionId)}/debug`,
+        { method: "GET" }
+      );
+      if (!response.ok) {
+        fail("BROWSERBASE_LIVE_VIEW_UNAVAILABLE", "The Browserbase live view is unavailable.");
+      }
+      const value = await readProviderJson(response);
+      if (!value || typeof value !== "object" || Array.isArray(value)) {
+        fail("BROWSERBASE_PROVIDER_RESPONSE_INVALID", "Browserbase returned an invalid live view.");
+      }
+      const liveViewUrl = secureLiveViewUrl(
+        value.debuggerFullscreenUrl
+      );
+      let currentBinding;
+      try {
+        currentBinding = await config.bindingStore.get(browserSessionId);
+      } catch {
+        fail("BROWSERBASE_LIVE_VIEW_UNAVAILABLE", "The Browserbase live view is unavailable.");
+      }
+      if (!validBinding(currentBinding, ownership, browserSessionId, now()) || currentBinding.expiresAt !== binding.expiresAt) {
+        fail("BROWSERBASE_SESSION_NOT_OWNED", "The Browserbase session is not owned.");
+      }
+      return Object.freeze({
+        browserSessionId,
+        liveViewUrl,
+        expiresAt: currentBinding.expiresAt
+      });
+    },
+    async revokeSession(browserSessionIdValue, expectedLifecycleOwner) {
+      const browserSessionId = sessionId(browserSessionIdValue);
+      let binding;
+      try {
+        binding = await config.bindingStore.get(browserSessionId);
+      } catch {
+        return false;
+      }
+      if (!validBinding(binding, ownership, browserSessionId, now()) || lifecycleOwner(binding) !== expectedLifecycleOwner) {
+        return false;
+      }
+      try {
+        return await config.bindingStore.revoke({
+          browserSessionId,
+          ...ownership,
+          revokedAt: now().toISOString()
+        });
+      } catch {
+        fail(
+          "BROWSERBASE_SESSION_RELEASE_FAILED",
+          "The Browserbase session ownership binding could not be revoked."
+        );
+      }
+    },
+    async releaseContextLease(browserSessionIdValue) {
+      if (!contextId) return true;
+      const browserSessionId = sessionId(browserSessionIdValue);
+      try {
+        return await config.bindingStore.releaseContextLease({
+          browserSessionId,
+          ...ownership
+        });
+      } catch {
+        return false;
+      }
+    },
+    releaseProviderSession
+  });
+}
+function createBrowserbaseGuardedPlaywrightCheckoutRuntimeHost(config) {
+  if (!config || typeof config !== "object") {
+    fail(
+      "BROWSERBASE_CONFIG_INVALID",
+      "The Browserbase guarded runtime configuration is required."
+    );
+  }
+  if (config.token === config.browserbase?.apiKey) {
+    fail("BROWSERBASE_CONFIG_INVALID", "Use a dedicated browser runtime token.");
+  }
+  const manager = createBrowserbaseSessionManager(config.browserbase);
+  const host = createGuardedPlaywrightCheckoutRuntimeHost({
+    conto: config.conto,
+    browserSessions: {
+      allowedConnectOrigins: BROWSERBASE_CONNECT_ORIGINS,
+      connectUrlForSession: manager.connectUrlForSession,
+      connectOverCDP: config.connectOverCDP,
+      selectPage: config.selectPage,
+      maxSessions: config.maxSessions
+    },
+    targetStore: config.targetStore,
+    dispatchAttemptFor: config.dispatchAttemptFor,
+    token: config.token,
+    maxBodyBytes: config.maxBodyBytes,
+    clickTimeoutMs: config.clickTimeoutMs,
+    popupTimeoutMs: config.popupTimeoutMs,
+    targetTtlMs: config.targetTtlMs,
+    now: config.now
+  });
+  return Object.freeze({
+    handler: host.handler,
+    createSession: manager.createSession,
+    attachSession: manager.attachSession,
+    observeSession: host.observeSession,
+    liveViewForSession: manager.liveViewForSession,
+    async releaseSession(browserSessionId) {
+      const revoked = await manager.revokeSession(browserSessionId, "CONTO_RUNTIME");
+      if (!revoked) {
+        fail(
+          "BROWSERBASE_SESSION_NOT_OWNED",
+          "The Browserbase session is not active for this organization and agent."
+        );
+      }
+      const results = await Promise.allSettled([
+        host.closeSession(browserSessionId),
+        manager.releaseProviderSession(browserSessionId)
+      ]);
+      const contextLeaseReleased = results[1].status === "fulfilled" ? await manager.releaseContextLease(browserSessionId) : false;
+      if (results.some((result) => result.status === "rejected") || !contextLeaseReleased) {
+        fail(
+          "BROWSERBASE_SESSION_RELEASE_FAILED",
+          "The Browserbase session could not be released."
+        );
+      }
+    },
+    async detachSession(browserSessionId) {
+      const revoked = await manager.revokeSession(browserSessionId, "AGENT_HOST");
+      if (!revoked) {
+        fail(
+          "BROWSERBASE_SESSION_NOT_OWNED",
+          "The Browserbase session is not active for this organization and agent."
+        );
+      }
+      try {
+        await host.closeSession(browserSessionId);
+      } catch {
+        fail(
+          "BROWSERBASE_SESSION_RELEASE_FAILED",
+          "The Browserbase session handoff could not be detached."
+        );
+      }
+    },
+    close: host.close
+  });
+}
+export {
+  BROWSERBASE_CONNECT_ORIGINS,
+  BrowserbaseSessionError,
+  createBrowserbaseGuardedPlaywrightCheckoutRuntimeHost,
+  createBrowserbaseSessionHandoffAssertion
+};