agentmail 0.5.33 → 0.5.35

package/dist/cjs/BaseClient.js

@@ -43,8 +43,8 @@ function normalizeClientOptions(options) {
     const headers = (0, headers_js_1.mergeHeaders)({
         "X-Fern-Language": "JavaScript",
         "X-Fern-SDK-Name": "agentmail",
-        "X-Fern-SDK-Version": "0.5.33",
-        "User-Agent": "agentmail/0.5.33",
+        "X-Fern-SDK-Version": "0.5.35",
+        "User-Agent": "agentmail/0.5.35",
         "X-Fern-Runtime": core.RUNTIME.type,
         "X-Fern-Runtime-Version": core.RUNTIME.version,
     }, options === null || options === void 0 ? void 0 : options.headers);

package/dist/cjs/api/resources/apiKeys/client/Client.d.ts

@@ -64,8 +64,8 @@ export declare class ApiKeysClient {
     private __create;
     /**
      * Renames a credential or changes its permissions. Public keys also resolve
-     * by `client_id`; a sign-in key accepts only `provider_connect` and
-     * `provider_share_owner`.
+     * by `client_id`; a sign-in key accepts only `app_connect` and
+     * `app_share_owner`.
      *
      * @param {AgentMail.ApiKeyId} api_key_id
      * @param {AgentMail.UpdateApiKeyRequest} request

package/dist/cjs/api/resources/apiKeys/client/Client.js

@@ -278,8 +278,8 @@ class ApiKeysClient {
     }
     /**
      * Renames a credential or changes its permissions. Public keys also resolve
-     * by `client_id`; a sign-in key accepts only `provider_connect` and
-     * `provider_share_owner`.
+     * by `client_id`; a sign-in key accepts only `app_connect` and
+     * `app_share_owner`.
      *
      * @param {AgentMail.ApiKeyId} api_key_id
      * @param {AgentMail.UpdateApiKeyRequest} request

package/dist/cjs/api/resources/apiKeys/types/AcceptDisclosure.d.ts

@@ -1,6 +1,6 @@
 /**
  * Accept the app's disclosure on the agent's behalf, skipping the
- * first-use disclosure page. Requires `provider_share_owner` when owner
+ * first-use disclosure page. Requires `app_share_owner` when owner
  * scopes are involved.
  */
 export type AcceptDisclosure = boolean;

package/dist/cjs/api/resources/apiKeys/types/ApiKeyPermissions.d.ts

@@ -71,17 +71,17 @@ export interface ApiKeyPermissions {
     /** Delete API keys. */
     apiKeyDelete?: boolean;
     /**
-     * Sign in to providers as an inbox: connect a provider, authorize an inbox, and mint the
+     * Sign in to apps as an inbox: connect an app, authorize an inbox, and mint the
      * sign-in keys. Omitted on a new bearer key means false, whatever else the key holds.
      */
-    providerConnect?: boolean;
+    appConnect?: boolean;
     /**
-     * Share the organization owner's name and email with providers at sign-in. One permission
+     * Share the organization owner's name and email with apps at sign-in. One permission
      * for both values.
      */
-    providerShareOwner?: boolean;
+    appShareOwner?: boolean;
     /**
-     * Update accounts: disable or re-enable an inbox's sign-in at a provider. Reading accounts
+     * Update accounts: disable or re-enable an inbox's sign-in at an app. Reading accounts
      * needs only `inbox_read`.
      */
     accountUpdate?: boolean;

package/dist/cjs/api/resources/apiKeys/types/PublicKeyCredential.d.ts

@@ -3,8 +3,8 @@ import type * as AgentMail from "../../../index.js";
  * An AgentID sign-in credential, scoped like a bearer key; `api_key_id` is
  * the JWS `kid`. A sign-in key carries `status`, gains `public_key` once
  * the client has proved it, expires 30 days after
- * activation, and carries exactly `provider_connect` and
- * `provider_share_owner`, snapshotted from the bearer key that created it
+ * activation, and carries exactly `app_connect` and
+ * `app_share_owner`, snapshotted from the bearer key that created it
  * and enforced from the key itself.
  */
 export interface PublicKeyCredential {

package/dist/cjs/serialization/resources/apiKeys/types/ApiKeyPermissions.d.ts

@@ -38,8 +38,8 @@ export declare namespace ApiKeyPermissions {
         api_key_create?: boolean | null;
         api_key_update?: boolean | null;
         api_key_delete?: boolean | null;
-        provider_connect?: boolean | null;
-        provider_share_owner?: boolean | null;
+        app_connect?: boolean | null;
+        app_share_owner?: boolean | null;
         account_update?: boolean | null;
         pod_read?: boolean | null;
         pod_create?: boolean | null;

package/dist/cjs/serialization/resources/apiKeys/types/ApiKeyPermissions.js

@@ -71,8 +71,8 @@ exports.ApiKeyPermissions = core.serialization.object({
     apiKeyCreate: core.serialization.property("api_key_create", core.serialization.boolean().optional()),
     apiKeyUpdate: core.serialization.property("api_key_update", core.serialization.boolean().optional()),
     apiKeyDelete: core.serialization.property("api_key_delete", core.serialization.boolean().optional()),
-    providerConnect: core.serialization.property("provider_connect", core.serialization.boolean().optional()),
-    providerShareOwner: core.serialization.property("provider_share_owner", core.serialization.boolean().optional()),
+    appConnect: core.serialization.property("app_connect", core.serialization.boolean().optional()),
+    appShareOwner: core.serialization.property("app_share_owner", core.serialization.boolean().optional()),
     accountUpdate: core.serialization.property("account_update", core.serialization.boolean().optional()),
     podRead: core.serialization.property("pod_read", core.serialization.boolean().optional()),
     podCreate: core.serialization.property("pod_create", core.serialization.boolean().optional()),

package/dist/cjs/version.d.ts

@@ -1 +1 @@
-export declare const SDK_VERSION = "0.5.33";
+export declare const SDK_VERSION = "0.5.35";

package/dist/cjs/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SDK_VERSION = void 0;
-exports.SDK_VERSION = "0.5.33";
+exports.SDK_VERSION = "0.5.35";

package/dist/cjs/wrapper/WebsocketsClient.d.ts

@@ -1,10 +1,24 @@
 import { WebsocketsClient as FernWebsocketsClient } from "../api/resources/websockets/client/Client.js";
 import type { WebsocketsSocket } from "../api/resources/websockets/client/Socket.js";
+import { type ReconnectPolicy } from "./reconnect.js";
 export type GetPaymentCredentials = (wsUrl: string) => Promise<Record<string, string>>;
 export declare class WebsocketsClient extends FernWebsocketsClient {
     private readonly _getPaymentCredentials;
-    constructor(options: FernWebsocketsClient.Options, getPaymentCredentials?: GetPaymentCredentials);
+    private readonly _reconnectPolicy;
+    constructor(options: FernWebsocketsClient.Options, getPaymentCredentials?: GetPaymentCredentials, reconnectPolicy?: ReconnectPolicy);
     connect(args?: FernWebsocketsClient.ConnectArgs & {
+        /** Resolve only once the connection is open. Defaults to true. */
         waitForOpen?: boolean;
+        /**
+         * Keep the socket connected and subscribed. Whenever the connection drops, reconnect with
+         * exponential backoff (full jitter, 1 s doubling up to 60 s) and re-send every subscription
+         * sent through `sendSubscribe` on the new connection; `reconnectAttempts` then only bounds
+         * the generated socket's own quick retries, not the total. Stops on `close()`, on
+         * `abortSignal`, or when the server refuses the handshake with 401, 402 or 403, which is
+         * reported to the `error` handler. x402/MPP sockets reuse the payment credential minted by
+         * this call on every reconnect. Defaults to true. `false` (or `reconnectAttempts: 0`) keeps
+         * only the generated socket's own limited retries and does not re-subscribe.
+         */
+        autoReconnect?: boolean;
     }): Promise<WebsocketsSocket>;
 }

package/dist/cjs/wrapper/WebsocketsClient.js

@@ -57,31 +57,49 @@ exports.WebsocketsClient = void 0;
 const Client_js_1 = require("../api/resources/websockets/client/Client.js");
 const core = __importStar(require("../core/index.js"));
 const environments = __importStar(require("../environments.js"));
+const version_js_1 = require("../version.js");
+const reconnect_js_1 = require("./reconnect.js");
+// The generated client's default. Always passed explicitly: auto-reconnect has to know the generated
+// socket's exact retry budget to take over before it runs out.
+const DEFAULT_RECONNECT_ATTEMPTS = 30;
+// Lets the server tell SDK releases apart on the handshake (Node only; browsers cannot set handshake
+// headers). Caller-supplied headers win.
+const SDK_HEADERS = { "X-Fern-SDK-Name": "agentmail", "X-Fern-SDK-Version": version_js_1.SDK_VERSION };
 class WebsocketsClient extends Client_js_1.WebsocketsClient {
-    constructor(options, getPaymentCredentials) {
+    constructor(options, getPaymentCredentials, reconnectPolicy = reconnect_js_1.DEFAULT_RECONNECT_POLICY) {
         super(options);
         this._getPaymentCredentials = getPaymentCredentials;
+        this._reconnectPolicy = reconnectPolicy;
     }
     connect() {
         const _super = Object.create(null, {
             connect: { get: () => super.connect }
         });
         return __awaiter(this, arguments, void 0, function* (args = {}) {
-            var _a, _b, _c;
-            const { waitForOpen = true } = args, rest = __rest(args, ["waitForOpen"]);
-            let connectArgs = rest;
+            var _a, _b, _c, _d;
+            const { waitForOpen = true, autoReconnect = true } = args, rest = __rest(args, ["waitForOpen", "autoReconnect"]);
+            const reconnectAttempts = (_a = rest.reconnectAttempts) !== null && _a !== void 0 ? _a : DEFAULT_RECONNECT_ATTEMPTS;
+            let connectArgs = Object.assign(Object.assign({}, rest), { reconnectAttempts, headers: Object.assign(Object.assign({}, SDK_HEADERS), rest.headers) });
             if (this._getPaymentCredentials) {
-                const wsUrl = core.url.join((_a = (yield core.Supplier.get(this._options.baseUrl))) !== null && _a !== void 0 ? _a : ((_b = (yield core.Supplier.get(this._options.environment))) !== null && _b !== void 0 ? _b : environments.AgentMailEnvironment.Prod).websockets, "/v0");
+                const wsUrl = core.url.join((_b = (yield core.Supplier.get(this._options.baseUrl))) !== null && _b !== void 0 ? _b : ((_c = (yield core.Supplier.get(this._options.environment))) !== null && _c !== void 0 ? _c : environments.AgentMailEnvironment.Prod)
+                    .websockets, "/v0");
                 const credentials = yield this._getPaymentCredentials(wsUrl);
-                connectArgs = Object.assign(Object.assign({}, rest), { queryParams: Object.assign(Object.assign({}, credentials), rest.queryParams) });
+                connectArgs = Object.assign(Object.assign({}, connectArgs), { queryParams: Object.assign(Object.assign({}, credentials), rest.queryParams) });
             }
             else if (!rest.apiKey) {
-                const apiKey = (_c = (yield core.Supplier.get(this._options.apiKey))) !== null && _c !== void 0 ? _c : process.env.AGENTMAIL_API_KEY;
-                connectArgs = Object.assign(Object.assign({}, rest), { apiKey });
+                const apiKey = (_d = (yield core.Supplier.get(this._options.apiKey))) !== null && _d !== void 0 ? _d : process.env.AGENTMAIL_API_KEY;
+                connectArgs = Object.assign(Object.assign({}, connectArgs), { apiKey });
             }
             const socket = yield _super.connect.call(this, connectArgs);
             if (waitForOpen)
                 yield socket.waitForOpen();
+            if (autoReconnect && reconnectAttempts > 0) {
+                (0, reconnect_js_1.enableAutoReconnect)(socket, {
+                    maxRetries: reconnectAttempts,
+                    abortSignal: rest.abortSignal,
+                    policy: this._reconnectPolicy,
+                });
+            }
             return socket;
         });
     }

package/dist/cjs/wrapper/reconnect.d.ts

@@ -0,0 +1,22 @@
+import type { WebsocketsSocket } from "../api/resources/websockets/client/Socket.js";
+export interface ReconnectPolicy {
+    baseDelayMs: number;
+    maxDelayMs: number;
+    /** How long a connection must stay open before the backoff starts over. */
+    stableAfterMs: number;
+}
+export declare const DEFAULT_RECONNECT_POLICY: ReconnectPolicy;
+/** Exponential backoff with full jitter: uniform in [0, min(maxDelayMs, baseDelayMs * 2^attempt)). */
+export declare function backoffDelay(attempt: number, policy: ReconnectPolicy, random?: () => number): number;
+export interface AutoReconnectOptions {
+    /** The generated socket's own retry budget (`reconnectAttempts`). */
+    maxRetries: number;
+    abortSignal?: AbortSignal;
+    policy: ReconnectPolicy;
+}
+/**
+ * Keeps `socket` connected and subscribed: re-sends every subscription on each reconnect, takes over
+ * reconnecting whenever the generated socket gives up, and stops on close(), abort, or a terminal
+ * handshake refusal.
+ */
+export declare function enableAutoReconnect(socket: WebsocketsSocket, options: AutoReconnectOptions): void;

package/dist/cjs/wrapper/reconnect.js

@@ -0,0 +1,246 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_RECONNECT_POLICY = void 0;
+exports.backoffDelay = backoffDelay;
+exports.enableAutoReconnect = enableAutoReconnect;
+const index_js_1 = require("../core/index.js");
+const Events = __importStar(require("../core/websocket/events.js"));
+exports.DEFAULT_RECONNECT_POLICY = { baseDelayMs: 1000, maxDelayMs: 60000, stableAfterMs: 5000 };
+/** Exponential backoff with full jitter: uniform in [0, min(maxDelayMs, baseDelayMs * 2^attempt)). */
+function backoffDelay(attempt, policy, random = Math.random) {
+    return random() * Math.min(policy.maxDelayMs, policy.baseDelayMs * Math.pow(2, attempt));
+}
+const { OPEN, CLOSING, CLOSED } = index_js_1.ReconnectingWebSocket.ReadyState;
+// ws reports a refused handshake as "Unexpected server response: <status>". Browsers expose no status,
+// so there every refusal looks transient and is retried on the capped backoff.
+const HANDSHAKE_STATUS = /^Unexpected server response: (\d{3})\b/;
+// Refusals that retrying with the same credentials cannot fix. 402 comes from the x402/MPP proxies,
+// whose payment credential is minted once per connect() call and reused on reconnects. The server
+// also answers 403 when the organization is at its connection cap, which a retry could outlast.
+const TERMINAL_FAILURES = new Map([
+    ["401", "WebSocket authentication failed (401): the API key is missing, invalid, or was deleted."],
+    [
+        "402",
+        "WebSocket payment required (402): the payment credential minted by connect() is no longer accepted; open a new socket with client.websockets.connect() to pay again.",
+    ],
+    [
+        "403",
+        "WebSocket authentication failed (403): the API key is invalid or was deleted, or the organization is at its WebSocket connection limit.",
+    ],
+]);
+/**
+ * Keeps `socket` connected and subscribed: re-sends every subscription on each reconnect, takes over
+ * reconnecting whenever the generated socket gives up, and stops on close(), abort, or a terminal
+ * handshake refusal.
+ */
+function enableAutoReconnect(socket, options) {
+    const { maxRetries, abortSignal, policy } = options;
+    const rws = socket.socket;
+    const sendSubscribe = socket.sendSubscribe.bind(socket);
+    const closeSocket = rws.close.bind(rws);
+    const reconnectSocket = rws.reconnect.bind(rws);
+    // Keyed by canonical JSON, in the order last sent. The server keeps one subscription per target and
+    // the last filter sent for it, so a new message takes its targets out of every earlier one: a
+    // replay can never put back a filter the caller has since changed.
+    const subscriptions = new Map();
+    // Keys already sent on the current connection, e.g. by the user's own open handler.
+    const sentOnConnection = new Set();
+    let opened = rws.readyState === OPEN;
+    let openedAt = opened ? Date.now() : undefined;
+    let stopped = false;
+    let attempt = 0;
+    let timer;
+    let emitting = false;
+    const isStopped = () => stopped || (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) === true;
+    const cancelTimer = () => {
+        clearTimeout(timer);
+        timer = undefined;
+    };
+    const stop = () => {
+        stopped = true;
+        cancelTimer();
+    };
+    const emitError = (message) => {
+        var _a;
+        const event = new Events.ErrorEvent(new Error(message), rws);
+        emitting = true;
+        try {
+            (_a = rws.onerror) === null || _a === void 0 ? void 0 : _a.call(rws, event);
+            rws.dispatchEvent(event);
+        }
+        finally {
+            emitting = false;
+        }
+    };
+    const scheduleReconnect = () => {
+        cancelTimer();
+        timer = setTimeout(() => {
+            timer = undefined;
+            if (isStopped())
+                return;
+            // reconnect() on a socket that is not CLOSED closes it with 1000 and then never connects.
+            if (rws.readyState === CLOSED)
+                reconnectSocket();
+            else if (rws.readyState === CLOSING)
+                scheduleReconnect();
+        }, backoffDelay(attempt++, policy));
+    };
+    rws.addEventListener("open", () => {
+        cancelTimer();
+        openedAt = Date.now();
+        if (!opened) {
+            opened = true;
+            return;
+        }
+        for (const [key, message] of subscriptions) {
+            if (isStopped() || rws.readyState !== OPEN)
+                return;
+            if (sentOnConnection.has(key))
+                continue;
+            try {
+                sendSubscribe(message);
+                sentOnConnection.add(key);
+            }
+            catch (error) {
+                emitError(`Failed to re-subscribe after reconnecting: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    });
+    rws.addEventListener("close", (event) => {
+        sentOnConnection.clear();
+        if (openedAt !== undefined && Date.now() - openedAt >= policy.stableAfterMs)
+            attempt = 0;
+        openedAt = undefined;
+        if (isStopped())
+            return;
+        if (event.code !== 1000) {
+            // The generated socket retries these closes itself, up to maxRetries times.
+            if (rws.retryCount < maxRetries)
+                return;
+            // It has just scheduled its last retry. If that one fails too, it keeps its connect lock
+            // and ignores reconnect() for good, so cancel it and take over.
+            closeSocket();
+        }
+        scheduleReconnect();
+    });
+    rws.addEventListener("error", (event) => {
+        var _a;
+        if (emitting || isStopped())
+            return;
+        const status = (_a = HANDSHAKE_STATUS.exec(event.message)) === null || _a === void 0 ? void 0 : _a[1];
+        const failure = status === undefined ? undefined : TERMINAL_FAILURES.get(status);
+        if (failure === undefined)
+            return;
+        stop();
+        emitError(`${failure} Not reconnecting.`);
+    });
+    abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.addEventListener("abort", stop, { once: true });
+    // Patched on the generated socket so WebsocketsSocket.close()/connect() and direct
+    // socket.socket.close()/reconnect() calls all count as the user's intent.
+    rws.close = (code, reason) => {
+        stop();
+        subscriptions.clear();
+        closeSocket(code, reason);
+    };
+    rws.reconnect = (code, reason) => {
+        stopped = false;
+        attempt = 0;
+        cancelTimer();
+        reconnectSocket(code, reason);
+    };
+    socket.sendSubscribe = (message) => {
+        sendSubscribe(message);
+        const recorded = JSON.parse(JSON.stringify(message));
+        const covered = new Set(targetsOf(recorded));
+        const kept = [...subscriptions].flatMap(([key, cached]) => {
+            const remaining = withoutTargets(cached, covered);
+            if (remaining === undefined)
+                return [];
+            return [[remaining === cached ? key : subscriptionKey(remaining), remaining]];
+        });
+        const key = subscriptionKey(recorded);
+        subscriptions.clear();
+        for (const [keptKey, keptMessage] of kept)
+            if (keptKey !== key)
+                subscriptions.set(keptKey, keptMessage);
+        subscriptions.set(key, recorded);
+        sentOnConnection.add(key);
+    };
+}
+// What a subscribe message sets on the server: one subscription per inbox and per pod it names, or the
+// credential's own scope when it names neither. That default resolves server-side to an inbox, pod or
+// organization the SDK cannot see, so it is tracked as its own target.
+function targetsOf(message) {
+    var _a, _b;
+    if (message.inboxIds === undefined && message.podIds === undefined)
+        return ["default"];
+    return [...((_a = message.inboxIds) !== null && _a !== void 0 ? _a : []).map((id) => `inbox:${id}`), ...((_b = message.podIds) !== null && _b !== void 0 ? _b : []).map((id) => `pod:${id}`)];
+}
+// `message` without the covered targets; undefined once none of its targets is left.
+function withoutTargets(message, covered) {
+    const targets = targetsOf(message);
+    if (!targets.some((target) => covered.has(target)))
+        return message;
+    if (targets.every((target) => covered.has(target)))
+        return undefined;
+    const { inboxIds, podIds } = message, rest = __rest(message, ["inboxIds", "podIds"]);
+    const keptInboxIds = inboxIds === null || inboxIds === void 0 ? void 0 : inboxIds.filter((id) => !covered.has(`inbox:${id}`));
+    const keptPodIds = podIds === null || podIds === void 0 ? void 0 : podIds.filter((id) => !covered.has(`pod:${id}`));
+    return Object.assign(Object.assign(Object.assign({}, rest), ((keptInboxIds === null || keptInboxIds === void 0 ? void 0 : keptInboxIds.length) ? { inboxIds: keptInboxIds } : {})), ((keptPodIds === null || keptPodIds === void 0 ? void 0 : keptPodIds.length) ? { podIds: keptPodIds } : {}));
+}
+// Canonical JSON (sorted object keys), so the same subscription written in a different key order dedupes.
+function subscriptionKey(message) {
+    return JSON.stringify(message, (_key, value) => {
+        if (value === null || typeof value !== "object" || Array.isArray(value))
+            return value;
+        const sorted = {};
+        for (const key of Object.keys(value).sort()) {
+            sorted[key] = value[key];
+        }
+        return sorted;
+    });
+}

package/dist/esm/BaseClient.mjs

@@ -6,8 +6,8 @@ export function normalizeClientOptions(options) {
     const headers = mergeHeaders({
         "X-Fern-Language": "JavaScript",
         "X-Fern-SDK-Name": "agentmail",
-        "X-Fern-SDK-Version": "0.5.33",
-        "User-Agent": "agentmail/0.5.33",
+        "X-Fern-SDK-Version": "0.5.35",
+        "User-Agent": "agentmail/0.5.35",
         "X-Fern-Runtime": core.RUNTIME.type,
         "X-Fern-Runtime-Version": core.RUNTIME.version,
     }, options === null || options === void 0 ? void 0 : options.headers);

package/dist/esm/api/resources/apiKeys/client/Client.d.mts

@@ -64,8 +64,8 @@ export declare class ApiKeysClient {
     private __create;
     /**
      * Renames a credential or changes its permissions. Public keys also resolve
-     * by `client_id`; a sign-in key accepts only `provider_connect` and
-     * `provider_share_owner`.
+     * by `client_id`; a sign-in key accepts only `app_connect` and
+     * `app_share_owner`.
      *
      * @param {AgentMail.ApiKeyId} api_key_id
      * @param {AgentMail.UpdateApiKeyRequest} request

package/dist/esm/api/resources/apiKeys/client/Client.mjs

@@ -242,8 +242,8 @@ export class ApiKeysClient {
     }
     /**
      * Renames a credential or changes its permissions. Public keys also resolve
-     * by `client_id`; a sign-in key accepts only `provider_connect` and
-     * `provider_share_owner`.
+     * by `client_id`; a sign-in key accepts only `app_connect` and
+     * `app_share_owner`.
      *
      * @param {AgentMail.ApiKeyId} api_key_id
      * @param {AgentMail.UpdateApiKeyRequest} request

package/dist/esm/api/resources/apiKeys/types/AcceptDisclosure.d.mts

@@ -1,6 +1,6 @@
 /**
  * Accept the app's disclosure on the agent's behalf, skipping the
- * first-use disclosure page. Requires `provider_share_owner` when owner
+ * first-use disclosure page. Requires `app_share_owner` when owner
  * scopes are involved.
  */
 export type AcceptDisclosure = boolean;

package/dist/esm/api/resources/apiKeys/types/ApiKeyPermissions.d.mts

@@ -71,17 +71,17 @@ export interface ApiKeyPermissions {
     /** Delete API keys. */
     apiKeyDelete?: boolean;
     /**
-     * Sign in to providers as an inbox: connect a provider, authorize an inbox, and mint the
+     * Sign in to apps as an inbox: connect an app, authorize an inbox, and mint the
      * sign-in keys. Omitted on a new bearer key means false, whatever else the key holds.
      */
-    providerConnect?: boolean;
+    appConnect?: boolean;
     /**
-     * Share the organization owner's name and email with providers at sign-in. One permission
+     * Share the organization owner's name and email with apps at sign-in. One permission
      * for both values.
      */
-    providerShareOwner?: boolean;
+    appShareOwner?: boolean;
     /**
-     * Update accounts: disable or re-enable an inbox's sign-in at a provider. Reading accounts
+     * Update accounts: disable or re-enable an inbox's sign-in at an app. Reading accounts
      * needs only `inbox_read`.
      */
     accountUpdate?: boolean;

package/dist/esm/api/resources/apiKeys/types/PublicKeyCredential.d.mts

@@ -3,8 +3,8 @@ import type * as AgentMail from "../../../index.mjs";
  * An AgentID sign-in credential, scoped like a bearer key; `api_key_id` is
  * the JWS `kid`. A sign-in key carries `status`, gains `public_key` once
  * the client has proved it, expires 30 days after
- * activation, and carries exactly `provider_connect` and
- * `provider_share_owner`, snapshotted from the bearer key that created it
+ * activation, and carries exactly `app_connect` and
+ * `app_share_owner`, snapshotted from the bearer key that created it
  * and enforced from the key itself.
  */
 export interface PublicKeyCredential {

package/dist/esm/serialization/resources/apiKeys/types/ApiKeyPermissions.d.mts

@@ -38,8 +38,8 @@ export declare namespace ApiKeyPermissions {
         api_key_create?: boolean | null;
         api_key_update?: boolean | null;
         api_key_delete?: boolean | null;
-        provider_connect?: boolean | null;
-        provider_share_owner?: boolean | null;
+        app_connect?: boolean | null;
+        app_share_owner?: boolean | null;
         account_update?: boolean | null;
         pod_read?: boolean | null;
         pod_create?: boolean | null;

package/dist/esm/serialization/resources/apiKeys/types/ApiKeyPermissions.mjs

@@ -35,8 +35,8 @@ export const ApiKeyPermissions = core.serialization.object({
     apiKeyCreate: core.serialization.property("api_key_create", core.serialization.boolean().optional()),
     apiKeyUpdate: core.serialization.property("api_key_update", core.serialization.boolean().optional()),
     apiKeyDelete: core.serialization.property("api_key_delete", core.serialization.boolean().optional()),
-    providerConnect: core.serialization.property("provider_connect", core.serialization.boolean().optional()),
-    providerShareOwner: core.serialization.property("provider_share_owner", core.serialization.boolean().optional()),
+    appConnect: core.serialization.property("app_connect", core.serialization.boolean().optional()),
+    appShareOwner: core.serialization.property("app_share_owner", core.serialization.boolean().optional()),
     accountUpdate: core.serialization.property("account_update", core.serialization.boolean().optional()),
     podRead: core.serialization.property("pod_read", core.serialization.boolean().optional()),
     podCreate: core.serialization.property("pod_create", core.serialization.boolean().optional()),

package/dist/esm/version.d.mts

@@ -1 +1 @@
-export declare const SDK_VERSION = "0.5.33";
+export declare const SDK_VERSION = "0.5.35";

package/dist/esm/version.mjs

@@ -1 +1 @@
-export const SDK_VERSION = "0.5.33";
+export const SDK_VERSION = "0.5.35";

package/dist/esm/wrapper/WebsocketsClient.d.mts

@@ -1,10 +1,24 @@
 import { WebsocketsClient as FernWebsocketsClient } from "../api/resources/websockets/client/Client.mjs";
 import type { WebsocketsSocket } from "../api/resources/websockets/client/Socket.mjs";
+import { type ReconnectPolicy } from "./reconnect.mjs";
 export type GetPaymentCredentials = (wsUrl: string) => Promise<Record<string, string>>;
 export declare class WebsocketsClient extends FernWebsocketsClient {
     private readonly _getPaymentCredentials;
-    constructor(options: FernWebsocketsClient.Options, getPaymentCredentials?: GetPaymentCredentials);
+    private readonly _reconnectPolicy;
+    constructor(options: FernWebsocketsClient.Options, getPaymentCredentials?: GetPaymentCredentials, reconnectPolicy?: ReconnectPolicy);
     connect(args?: FernWebsocketsClient.ConnectArgs & {
+        /** Resolve only once the connection is open. Defaults to true. */
         waitForOpen?: boolean;
+        /**
+         * Keep the socket connected and subscribed. Whenever the connection drops, reconnect with
+         * exponential backoff (full jitter, 1 s doubling up to 60 s) and re-send every subscription
+         * sent through `sendSubscribe` on the new connection; `reconnectAttempts` then only bounds
+         * the generated socket's own quick retries, not the total. Stops on `close()`, on
+         * `abortSignal`, or when the server refuses the handshake with 401, 402 or 403, which is
+         * reported to the `error` handler. x402/MPP sockets reuse the payment credential minted by
+         * this call on every reconnect. Defaults to true. `false` (or `reconnectAttempts: 0`) keeps
+         * only the generated socket's own limited retries and does not re-subscribe.
+         */
+        autoReconnect?: boolean;
     }): Promise<WebsocketsSocket>;
 }

package/dist/esm/wrapper/WebsocketsClient.mjs

@@ -21,31 +21,49 @@ var __rest = (this && this.__rest) || function (s, e) {
 import { WebsocketsClient as FernWebsocketsClient } from "../api/resources/websockets/client/Client.mjs";
 import * as core from "../core/index.mjs";
 import * as environments from "../environments.mjs";
+import { SDK_VERSION } from "../version.mjs";
+import { DEFAULT_RECONNECT_POLICY, enableAutoReconnect } from "./reconnect.mjs";
+// The generated client's default. Always passed explicitly: auto-reconnect has to know the generated
+// socket's exact retry budget to take over before it runs out.
+const DEFAULT_RECONNECT_ATTEMPTS = 30;
+// Lets the server tell SDK releases apart on the handshake (Node only; browsers cannot set handshake
+// headers). Caller-supplied headers win.
+const SDK_HEADERS = { "X-Fern-SDK-Name": "agentmail", "X-Fern-SDK-Version": SDK_VERSION };
 export class WebsocketsClient extends FernWebsocketsClient {
-    constructor(options, getPaymentCredentials) {
+    constructor(options, getPaymentCredentials, reconnectPolicy = DEFAULT_RECONNECT_POLICY) {
         super(options);
         this._getPaymentCredentials = getPaymentCredentials;
+        this._reconnectPolicy = reconnectPolicy;
     }
     connect() {
         const _super = Object.create(null, {
             connect: { get: () => super.connect }
         });
         return __awaiter(this, arguments, void 0, function* (args = {}) {
-            var _a, _b, _c;
-            const { waitForOpen = true } = args, rest = __rest(args, ["waitForOpen"]);
-            let connectArgs = rest;
+            var _a, _b, _c, _d;
+            const { waitForOpen = true, autoReconnect = true } = args, rest = __rest(args, ["waitForOpen", "autoReconnect"]);
+            const reconnectAttempts = (_a = rest.reconnectAttempts) !== null && _a !== void 0 ? _a : DEFAULT_RECONNECT_ATTEMPTS;
+            let connectArgs = Object.assign(Object.assign({}, rest), { reconnectAttempts, headers: Object.assign(Object.assign({}, SDK_HEADERS), rest.headers) });
             if (this._getPaymentCredentials) {
-                const wsUrl = core.url.join((_a = (yield core.Supplier.get(this._options.baseUrl))) !== null && _a !== void 0 ? _a : ((_b = (yield core.Supplier.get(this._options.environment))) !== null && _b !== void 0 ? _b : environments.AgentMailEnvironment.Prod).websockets, "/v0");
+                const wsUrl = core.url.join((_b = (yield core.Supplier.get(this._options.baseUrl))) !== null && _b !== void 0 ? _b : ((_c = (yield core.Supplier.get(this._options.environment))) !== null && _c !== void 0 ? _c : environments.AgentMailEnvironment.Prod)
+                    .websockets, "/v0");
                 const credentials = yield this._getPaymentCredentials(wsUrl);
-                connectArgs = Object.assign(Object.assign({}, rest), { queryParams: Object.assign(Object.assign({}, credentials), rest.queryParams) });
+                connectArgs = Object.assign(Object.assign({}, connectArgs), { queryParams: Object.assign(Object.assign({}, credentials), rest.queryParams) });
             }
             else if (!rest.apiKey) {
-                const apiKey = (_c = (yield core.Supplier.get(this._options.apiKey))) !== null && _c !== void 0 ? _c : process.env.AGENTMAIL_API_KEY;
-                connectArgs = Object.assign(Object.assign({}, rest), { apiKey });
+                const apiKey = (_d = (yield core.Supplier.get(this._options.apiKey))) !== null && _d !== void 0 ? _d : process.env.AGENTMAIL_API_KEY;
+                connectArgs = Object.assign(Object.assign({}, connectArgs), { apiKey });
             }
             const socket = yield _super.connect.call(this, connectArgs);
             if (waitForOpen)
                 yield socket.waitForOpen();
+            if (autoReconnect && reconnectAttempts > 0) {
+                enableAutoReconnect(socket, {
+                    maxRetries: reconnectAttempts,
+                    abortSignal: rest.abortSignal,
+                    policy: this._reconnectPolicy,
+                });
+            }
             return socket;
         });
     }

package/dist/esm/wrapper/reconnect.d.mts

@@ -0,0 +1,22 @@
+import type { WebsocketsSocket } from "../api/resources/websockets/client/Socket.mjs";
+export interface ReconnectPolicy {
+    baseDelayMs: number;
+    maxDelayMs: number;
+    /** How long a connection must stay open before the backoff starts over. */
+    stableAfterMs: number;
+}
+export declare const DEFAULT_RECONNECT_POLICY: ReconnectPolicy;
+/** Exponential backoff with full jitter: uniform in [0, min(maxDelayMs, baseDelayMs * 2^attempt)). */
+export declare function backoffDelay(attempt: number, policy: ReconnectPolicy, random?: () => number): number;
+export interface AutoReconnectOptions {
+    /** The generated socket's own retry budget (`reconnectAttempts`). */
+    maxRetries: number;
+    abortSignal?: AbortSignal;
+    policy: ReconnectPolicy;
+}
+/**
+ * Keeps `socket` connected and subscribed: re-sends every subscription on each reconnect, takes over
+ * reconnecting whenever the generated socket gives up, and stops on close(), abort, or a terminal
+ * handshake refusal.
+ */
+export declare function enableAutoReconnect(socket: WebsocketsSocket, options: AutoReconnectOptions): void;

package/dist/esm/wrapper/reconnect.mjs

@@ -0,0 +1,208 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { ReconnectingWebSocket } from "../core/index.mjs";
+import * as Events from "../core/websocket/events.mjs";
+export const DEFAULT_RECONNECT_POLICY = { baseDelayMs: 1000, maxDelayMs: 60000, stableAfterMs: 5000 };
+/** Exponential backoff with full jitter: uniform in [0, min(maxDelayMs, baseDelayMs * 2^attempt)). */
+export function backoffDelay(attempt, policy, random = Math.random) {
+    return random() * Math.min(policy.maxDelayMs, policy.baseDelayMs * Math.pow(2, attempt));
+}
+const { OPEN, CLOSING, CLOSED } = ReconnectingWebSocket.ReadyState;
+// ws reports a refused handshake as "Unexpected server response: <status>". Browsers expose no status,
+// so there every refusal looks transient and is retried on the capped backoff.
+const HANDSHAKE_STATUS = /^Unexpected server response: (\d{3})\b/;
+// Refusals that retrying with the same credentials cannot fix. 402 comes from the x402/MPP proxies,
+// whose payment credential is minted once per connect() call and reused on reconnects. The server
+// also answers 403 when the organization is at its connection cap, which a retry could outlast.
+const TERMINAL_FAILURES = new Map([
+    ["401", "WebSocket authentication failed (401): the API key is missing, invalid, or was deleted."],
+    [
+        "402",
+        "WebSocket payment required (402): the payment credential minted by connect() is no longer accepted; open a new socket with client.websockets.connect() to pay again.",
+    ],
+    [
+        "403",
+        "WebSocket authentication failed (403): the API key is invalid or was deleted, or the organization is at its WebSocket connection limit.",
+    ],
+]);
+/**
+ * Keeps `socket` connected and subscribed: re-sends every subscription on each reconnect, takes over
+ * reconnecting whenever the generated socket gives up, and stops on close(), abort, or a terminal
+ * handshake refusal.
+ */
+export function enableAutoReconnect(socket, options) {
+    const { maxRetries, abortSignal, policy } = options;
+    const rws = socket.socket;
+    const sendSubscribe = socket.sendSubscribe.bind(socket);
+    const closeSocket = rws.close.bind(rws);
+    const reconnectSocket = rws.reconnect.bind(rws);
+    // Keyed by canonical JSON, in the order last sent. The server keeps one subscription per target and
+    // the last filter sent for it, so a new message takes its targets out of every earlier one: a
+    // replay can never put back a filter the caller has since changed.
+    const subscriptions = new Map();
+    // Keys already sent on the current connection, e.g. by the user's own open handler.
+    const sentOnConnection = new Set();
+    let opened = rws.readyState === OPEN;
+    let openedAt = opened ? Date.now() : undefined;
+    let stopped = false;
+    let attempt = 0;
+    let timer;
+    let emitting = false;
+    const isStopped = () => stopped || (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) === true;
+    const cancelTimer = () => {
+        clearTimeout(timer);
+        timer = undefined;
+    };
+    const stop = () => {
+        stopped = true;
+        cancelTimer();
+    };
+    const emitError = (message) => {
+        var _a;
+        const event = new Events.ErrorEvent(new Error(message), rws);
+        emitting = true;
+        try {
+            (_a = rws.onerror) === null || _a === void 0 ? void 0 : _a.call(rws, event);
+            rws.dispatchEvent(event);
+        }
+        finally {
+            emitting = false;
+        }
+    };
+    const scheduleReconnect = () => {
+        cancelTimer();
+        timer = setTimeout(() => {
+            timer = undefined;
+            if (isStopped())
+                return;
+            // reconnect() on a socket that is not CLOSED closes it with 1000 and then never connects.
+            if (rws.readyState === CLOSED)
+                reconnectSocket();
+            else if (rws.readyState === CLOSING)
+                scheduleReconnect();
+        }, backoffDelay(attempt++, policy));
+    };
+    rws.addEventListener("open", () => {
+        cancelTimer();
+        openedAt = Date.now();
+        if (!opened) {
+            opened = true;
+            return;
+        }
+        for (const [key, message] of subscriptions) {
+            if (isStopped() || rws.readyState !== OPEN)
+                return;
+            if (sentOnConnection.has(key))
+                continue;
+            try {
+                sendSubscribe(message);
+                sentOnConnection.add(key);
+            }
+            catch (error) {
+                emitError(`Failed to re-subscribe after reconnecting: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    });
+    rws.addEventListener("close", (event) => {
+        sentOnConnection.clear();
+        if (openedAt !== undefined && Date.now() - openedAt >= policy.stableAfterMs)
+            attempt = 0;
+        openedAt = undefined;
+        if (isStopped())
+            return;
+        if (event.code !== 1000) {
+            // The generated socket retries these closes itself, up to maxRetries times.
+            if (rws.retryCount < maxRetries)
+                return;
+            // It has just scheduled its last retry. If that one fails too, it keeps its connect lock
+            // and ignores reconnect() for good, so cancel it and take over.
+            closeSocket();
+        }
+        scheduleReconnect();
+    });
+    rws.addEventListener("error", (event) => {
+        var _a;
+        if (emitting || isStopped())
+            return;
+        const status = (_a = HANDSHAKE_STATUS.exec(event.message)) === null || _a === void 0 ? void 0 : _a[1];
+        const failure = status === undefined ? undefined : TERMINAL_FAILURES.get(status);
+        if (failure === undefined)
+            return;
+        stop();
+        emitError(`${failure} Not reconnecting.`);
+    });
+    abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.addEventListener("abort", stop, { once: true });
+    // Patched on the generated socket so WebsocketsSocket.close()/connect() and direct
+    // socket.socket.close()/reconnect() calls all count as the user's intent.
+    rws.close = (code, reason) => {
+        stop();
+        subscriptions.clear();
+        closeSocket(code, reason);
+    };
+    rws.reconnect = (code, reason) => {
+        stopped = false;
+        attempt = 0;
+        cancelTimer();
+        reconnectSocket(code, reason);
+    };
+    socket.sendSubscribe = (message) => {
+        sendSubscribe(message);
+        const recorded = JSON.parse(JSON.stringify(message));
+        const covered = new Set(targetsOf(recorded));
+        const kept = [...subscriptions].flatMap(([key, cached]) => {
+            const remaining = withoutTargets(cached, covered);
+            if (remaining === undefined)
+                return [];
+            return [[remaining === cached ? key : subscriptionKey(remaining), remaining]];
+        });
+        const key = subscriptionKey(recorded);
+        subscriptions.clear();
+        for (const [keptKey, keptMessage] of kept)
+            if (keptKey !== key)
+                subscriptions.set(keptKey, keptMessage);
+        subscriptions.set(key, recorded);
+        sentOnConnection.add(key);
+    };
+}
+// What a subscribe message sets on the server: one subscription per inbox and per pod it names, or the
+// credential's own scope when it names neither. That default resolves server-side to an inbox, pod or
+// organization the SDK cannot see, so it is tracked as its own target.
+function targetsOf(message) {
+    var _a, _b;
+    if (message.inboxIds === undefined && message.podIds === undefined)
+        return ["default"];
+    return [...((_a = message.inboxIds) !== null && _a !== void 0 ? _a : []).map((id) => `inbox:${id}`), ...((_b = message.podIds) !== null && _b !== void 0 ? _b : []).map((id) => `pod:${id}`)];
+}
+// `message` without the covered targets; undefined once none of its targets is left.
+function withoutTargets(message, covered) {
+    const targets = targetsOf(message);
+    if (!targets.some((target) => covered.has(target)))
+        return message;
+    if (targets.every((target) => covered.has(target)))
+        return undefined;
+    const { inboxIds, podIds } = message, rest = __rest(message, ["inboxIds", "podIds"]);
+    const keptInboxIds = inboxIds === null || inboxIds === void 0 ? void 0 : inboxIds.filter((id) => !covered.has(`inbox:${id}`));
+    const keptPodIds = podIds === null || podIds === void 0 ? void 0 : podIds.filter((id) => !covered.has(`pod:${id}`));
+    return Object.assign(Object.assign(Object.assign({}, rest), ((keptInboxIds === null || keptInboxIds === void 0 ? void 0 : keptInboxIds.length) ? { inboxIds: keptInboxIds } : {})), ((keptPodIds === null || keptPodIds === void 0 ? void 0 : keptPodIds.length) ? { podIds: keptPodIds } : {}));
+}
+// Canonical JSON (sorted object keys), so the same subscription written in a different key order dedupes.
+function subscriptionKey(message) {
+    return JSON.stringify(message, (_key, value) => {
+        if (value === null || typeof value !== "object" || Array.isArray(value))
+            return value;
+        const sorted = {};
+        for (const key of Object.keys(value).sort()) {
+            sorted[key] = value[key];
+        }
+        return sorted;
+    });
+}

package/dist/llms.txt

@@ -36,9 +36,9 @@
 - [MPP](https://docs.agentmail.to/integrations/mpp.md): AgentMail's MPP integration for machine-to-machine payments via Stripe
 - [Integrate LiveKit Agents](https://docs.agentmail.to/integrate-livekit-agents.md): A step-by-step guide to integrate with the LiveKit Agents SDK.
 - [Sim.ai](https://docs.agentmail.to/integrations/sim.md): AgentMail's Sim.ai integration
-- [AgentID Sign-In](https://docs.agentmail.to/agentid-sign-in.md): Connect an inbox to a provider, authorize a pending AgentID sign-in, and manage sign-in keys with the AgentMail API and CLI.
+- [AgentID Sign-In](https://docs.agentmail.to/agentid-sign-in.md): Connect an inbox to an app, authorize a pending AgentID sign-in, and manage sign-in keys with the AgentMail API and CLI.
 - [AgentID Public-Key Authentication](https://docs.agentmail.to/agentid-public-key-authentication.md): Register a public P-256 key, choose its scope and permissions, and manage it through the current AgentMail API Keys endpoints.
-- [AgentID in Claude, ChatGPT, and Cursor](https://docs.agentmail.to/agentid-in-assistants.md): Ask Claude, ChatGPT, Cursor, Claude Code, or Codex to create an account for your agent at a provider such as Firecrawl, get its API key, and see where your agent already has accounts, using AgentMail and AgentID.
+- [AgentID in Claude, ChatGPT, and Cursor](https://docs.agentmail.to/agentid-in-assistants.md): Ask Claude, ChatGPT, Cursor, Claude Code, or Codex to create an account for your agent at an app such as Firecrawl, get its API key, and see where your agent already has accounts, using AgentMail and AgentID.
 - [Guide: Sending & Receiving Email](https://docs.agentmail.to/sending-receiving-email.md): A step-by-step guide to the practical workflow of sending initial emails and handling replies to have a full conversation.
 - [Reply & Attachment Extraction](https://docs.agentmail.to/reply-extraction.md): AgentMail strips quoted history and boilerplate from every message into extracted_text and extracted_html, and extracts plain text from PDF, Word, Excel, and text attachments. No Talon or reply-parsing library required.
 - [IMAP & SMTP](https://docs.agentmail.to/imap-smtp.md): Configure IMAP and SMTP to access your AgentMail inboxes using email clients or programmatic access.
@@ -201,11 +201,11 @@
 - API Reference > API Keys [Create API Key](https://docs.agentmail.to/api-reference/api-keys/create.md)
 - API Reference > API Keys [Update API Key](https://docs.agentmail.to/api-reference/api-keys/update.md)
 - API Reference > API Keys [Delete API Key](https://docs.agentmail.to/api-reference/api-keys/delete.md)
-- API Reference > Providers [List Providers](https://docs.agentmail.to/api-reference/providers/list.md)
-- API Reference > Providers [Search Providers](https://docs.agentmail.to/api-reference/providers/search.md)
-- API Reference > Providers [Get Provider](https://docs.agentmail.to/api-reference/providers/get.md)
-- API Reference > Providers [List Provider Accounts](https://docs.agentmail.to/api-reference/providers/list-accounts.md)
-- API Reference > Providers [Connect Provider](https://docs.agentmail.to/api-reference/providers/connect.md)
+- API Reference > Apps [List Apps](https://docs.agentmail.to/api-reference/apps/list.md)
+- API Reference > Apps [Search Apps](https://docs.agentmail.to/api-reference/apps/search.md)
+- API Reference > Apps [Get App](https://docs.agentmail.to/api-reference/apps/get.md)
+- API Reference > Apps [List App Accounts](https://docs.agentmail.to/api-reference/apps/list-accounts.md)
+- API Reference > Apps [Connect App](https://docs.agentmail.to/api-reference/apps/connect.md)
 - API Reference > Accounts [List Accounts](https://docs.agentmail.to/api-reference/accounts/list.md)
 - API Reference > Accounts [Get Account](https://docs.agentmail.to/api-reference/accounts/get.md)
 - API Reference > Accounts [Update Account](https://docs.agentmail.to/api-reference/accounts/update.md)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "agentmail",
-    "version": "0.5.33",
+    "version": "0.5.35",
     "private": false,
     "repository": {
         "type": "git",

package/reference.md

@@ -1896,8 +1896,8 @@ await client.apiKeys.create({});
 <dd>
 
 Renames a credential or changes its permissions. Public keys also resolve
-by `client_id`; a sign-in key accepts only `provider_connect` and
-`provider_share_owner`.
+by `client_id`; a sign-in key accepts only `app_connect` and
+`app_share_owner`.
 </dd>
 </dl>
 </dd>