@babelforce/babelconnect-sdk 0.1.0

package/dist/client.js

@@ -0,0 +1,322 @@
+import { createClient } from "@connectrpc/connect";
+import { createGrpcWebTransport } from "@connectrpc/connect-web";
+import { Agent } from "./gen/babelconnect/v1/babelconnect_connect.js";
+import { AddConferenceMember, AnswerCall, CallDirection, CallLifecycle, CallSource, Command, EndConference, Error as BcError, FlagRecording, Hangup, HistoryRequest, SmsThreadRequest, PhonebookRequest, HoldConferenceMember, Hold, KickConferenceMember, LeaveConference, MarkConversationRead, Mute, MuteConferenceMember, PlaceCall, Register, ResetLineStatus, SendDigits, SendSmsRequest, SetAgentNumber, SetConversationOpen, SetDisplayAs, SetPresence, SetWebrtc, StartConference, StartRecording, StopRecording, SetRecordingTags, SubscribeRequest, Transfer, WrapUpCancel, WrapUpExtend, } from "./gen/babelconnect/v1/babelconnect_pb.js";
+import { browserMediaFactory, toRTCIceServers } from "./media.js";
+import { StateCache } from "./state-cache.js";
+/**
+ * The TypeScript "dumb renderer" client: opens the `Subscribe`/`Send` gRPC-web
+ * split, mirrors the server's `AgentView` in a {@link StateCache}, exposes typed
+ * intent senders, and drives a pluggable WebRTC {@link Media} leg. UI binds to
+ * {@link subscribe} and dispatches intents — no call/agent logic lives here.
+ */
+export class BabelconnectClient {
+    opts;
+    rpc;
+    cache = new StateCache();
+    media = new Map();
+    answering = new Set();
+    abort = new AbortController();
+    ready = false;
+    pending = [];
+    closed = false;
+    constructor(opts) {
+        this.opts = opts;
+        const transport = createGrpcWebTransport({
+            baseUrl: opts.serverUrl,
+            interceptors: [authInterceptor(opts.token)],
+        });
+        this.rpc = createClient(Agent, transport);
+    }
+    /** Open the session and start mirroring server state. */
+    static connect(opts) {
+        const c = new BabelconnectClient(opts);
+        void c.runSubscribe();
+        return c;
+    }
+    /** The current view (deep copy). */
+    get view() {
+        return this.cache.current;
+    }
+    /** Register a render callback (fired immediately and on every state update). Returns an unsubscribe fn. */
+    subscribe(fn) {
+        return this.cache.subscribe(fn);
+    }
+    /** The first active call, or undefined. */
+    activeCall() {
+        return this.cache.current.activeCalls[0];
+    }
+    // --- intents ---
+    register(capabilities = ["webrtc"]) {
+        this.send(new Command({ command: { case: "register", value: new Register({ capabilities }) } }));
+    }
+    placeCall(to, opts = {}) {
+        this.send(new Command({
+            command: {
+                case: "placeCall",
+                value: new PlaceCall({
+                    to,
+                    displayAsTo: opts.displayAsTo ?? "",
+                    displayAsFrom: opts.displayAsFrom ?? "",
+                    record: opts.record ?? false,
+                    session: opts.session ?? {},
+                }),
+            },
+        }));
+    }
+    /** Manually answer a RINGING call by id (no-op under autoAnswer once already answered). */
+    async answerCall(callId) {
+        const call = this.cache.current.activeCalls.find((c) => c.id === callId);
+        if (call)
+            await this.doAnswer(call);
+    }
+    hangup(callId) {
+        this.send(new Command({ command: { case: "hangup", value: new Hangup({ callId }) } }));
+    }
+    mute(callId, on) {
+        this.send(new Command({ command: { case: "mute", value: new Mute({ callId, on }) } }));
+    }
+    hold(callId, on) {
+        this.send(new Command({ command: { case: "hold", value: new Hold({ callId, on }) } }));
+    }
+    sendDigits(callId, digits) {
+        this.send(new Command({ command: { case: "dtmf", value: new SendDigits({ callId, digits }) } }));
+    }
+    setDisplayAs(number) {
+        this.send(new Command({ command: { case: "setDisplayAs", value: new SetDisplayAs({ number }) } }));
+    }
+    /** Switch presence (the selector): "available" or a configured pause reason (see `AgentInfo.presenceOptions`). */
+    setPresence(name) {
+        this.send(new Command({ command: { case: "setPresence", value: new SetPresence({ name }) } }));
+    }
+    /** Transfer to exactly one of `to` (number), `agentId`, or `applicationId`; `warm` = attended. */
+    transfer(callId, to, opts = {}) {
+        this.send(new Command({
+            command: {
+                case: "transfer",
+                value: new Transfer({
+                    callId,
+                    to,
+                    warm: opts.warm ?? false,
+                    agentId: opts.agentId ?? "",
+                    applicationId: opts.applicationId ?? "",
+                }),
+            },
+        }));
+    }
+    // --- Conferences ---
+    startConference(hold = false) {
+        this.send(new Command({ command: { case: "startConference", value: new StartConference({ hold }) } }));
+    }
+    addConferenceMember(opts) {
+        this.send(new Command({
+            command: {
+                case: "addConferenceMember",
+                value: new AddConferenceMember({ agentId: opts.agentId ?? "", number: opts.number ?? "" }),
+            },
+        }));
+    }
+    kickConferenceMember(memberId) {
+        this.send(new Command({ command: { case: "kickConferenceMember", value: new KickConferenceMember({ memberId }) } }));
+    }
+    holdConferenceMember(memberId, on) {
+        this.send(new Command({ command: { case: "holdConferenceMember", value: new HoldConferenceMember({ memberId, on }) } }));
+    }
+    muteConferenceMember(memberId, on) {
+        this.send(new Command({ command: { case: "muteConferenceMember", value: new MuteConferenceMember({ memberId, on }) } }));
+    }
+    endConference() {
+        this.send(new Command({ command: { case: "endConference", value: new EndConference({}) } }));
+    }
+    leaveConference() {
+        this.send(new Command({ command: { case: "leaveConference", value: new LeaveConference({}) } }));
+    }
+    wrapUpExtend(seconds = 30) {
+        this.send(new Command({ command: { case: "wrapUpExtend", value: new WrapUpExtend({ seconds }) } }));
+    }
+    wrapUpCancel() {
+        this.send(new Command({ command: { case: "wrapUpCancel", value: new WrapUpCancel({}) } }));
+    }
+    resetLineStatus() {
+        this.send(new Command({ command: { case: "resetLineStatus", value: new ResetLineStatus({}) } }));
+    }
+    startRecording(callId) {
+        this.send(new Command({ command: { case: "startRecording", value: new StartRecording({ callId }) } }));
+    }
+    stopRecording(callId) {
+        this.send(new Command({ command: { case: "stopRecording", value: new StopRecording({ callId }) } }));
+    }
+    flagRecording(callId) {
+        this.send(new Command({ command: { case: "flagRecording", value: new FlagRecording({ callId }) } }));
+    }
+    setRecordingTags(callId, tags) {
+        this.send(new Command({ command: { case: "setRecordingTags", value: new SetRecordingTags({ callId, tags }) } }));
+    }
+    setWebrtc(on) {
+        this.send(new Command({ command: { case: "setWebrtc", value: new SetWebrtc({ on }) } }));
+    }
+    setAgentNumber(number) {
+        this.send(new Command({ command: { case: "setAgentNumber", value: new SetAgentNumber({ number }) } }));
+    }
+    /** Send an SMS. `from` may be empty (server picks the default); `session` carries CTI/embedding correlation. */
+    sendSms(to, text, opts = {}) {
+        this.send(new Command({
+            command: {
+                case: "sendSms",
+                value: new SendSmsRequest({ to, text, from: opts.from ?? "", session: opts.session ?? {} }),
+            },
+        }));
+    }
+    /** Open (reopen) or close (resolve) an SMS conversation. */
+    setConversationOpen(conversationId, open) {
+        this.send(new Command({
+            command: { case: "setConversationOpen", value: new SetConversationOpen({ conversationId, open }) },
+        }));
+    }
+    /** Clear the unread count on an SMS conversation (the agent opened its thread). */
+    markConversationRead(conversationId) {
+        this.send(new Command({
+            command: { case: "markConversationRead", value: new MarkConversationRead({ conversationId }) },
+        }));
+    }
+    /** Fetch a page of the agent's call history (the History tab). */
+    async getHistory(max = 50, page = 1) {
+        const resp = await this.rpc.getHistory(new HistoryRequest({ max, page }));
+        return resp.calls;
+    }
+    /** Fetch the messages of one SMS conversation (the chat thread), oldest first. */
+    async getSmsThread(conversationId, max = 50, page = 1) {
+        const resp = await this.rpc.getSmsThread(new SmsThreadRequest({ conversationId, max, page }));
+        return resp.messages;
+    }
+    /**
+     * Re-pull the agent's merged contacts + recent numbers (the Contacts tab) — an
+     * on-demand refresh of the register-time `AgentInfo.phonebook` snapshot.
+     * `query` filters by label/number.
+     */
+    async getPhonebook(max = 200, page = 1, query = "") {
+        const resp = await this.rpc.getPhonebook(new PhonebookRequest({ max, page, query }));
+        return resp.entries;
+    }
+    /** Tear down media legs and the connection. */
+    async close() {
+        this.closed = true;
+        this.abort.abort();
+        await this.closeAllMedia();
+    }
+    // --- internals ---
+    async runSubscribe() {
+        try {
+            for await (const u of this.rpc.subscribe(new SubscribeRequest({}), { signal: this.abort.signal })) {
+                this.onUpdate(u);
+            }
+        }
+        catch (e) {
+            if (!this.closed)
+                this.opts.onError?.(new BcError({ code: "disconnected", message: String(e) }));
+        }
+    }
+    onUpdate(u) {
+        // First message = the snapshot ⇒ the session is registered server-side, so
+        // flush intents queued during connect() (register(), an early dial, …).
+        if (!this.ready) {
+            this.ready = true;
+            const queued = this.pending.splice(0);
+            for (const cmd of queued)
+                void this.rawSend(cmd);
+        }
+        if (u.update.case === "error") {
+            this.opts.onError?.(u.update.value);
+            return;
+        }
+        if (u.update.case === "patch" && u.update.value.change.case === "notification") {
+            this.opts.onNotification?.(u.update.value.change.value);
+            return;
+        }
+        if (this.cache.apply(u))
+            this.opts.onGap?.();
+        this.reconcile();
+    }
+    reconcile() {
+        const present = new Set();
+        const autoAnswer = this.opts.autoAnswer ?? true;
+        for (const call of this.cache.current.activeCalls) {
+            present.add(call.id);
+            // Auto-answer the agent's own dialed OUTBOUND leg. INBOUND calls — and
+            // OUTBOUND *callbacks* (a scheduled call to accept) — wait for answerCall().
+            if (autoAnswer &&
+                call.state === CallLifecycle.RINGING &&
+                call.webrtcOffer !== "" &&
+                call.direction === CallDirection.OUTBOUND &&
+                call.source !== CallSource.CALLBACK) {
+                void this.doAnswer(call);
+            }
+        }
+        for (const [id, m] of this.media) {
+            if (!present.has(id)) {
+                void m.close();
+                this.media.delete(id);
+                this.answering.delete(id);
+            }
+        }
+    }
+    async doAnswer(call) {
+        if (this.answering.has(call.id) || this.media.has(call.id))
+            return;
+        const factory = this.opts.mediaFactory === undefined ? browserMediaFactory : this.opts.mediaFactory;
+        if (!factory) {
+            this.opts.onError?.(new BcError({ code: "no_media", message: "no media factory configured", callId: call.id }));
+            return;
+        }
+        this.answering.add(call.id);
+        try {
+            const media = factory(call.id);
+            // Thread the server-advertised STUN/TURN servers into the peer (off-host NAT
+            // traversal); when none are advertised (in-cluster/LAN) toRTCIceServers returns
+            // undefined so the Media's own fallback applies.
+            const answerSdp = await media.answer(call.webrtcOffer, toRTCIceServers(call.iceServers));
+            this.media.set(call.id, media);
+            this.send(new Command({ command: { case: "answer", value: new AnswerCall({ callId: call.id, sdp: answerSdp }) } }));
+        }
+        catch (e) {
+            this.opts.onError?.(new BcError({ code: "media_answer_failed", message: String(e), callId: call.id }));
+        }
+        finally {
+            this.answering.delete(call.id);
+        }
+    }
+    send(cmd) {
+        if (this.closed)
+            return;
+        // Hold intents until the Subscribe stream is live server-side (first snapshot),
+        // else the unary Send races stream registration and is rejected.
+        if (!this.ready) {
+            this.pending.push(cmd);
+            return;
+        }
+        void this.rawSend(cmd);
+    }
+    async rawSend(cmd) {
+        // Fire-and-forget: a command's RESULT (or rejection) arrives as state / an
+        // Error on the Subscribe stream. Only a transport failure surfaces here.
+        try {
+            await this.rpc.send(cmd);
+        }
+        catch (e) {
+            this.opts.onError?.(new BcError({ code: "send_failed", message: String(e) }));
+        }
+    }
+    async closeAllMedia() {
+        const all = [...this.media.values()];
+        this.media.clear();
+        this.answering.clear();
+        await Promise.all(all.map((m) => m.close()));
+    }
+}
+/** An interceptor that attaches the bearer token to every gRPC-web call. */
+function authInterceptor(token) {
+    return (next) => (req) => {
+        req.header.set("Authorization", `Bearer ${token}`);
+        return next(req);
+    };
+}

