@vogent/vogent-web-client 0.0.7 → 0.0.9

package/dist/VogentCall.d.ts

@@ -0,0 +1,121 @@
+/**
+ * @fileoverview VogentCall provides the main interface for managing voice calls with Vogent's AI system.
+ *
+ * This class handles:
+ * - Call lifecycle management (start, pause, hangup)
+ * - Audio connection setup
+ * - Real-time transcript monitoring
+ * - Status event handling
+ *
+ * Basic usage:
+ * ```typescript
+ * const call = new VogentCall({
+ *   sessionId: "session_id",
+ *   dialId: "dial_id",
+ *   token: "auth_token"
+ * });
+ *
+ * // Start the call
+ * await call.start();
+ *
+ * // Connect audio
+ * const audioConn = await call.connectAudio();
+ *
+ * // Monitor transcripts
+ * const unsubscribe = call.monitorTranscript((transcript) => {
+ *   console.log(transcript);
+ * });
+ *
+ * // Monitor status changes
+ * call.on('status', (status) => {
+ *   console.log('Call status:', status);
+ * });
+ *
+ * // Later: cleanup
+ * unsubscribe();
+ * await call.hangup();
+ * ```
+ *
+ * @see {@link https://docs.vogent.ai} for complete server documentation
+ * @module VogentCall
+ */
+import { VogentAudioConn } from './devices/VogentDevice';
+export type Transcript = {
+    /** The text of the transcript */
+    text: string;
+    /** The speaker of the transcript currently either 'HUMAN' or 'AI', or 'IVR' if IVR detection is enabled */
+    speaker: string;
+}[];
+/**
+ * VogentCall manages the lifecycle and state of a voice call session
+ */
+export declare class VogentCall {
+    /** Apollo GraphQL client instance for API communication */
+    private client;
+    /** Unique identifier for the current session */
+    private sessionId;
+    /** Unique identifier for the current dial/call */
+    private dialId;
+    /** GraphQL subscription handle */
+    private subscription?;
+    /** Base URL for the API endpoints */
+    private baseUrl;
+    /** Current dial/call state */
+    private dial?;
+    /** Array of event handlers for status changes */
+    private _handlers;
+    /**
+     * Creates a new VogentCall instance
+     * @param dialDetails - Object containing session details and authentication, retrieved from the Vogent server API
+     * @param dialDetails.sessionId - Unique session identifier
+     * @param dialDetails.dialId - Unique dial/call identifier
+     * @param dialDetails.token - Authentication token
+     * @param config - Configuration options
+     * @param config.baseUrl - API base URL (defaults to 'https://api.getelto.com')
+     */
+    constructor(dialDetails: {
+        sessionId: string;
+        dialId: string;
+        token: string;
+    }, config?: {
+        baseUrl: string;
+    });
+    /**
+     * Registers an event handler for status changes
+     * @param ev - Event type ('status')
+     * - status: called when the dial status changes, see docs.vogent.ai for more details
+     * @param fn - Callback function to handle the event
+     */
+    on(ev: 'status', fn: (...args: any[]) => void): void;
+    /**
+     * Subscribes to transcript updates for the current call
+     * @param fn - Callback function that receives transcript updates
+     * @returns Function to unsubscribe from transcript updates
+     */
+    monitorTranscript(fn: (transcript: Transcript) => void): () => void;
+    /**
+     * Internal method to update dial state and trigger status handlers
+     * @param dial - Updated dial information
+     */
+    private updateDial;
+    /**
+     * Establishes audio connection for the call
+     * @param liveListen - Whether to enable live listening mode. This should be set to true for monitoring legs (e.g. humans that are listening
+     * to the call who the AI should not interact with.)
+     * @returns Promise resolving to audio connection handle
+     */
+    connectAudio(liveListen?: boolean): Promise<VogentAudioConn>;
+    /**
+     * Starts the call session. Does not connect audio, you must call connectAudio() to do so.
+     */
+    start(): Promise<void>;
+    /**
+     * Sets the pause state of the AI
+     * @param paused - Whether to pause the AI or not.
+     */
+    setPaused(paused: boolean): Promise<void>;
+    /**
+     * Ends the current call
+     */
+    hangup(): Promise<void>;
+}

