@bytexbyte/nxtlinq-ai-agent-sdk 1.2.2 → 1.2.3

package/dist/components/context/ChatBotContext.js

@@ -0,0 +1,737 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from 'react';
+import { ethers } from 'ethers';
+import { createNxtlinqApi } from '../../api/nxtlinq-api';
+import stringify from 'fast-json-stable-stringify';
+import metakeepClient from '../../core/metakeepClient';
+import useLocalStorage from '../../core/lib/useLocalStorage';
+const ChatBotContext = React.createContext(undefined);
+export const useChatBot = () => {
+    const context = React.useContext(ChatBotContext);
+    if (!context) {
+        throw new Error('useChatBot must be used within a ChatBotProvider');
+    }
+    return context;
+};
+export const ChatBotProvider = ({ onMessage, onError, onToolUse, presetMessages = [], placeholder = 'Type a message...', className = '', maxRetries = 3, retryDelay = 1000, serviceId, apiKey, apiSecret, onVerifyWallet, permissionGroup, children }) => {
+    // State
+    const [messages, setMessages] = React.useState([]);
+    const [inputValue, setInputValue] = React.useState('');
+    const [isLoading, setIsLoading] = React.useState(false);
+    const [isOpen, setIsOpen] = React.useState(false);
+    const [hitAddress, setHitAddress] = React.useState(null);
+    const [ait, setAit] = React.useState(null);
+    const [permissions, setPermissions] = React.useState([]);
+    const [availablePermissions, setAvailablePermissions] = React.useState([]);
+    const [showPermissionForm, setShowPermissionForm] = React.useState(false);
+    const [isPermissionFormOpen, setIsPermissionFormOpen] = React.useState(false);
+    const [isAITLoading, setIsAITLoading] = React.useState(false);
+    const [isDisabled, setIsDisabled] = React.useState(true);
+    const [signer, setSigner] = React.useState(null);
+    const [walletInfo, setWalletInfo] = React.useState(null);
+    const [isWalletLoading, setIsWalletLoading] = React.useState(false);
+    const [nxtlinqAITServiceAccessToken, setNxtlinqAITServiceAccessToken] = useLocalStorage('nxtlinqAITServiceAccessToken', '');
+    const [notification, setNotification] = React.useState({
+        show: false,
+        type: 'info',
+        message: '',
+        autoHide: true,
+        duration: 5000
+    });
+    const nxtlinqApi = React.useMemo(() => createNxtlinqApi(apiKey, apiSecret), [apiKey, apiSecret]);
+    // Notification functions
+    const showNotification = (type, message, duration = 5000) => {
+        setNotification({
+            show: true,
+            type,
+            message,
+            autoHide: true,
+            duration
+        });
+        if (duration > 0) {
+            setTimeout(() => {
+                setNotification(prev => ({ ...prev, show: false }));
+            }, duration);
+        }
+    };
+    const showSuccess = (message) => showNotification('success', message, 3000);
+    const showError = (message) => showNotification('error', message, 5000);
+    const showWarning = (message) => showNotification('warning', message, 4000);
+    const showInfo = (message) => showNotification('info', message, 3000);
+    // Fetch available permissions
+    const fetchAvailablePermissions = async () => {
+        if (!serviceId)
+            return;
+        try {
+            const result = await nxtlinqApi.permissions.getServicePermissions({
+                serviceId,
+                ...(permissionGroup && { groupName: permissionGroup })
+            });
+            if ('error' in result) {
+                console.error('Failed to fetch permissions:', result.error);
+                return;
+            }
+            setAvailablePermissions(result.permissions);
+        }
+        catch (error) {
+            console.error('Error fetching permissions:', error);
+        }
+    };
+    // Refresh AIT
+    const refreshAIT = async (forceUpdatePermissions = false) => {
+        if (!hitAddress) {
+            setAit(null);
+            setPermissions([]);
+            setWalletInfo(null);
+            return;
+        }
+        setIsAITLoading(true);
+        try {
+            // Get wallet info first
+            if (nxtlinqAITServiceAccessToken) {
+                try {
+                    const walletResponse = await nxtlinqApi.wallet.getWallet({ address: hitAddress }, nxtlinqAITServiceAccessToken);
+                    if (!('error' in walletResponse)) {
+                        setWalletInfo(walletResponse);
+                    }
+                }
+                catch (error) {
+                    console.error('Failed to fetch wallet info:', error);
+                }
+            }
+            const response = await nxtlinqApi.ait.getAITByServiceIdAndController({
+                serviceId,
+                controller: hitAddress
+            }, nxtlinqAITServiceAccessToken || '');
+            if ('error' in response) {
+                console.error('Failed to fetch AIT:', response.error);
+                setAit(null);
+                setPermissions([]);
+                return;
+            }
+            setAit(response);
+            if (!isPermissionFormOpen || forceUpdatePermissions) {
+                const newPermissions = response.metadata?.permissions || [];
+                setPermissions(newPermissions);
+            }
+        }
+        catch (error) {
+            console.error('Failed to fetch AIT:', error);
+            setAit(null);
+            setPermissions([]);
+        }
+        finally {
+            setIsAITLoading(false);
+        }
+    };
+    // Check if user needs to sign in
+    const isNeedSignInWithWallet = React.useMemo(() => {
+        if (!hitAddress)
+            return false;
+        if (!nxtlinqAITServiceAccessToken)
+            return true;
+        try {
+            const payload = JSON.parse(atob(nxtlinqAITServiceAccessToken.split('.')[1]));
+            const exp = payload.exp * 1000;
+            const now = Date.now();
+            if (exp < now)
+                return true;
+            const address = payload.address;
+            if (address !== hitAddress)
+                return true;
+            return false;
+        }
+        catch (error) {
+            console.error('Error parsing token:', error);
+            return true;
+        }
+    }, [hitAddress, nxtlinqAITServiceAccessToken]);
+    // Connect wallet
+    const connectWallet = React.useCallback(async (autoShowSignInMessage = true) => {
+        if (typeof window === 'undefined') {
+            console.error('Web3 is not available in server-side rendering');
+            return;
+        }
+        try {
+            const web3Provider = await metakeepClient.ethereum;
+            if (!web3Provider) {
+                throw new Error('Web3 provider not available');
+            }
+            await web3Provider.enable();
+            const ethersProvider = new ethers.providers.Web3Provider(web3Provider);
+            const userSigner = await ethersProvider.getSigner();
+            const userAddress = await userSigner.getAddress();
+            localStorage.setItem('walletAddress', userAddress);
+            setHitAddress(userAddress);
+            setSigner(userSigner);
+            if (nxtlinqAITServiceAccessToken) {
+                await refreshAIT();
+            }
+            if (autoShowSignInMessage) {
+                if (isNeedSignInWithWallet) {
+                    setMessages(prev => [...prev, {
+                            id: Date.now().toString(),
+                            content: 'Please sign in with your wallet to continue.',
+                            role: 'assistant',
+                            timestamp: new Date().toISOString(),
+                            button: 'signIn'
+                        }]);
+                }
+                else {
+                    showSuccess('Successfully connected your HIT wallet. You are already signed in and can use the AI agent.');
+                }
+            }
+            return userAddress;
+        }
+        catch (error) {
+            console.error('Failed to connect wallet:', error);
+            localStorage.removeItem('walletAddress');
+            setHitAddress(null);
+            setSigner(null);
+            throw error;
+        }
+    }, [nxtlinqAITServiceAccessToken, refreshAIT, isNeedSignInWithWallet]);
+    // Sign in wallet
+    const signInWallet = async (autoShowSuccessMessage = true) => {
+        if (!hitAddress) {
+            showError('Please connect your wallet first.');
+            return;
+        }
+        if (!signer) {
+            showError('Please connect your wallet first.');
+            return;
+        }
+        try {
+            const nonceResponse = await nxtlinqApi.auth.getNonce({ address: hitAddress });
+            if ('error' in nonceResponse) {
+                showError(nonceResponse.error);
+                return;
+            }
+            const payload = {
+                address: hitAddress,
+                code: nonceResponse.code,
+                timestamp: nonceResponse.timestamp
+            };
+            const stringToSign = stringify(payload);
+            const signature = await signer.signMessage(stringToSign || '');
+            const response = await nxtlinqApi.auth.signIn({
+                ...payload,
+                signature
+            });
+            if ('error' in response) {
+                showError(response.error);
+                return;
+            }
+            const { accessToken } = response;
+            setNxtlinqAITServiceAccessToken(accessToken);
+            if (autoShowSuccessMessage) {
+                showSuccess('Successfully signed in with your HIT wallet. You can now use the AI agent.');
+            }
+            refreshAIT();
+        }
+        catch (error) {
+            console.error('Failed to sign in:', error);
+            showError('Failed to sign in. Please try again.');
+        }
+    };
+    // Check permissions
+    const hasPermission = async (toolName) => {
+        if (!hitAddress) {
+            setMessages(prev => [...prev, {
+                    id: Date.now().toString(),
+                    content: 'Please connect your HIT wallet to continue.',
+                    role: 'assistant',
+                    timestamp: new Date().toISOString(),
+                    button: 'connect'
+                }]);
+            return false;
+        }
+        if (!nxtlinqAITServiceAccessToken) {
+            setMessages(prev => [...prev, {
+                    id: Date.now().toString(),
+                    content: 'Please sign in with your HIT wallet to continue.',
+                    role: 'assistant',
+                    timestamp: new Date().toISOString(),
+                    button: 'signIn'
+                }]);
+            return false;
+        }
+        try {
+            const payload = JSON.parse(atob(nxtlinqAITServiceAccessToken.split('.')[1]));
+            const exp = payload.exp * 1000;
+            const now = Date.now();
+            if (exp < now) {
+                setNxtlinqAITServiceAccessToken('');
+                setMessages(prev => [...prev, {
+                        id: Date.now().toString(),
+                        content: 'Your wallet session has expired. Please sign in again.',
+                        role: 'assistant',
+                        timestamp: new Date().toISOString(),
+                        button: 'signIn'
+                    }]);
+                return false;
+            }
+            const address = payload.address;
+            if (address !== hitAddress) {
+                setNxtlinqAITServiceAccessToken('');
+                setMessages(prev => [...prev, {
+                        id: Date.now().toString(),
+                        content: 'Wallet address mismatch. Please sign in with the correct wallet.',
+                        role: 'assistant',
+                        timestamp: new Date().toISOString(),
+                        button: 'signIn'
+                    }]);
+                return false;
+            }
+        }
+        catch (error) {
+            console.error('Error parsing token:', error);
+            setNxtlinqAITServiceAccessToken('');
+            setMessages(prev => [...prev, {
+                    id: Date.now().toString(),
+                    content: 'Invalid wallet session. Please sign in again.',
+                    role: 'assistant',
+                    timestamp: new Date().toISOString(),
+                    button: 'signIn'
+                }]);
+            return false;
+        }
+        if (!ait) {
+            // Show loading message if AIT is still loading
+            if (isAITLoading) {
+                setMessages(prev => [...prev, {
+                        id: Date.now().toString(),
+                        content: 'Loading your wallet configuration... Please wait a moment.',
+                        role: 'assistant',
+                        timestamp: new Date().toISOString()
+                    }]);
+                return false;
+            }
+            setMessages(prev => [...prev, {
+                    id: Date.now().toString(),
+                    content: 'No AIT found for your wallet. Please click the settings button (⚙️) to configure your AIT permissions.',
+                    role: 'assistant',
+                    timestamp: new Date().toISOString()
+                }]);
+            return false;
+        }
+        const availablePermissionLabels = availablePermissions.map(p => p.label);
+        if (!availablePermissionLabels.includes(toolName)) {
+            setMessages(prev => [...prev, {
+                    id: Date.now().toString(),
+                    content: `This tool (${toolName}) is not available for your current identity provider.`,
+                    role: 'assistant',
+                    timestamp: new Date().toISOString()
+                }]);
+            return false;
+        }
+        if (!permissions.includes(toolName)) {
+            setMessages(prev => [...prev, {
+                    id: Date.now().toString(),
+                    content: `You do not have the required AIT permission: ${toolName}. Please click the settings button (⚙️) to update your permissions.`,
+                    role: 'assistant',
+                    timestamp: new Date().toISOString()
+                }]);
+            return false;
+        }
+        return true;
+    };
+    // Send message
+    const sendMessage = async (content, retryCount = 0) => {
+        try {
+            setIsLoading(true);
+            const response = await nxtlinqApi.agent.sendMessage({
+                message: content,
+                apiKey,
+                apiSecret,
+            });
+            if ('error' in response) {
+                throw new Error(response.error);
+            }
+            const novaResponse = response;
+            if (novaResponse.toolCall?.toolUse && novaResponse.result !== 'Authentication data retrieved') {
+                if (onToolUse) {
+                    const isToolAllowed = await hasPermission(novaResponse.toolCall.toolUse.name);
+                    if (!isToolAllowed) {
+                        return;
+                    }
+                    const toolUseResult = await onToolUse(novaResponse.toolCall.toolUse);
+                    if (toolUseResult) {
+                        setMessages(prev => [...prev, toolUseResult]);
+                        return;
+                    }
+                }
+            }
+            if (!novaResponse.toolCall?.toolUse && novaResponse.reply) {
+                const replyText = novaResponse.reply
+                    .map(item => item.text.replace(/<thinking>/g, '').replace(/<\/thinking>/g, ''))
+                    .join(' ') || '';
+                if (replyText) {
+                    const message = {
+                        id: Date.now().toString(),
+                        content: replyText,
+                        role: 'assistant',
+                        timestamp: new Date().toISOString()
+                    };
+                    setMessages(prev => [...prev, message]);
+                    return;
+                }
+            }
+            return;
+        }
+        catch (error) {
+            if (retryCount < maxRetries) {
+                await new Promise(resolve => setTimeout(resolve, retryDelay));
+                return sendMessage(content, retryCount + 1);
+            }
+            throw error;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    };
+    // Handle submit
+    const handleSubmit = async (e) => {
+        e.preventDefault();
+        if (!inputValue.trim() || isLoading)
+            return;
+        // Show loading message if AIT is still loading
+        if (isAITLoading) {
+            const loadingMessage = {
+                id: Date.now().toString(),
+                content: 'Loading your wallet configuration... Please wait a moment.',
+                role: 'assistant',
+                timestamp: new Date().toISOString()
+            };
+            setMessages(prev => [...prev, loadingMessage]);
+            return;
+        }
+        const userMessage = {
+            id: Date.now().toString(),
+            content: inputValue,
+            role: 'user',
+            timestamp: new Date().toISOString()
+        };
+        setMessages(prev => [...prev, userMessage]);
+        setInputValue('');
+        setIsLoading(true);
+        try {
+            await sendMessage(inputValue);
+        }
+        catch (error) {
+            console.error('Failed to send message:', error);
+            onError?.(error instanceof Error ? error : new Error('Failed to send message'));
+            const errorMessage = {
+                id: Date.now().toString(),
+                content: 'Sorry, there was an error processing your message. Please try again.',
+                role: 'assistant',
+                timestamp: new Date().toISOString()
+            };
+            setMessages(prev => [...prev, errorMessage]);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    };
+    // Handle preset message
+    const handlePresetMessage = (message) => {
+        // Show loading message if AIT is still loading
+        if (isAITLoading) {
+            const loadingMessage = {
+                id: Date.now().toString(),
+                content: 'Loading your wallet configuration... Please wait a moment.',
+                role: 'assistant',
+                timestamp: new Date().toISOString()
+            };
+            setMessages(prev => [...prev, loadingMessage]);
+            return;
+        }
+        if (message.autoSend) {
+            setMessages(prev => [...prev, {
+                    id: Date.now().toString(),
+                    content: message.text,
+                    role: 'user',
+                    timestamp: new Date().toISOString()
+                }]);
+            sendMessage(message.text);
+        }
+        else {
+            setInputValue(message.text);
+        }
+    };
+    // Generate and register AIT
+    const generateAndRegisterAIT = async () => {
+        if (!signer || !hitAddress) {
+            throw new Error('Missing signer or wallet address');
+        }
+        const timestamp = Math.floor(Date.now() / 1000);
+        const aitId = `did:polygon:ike-dashboard:${hitAddress}:${timestamp}`;
+        const metadata = {
+            model: 'gpt-4',
+            permissions,
+            issuedBy: hitAddress,
+        };
+        const metadataStr = stringify(metadata);
+        const metadataHash = ethers.utils.keccak256(ethers.utils.toUtf8Bytes(metadataStr));
+        const uploadResponse = await nxtlinqApi.metadata.createMetadata(metadata, nxtlinqAITServiceAccessToken || '');
+        if ('error' in uploadResponse) {
+            throw new Error(`Failed to upload metadata: ${uploadResponse.error}`);
+        }
+        const { metadataCid } = uploadResponse;
+        const createAITResponse = await nxtlinqApi.ait.createAIT({
+            aitId,
+            controller: hitAddress,
+            serviceId,
+            metadataHash,
+            metadataCid,
+        }, nxtlinqAITServiceAccessToken || '');
+        if ('error' in createAITResponse) {
+            throw new Error(`Failed to create AIT: ${createAITResponse.error}`);
+        }
+        const aitInfo = {
+            aitId,
+            controller: hitAddress,
+            metadata,
+            metadataHash,
+            metadataCid,
+        };
+        setAit(aitInfo);
+        setPermissions(permissions);
+    };
+    // Save permissions
+    const savePermissions = async () => {
+        setIsDisabled(true);
+        try {
+            await generateAndRegisterAIT();
+            showSuccess('AIT permissions saved successfully! You can now use the AI agent with your configured permissions.');
+            setShowPermissionForm(false);
+            setIsPermissionFormOpen(false);
+            await refreshAIT(true);
+        }
+        catch (error) {
+            console.error('Failed to generate AIT:', error);
+            setIsDisabled(false);
+            if (error instanceof Error) {
+                showError(error.message);
+            }
+            else {
+                showError('Failed to save permissions. Please try again.');
+            }
+        }
+    };
+    // Handle verify wallet click
+    const handleVerifyWalletClick = async () => {
+        if (!hitAddress) {
+            showError('Please connect your wallet first.');
+            return;
+        }
+        try {
+            if (onVerifyWallet) {
+                setIsLoading(true);
+                const result = await onVerifyWallet();
+                if (!result) {
+                    setIsLoading(false);
+                    return;
+                }
+                const { token } = result;
+                const address = hitAddress;
+                if (token && address) {
+                    const payload = {
+                        address: hitAddress,
+                        token,
+                        timestamp: Date.now(),
+                        method: 'berifyme'
+                    };
+                    try {
+                        const verifyWalletResponse = await nxtlinqApi.wallet.verifyWallet({ ...payload }, token);
+                        if ('error' in verifyWalletResponse) {
+                            if (verifyWalletResponse.error === 'Wallet already exists') {
+                                setIsWalletLoading(true);
+                                try {
+                                    const walletResponse = await nxtlinqApi.wallet.getWallet({ address }, token);
+                                    if (!('error' in walletResponse)) {
+                                        setWalletInfo(walletResponse);
+                                        const aitResponse = await nxtlinqApi.ait.getAITByServiceIdAndController({ serviceId, controller: address }, token);
+                                        if (!('error' in aitResponse)) {
+                                            setAit(aitResponse);
+                                        }
+                                    }
+                                }
+                                finally {
+                                    setIsWalletLoading(false);
+                                }
+                                if (typeof window !== 'undefined') {
+                                    try {
+                                        const url = new URL(window.location.href);
+                                        url.searchParams.delete('token');
+                                        url.searchParams.delete('isAutoConnect');
+                                        url.searchParams.delete('method');
+                                        url.searchParams.delete('returnUrl');
+                                        window.history.replaceState({}, '', url.toString());
+                                    }
+                                    catch (e) {
+                                        console.error('Failed to clean URL:', e);
+                                    }
+                                }
+                                setIsLoading(false);
+                                showSuccess('Wallet verification completed successfully! Your wallet is now verified and ready to use.');
+                                refreshAIT();
+                                return;
+                            }
+                            showError(verifyWalletResponse.error);
+                            setIsLoading(false);
+                            return;
+                        }
+                        setIsWalletLoading(true);
+                        try {
+                            const walletResponse = await nxtlinqApi.wallet.getWallet({ address }, token);
+                            if (!('error' in walletResponse)) {
+                                setWalletInfo(walletResponse);
+                                const aitResponse = await nxtlinqApi.ait.getAITByServiceIdAndController({ serviceId, controller: address }, token);
+                                if (!('error' in aitResponse)) {
+                                    setAit(aitResponse);
+                                }
+                            }
+                        }
+                        finally {
+                            setIsWalletLoading(false);
+                        }
+                        if (typeof window !== 'undefined') {
+                            try {
+                                const url = new URL(window.location.href);
+                                url.searchParams.delete('token');
+                                url.searchParams.delete('isAutoConnect');
+                                url.searchParams.delete('method');
+                                url.searchParams.delete('returnUrl');
+                                window.history.replaceState({}, '', url.toString());
+                            }
+                            catch (e) {
+                                console.error('Failed to clean URL:', e);
+                            }
+                        }
+                        setIsLoading(false);
+                        showSuccess('Wallet verification completed successfully! Your wallet is now verified and ready to use.');
+                        refreshAIT();
+                        return;
+                    }
+                    catch (error) {
+                        let msg = 'Verification failed';
+                        if (typeof error === 'object' && error !== null && 'response' in error) {
+                            msg = error.response?.data?.error || error.message || msg;
+                        }
+                        else if (error instanceof Error) {
+                            msg = error.message;
+                        }
+                        console.error('Wallet verification failed:', error);
+                        showError(msg);
+                        setIsLoading(false);
+                        throw error;
+                    }
+                }
+                setIsLoading(false);
+                return;
+            }
+        }
+        catch (error) {
+            console.error('Failed to verify wallet:', error);
+            setIsLoading(false);
+            showError('Failed to verify wallet. Please try again.');
+            throw error;
+        }
+    };
+    // Effects
+    React.useEffect(() => {
+        if (hitAddress && nxtlinqAITServiceAccessToken) {
+            refreshAIT();
+        }
+    }, [hitAddress, nxtlinqAITServiceAccessToken]);
+    React.useEffect(() => {
+        fetchAvailablePermissions();
+    }, [serviceId, permissionGroup]);
+    React.useEffect(() => {
+        if (typeof window !== 'undefined') {
+            try {
+                const urlParams = new URLSearchParams(window.location.search);
+                const token = urlParams.get('token');
+                if (token && hitAddress) {
+                    handleVerifyWalletClick();
+                }
+            }
+            catch (e) {
+                console.error('Failed to get URL params:', e);
+            }
+        }
+    }, [hitAddress]);
+    React.useEffect(() => {
+        if (messages.length > 0) {
+            const lastMessage = messages[messages.length - 1];
+            onMessage?.(lastMessage);
+        }
+    }, [messages, onMessage]);
+    const contextValue = {
+        // State
+        messages,
+        inputValue,
+        isLoading,
+        isOpen,
+        hitAddress,
+        ait,
+        permissions,
+        availablePermissions,
+        showPermissionForm,
+        isPermissionFormOpen,
+        isAITLoading,
+        isDisabled,
+        walletInfo,
+        isWalletLoading,
+        notification,
+        // Actions
+        setInputValue,
+        setIsOpen,
+        setShowPermissionForm,
+        setIsPermissionFormOpen,
+        setPermissions,
+        setIsDisabled,
+        setIsWalletLoading,
+        setNotification,
+        // Functions
+        connectWallet,
+        signInWallet,
+        sendMessage,
+        handleSubmit,
+        handlePresetMessage,
+        savePermissions,
+        handleVerifyWalletClick,
+        showSuccess,
+        showError,
+        showWarning,
+        showInfo,
+        refreshAIT,
+        // Additional properties for PermissionForm
+        onSave: savePermissions,
+        onConnectWallet: () => connectWallet(false),
+        onSignIn: () => signInWallet(false),
+        isNeedSignInWithWallet,
+        onVerifyWallet: handleVerifyWalletClick,
+        serviceId,
+        permissionGroup,
+        // Props
+        props: {
+            onMessage,
+            onError,
+            onToolUse,
+            presetMessages,
+            placeholder,
+            className,
+            maxRetries,
+            retryDelay,
+            serviceId,
+            apiKey,
+            apiSecret,
+            onVerifyWallet,
+            permissionGroup
+        },
+        nxtlinqApi
+    };
+    return (_jsx(ChatBotContext.Provider, { value: contextValue, children: children }));
+};