package/dist/embed/index.d.ts

@@ -0,0 +1,79 @@
+/**
+ * `@babelforce/babelconnect-sdk/embed` — embed the babelconnect agent app (the
+ * server-served Flutter web app) into a host page via an `<iframe>` and a two-way
+ * `postMessage` bridge. See the Embedding guide at
+ * https://babelforce.github.io/babelconnect-sdk-docs/ for the full protocol.
+ * The embedded app talks only to babelconnect-server.
+ *
+ * @example
+ * ```ts
+ * import { BabelconnectEmbed } from "@babelforce/babelconnect-sdk/embed";
+ * const bc = BabelconnectEmbed.mount({
+ *   container: document.getElementById("bc")!,
+ *   serverUrl: "https://agent.example.com",
+ *   token: await myLogin(),
+ * });
+ * bc.on("cti.call", (e) => console.log("call", e));
+ * bc.calls.dial("+49301234567");
+ * ```
+ */
+/** Options for {@link BabelconnectEmbed.mount}. */
+export interface EmbedOptions {
+    /** Element the iframe is appended to. */
+    container: HTMLElement;
+    /** babelconnect-server origin (the iframe `src` + the only origin messages are exchanged with). */
+    serverUrl: string;
+    /** Bearer token, handed to the app via `postMessage` after its `ready` event (never in the URL). */
+    token: string;
+    /** Optional initial session correlation (also settable later via {@link session}). */
+    session?: Record<string, unknown>;
+    /** Optional initial shared context (also settable later via {@link context}). */
+    context?: Record<string, unknown>;
+    /** Path within the app (default `/`). */
+    path?: string;
+    /** Optional className for the iframe. */
+    className?: string;
+}
+/** A handler for an app→host event's `data` payload. */
+export type EmbedEventHandler = (data: unknown) => void;
+/**
+ * A mounted embed. Use the verb groups ({@link calls}, {@link session},
+ * {@link context}, {@link app}) to drive the app, and {@link on} to receive
+ * app→host events (`agent.loaded`, `cti.call`, `cti.error`, …).
+ */
+export declare class BabelconnectEmbed {
+    private readonly opts;
+    private readonly iframe;
+    private readonly serverOrigin;
+    private readonly handlers;
+    private readonly onMessage;
+    private disposed;
+    private constructor();
+    /** Mount the embed: inject the iframe and start the bridge. */
+    static mount(opts: EmbedOptions): BabelconnectEmbed;
+    /** Click-to-dial: place a call (or `dial=false` to only pre-fill the dialer). */
+    readonly calls: {
+        dial: (number: string, dial?: boolean) => void;
+    };
+    /** Attach session correlation; a `number` pre-fills a new SMS. */
+    readonly session: {
+        set: (args: Record<string, unknown>) => void;
+    };
+    /** Merge into the persisted shared context carried onto subsequent calls/SMS. */
+    readonly context: {
+        set: (args: Record<string, unknown>) => void;
+    };
+    /** Route the agent to a tab: `phone` | `chat` | `history` | `outbound`. */
+    readonly app: {
+        setTab: (tab: string) => void;
+    };
+    /** Subscribe to an app→host event. Returns an unsubscribe fn. */
+    on(name: string, fn: EmbedEventHandler): () => void;
+    /** The underlying iframe (e.g. to adjust sizing). */
+    get element(): HTMLIFrameElement;
+    /** Remove the iframe and stop listening. */
+    dispose(): void;
+    private post;
+    private handleMessage;
+    private emit;
+}