package/dist/VogentCall.js

@@ -0,0 +1,247 @@
+/**
+ * @fileoverview VogentCall provides the main interface for managing voice calls with Vogent's AI system.
+ *
+ * This class handles:
+ * - Call lifecycle management (start, pause, hangup)
+ * - Audio connection setup
+ * - Real-time transcript monitoring
+ * - Status event handling
+ *
+ * Basic usage:
+ * ```typescript
+ * const call = new VogentCall({
+ *   sessionId: "session_id",
+ *   dialId: "dial_id",
+ *   token: "auth_token"
+ * });
+ *
+ * // Start the call
+ * await call.start();
+ *
+ * // Connect audio
+ * const audioConn = await call.connectAudio();
+ *
+ * // Monitor transcripts
+ * const unsubscribe = call.monitorTranscript((transcript) => {
+ *   console.log(transcript);
+ * });
+ *
+ * // Monitor status changes
+ * call.on('status', (status) => {
+ *   console.log('Call status:', status);
+ * });
+ *
+ * // Later: cleanup
+ * unsubscribe();
+ * await call.hangup();
+ * ```
+ *
+ * @see {@link https://docs.vogent.ai} for complete server documentation
+ * @module VogentCall
+ */
+import { ApolloClient, createHttpLink, InMemoryCache, split } from '@apollo/client';
+import { setContext } from '@apollo/client/link/context';
+import { GraphQLWsLink } from '@apollo/client/link/subscriptions';
+import { getMainDefinition } from '@apollo/client/utilities';
+import { BrowserDialTokenType, SessionMessageType, } from './__generated__/graphql';
+import { AI_CONNECT_SESSION, AI_GET_TOKEN, AI_HANGUP_CALL, AI_START_DIAL_SESSION, AI_SET_PAUSED, REFRESH_TRANSCRIPT, } from './queries';
+import { createClient } from 'graphql-ws';
+import { VonageDevice } from './devices/VonageDevice';
+import { dialStatusIsComplete } from './utils';
+/**
+ * VogentCall manages the lifecycle and state of a voice call session
+ */
+export class VogentCall {
+    /**
+     * Creates a new VogentCall instance
+     * @param dialDetails - Object containing session details and authentication, retrieved from the Vogent server API
+     * @param dialDetails.sessionId - Unique session identifier
+     * @param dialDetails.dialId - Unique dial/call identifier
+     * @param dialDetails.token - Authentication token
+     * @param config - Configuration options
+     * @param config.baseUrl - API base URL (defaults to 'https://api.getelto.com')
+     */
+    constructor(dialDetails, config = {
+        baseUrl: 'https://api.getelto.com',
+    }) {
+        this._handlers = [];
+        this.sessionId = dialDetails.sessionId;
+        this.dialId = dialDetails.dialId;
+        let token = dialDetails.token;
+        const authLink = setContext((_, { headers }) => {
+            return {
+                headers: {
+                    ...headers,
+                    Authorization: `Bearer ${token}`,
+                },
+            };
+        });
+        this.baseUrl = config.baseUrl;
+        const httpLink = createHttpLink({
+            uri: `${this.baseUrl}/query`,
+            headers: {
+                Authorization: `Bearer ${token}`,
+            }
+        });
+        const wsBaseUrl = this.baseUrl.replace('https://', 'wss://').replace("http://", "ws://");
+        const wsLink = new GraphQLWsLink(createClient({
+            url: `${wsBaseUrl}/query`,
+            connectionParams: () => ({
+                authToken: token,
+            }),
+        }));
+        const splitLink = split(({ query }) => {
+            const definition = getMainDefinition(query);
+            return definition.kind === 'OperationDefinition' && definition.operation === 'subscription';
+        }, wsLink, 
+        // @ts-ignore
+        authLink.concat(httpLink));
+        this.client = new ApolloClient({
+            cache: new InMemoryCache(),
+            link: splitLink,
+        });
+    }
+    /**
+     * Registers an event handler for status changes
+     * @param ev - Event type ('status')
+     * - status: called when the dial status changes, see docs.vogent.ai for more details
+     * @param fn - Callback function to handle the event
+     */
+    on(ev, fn) {
+        this._handlers.push({
+            ev,
+            fn,
+        });
+    }
+    /**
+     * Subscribes to transcript updates for the current call
+     * @param fn - Callback function that receives transcript updates
+     * @returns Function to unsubscribe from transcript updates
+     */
+    monitorTranscript(fn) {
+        const subscription = this.client
+            .subscribe({
+            query: REFRESH_TRANSCRIPT,
+            variables: {
+                dialId: this.dialId,
+            },
+        })
+            .subscribe(({ data }) => {
+            console.log('monitorTranscript', data);
+            if (!data?.watchTranscript) {
+                return;
+            }
+            fn(data.watchTranscript.map((t) => ({
+                text: t.text,
+                speaker: t.speaker,
+            })));
+        });
+        return () => {
+            subscription.unsubscribe();
+        };
+    }
+    /**
+     * Internal method to update dial state and trigger status handlers
+     * @param dial - Updated dial information
+     */
+    updateDial(dial) {
+        if (!this.dial || dial.status !== this.dial.status) {
+            this._handlers.forEach((h) => {
+                h.fn(dial.status);
+            });
+        }
+        else {
+            return;
+        }
+        if (dialStatusIsComplete(dial.status)) {
+            this.subscription?.unsubscribe();
+        }
+        this.dial = {
+            ...this.dial,
+            ...dial,
+        };
+    }
+    /**
+     * Establishes audio connection for the call
+     * @param liveListen - Whether to enable live listening mode. This should be set to true for monitoring legs (e.g. humans that are listening
+     * to the call who the AI should not interact with.)
+     * @returns Promise resolving to audio connection handle
+     */
+    async connectAudio(liveListen = false) {
+        const token = await this.client.mutate({
+            mutation: AI_GET_TOKEN,
+            variables: {
+                input: {
+                    type: BrowserDialTokenType.DialSession,
+                    dialSessionId: this.sessionId,
+                },
+            },
+        });
+        const d = await VonageDevice.getDevice(token.data.browserDialToken.token, true);
+        const c = await d.connect({
+            params: { EltoDialSessionID: this.sessionId, LiveListen: liveListen, DialID: this.dialId },
+        });
+        return c;
+    }
+    /**
+     * Starts the call session. Does not connect audio, you must call connectAudio() to do so.
+     */
+    async start() {
+        this.subscription = this.client
+            .subscribe({
+            query: AI_CONNECT_SESSION,
+            variables: {
+                sessionId: this.sessionId,
+            },
+        })
+            .subscribe(({ data }) => {
+            switch (data?.connectSession.messageType) {
+                case SessionMessageType.GlobalCallConnect:
+                    this.client.mutate({
+                        mutation: AI_START_DIAL_SESSION,
+                        variables: {
+                            sessionId: this.sessionId,
+                        },
+                    });
+                    break;
+                case SessionMessageType.SessionContactUpdate: {
+                    const content = data?.connectSession.content;
+                    if (content.dials.length != 1) {
+                        break;
+                    }
+                    this.updateDial(content.dials[0]);
+                }
+            }
+        });
+    }
+    /**
+     * Sets the pause state of the AI
+     * @param paused - Whether to pause the AI or not.
+     */
+    async setPaused(paused) {
+        if (!this.dialId) {
+            return;
+        }
+        await this.client.mutate({
+            mutation: AI_SET_PAUSED,
+            variables: {
+                dialId: this.dialId,
+                pauseStatus: paused,
+            },
+        });
+    }
+    /**
+     * Ends the current call
+     */
+    async hangup() {
+        if (!this.dialId) {
+            return;
+        }
+        await this.client.mutate({
+            mutation: AI_HANGUP_CALL,
+            variables: {
+                dialId: this.dialId,
+            },
+        });
+    }
+}

