notte-sdk 1.9.0 → 1.9.2

package/dist/index.js

@@ -47,12 +47,14 @@ __export(index_exports, {
   FileExistsError: () => FileExistsError,
   FileNotFoundError: () => FileNotFoundError,
   InvalidRequestError: () => InvalidRequestError,
+  ManagedAuthError: () => ManagedAuthError,
   NotteAPIError: () => NotteAPIError,
   NotteAPIExecutionError: () => NotteAPIExecutionError,
   NotteAnything: () => NotteAnything,
   NotteClient: () => NotteClient3,
   NotteError: () => NotteError,
   NotteFunction: () => NotteFunction,
+  NotteManagedAuth: () => NotteManagedAuth,
   NottePersona: () => NottePersona,
   NotteProxyAuthError: () => NotteProxyAuthError,
   NotteSecrets: () => NotteSecrets,
@@ -82,11 +84,14 @@ __export(index_exports, {
   connectLinkMailboxes: () => connectLinkMailboxes,
   connectLinkStatus: () => connectLinkStatus,
   connectLinkSubmit: () => connectLinkSubmit,
+  connectPaymentWallet: () => connectPaymentWallet,
   createClient: () => createClient2,
   createOrAppendCookiesToFile: () => createOrAppendCookiesToFile,
+  createPayment: () => createPayment,
   default: () => NotteClient3,
   deleteSecret: () => deleteSecret,
   deleteSessionFile: () => deleteSessionFile,
+  disconnectPaymentWallet: () => disconnectPaymentWallet,
   downloadSessionFile: () => downloadSessionFile,
   functionCreate: () => functionCreate,
   functionDelete: () => functionDelete,
@@ -102,6 +107,7 @@ __export(index_exports, {
   functionScheduleDelete: () => functionScheduleDelete,
   functionScheduleSet: () => functionScheduleSet,
   functionUpdate: () => functionUpdate,
+  getPayment: () => getPayment,
   getRootDomain: () => getRootDomain,
   getScript: () => getScript,
   getSecret: () => getSecret,
@@ -158,11 +164,13 @@ __export(index_exports, {
   scrapeFromHtml: () => scrapeFromHtml,
   scrapeWebpage: () => scrapeWebpage,
   searchWeb: () => searchWeb,
+  sessionAuthReadiness: () => sessionAuthReadiness,
   sessionCookiesGet: () => sessionCookiesGet,
   sessionCookiesSet: () => sessionCookiesSet,
   sessionDebugInfo: () => sessionDebugInfo,
   sessionNetworkLogs: () => sessionNetworkLogs,
   sessionOffset: () => sessionOffset,
+  sessionProfilePreview: () => sessionProfilePreview,
   sessionReplay: () => sessionReplay,
   sessionStart: () => sessionStart,
   sessionStatus: () => sessionStatus,
@@ -187,7 +195,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/version.ts
-var SDK_VERSION = true ? "1.9.0" : "dev";
+var SDK_VERSION = true ? "1.9.2" : "dev";
 var SDK_PACKAGE_NAME = true ? "notte-sdk" : "notte-sdk";
 
 // src/version-check.ts
@@ -1120,6 +1128,11 @@ var createClient = (config = {}) => {
 var client = createClient(createConfig({ baseUrl: "https://api.notte.cc" }));
 
 // src/lib/client/sdk.gen.ts
+var sessionAuthReadiness = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/sessions/{session_id}/auth",
+  ...options
+});
 var listSessions = (options) => (options?.client ?? client).get({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/sessions",
@@ -1139,6 +1152,11 @@ var sessionStatus = (options) => (options.client ?? client).get({
   url: "/sessions/{session_id}",
   ...options
 });
+var sessionProfilePreview = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/sessions/{session_id}/profile-preview",
+  ...options
+});
 var getSessionScript = (options) => (options.client ?? client).get({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/sessions/{session_id}/workflow/code",
@@ -1450,6 +1468,38 @@ var listVaults = (options) => (options?.client ?? client).get({
   url: "/vaults",
   ...options
 });
+var connectPaymentWallet = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/payments/connect",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var disconnectPaymentWallet = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/payments/disconnect",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var createPayment = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/sessions/{session_id}/payments",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var getPayment = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/payments/{payment_id}",
+  ...options
+});
 var profileCreate = (options) => (options.client ?? client).post({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/profiles/create",
@@ -1707,10 +1757,8 @@ var scrapeFromHtml = (options) => (options.client ?? client).post({
   }
 });
 
-// src/session.ts
-var import_node_fs = require("fs");
-var import_promises2 = require("fs/promises");
-var import_node_path2 = require("path");
+// src/managed-auth.ts
+var import_promises = require("timers/promises");
 
 // src/errors.ts
 var NotteError = class extends Error {
@@ -1864,70 +1912,544 @@ function sleep(ms) {
   return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 
-// src/actions.ts
-function builder(type) {
-  return (...[input]) => ({ ...input ?? {}, type });
+// src/managed-auth.ts
+var ManagedAuthError = class extends NotteError {
+};
+function validateAuthRetry(value) {
+  if (!Number.isInteger(value) || value < 0 || value > 2) {
+    throw new InvalidRequestError("auth_retry must be an integer between 0 and 2");
+  }
 }
-var goto = builder("goto");
-var gotoNewTab = builder("goto_new_tab");
-var closeTab = builder("close_tab");
-var switchTab = builder("switch_tab");
-var goBack = builder("go_back");
-var goForward = builder("go_forward");
-var reload = builder("reload");
-var wait = builder("wait");
-var pressKey = builder("press_key");
-var scrollUp = builder("scroll_up");
-var scrollDown = builder("scroll_down");
-var captchaSolve = builder("captcha_solve");
-var help = builder("help");
-var completion = builder("completion");
-var scrape = builder("scrape");
-var emailRead = builder("email_read");
-var emailVerificationRead = builder("email_verification_read");
-var smsRead = builder("sms_read");
-var evaluateJs = builder("evaluate_js");
-var formFill = builder("form_fill");
-var click = builder("click");
-var fill = builder("fill");
-var multiFactorFill = builder("multi_factor_fill");
-var fallbackFill = builder("fallback_fill");
-var check = builder("check");
-var selectDropdownOption = builder("select_dropdown_option");
-var uploadFile = builder("upload_file");
-var downloadFile = builder("download_file");
-var actions = {
-  goto,
-  gotoNewTab,
-  closeTab,
-  switchTab,
-  goBack,
-  goForward,
-  reload,
-  wait,
-  pressKey,
-  scrollUp,
-  scrollDown,
-  captchaSolve,
-  help,
-  completion,
-  scrape,
-  emailRead,
-  emailVerificationRead,
-  smsRead,
-  evaluateJs,
-  formFill,
-  click,
-  fill,
-  multiFactorFill,
-  fallbackFill,
-  check,
-  selectDropdownOption,
-  uploadFile,
-  downloadFile
+async function pollAuth(read, options) {
+  const timeoutMs = options.timeoutMs ?? 615e3;
+  const interval = options.pollIntervalMs ?? 1e3;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || !Number.isFinite(interval) || interval <= 0) {
+    throw new InvalidRequestError("timeoutMs and pollIntervalMs must be positive finite numbers");
+  }
+  const deadline = new AbortController();
+  const timer = setTimeout(() => deadline.abort(new NotteTimeoutError("Timed out waiting for authentication")), timeoutMs);
+  const cancel = () => deadline.abort(options.signal?.reason);
+  if (options.signal?.aborted) cancel();
+  else options.signal?.addEventListener("abort", cancel, { once: true });
+  const signal = deadline.signal;
+  let errors = 0;
+  try {
+    while (true) {
+      signal.throwIfAborted();
+      try {
+        const value = await read(signal);
+        signal.throwIfAborted();
+        if (value !== void 0) return value;
+        errors = 0;
+      } catch (error) {
+        signal.throwIfAborted();
+        const retryable = error instanceof NotteAPIError ? error.statusCode >= 500 : error instanceof TypeError || error instanceof NotteTimeoutError;
+        if (!retryable || ++errors >= 3) throw error;
+      }
+      await (0, import_promises.setTimeout)(interval, void 0, { signal });
+    }
+  } catch (error) {
+    signal.throwIfAborted();
+    throw error;
+  } finally {
+    clearTimeout(timer);
+    options.signal?.removeEventListener("abort", cancel);
+  }
+}
+var NotteManagedAuth = class {
+  constructor(client2) {
+    this.client = client2;
+  }
+  /** Run only the verifier; this does not submit login credentials. */
+  async checkConnection(connectionId) {
+    const response = await this.client.getClient().post({
+      url: `/managed-auth/connections/${encodeURIComponent(connectionId)}/check`,
+      body: {},
+      headers: { "Content-Type": "application/json" },
+      throwOnError: true
+    });
+    return response.data;
+  }
+  async getOperation(operationId, options = {}) {
+    const response = await this.client.getClient().get({
+      url: `/managed-auth/operations/${encodeURIComponent(operationId)}`,
+      headers: { [TIMEOUT_HEADER]: "10000" },
+      signal: options.signal,
+      throwOnError: true
+    });
+    return response.data;
+  }
+  /** Wait for an accepted operation. Aborting this wait does not cancel the server operation. */
+  async waitForAuth(operation, options = {}) {
+    const completed = (value) => {
+      if (value.status === "succeeded") return value;
+      if (value.status === "pending" || value.status === "running") return void 0;
+      throw new ManagedAuthError(value.error || "Connection authentication failed");
+    };
+    options.signal?.throwIfAborted();
+    const result = completed(operation);
+    if (result) return result;
+    return pollAuth(async (signal) => completed(await this.getOperation(operation.id, { signal })), options);
+  }
+  /** Verify first, logging in only when required and automatic recovery is allowed. */
+  async refreshConnection(connectionId, options = {}) {
+    return this.run(connectionId, "refresh", options);
+  }
+  /** Explicitly request a new login. Conflicting operations remain HTTP 409 errors. */
+  async reauthenticateConnection(connectionId, options = {}) {
+    return this.run(connectionId, "reauthenticate", options);
+  }
+  async run(connectionId, action, options) {
+    const authRetry = options.auth_retry ?? 0;
+    validateAuthRetry(authRetry);
+    options.signal?.throwIfAborted();
+    const response = await this.client.getClient().post({
+      url: `/managed-auth/connections/${encodeURIComponent(connectionId)}/${action}`,
+      body: { auth_retry: authRetry },
+      headers: { "Content-Type": "application/json" },
+      signal: options.signal,
+      throwOnError: true
+    });
+    return options.wait === false ? response.data : this.waitForAuth(response.data, options);
+  }
 };
-function isCaptchaSolveAction(action) {
-  return action.type === "captcha_solve";
+
+// src/resources.gen.ts
+function createResources(client2, getApiKey) {
+  return {
+    sessions: {
+      /** sessionAuthReadiness: /sessions/{session_id}/auth. Returns the API response body. */
+      authReadiness: async (sessionId, requestOptions = {}) => {
+        const response = await sessionAuthReadiness({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "session_id": sessionId } });
+        return response.data;
+      },
+      /** createPayment: /sessions/{session_id}/payments. Returns the API response body. */
+      createPayment: async (sessionId, body, query = void 0, requestOptions) => {
+        const response = await createPayment({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "session_id": sessionId }, body, query });
+        return response.data;
+      },
+      /** sessionDebugInfo: /sessions/{session_id}/debug. Returns the API response body. */
+      debugInfo: async (sessionId, query = void 0, requestOptions = {}) => {
+        const response = await sessionDebugInfo({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "session_id": sessionId }, query });
+        return response.data;
+      },
+      /** deleteSessionFile: /sessions/{session_id}/files/{file_id}. Returns the API response body. */
+      deleteSessionFile: async (sessionId, fileId, requestOptions = {}) => {
+        const response = await deleteSessionFile({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "session_id": sessionId, "file_id": fileId } });
+        return response.data;
+      },
+      /** downloadSessionFile: /sessions/{session_id}/files/{file_id}. Returns the API response body. */
+      downloadSessionFile: async (sessionId, fileId, requestOptions = {}) => {
+        const response = await downloadSessionFile({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "session_id": sessionId, "file_id": fileId } });
+        return response.data;
+      },
+      /** pageExecute: /sessions/{session_id}/page/execute. Returns the API response body. */
+      execute: async (sessionId, body, query = void 0, requestOptions = {}) => {
+        const response = await pageExecute({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "session_id": sessionId }, body, query });
+        return response.data;
+      },
+      /** sessionCookiesGet: /sessions/{session_id}/cookies. Returns the API response body. */
+      getCookies: async (sessionId, query = void 0, requestOptions = {}) => {
+        const response = await sessionCookiesGet({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "session_id": sessionId }, query });
+        return response.data;
+      },
+      /** getSessionScript: /sessions/{session_id}/workflow/code. Returns the API response body. */
+      getSessionScript: async (sessionId, query, requestOptions = {}) => {
+        const response = await getSessionScript({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "session_id": sessionId }, query });
+        return response.data;
+      },
+      /** listSessions: /sessions. Returns the API response body. */
+      list: async (query = void 0, requestOptions = {}) => {
+        const response = await listSessions({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, query });
+        return response.data;
+      },
+      /** listSessionFiles: /sessions/{session_id}/files. Returns the API response body. */
+      listSessionFiles: async (sessionId, query = void 0, requestOptions = {}) => {
+        const response = await listSessionFiles({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "session_id": sessionId }, query });
+        return response.data;
+      },
+      /** sessionNetworkLogs: /sessions/{session_id}/network/logs. Returns the API response body. */
+      networkLogs: async (sessionId, query = void 0, requestOptions = {}) => {
+        const response = await sessionNetworkLogs({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "session_id": sessionId }, query });
+        return response.data;
+      },
+      /** pageObserve: /sessions/{session_id}/page/observe. Returns the API response body. */
+      observe: async (sessionId, body, query = void 0, requestOptions = {}) => {
+        const response = await pageObserve({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "session_id": sessionId }, body, query });
+        return response.data;
+      },
+      /** sessionOffset: /sessions/{session_id}/offset. Returns the API response body. */
+      offset: async (sessionId, requestOptions = {}) => {
+        const response = await sessionOffset({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "session_id": sessionId } });
+        return response.data;
+      },
+      /** pageScreenshot: /sessions/{session_id}/page/screenshot. Returns the API response body. */
+      pageScreenshot: async (sessionId, query = void 0, requestOptions = {}) => {
+        const response = await pageScreenshot({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "session_id": sessionId }, query });
+        return response.data;
+      },
+      /** sessionProfilePreview: /sessions/{session_id}/profile-preview. Returns the API response body. */
+      profilePreview: async (sessionId, query = void 0, requestOptions = {}) => {
+        const response = await sessionProfilePreview({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "session_id": sessionId }, query });
+        return response.data;
+      },
+      /** sessionReplay: /sessions/{session_id}/replay. Returns the API response body. */
+      replay: async (sessionId, requestOptions = {}) => {
+        const response = await sessionReplay({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "session_id": sessionId } });
+        return response.data;
+      },
+      /** pageScrape: /sessions/{session_id}/page/scrape. Returns the API response body. */
+      scrape: async (sessionId, body, query = void 0, requestOptions = {}) => {
+        const response = await pageScrape({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "session_id": sessionId }, body, query });
+        return response.data;
+      },
+      /** sessionCookiesSet: /sessions/{session_id}/cookies. Returns the API response body. */
+      setCookies: async (sessionId, body, query = void 0, requestOptions = {}) => {
+        const response = await sessionCookiesSet({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "session_id": sessionId }, body, query });
+        return response.data;
+      },
+      /** sessionStart: /sessions/start. Returns the API response body. */
+      start: async (body, requestOptions = {}) => {
+        const response = await sessionStart({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, body });
+        return response.data;
+      },
+      /** sessionStatus: /sessions/{session_id}. Returns the API response body. */
+      status: async (sessionId, requestOptions = {}) => {
+        const response = await sessionStatus({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "session_id": sessionId } });
+        return response.data;
+      },
+      /** sessionStop: /sessions/{session_id}/stop. Returns the API response body. */
+      stop: async (sessionId, query = void 0, requestOptions = {}) => {
+        const response = await sessionStop({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "session_id": sessionId }, query });
+        return response.data;
+      },
+      /** uploadSessionFile: /sessions/{session_id}/files. Returns the API response body. */
+      uploadSessionFile: async (sessionId, body, requestOptions = {}) => {
+        const response = await uploadSessionFile({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "session_id": sessionId }, body });
+        return response.data;
+      }
+    },
+    agents: {
+      /** getScript: /agents/{agent_id}/workflow/code. Returns the API response body. */
+      getScript: async (agentId, query, requestOptions = {}) => {
+        const response = await getScript({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "agent_id": agentId }, query });
+        return response.data;
+      },
+      /** listAgents: /agents. Returns the API response body. */
+      list: async (query = void 0, requestOptions = {}) => {
+        const response = await listAgents({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, query });
+        return response.data;
+      },
+      /** agentStart: /agents/start. Returns the API response body. */
+      start: async (body, requestOptions = {}) => {
+        const response = await agentStart({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, body });
+        return response.data;
+      },
+      /** agentStatus: /agents/{agent_id}. Returns the API response body. */
+      status: async (agentId, requestOptions = {}) => {
+        const response = await agentStatus({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "agent_id": agentId } });
+        return response.data;
+      },
+      /** agentStop: /agents/{agent_id}/stop. Returns the API response body. */
+      stop: async (agentId, query, requestOptions = {}) => {
+        const response = await agentStop({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "agent_id": agentId }, query });
+        return response.data;
+      }
+    },
+    functions: {
+      /** functionCreate: /functions. Returns the API response body. */
+      create: async (body, query = void 0, requestOptions = {}) => {
+        const response = await functionCreate({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, body, query });
+        return response.data;
+      },
+      /** functionDelete: /functions/{function_id}. Returns the API response body. */
+      delete: async (functionId, requestOptions = {}) => {
+        const response = await functionDelete({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "function_id": functionId } });
+        return response.data;
+      },
+      /** functionScheduleDelete: /functions/{function_id}/schedule. Returns the API response body. */
+      deleteSchedule: async (functionId, requestOptions = {}) => {
+        const response = await functionScheduleDelete({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "function_id": functionId } });
+        return response.data;
+      },
+      /** functionDownloadUrl: /functions/{function_id}. Returns the API response body. */
+      downloadUrl: async (functionId, query = void 0, requestOptions = {}) => {
+        const response = await functionDownloadUrl({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "function_id": functionId }, query });
+        return response.data;
+      },
+      /** functionFork: /functions/{function_id}/fork. Returns the API response body. */
+      fork: async (functionId, requestOptions = {}) => {
+        const response = await functionFork({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "function_id": functionId } });
+        return response.data;
+      },
+      /** listFunctions: /functions. Returns the API response body. */
+      list: async (query = void 0, requestOptions = {}) => {
+        const response = await listFunctions({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, query });
+        return response.data;
+      },
+      /** listFunctionRunsByFunctionId: /functions/{function_id}/runs. Returns the API response body. */
+      listRuns: async (functionId, query = void 0, requestOptions = {}) => {
+        const response = await listFunctionRunsByFunctionId({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "function_id": functionId }, query });
+        return response.data;
+      },
+      /** functionMetadataUpdate: /functions/{function_id}. Returns the API response body. */
+      metadataUpdate: async (functionId, body, requestOptions = {}) => {
+        const response = await functionMetadataUpdate({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "function_id": functionId }, body });
+        return response.data;
+      },
+      /** functionRollback: /functions/{function_id}/rollback. Returns the API response body. */
+      rollback: async (functionId, body, query = void 0, requestOptions = {}) => {
+        const response = await functionRollback({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "function_id": functionId }, body, query });
+        return response.data;
+      },
+      /** functionRunGetMetadata: /functions/{function_id}/runs/{run_id}. Returns the API response body. */
+      runGetMetadata: async (functionId, runId, requestOptions = {}) => {
+        const response = await functionRunGetMetadata({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "function_id": functionId, "run_id": runId } });
+        return response.data;
+      },
+      /** functionRunStart: /functions/{function_id}/runs/start. Returns the API response body. */
+      runStart: async (functionId, body, requestOptions = {}) => {
+        const response = await functionRunStart({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers, "x-notte-api-key": getApiKey() }, path: { "function_id": functionId }, body });
+        return response.data;
+      },
+      /** functionRunStop: /functions/{function_id}/runs/{run_id}. Returns the API response body. */
+      runStop: async (functionId, runId, requestOptions = {}) => {
+        const response = await functionRunStop({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "function_id": functionId, "run_id": runId } });
+        return response.data;
+      },
+      /** functionRunUpdateMetadata: /functions/{function_id}/runs/{run_id}. Returns the API response body. */
+      runUpdateMetadata: async (functionId, runId, body, requestOptions = {}) => {
+        const response = await functionRunUpdateMetadata({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "function_id": functionId, "run_id": runId }, body });
+        return response.data;
+      },
+      /** functionRuntimeHealth: /functions/health. Returns the API response body. */
+      runtimeHealth: async (requestOptions = {}) => {
+        const response = await functionRuntimeHealth({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers } });
+        return response.data;
+      },
+      /** functionScheduleSet: /functions/{function_id}/schedule. Returns the API response body. */
+      setSchedule: async (functionId, body, requestOptions = {}) => {
+        const response = await functionScheduleSet({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "function_id": functionId }, body });
+        return response.data;
+      },
+      /** functionUpdate: /functions/{function_id}. Returns the API response body. */
+      update: async (functionId, body, query = void 0, requestOptions = {}) => {
+        const response = await functionUpdate({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "function_id": functionId }, body, query });
+        return response.data;
+      }
+    },
+    vaults: {
+      /** vaultCreate: /vaults/create. Returns the API response body. */
+      create: async (body, requestOptions = {}) => {
+        const response = await vaultCreate({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, body });
+        return response.data;
+      },
+      /** vaultCredentialsAdd: /vaults/{vault_id}/credentials. Returns the API response body. */
+      credentialsAdd: async (vaultId, body, requestOptions = {}) => {
+        const response = await vaultCredentialsAdd({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "vault_id": vaultId }, body });
+        return response.data;
+      },
+      /** vaultCredentialsDelete: /vaults/{vault_id}/credentials. Returns the API response body. */
+      credentialsDelete: async (vaultId, query, requestOptions = {}) => {
+        const response = await vaultCredentialsDelete({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "vault_id": vaultId }, query });
+        return response.data;
+      },
+      /** vaultCredentialsGet: /vaults/{vault_id}/credentials. Returns the API response body. */
+      credentialsGet: async (vaultId, query, requestOptions = {}) => {
+        const response = await vaultCredentialsGet({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "vault_id": vaultId }, query });
+        return response.data;
+      },
+      /** vaultCredentialsList: /vaults/{vault_id}. Returns the API response body. */
+      credentialsList: async (vaultId, requestOptions = {}) => {
+        const response = await vaultCredentialsList({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "vault_id": vaultId } });
+        return response.data;
+      },
+      /** vaultCreditCardDelete: /vaults/{vault_id}/card. Returns the API response body. */
+      creditCardDelete: async (vaultId, requestOptions = {}) => {
+        const response = await vaultCreditCardDelete({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "vault_id": vaultId } });
+        return response.data;
+      },
+      /** vaultCreditCardGet: /vaults/{vault_id}/card. Returns the API response body. */
+      creditCardGet: async (vaultId, requestOptions = {}) => {
+        const response = await vaultCreditCardGet({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "vault_id": vaultId } });
+        return response.data;
+      },
+      /** vaultCreditCardSet: /vaults/{vault_id}/card. Returns the API response body. */
+      creditCardSet: async (vaultId, body, requestOptions = {}) => {
+        const response = await vaultCreditCardSet({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "vault_id": vaultId }, body });
+        return response.data;
+      },
+      /** vaultDelete: /vaults/{vault_id}. Returns the API response body. */
+      delete: async (vaultId, requestOptions = {}) => {
+        const response = await vaultDelete({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "vault_id": vaultId } });
+        return response.data;
+      },
+      /** listVaults: /vaults. Returns the API response body. */
+      list: async (query = void 0, requestOptions = {}) => {
+        const response = await listVaults({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, query });
+        return response.data;
+      },
+      /** vaultUpdate: /vaults/{vault_id}. Returns the API response body. */
+      update: async (vaultId, body, requestOptions = {}) => {
+        const response = await vaultUpdate({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "vault_id": vaultId }, body });
+        return response.data;
+      }
+    },
+    personas: {
+      /** personaCreate: /personas/create. Returns the API response body. */
+      create: async (body, requestOptions = {}) => {
+        const response = await personaCreate({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, body });
+        return response.data;
+      },
+      /** personaDelete: /personas/{persona_id}. Returns the API response body. */
+      delete: async (personaId, requestOptions = {}) => {
+        const response = await personaDelete({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "persona_id": personaId } });
+        return response.data;
+      },
+      /** personaEmailsList: /personas/{persona_id}/emails. Returns the API response body. */
+      emailsList: async (personaId, query = void 0, requestOptions = {}) => {
+        const response = await personaEmailsList({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "persona_id": personaId }, query });
+        return response.data;
+      },
+      /** personaGet: /personas/{persona_id}. Returns the API response body. */
+      get: async (personaId, requestOptions = {}) => {
+        const response = await personaGet({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "persona_id": personaId } });
+        return response.data;
+      },
+      /** listPersonas: /personas. Returns the API response body. */
+      list: async (query = void 0, requestOptions = {}) => {
+        const response = await listPersonas({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, query });
+        return response.data;
+      },
+      /** personaSmsList: /personas/{persona_id}/sms. Returns the API response body. */
+      smsList: async (personaId, query = void 0, requestOptions = {}) => {
+        const response = await personaSmsList({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "persona_id": personaId }, query });
+        return response.data;
+      },
+      /** personaUpdate: /personas/{persona_id}. Returns the API response body. */
+      update: async (personaId, body, requestOptions = {}) => {
+        const response = await personaUpdate({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "persona_id": personaId }, body });
+        return response.data;
+      }
+    },
+    profiles: {
+      /** profileCookiesGet: /profiles/{profile_id}/cookies. Returns the API response body. */
+      cookiesGet: async (profileId, requestOptions = {}) => {
+        const response = await profileCookiesGet({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "profile_id": profileId } });
+        return response.data;
+      },
+      /** profileCookiesSet: /profiles/{profile_id}/cookies. Returns the API response body. */
+      cookiesSet: async (profileId, body, requestOptions = {}) => {
+        const response = await profileCookiesSet({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "profile_id": profileId }, body });
+        return response.data;
+      },
+      /** profileCreate: /profiles/create. Returns the API response body. */
+      create: async (body, requestOptions = {}) => {
+        const response = await profileCreate({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, body });
+        return response.data;
+      },
+      /** profileDelete: /profiles/{profile_id}. Returns the API response body. */
+      delete: async (profileId, requestOptions = {}) => {
+        const response = await profileDelete({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "profile_id": profileId } });
+        return response.data;
+      },
+      /** profileDuplicate: /profiles/{profile_id}/duplicate. Returns the API response body. */
+      duplicate: async (profileId, body, requestOptions = {}) => {
+        const response = await profileDuplicate({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "profile_id": profileId }, body });
+        return response.data;
+      },
+      /** profileGet: /profiles/{profile_id}. Returns the API response body. */
+      get: async (profileId, requestOptions = {}) => {
+        const response = await profileGet({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, path: { "profile_id": profileId } });
+        return response.data;
+      },
+      /** profileList: /profiles. Returns the API response body. */
+      list: async (query = void 0, requestOptions = {}) => {
+        const response = await profileList({ client: client2, throwOnError: true, signal: requestOptions.signal, headers: { ...requestOptions.headers }, query });
+        return response.data;
+      }
+    }
+  };
+}
+
+// src/session.ts
+var import_node_fs = require("fs");
+var import_promises3 = require("fs/promises");
+var import_node_path2 = require("path");
+var import_promises4 = require("timers/promises");
+
+// src/captcha.ts
+async function executeWithCaptcha(action, budgetSeconds, request) {
+  const explicit = action.type === "captcha_solve";
+  let deadline = explicit ? performance.now() + budgetSeconds * 1e3 : void 0;
+  let params = { captcha_timeout_seconds: budgetSeconds };
+  let requestAction = action;
+  let original;
+  let last;
+  const remaining = () => deadline === void 0 ? budgetSeconds : (deadline - performance.now()) / 1e3;
+  const pause = (ms = 1e3) => sleep(Math.max(0, Math.min(ms, remaining() * 1e3)));
+  const failure = (message, code) => ({
+    started_at: (/* @__PURE__ */ new Date()).toISOString(),
+    ended_at: (/* @__PURE__ */ new Date()).toISOString(),
+    ...original ?? last,
+    action,
+    success: false,
+    message,
+    code,
+    exception: message,
+    exception_detail: null,
+    captcha: last?.captcha
+  });
+  while (true) {
+    const left = remaining();
+    if (left <= 0) return failure("CAPTCHA wait deadline exceeded", "captcha_timeout");
+    params.captcha_timeout_seconds = left;
+    const polling = requestAction.type === "captcha_solve";
+    let result;
+    try {
+      result = await request(requestAction, { ...params }, polling ? Math.min(1e4, left * 1e3) : void 0);
+    } catch (error) {
+      const transport = error instanceof NotteTimeoutError || error instanceof TypeError || error instanceof SyntaxError;
+      const transient = params.captcha_id !== void 0 && error instanceof NotteAPIError && [408, 429, 502, 503, 504].includes(error.statusCode);
+      if (!polling || params.captcha_id === void 0 || !transport && !transient) throw error;
+      await pause();
+      continue;
+    }
+    last = result;
+    const status = result.captcha;
+    if (!status) {
+      return params.captcha_id ? failure("Server omitted CAPTCHA polling status", "captcha_protocol_error") : result;
+    }
+    if (params.captcha_id && status.captcha_id !== params.captcha_id) {
+      return failure("Server returned a different CAPTCHA solve", "captcha_protocol_error");
+    }
+    deadline ??= performance.now() + budgetSeconds * 1e3;
+    if (!original && !explicit && result.action_executed === true) original = result;
+    if (status.state === "cancelled" && status.cancel_reason === "navigation" && original) {
+      return { ...original, captcha: status };
+    }
+    if (status.state === "failed" || status.state === "cancelled") {
+      return failure(status.message || `CAPTCHA ${status.state}`, `captcha_${status.state}`);
+    }
+    if (status.state === "solved") {
+      if (explicit) return result;
+      if (original) return { ...original, captcha: status };
+      if (!params.captcha_id && result.action_executed !== false) return result;
+      params = {
+        captcha_timeout_seconds: remaining(),
+        target_page_id: status.page_id,
+        target_generation: status.generation
+      };
+      requestAction = action;
+      continue;
+    }
+    if (!explicit && !original && !params.captcha_id && result.action_executed !== false) {
+      return failure("Server did not confirm whether the action executed", "captcha_execution_unknown");
+    }
+    params.captcha_id = status.captcha_id;
+    requestAction = { type: "captcha_solve" };
+    await pause(Math.min(1e3, Math.max(100, status.retry_after_ms ?? 1e3)));
+  }
 }
 
 // src/page-fetch.ts