package/dist/embed/index.js

@@ -0,0 +1,115 @@
+/**
+ * `@babelforce/babelconnect-sdk/embed` — embed the babelconnect agent app (the
+ * server-served Flutter web app) into a host page via an `<iframe>` and a two-way
+ * `postMessage` bridge. See the Embedding guide at
+ * https://babelforce.github.io/babelconnect-sdk-docs/ for the full protocol.
+ * The embedded app talks only to babelconnect-server.
+ *
+ * @example
+ * ```ts
+ * import { BabelconnectEmbed } from "@babelforce/babelconnect-sdk/embed";
+ * const bc = BabelconnectEmbed.mount({
+ *   container: document.getElementById("bc")!,
+ *   serverUrl: "https://agent.example.com",
+ *   token: await myLogin(),
+ * });
+ * bc.on("cti.call", (e) => console.log("call", e));
+ * bc.calls.dial("+49301234567");
+ * ```
+ */
+/**
+ * A mounted embed. Use the verb groups ({@link calls}, {@link session},
+ * {@link context}, {@link app}) to drive the app, and {@link on} to receive
+ * app→host events (`agent.loaded`, `cti.call`, `cti.error`, …).
+ */
+export class BabelconnectEmbed {
+    opts;
+    iframe;
+    serverOrigin;
+    handlers = new Map();
+    onMessage;
+    disposed = false;
+    constructor(opts) {
+        this.opts = opts;
+        this.serverOrigin = new URL(opts.serverUrl).origin;
+        const iframe = document.createElement("iframe");
+        iframe.src = opts.serverUrl.replace(/\/+$/, "") + (opts.path ?? "/");
+        iframe.allow = "microphone; autoplay";
+        iframe.style.border = "0";
+        iframe.style.width = "100%";
+        iframe.style.height = "100%";
+        if (opts.className)
+            iframe.className = opts.className;
+        this.iframe = iframe;
+        this.onMessage = (e) => this.handleMessage(e);
+        window.addEventListener("message", this.onMessage);
+        opts.container.appendChild(iframe);
+    }
+    /** Mount the embed: inject the iframe and start the bridge. */
+    static mount(opts) {
+        return new BabelconnectEmbed(opts);
+    }
+    /** Click-to-dial: place a call (or `dial=false` to only pre-fill the dialer). */
+    calls = {
+        dial: (number, dial = true) => this.post("calls", "calls.dial", { number, dial }),
+    };
+    /** Attach session correlation; a `number` pre-fills a new SMS. */
+    session = {
+        set: (args) => this.post("session", "session.set", args),
+    };
+    /** Merge into the persisted shared context carried onto subsequent calls/SMS. */
+    context = {
+        set: (args) => this.post("context", "context.set", args),
+    };
+    /** Route the agent to a tab: `phone` | `chat` | `history` | `outbound`. */
+    app = {
+        setTab: (tab) => this.post("app", "app.setTab", { tab }),
+    };
+    /** Subscribe to an app→host event. Returns an unsubscribe fn. */
+    on(name, fn) {
+        let set = this.handlers.get(name);
+        if (!set) {
+            set = new Set();
+            this.handlers.set(name, set);
+        }
+        set.add(fn);
+        return () => set.delete(fn);
+    }
+    /** The underlying iframe (e.g. to adjust sizing). */
+    get element() {
+        return this.iframe;
+    }
+    /** Remove the iframe and stop listening. */
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        window.removeEventListener("message", this.onMessage);
+        this.iframe.remove();
+        this.handlers.clear();
+    }
+    post(module, name, args) {
+        this.iframe.contentWindow?.postMessage({ type: "connect", module, name, args }, this.serverOrigin);
+    }
+    handleMessage(e) {
+        if (e.origin !== this.serverOrigin)
+            return; // only trust the app's origin
+        const msg = e.data;
+        if (!msg || msg.type !== "bcConnect" || typeof msg.name !== "string")
+            return;
+        // Token handoff: on the app's `ready`, hand off the bearer token (+ optional
+        // initial session/context) over postMessage — never via the iframe URL.
+        if (msg.name === "ready") {
+            this.post("auth", "auth.set", {
+                token: this.opts.token,
+                session: this.opts.session,
+                context: this.opts.context,
+            });
+        }
+        this.emit(msg.name, msg.data);
+    }
+    emit(name, data) {
+        for (const fn of this.handlers.get(name) ?? [])
+            fn(data);
+    }
+}

