@hainiva/agent-sdk 0.0.0-stage → 0.3.0

package/dist/cjs/reactNativeDesk.cjs

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deskBridgeScript = deskBridgeScript;
+exports.deliverScript = deliverScript;
+exports.HainivaDesk = HainivaDesk;
+/**
+ * `<HainivaDesk/>` — the HAINIVA desk inside your React Native app.
+ *
+ *   import { WebView } from "react-native-webview";
+ *   import { HainivaDesk } from "@hainiva/agent-sdk/react-native";
+ *
+ *   <HainivaDesk agent={agent} appId={APP_ID} baseUrl="https://app.hainiva.com"
+ *     onDial={(number, contactId) => placeNativeCall(number, contactId)}
+ *     onEnded={(reason) => goToSignIn(reason)} />
+ *
+ * The split is the HAINIVA Agent app's: YOUR app rings and carries call audio
+ * natively (@hainiva/react-native-call + this SDK's CallStore); the desk shows
+ * the work and hands calls to you (`onDial`, `onDialer`).
+ *
+ * Security:
+ *   - `originWhitelist` and `onShouldStartLoadWithRequest` keep the WebView on
+ *     the HAINIVA desk origin; any other URL is refused there (and offered to
+ *     `onOpenUrl`, if you pass one);
+ *   - no window.open passthrough (`setSupportMultipleWindows={false}`,
+ *     `javaScriptCanOpenWindowsAutomatically={false}`);
+ *   - the bridge is installed before the desk's scripts and ONLY when the page
+ *     is on the desk origin; the desk token goes in by injectJavaScript, never
+ *     in the URL, and is not written to storage.
+ */
+const React = require("react");
+const embed_js_1 = require("./embed.cjs");
+/** Runs before the desk's scripts, on the desk origin only: the partner-rn bridge the desk looks for. */
+function deskBridgeScript(deskOrigin, appId) {
+    return `(function(){if(location.origin!==${JSON.stringify(deskOrigin)})return;`
+        + `window.__HAINIVA_EMBED__={host:"partner-rn",appId:${JSON.stringify(appId.toLowerCase())},q:[],deliver:function(s){this.q.push(String(s));}};})();true;`;
+}
+/** A message to the desk, as a script: JSON twice (a string literal of the JSON), nothing interpolated raw. */
+function deliverScript(m) {
+    return `window.__HAINIVA_EMBED__&&window.__HAINIVA_EMBED__.deliver(${JSON.stringify(JSON.stringify(m))});true;`;
+}
+function defaultWebView() {
+    const mod = require("react-native-webview");
+    const W = mod.WebView ?? mod.default;
+    if (!W)
+        throw new Error("@hainiva/agent-sdk: install react-native-webview (or pass the WebView prop) to use <HainivaDesk/>");
+    return W;
+}
+function HainivaDesk(props) {
+    const url = React.useMemo(() => (0, embed_js_1.deskUrl)(props.baseUrl, props.appId, props.allowInsecureLocalhost ? { allowInsecureLocalhost: true } : {}), [props.baseUrl, props.appId, props.allowInsecureLocalhost]);
+    const origin = url.origin;
+    const web = React.useRef(null);
+    const latest = React.useRef(props);
+    latest.current = props;
+    const host = React.useMemo(() => new embed_js_1.DeskHost(props.appId, props.agent, (m) => web.current?.injectJavaScript(deliverScript(m)), {
+        onDial: (n, c) => latest.current.onDial?.(n, c),
+        onDialer: (p) => latest.current.onDialer?.(p),
+        onEnded: (r) => latest.current.onEnded?.(r),
+        onOpenUrl: (u) => latest.current.onOpenUrl?.(u),
+        onMediaError: (n) => latest.current.onMediaError?.(n),
+    }), 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [props.appId, props.agent, origin]);
+    React.useEffect(() => { if (props.theme && host.isReady)
+        host.setTheme(props.theme); }, [props.theme, host]);
+    React.useEffect(() => { if (props.locale && host.isReady)
+        host.setLocale(props.locale); }, [props.locale, host]);
+    // Unmounted: the desk drops its token.
+    React.useEffect(() => () => { if (!host.isEnded)
+        web.current?.injectJavaScript(deliverScript({ v: 1, type: "hainiva:end" })); }, [host]);
+    const W = props.WebView ?? defaultWebView();
+    return React.createElement(W, {
+        ref: web,
+        source: { uri: url.href },
+        style: props.style,
+        originWhitelist: [origin],
+        injectedJavaScriptBeforeContentLoaded: deskBridgeScript(origin, props.appId),
+        onMessage: (e) => {
+            // Only from the desk origin (a page elsewhere never gets the bridge, and is refused below anyway).
+            const from = e.nativeEvent.url;
+            if (typeof from === "string" && !from.startsWith(`${origin}/`))
+                return;
+            const wasReady = host.isReady;
+            host.receive(e.nativeEvent.data);
+            if (!wasReady && host.isReady) {
+                if (latest.current.theme)
+                    host.setTheme(latest.current.theme);
+                if (latest.current.locale)
+                    host.setLocale(latest.current.locale);
+            }
+        },
+        onShouldStartLoadWithRequest: (r) => {
+            if (r.url === "about:blank" || r.url.startsWith(`${origin}/`) || r.url.startsWith("blob:") || r.url.startsWith("data:"))
+                return true;
+            latest.current.onOpenUrl?.(r.url);
+            return false;
+        },
+        setSupportMultipleWindows: false,
+        javaScriptCanOpenWindowsAutomatically: false,
+        allowFileAccess: false,
+        allowUniversalAccessFromFileURLs: false,
+        mixedContentMode: "never",
+        domStorageEnabled: true,
+        sharedCookiesEnabled: false,
+        thirdPartyCookiesEnabled: false,
+        mediaPlaybackRequiresUserAction: false,
+    });
+}