@@ -2183,10 +2705,10 @@ function responseFromEvaluated(raw) {
 }
 
 // src/cookies.ts
-var import_promises = require("fs/promises");
+var import_promises2 = require("fs/promises");
 var import_node_path = require("path");
 async function readCookiesFile(cookieFile) {
-  const cookies = JSON.parse(await (0, import_promises.readFile)(cookieFile, "utf-8"));
+  const cookies = JSON.parse(await (0, import_promises2.readFile)(cookieFile, "utf-8"));
   if (!Array.isArray(cookies)) {
     throw new InvalidRequestError(`Cookie file ${cookieFile} must contain a JSON list of cookies`);
   }
@@ -2204,7 +2726,7 @@ async function createOrAppendCookiesToFile(cookieFile, cookies) {
       }
     }
     existing.push(...cookies);
-    await (0, import_promises.writeFile)(cookieFile, JSON.stringify(existing), "utf-8");
+    await (0, import_promises2.writeFile)(cookieFile, JSON.stringify(existing), "utf-8");
   });
 }
 var fileLocks = /* @__PURE__ */ new Map();
@@ -2328,7 +2850,6 @@ function openBrowser(url) {
 var SESSION_START_TRIES = 3;
 var CLUSTER_OVERLOAD_RETRY_DELAY_MS = 3e4;
 var CAPTCHA_SOLVE_TIMEOUT_MS = 1e5;
-var CAPTCHA_SOLVE_TRIES = 3;
 function observeServerOwnedDialog(_dialog) {
 }
 function installServerOwnedDialogPolicy(browser) {
@@ -2344,6 +2865,9 @@ var Session = class {
   defaultRaiseOnFailure;
   defaultPerceptionType;
   cookieFile;
+  cookiesLoaded = false;
+  cookieLoadPromise;
+  authenticationReady = false;
   fileStorage;
   sessionId = null;
   isActive = false;
@@ -2379,12 +2903,17 @@ var Session = class {
    * `CLUSTER_OVERLOAD_RETRY_DELAY_MS` on HTTP 529 (cluster overload). 4xx
    * errors are never retried.
    *
+   * Managed-auth sessions wait for readiness by default. Pass
+   * `{ wait_for_authentication: false }` for an explicit nonblocking start,
+   * then call `waitForAuth()` before executing actions or connecting over CDP.
+   * Cancellation during creation waits for its response so the new session can
+   * be closed. Cancellation or failure during the startup wait also closes it.
    * Prefer `session.use(async session => { ... })`, which also stops the session.
    * @example
    * const session = client.Session();
    * await session.start();
    */
-  async start() {
+  async start(options = {}) {
     if (this.legacyHeadless === false) {
       throw new Error(
         "Remote `headless: false` is no longer supported. `headless: true` sessions still include session replays and access to the live viewer."
@@ -2397,11 +2926,19 @@ var Session = class {
     if (this.isActive) {
       throw new Error("Session is already active");
     }
-    const body = this.options;
+    options.signal?.throwIfAborted();
+    validateAuthRetry(this.options.auth_retry ?? 0);
+    const { auth_retry, wait_for_authentication, ...request } = this.options;
+    const body = {
+      ...request,
+      ...request.auth_ids?.length ? { auth_retry: auth_retry ?? 0, wait_for_authentication: false } : {}
+    };
+    const shouldWait = options.wait_for_authentication ?? wait_for_authentication ?? true;
     let tries = SESSION_START_TRIES;
     const origTries = tries;
     let sessionData;
     while (tries > 0) {
+      options.signal?.throwIfAborted();
       tries -= 1;
       try {
         const response = await sessionStart({ client: this.client.getClient(), body, throwOnError: true });
@@ -2416,7 +2953,16 @@ var Session = class {
           console.warn(
             `Failed to start session due to cluster overload, retrying in ${CLUSTER_OVERLOAD_RETRY_DELAY_MS / 1e3} seconds (${retryStr})...`
           );
-          await sleep(CLUSTER_OVERLOAD_RETRY_DELAY_MS);
+          if (options.signal) {
+            try {
+              await (0, import_promises4.setTimeout)(CLUSTER_OVERLOAD_RETRY_DELAY_MS, void 0, { signal: options.signal });
+            } catch (error2) {
+              options.signal.throwIfAborted();
+              throw error2;
+            }
+          } else {
+            await sleep(CLUSTER_OVERLOAD_RETRY_DELAY_MS);
+          }
         } else {
           console.warn(`Failed to start session: retrying (${retryStr})`);
         }
@@ -2428,19 +2974,17 @@ var Session = class {
     this.sessionId = sessionData.session_id;
     this.isActive = true;
     this.response = sessionData;
+    this.cookiesLoaded = false;
+    this.cookieLoadPromise = void 0;
+    this.authenticationReady = false;
     this.fileStorage = this.fileStorage?.forSession(sessionData.session_id);
     try {
+      options.signal?.throwIfAborted();
+      if (shouldWait) await this.waitForAuth(options);
       if (this.openViewer) {
         this.openViewerInBrowser();
       }
-      if (this.cookieFile !== void 0) {
-        if ((0, import_node_fs.existsSync)(this.cookieFile)) {
-          console.info(`\u{1F36A} Automatically loading cookies from ${this.cookieFile}`);
-          await this.setCookiesFromFile(this.cookieFile);
-        } else {
-          console.warn(`\u{1F36A} Cookie file ${this.cookieFile} not found, skipping cookie loading`);
-        }
-      }
+      if (this.response?.status === "active") await this.loadInitialCookies();
     } catch (error) {
       try {
         await this.stop("error");
@@ -2450,6 +2994,65 @@ var Session = class {
       throw error;
     }
   }
+  /**
+   * Wait for this session to become usable without creating a session or submitting another login.
+   * A standalone wait leaves session ownership with the caller, including on timeout or cancellation.
+   */
+  async waitForAuth(options = {}) {
+    options.signal?.throwIfAborted();
+    if (!this.response) throw new Error("Session has not started");
+    if (this.response.status === "active") {
+      await this.loadInitialCookies();
+      return;
+    }
+    const sessionId = this.lastSessionId();
+    this.response = await pollAuth(async (signal) => {
+      const response = await sessionAuthReadiness({
+        client: this.client.getClient(),
+        path: { session_id: sessionId },
+        headers: { [TIMEOUT_HEADER]: "10000" },
+        signal,
+        throwOnError: true
+      });
+      let result = response.data;
+      if (result.status === "active") {
+        this.authenticationReady = true;
+        result = (await sessionStatus({
+          client: this.client.getClient(),
+          path: { session_id: sessionId },
+          headers: { [TIMEOUT_HEADER]: "10000" },
+          signal,
+          throwOnError: true
+        })).data;
+        this.authenticationReady = result.status === "active";
+        if (this.authenticationReady) return result;
+      }
+      if (result.status !== "authenticating") throw new ManagedAuthError(result.error || "Session authentication failed");
+      return void 0;
+    }, options);
+    await this.loadInitialCookies();
+  }
+  async loadInitialCookies() {
+    if (this.cookiesLoaded || this.cookieFile === void 0) return;
+    if (!this.cookieLoadPromise) {
+      const cookieFile = this.cookieFile;
+      this.cookieLoadPromise = (async () => {
+        if ((0, import_node_fs.existsSync)(cookieFile)) {
+          console.info(`\u{1F36A} Automatically loading cookies from ${cookieFile}`);
+          await this.setCookiesFromFile(cookieFile);
+        } else {
+          console.warn(`\u{1F36A} Cookie file ${cookieFile} not found, skipping cookie loading`);
+        }
+        this.cookiesLoaded = true;
+      })();
+    }
+    const pending = this.cookieLoadPromise;
+    try {
+      await pending;
+    } finally {
+      if (this.cookieLoadPromise === pending) this.cookieLoadPromise = void 0;
+    }
+  }
   /**
    * Stop the session and clean up resources (including any Playwright
    * connection opened with `page()`). When a `cookie_file` was given, the
@@ -2465,7 +3068,7 @@ var Session = class {
     }
     const sessionId = this.sessionId;
     await this.closePlaywright();
-    if (this.cookieFile !== void 0) {
+    if (this.cookieFile !== void 0 && (this.authenticationReady || this.response?.status === "active")) {
       try {
         const cookies = await this.getCookies();
         await createOrAppendCookiesToFile(this.cookieFile, cookies);
@@ -2644,7 +3247,7 @@ var Session = class {
       throw new Error(`Failed to download replay: HTTP ${response.status}`);
     }
     const target = (0, import_node_path2.resolve)(path);
-    await (0, import_promises2.writeFile)(target, new Uint8Array(await response.arrayBuffer()));
+    await (0, import_promises3.writeFile)(target, new Uint8Array(await response.arrayBuffer()));
     return target;
   }
   // #######################################################################
@@ -2826,32 +3429,22 @@ var Session = class {
   async execute(action, options = {}) {
     const sessionId = this.requireSessionId();
     const raiseOnFailure = typeof options === "boolean" ? options : options.raiseOnFailure ?? this.defaultRaiseOnFailure;
-    const isCaptcha = isCaptchaSolveAction(action);
-    let result;
-    let lastError;
-    for (let attempt = 0; attempt < CAPTCHA_SOLVE_TRIES; attempt += 1) {
-      try {
+    const result = await executeWithCaptcha(
+      action,
+      this.client.getConfig().captchaTimeoutSeconds ?? 180,
+      async (requestAction, params, timeoutMs) => {
+        const query = params;
         const response = await pageExecute({
           client: this.client.getClient(),
           path: { session_id: sessionId },
-          body: action,
-          headers: isCaptcha ? { [TIMEOUT_HEADER]: String(CAPTCHA_SOLVE_TIMEOUT_MS) } : void 0,
+          body: requestAction,
+          query,
+          headers: timeoutMs === void 0 ? void 0 : { [TIMEOUT_HEADER]: String(timeoutMs) },
           throwOnError: true
         });
-        result = response.data;
-        break;
-      } catch (error) {
-        if (isCaptcha && error instanceof NotteAPIError && error.statusCode === 408) {
-          lastError = error;
-          console.warn("Solve captcha action timed out. This can happen for long and complex captchas. Retrying...");
-          continue;
-        }
-        throw error;
+        return response.data;
       }
-    }
-    if (!result) {
-      throw lastError ?? new Error(`Failed to execute action '${action.type}'. This should not happen. Please report this issue.`);
-    }
+    );
     if (raiseOnFailure && !result.success) {
       console.error(`\u{1F6A8} Execution failed with message: '${result.message}'`);
       if (result.exception_detail) {
@@ -2945,7 +3538,10 @@ var Session = class {
    * Context manager pattern: start the session, run the callback and stop the
    * session, with close reason `error` when the callback throws.
    *
-   * @param callback - Async work to perform with the started session.
+   * Always waits for Managed Auth readiness before invoking the callback.
+   *
+   * @param callback - Async work to perform with the ready session.
+   * @param options - Controls the Managed Auth readiness wait, including timeout and cancellation.
    * @returns The callback's return value after session cleanup has been attempted.
    * @throws Error if startup fails, the callback throws, or cleanup fails after a successful callback.
    * @example
@@ -2953,8 +3549,8 @@ var Session = class {
    *   await session.execute({ type: 'goto', url: 'https://www.notte.cc' });
    * });
    */
-  async use(callback) {
-    await this.start();
+  async use(callback, options = {}) {
+    await this.start({ ...options, wait_for_authentication: true });
     let callbackFailed = false;
     try {
       return await callback(this);
@@ -3992,7 +4588,7 @@ var NottePersona = class {
 };
 
 // src/functions.ts
-var import_promises3 = require("fs/promises");
+var import_promises5 = require("fs/promises");
 var import_node_path3 = require("path");
 
 // src/encryption.ts
@@ -4475,7 +5071,7 @@ var NotteFunction = class {
     }
     const code = await response.text();
     if (path !== void 0) {
-      await (0, import_promises3.writeFile)(path, code, "utf8");
+      await (0, import_promises5.writeFile)(path, code, "utf8");
     }
     return code;
   }
@@ -4513,7 +5109,7 @@ async function readPythonFile(path) {
   assertPythonPath(path);
   let bytes;
   try {
-    bytes = await (0, import_promises3.readFile)(path);
+    bytes = await (0, import_promises5.readFile)(path);
   } catch (error) {
     throw new InvalidRequestError(
       `The file '${path}' could not be read: ${error instanceof Error ? error.message : String(error)}`
@@ -4630,11 +5226,11 @@ async function readFunctionStream(body, onLog, path, signal) {
 
 // src/files.ts
 var import_node_fs2 = require("fs");
-var import_promises4 = require("fs/promises");
+var import_promises6 = require("fs/promises");
 var import_node_path4 = require("path");
 var import_node_crypto2 = require("crypto");
 var import_node_stream = require("stream");
-var import_promises5 = require("stream/promises");
+var import_promises7 = require("stream/promises");
 var FileNotFoundError = class extends NotteError {
 };
 var FileExistsError = class extends NotteError {
@@ -4834,11 +5430,11 @@ var RemoteFileStorage = class _RemoteFileStorage {
   async upload(file, uploadFileName) {
     const files = this.files();
     if (typeof file === "string") {
-      const info = await (0, import_promises4.stat)(file).catch(() => null);
+      const info = await (0, import_promises6.stat)(file).catch(() => null);
       if (!info?.isFile()) {
         throw new InvalidRequestError(`Cannot upload file ${file}: it is not a file`);
       }
-      const bytes = await (0, import_promises4.readFile)(file);
+      const bytes = await (0, import_promises6.readFile)(file);
       return files.upload(bytes, uploadFileName ?? (0, import_node_path4.basename)(file));
     }
     const filename = uploadFileName ?? (file instanceof File ? file.name : "file");
@@ -4890,10 +5486,10 @@ var RemoteFileStorage = class _RemoteFileStorage {
     if (safeName === "" || safeName === "." || safeName === "..") {
       throw new NotteError(`Unsafe filename returned for file ${fileId}: ${JSON.stringify(metadata.filename)}`);
     }
-    await (0, import_promises4.mkdir)(localDir, { recursive: true });
+    await (0, import_promises6.mkdir)(localDir, { recursive: true });
     const destination = (0, import_node_path4.join)(localDir, safeName);
     if (!options.force) {
-      const exists = await (0, import_promises4.stat)(destination).then(() => true, () => false);
+      const exists = await (0, import_promises6.stat)(destination).then(() => true, () => false);
       if (exists) {
         throw new FileExistsError(`${destination} already exists; pass force: true to overwrite it`);
       }
@@ -4901,25 +5497,25 @@ var RemoteFileStorage = class _RemoteFileStorage {
     const body = await files.stream(fileId);
     const temporary = (0, import_node_path4.join)(localDir, `.${safeName}.${(0, import_node_crypto2.randomBytes)(8).toString("hex")}.part`);
     try {
-      await (0, import_promises5.pipeline)(
+      await (0, import_promises7.pipeline)(
         import_node_stream.Readable.fromWeb(body),
         (0, import_node_fs2.createWriteStream)(temporary, { flags: "wx" })
       );
       if (options.force) {
-        await (0, import_promises4.rename)(temporary, destination);
+        await (0, import_promises6.rename)(temporary, destination);
       } else {
         try {
-          await (0, import_promises4.link)(temporary, destination);
+          await (0, import_promises6.link)(temporary, destination);
         } catch (error) {
           if (error.code === "EEXIST") {
             throw new FileExistsError(`${destination} already exists; pass force: true to overwrite it`);
           }
           throw error;
         }
-        await (0, import_promises4.rm)(temporary, { force: true });
+        await (0, import_promises6.rm)(temporary, { force: true });
       }
     } catch (error) {
-      await (0, import_promises4.rm)(temporary, { force: true });
+      await (0, import_promises6.rm)(temporary, { force: true });
       throw error;
     }
     return destination;
@@ -5079,11 +5675,16 @@ function isRelativeProxyUrl(baseUrl) {
 var NotteClient3 = class {
   config;
   client = createClient();
+  resources = createResources(this.client, () => this.config.apiKey ?? "");
   constructor(config = {}) {
     const apiKey = config.apiKey || process.env.NOTTE_API_KEY;
     const baseUrl = config.baseUrl || process.env.NOTTE_API_URL || DEFAULT_NOTTE_API_URL;
     const dbPreview = config.dbPreview || process.env[DB_PREVIEW_ENV] || void 0;
     const timeoutMs = config.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    const captchaTimeoutSeconds = config.captchaTimeoutSeconds ?? 180;
+    if (!Number.isFinite(captchaTimeoutSeconds) || captchaTimeoutSeconds <= 0) {
+      throw new InvalidRequestError("captchaTimeoutSeconds must be positive and finite");
+    }
     if (!(timeoutMs >= 0)) {
       throw new InvalidRequestError("timeoutMs must be a non-negative number");
     }
@@ -5102,7 +5703,7 @@ var NotteClient3 = class {
         "NOTTE_API_KEY needs to be provided. Pass config.apiKey or set the NOTTE_API_KEY environment variable."
       );
     }
-    this.config = { baseUrl, apiKey, timeoutMs, dbPreview, verbose: config.verbose ?? false };
+    this.config = { baseUrl, apiKey, timeoutMs, captchaTimeoutSeconds, dbPreview, verbose: config.verbose ?? false };
     if (baseUrl !== DEFAULT_NOTTE_API_URL && !isProxyMode) {
       console.warn(`NOTTE_API_URL is set to: ${baseUrl}`);
     }
@@ -5317,36 +5918,40 @@ var NotteClient3 = class {
   Function(options) {
     return this.NotteFunction(options);
   }
-  /** Sessions listing, the counterpart of `client.sessions.list()`. */
+  /** Client-bound session API operations. `list()` retains its array return value. */
   get sessions() {
     return {
+      ...this.resources.sessions,
       list: async (options = {}) => {
         const response = await listSessions({ client: this.getClient(), query: options });
         return response.data?.items ?? [];
       }
     };
   }
-  /** Agents listing, the counterpart of `client.agents.list()`. */
+  /** Client-bound agent API operations. `list()` retains its array return value. */
   get agents() {
     return {
+      ...this.resources.agents,
       list: async (options = {}) => {
         const response = await listAgents({ client: this.getClient(), query: options });
         return response.data?.items ?? [];
       }
     };
   }
-  /** Vaults listing, the counterpart of `client.vaults.list()`. */
+  /** Client-bound vault API operations. `list()` retains its array return value. */
   get vaults() {
     return {
+      ...this.resources.vaults,
       list: async (options = {}) => {
         const response = await listVaults({ client: this.getClient(), query: options });
         return response.data?.items ?? [];
       }
     };
   }
-  /** Functions listing, the counterpart of `client.functions.list()`. */
+  /** Client-bound function API operations. `list()` retains its array return value. */
   get functions() {
     return {
+      ...this.resources.functions,
       list: async (options = {}) => {
         const response = await listFunctions({ client: this.getClient(), query: options });
         return response.data?.items ?? [];
@@ -5369,6 +5974,10 @@ var NotteClient3 = class {
   get secrets() {
     return new NotteSecrets(this);
   }
+  /** Managed authentication: verify connections, request login, and wait for readiness. */
+  get managedAuth() {
+    return new NotteManagedAuth(this);
+  }
   /** Usage and billing (`/usage`, `/usage/logs`). */
   get usage() {
     return new NotteUsage(this);
@@ -5378,6 +5987,7 @@ var NotteClient3 = class {
    */
   get personas() {
     return {
+      ...this.resources.personas,
       list: async (options) => {
         const response = await listPersonas({
           client: this.getClient(),
@@ -5393,6 +6003,10 @@ var NotteClient3 = class {
   getClient() {
     return this.client;
   }
+  /** Client-bound profile API operations, generated from OpenAPI. */
+  get profiles() {
+    return this.resources.profiles;
+  }
   async scrape(url, options = {}) {
     const body = await buildScrapeBody(options);
     const response = await scrapeWebpage({
@@ -5466,6 +6080,72 @@ function withTimeout(signal, timeoutMs) {
   return { signal: composite, release };
 }
 
+// src/actions.ts
+function builder(type) {
+  return (...[input]) => ({ ...input ?? {}, type });
+}
+var goto = builder("goto");
+var gotoNewTab = builder("goto_new_tab");
+var closeTab = builder("close_tab");
+var switchTab = builder("switch_tab");
+var goBack = builder("go_back");
+var goForward = builder("go_forward");
+var reload = builder("reload");
+var wait = builder("wait");
+var pressKey = builder("press_key");
+var scrollUp = builder("scroll_up");
+var scrollDown = builder("scroll_down");
+var captchaSolve = builder("captcha_solve");
+var help = builder("help");
+var completion = builder("completion");
+var scrape = builder("scrape");
+var emailRead = builder("email_read");
+var emailVerificationRead = builder("email_verification_read");
+var smsRead = builder("sms_read");
+var evaluateJs = builder("evaluate_js");
+var formFill = builder("form_fill");
+var click = builder("click");
+var fill = builder("fill");
+var multiFactorFill = builder("multi_factor_fill");
+var fallbackFill = builder("fallback_fill");
+var check = builder("check");
+var selectDropdownOption = builder("select_dropdown_option");
+var uploadFile = builder("upload_file");
+var downloadFile = builder("download_file");
+var actions = {
+  goto,
+  gotoNewTab,
+  closeTab,
+  switchTab,
+  goBack,
+  goForward,
+  reload,
+  wait,
+  pressKey,
+  scrollUp,
+  scrollDown,
+  captchaSolve,
+  help,
+  completion,
+  scrape,
+  emailRead,
+  emailVerificationRead,
+  smsRead,
+  evaluateJs,
+  formFill,
+  click,
+  fill,
+  multiFactorFill,
+  fallbackFill,
+  check,
+  selectDropdownOption,
+  uploadFile,
+  downloadFile
+};
+function isCaptchaSolveAction(action) {
+  return action.type === "captcha_solve";
+}
+
 // src/proxy/types.ts
 var NotteProxyAuthError = class extends Error {
   constructor(message = "Unauthorized") {
@@ -5507,12 +6187,14 @@ var createClient2 = (config) => {
   FileExistsError,
   FileNotFoundError,
   InvalidRequestError,
+  ManagedAuthError,
   NotteAPIError,
   NotteAPIExecutionError,
   NotteAnything,
   NotteClient,
   NotteError,
   NotteFunction,
+  NotteManagedAuth,
   NottePersona,
   NotteProxyAuthError,
   NotteSecrets,
@@ -5542,10 +6224,13 @@ var createClient2 = (config) => {
   connectLinkMailboxes,
   connectLinkStatus,
   connectLinkSubmit,
+  connectPaymentWallet,
   createClient,
   createOrAppendCookiesToFile,
+  createPayment,
   deleteSecret,
   deleteSessionFile,
+  disconnectPaymentWallet,
   downloadSessionFile,
   functionCreate,
   functionDelete,
@@ -5561,6 +6246,7 @@ var createClient2 = (config) => {
   functionScheduleDelete,
   functionScheduleSet,
   functionUpdate,
+  getPayment,
   getRootDomain,
   getScript,
   getSecret,
@@ -5617,11 +6303,13 @@ var createClient2 = (config) => {
   scrapeFromHtml,
   scrapeWebpage,
   searchWeb,
+  sessionAuthReadiness,
   sessionCookiesGet,
   sessionCookiesSet,
   sessionDebugInfo,
   sessionNetworkLogs,
   sessionOffset,
+  sessionProfilePreview,
   sessionReplay,
   sessionStart,
   sessionStatus,