@servicetitan/titan-chatbot-api 3.0.0

package/src/api-client/index.ts

@@ -0,0 +1,12 @@
+export * as ApiClientTitanChat from './titan-chat';
+export * as ApiClientHelpCenter from './help-center';
+export * as Models from './models';
+export * as ModelsMocks from './models/__mocks__/models.mock';
+export * as ClientMocks from './__mocks__/chatbot-api-client.mock';
+export * as ModelsUtils from './utils/model-utils';
+export {
+    IChatbotClientSettings,
+    IChatbotApiClient,
+    CHATBOT_CLIENT_SETTINGS,
+    CHATBOT_API_CLIENT,
+} from './base/chatbot-api-client';

package/src/api-client/models/__mocks__/models.mock.ts

@@ -0,0 +1,141 @@
+import {
+    ChatMessageModelBase,
+    ChatMessageState,
+    ChatParticipantIcon,
+} from '@servicetitan/titan-chat-ui-common';
+import { Models, ModelsUtils } from '../..';
+
+export const mockOption = (overrides?: Models.IOption) =>
+    new Models.Option({
+        key: 'mock_key',
+        displayName: 'Mock Option',
+        type: Models.OptionType.Group,
+        ...overrides,
+    });
+
+export const mockFrontendModel = (): Models.FrontendModel => {
+    const opt = (
+        key: string,
+        displayName: string | undefined,
+        type: Models.OptionType,
+        subOptions?: Models.Option[]
+    ) =>
+        mockOption({
+            key,
+            displayName,
+            type,
+            subOptions,
+        });
+
+    const sources = opt('Sources', 'Sources', Models.OptionType.Group, [
+        opt('KnowledgeBase', 'Knowledge Base', Models.OptionType.Selectable, [
+            opt('ContentTypes', 'Content Types', Models.OptionType.Group, [
+                opt('kbReleaseNotes', 'Release Notes', Models.OptionType.Selectable),
+                opt('kbFaq', 'FAQ', Models.OptionType.Selectable),
+                opt('kbHowTo', 'How To', Models.OptionType.Selectable),
+            ]),
+            opt('ProductAreas', 'Product Areas', Models.OptionType.Group, [
+                opt('Call Booking', 'Call Booking', Models.OptionType.Selectable),
+                opt('Marketing', 'Marketing', Models.OptionType.Selectable),
+                opt('Marketing Pro', 'Marketing Pro', Models.OptionType.Selectable),
+            ]),
+        ]),
+        opt('Jarvis', 'Jarvis', Models.OptionType.Selectable, [
+            opt('ContentTypes', 'Content Types', Models.OptionType.Group, [
+                opt('kbReleaseNotes', 'Release Notes', Models.OptionType.Selectable),
+                opt('xxx', 'Xxx', Models.OptionType.Selectable),
+                opt('yyy', 'Yyy', Models.OptionType.Selectable),
+            ]),
+        ]),
+    ]);
+    return new Models.FrontendModel({
+        options: opt('customer-knowledge', undefined, Models.OptionType.Group, [sources]),
+    });
+};
+
+export const mockSession = (overrides?: Partial<Models.ISession>): Models.Session =>
+    new Models.Session({
+        id: 1,
+        data: {
+            createdUtc: new Date('2021-01-01T00:00:00Z').toISOString(),
+            closedUtc: new Date('2021-01-02T00:00:00Z').toISOString(),
+            botId: 'bot-id',
+            instance: 'instance',
+            category: 'category',
+            subCategory: 'sub-category',
+        },
+        ...overrides,
+    });
+
+export const mockFeedback = (overrides?: Partial<Models.IFeedback>): Models.Feedback =>
+    new Models.Feedback({
+        linkUrl: 'https://example.com',
+        sessionId: 1,
+        messageId: 1,
+        rating: Models.FeedbackRatings.ThumbsUp,
+        description: 'description',
+        options: undefined,
+        ...overrides,
+    });
+
+export const mockSelections = (overrides?: Models.Selections): Models.Selections | undefined =>
+    new Models.Selections({
+        ...ModelsUtils.createSelectionsModel([mockFrontendModel().options], {
+            Sources: ['KnowledgeBase', 'Jarvis'],
+            ContentTypes: ['kbReleaseNotes', 'kbFaq', 'xxx'],
+        }),
+        ...overrides,
+    });
+
+export const mockUserMessage = (overrides?: Partial<Models.IUserMessage>): Models.UserMessage =>
+    new Models.UserMessage({
+        sessionId: 1,
+        question: 'question',
+        experience: Models.Experience.MultiTurn,
+        selections: mockSelections(),
+        context: {
+            key1: 'value1',
+            key2: 'value2',
+        },
+        ...overrides,
+    });
+
+export const mockScoredUrl = (overrides?: Partial<Models.IScoredUrl>): Models.ScoredUrl =>
+    new Models.ScoredUrl({
+        url: 'https://example.com',
+        score: 0.9,
+        title: 'Example Title',
+        ...overrides,
+    });
+
+export const mockScoredUrls = (): Models.ScoredUrl[] => [
+    mockScoredUrl({ url: 'https://example1.com', score: 0.95, title: 'Example 1' }),
+    mockScoredUrl({ url: 'https://example2.com', score: 0.85, title: 'Example 2' }),
+];
+
+export const mockBotMessage = (overrides?: Partial<Models.IBotMessage>): Models.BotMessage =>
+    new Models.BotMessage({
+        id: 1,
+        answer: 'answer',
+        sessionId: 1,
+        isGuardrailed: false,
+        scoredUrls: undefined,
+        guardFlag: 'N',
+        ...overrides,
+    });
+
+export const mockChatMessageModel = <T extends ChatMessageModelBase>(overrides?: Partial<T>): T => {
+    const result = {
+        id: '1',
+        timestamp: new Date('2021-01-01T00:00:00Z'),
+        state: ChatMessageState.Delivered,
+        participant: {
+            isAgent: true,
+            name: 'Agent Name',
+            icon: ChatParticipantIcon.Initials,
+        },
+        type: 'message',
+        ...overrides,
+    };
+    return result as T;
+};