package/dist/cjs/reactNativeDesk.d.cts

@@ -0,0 +1,53 @@
+/**
+ * `<HainivaDesk/>` — the HAINIVA desk inside your React Native app.
+ *
+ *   import { WebView } from "react-native-webview";
+ *   import { HainivaDesk } from "@hainiva/agent-sdk/react-native";
+ *
+ *   <HainivaDesk agent={agent} appId={APP_ID} baseUrl="https://app.hainiva.com"
+ *     onDial={(number, contactId) => placeNativeCall(number, contactId)}
+ *     onEnded={(reason) => goToSignIn(reason)} />
+ *
+ * The split is the HAINIVA Agent app's: YOUR app rings and carries call audio
+ * natively (@hainiva/react-native-call + this SDK's CallStore); the desk shows
+ * the work and hands calls to you (`onDial`, `onDialer`).
+ *
+ * Security:
+ *   - `originWhitelist` and `onShouldStartLoadWithRequest` keep the WebView on
+ *     the HAINIVA desk origin; any other URL is refused there (and offered to
+ *     `onOpenUrl`, if you pass one);
+ *   - no window.open passthrough (`setSupportMultipleWindows={false}`,
+ *     `javaScriptCanOpenWindowsAutomatically={false}`);
+ *   - the bridge is installed before the desk's scripts and ONLY when the page
+ *     is on the desk origin; the desk token goes in by injectJavaScript, never
+ *     in the URL, and is not written to storage.
+ */
+import * as React from "react";
+import { type DeskCallbacks, type DeskTokenSource, type HostToDesk } from "./embed.cjs";
+/** The parts of react-native-webview's WebView this component uses. */
+export interface WebViewLike {
+    injectJavaScript(script: string): void;
+}
+type WebViewComponent = React.ComponentType<Record<string, unknown> & {
+    ref?: React.Ref<WebViewLike>;
+}>;
+export interface HainivaDeskProps extends DeskCallbacks {
+    agent: DeskTokenSource;
+    appId: string;
+    /** The HAINIVA desk, e.g. https://app.hainiva.com. */
+    baseUrl: string;
+    theme?: "light" | "dark";
+    locale?: "vi" | "en";
+    /** react-native-webview's WebView. Default: required from "react-native-webview". */
+    WebView?: WebViewComponent;
+    /** Passed to the WebView. */
+    style?: unknown;
+    /** Local development only (http://localhost desk). */
+    allowInsecureLocalhost?: boolean;
+}
+/** Runs before the desk's scripts, on the desk origin only: the partner-rn bridge the desk looks for. */
+export declare function deskBridgeScript(deskOrigin: string, appId: string): string;
+/** A message to the desk, as a script: JSON twice (a string literal of the JSON), nothing interpolated raw. */
+export declare function deliverScript(m: HostToDesk): string;
+export declare function HainivaDesk(props: HainivaDeskProps): React.ReactElement;
+export {};