package/dist/gen/babelconnect/v1/babelconnect_connect.d.ts

@@ -0,0 +1,132 @@
+import { Ack, AgentView, AuthenticateRequest, Command, GetStateRequest, HistoryRequest, HistoryResponse, Identity, PhonebookRequest, PhonebookResponse, SendSmsRequest, SmsConversation, SmsThreadRequest, SmsThreadResponse, StateUpdate, SubscribeRequest } from "./babelconnect_pb.js";
+import { MethodKind } from "@bufbuild/protobuf";
+/**
+ * @generated from service babelconnect.v1.Agent
+ */
+export declare const Agent: {
+    readonly typeName: "babelconnect.v1.Agent";
+    readonly methods: {
+        /**
+         * Authenticate validates the caller's bearer token and returns the resolved
+         * agent identity (id, account, presence).
+         *
+         * @generated from rpc babelconnect.v1.Agent.Authenticate
+         */
+        readonly authenticate: {
+            readonly name: "Authenticate";
+            readonly I: typeof AuthenticateRequest;
+            readonly O: typeof Identity;
+            readonly kind: MethodKind.Unary;
+        };
+        /**
+         * Session opens the long-lived control stream. The client sends Command
+         * intents; the server streams StateUpdate (one snapshot on open, then
+         * entity-level patches). UI = f(AgentView).
+         *
+         * Native clients (Go/Dart desktop/mobile over HTTP/2) use this bidi stream.
+         *
+         * @generated from rpc babelconnect.v1.Agent.Session
+         */
+        readonly session: {
+            readonly name: "Session";
+            readonly I: typeof Command;
+            readonly O: typeof StateUpdate;
+            readonly kind: MethodKind.BiDiStreaming;
+        };
+        /**
+         * Subscribe + Send are the browser-friendly split of Session: a browser speaks
+         * gRPC-web, which cannot client-stream, so the bidi Session is impossible there.
+         * Subscribe is the server→client half (the StateUpdate stream); Send is the
+         * client→server half (one Command per unary call). Together they are equivalent
+         * to Session for a single agent — the server keys both to the agent's one state
+         * store. Command rejections still arrive as an Error on the Subscribe stream
+         * (never on Send's reply), exactly as on Session.
+         *
+         * @generated from rpc babelconnect.v1.Agent.Subscribe
+         */
+        readonly subscribe: {
+            readonly name: "Subscribe";
+            readonly I: typeof SubscribeRequest;
+            readonly O: typeof StateUpdate;
+            readonly kind: MethodKind.ServerStreaming;
+        };
+        /**
+         * @generated from rpc babelconnect.v1.Agent.Send
+         */
+        readonly send: {
+            readonly name: "Send";
+            readonly I: typeof Command;
+            readonly O: typeof Ack;
+            readonly kind: MethodKind.Unary;
+        };
+        /**
+         * GetHistory returns the agent's past calls (the History tab). A unary query —
+         * history is on-demand reference data, not part of the live AgentView snapshot.
+         *
+         * @generated from rpc babelconnect.v1.Agent.GetHistory
+         */
+        readonly getHistory: {
+            readonly name: "GetHistory";
+            readonly I: typeof HistoryRequest;
+            readonly O: typeof HistoryResponse;
+            readonly kind: MethodKind.Unary;
+        };
+        /**
+         * GetSmsThread returns the messages of one SMS conversation (the chat thread).
+         * A unary query like GetHistory — the live AgentView carries only the
+         * SmsConversation summary; the full thread is fetched on demand. conversation_id
+         * is a query param (it can be a peer phone number when no conversation id is
+         * available), so this stays distinct from the POST /v1/agent/sms send.
+         *
+         * @generated from rpc babelconnect.v1.Agent.GetSmsThread
+         */
+        readonly getSmsThread: {
+            readonly name: "GetSmsThread";
+            readonly I: typeof SmsThreadRequest;
+            readonly O: typeof SmsThreadResponse;
+            readonly kind: MethodKind.Unary;
+        };
+        /**
+         * GetPhonebook returns the agent's dial-from contacts + recent numbers (the
+         * Contacts tab). A unary query like GetHistory: the live AgentView carries a
+         * phonebook snapshot frozen at register (AgentInfo.phonebook); this re-pulls the
+         * merged contacts+recents list on demand (refresh) so a long-running session can
+         * see new contacts. `query` filters by label/number.
+         *
+         * @generated from rpc babelconnect.v1.Agent.GetPhonebook
+         */
+        readonly getPhonebook: {
+            readonly name: "GetPhonebook";
+            readonly I: typeof PhonebookRequest;
+            readonly O: typeof PhonebookResponse;
+            readonly kind: MethodKind.Unary;
+        };
+        /**
+         * GetState returns the agent's current AgentView as a single unary call — the
+         * REST/web "get current state" (the Subscribe stream is the realtime twin). When
+         * no live session backs the caller, the server builds the snapshot on demand
+         * (agent + presence + wrap-up); live call state requires a stream.
+         *
+         * @generated from rpc babelconnect.v1.Agent.GetState
+         */
+        readonly getState: {
+            readonly name: "GetState";
+            readonly I: typeof GetStateRequest;
+            readonly O: typeof AgentView;
+            readonly kind: MethodKind.Unary;
+        };
+        /**
+         * SendSms sends an SMS and returns the (upserted) conversation summary. Exposed
+         * over REST as POST /v1/agent/sms and as the Command.send_sms intent on the
+         * stream — both send the same message.
+         *
+         * @generated from rpc babelconnect.v1.Agent.SendSms
+         */
+        readonly sendSms: {
+            readonly name: "SendSms";
+            readonly I: typeof SendSmsRequest;
+            readonly O: typeof SmsConversation;
+            readonly kind: MethodKind.Unary;
+        };
+    };
+};