package/src/api-client/models/index.ts

@@ -0,0 +1,48 @@
+/* eslint-disable no-restricted-imports */
+import { IBotMessage, IFeedback, IUserMessage } from '../titan-chat/native-client';
+export {
+    IUserMessage,
+    Selections,
+    FeedbackOptions,
+    FeedbackRatings,
+    Session,
+    ApiException,
+    Feedback,
+    Option,
+    IFeedback,
+    FrontendModel,
+    UserMessage,
+    IFrontendModel,
+    IOption,
+    OptionType,
+    ScoredUrl,
+    IScoredUrl,
+    ISelections,
+    ISession,
+    Experience,
+    IBotMessage,
+    BotMessage,
+} from '../titan-chat/native-client';
+
+export interface IBotMessageWithFeedback extends IBotMessage {
+    isFeedbackSaved?: boolean;
+    feedback?: IFeedback;
+}
+
+export interface ChatbotAskBotResult {
+    question: IUserMessage;
+    answer: IBotMessage;
+}
+
+export enum BotArea {
+    SupportFlow = 'SupportFlow',
+    Search = 'Search',
+    FloatingChat = 'FloatingChat',
+}
+
+export enum ChatbotFeedbackState {
+    None,
+    Sent,
+    Success,
+    Failure,
+}

package/src/api-client/titan-chat/chatbot-api-client.ts

@@ -0,0 +1,77 @@
+import { inject, injectable } from '@servicetitan/react-ioc';
+import { Models } from '..';
+import {
+    CHATBOT_CLIENT_SETTINGS,
+    FirstParameterType,
+    IChatbotApiClient,
+    IChatbotClientSettings,
+    SecondParameterType,
+} from '../base/chatbot-api-client';
+// eslint-disable-next-line no-restricted-imports
+import { Client } from './native-client';
+
+/**
+ * Settings for the chatbot client, which includes a factory for constructor parameters, and additional settings
+ * like version and clientId which are used in the API calls.
+ */
+export interface IChatbotClientSettingsTitanChat extends IChatbotClientSettings {
+    constructorParametersFactory: () => {
+        baseUrl?: FirstParameterType<typeof Client>;
+        http?: SecondParameterType<typeof Client>;
+    };
+    version: string;
+    clientId: string;
+}
+
+/**
+ * Client adapter adopts the generated titan chatbot client to the generic IChatbotApiClient interface.
+ * Contains client-specific methods for interacting with the titan chatbot API.
+ */
+@injectable()
+export class ChatbotApiClient implements IChatbotApiClient {
+    private readonly client: Client;
+
+    get version(): string {
+        return this.chatbotApiClientSettings.version;
+    }
+
+    get clientId(): string {
+        return this.chatbotApiClientSettings.clientId;
+    }
+
+    constructor(
+        @inject(CHATBOT_CLIENT_SETTINGS)
+        private readonly chatbotApiClientSettings: IChatbotClientSettingsTitanChat
+    ) {
+        const { baseUrl, http } = this.chatbotApiClientSettings.constructorParametersFactory();
+        this.client = new Client(baseUrl, http);
+    }
+
+    postRefreshAuthCookies(_?: AbortSignal): Promise<boolean> {
+        return Promise.resolve<boolean>(true);
+    }
+
+    postFeedback(body: Models.Feedback, abortSignal?: AbortSignal) {
+        return this.client.feedback(this.version, this.clientId, body, abortSignal);
+    }
+
+    postMessage(body: Models.UserMessage, abortSignal?: AbortSignal) {
+        return this.client.message(this.version, this.clientId, body, abortSignal);
+    }
+
+    getOptions(abortSignal?: AbortSignal): Promise<Models.FrontendModel> {
+        return this.client.options(this.version, this.clientId, abortSignal);
+    }
+
+    async postSession(body: Models.Session, abortSignal?: AbortSignal) {
+        return this.client.sessionPOST(this.version, this.clientId, body, abortSignal);
+    }
+
+    patchSession(body: Models.Session, abortSignal?: AbortSignal) {
+        return this.client.sessionPATCH(this.version, this.clientId, body, abortSignal);
+    }
+
+    deleteSession(body: Models.Session, abortSignal?: AbortSignal) {
+        return this.client.sessionDELETE(this.version, this.clientId, body, abortSignal);
+    }
+}

package/src/api-client/titan-chat/index.ts

@@ -0,0 +1 @@
+export { ChatbotApiClient, IChatbotClientSettingsTitanChat } from './chatbot-api-client';