@babelforce/babelconnect-sdk 0.11.0 → 0.13.0

package/README.md

@@ -74,6 +74,11 @@ bc.calls.dial("+49301234567");              // click-to-dial from your CRM
 bc.session.set({ number: "+49301234567" }); // correlate / prefill
 ```
 
+No bundler? Load `<script src="https://agent.example.com/embed/babelconnect-embed.iife.js">` instead — it
+defines `window.BabelconnectEmbed` with the same API, no `import` needed. See the
+**[embedding guide](https://babelforce.github.io/babelconnect-sdk/docs/typescript/embedding)**, "Script tag
+(no bundler)".
+
 ## API overview
 
 | Area | Exports |

package/dist/client.d.ts

@@ -88,10 +88,18 @@ export declare class BabelconnectClient {
     }): void;
     /** Open a conference around the current call. `hold` parks that call while you add members and consult. */
     startConference(hold?: boolean): void;
-    /** Invite a participant — pass exactly one of `agentId` or `number`. Starts a conference first if none is active. */
+    /**
+     * Invite a participant — pass exactly one of `agentId` or `number`. Starts a
+     * conference first if none is active. `holdOthers` parks every other live
+     * member of the CURRENT conference before the invite goes out (CA4's "hold
+     * others" checkbox, default off) so they don't overhear the invitee
+     * ringing; the server unholds them again once the invitee joins or the
+     * invite fails.
+     */
     addConferenceMember(opts: {
         agentId?: string;
         number?: string;
+        holdOthers?: boolean;
     }): void;
     /** Remove a member from the conference (moderator only). */
     kickConferenceMember(memberId: string): void;
@@ -103,6 +111,37 @@ export declare class BabelconnectClient {
     endConference(): void;
     /** Drop only the agent's own leg; the other members stay connected. */
     leaveConference(): void;
+    /**
+     * Enter a campaign (the picker's "Enter"). `paused` false (default) starts
+     * the agent `waiting` for a lead right away; true enters already idle.
+     */
+    joinCampaign(campaignId: string, paused?: boolean): void;
+    /** Exit the current campaign (selector row or in-call). */
+    leaveCampaign(): void;
+    /** Pause (`on` true) or resume (`on` false) the campaign. */
+    pauseCampaign(on: boolean): void;
+    /**
+     * List the active outbound-dialer campaigns the agent may join (the
+     * Outbound tab's campaign picker, OBDA1).
+     */
+    listCampaigns(): Promise<import("./gen/babelconnect/v1/babelconnect_pb.js").Campaign[]>;
+    /**
+     * End the agent's live campaign call (OBDB2) — distinct from `hangup`: the
+     * backend both releases the Vicidial-side channel and drives the campaign
+     * member state to DISPOSITION.
+     */
+    endCampaignCall(): void;
+    /**
+     * Record the outcome of a campaign call (OBDC1). `callbackDate` is ISO
+     * `YYYY-MM-DDTHH:mmZZ` and should be left empty except for the "callback"
+     * disposition (OBDC2).
+     */
+    disposeCall(code: string, callbackDate?: string): void;
+    /**
+     * List the available call-outcome codes for the disposition picker
+     * (OBDC1) — a static global list, not campaign-scoped.
+     */
+    listDispositions(): Promise<string[]>;
     /** Add seconds to the after-call-work countdown (default 30). Show only when `wrapUp.canExtend`. */
     wrapUpExtend(seconds?: number): void;
     /** End after-call work early. Show only when `wrapUp.canCancel`. */
@@ -140,6 +179,12 @@ export declare class BabelconnectClient {
      * `query` filters by label/number.
      */
     getPhonebook(max?: number, page?: number, query?: string): Promise<import("./gen/babelconnect/v1/babelconnect_pb.js").PhonebookEntry[]>;
+    /**
+     * Autocomplete blind-transfer / add-member targets — agents, raw numbers,
+     * and IVR applications — as the caller types. `query` filters server-side;
+     * empty returns the default result set.
+     */
+    getTransferTargets(query?: string): Promise<import("./gen/babelconnect/v1/babelconnect_pb.js").TransferTarget[]>;
     /** Tear down media legs and the connection. */
     close(): Promise<void>;
     private runSubscribe;

package/dist/client.js

@@ -2,7 +2,7 @@ import { createClient, } from "@connectrpc/connect";
 import { createGrpcWebTransport } from "@connectrpc/connect-web";
 import { SDK_VERSION } from "./version.js";
 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, Pong, 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 { AddConferenceMember, AnswerCall, CallDirection, CallLifecycle, CallSource, Command, DisposeCall, EndCampaignCall, EndConference, Error as BcError, FlagRecording, Hangup, HistoryRequest, SmsThreadRequest, PhonebookRequest, HoldConferenceMember, Hold, JoinCampaign, KickConferenceMember, LeaveCampaign, LeaveConference, ListCampaignsRequest, ListDispositionsRequest, MarkConversationRead, Mute, MuteConferenceMember, PauseCampaign, PlaceCall, Pong, Register, ResetLineStatus, SendDigits, SendSmsRequest, SetAgentNumber, SetConversationOpen, SetDisplayAs, SetPresence, SetWebrtc, StartConference, StartRecording, StopRecording, SetRecordingTags, SubscribeRequest, Transfer, TransferTargetsRequest, WrapUpCancel, WrapUpExtend, } from "./gen/babelconnect/v1/babelconnect_pb.js";
 import { browserMediaFactory, MediaError, toRTCIceServers, } from "./media.js";
 import { StateCache } from "./state-cache.js";
 /**
@@ -151,7 +151,14 @@ export class BabelconnectClient {
             },
         }));
     }
-    /** Invite a participant — pass exactly one of `agentId` or `number`. Starts a conference first if none is active. */
+    /**
+     * Invite a participant — pass exactly one of `agentId` or `number`. Starts a
+     * conference first if none is active. `holdOthers` parks every other live
+     * member of the CURRENT conference before the invite goes out (CA4's "hold
+     * others" checkbox, default off) so they don't overhear the invitee
+     * ringing; the server unholds them again once the invitee joins or the
+     * invite fails.
+     */
     addConferenceMember(opts) {
         this.send(new Command({
             command: {
@@ -159,6 +166,7 @@ export class BabelconnectClient {
                 value: new AddConferenceMember({
                     agentId: opts.agentId ?? "",
                     number: opts.number ?? "",
+                    holdOthers: opts.holdOthers ?? false,
                 }),
             },
         }));
@@ -202,6 +210,73 @@ export class BabelconnectClient {
             command: { case: "leaveConference", value: new LeaveConference({}) },
         }));
     }
+    // --- Outbound dialer (campaign mode, OBDA1–3) ---
+    /**
+     * Enter a campaign (the picker's "Enter"). `paused` false (default) starts
+     * the agent `waiting` for a lead right away; true enters already idle.
+     */
+    joinCampaign(campaignId, paused = false) {
+        this.send(new Command({
+            command: {
+                case: "joinCampaign",
+                value: new JoinCampaign({ campaignId, paused }),
+            },
+        }));
+    }
+    /** Exit the current campaign (selector row or in-call). */
+    leaveCampaign() {
+        this.send(new Command({
+            command: { case: "leaveCampaign", value: new LeaveCampaign({}) },
+        }));
+    }
+    /** Pause (`on` true) or resume (`on` false) the campaign. */
+    pauseCampaign(on) {
+        this.send(new Command({
+            command: { case: "pauseCampaign", value: new PauseCampaign({ on }) },
+        }));
+    }
+    /**
+     * List the active outbound-dialer campaigns the agent may join (the
+     * Outbound tab's campaign picker, OBDA1).
+     */
+    async listCampaigns() {
+        const resp = await this.rpc.listCampaigns(new ListCampaignsRequest({}));
+        return resp.campaigns;
+    }
+    /**
+     * End the agent's live campaign call (OBDB2) — distinct from `hangup`: the
+     * backend both releases the Vicidial-side channel and drives the campaign
+     * member state to DISPOSITION.
+     */
+    endCampaignCall() {
+        this.send(new Command({
+            command: {
+                case: "endCampaignCall",
+                value: new EndCampaignCall({}),
+            },
+        }));
+    }
+    /**
+     * Record the outcome of a campaign call (OBDC1). `callbackDate` is ISO
+     * `YYYY-MM-DDTHH:mmZZ` and should be left empty except for the "callback"
+     * disposition (OBDC2).
+     */
+    disposeCall(code, callbackDate = "") {
+        this.send(new Command({
+            command: {
+                case: "disposeCall",
+                value: new DisposeCall({ code, callbackDate }),
+            },
+        }));
+    }
+    /**
+     * List the available call-outcome codes for the disposition picker
+     * (OBDC1) — a static global list, not campaign-scoped.
+     */
+    async listDispositions() {
+        const resp = await this.rpc.listDispositions(new ListDispositionsRequest({}));
+        return resp.reasons;
+    }
     /** Add seconds to the after-call-work countdown (default 30). Show only when `wrapUp.canExtend`. */
     wrapUpExtend(seconds = 30) {
         this.send(new Command({
@@ -322,6 +397,15 @@ export class BabelconnectClient {
         const resp = await this.rpc.getPhonebook(new PhonebookRequest({ max, page, query }));
         return resp.entries;
     }
+    /**
+     * Autocomplete blind-transfer / add-member targets — agents, raw numbers,
+     * and IVR applications — as the caller types. `query` filters server-side;
+     * empty returns the default result set.
+     */
+    async getTransferTargets(query = "") {
+        const resp = await this.rpc.getTransferTargets(new TransferTargetsRequest({ query }));
+        return resp.targets;
+    }
     /** Tear down media legs and the connection. */
     async close() {
         this.closed = true;

package/dist/embed/iife-entry.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Script-tag build entry (EMB21) — bundled by esbuild (not `tsc`, which only emits
+ * the ESM `dist/embed/index.js`) into a self-contained IIFE at
+ * `dist/web/babelconnect-embed.iife.js`, for CRM hosts with no bundler/ESM support:
+ *
+ * ```html
+ * <script src="https://agent.example.com/embed/babelconnect-embed.iife.js"></script>
+ * <script>
+ *   const bc = BabelconnectEmbed.mount({ container, serverUrl, token });
+ * </script>
+ * ```
+ *
+ * Loading this file defines a single global, `window.BabelconnectEmbed` — the same
+ * class exported as `BabelconnectEmbed` from `@babelforce/babelconnect-sdk/embed`,
+ * so `BabelconnectEmbed.mount({...})` here is identical to the ESM
+ * `BabelconnectEmbed.mount({...})`. The name is deliberately **distinct** from the
+ * legacy `@babelforce/bc-connect` global (`BabelconnectConnect`) — the two APIs
+ * differ and a compatibility shim is out of scope; see EMBEDDING.md for the
+ * migration.
+ *
+ * This file has no `export` statement on purpose: esbuild's `--format=iife` wraps
+ * an entry's *exports* into a namespace object under `--global-name`, which would
+ * put the class at `window.BabelconnectEmbed.BabelconnectEmbed` instead of
+ * `window.BabelconnectEmbed` itself. Assigning to `globalThis` directly here keeps
+ * the global exactly the class.
+ */
+import { BabelconnectEmbed } from "./index.js";
+declare global {
+    interface Window {
+        BabelconnectEmbed: typeof BabelconnectEmbed;
+    }
+}

package/dist/embed/iife-entry.js

@@ -0,0 +1,28 @@
+/**
+ * Script-tag build entry (EMB21) — bundled by esbuild (not `tsc`, which only emits
+ * the ESM `dist/embed/index.js`) into a self-contained IIFE at
+ * `dist/web/babelconnect-embed.iife.js`, for CRM hosts with no bundler/ESM support:
+ *
+ * ```html
+ * <script src="https://agent.example.com/embed/babelconnect-embed.iife.js"></script>
+ * <script>
+ *   const bc = BabelconnectEmbed.mount({ container, serverUrl, token });
+ * </script>
+ * ```
+ *
+ * Loading this file defines a single global, `window.BabelconnectEmbed` — the same
+ * class exported as `BabelconnectEmbed` from `@babelforce/babelconnect-sdk/embed`,
+ * so `BabelconnectEmbed.mount({...})` here is identical to the ESM
+ * `BabelconnectEmbed.mount({...})`. The name is deliberately **distinct** from the
+ * legacy `@babelforce/bc-connect` global (`BabelconnectConnect`) — the two APIs
+ * differ and a compatibility shim is out of scope; see EMBEDDING.md for the
+ * migration.
+ *
+ * This file has no `export` statement on purpose: esbuild's `--format=iife` wraps
+ * an entry's *exports* into a namespace object under `--global-name`, which would
+ * put the class at `window.BabelconnectEmbed.BabelconnectEmbed` instead of
+ * `window.BabelconnectEmbed` itself. Assigning to `globalThis` directly here keeps
+ * the global exactly the class.
+ */
+import { BabelconnectEmbed } from "./index.js";
+globalThis.BabelconnectEmbed = BabelconnectEmbed;

package/dist/embed/index.d.ts

@@ -29,6 +29,17 @@ export interface EmbedOptions {
     session?: Record<string, unknown>;
     /** Optional initial shared context (also settable later via {@link context}). */
     context?: Record<string, unknown>;
+    /**
+     * The `agent.loaded`/`user.loaded` event-payload schema version (EMB20).
+     * Omit for the app's current default (`"v3"` — just the top-level
+     * `agentId`, no legacy struct nesting). Pass `"v1"` to opt into the
+     * bc-connect-compatible shape (`agent.loaded` → `{agentId,
+     * agent:{id,name,email,number}}`, `user.loaded` → `{agentId,
+     * user:{email}}`) for a host still doing bc-v2-style CRM matching by email
+     * or routing by number. See the Embedding guide, "Loaded event schema
+     * version".
+     */
+    eventsVersion?: string;
     /** Path within the app (default `/`). */
     path?: string;
     /** Optional className for the iframe. */
@@ -36,21 +47,49 @@ export interface EmbedOptions {
 }
 /** A handler for an app→host event's `data` payload. */
 export type EmbedEventHandler = (data: unknown) => void;
+/** Args for {@link BabelconnectEmbed.auth}'s `set`. */
+export interface AuthSetArgs {
+    /** New bearer token. */
+    token: string;
+    /** Updated session correlation. Omit to leave the currently-tracked value unchanged. */
+    session?: Record<string, unknown>;
+    /** Updated shared context. Omit to leave the currently-tracked value unchanged. */
+    context?: Record<string, unknown>;
+    /** Updated events-schema version (EMB20, see {@link EmbedOptions.eventsVersion}). Only takes
+     * effect on the NEXT `ready` handshake (an iframe reload) — a live session's already-emitted
+     * `agent.loaded`/`user.loaded` don't refire. Omit to leave the currently-tracked value unchanged. */
+    eventsVersion?: string;
+}
 /**
- * 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`, …).
+ * A mounted embed. Use the verb groups ({@link auth}, {@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 currentToken;
+    private currentSession;
+    private currentContext;
+    private currentEventsVersion;
     private constructor();
     /** Mount the embed: inject the iframe and start the bridge. */
     static mount(opts: EmbedOptions): BabelconnectEmbed;
+    /**
+     * Refresh the bearer token (and optionally session/context) mid-session —
+     * e.g. ahead of expiry on a long shift. Posts `auth.set` immediately; the
+     * live app applies it in place without interrupting the session or any
+     * active call (EMB15). Also remembers the values as *current*, so if the
+     * iframe later reloads and re-emits `ready`, the handshake hands off this
+     * refreshed token rather than the one passed to {@link BabelconnectEmbed.mount}.
+     */
+    readonly auth: {
+        set: (args: AuthSetArgs) => void;
+    };
     /** Click-to-dial: place a call (or `dial=false` to only pre-fill the dialer). */
     readonly calls: {
         dial: (number: string, dial?: boolean) => void;
@@ -74,6 +113,7 @@ export declare class BabelconnectEmbed {
     /** Remove the iframe and stop listening. */
     dispose(): void;
     private post;
+    private postAuthSet;
     private handleMessage;
     private emit;
 }

package/dist/embed/index.js

@@ -18,20 +18,31 @@
  * ```
  */
 /**
- * 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`, …).
+ * A mounted embed. Use the verb groups ({@link auth}, {@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;
+    // The token/session/context/eventsVersion currently in effect — seeded from
+    // `opts` at mount() and updated in place by `auth.set()`, so a later `ready`
+    // (an iframe reload) re-sends whatever is *current*, not the mount()-time
+    // value.
+    currentToken;
+    currentSession;
+    currentContext;
+    currentEventsVersion;
     constructor(opts) {
-        this.opts = opts;
         this.serverOrigin = new URL(opts.serverUrl).origin;
+        this.currentToken = opts.token;
+        this.currentSession = opts.session;
+        this.currentContext = opts.context;
+        this.currentEventsVersion = opts.eventsVersion;
         const iframe = document.createElement("iframe");
         iframe.src = opts.serverUrl.replace(/\/+$/, "") + (opts.path ?? "/");
         iframe.allow = "microphone; autoplay";
@@ -49,6 +60,26 @@ export class BabelconnectEmbed {
     static mount(opts) {
         return new BabelconnectEmbed(opts);
     }
+    /**
+     * Refresh the bearer token (and optionally session/context) mid-session —
+     * e.g. ahead of expiry on a long shift. Posts `auth.set` immediately; the
+     * live app applies it in place without interrupting the session or any
+     * active call (EMB15). Also remembers the values as *current*, so if the
+     * iframe later reloads and re-emits `ready`, the handshake hands off this
+     * refreshed token rather than the one passed to {@link BabelconnectEmbed.mount}.
+     */
+    auth = {
+        set: (args) => {
+            this.currentToken = args.token;
+            if (args.session !== undefined)
+                this.currentSession = args.session;
+            if (args.context !== undefined)
+                this.currentContext = args.context;
+            if (args.eventsVersion !== undefined)
+                this.currentEventsVersion = args.eventsVersion;
+            this.postAuthSet();
+        },
+    };
     /** 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 }),
@@ -91,25 +122,46 @@ export class BabelconnectEmbed {
     post(module, name, args) {
         this.iframe.contentWindow?.postMessage({ type: "connect", module, name, args }, this.serverOrigin);
     }
+    // Posts the current token/session/context (+ eventsVersion, EMB20) as an
+    // auth.set envelope. `eventsVersion` is only included when the host set
+    // one — an absent key (rather than an explicit `undefined`) keeps the args
+    // shape unchanged for hosts that never opted in, and lets the app apply its
+    // own default unambiguously.
+    postAuthSet() {
+        this.post("auth", "auth.set", {
+            token: this.currentToken,
+            session: this.currentSession,
+            context: this.currentContext,
+            ...(this.currentEventsVersion !== undefined ? { eventsVersion: this.currentEventsVersion } : {}),
+        });
+    }
     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,
-            });
-        }
+        // Token handoff: on the app's `ready`, hand off the current bearer token
+        // (+ session/context/eventsVersion) over postMessage — never via the
+        // iframe URL. `ready` also fires on an iframe reload, so this re-sends
+        // whatever is current (see `auth.set`), not necessarily the value passed
+        // to `mount()`.
+        if (msg.name === "ready")
+            this.postAuthSet();
         this.emit(msg.name, msg.data);
     }
     emit(name, data) {
-        for (const fn of this.handlers.get(name) ?? [])
-            fn(data);
+        for (const fn of this.handlers.get(name) ?? []) {
+            try {
+                fn(data);
+            }
+            catch (err) {
+                // A subscriber's handler is host code, not ours — one throwing
+                // handler must not stop sibling handlers from receiving the event,
+                // nor escape into the window `message` dispatch (which would break
+                // unrelated listeners on the host page).
+                console.error("[babelconnect-embed] on() handler threw", err);
+            }
+        }
     }
 }

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

@@ -1,4 +1,4 @@
-import { Ack, AgentView, AuthenticateRequest, Command, GetStateRequest, HistoryRequest, HistoryResponse, Identity, PhonebookRequest, PhonebookResponse, SendSmsRequest, SmsConversation, SmsThreadRequest, SmsThreadResponse, StateUpdate, SubscribeRequest } from "./babelconnect_pb.js";
+import { Ack, AgentView, AuthenticateRequest, Command, GetStateRequest, HistoryRequest, HistoryResponse, Identity, ListCampaignsRequest, ListCampaignsResponse, ListDispositionsRequest, ListDispositionsResponse, PhonebookRequest, PhonebookResponse, SendSmsRequest, SmsConversation, SmsThreadRequest, SmsThreadResponse, StateUpdate, SubscribeRequest, TransferTargetsRequest, TransferTargetsResponse } from "./babelconnect_pb.js";
 import { MethodKind } from "@bufbuild/protobuf";
 /**
  * @generated from service babelconnect.v1.Agent
@@ -19,28 +19,15 @@ export declare const Agent: {
             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.
+         * Subscribe + Send are the control stream, split into its server→client and
+         * client→server halves — the one shape every client uses (RPC-A4 retired the
+         * earlier bidi `Session` RPC, which needed HTTP/2 end-to-end and couldn't
+         * ride gRPC-web or a plain HTTP/1.1 ingress). Subscribe is the server→client
+         * half (StateUpdate: one snapshot on open, then entity-level patches; UI =
+         * f(AgentView)). Send is the client→server half (one Command per unary
+         * call). Together they key to the agent's one state store. Command
+         * rejections arrive as an Error on the Subscribe stream, never on Send's
+         * reply.
          *
          * @generated from rpc babelconnect.v1.Agent.Subscribe
          */
@@ -101,6 +88,24 @@ export declare const Agent: {
             readonly O: typeof PhonebookResponse;
             readonly kind: MethodKind.Unary;
         };
+        /**
+         * GetTransferTargets autocompletes blind-transfer / add-member targets as the
+         * agent types — agents, raw numbers, and IVR applications (GET
+         * /agent/calls/transfer/targets?query=, bc-standalone-2
+         * src/components/Common/NumberListSelect.vue:59). `query` filters server-side
+         * (substring across name/email/number for agents, name for applications); the
+         * backend has no call-context param, so eligibility by call direction is a
+         * separate, already-server-computed flag the client applies itself
+         * (CallState.can_transfer_to_application hides APPLICATION results — CALL-I3).
+         *
+         * @generated from rpc babelconnect.v1.Agent.GetTransferTargets
+         */
+        readonly getTransferTargets: {
+            readonly name: "GetTransferTargets";
+            readonly I: typeof TransferTargetsRequest;
+            readonly O: typeof TransferTargetsResponse;
+            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
@@ -128,5 +133,35 @@ export declare const Agent: {
             readonly O: typeof SmsConversation;
             readonly kind: MethodKind.Unary;
         };
+        /**
+         * ListCampaigns lists the outbound-dialer campaigns the agent may join (the
+         * Outbound tab's campaign picker, OBDA1) — on-demand reference data like
+         * GetPhonebook/GetTransferTargets, backed by GET /api/v2/agent/outbound/
+         * campaigns?active=true (sbf/services ObdController#listCampaigns).
+         *
+         * @generated from rpc babelconnect.v1.Agent.ListCampaigns
+         */
+        readonly listCampaigns: {
+            readonly name: "ListCampaigns";
+            readonly I: typeof ListCampaignsRequest;
+            readonly O: typeof ListCampaignsResponse;
+            readonly kind: MethodKind.Unary;
+        };
+        /**
+         * ListDispositions lists the available call-outcome codes for the disposition
+         * picker (OBDC1) — on-demand reference data like ListCampaigns, backed by GET
+         * /api/v2/agent/outbound/campaigns/{id}/dispositions (sbf/services
+         * ObdController#listDispositions). Grounded: the `{id}` path segment is never
+         * read server-side — the list is a static global, not campaign-scoped — so the
+         * request carries no campaign id either.
+         *
+         * @generated from rpc babelconnect.v1.Agent.ListDispositions
+         */
+        readonly listDispositions: {
+            readonly name: "ListDispositions";
+            readonly I: typeof ListDispositionsRequest;
+            readonly O: typeof ListDispositionsResponse;
+            readonly kind: MethodKind.Unary;
+        };
     };
 };