@bytexbyte/nxtlinq-ai-agent-ui-react-development 0.4.0 → 0.4.2

package/dist/context/ChatBotContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ChatBotContext.d.ts","sourceRoot":"","sources":["../../src/context/ChatBotContext.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAyB/B,OAAO,EAEL,kBAAkB,EAClB,YAAY,EAEb,MAAM,uBAAuB,CAAC;AAM/B,eAAO,MAAM,UAAU,0BAMtB,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,YAAY,CAwvGlD,CAAC"}
+{"version":3,"file":"ChatBotContext.d.ts","sourceRoot":"","sources":["../../src/context/ChatBotContext.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AA6B/B,OAAO,EAEL,kBAAkB,EAClB,YAAY,EAEb,MAAM,uBAAuB,CAAC;AAM/B,eAAO,MAAM,UAAU,0BAMtB,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,YAAY,CA25FlD,CAAC"}

package/dist/context/ChatBotContext.js

@@ -5,6 +5,7 @@ import * as React from 'react';
 import { flushSync } from 'react-dom';
 import { v4 as uuidv4 } from 'uuid';
 import { createNxtlinqApi, setApiHosts, synthesizeSpeechToBuffer, streamSpeechToAudioContext, useLocalStorage, useSessionStorage, useSpeechToTextFromMic, useVoiceMode, metakeepClient, getEthers, sleep, walletTextUtils, } from '@bytexbyte/nxtlinq-ai-agent-web-development';
+import { authorizeTextFrontendTool, hasRecordedWalletVerification, } from '@bytexbyte/nxtlinq-ai-agent-core-development';
 const MIC_ENABLED_SESSION_KEY = 'chatbot-mic-enabled';
 const ChatBotContext = React.createContext(undefined);
 export const useChatBot = () => {
@@ -30,9 +31,7 @@ idvBannerDismissSeconds = 86400,
 // 24 hours in seconds
 isStopRecordingOnSend = false, 
 // Custom error message to display in chat
-customError, 
-// PII display mode
-piiDisplayMode = 'redacted', voiceThresholds, debugVoiceRms = false, sttGlossary, }) => {
+customError, voiceThresholds, debugVoiceRms = false, sttGlossary, }) => {
     // Set API hosts immediately based on environment (before any API calls)
     setApiHosts(environment);
     const nxtlinqApi = React.useMemo(() => (serviceToken || getAuthToken
@@ -769,6 +768,11 @@ piiDisplayMode = 'redacted', voiceThresholds, debugVoiceRms = false, sttGlossary
     // AI Model related state
     const [modelsFromApi, setModelsFromApi] = React.useState([]);
     const [selectedModelIndex, setSelectedModelIndex] = useLocalStorage('selectedAIModelIndex', 0);
+    // PII protection status: fetched from the service's own config (via serviceId + credentials
+    // already provided to the SDK), not passed in by the host app. Defaults to off until the fetch
+    // below resolves, matching how modelsFromApi starts empty.
+    const [enablePiiProtection, setEnablePiiProtection] = React.useState(false);
+    const piiDisplayMode = enablePiiProtection ? 'redacted' : 'plain';
     // Use models from API only (no default fallback)
     // This ensures SDK always uses Dashboard-configured models
     const effectiveAvailableModels = React.useMemo(() => {
@@ -787,6 +791,9 @@ piiDisplayMode = 'redacted', voiceThresholds, debugVoiceRms = false, sttGlossary
                 if ('availableModels' in result && Array.isArray(result.availableModels)) {
                     setModelsFromApi(result.availableModels);
                 }
+                if ('enablePiiProtection' in result) {
+                    setEnablePiiProtection(!!result.enablePiiProtection);
+                }
             }
             catch (error) {
                 console.error('Failed to fetch available models from API:', error);
@@ -862,14 +869,18 @@ piiDisplayMode = 'redacted', voiceThresholds, debugVoiceRms = false, sttGlossary
         }
         setIsAITLoading(true);
         try {
+            let walletAllowsAITLookup = !requireWalletIDVVerification;
             // Get wallet info first - always try to get wallet info if we have a token
             if (nxtlinqAITServiceAccessToken) {
                 try {
                     const walletResponse = await nxtlinqApi.wallet.getWallet({ address: hitAddress }, nxtlinqAITServiceAccessToken);
                     if (!('error' in walletResponse)) {
                         setWalletInfo(walletResponse);
+                        walletAllowsAITLookup = !requireWalletIDVVerification
+                            || hasRecordedWalletVerification(walletResponse);
                     }
                     else {
+                        setWalletInfo(null);
                         // Check if the error is due to invalid/expired token
                         if (walletResponse.error.includes('Invalid or expired token')) {
                             console.log('Token appears to be invalid during wallet info fetch, clearing it');
@@ -878,9 +889,17 @@ piiDisplayMode = 'redacted', voiceThresholds, debugVoiceRms = false, sttGlossary
                     }
                 }
                 catch (error) {
+                    setWalletInfo(null);
                     console.error('Failed to fetch wallet info:', error);
                 }
             }
+            // AIT existence is not identity verification. In strict mode, stop before
+            // the legacy AIT lookup can synthesize a custom wallet record.
+            if (nxtlinqAITServiceAccessToken && !walletAllowsAITLookup) {
+                setAit(null);
+                setPermissions([]);
+                return;
+            }
             // Only try to fetch AIT if we have a token
             if (nxtlinqAITServiceAccessToken) {
                 const response = await nxtlinqApi.ait.getAITByServiceIdAndController({
@@ -1112,338 +1131,67 @@ piiDisplayMode = 'redacted', voiceThresholds, debugVoiceRms = false, sttGlossary
         }
     };
     // Check permissions
-    const hasPermission = async (requiredPermission, autoRetry = true, onAutoConnect, onAutoSignIn) => {
+    const hasPermission = async (requiredPermission) => {
         // Use refs to get latest state values
         const currentHitAddress = hitAddressRef.current;
-        const currentAit = aitRef.current;
-        const currentPermissions = permissionsRef.current;
         const currentToken = nxtlinqAITServiceAccessTokenRef.current;
-        if (!currentHitAddress) {
-            if (autoRetry) {
-                setIsLoading(false); // Stop thinking before showing message
-                setMessages(prev => [...prev, {
-                        id: Date.now().toString(),
-                        content: walletTextUtils.getWalletText('Please connect your HIT wallet to continue.', serviceId),
-                        role: 'assistant',
-                        timestamp: new Date().toISOString(),
-                        button: 'connectWallet'
-                    }]);
-                try {
-                    setIsAutoConnecting(true); // Mark as auto-connecting
-                    await connectWallet(false); // Don't show sign-in message yet
-                    setIsAutoConnecting(false); // Clear auto-connecting state
-                    // Show brief success message for auto-connect
-                    showSuccess(walletTextUtils.getWalletText('Auto wallet connection successful', serviceId));
-                    onAutoConnect?.(); // Call callback if provided
-                    await new Promise(resolve => setTimeout(resolve, 2000));
-                    // After auto connect, if not signed in, then auto sign-in
-                    const tokenAfterConnect = nxtlinqAITServiceAccessTokenRef.current;
-                    if (!tokenAfterConnect) {
-                        setIsAutoConnecting(true);
-                        await signInWallet(false);
-                        onAutoSignIn?.(); // Call callback if provided
-                        setIsAutoConnecting(false);
-                        showSuccess(walletTextUtils.getWalletText('Auto sign-in successful after wallet connect', serviceId));
-                        await refreshAIT();
-                        // Wait for AIT to be fully loaded with polling
-                        let attempts = 0;
-                        const maxAttempts = 5;
-                        while (!aitRef.current && attempts < maxAttempts) {
-                            await new Promise(resolve => setTimeout(resolve, 2000));
-                            attempts++;
-                        }
-                    }
-                    // If connection (and sign-in if needed) successful, continue with permission check
-                    const result = await hasPermission(requiredPermission, false);
-                    return result;
-                }
-                catch (error) {
-                    console.error('Failed to auto-connect wallet:', error);
-                    setIsAutoConnecting(false); // Clear auto-connecting state on error
-                    return false;
-                }
-            }
-            // If autoRetry is false, don't show message again, just return false
-            return false;
-        }
-        if (!currentToken) {
-            if (autoRetry) {
-                setIsLoading(false); // Stop thinking before showing message
-                setMessages(prev => [...prev, {
-                        id: Date.now().toString(),
-                        content: walletTextUtils.getWalletText('Please sign in with your HIT wallet to continue.', serviceId),
-                        role: 'assistant',
-                        timestamp: new Date().toISOString(),
-                        button: 'signIn'
-                    }]);
-                try {
-                    setIsAutoConnecting(true); // Mark as auto-signing
-                    await signInWallet(false); // Don't show success message yet
-                    onAutoSignIn?.(); // Call callback if provided
-                    setIsAutoConnecting(false); // Clear auto-signing state
-                    // Show brief success message for auto-sign-in
-                    showSuccess('Auto sign-in successful');
-                    // Ensure AIT is refreshed after sign-in
-                    await refreshAIT();
-                    // Wait for AIT to be fully loaded with polling
-                    let attempts = 0;
-                    const maxAttempts = 5; // Wait up to 10 seconds (5 * 2000ms)
-                    while (!aitRef.current && attempts < maxAttempts) {
-                        await new Promise(resolve => setTimeout(resolve, 2000));
-                        attempts++;
-                    }
-                    // Only continue if AIT is actually loaded
-                    if (aitRef.current) {
-                        // Wait a bit more to ensure permissions are also loaded
-                        await new Promise(resolve => setTimeout(resolve, 2000));
-                        // If sign-in successful, continue with permission check
-                        const result = await hasPermission(requiredPermission, false);
-                        return result;
-                    }
-                    else {
-                        return false;
-                    }
-                }
-                catch (error) {
-                    console.error('Failed to auto-sign-in wallet:', error);
-                    setIsAutoConnecting(false); // Clear auto-signing state on error
-                    return false;
-                }
-            }
-            // If autoRetry is false, don't show message again, just return false
-            return false;
-        }
-        try {
-            const payload = JSON.parse(atob(currentToken.split('.')[1]));
-            const address = payload.address;
-            if (address !== currentHitAddress) {
-                setNxtlinqAITServiceAccessToken('');
-                if (autoRetry) {
-                    setIsLoading(false); // Stop thinking before showing message
-                    setMessages(prev => [...prev, {
-                            id: Date.now().toString(),
-                            content: walletTextUtils.getWalletText('Wallet address mismatch. Please sign in with the correct wallet.', serviceId),
-                            role: 'assistant',
-                            timestamp: new Date().toISOString(),
-                            button: 'signIn'
-                        }]);
-                    try {
-                        setIsAutoConnecting(true); // Mark as auto-signing
-                        await signInWallet(false); // Don't show success message yet
-                        onAutoSignIn?.(); // Call callback if provided
-                        setIsAutoConnecting(false); // Clear auto-signing state
-                        // Show brief success message for auto-sign-in after address mismatch
-                        showSuccess('Auto sign-in successful after address mismatch');
-                        // Ensure AIT is refreshed after sign-in
-                        await refreshAIT();
-                        // Wait for AIT to be fully loaded with polling
-                        let attempts = 0;
-                        const maxAttempts = 5; // Wait up to 10 seconds (5 * 2000ms)
-                        while (!aitRef.current && attempts < maxAttempts) {
-                            await new Promise(resolve => setTimeout(resolve, 2000));
-                            attempts++;
-                        }
-                        // Only continue if AIT is actually loaded
-                        if (aitRef.current) {
-                            // Wait a bit more to ensure permissions are also loaded
-                            await new Promise(resolve => setTimeout(resolve, 2000));
-                            // If sign-in successful, continue with permission check
-                            const result = await hasPermission(requiredPermission, false);
-                            return result;
-                        }
-                        else {
-                            return false;
-                        }
-                    }
-                    catch (error) {
-                        console.error('Failed to auto-sign-in after address mismatch:', error);
-                        setIsAutoConnecting(false); // Clear auto-signing state on error
-                        return false;
-                    }
-                }
-                // If autoRetry is false, don't show message again, just return false
-                return false;
-            }
-        }
-        catch (error) {
-            console.error('Error parsing token:', error);
-            setNxtlinqAITServiceAccessToken('');
-            if (autoRetry) {
-                setIsLoading(false); // Stop thinking before showing message
-                setMessages(prev => [...prev, {
-                        id: Date.now().toString(),
-                        content: walletTextUtils.getWalletText('Invalid wallet session. Please sign in again.', serviceId),
-                        role: 'assistant',
-                        timestamp: new Date().toISOString(),
-                        button: 'signIn'
-                    }]);
-                try {
-                    setIsAutoConnecting(true); // Mark as auto-signing
-                    await signInWallet(false); // Don't show success message yet
-                    onAutoSignIn?.(); // Call callback if provided
-                    setIsAutoConnecting(false); // Clear auto-signing state
-                    // Show brief success message for auto-sign-in after token parse error
-                    showSuccess('Auto sign-in successful after token error');
-                    // Ensure AIT is refreshed after sign-in
-                    await refreshAIT();
-                    // Wait for AIT to be fully loaded with polling
-                    let attempts = 0;
-                    const maxAttempts = 5; // Wait up to 10 seconds (5 * 2000ms)
-                    while (!aitRef.current && attempts < maxAttempts) {
-                        await new Promise(resolve => setTimeout(resolve, 2000));
-                        attempts++;
-                    }
-                    // Only continue if AIT is actually loaded
-                    if (aitRef.current) {
-                        // Wait a bit more to ensure permissions are also loaded
-                        await new Promise(resolve => setTimeout(resolve, 2000));
-                        // If sign-in successful, continue with permission check
-                        const result = await hasPermission(requiredPermission, false);
-                        return result;
-                    }
-                    else {
-                        return false;
-                    }
-                }
-                catch (signInError) {
-                    console.error('Failed to auto-sign-in after token parse error:', signInError);
-                    setIsAutoConnecting(false); // Clear auto-signing state on error
-                    return false;
-                }
-            }
-            // If autoRetry is false, don't show message again, just return false
-            return false;
-        }
-        if (!currentAit) {
-            // Show loading message if AIT is still loading
-            if (isAITLoading) {
-                setIsLoading(false); // Stop thinking before showing message
-                setMessages(prev => [...prev, {
-                        id: Date.now().toString(),
-                        content: walletTextUtils.getWalletText('Loading your wallet configuration... Please wait a moment.', serviceId),
-                        role: 'assistant',
-                        timestamp: new Date().toISOString()
-                    }]);
-                return false;
-            }
-            // If AIT is not loaded but we have a token, try to refresh it once
-            if (currentToken && !isAITLoading) {
-                try {
-                    await refreshAIT();
-                    // Wait for AIT to be loaded with polling
-                    let attempts = 0;
-                    const maxAttempts = 5; // Wait up to 10 seconds (5 * 2000ms)
-                    while (!aitRef.current && attempts < maxAttempts) {
-                        await new Promise(resolve => setTimeout(resolve, 2000));
-                        attempts++;
-                    }
-                    // Check again after refresh
-                    if (!aitRef.current) {
-                        setIsLoading(false); // Stop thinking before showing message
-                        setMessages(prev => [...prev, {
-                                id: Date.now().toString(),
-                                content: walletTextUtils.getWalletText('No AIT found for your wallet. Please click the settings button (⚙️) to configure your AIT permissions.', serviceId),
-                                role: 'assistant',
-                                timestamp: new Date().toISOString()
-                            }]);
-                        return false;
-                    }
-                }
-                catch (error) {
-                    console.error('Failed to refresh AIT during permission check:', error);
-                    setIsLoading(false); // Stop thinking before showing message
-                    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;
-                }
-            }
-            else {
-                setIsLoading(false); // Stop thinking before showing message
-                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;
-            }
-        }
-        if (availablePermissions.length === 0) {
-            setIsLoading(false); // Stop thinking before showing message
-            setMessages(prev => [...prev, {
-                    id: Date.now().toString(),
-                    content: `No permissions available for your current identity provider. Please check your service configuration or contact support. Service ID: ${serviceId}, Permission Group: ${permissionGroup || 'None'}`,
-                    role: 'assistant',
-                    timestamp: new Date().toISOString()
-                }]);
-            return false;
-        }
-        const checkToolPermissionResult = await nxtlinqApi.agent.checkToolPermission({
+        const authorization = await authorizeTextFrontendTool({
+            api: nxtlinqApi,
+            serviceId,
+            toolName: requiredPermission,
+            snapshot: {
+                walletAddress: currentHitAddress,
+                walletToken: currentToken,
+                // Legacy AIT issuance is unscoped (`externalId=''`). Do not impose a
+                // wallet-address subject until issuance/migration supports it.
+                externalId: undefined,
+                requireWalletIDVVerification,
+                loading: isAITLoading || isAutoConnecting,
+            },
             ...authFields(),
-            aitToken: currentToken,
-            controller: currentHitAddress,
-            toolName: requiredPermission
+            customUsername: (!requireWalletIDVVerification && customUsername)
+                ? getFinalCustomUsername(customUsername)
+                : undefined,
         });
-        if ('error' in checkToolPermissionResult) {
-            // Check if AIT is still loading or if we just auto-connected
-            if (isAITLoading || isAutoConnecting) {
-                setIsLoading(false); // Stop thinking before showing message
-                setMessages(prev => [...prev, {
-                        id: Date.now().toString(),
-                        content: walletTextUtils.getWalletText('Loading your wallet configuration... Please wait a moment.', serviceId),
-                        role: 'assistant',
-                        timestamp: new Date().toISOString()
-                    }]);
-                return false;
-            }
-            // Refresh service permissions before judging; use latest result to decide message
-            const freshAvailablePermissions = await fetchAvailablePermissions();
-            const latestAvailablePermissions = freshAvailablePermissions ?? availablePermissions;
-            const requiredPermission = checkToolPermissionResult.requiredPermission;
-            const isInServiceList = latestAvailablePermissions.some((p) => p.label === requiredPermission);
-            // Permission not in service's available list → "not available for your current identity provider"
-            if (!isInServiceList) {
-                setIsLoading(false); // Stop thinking before showing message
-                setMessages(prev => [...prev, {
-                        id: Date.now().toString(),
-                        content: `This permission (${requiredPermission}) is not available for your current identity provider.`,
-                        role: 'assistant',
-                        timestamp: new Date().toISOString()
-                    }]);
-                return false;
-            }
-            // AIT loaded but permissions empty (no AIT found)
-            if (currentAit && currentPermissions.length === 0) {
-                setIsLoading(false); // Stop thinking before showing message
-                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;
-            }
-            // User has AIT but hasn't enabled this permission → prompt to enable
-            setIsLoading(false); // Stop thinking before showing message
-            const permissionMsg = `You don't have the required AIT permission: ${requiredPermission}. Would you like to enable AIT permission?`;
-            setMessages(prev => [
-                ...prev,
-                {
-                    id: Date.now().toString(),
-                    content: permissionMsg,
-                    role: 'assistant',
-                    timestamp: new Date().toISOString(),
-                    button: 'enableAIT',
-                    metadata: { requiredPermission }
-                }
-            ]);
-            return false;
-        }
-        return true;
+        if (authorization.status === 'allowed')
+            return true;
+        setIsLoading(false);
+        const recovery = {
+            id: Date.now().toString(),
+            content: 'Authorization is temporarily unavailable. Please try again.',
+            role: 'assistant',
+            timestamp: new Date().toISOString(),
+        };
+        switch (authorization.status) {
+            case 'wallet_disconnected':
+                recovery.content = walletTextUtils.getWalletText('Please connect your HIT wallet to continue.', serviceId);
+                recovery.button = 'connectWallet';
+                break;
+            case 'wallet_signed_out':
+                recovery.content = walletTextUtils.getWalletText('Please sign in with your HIT wallet to continue.', serviceId);
+                recovery.button = 'signIn';
+                break;
+            case 'wallet_session_invalid':
+                recovery.content = walletTextUtils.getWalletText('Invalid wallet session. Please sign in again.', serviceId);
+                recovery.button = 'signIn';
+                break;
+            case 'wallet_verification_required':
+                recovery.content = 'Please verify your wallet identity before using this tool.';
+                recovery.button = 'verifyWallet';
+                break;
+            case 'ait_not_found':
+                recovery.content = 'No AIT found for your wallet. Please open settings to configure your AIT.';
+                break;
+            case 'permission_denied':
+                recovery.content = `You don't have the required AIT permission: ${authorization.requiredPermission}. Would you like to enable AIT permission?`;
+                recovery.button = 'enableAIT';
+                recovery.metadata = { requiredPermission: authorization.requiredPermission };
+                break;
+            case 'authorization_unavailable':
+                break;
+        }
+        setMessages(prev => [...prev, recovery]);
+        return false;
     };
     // AI Model related functions
     const handleModelChange = React.useCallback((modelIndex) => {
@@ -1485,6 +1233,9 @@ piiDisplayMode = 'redacted', voiceThresholds, debugVoiceRms = false, sttGlossary
         if (!hasContent || isLoading)
             return;
         setPendingAutoTts(null);
+        const turnExternalId = typeof window !== 'undefined'
+            ? localStorage.getItem('walletAddress') || undefined
+            : hitAddressRef.current || undefined;
         const currentModel = getCurrentModel();
         // Initialize with current model, will be updated with actual model from backend response
         let actualModelUsed = currentModel.value;
@@ -1556,7 +1307,7 @@ piiDisplayMode = 'redacted', voiceThresholds, debugVoiceRms = false, sttGlossary
                 model: currentModel.value,
                 ...authFields(),
                 pseudoId: pseudoId,
-                externalId: localStorage.getItem('walletAddress') || undefined,
+                externalId: turnExternalId,
                 customUserInfo,
                 customUsername,
                 message: content || (attachments && attachments.length > 0 ? `Uploaded ${attachments.length} file(s)` : ''),
@@ -1770,82 +1521,10 @@ piiDisplayMode = 'redacted', voiceThresholds, debugVoiceRms = false, sttGlossary
                 const toolUse = response.toolCall.toolUse;
                 let toolMsg = '';
                 if (onToolUse) {
-                    let wasAutoConnected = false;
-                    let wasAutoSignedIn = false;
-                    // Added: Mark if permission denied due to missing AIT permission
-                    let permissionDenied = false;
-                    // Use requiredPermission from response if available, otherwise fall back to toolUse.name
-                    const permissionToCheck = response?.requiredPermission || toolUse.name;
-                    const isToolAllowed = await hasPermission(permissionToCheck, true, () => { wasAutoConnected = true; }, () => { wasAutoSignedIn = true; });
-                    // If currentPermissions does not include permissionToCheck and availablePermissionLabels includes permissionToCheck, it means AIT permission is missing
-                    if (!isToolAllowed && !permissions.includes(permissionToCheck) && availablePermissions.map(p => p.label).includes(permissionToCheck)) {
-                        permissionDenied = true;
-                    }
+                    const isToolAllowed = await hasPermission(toolUse.name);
+                    // Typed preflight already emitted the only permitted recovery UI.
                     if (!isToolAllowed) {
-                        // If permission denied due to missing AIT permission return
-                        if (permissionDenied) {
-                            setIsLoading(false);
-                            return;
-                        }
-                        if (isSemiAutomaticMode) {
-                            setIsLoading(false);
-                            setMessages(prev => [...prev, {
-                                    id: Date.now().toString(),
-                                    content: 'Click button to continue using tool',
-                                    role: 'assistant',
-                                    timestamp: new Date().toISOString(),
-                                    button: 'continue'
-                                }]);
-                            return;
-                        }
-                        else {
-                            // Only retry for auto-connect/auto-sign-in scenarios
-                            if (wasAutoConnected && retryCount < 1) {
-                                // Clear loading state and retry immediately
-                                setIsLoading(false);
-                                // Check if wallet is already signed in
-                                const currentToken = nxtlinqAITServiceAccessTokenRef.current;
-                                if (!currentToken) {
-                                    // If not signed in, directly retry the message without waiting for AIT
-                                    setTimeout(() => {
-                                        sendMessage(content, retryCount + 1, isPresetMessage);
-                                    }, 2000);
-                                }
-                                else {
-                                    // If already signed in, wait for AIT to be fully loaded before retrying
-                                    setTimeout(async () => {
-                                        // Wait for AIT to be loaded if needed
-                                        if (!aitRef.current && nxtlinqAITServiceAccessTokenRef.current) {
-                                            await refreshAIT();
-                                        }
-                                        // Wait for AIT to be fully loaded with polling
-                                        let attempts = 0;
-                                        const maxAttempts = 5; // Wait up to 10 seconds (5 * 2000ms)
-                                        while (!aitRef.current && attempts < maxAttempts) {
-                                            await new Promise(resolve => setTimeout(resolve, 2000));
-                                            attempts++;
-                                        }
-                                        // Only retry if AIT is actually loaded
-                                        if (aitRef.current) {
-                                            // Wait a bit more to ensure permissions are also loaded
-                                            await new Promise(resolve => setTimeout(resolve, 3000));
-                                            sendMessage(content, retryCount + 1, isPresetMessage);
-                                        }
-                                    }, 2000);
-                                }
-                            }
-                            return;
-                        }
-                    }
-                    if (isSemiAutomaticMode && wasAutoSignedIn) {
                         setIsLoading(false);
-                        setMessages(prev => [...prev, {
-                                id: Date.now().toString(),
-                                content: 'Click button to continue using tool',
-                                role: 'assistant',
-                                timestamp: new Date().toISOString(),
-                                button: 'continue'
-                            }]);
                         return;
                     }
                     // Create streaming message for tool execution

package/dist/index.d.ts

@@ -2,7 +2,7 @@ export { ChatBot } from './ChatBot';
 export { ChatBotProvider, useChatBot } from './context/ChatBotContext';
 export { ChatBotUI, MessageInput, MessageList, ModelSelector, NotificationModal, PermissionForm, PresetMessages, BerifyMeModal, } from './ui/index';
 export type { AIModel, AITMetadata, ChatBotContextType, ChatBotProps, NovaError, NovaResponse, ToolCall, ToolUse, PresetMessage, } from './types/ChatBotTypes';
-export type { AgentEnvironment, AgentConfig, Attachment, AgentResponse, Message, SendMessageOptions, NxtlinqAgentSnapshot, VoiceSession, VoiceStatus, } from '@bytexbyte/nxtlinq-ai-agent-core-development';
-export { NxtlinqAgent, setApiHosts, VoiceNotSupportedError, STORAGE_KEYS, } from '@bytexbyte/nxtlinq-ai-agent-core-development';
+export type { AgentEnvironment, AgentConfig, Attachment, AgentResponse, Message, SendMessageOptions, NxtlinqAgentSnapshot, TextToolAuthorizationSnapshot, TextToolAuthorizationOutcome, VoiceSession, VoiceStatus, } from '@bytexbyte/nxtlinq-ai-agent-core-development';
+export { NxtlinqAgent, setApiHosts, VoiceNotSupportedError, STORAGE_KEYS, authorizeTextFrontendTool, hasRecordedWalletVerification, validateWalletSession, } from '@bytexbyte/nxtlinq-ai-agent-core-development';
 export { createNxtlinqApi, useLocalStorage, useSessionStorage, useSpeechToTextFromMic, useVoiceMode, metakeepClient, getEthers, sleep, walletTextUtils, } from '@bytexbyte/nxtlinq-ai-agent-web-development';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAEvE,OAAO,EACL,SAAS,EACT,YAAY,EACZ,WAAW,EACX,aAAa,EACb,iBAAiB,EACjB,cAAc,EACd,cAAc,EACd,aAAa,GACd,MAAM,YAAY,CAAC;AAEpB,YAAY,EACV,OAAO,EACP,WAAW,EACX,kBAAkB,EAClB,YAAY,EACZ,SAAS,EACT,YAAY,EACZ,QAAQ,EACR,OAAO,EACP,aAAa,GACd,MAAM,sBAAsB,CAAC;AAE9B,YAAY,EACV,gBAAgB,EAChB,WAAW,EACX,UAAU,EACV,aAAa,EACb,OAAO,EACP,kBAAkB,EAClB,oBAAoB,EACpB,YAAY,EACZ,WAAW,GACZ,MAAM,8CAA8C,CAAC;AAEtD,OAAO,EACL,YAAY,EACZ,WAAW,EACX,sBAAsB,EACtB,YAAY,GACb,MAAM,8CAA8C,CAAC;AAEtD,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EACjB,sBAAsB,EACtB,YAAY,EACZ,cAAc,EACd,SAAS,EACT,KAAK,EACL,eAAe,GAChB,MAAM,6CAA6C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAEvE,OAAO,EACL,SAAS,EACT,YAAY,EACZ,WAAW,EACX,aAAa,EACb,iBAAiB,EACjB,cAAc,EACd,cAAc,EACd,aAAa,GACd,MAAM,YAAY,CAAC;AAEpB,YAAY,EACV,OAAO,EACP,WAAW,EACX,kBAAkB,EAClB,YAAY,EACZ,SAAS,EACT,YAAY,EACZ,QAAQ,EACR,OAAO,EACP,aAAa,GACd,MAAM,sBAAsB,CAAC;AAE9B,YAAY,EACV,gBAAgB,EAChB,WAAW,EACX,UAAU,EACV,aAAa,EACb,OAAO,EACP,kBAAkB,EAClB,oBAAoB,EACpB,6BAA6B,EAC7B,4BAA4B,EAC5B,YAAY,EACZ,WAAW,GACZ,MAAM,8CAA8C,CAAC;AAEtD,OAAO,EACL,YAAY,EACZ,WAAW,EACX,sBAAsB,EACtB,YAAY,EACZ,yBAAyB,EACzB,6BAA6B,EAC7B,qBAAqB,GACtB,MAAM,8CAA8C,CAAC;AAEtD,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EACjB,sBAAsB,EACtB,YAAY,EACZ,cAAc,EACd,SAAS,EACT,KAAK,EACL,eAAe,GAChB,MAAM,6CAA6C,CAAC"}

package/dist/index.js

@@ -1,5 +1,5 @@
 export { ChatBot } from './ChatBot';
 export { ChatBotProvider, useChatBot } from './context/ChatBotContext';
 export { ChatBotUI, MessageInput, MessageList, ModelSelector, NotificationModal, PermissionForm, PresetMessages, BerifyMeModal, } from './ui/index';
-export { NxtlinqAgent, setApiHosts, VoiceNotSupportedError, STORAGE_KEYS, } from '@bytexbyte/nxtlinq-ai-agent-core-development';
+export { NxtlinqAgent, setApiHosts, VoiceNotSupportedError, STORAGE_KEYS, authorizeTextFrontendTool, hasRecordedWalletVerification, validateWalletSession, } from '@bytexbyte/nxtlinq-ai-agent-core-development';
 export { createNxtlinqApi, useLocalStorage, useSessionStorage, useSpeechToTextFromMic, useVoiceMode, metakeepClient, getEthers, sleep, walletTextUtils, } from '@bytexbyte/nxtlinq-ai-agent-web-development';