@dominusnode/sdk 1.1.2 → 1.3.0

package/dist/cjs/resources/x402.js

@@ -1,11 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.X402Resource = void 0;
+exports.X402Resource = exports.X402_HEADERS = exports.X402_PROTOCOL_VERSION = void 0;
 /**
- * x402 (HTTP 402 Payment Required) protocol information.
+ * x402 V2 protocol version.
+ * V2 uses CAIP-2 network identifiers (e.g. "eip155:8453" instead of "base").
+ */
+exports.X402_PROTOCOL_VERSION = "2";
+/**
+ * x402 V2 header constants.
+ * V2 renamed the payment headers. Servers should accept both old and new
+ * for backward compatibility during the transition period.
+ */
+exports.X402_HEADERS = {
+    /** V2 payment header (replaces V1 "X-PAYMENT"). */
+    PAYMENT_SIGNATURE: "PAYMENT-SIGNATURE",
+    /** V1 legacy payment header — kept for backward compatibility. */
+    PAYMENT_SIGNATURE_LEGACY: "X-PAYMENT",
+    /** V2 payment response header (replaces V1 "X-PAYMENT-RESPONSE"). */
+    PAYMENT_RESPONSE: "PAYMENT-RESPONSE",
+    /** V1 legacy payment response header. */
+    PAYMENT_RESPONSE_LEGACY: "X-PAYMENT-RESPONSE",
+    /** V2 payment requirements header. */
+    PAYMENT_REQUIRED: "PAYMENT-REQUIRED",
+};
+/**
+ * x402 V2 (HTTP 402 Payment Required) protocol information.
  *
  * Provides details about x402 micropayment support, facilitator addresses,
- * pricing, and supported chains/currencies for AI agent payments.
+ * pricing, supported chains/currencies, and payment schemes for AI agent
+ * payments.
+ *
+ * V2 changes from V1:
+ * - Protocol version "2" (was "1")
+ * - CAIP-2 network IDs (e.g. "eip155:8453" instead of "base")
+ * - Payment header: PAYMENT-SIGNATURE (was X-PAYMENT)
+ * - Response header: PAYMENT-RESPONSE (was X-PAYMENT-RESPONSE)
+ * - Requirements header: PAYMENT-REQUIRED
+ * - New token: EURC (in addition to USDC)
+ * - New scheme: permit2 (in addition to exact)
+ * - Additional facilitator chains: Ethereum (eip155:1), Optimism (eip155:10),
+ *   Arbitrum (eip155:42161), and Solana
  */
 class X402Resource {
     http;
@@ -13,8 +47,8 @@ class X402Resource {
         this.http = http;
     }
     /**
-     * Get x402 protocol information including facilitator details,
-     * pricing, supported chains, and currencies.
+     * Get x402 V2 protocol information including facilitator details,
+     * pricing, supported chains, currencies, and payment schemes.
      *
      * This endpoint does not require authentication.
      */

package/dist/cjs/wallet.js

@@ -22,14 +22,18 @@ class WalletResource {
     }
     /** Create a Stripe checkout session for wallet top-up. */
     async topUpStripe(amountCents) {
-        if (!Number.isInteger(amountCents) || amountCents <= 0 || amountCents > 2_147_483_647) {
+        if (!Number.isInteger(amountCents) ||
+            amountCents <= 0 ||
+            amountCents > 2_147_483_647) {
             throw new Error("amountCents must be a positive integer <= 2,147,483,647");
         }
         return this.http.post("/api/wallet/topup/stripe", { amountCents });
     }
     /** Create a crypto invoice for wallet top-up. Minimum $10 (1000 cents). */
     async topUpCrypto(amountCents, currency) {
-        if (!Number.isInteger(amountCents) || amountCents <= 0 || amountCents > 2_147_483_647) {
+        if (!Number.isInteger(amountCents) ||
+            amountCents <= 0 ||
+            amountCents > 2_147_483_647) {
             throw new Error("amountCents must be a positive integer <= 2,147,483,647");
         }
         if (amountCents < 1000) {
@@ -40,7 +44,9 @@ class WalletResource {
     }
     /** Create a PayPal order for wallet top-up. Minimum $5 (500 cents). */
     async topUpPaypal(amountCents) {
-        if (!Number.isInteger(amountCents) || amountCents <= 0 || amountCents > 2_147_483_647) {
+        if (!Number.isInteger(amountCents) ||
+            amountCents <= 0 ||
+            amountCents > 2_147_483_647) {
             throw new Error("amountCents must be a positive integer <= 2,147,483,647");
         }
         if (amountCents < 500) {

package/dist/esm/auth.d.ts

@@ -3,6 +3,7 @@ import type { User, LoginResult, MfaStatus, MfaSetup } from "./types.js";
 export declare class AuthResource {
     private http;
     constructor(http: HttpClient);
+    private solvePoW;
     register(email: string, password: string): Promise<{
         user: User;
         token?: string;

package/dist/esm/auth.js

@@ -1,10 +1,54 @@
+import * as crypto from "node:crypto";
+const POW_MAX_NONCE = 100_000_000;
+function countLeadingZeroBits(hash) {
+    let count = 0;
+    for (const byte of hash) {
+        if (byte === 0) {
+            count += 8;
+        }
+        else {
+            let mask = 0x80;
+            while (mask && !(byte & mask)) {
+                count += 1;
+                mask >>= 1;
+            }
+            break;
+        }
+    }
+    return count;
+}
 export class AuthResource {
     http;
     constructor(http) {
         this.http = http;
     }
+    async solvePoW() {
+        try {
+            const challenge = await this.http.post("/api/auth/pow/challenge", {}, false);
+            const { challengeId, prefix } = challenge;
+            const difficulty = Math.min(challenge.difficulty, 32);
+            for (let nonce = 0; nonce < POW_MAX_NONCE; nonce++) {
+                const hash = crypto
+                    .createHash("sha256")
+                    .update(prefix + nonce)
+                    .digest();
+                if (countLeadingZeroBits(hash) >= difficulty) {
+                    return { challengeId, nonce };
+                }
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
     async register(email, password) {
-        return this.http.post("/api/auth/register", { email, password }, false);
+        const pow = await this.solvePoW();
+        const body = { email, password };
+        if (pow) {
+            body.pow = pow;
+        }
+        return this.http.post("/api/auth/register", body, false);
     }
     async login(email, password) {
         return this.http.post("/api/auth/login", { email, password }, false);
@@ -22,7 +66,10 @@ export class AuthResource {
         return this.http.get("/api/auth/me");
     }
     async changePassword(currentPassword, newPassword) {
-        await this.http.post("/api/auth/change-password", { currentPassword, newPassword });
+        await this.http.post("/api/auth/change-password", {
+            currentPassword,
+            newPassword,
+        });
     }
     async verifyKey(apiKey) {
         return this.http.post("/api/auth/verify-key", { apiKey }, false);

package/dist/esm/client.d.ts

@@ -11,6 +11,7 @@ import { AgenticWalletResource } from "./resources/agent-wallet.js";
 import { TeamsResource } from "./resources/teams.js";
 import { X402Resource } from "./resources/x402.js";
 import { WalletAuthResource } from "./resources/wallet-auth.js";
+import { MppResource } from "./resources/mpp.js";
 import type { DominusNodeConfig, LoginResult } from "./types.js";
 export declare class DominusNodeClient {
     readonly auth: AuthResource;
@@ -26,6 +27,7 @@ export declare class DominusNodeClient {
     readonly teams: TeamsResource;
     readonly x402: X402Resource;
     readonly walletAuth: WalletAuthResource;
+    readonly mpp: MppResource;
     private tokenManager;
     private http;
     private apiKey;

package/dist/esm/client.js

@@ -13,6 +13,7 @@ import { AgenticWalletResource } from "./resources/agent-wallet.js";
 import { TeamsResource } from "./resources/teams.js";
 import { X402Resource } from "./resources/x402.js";
 import { WalletAuthResource } from "./resources/wallet-auth.js";
+import { MppResource } from "./resources/mpp.js";
 import { DEFAULT_BASE_URL } from "./constants.js";
 export class DominusNodeClient {
     auth;
@@ -28,6 +29,7 @@ export class DominusNodeClient {
     teams;
     x402;
     walletAuth;
+    mpp;
     tokenManager;
     http;
     apiKey = null;
@@ -50,6 +52,7 @@ export class DominusNodeClient {
         this.teams = new TeamsResource(this.http);
         this.x402 = new X402Resource(this.http);
         this.walletAuth = new WalletAuthResource(this.http, this.tokenManager);
+        this.mpp = new MppResource(this.http);
         // Set refresh function AFTER auth is initialized
         this.tokenManager.setRefreshFunction(async (rt) => {
             const res = await this.auth.refresh(rt);

package/dist/esm/http.js

@@ -45,12 +45,18 @@ function throwForStatus(status, body, headers) {
     if (message.length > 500)
         message = message.slice(0, 500) + "... [truncated]";
     switch (status) {
-        case 400: throw new ValidationError(message);
-        case 401: throw new AuthenticationError(message);
-        case 402: throw new InsufficientBalanceError(message);
-        case 403: throw new AuthorizationError(message);
-        case 404: throw new NotFoundError(message);
-        case 409: throw new ConflictError(message);
+        case 400:
+            throw new ValidationError(message);
+        case 401:
+            throw new AuthenticationError(message);
+        case 402:
+            throw new InsufficientBalanceError(message);
+        case 403:
+            throw new AuthorizationError(message);
+        case 404:
+            throw new NotFoundError(message);
+        case 409:
+            throw new ConflictError(message);
         case 429: {
             const parsed = parseInt(headers.get("retry-after") ?? "60", 10);
             const retryAfter = Number.isFinite(parsed) ? parsed : 60; // NaN guard

package/dist/esm/index.d.ts

@@ -18,10 +18,12 @@ export { AgenticWalletResource } from "./resources/agent-wallet.js";
 export type { AgenticWallet, AgenticWalletTransaction, AgenticWalletListResponse, AgenticWalletFundResponse, AgenticWalletTransactionsResponse, AgenticWalletDeleteResponse, } from "./resources/agent-wallet.js";
 export { TeamsResource } from "./resources/teams.js";
 export type { Team, TeamMember, TeamInvite, TeamListResponse, TeamMembersResponse, TeamInvitesResponse, TeamKeysResponse, TeamKeyCreateResponse, TeamDeleteResponse, TeamFundResponse, TeamTransactionsResponse, } from "./resources/teams.js";
-export { X402Resource } from "./resources/x402.js";
-export type { X402Info, X402Facilitator, X402Pricing, } from "./resources/x402.js";
+export { X402Resource, X402_PROTOCOL_VERSION, X402_HEADERS, } from "./resources/x402.js";
+export type { X402Info, X402Facilitator, X402PaymentHeaders, X402Pricing, X402Scheme, X402Token, } from "./resources/x402.js";
 export { WalletAuthResource } from "./resources/wallet-auth.js";
 export type { WalletChallenge, WalletVerifyResult, WalletLinkResult, } from "./resources/wallet-auth.js";
+export { MppResource } from "./resources/mpp.js";
+export type { MppInfo, MppPricing, MppLimits, MppTopUpResponse, MppSessionResponse, MppCloseResponse, MppSessionStatus, MppChallengeResponse, MppCredentialPayload, } from "./resources/mpp.js";
 export type { DateRangeOptions as AdminDateRangeOptions, ListUsersResponse, GetUserResponse, RevenueResponse, DailyRevenueEntry, DailyRevenueResponse, } from "./admin.js";
 export { HttpClient } from "./http.js";
 export type { HttpOptions } from "./http.js";

package/dist/esm/index.js

@@ -12,8 +12,9 @@ export { AdminResource } from "./admin.js";
 export { SlotsResource } from "./slots.js";
 export { AgenticWalletResource } from "./resources/agent-wallet.js";
 export { TeamsResource } from "./resources/teams.js";
-export { X402Resource } from "./resources/x402.js";
+export { X402Resource, X402_PROTOCOL_VERSION, X402_HEADERS, } from "./resources/x402.js";
 export { WalletAuthResource } from "./resources/wallet-auth.js";
+export { MppResource } from "./resources/mpp.js";
 // Infrastructure (HttpClient for advanced custom integrations)
 export { HttpClient } from "./http.js";
 // TokenManager is internal — not exported to prevent misuse of token lifecycle

package/dist/esm/resources/agent-wallet.js

@@ -4,11 +4,16 @@ export class AgenticWalletResource {
         this.http = http;
     }
     async create(label, spendingLimitCents = 10000, options) {
-        if (!Number.isInteger(spendingLimitCents) || spendingLimitCents < 0 || spendingLimitCents > 2_147_483_647) {
+        if (!Number.isInteger(spendingLimitCents) ||
+            spendingLimitCents < 0 ||
+            spendingLimitCents > 2_147_483_647) {
             throw new Error("spendingLimitCents must be a non-negative integer <= 2,147,483,647");
         }
-        if (options?.dailyLimitCents !== undefined && options.dailyLimitCents !== null) {
-            if (!Number.isInteger(options.dailyLimitCents) || options.dailyLimitCents < 0 || options.dailyLimitCents > 2_147_483_647) {
+        if (options?.dailyLimitCents !== undefined &&
+            options.dailyLimitCents !== null) {
+            if (!Number.isInteger(options.dailyLimitCents) ||
+                options.dailyLimitCents < 0 ||
+                options.dailyLimitCents > 2_147_483_647) {
                 throw new Error("dailyLimitCents must be a non-negative integer <= 2,147,483,647");
             }
         }
@@ -26,14 +31,19 @@ export class AgenticWalletResource {
         return this.http.get(`/api/agent-wallet/${encodeURIComponent(walletId)}`);
     }
     async fund(walletId, amountCents) {
-        if (!Number.isInteger(amountCents) || amountCents <= 0 || amountCents > 2_147_483_647) {
+        if (!Number.isInteger(amountCents) ||
+            amountCents <= 0 ||
+            amountCents > 2_147_483_647) {
             throw new Error("amountCents must be a positive integer <= 2,147,483,647");
         }
         return this.http.post(`/api/agent-wallet/${encodeURIComponent(walletId)}/fund`, { amountCents });
     }
     async updateWalletPolicy(walletId, policy) {
-        if (policy.dailyLimitCents !== undefined && policy.dailyLimitCents !== null) {
-            if (!Number.isInteger(policy.dailyLimitCents) || policy.dailyLimitCents < 0 || policy.dailyLimitCents > 2_147_483_647) {
+        if (policy.dailyLimitCents !== undefined &&
+            policy.dailyLimitCents !== null) {
+            if (!Number.isInteger(policy.dailyLimitCents) ||
+                policy.dailyLimitCents < 0 ||
+                policy.dailyLimitCents > 2_147_483_647) {
                 throw new Error("dailyLimitCents must be a non-negative integer <= 2,147,483,647");
             }
         }

package/dist/esm/resources/mpp.d.ts

@@ -0,0 +1,161 @@
+import type { HttpClient } from "../http.js";
+/** IETF MPP auth scheme name (official spec) */
+export declare const MPP_AUTH_SCHEME = "Payment";
+/** Legacy auth scheme name (backward compat) */
+export declare const MPP_AUTH_SCHEME_LEGACY = "MPP";
+export interface MppInfo {
+    supported: boolean;
+    enabled: boolean;
+    protocol: string;
+    version: string;
+    methods: string[];
+    pricing: MppPricing;
+    limits: MppLimits;
+}
+export interface MppPricing {
+    perGbCents: number;
+    depositMinCents: number;
+    currency: string;
+}
+export interface MppLimits {
+    maxDepositCents: number;
+    maxSessionDurationSeconds: number;
+}
+export interface MppTopUpResponse {
+    success: boolean;
+    amountCents: number;
+    method: string;
+    transactionId: string;
+}
+export interface MppSessionResponse {
+    channelId: string;
+    depositCents: number;
+    method: string;
+    poolType: string;
+    expiresAt: string;
+}
+export interface MppCloseResponse {
+    channelId: string;
+    refundedCents: number;
+    usedCents: number;
+    closed: boolean;
+}
+export interface MppSessionStatus {
+    channelId: string;
+    status: string;
+    depositCents: number;
+    usedCents: number;
+    method: string;
+    poolType: string;
+    createdAt: string;
+    expiresAt: string;
+}
+/**
+ * MPP challenge response returned by POST /api/mpp/challenge.
+ * Used for keyless proxy access -- AI agents can use the proxy
+ * without any API key by solving a challenge and paying per request.
+ */
+export interface MppChallengeResponse {
+    challengeId: string;
+    nonce: string;
+    expiresAt: string;
+    poolType: string;
+    credential: MppCredentialPayload;
+}
+/**
+ * Credential payload for keyless MPP proxy access.
+ * Pass this to `buildProxyHeaders()` to construct the headers
+ * needed to route through the proxy without an API key.
+ */
+export interface MppCredentialPayload {
+    challengeId: string;
+    nonce: string;
+    poolType: string;
+    sessionToken?: string;
+}
+/**
+ * Micropayment Payment Protocol (MPP) resource.
+ *
+ * Provides pay-per-use proxy sessions with real-time micropayment channels.
+ * Supports multiple payment methods: Tempo streaming, Stripe SPT, and Lightning.
+ *
+ * MPP also enables keyless proxy access for AI agents: call `getChallenge()` to
+ * obtain a credential, then use `buildProxyHeaders()` to construct the proxy
+ * Authorization header -- no API key needed.
+ */
+export declare class MppResource {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Get MPP protocol information including supported methods, pricing, and limits.
+     *
+     * This endpoint does not require authentication.
+     */
+    getInfo(): Promise<MppInfo>;
+    /**
+     * Request an MPP challenge for keyless proxy access.
+     *
+     * This endpoint does not require authentication. The returned credential
+     * can be used with `buildProxyHeaders()` to access the proxy without an API key.
+     *
+     * @param poolType - Proxy pool type: "dc" (datacenter, $3/GB) or "residential" ($5/GB)
+     */
+    getChallenge(poolType: "dc" | "residential"): Promise<MppChallengeResponse>;
+    /**
+     * Build proxy Authorization header for keyless MPP access.
+     *
+     * Returns headers that should be set on the HTTP CONNECT / proxy request
+     * to route through the proxy without an API key.
+     *
+     * @param credential - The credential payload from `getChallenge()`
+     * @returns Headers object with `Authorization: MPP <json>`
+     */
+    buildProxyHeaders(credential: MppCredentialPayload): Record<string, string>;
+    /**
+     * Build proxy session token header for ongoing MPP sessions.
+     *
+     * After opening a session, use the session token for subsequent requests
+     * within the same session.
+     *
+     * @param sessionToken - The session token from an active MPP session
+     * @returns Headers object with `MPP-SESSION-TOKEN`
+     */
+    buildSessionHeaders(sessionToken: string): Record<string, string>;
+    /**
+     * Top up MPP balance using the specified payment method.
+     *
+     * Requires authentication (wallet credit needs a user account).
+     *
+     * @param amountCents - Amount to top up in cents (must be > 0 and <= 2,147,483,647)
+     * @param method - Payment method: "tempo", "stripe_spt", or "lightning"
+     */
+    topUp(amountCents: number, method: "tempo" | "stripe_spt" | "lightning"): Promise<MppTopUpResponse>;
+    /**
+     * Open a new micropayment session channel.
+     *
+     * This endpoint does not require authentication -- anonymous agents can
+     * open sessions by providing a payment method and deposit.
+     *
+     * @param opts.maxDepositCents - Maximum deposit for the session in cents
+     * @param opts.method - Payment method identifier
+     * @param opts.poolType - Proxy pool type (e.g. "dc", "residential")
+     */
+    openSession(opts: {
+        maxDepositCents: number;
+        method: string;
+        poolType: string;
+    }): Promise<MppSessionResponse>;
+    /**
+     * Close an active micropayment session channel.
+     * Any unused deposit is refunded.
+     *
+     * @param channelId - The channel ID to close
+     */
+    closeSession(channelId: string): Promise<MppCloseResponse>;
+    /**
+     * Get the status of a micropayment session channel.
+     *
+     * @param channelId - The channel ID to query
+     */
+    getSession(channelId: string): Promise<MppSessionStatus>;
+}

package/dist/esm/resources/mpp.js

@@ -0,0 +1,128 @@
+/** IETF MPP auth scheme name (official spec) */
+export const MPP_AUTH_SCHEME = "Payment";
+/** Legacy auth scheme name (backward compat) */
+export const MPP_AUTH_SCHEME_LEGACY = "MPP";
+/**
+ * Micropayment Payment Protocol (MPP) resource.
+ *
+ * Provides pay-per-use proxy sessions with real-time micropayment channels.
+ * Supports multiple payment methods: Tempo streaming, Stripe SPT, and Lightning.
+ *
+ * MPP also enables keyless proxy access for AI agents: call `getChallenge()` to
+ * obtain a credential, then use `buildProxyHeaders()` to construct the proxy
+ * Authorization header -- no API key needed.
+ */
+export class MppResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * Get MPP protocol information including supported methods, pricing, and limits.
+     *
+     * This endpoint does not require authentication.
+     */
+    async getInfo() {
+        return this.http.get("/api/mpp/info", false);
+    }
+    /**
+     * Request an MPP challenge for keyless proxy access.
+     *
+     * This endpoint does not require authentication. The returned credential
+     * can be used with `buildProxyHeaders()` to access the proxy without an API key.
+     *
+     * @param poolType - Proxy pool type: "dc" (datacenter, $3/GB) or "residential" ($5/GB)
+     */
+    async getChallenge(poolType) {
+        if (poolType !== "dc" && poolType !== "residential") {
+            throw new Error("poolType must be 'dc' or 'residential'");
+        }
+        return this.http.post("/api/mpp/challenge", { poolType }, false);
+    }
+    /**
+     * Build proxy Authorization header for keyless MPP access.
+     *
+     * Returns headers that should be set on the HTTP CONNECT / proxy request
+     * to route through the proxy without an API key.
+     *
+     * @param credential - The credential payload from `getChallenge()`
+     * @returns Headers object with `Authorization: MPP <json>`
+     */
+    buildProxyHeaders(credential) {
+        return {
+            Authorization: MPP_AUTH_SCHEME + " " + JSON.stringify(credential),
+        };
+    }
+    /**
+     * Build proxy session token header for ongoing MPP sessions.
+     *
+     * After opening a session, use the session token for subsequent requests
+     * within the same session.
+     *
+     * @param sessionToken - The session token from an active MPP session
+     * @returns Headers object with `MPP-SESSION-TOKEN`
+     */
+    buildSessionHeaders(sessionToken) {
+        if (!sessionToken || typeof sessionToken !== "string") {
+            throw new Error("sessionToken must be a non-empty string");
+        }
+        return {
+            "MPP-SESSION-TOKEN": sessionToken,
+        };
+    }
+    /**
+     * Top up MPP balance using the specified payment method.
+     *
+     * Requires authentication (wallet credit needs a user account).
+     *
+     * @param amountCents - Amount to top up in cents (must be > 0 and <= 2,147,483,647)
+     * @param method - Payment method: "tempo", "stripe_spt", or "lightning"
+     */
+    async topUp(amountCents, method) {
+        if (!Number.isInteger(amountCents) ||
+            amountCents <= 0 ||
+            amountCents > 2_147_483_647) {
+            throw new Error("amountCents must be a positive integer <= 2,147,483,647");
+        }
+        return this.http.post("/api/mpp/topup", { amountCents, method });
+    }
+    /**
+     * Open a new micropayment session channel.
+     *
+     * This endpoint does not require authentication -- anonymous agents can
+     * open sessions by providing a payment method and deposit.
+     *
+     * @param opts.maxDepositCents - Maximum deposit for the session in cents
+     * @param opts.method - Payment method identifier
+     * @param opts.poolType - Proxy pool type (e.g. "dc", "residential")
+     */
+    async openSession(opts) {
+        if (!Number.isInteger(opts.maxDepositCents) ||
+            opts.maxDepositCents <= 0 ||
+            opts.maxDepositCents > 2_147_483_647) {
+            throw new Error("maxDepositCents must be a positive integer <= 2,147,483,647");
+        }
+        return this.http.post("/api/mpp/session/open", {
+            maxDepositCents: opts.maxDepositCents,
+            method: opts.method,
+            poolType: opts.poolType,
+        }, false);
+    }
+    /**
+     * Close an active micropayment session channel.
+     * Any unused deposit is refunded.
+     *
+     * @param channelId - The channel ID to close
+     */
+    async closeSession(channelId) {
+        return this.http.post("/api/mpp/session/close", { channelId });
+    }
+    /**
+     * Get the status of a micropayment session channel.
+     *
+     * @param channelId - The channel ID to query
+     */
+    async getSession(channelId) {
+        return this.http.get(`/api/mpp/session/${encodeURIComponent(channelId)}`);
+    }
+}

package/dist/esm/resources/teams.js

@@ -22,7 +22,9 @@ export class TeamsResource {
         return this.http.delete(`/api/teams/${encodeURIComponent(teamId)}`);
     }
     async fundWallet(teamId, amountCents) {
-        if (!Number.isInteger(amountCents) || amountCents <= 0 || amountCents > 2_147_483_647) {
+        if (!Number.isInteger(amountCents) ||
+            amountCents <= 0 ||
+            amountCents > 2_147_483_647) {
             throw new Error("amountCents must be a positive integer <= 2,147,483,647");
         }
         return this.http.post(`/api/teams/${encodeURIComponent(teamId)}/wallet/fund`, { amountCents });
@@ -67,7 +69,9 @@ export class TeamsResource {
         return this.http.post(`/api/teams/invites/${encodeURIComponent(token)}/accept`, {});
     }
     async createKey(teamId, label) {
-        return this.http.post(`/api/teams/${encodeURIComponent(teamId)}/keys`, { label });
+        return this.http.post(`/api/teams/${encodeURIComponent(teamId)}/keys`, {
+            label,
+        });
     }
     async listKeys(teamId) {
         return this.http.get(`/api/teams/${encodeURIComponent(teamId)}/keys`);