@chatbotkit/react 1.7.0 → 1.8.0

package/dist/cjs/hooks/useConversationManager.cjs

@@ -1,191 +1,127 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useConversationManager = void 0;
+const tslib_1 = require("tslib");
 const react_1 = require("react");
-const object_js_1 = require("../utils/object.cjs");
-const stream_js_1 = require("../utils/stream.cjs");
-const string_js_1 = require("../utils/string.cjs");
-const sdk_1 = require("@chatbotkit/sdk");
-function useConversationManager(options) {
-    const { client: _client, endpoint, token: _token, conversationId: _conversationId, botId: _botId, backstory: _backstory, model: _model, datasetId: _datasetId, skillsetId: _skillsetId, ...rest } = options;
-    const [token, setToken] = (0, react_1.useState)(_token);
-    const [conversationId, setConversationId] = (0, react_1.useState)(_conversationId);
-    const [botId, setBotId] = (0, react_1.useState)(_botId);
-    const [backstory, setBackstory] = (0, react_1.useState)(_backstory);
-    const [model, setModel] = (0, react_1.useState)(_model);
-    const [datasetId, setDatasetId] = (0, react_1.useState)(_datasetId);
-    const [skillsetId, setSkillsetId] = (0, react_1.useState)(_skillsetId);
-    const client = (0, react_1.useMemo)(() => {
-        var _a, _b;
-        if (typeof endpoint === 'function') {
-            return {
-                complete(conversationId, options) {
-                    return {
-                        async *stream() {
-                            yield* (0, stream_js_1.consume)(endpoint(conversationId, options));
-                        },
-                    };
-                },
-            };
-        }
-        const options = { ...rest, secret: token || '' };
-        let thisClient = _client || new sdk_1.ConversationClient(options);
-        const extension = {};
-        if (typeof endpoint === 'string') {
-            extension.url = new URL(((_b = (_a = globalThis.window) === null || _a === void 0 ? void 0 : _a.location) === null || _b === void 0 ? void 0 : _b.origin) || 'about:blank');
-            extension.endpoints = {
-                '/api/v1/conversation/complete': endpoint,
-            };
-        }
-        if (token) {
-            extension.secret = token;
-        }
-        if (Object.keys(extension).length === 0) {
-            return thisClient;
-        }
-        else {
-            return (0, object_js_1.cloneAndExtend)(thisClient, extension);
-        }
-    }, [_client, endpoint, token]);
+const useConversationManagerRemote_js_1 = tslib_1.__importDefault(require("./useConversationManagerRemote.cjs"));
+const useConversationManagerState_js_1 = require("./useConversationManagerState.cjs");
+function useConversationManager({ ...conversationManagerRemoteOptions }) {
+    const remote = (0, useConversationManagerRemote_js_1.default)(conversationManagerRemoteOptions);
+    const [{ thinking, typing, message, messages, }, { setThinking, setTyping, appendText, appendMessage, },] = (0, useConversationManagerState_js_1.useConversationManagerState)();
     const [text, setText] = (0, react_1.useState)((''));
-    const [messages, setMessages] = (0, react_1.useState)(([]));
-    const [thinking, setThinking] = (0, react_1.useState)(false);
-    const [typing, setTyping] = (0, react_1.useState)(false);
     const [error, setError] = (0, react_1.useState)((null));
     async function stream(newMessages) {
-        setThinking(true);
-        let it;
-        try {
-            if (conversationId) {
-                it = client.complete(conversationId, { text });
-            }
-            else {
-                it = client.complete(null, {
-                    backstory: backstory,
-                    model: model,
-                    datasetId: datasetId,
-                    skillsetId: skillsetId,
-                    messages: newMessages
-                        .slice(-100)
-                        .map(({ type, text, meta }) => ({ type, text, meta })),
-                });
-            }
-        }
-        catch (e) {
-            setThinking(false);
-            setError(e);
-            return;
-        }
-        const botMessage = {
-            id: (0, string_js_1.getRandomId)('message-'),
-            type: 'bot',
-            text: '',
-        };
-        let alreadyStreaming = false;
+        const allMessages = [
+            ...messages.map(({ type, text, meta }) => {
+                return {
+                    type,
+                    text,
+                    meta,
+                };
+            }),
+            ...((newMessages === null || newMessages === void 0 ? void 0 : newMessages.map(({ type, text, meta }) => {
+                return {
+                    type,
+                    text,
+                    meta,
+                };
+            })) || []),
+        ].slice(-100);
         try {
-            for await (const event of it.stream()) {
-                switch (event.type) {
+            setThinking(true);
+            setError(null);
+            for await (const item of remote(allMessages)) {
+                switch (item.type) {
                     case 'token': {
-                        if (!alreadyStreaming) {
-                            alreadyStreaming = true;
-                            newMessages = [...newMessages, botMessage];
-                            setMessages(newMessages);
-                            setThinking(false);
-                            setTyping(true);
-                        }
-                        botMessage.text += event.data.token;
-                        setMessages([...newMessages]);
+                        appendText(item.data.token);
                         break;
                     }
                     case 'message': {
-                        const message = event.data;
-                        if (botMessage.text !== message.text ||
-                            message.type === 'activity' ||
-                            typeof message.children !== 'undefined') {
-                            const newMessage = {
-                                id: (0, string_js_1.getRandomId)('message-'),
-                                ...event.data,
-                            };
-                            newMessages = [...newMessages, newMessage];
-                            setMessages([...newMessages]);
-                        }
+                        appendMessage(item.data);
                         break;
                     }
-                    case 'result': {
-                        setThinking(false);
-                        setTyping(false);
-                    }
                 }
             }
         }
         catch (e) {
             setError(e);
+            if (typeof process !== 'undefined' &&
+                process.env.NODE_ENV === 'development') {
+                console.error(e);
+            }
         }
         finally {
+            setThinking(false);
             setTyping(false);
         }
     }
-    async function submit() {
-        if (!text) {
+    async function submit(thisText) {
+        if (thinking || typing) {
             return;
         }
-        setText('');
+        if (!thisText) {
+            if (!text) {
+                return;
+            }
+            thisText = text;
+            setText('');
+        }
         const userMessage = {
-            id: (0, string_js_1.getRandomId)('message-'),
             type: 'user',
-            text: text,
+            text: thisText,
         };
-        let newMessages = messages.slice(0);
-        newMessages = [...newMessages, userMessage];
-        setMessages([...newMessages]);
-        await stream(newMessages);
+        appendMessage(userMessage);
+        await stream([userMessage]);
     }
-    async function trigger(name, ...args) {
-        const newMessages = [
-            ...messages,
-            ({
-                type: 'activity',
-                text: '',
-                meta: {
-                    activity: {
-                        type: 'trigger',
-                        function: {
-                            name: name,
-                            arguments: args,
-                        },
+    async function trigger(name) {
+        if (thinking || typing) {
+            return;
+        }
+        const activityMessage = {
+            type: 'activity',
+            text: '',
+            meta: {
+                activity: {
+                    type: 'trigger',
+                    function: {
+                        name: name,
                     },
                 },
-            }),
-        ];
-        await stream(newMessages);
+            },
+        };
+        await stream([activityMessage]);
+    }
+    async function request(name, args) {
+        if (thinking || typing) {
+            return;
+        }
+        const activityMessage = {
+            type: 'activity',
+            text: '',
+            meta: {
+                activity: {
+                    type: 'request',
+                    function: {
+                        name: name,
+                        arguments: args,
+                    },
+                },
+            },
+        };
+        await stream([activityMessage]);
     }
     return {
-        token,
-        setToken,
-        conversationId,
-        setConversationId,
-        botId,
-        setBotId,
-        backstory,
-        setBackstory,
-        model,
-        setModel,
-        datasetId,
-        setDatasetId,
-        skillsetId,
-        setSkillsetId,
-        text,
-        setText,
+        message,
         messages,
-        setMessages,
         thinking,
-        setThinking,
         typing,
-        setTyping,
+        text,
+        setText,
         error,
         setError,
         submit,
         trigger,
+        request,
     };
 }
 exports.useConversationManager = useConversationManager;

package/dist/cjs/hooks/useConversationManager.d.ts

@@ -1,63 +1,18 @@
-export function useConversationManager(options: UseConversationManagerOptions): UseConversationManagerResult;
+export function useConversationManager({ ...conversationManagerRemoteOptions }: UseConversationManagerOptions): UseConversationManagerResult;
 export default useConversationManager;
-export type ModelConfig = {
-    maxTokens?: number;
-    temperature?: number;
-    frequencyPenalty?: number;
-    presencePenalty?: number;
-    seed?: number;
-    interactionMaxMessages?: number;
-    region?: 'us' | 'eu';
-};
-export type Model = string | {
-    name: string;
-    config?: ModelConfig;
-};
-export type Message = {
-    id?: string;
-    type: 'bot' | 'user' | 'context' | 'instruction' | 'backstory' | 'activity';
-    text: string;
-    meta?: Record<string, any>;
-};
-export type EndpointURL = string;
-export type EndpointFunction = (conversationId: any, request: any) => AsyncGenerator<any>;
-export type UseConversationManagerOptions = {
-    [key: string]: any;
-    client?: ConversationClient;
-    endpoint?: EndpointURL | EndpointFunction;
-    token?: string;
-    conversationId?: string;
-    backstory?: string;
-    Model?: string;
-    datasetId?: string;
-    skillsetId?: string;
-};
+export type Message = any;
+export type UseConversationManagerRemoteOptions = import('./useConversationManagerRemote.cjs').UseConversationManagerRemoteOptions;
+export type UseConversationManagerOptions = UseConversationManagerRemoteOptions & {};
 export type UseConversationManagerResult = {
-    token?: string;
-    setToken: (token: string) => void;
-    conversationId?: string;
-    setConversationId: (conversationId: string) => void;
-    botId?: string;
-    setBotId: (botId: string) => void;
-    backstory?: string;
-    setBackstory: (backstory: string) => void;
-    model?: Model;
-    setModel: (model: Model) => void;
-    datasetId?: string;
-    setDatasetId: (datasetId: string) => void;
-    skillsetId?: string;
-    setSkillsetId: (skillsetId: string) => void;
-    text: string;
-    setText: (text: string) => void;
+    message: any;
     messages: Message[];
-    setMessages: (messages: Message[]) => void;
     thinking: boolean;
-    setThinking: (thinking: boolean) => void;
     typing: boolean;
-    setTyping: (typing: boolean) => void;
+    text: string;
+    setText: (text: string) => void;
     error: any;
     setError: (error: any) => void;
     submit: () => void;
-    trigger: (name: string, ...args: any) => void;
+    trigger: (name: string) => void;
+    request: (name: string, args: any) => void;
 };
-import { ConversationClient } from '@chatbotkit/sdk';

package/dist/cjs/hooks/useConversationManagerRemote.cjs

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useConversationManagerRemote = void 0;
+const react_1 = require("react");
+const object_js_1 = require("../utils/object.cjs");
+const stream_js_1 = require("../utils/stream.cjs");
+const sdk_1 = require("@chatbotkit/sdk");
+function useConversationManagerRemote({ client: _client, endpoint, conversationId, token, backstory, model, datasetId, skillsetId, privacy, moderation, ...rest }) {
+    const client = (0, react_1.useMemo)(() => {
+        var _a, _b;
+        if (typeof endpoint === 'function') {
+            return {
+                complete(conversationId, options) {
+                    return {
+                        async *stream() {
+                            yield* (0, stream_js_1.consume)(endpoint(options));
+                        },
+                    };
+                },
+            };
+        }
+        const options = { ...rest, secret: token || '' };
+        let thisClient = _client || new sdk_1.ConversationClient(options);
+        const extension = {};
+        if (typeof endpoint === 'string') {
+            extension.url = new URL(((_b = (_a = globalThis.window) === null || _a === void 0 ? void 0 : _a.location) === null || _b === void 0 ? void 0 : _b.origin) || 'about:blank');
+            extension.endpoints = {
+                '/api/v1/conversation/complete': endpoint,
+            };
+        }
+        if (token) {
+            extension.secret = token;
+        }
+        if (Object.keys(extension).length === 0) {
+            return thisClient;
+        }
+        else {
+            return (0, object_js_1.cloneAndExtend)(thisClient, extension);
+        }
+    }, [_client, endpoint, token]);
+    const remote = (0, react_1.useMemo)(() => {
+        if (conversationId) {
+            return (async function* (messages) {
+                const lastUserMessage = [...messages]
+                    .reverse()
+                    .find((message) => message.type === 'user');
+                if (!lastUserMessage) {
+                    throw new Error('No user message found');
+                }
+                yield* client
+                    .complete(conversationId, { text: lastUserMessage.text })
+                    .stream();
+            });
+        }
+        else {
+            return (async function* (messages) {
+                yield* client
+                    .complete(null, {
+                    backstory: backstory,
+                    model: model,
+                    datasetId: datasetId,
+                    skillsetId: skillsetId,
+                    privacy: privacy,
+                    moderation: moderation,
+                    messages: messages,
+                })
+                    .stream();
+            });
+        }
+    }, [
+        client,
+        conversationId,
+        backstory,
+        model,
+        datasetId,
+        skillsetId,
+        privacy,
+        moderation,
+    ]);
+    return remote;
+}
+exports.useConversationManagerRemote = useConversationManagerRemote;
+exports.default = useConversationManagerRemote;

package/dist/cjs/hooks/useConversationManagerRemote.d.ts

@@ -0,0 +1,20 @@
+export function useConversationManagerRemote({ client: _client, endpoint, conversationId, token, backstory, model, datasetId, skillsetId, privacy, moderation, ...rest }: UseConversationManagerRemoteOptions): UseConversationManagerRemoteResult;
+export default useConversationManagerRemote;
+export type Message = any;
+export type Model = any;
+export type EndpointURL = string;
+export type EndpointFunction = (options: any) => AsyncGenerator<any>;
+export type UseConversationManagerRemoteOptions = {
+    client?: ConversationClient;
+    endpoint?: EndpointURL | EndpointFunction;
+    conversationId?: string;
+    token?: string;
+    backstory?: string;
+    model?: Model;
+    datasetId?: string;
+    skillsetId?: string;
+    privacy?: boolean;
+    moderation?: boolean;
+};
+export type UseConversationManagerRemoteResult = (messages: Message[]) => AsyncGenerator<any, void, any>;
+import { ConversationClient } from '@chatbotkit/sdk';

package/dist/cjs/hooks/useConversationManagerState.cjs

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useConversationManagerState = void 0;
+const tslib_1 = require("tslib");
+const react_1 = require("react");
+const useConversationManagerStateReducer_js_1 = tslib_1.__importDefault(require("./useConversationManagerStateReducer.cjs"));
+function useConversationManagerState(state) {
+    const [_, dispatch] = (0, useConversationManagerStateReducer_js_1.default)(state);
+    const setThinking = (0, react_1.useCallback)((thinking) => {
+        dispatch({ type: 'setThinking', data: { thinking } });
+    }, [dispatch]);
+    const setTyping = (0, react_1.useCallback)((typing) => {
+        dispatch({ type: 'setTyping', data: { typing } });
+    }, [dispatch]);
+    const appendText = (0, react_1.useCallback)((text) => {
+        dispatch({ type: 'appendText', data: { text } });
+    }, [dispatch]);
+    const appendMessage = (0, react_1.useCallback)((message) => {
+        dispatch({ type: 'appendMessage', data: { message } });
+    }, [dispatch]);
+    return [
+        _,
+        {
+            setThinking,
+            setTyping,
+            appendText,
+            appendMessage,
+        },
+    ];
+}
+exports.useConversationManagerState = useConversationManagerState;
+exports.default = useConversationManagerState;

package/dist/cjs/hooks/useConversationManagerState.d.ts

@@ -0,0 +1,10 @@
+export function useConversationManagerState(state?: Partial<State>): [State, StateFunctions];
+export default useConversationManagerState;
+export type Message = any;
+export type State = import('./useConversationManagerStateReducer.cjs').State;
+export type StateFunctions = {
+    setThinking: (thinking: boolean) => void;
+    setTyping: (typing: boolean) => void;
+    appendText: (text: string) => void;
+    appendMessage: (message: any) => void;
+};

package/dist/cjs/hooks/useConversationManagerStateReducer.cjs

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useConversationManagerStateReducer = exports.conversationManagerStateInitial = exports.conversationManagerStateReducer = void 0;
+const react_1 = require("react");
+const string_js_1 = require("../utils/string.cjs");
+function conversationManagerStateReducer(state, action) {
+    var _a;
+    switch (action.type) {
+        case 'setThinking': {
+            const { thinking } = action.data;
+            const extra = {};
+            if (thinking) {
+                extra.typing = false;
+                extra.message = null;
+            }
+            return {
+                ...state,
+                ...extra,
+                thinking,
+            };
+        }
+        case 'setTyping': {
+            const { typing } = action.data;
+            const extra = {};
+            if (typing) {
+                extra.thinking = false;
+                extra.message = null;
+            }
+            return {
+                ...state,
+                ...extra,
+                typing,
+            };
+        }
+        case 'appendText': {
+            const { text } = action.data;
+            const extra = {
+                thinking: false,
+                typing: true,
+            };
+            const message = state.message
+                ? ({ ...state.message })
+                : ({
+                    id: (0, string_js_1.getRandomId)('tmp-'),
+                    type: 'bot',
+                    text: '',
+                });
+            message.text += text;
+            return {
+                ...state,
+                ...extra,
+                message,
+            };
+        }
+        case 'appendMessage': {
+            const { message } = action.data;
+            const extra = {};
+            if (message.type === 'bot') {
+                if (message.text === ((_a = state.message) === null || _a === void 0 ? void 0 : _a.text)) {
+                    extra.typing = false;
+                    extra.message = null;
+                }
+            }
+            const messages = state.messages.slice(0);
+            if (message.id) {
+                const index = messages.findIndex((m) => m.id === message.id);
+                if (index !== -1) {
+                    messages[index] = {
+                        ...messages[index],
+                        ...message,
+                    };
+                }
+                else {
+                    messages.push({
+                        ...message,
+                        id: message.id || (0, string_js_1.getRandomId)('tmp-'),
+                    });
+                }
+            }
+            else {
+                messages.push({
+                    ...message,
+                    id: (0, string_js_1.getRandomId)('tmp-'),
+                });
+            }
+            return {
+                ...state,
+                ...extra,
+                messages,
+            };
+        }
+        default: {
+            throw new Error(`Unhandled action`);
+        }
+    }
+}
+exports.conversationManagerStateReducer = conversationManagerStateReducer;
+function conversationManagerStateInitial(state) {
+    return {
+        message: null,
+        messages: [],
+        thinking: false,
+        typing: false,
+        ...state,
+    };
+}
+exports.conversationManagerStateInitial = conversationManagerStateInitial;
+function useConversationManagerStateReducer(state) {
+    return (0, react_1.useReducer)(conversationManagerStateReducer, state, conversationManagerStateInitial);
+}
+exports.useConversationManagerStateReducer = useConversationManagerStateReducer;
+exports.default = useConversationManagerStateReducer;

package/dist/cjs/hooks/useConversationManagerStateReducer.d.ts

@@ -0,0 +1,42 @@
+export function conversationManagerStateReducer(state: State, action: Action): State;
+export function conversationManagerStateInitial(state?: Partial<State>): State;
+export function useConversationManagerStateReducer(state?: Partial<State>): [State, import('react').Dispatch<Action>];
+export default useConversationManagerStateReducer;
+export type Message = any;
+export type MessageWithId = {
+    id: string;
+} & Message;
+export type MessageWithOptionalId = {
+    id?: string;
+} & Message;
+export type State = {
+    thinking: boolean;
+    typing: boolean;
+    message: MessageWithId | null;
+    messages: MessageWithId[];
+};
+export type SetThinkingAction = {
+    type: 'setThinking';
+    data: {
+        thinking: boolean;
+    };
+};
+export type SetTypingAction = {
+    type: 'setTyping';
+    data: {
+        typing: boolean;
+    };
+};
+export type AppendTextAction = {
+    type: 'appendText';
+    data: {
+        text: string;
+    };
+};
+export type AppendMessageAction = {
+    type: 'appendMessage';
+    data: {
+        message: MessageWithOptionalId;
+    };
+};
+export type Action = SetThinkingAction | SetTypingAction | AppendTextAction | AppendMessageAction;

package/dist/cjs/utils/it.cjs

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAsyncGenerator = void 0;
+function isAsyncGenerator(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        typeof value[Symbol.asyncIterator] === 'function');
+}
+exports.isAsyncGenerator = isAsyncGenerator;

package/dist/cjs/utils/it.d.ts

@@ -0,0 +1 @@
+export function isAsyncGenerator(value: any): boolean;