package/dist/__generated__/gql.d.ts

@@ -0,0 +1,82 @@
+import * as types from './graphql';
+import { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
+/**
+ * Map of all GraphQL operations in the project.
+ *
+ * This map has several performance disadvantages:
+ * 1. It is not tree-shakeable, so it will include all operations in the project.
+ * 2. It is not minifiable, so the string of a GraphQL query will be multiple times inside the bundle.
+ * 3. It does not support dead code elimination, so it will add unused operations.
+ *
+ * Therefore it is highly recommended to use the babel or swc plugin for production.
+ * Learn more about it here: https://the-guild.dev/graphql/codegen/plugins/presets/preset-client#reducing-bundle-size
+ */
+declare const documents: {
+    "\nmutation CreateAdHocDialSession($input: CreateAdHocDialSessionInput!) {\n  createAdHocDialSession(input: $input) {\n    id\n    telephonyProvider\n  }\n}": DocumentNode<types.CreateAdHocDialSessionMutation, types.Exact<{
+        input: types.CreateAdHocDialSessionInput;
+    }>>;
+    "\n  mutation StartDialSession($sessionId: ID!) {\n    startDialSession(dialSessionId: $sessionId)\n  }\n": DocumentNode<types.StartDialSessionMutation, types.Exact<{
+        sessionId: types.Scalars["ID"]["input"];
+    }>>;
+    "\n  mutation HangupCall($dialId: ID!, $dropVoicemail: Boolean, $transferNumber: String) {\n    hangupCall(dialId: $dialId, dropVoicemail: $dropVoicemail, transferNumber: $transferNumber)\n  }\n": DocumentNode<types.HangupCallMutation, types.Exact<{
+        dialId: types.Scalars["ID"]["input"];
+        dropVoicemail?: types.InputMaybe<types.Scalars["Boolean"]["input"]>;
+        transferNumber?: types.InputMaybe<types.Scalars["String"]["input"]>;
+    }>>;
+    "\n  mutation SetPaused($dialId: ID!, $pauseStatus: Boolean!) {\n    pauseAI(dialId: $dialId, pauseStatus: $pauseStatus) {\n        id\n    }\n  }\n": DocumentNode<types.SetPausedMutation, types.Exact<{
+        dialId: types.Scalars["ID"]["input"];
+        pauseStatus: types.Scalars["Boolean"]["input"];
+    }>>;
+    "\n  subscription RefreshTranscript($dialId: ID!) {\n    watchTranscript(dialId: $dialId) {\n      speaker\n      text\n      detailType\n    }\n  }\n": DocumentNode<types.RefreshTranscriptSubscription, types.Exact<{
+        dialId: types.Scalars["ID"]["input"];
+    }>>;
+    "\n  mutation BrowserDialToken($input: BrowserDialTokenInput!) {\n    browserDialToken(input: $input) {\n      token\n      iceConfig\n    }\n  }\n": DocumentNode<types.BrowserDialTokenMutation, types.Exact<{
+        input: types.BrowserDialTokenInput;
+    }>>;
+    "\n  subscription ConnectSession($sessionId: ID!) {\n    connectSession(sessionId: $sessionId) {\n      messageType\n      content {\n        __typename\n        ... on DialsUpdatedMessage {\n          contactId\n          dials {\n            id\n            status\n            answerType\n            phoneField\n            callDispositionId\n            systemResultType\n            toNumber\n          }\n          contactComplete\n        }\n        ... on DialConnectMessage {\n          dialId\n        }\n        ... on SessionUpdatedMessage {\n          dialSession {\n            id\n            status\n          }\n          reason\n        }\n      }\n    }\n  }\n": DocumentNode<types.ConnectSessionSubscription, types.Exact<{
+        sessionId: types.Scalars["ID"]["input"];
+    }>>;
+};
+/**
+ * The gql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ *
+ *
+ * @example
+ * ```ts
+ * const query = gql(`query GetUser($id: ID!) { user(id: $id) { name } }`);
+ * ```
+ *
+ * The query argument is unknown!
+ * Please regenerate the types.
+ */
+export declare function gql(source: string): unknown;
+/**
+ * The gql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export declare function gql(source: "\nmutation CreateAdHocDialSession($input: CreateAdHocDialSessionInput!) {\n  createAdHocDialSession(input: $input) {\n    id\n    telephonyProvider\n  }\n}"): (typeof documents)["\nmutation CreateAdHocDialSession($input: CreateAdHocDialSessionInput!) {\n  createAdHocDialSession(input: $input) {\n    id\n    telephonyProvider\n  }\n}"];
+/**
+ * The gql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export declare function gql(source: "\n  mutation StartDialSession($sessionId: ID!) {\n    startDialSession(dialSessionId: $sessionId)\n  }\n"): (typeof documents)["\n  mutation StartDialSession($sessionId: ID!) {\n    startDialSession(dialSessionId: $sessionId)\n  }\n"];
+/**
+ * The gql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export declare function gql(source: "\n  mutation HangupCall($dialId: ID!, $dropVoicemail: Boolean, $transferNumber: String) {\n    hangupCall(dialId: $dialId, dropVoicemail: $dropVoicemail, transferNumber: $transferNumber)\n  }\n"): (typeof documents)["\n  mutation HangupCall($dialId: ID!, $dropVoicemail: Boolean, $transferNumber: String) {\n    hangupCall(dialId: $dialId, dropVoicemail: $dropVoicemail, transferNumber: $transferNumber)\n  }\n"];
+/**
+ * The gql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export declare function gql(source: "\n  mutation SetPaused($dialId: ID!, $pauseStatus: Boolean!) {\n    pauseAI(dialId: $dialId, pauseStatus: $pauseStatus) {\n        id\n    }\n  }\n"): (typeof documents)["\n  mutation SetPaused($dialId: ID!, $pauseStatus: Boolean!) {\n    pauseAI(dialId: $dialId, pauseStatus: $pauseStatus) {\n        id\n    }\n  }\n"];
+/**
+ * The gql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export declare function gql(source: "\n  subscription RefreshTranscript($dialId: ID!) {\n    watchTranscript(dialId: $dialId) {\n      speaker\n      text\n      detailType\n    }\n  }\n"): (typeof documents)["\n  subscription RefreshTranscript($dialId: ID!) {\n    watchTranscript(dialId: $dialId) {\n      speaker\n      text\n      detailType\n    }\n  }\n"];
+/**
+ * The gql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export declare function gql(source: "\n  mutation BrowserDialToken($input: BrowserDialTokenInput!) {\n    browserDialToken(input: $input) {\n      token\n      iceConfig\n    }\n  }\n"): (typeof documents)["\n  mutation BrowserDialToken($input: BrowserDialTokenInput!) {\n    browserDialToken(input: $input) {\n      token\n      iceConfig\n    }\n  }\n"];
+/**
+ * The gql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export declare function gql(source: "\n  subscription ConnectSession($sessionId: ID!) {\n    connectSession(sessionId: $sessionId) {\n      messageType\n      content {\n        __typename\n        ... on DialsUpdatedMessage {\n          contactId\n          dials {\n            id\n            status\n            answerType\n            phoneField\n            callDispositionId\n            systemResultType\n            toNumber\n          }\n          contactComplete\n        }\n        ... on DialConnectMessage {\n          dialId\n        }\n        ... on SessionUpdatedMessage {\n          dialSession {\n            id\n            status\n          }\n          reason\n        }\n      }\n    }\n  }\n"): (typeof documents)["\n  subscription ConnectSession($sessionId: ID!) {\n    connectSession(sessionId: $sessionId) {\n      messageType\n      content {\n        __typename\n        ... on DialsUpdatedMessage {\n          contactId\n          dials {\n            id\n            status\n            answerType\n            phoneField\n            callDispositionId\n            systemResultType\n            toNumber\n          }\n          contactComplete\n        }\n        ... on DialConnectMessage {\n          dialId\n        }\n        ... on SessionUpdatedMessage {\n          dialSession {\n            id\n            status\n          }\n          reason\n        }\n      }\n    }\n  }\n"];
+export type DocumentType<TDocumentNode extends DocumentNode<any, any>> = TDocumentNode extends DocumentNode<infer TType, any> ? TType : never;
+export {};

package/dist/__generated__/gql.js

@@ -0,0 +1,25 @@
+/* eslint-disable */
+import * as types from './graphql';
+/**
+ * Map of all GraphQL operations in the project.
+ *
+ * This map has several performance disadvantages:
+ * 1. It is not tree-shakeable, so it will include all operations in the project.
+ * 2. It is not minifiable, so the string of a GraphQL query will be multiple times inside the bundle.
+ * 3. It does not support dead code elimination, so it will add unused operations.
+ *
+ * Therefore it is highly recommended to use the babel or swc plugin for production.
+ * Learn more about it here: https://the-guild.dev/graphql/codegen/plugins/presets/preset-client#reducing-bundle-size
+ */
+const documents = {
+    "\nmutation CreateAdHocDialSession($input: CreateAdHocDialSessionInput!) {\n  createAdHocDialSession(input: $input) {\n    id\n    telephonyProvider\n  }\n}": types.CreateAdHocDialSessionDocument,
+    "\n  mutation StartDialSession($sessionId: ID!) {\n    startDialSession(dialSessionId: $sessionId)\n  }\n": types.StartDialSessionDocument,
+    "\n  mutation HangupCall($dialId: ID!, $dropVoicemail: Boolean, $transferNumber: String) {\n    hangupCall(dialId: $dialId, dropVoicemail: $dropVoicemail, transferNumber: $transferNumber)\n  }\n": types.HangupCallDocument,
+    "\n  mutation SetPaused($dialId: ID!, $pauseStatus: Boolean!) {\n    pauseAI(dialId: $dialId, pauseStatus: $pauseStatus) {\n        id\n    }\n  }\n": types.SetPausedDocument,
+    "\n  subscription RefreshTranscript($dialId: ID!) {\n    watchTranscript(dialId: $dialId) {\n      speaker\n      text\n      detailType\n    }\n  }\n": types.RefreshTranscriptDocument,
+    "\n  mutation BrowserDialToken($input: BrowserDialTokenInput!) {\n    browserDialToken(input: $input) {\n      token\n      iceConfig\n    }\n  }\n": types.BrowserDialTokenDocument,
+    "\n  subscription ConnectSession($sessionId: ID!) {\n    connectSession(sessionId: $sessionId) {\n      messageType\n      content {\n        __typename\n        ... on DialsUpdatedMessage {\n          contactId\n          dials {\n            id\n            status\n            answerType\n            phoneField\n            callDispositionId\n            systemResultType\n            toNumber\n          }\n          contactComplete\n        }\n        ... on DialConnectMessage {\n          dialId\n        }\n        ... on SessionUpdatedMessage {\n          dialSession {\n            id\n            status\n          }\n          reason\n        }\n      }\n    }\n  }\n": types.ConnectSessionDocument,
+};
+export function gql(source) {
+    return documents[source] ?? {};
+}