package/dist/cjs/redact.cjs

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * Redaction: no token, assertion or secret may leave the SDK in an error message,
+ * a log line or an event. Two layers:
+ *  - patterns that catch credentials by shape (JWTs, Bearer headers, token query
+ *    parameters, HAINIVA key prefixes), always on;
+ *  - a Redactor that also knows the exact secrets this client holds right now
+ *    (the current access and refresh tokens), so even an opaque token is caught.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Redactor = void 0;
+exports.redactString = redactString;
+exports.redactValue = redactValue;
+const PATTERNS = [
+    // JWT / JWS / JWE (assertions, access tokens, LiveKit tokens).
+    [/eyJ[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]{4,}(?:\.[A-Za-z0-9_-]*){1,3}/g, "[redacted-jwt]"],
+    // Authorization header values.
+    [/\b(Bearer|Basic|Token)\s+[A-Za-z0-9._~+/=-]{8,}/gi, "$1 [redacted]"],
+    // Credentials in a query string.
+    [/([?&#](?:access_token|refresh_token|id_token|token|assertion|ticket|api_key|apikey|key|secret|signature|sig|password)=)[^&#\s"']+/gi, "$1[redacted]"],
+    // HAINIVA API keys and refresh tokens by prefix.
+    [/\b(aicc_(?:live|test)_|hnv_|agr_|apr_)[A-Za-z0-9_-]{6,}/g, "$1[redacted]"],
+];
+/** Object keys whose values are never shown. */
+const SENSITIVE_KEY = /token|assertion|secret|password|passwd|authori[sz]ation|cookie|refresh|jwt|signature|api[-_]?key|private[-_]?key|credential/i;
+/** Redact credential-shaped substrings. */
+function redactString(s, known = []) {
+    let out = s;
+    for (const k of known)
+        if (k && k.length >= 8)
+            out = out.split(k).join("[redacted]");
+    for (const [re, by] of PATTERNS)
+        out = out.replace(re, by);
+    return out;
+}
+/** A deep copy with credentials removed: sensitive keys blanked, strings scrubbed, Errors flattened. */
+function redactValue(v, known = [], depth = 0) {
+    const list = [...known];
+    if (typeof v === "string")
+        return redactString(v, list);
+    if (v === null || typeof v !== "object")
+        return v;
+    if (depth > 6)
+        return "[truncated]";
+    if (v instanceof Error) {
+        return { name: v.name, message: redactString(v.message, list), ...(v.stack ? { stack: redactString(v.stack, list) } : {}) };
+    }
+    if (Array.isArray(v))
+        return v.slice(0, 100).map((x) => redactValue(x, list, depth + 1));
+    const out = {};
+    for (const [k, x] of Object.entries(v)) {
+        out[k] = SENSITIVE_KEY.test(k) && x !== null && x !== undefined && x !== "" ? "[redacted]" : redactValue(x, list, depth + 1);
+    }
+    return out;
+}
+/** Knows the secrets one client holds right now, on top of the patterns. */
+class Redactor {
+    constructor() {
+        this.secrets = new Set();
+    }
+    add(...secrets) { for (const s of secrets)
+        if (s)
+            this.secrets.add(s); }
+    remove(...secrets) { for (const s of secrets)
+        if (s)
+            this.secrets.delete(s); }
+    clear() { this.secrets.clear(); }
+    string(s) { return redactString(s, this.secrets); }
+    value(v) { return redactValue(v, this.secrets); }
+}
+exports.Redactor = Redactor;

package/dist/cjs/redact.d.cts

@@ -0,0 +1,21 @@
+/**
+ * Redaction: no token, assertion or secret may leave the SDK in an error message,
+ * a log line or an event. Two layers:
+ *  - patterns that catch credentials by shape (JWTs, Bearer headers, token query
+ *    parameters, HAINIVA key prefixes), always on;
+ *  - a Redactor that also knows the exact secrets this client holds right now
+ *    (the current access and refresh tokens), so even an opaque token is caught.
+ */
+/** Redact credential-shaped substrings. */
+export declare function redactString(s: string, known?: Iterable<string>): string;
+/** A deep copy with credentials removed: sensitive keys blanked, strings scrubbed, Errors flattened. */
+export declare function redactValue(v: unknown, known?: Iterable<string>, depth?: number): unknown;
+/** Knows the secrets one client holds right now, on top of the patterns. */
+export declare class Redactor {
+    private readonly secrets;
+    add(...secrets: (string | null | undefined)[]): void;
+    remove(...secrets: (string | null | undefined)[]): void;
+    clear(): void;
+    string(s: string): string;
+    value(v: unknown): unknown;
+}

package/dist/cjs/rest.cjs

@@ -0,0 +1,286 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentRestClient = void 0;
+exports.newIdempotencyKey = newIdempotencyKey;
+exports.errorFromResponse = errorFromResponse;
+const errors_js_1 = require("./errors.cjs");
+const log_js_1 = require("./log.cjs");
+const redact_js_1 = require("./redact.cjs");
+const url_js_1 = require("./url.cjs");
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const TENANT = /^[A-Za-z0-9_-]{1,64}$/;
+/** A random UUID v4: crypto.randomUUID where it exists (browsers, Node), else getRandomValues, else Math.random (Idempotency-Key only, not a secret). */
+function newIdempotencyKey() {
+    const c = globalThis.crypto;
+    if (c?.randomUUID)
+        return c.randomUUID();
+    const b = new Uint8Array(16);
+    if (c?.getRandomValues)
+        c.getRandomValues(b);
+    else
+        for (let i = 0; i < 16; i++)
+            b[i] = Math.floor(Math.random() * 256);
+    b[6] = (b[6] & 0x0f) | 0x40;
+    b[8] = (b[8] & 0x3f) | 0x80;
+    const h = [...b].map((x) => x.toString(16).padStart(2, "0")).join("");
+    return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
+}
+/** An id that goes into a path: a UUID, or the request is refused before it leaves (no path tricks). */
+function id(v, what) {
+    if (typeof v !== "string" || !UUID.test(v))
+        throw new errors_js_1.HainivaAgentError(0, "invalid_id", { field: what });
+    return v.toLowerCase();
+}
+function isObject(v) {
+    return !!v && typeof v === "object" && !Array.isArray(v);
+}
+/** Pure: the error a non-2xx answer becomes. Exported for tests. */
+function errorFromResponse(status, data, redactor, retryAfter) {
+    const e = isObject(data) ? data["error"] : undefined;
+    let code = status === 401 ? "unauthorized" : status === 403 ? "forbidden" : status === 404 ? "not_found" : status === 409 ? "conflict" : status === 429 ? "rate_limited" : status >= 500 ? "server_error" : "invalid_request";
+    let message;
+    if (isObject(e)) {
+        if (typeof e["code"] === "string" && e["code"])
+            code = e["code"].slice(0, 80);
+        if (typeof e["message"] === "string")
+            message = e["message"].slice(0, 500);
+    }
+    else if (typeof e === "string") {
+        message = e.slice(0, 500);
+    }
+    const body = {};
+    if (message)
+        body["message"] = message;
+    if (retryAfter && /^\d{1,6}$/.test(retryAfter))
+        body["retryAfterSec"] = Number(retryAfter);
+    return new errors_js_1.HainivaAgentError(status, code, body, redactor);
+}
+/**
+ * The Agent API over fetch. `tokens` is normally the SessionManager; the
+ * client's own `sessions` transport is what that SessionManager signs in with.
+ */
+class AgentRestClient {
+    constructor(o, tokens) {
+        this.o = o;
+        // ── Sessions (the SessionManager's transport) ───────────────────────────────
+        this.sessions = {
+            exchange: (assertion) => this.raw("POST", "/agent/v1/sessions", {
+                body: { tenantId: this.o.tenantId, assertion, ...(this.o.device ? { device: this.o.device } : {}) },
+            }, null).then((s) => s),
+            refresh: (refreshToken) => this.raw("POST", "/agent/v1/sessions/refresh", {
+                body: { tenantId: this.o.tenantId, refreshToken },
+            }, null).then((s) => s),
+            revoke: async (session) => {
+                await this.raw("DELETE", "/agent/v1/sessions/current", {}, session.accessToken);
+            },
+        };
+        const u = (0, url_js_1.assertSafeUrl)(o.baseUrl, { kind: "http", ...(o.allowInsecureLocalhost ? { allowInsecureLocalhost: true } : {}) });
+        if (u.search || u.hash)
+            throw new errors_js_1.HainivaAgentError(0, "invalid_url", { hint: "baseUrl takes no query or fragment" });
+        if (typeof o.tenantId !== "string" || !TENANT.test(o.tenantId))
+            throw new errors_js_1.HainivaAgentError(0, "invalid_tenant_id");
+        this.baseUrl = u.origin + u.pathname.replace(/\/+$/, "");
+        const f = o.fetch ?? globalThis.fetch;
+        if (!f)
+            throw new errors_js_1.HainivaAgentError(0, "no_fetch", { hint: "pass options.fetch" });
+        this.fetchFn = f.bind(globalThis);
+        this.timeoutMs = o.timeoutMs ?? 15000;
+        this.redactor = o.redactor ?? new redact_js_1.Redactor();
+        this.log = (0, log_js_1.safeLogger)(o.log, this.redactor);
+        this.tokens = tokens ?? null;
+    }
+    /** Attach the token source after construction (the SessionManager needs `sessions` first). */
+    useTokens(tokens) { this.tokens = tokens; }
+    /** The wss:// URL of the event stream, derived from baseUrl (never from a server answer). */
+    get wsUrl() {
+        return `${this.baseUrl.replace(/^http/, "ws")}/agent/v1/ws`;
+    }
+    // ── The generic request ─────────────────────────────────────────────────────
+    /** An authenticated request: refresh-and-retry once on an expired token. */
+    async request(method, path, opts = {}) {
+        if (!this.tokens)
+            throw new errors_js_1.HainivaAgentError(0, "not_signed_in");
+        const idem = method === "POST" ? newIdempotencyKey() : undefined;
+        const token = await this.tokens.accessToken();
+        try {
+            return await this.raw(method, path, opts, token, idem);
+        }
+        catch (e) {
+            if (!(e instanceof errors_js_1.HainivaAgentError) || e.status !== 401 || (e.code !== "token_expired" && e.code !== "token_invalid"))
+                throw e;
+            this.log("access_token_refused", { code: e.code });
+            this.tokens.invalidate(token);
+            const next = await this.tokens.accessToken();
+            return this.raw(method, path, opts, next, idem);
+        }
+    }
+    async raw(method, path, opts, token, idem) {
+        let url = `${this.baseUrl}${path}`;
+        if (opts.query) {
+            const q = new URLSearchParams();
+            for (const [k, v] of Object.entries(opts.query))
+                if (v !== undefined && v !== "")
+                    q.set(k, String(v));
+            const s = q.toString();
+            if (s)
+                url += `?${s}`;
+        }
+        const headers = { accept: "application/json" };
+        if (token) {
+            this.redactor.add(token);
+            headers["authorization"] = `Bearer ${token}`;
+        }
+        if (idem)
+            headers["idempotency-key"] = idem;
+        let body;
+        if (opts.body !== undefined) {
+            headers["content-type"] = "application/json";
+            body = JSON.stringify(opts.body);
+        }
+        const ctl = new AbortController();
+        const timeout = opts.timeoutMs ?? this.timeoutMs;
+        let timedOut = false;
+        const timer = setTimeout(() => { timedOut = true; ctl.abort(); }, timeout);
+        const onAbort = () => ctl.abort();
+        if (opts.signal) {
+            if (opts.signal.aborted) {
+                clearTimeout(timer);
+                throw new errors_js_1.HainivaAgentError(0, "aborted");
+            }
+            opts.signal.addEventListener("abort", onAbort, { once: true });
+        }
+        let res;
+        try {
+            res = await this.fetchFn(url, { method, headers, ...(body !== undefined ? { body } : {}), signal: ctl.signal });
+        }
+        catch (e) {
+            if (timedOut)
+                throw new errors_js_1.HainivaAgentError(0, "timeout", { timeoutMs: timeout });
+            if (opts.signal?.aborted)
+                throw new errors_js_1.HainivaAgentError(0, "aborted");
+            throw errors_js_1.HainivaAgentError.from(e, "network_error", this.redactor);
+        }
+        finally {
+            clearTimeout(timer);
+            opts.signal?.removeEventListener("abort", onAbort);
+        }
+        if (res.status === 204)
+            return undefined;
+        let data = null;
+        const text = await res.text().catch(() => "");
+        if (text) {
+            try {
+                data = JSON.parse(text);
+            }
+            catch {
+                data = null;
+            }
+        }
+        if (!res.ok)
+            throw errorFromResponse(res.status, data, this.redactor, res.headers?.get?.("retry-after") ?? null);
+        if (data === null || typeof data !== "object")
+            throw new errors_js_1.HainivaAgentError(res.status, "invalid_response", {}, this.redactor);
+        return data;
+    }
+    // ── Me ──────────────────────────────────────────────────────────────────────
+    async me(o) { return this.request("GET", "/agent/v1/me", o); }
+    async setStatus(status, o) {
+        return this.request("PUT", "/agent/v1/me/status", { ...o, body: { status } });
+    }
+    /** Rings for this member now (after a cold start, a missed push or a resync). */
+    async pendingRings(o) {
+        const r = await this.request("GET", "/agent/v1/rings/pending", o);
+        return Array.isArray(r.data) ? r.data : [];
+    }
+    // ── Calls ───────────────────────────────────────────────────────────────────
+    async getCall(callId, o) { return this.request("GET", `/agent/v1/calls/${id(callId, "callId")}`, o); }
+    async acceptCall(callId, o) { return this.request("POST", `/agent/v1/calls/${id(callId, "callId")}/accept`, { ...o, body: {} }); }
+    async declineCall(callId, o) { return this.request("POST", `/agent/v1/calls/${id(callId, "callId")}/decline`, { ...o, body: {} }); }
+    async endCall(callId, o) { return this.request("POST", `/agent/v1/calls/${id(callId, "callId")}/end`, { ...o, body: {} }); }
+    async holdCall(callId, on, o) {
+        return this.request("POST", `/agent/v1/calls/${id(callId, "callId")}/hold`, { ...o, body: { on } });
+    }
+    async transferCall(callId, target, o) {
+        let body;
+        if ("agentId" in target)
+            body = { targetAgentId: id(target.agentId, "agentId"), mode: target.mode ?? "warm" };
+        else if ("queueId" in target)
+            body = { queueId: id(target.queueId, "queueId") };
+        else
+            body = { number: target.number, mode: target.mode ?? "warm" };
+        return this.request("POST", `/agent/v1/calls/${id(callId, "callId")}/transfer`, { ...o, body });
+    }
+    /**
+     * A 15-minute desk token for the embedded HAINIVA desk (S4): give it to the
+     * desk over postMessage only (`@hainiva/agent-sdk/embed` does). Never put it
+     * in a URL or storage. Ends with this session.
+     */
+    async deskSession(o) { return this.request("POST", "/agent/v1/desk-session", { ...o, body: {} }); }
+    /** Re-mint the LiveKit token while still a participant (reconnect, token near expiry). */
+    async mediaToken(callId, o) { return this.request("POST", `/agent/v1/calls/${id(callId, "callId")}/media-token`, { ...o, body: {} }); }
+    // ── Wrap-up ─────────────────────────────────────────────────────────────────
+    async dispositions(channel, o) {
+        const r = await this.request("GET", "/agent/v1/dispositions", { ...o, ...(channel ? { query: { channel } } : {}) });
+        return Array.isArray(r.data) ? r.data : [];
+    }
+    async wrapUp(callId, w = {}, o) {
+        return this.request("POST", `/agent/v1/calls/${id(callId, "callId")}/wrapup`, { ...o, body: w });
+    }
+    // ── Conversations and messages ──────────────────────────────────────────────
+    async listConversations(q = {}, o) {
+        return this.request("GET", "/agent/v1/conversations", { ...o, query: { scope: q.scope, status: q.status, cursor: q.cursor, limit: q.limit } }).then((page));
+    }
+    async getConversation(conversationId, o) {
+        return this.request("GET", `/agent/v1/conversations/${id(conversationId, "conversationId")}`, o);
+    }
+    /** Claim it (no agentId), or — a supervisor — assign it to a colleague. */
+    async assignConversation(conversationId, agentId, o) {
+        return this.request("POST", `/agent/v1/conversations/${id(conversationId, "conversationId")}/assign`, { ...o, body: agentId ? { agentId: id(agentId, "agentId") } : {} });
+    }
+    async releaseConversation(conversationId, note, o) {
+        return this.request("POST", `/agent/v1/conversations/${id(conversationId, "conversationId")}/release`, { ...o, body: note ? { note } : {} });
+    }
+    async transferConversation(conversationId, to, o) {
+        const body = "agentId" in to ? { agentId: id(to.agentId, "agentId") } : { queueId: id(to.queueId, "queueId"), ...(to.note ? { note: to.note } : {}) };
+        return this.request("POST", `/agent/v1/conversations/${id(conversationId, "conversationId")}/transfer`, { ...o, body });
+    }
+    async closeConversation(conversationId, o) {
+        return this.request("POST", `/agent/v1/conversations/${id(conversationId, "conversationId")}/close`, { ...o, body: {} });
+    }
+    async listMessages(conversationId, q = {}, o) {
+        return this.request("GET", `/agent/v1/conversations/${id(conversationId, "conversationId")}/messages`, { ...o, query: { after: q.after, limit: q.limit } }).then((page));
+    }
+    async sendMessage(conversationId, text, o) {
+        return this.request("POST", `/agent/v1/conversations/${id(conversationId, "conversationId")}/messages`, { ...o, body: { text } });
+    }
+    async typing(conversationId, o) {
+        return this.request("POST", `/agent/v1/conversations/${id(conversationId, "conversationId")}/typing`, { ...o, body: {} });
+    }
+    // ── Supervisor ──────────────────────────────────────────────────────────────
+    async liveCalls(o) {
+        const r = await this.request("GET", "/agent/v1/supervisor/live-calls", o);
+        return Array.isArray(r.data) ? r.data : [];
+    }
+    async teamAgents(o) {
+        const r = await this.request("GET", "/agent/v1/supervisor/agents", o);
+        return Array.isArray(r.data) ? r.data : [];
+    }
+    async supervise(callId, mode = "monitor", o) {
+        return this.request("POST", `/agent/v1/supervisor/calls/${id(callId, "callId")}/supervise`, { ...o, body: { mode } });
+    }
+    async setSuperviseMode(callId, mode, supervisorTrackSid, o) {
+        return this.request("PUT", `/agent/v1/supervisor/calls/${id(callId, "callId")}/supervise-mode`, { ...o, body: { mode, ...(supervisorTrackSid ? { supervisorTrackSid } : {}) } });
+    }
+    // ── Push (your app's own FCM / APNs credentials, uploaded by your admin) ─────
+    async registerPush(sub, o) {
+        return this.request("POST", "/agent/v1/push/subscriptions", { ...o, body: sub });
+    }
+    async unregisterPush(token, o) {
+        await this.request("DELETE", "/agent/v1/push/subscriptions", { ...o, body: { token } });
+    }
+}
+exports.AgentRestClient = AgentRestClient;
+function page(r) {
+    const x = isObject(r) ? r : {};
+    return { data: Array.isArray(x["data"]) ? x["data"] : [], nextCursor: typeof x["nextCursor"] === "string" ? x["nextCursor"] : null };
+}