@bytexbyte/nxtlinq-ai-agent-ui-react-development 0.4.4 → 0.4.7

package/src/index.ts

@@ -14,7 +14,6 @@ export {
 
 export type {
   AIModel,
-  AITMetadata,
   ChatBotContextType,
   ChatBotProps,
   NovaError,

package/src/permissionState.ts

@@ -0,0 +1,313 @@
+import type { AIT, RuntimeAITResult } from '@bytexbyte/nxtlinq-ai-agent-core-development';
+import * as React from 'react';
+
+const useCommitPhaseEffect = typeof window === 'undefined'
+  ? React.useEffect
+  : React.useLayoutEffect;
+
+export function commitProviderRuntime<T, E>(
+  identityRef: React.MutableRefObject<T>,
+  identity: T,
+  environment: E,
+  publishEnvironment: (environment: E) => void,
+): void {
+  identityRef.current = identity;
+  publishEnvironment(environment);
+}
+
+export function useProviderRuntimeCommit<T, E>(
+  identityRef: React.MutableRefObject<T>,
+  identity: T,
+  environment: E,
+  publishEnvironment: (environment: E) => void,
+): void {
+  useCommitPhaseEffect(() => {
+    commitProviderRuntime(
+      identityRef,
+      identity,
+      environment,
+      publishEnvironment,
+    );
+  }, [environment, identity, identityRef, publishEnvironment]);
+}
+
+function stableUnique(values: readonly string[]): string[] {
+  const seen = new Set<string>();
+  const result: string[] = [];
+  for (const value of values) {
+    if (!seen.has(value)) {
+      seen.add(value);
+      result.push(value);
+    }
+  }
+  return result;
+}
+
+export function replaceCurrentMaximumDenyList(
+  persistedDeniedPermissions: readonly string[],
+  maximumPermissions: readonly string[],
+  checkedPermissions: readonly string[],
+): string[] {
+  const maximum = new Set(maximumPermissions);
+  const checked = new Set(checkedPermissions);
+  for (const permission of checked) {
+    if (!maximum.has(permission)) {
+      throw new Error(`Permission is outside the authoritative maximum: ${permission}`);
+    }
+  }
+
+  const retainedOutsideMaximum = persistedDeniedPermissions.filter(
+    (permission) => !maximum.has(permission),
+  );
+  const deniedInsideMaximum = maximumPermissions.filter(
+    (permission) => !checked.has(permission),
+  );
+  return stableUnique([...retainedOutsideMaximum, ...deniedInsideMaximum]);
+}
+
+export function removeOneDeniedPermission(
+  persistedDeniedPermissions: readonly string[],
+  permission: string,
+): string[] {
+  return stableUnique(persistedDeniedPermissions).filter((value) => value !== permission);
+}
+
+export type RuntimeAITContext = {
+  controller: string;
+  serviceId: string;
+  roles?: string[];
+  permissionGroup?: string;
+};
+
+export function runtimeAITContextKey(context: RuntimeAITContext): string {
+  return JSON.stringify([
+    context.controller,
+    context.serviceId,
+    context.roles === undefined ? null : [...context.roles],
+    context.permissionGroup ?? null,
+  ]);
+}
+
+export function runtimeAITSubjectKey(context: RuntimeAITContext): string {
+  return JSON.stringify([context.controller, context.serviceId]);
+}
+
+export function runtimeAuthorizationMatchesContext(
+  authorizationContextKey: string | null,
+  renderedContext: RuntimeAITContext | null,
+): boolean {
+  return authorizationContextKey === (
+    renderedContext ? runtimeAITContextKey(renderedContext) : null
+  );
+}
+
+export class StaleRuntimeAITResponseError extends Error {
+  constructor() {
+    super('Stale runtime AIT response was discarded');
+    this.name = 'StaleRuntimeAITResponseError';
+  }
+}
+
+/**
+ * Owns the authoritative recompute lifecycle. Only the newest request for the
+ * active captured context may write state; its failures clear state first.
+ */
+export class RuntimeAITRecomputeCoordinator {
+  private activeContextKey: string | null = null;
+  private activeContext: RuntimeAITContext | null = null;
+  private generation = 0;
+
+  commitContext(
+    context: RuntimeAITContext | null,
+    invalidate: () => void,
+  ): boolean {
+    const nextKey = context ? runtimeAITContextKey(context) : null;
+    if (nextKey === this.activeContextKey) {
+      return false;
+    }
+    this.activeContextKey = nextKey;
+    this.activeContext = context ? {
+      controller: context.controller,
+      serviceId: context.serviceId,
+      ...(context.roles !== undefined ? { roles: [...context.roles] } : {}),
+      ...(context.permissionGroup !== undefined
+        ? { permissionGroup: context.permissionGroup }
+        : {}),
+    } : null;
+    this.generation += 1;
+    invalidate();
+    return true;
+  }
+
+  getActiveContext(): RuntimeAITContext | null {
+    return this.activeContext ? {
+      controller: this.activeContext.controller,
+      serviceId: this.activeContext.serviceId,
+      ...(this.activeContext.roles !== undefined
+        ? { roles: [...this.activeContext.roles] }
+        : {}),
+      ...(this.activeContext.permissionGroup !== undefined
+        ? { permissionGroup: this.activeContext.permissionGroup }
+        : {}),
+    } : null;
+  }
+
+  isContextActive(context: RuntimeAITContext): boolean {
+    return runtimeAITContextKey(context) === this.activeContextKey;
+  }
+
+  assertContextActive(context: RuntimeAITContext): void {
+    if (!this.isContextActive(context)) {
+      throw new StaleRuntimeAITResponseError();
+    }
+  }
+
+  async run<T>(
+    context: RuntimeAITContext,
+    request: () => Promise<T>,
+    apply: (result: T, context: RuntimeAITContext) => void,
+    clear: () => void,
+  ): Promise<T> {
+    this.assertContextActive(context);
+    const contextKey = runtimeAITContextKey(context);
+    const generation = ++this.generation;
+
+    try {
+      const result = await request();
+      if (generation !== this.generation || contextKey !== this.activeContextKey) {
+        throw new StaleRuntimeAITResponseError();
+      }
+      apply(result, context);
+      return result;
+    } catch (error) {
+      if (
+        !(error instanceof StaleRuntimeAITResponseError)
+        && generation === this.generation
+        && contextKey === this.activeContextKey
+      ) {
+        clear();
+      }
+      throw error;
+    }
+  }
+}
+
+export function useRuntimeAITContextCommit(
+  coordinator: RuntimeAITRecomputeCoordinator,
+  context: RuntimeAITContext | null,
+  invalidate: () => void,
+): void {
+  const contextKey = context ? runtimeAITContextKey(context) : null;
+  useCommitPhaseEffect(() => {
+    coordinator.commitContext(context, invalidate);
+  }, [contextKey, coordinator, invalidate]);
+}
+
+export async function dispatchRuntimeAITCompleteReplacement(
+  coordinator: RuntimeAITRecomputeCoordinator,
+  context: RuntimeAITContext,
+  update: () => Promise<unknown>,
+  converge: (subjectKey: string) => Promise<void>,
+  clear: () => void,
+): Promise<void> {
+  const subjectKey = runtimeAITSubjectKey(context);
+  coordinator.assertContextActive(context);
+
+  let updateFailed = false;
+  let updateError: unknown;
+  try {
+    await update();
+  } catch (error) {
+    updateFailed = true;
+    updateError = error;
+  }
+
+  try {
+    await converge(subjectKey);
+  } catch (error) {
+    if (!updateFailed) {
+      throw error;
+    }
+  }
+
+  if (updateFailed) {
+    if (!coordinator.isContextActive(context)) {
+      throw new StaleRuntimeAITResponseError();
+    }
+    clear();
+    throw updateError;
+  }
+  coordinator.assertContextActive(context);
+}
+
+/** Serializes reads, complete replacements, and convergence for one persistence subject. */
+export class RuntimeAITMutationQueue {
+  private readonly tails = new Map<string, Promise<void>>();
+
+  async run<T>(subjectKey: string, mutation: () => Promise<T>): Promise<T> {
+    const previous = this.tails.get(subjectKey) ?? Promise.resolve();
+    const result = previous.catch(() => undefined).then(mutation);
+    const tail = result.then(() => undefined, () => undefined);
+    this.tails.set(subjectKey, tail);
+    try {
+      return await result;
+    } finally {
+      if (this.tails.get(subjectKey) === tail) {
+        this.tails.delete(subjectKey);
+      }
+    }
+  }
+}
+
+export type RuntimeAuthorizationState = {
+  ait: AIT | null;
+  maximumPermissions: string[];
+  effectivePermissions: string[];
+  deniedPermissions: string[];
+  selectedRuleId: string | null;
+  selectedRuleType: RuntimeAITResult['selectedRuleType'];
+  expiresAt: string | null;
+  grantActive: boolean;
+  unavailable: boolean;
+};
+
+export function runtimeAuthorizationState(
+  result: RuntimeAITResult,
+  controller: string,
+  serviceId: string,
+): RuntimeAuthorizationState {
+  return {
+    ait: result.aitId
+      ? {
+          aitId: result.aitId,
+          controller,
+          serviceId,
+          metadata: { permissions: [...result.effectivePermissions] },
+        }
+      : null,
+    maximumPermissions: [...result.maximumPermissions],
+    effectivePermissions: [...result.effectivePermissions],
+    deniedPermissions: [...result.deniedPermissions],
+    selectedRuleId: result.selectedRuleId,
+    selectedRuleType: result.selectedRuleType,
+    expiresAt: result.expiresAt,
+    grantActive: result.grantActive,
+    unavailable: false,
+  };
+}
+
+export function unavailableRuntimeAuthorization(
+  persistedDeniedPermissions: readonly string[],
+): RuntimeAuthorizationState {
+  return {
+    ait: null,
+    maximumPermissions: [],
+    effectivePermissions: [],
+    deniedPermissions: [...persistedDeniedPermissions],
+    selectedRuleId: null,
+    selectedRuleType: 'none',
+    expiresAt: null,
+    grantActive: false,
+    unavailable: true,
+  };
+}

package/src/piiMessageState.ts

@@ -0,0 +1,35 @@
+type PiiMessage = {
+  piiStatus?: 'scanning' | 'complete' | 'none';
+  piiStep?: 0 | 1 | 2;
+  piiProtection?: {
+    anonymizedContent?: string;
+    mapping?: Record<string, string>;
+  };
+};
+
+export type PiiScanCompleteData = {
+  entityCount?: number;
+  anonymizedUserMessage?: string | null;
+  mapping?: Record<string, string> | null;
+};
+
+export function completePiiScan<T extends PiiMessage>(message: T, data?: PiiScanCompleteData): T {
+  const mapping = data?.mapping || {};
+  const entityCount = typeof data?.entityCount === 'number'
+    ? data.entityCount
+    : Object.keys(mapping).length;
+
+  if (entityCount <= 0 || !data?.anonymizedUserMessage) {
+    return { ...message, piiStatus: 'none', piiStep: 1 } as T;
+  }
+
+  return {
+    ...message,
+    piiStatus: 'complete',
+    piiStep: 1,
+    piiProtection: {
+      anonymizedContent: data.anonymizedUserMessage,
+      mapping,
+    },
+  } as T;
+}

package/src/suggestionState.ts

@@ -0,0 +1,20 @@
+import type { PresetMessage } from './types/ChatBotTypes';
+
+export function normalizeSuggestionText(value: string): string {
+  return value.trim().replace(/\s+/g, ' ').toLocaleLowerCase();
+}
+
+export function filterSuggestions(
+  suggestions: readonly PresetMessage[],
+  lastUserMessage?: string,
+): PresetMessage[] {
+  const lastUserText = normalizeSuggestionText(lastUserMessage || '');
+  const seen = new Set<string>();
+
+  return suggestions.filter((suggestion) => {
+    const normalized = normalizeSuggestionText(suggestion.text || '');
+    if (!normalized || normalized === lastUserText || seen.has(normalized)) return false;
+    seen.add(normalized);
+    return true;
+  });
+}

package/src/types/ChatBotTypes.ts

@@ -24,11 +24,6 @@ export interface NovaError {
   error: string;
 }
 
-export interface AITMetadata {
-  permissions: string[];
-  issuedBy: string;
-}
-
 // AI Model related types
 export interface AIModel {
   label: string;
@@ -62,6 +57,8 @@ export interface ChatBotProps {
     token: string;
   } | undefined>;
   permissionGroup?: string;
+  /** Ordered runtime identity-provider roles. Order is preserved for Group fallback. */
+  roles?: string[];
   children?: React.ReactNode;
   // AI Model related properties
   onModelChange?: (model: AIModel) => void;
@@ -103,6 +100,9 @@ export interface ChatBotContextType {
   hitAddress: string | null;
   ait: AIT | null;
   permissions: string[];
+  maximumPermissions: string[];
+  deniedPermissions: string[];
+  runtimePermissionsUnavailable: boolean;
   availablePermissions: ServicePermission[];
   showPermissionForm: boolean;
   isPermissionFormOpen: boolean;
@@ -151,7 +151,6 @@ export interface ChatBotContextType {
   setIsOpen: (open: boolean) => void;
   setShowPermissionForm: (show: boolean) => void;
   setIsPermissionFormOpen: (open: boolean) => void;
-  setPermissions: (permissions: string[]) => void;
   setIsDisabled: (disabled: boolean) => void;
   setIsWalletLoading: (loading: boolean) => void;
   setNotification: (notification: any) => void;
@@ -167,7 +166,7 @@ export interface ChatBotContextType {
   retryPendingTextTool: () => Promise<boolean>;
   sendMessage: (content: string, retryCount?: number, isPresetMessage?: boolean, attachments?: Attachment[]) => Promise<void>;
   handleSubmit: (e: React.FormEvent, attachments?: Attachment[]) => Promise<void>;
-  handlePresetMessage: (message: PresetMessage) => void;
+  handlePresetMessage: (message: PresetMessage) => Promise<void>;
   savePermissions: (newPermissions?: string[]) => Promise<void>;
   enableAIT: (toolName: string) => Promise<boolean>;
   handleVerifyWalletClick: (method: 'berifyme' | 'custom') => Promise<void>;
@@ -200,6 +199,7 @@ export interface ChatBotContextType {
   onVerifyWallet: (method: 'berifyme' | 'custom') => Promise<void>;
   serviceId: string;
   permissionGroup?: string;
+  roles?: string[];
 
   // Props
   props: ChatBotProps;

package/src/ui/ModelSelector.tsx

@@ -15,10 +15,10 @@ export const ModelSelector: React.FC = () => {
 
   // Safety check: ensure selectedModelIndex is within bounds
   const safeSelectedModelIndex = selectedModelIndex >= availableModels.length ? 0 : selectedModelIndex;
-  
+
   // Check if current service is Adilas
   const isAdilasService = walletTextUtils.isAdilasService(serviceId);
-  
+
   // Get fallback model label (first available model or 'Unknown')
   // For Adilas, we don't show the label, only the image
   const fallbackModelLabel = availableModels.length > 0 
@@ -120,7 +120,7 @@ export const ModelSelector: React.FC = () => {
           font-size: 12px !important;
           font-weight: 500 !important;
           gap: 6px !important;
-          
+
           &:hover {
             background-color: rgba(255, 255, 255, 0.2) !important;
           }
@@ -159,7 +159,7 @@ export const ModelSelector: React.FC = () => {
                 color: ${index === safeSelectedModelIndex ? '#007bff' : '#333'} !important;
                 font-size: 12px !important;
                 border-bottom: ${index < availableModels.length - 1 ? '1px solid #eee' : 'none'} !important;
-                
+
                 &:hover {
                   background-color: ${index === safeSelectedModelIndex ? '#f0f0f0' : '#f8f9fa'} !important;
                 }
@@ -187,4 +187,4 @@ export const ModelSelector: React.FC = () => {
       )}
     </div>
   );
-}; 
+};

package/src/ui/PermissionForm.tsx

@@ -14,7 +14,8 @@ export const PermissionForm: React.FC<PermissionFormProps> = ({ onClose }) => {
   const {
     hitAddress,
     permissions,
-    setPermissions,
+    availablePermissions,
+    runtimePermissionsUnavailable,
     setIsDisabled,
     onSave,
     onConnectWallet,
@@ -23,15 +24,12 @@ export const PermissionForm: React.FC<PermissionFormProps> = ({ onClose }) => {
     walletInfo,
     onVerifyWallet,
     serviceId,
-    nxtlinqApi,
-    permissionGroup,
     isAITLoading,
     isWalletLoading = false,
     refreshAIT,
     props
   } = useChatBot();
 
-  const [availablePermissions, setAvailablePermissions] = React.useState<any[]>([]);
   const [isSaving, setIsSaving] = React.useState(false);
   const [tempPermissions, setTempPermissions] = React.useState<string[]>(permissions);
   const [hasUserInteracted, setHasUserInteracted] = React.useState(false);
@@ -64,28 +62,6 @@ export const PermissionForm: React.FC<PermissionFormProps> = ({ onClose }) => {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [isAllSelected, availablePermissions.length]);
 
-  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);
-    }
-  };
-
-  React.useEffect(() => {
-    fetchAvailablePermissions();
-  }, [serviceId, nxtlinqApi, permissionGroup]);
-
   // Refresh wallet info when component mounts or when hitAddress changes
   React.useEffect(() => {
     if (hitAddress) {
@@ -112,8 +88,6 @@ export const PermissionForm: React.FC<PermissionFormProps> = ({ onClose }) => {
   const handleSave = async () => {
     setIsSaving(true);
     try {
-      // Update the actual permissions with temp permissions
-      setPermissions(tempPermissions);
       await onSave(tempPermissions);
       setHasUserInteracted(false);
     } finally {
@@ -476,6 +450,21 @@ export const PermissionForm: React.FC<PermissionFormProps> = ({ onClose }) => {
               `}>
                 Loading permissions...
               </div>
+            ) : runtimePermissionsUnavailable ? (
+              <div css={css`
+                background-color: #fff4e5 !important;
+                padding: 16px !important;
+                border-radius: 8px !important;
+                border: 1px solid #ffb74d !important;
+                text-align: center !important;
+                color: #8a4b00 !important;
+              `}>
+                Permissions are unavailable. Retry to load the authoritative state.
+                <button type="button" onClick={() => refreshAIT()} css={css`
+                  display: block !important;
+                  margin: 12px auto 0 !important;
+                `}>Retry</button>
+              </div>
             ) : (
               <div css={css`
                 background-color: #f8f9fa !important;
@@ -543,7 +532,7 @@ export const PermissionForm: React.FC<PermissionFormProps> = ({ onClose }) => {
                               setIsDisabled(false);
                             }
                           }}
-                          disabled={isAITLoading || isOtherPermissionDisabled}
+                          disabled={isAITLoading || runtimePermissionsUnavailable || isOtherPermissionDisabled}
                           css={css`
                             margin: 0 !important;
                             width: 18px !important;
@@ -595,7 +584,7 @@ export const PermissionForm: React.FC<PermissionFormProps> = ({ onClose }) => {
             </button>
             <button
               onClick={handleSave}
-              disabled={!hasPermissionChanges() || isSaving || isAITLoading}
+              disabled={!hasPermissionChanges() || isSaving || isAITLoading || runtimePermissionsUnavailable}
               css={css`
                 padding: 10px 20px !important;
                 background-color: ${!hasPermissionChanges() || isSaving || isAITLoading ? '#e9ecef' : '#007bff'} !important;

package/src/ui/PresetMessages.tsx

@@ -4,11 +4,14 @@ import { css } from '@emotion/react';
 import { useChatBot } from '../context/ChatBotContext';
 import { PresetMessage } from '../types/ChatBotTypes';
 import { actionButton } from './styles/isolatedStyles';
+import { filterSuggestions, normalizeSuggestionText } from '../suggestionState';
 
 export const PresetMessages: React.FC = () => {
-  const { suggestions, handlePresetMessage } = useChatBot();
+  const { suggestions, messages, handlePresetMessage } = useChatBot();
+  const lastUserMessage = [...messages].reverse().find(message => message.role === 'user')?.content;
+  const visibleSuggestions = filterSuggestions(suggestions || [], lastUserMessage);
 
-  if (!suggestions || suggestions.length === 0) {
+  if (visibleSuggestions.length === 0) {
     return null;
   }
 
@@ -22,10 +25,10 @@ export const PresetMessages: React.FC = () => {
       gap: 10px !important;
       align-items: center !important;
     `}>
-      {suggestions.map((preset: PresetMessage, index: number) => (
+      {visibleSuggestions.map((preset: PresetMessage) => (
         <button
-          key={index}
-          onClick={() => handlePresetMessage(preset)}
+          key={normalizeSuggestionText(preset.text)}
+          onClick={() => { void handlePresetMessage(preset); }}
           css={css`
             ${actionButton}
             padding: 5px 10px !important;
@@ -47,4 +50,4 @@ export const PresetMessages: React.FC = () => {
       ))}
     </div>
   );
-}; 
+};