@bytexbyte/nxtlinq-ai-agent-ui-react-development 0.3.4 → 2.0.0

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/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;
@@ -108,6 +105,9 @@ export interface ChatBotContextType {
   hitAddress: string | null;
   ait: AIT | null;
   permissions: string[];
+  maximumPermissions: string[];
+  deniedPermissions: string[];
+  runtimePermissionsUnavailable: boolean;
   availablePermissions: ServicePermission[];
   showPermissionForm: boolean;
   isPermissionFormOpen: boolean;
@@ -155,7 +155,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;
@@ -203,8 +202,9 @@ export interface ChatBotContextType {
   onVerifyWallet: (method: 'berifyme' | 'custom') => Promise<void>;
   serviceId: string;
   permissionGroup?: string;
+  roles?: string[];
 
   // Props
   props: ChatBotProps;
   nxtlinqApi: AITApi;
-} 
+}

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

@@ -13,7 +13,8 @@ export const PermissionForm: React.FC<PermissionFormProps> = ({ onClose }) => {
   const {
     hitAddress,
     permissions,
-    setPermissions,
+    availablePermissions,
+    runtimePermissionsUnavailable,
     setIsDisabled,
     onSave,
     onConnectWallet,
@@ -22,15 +23,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);
@@ -63,28 +61,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) {
@@ -114,8 +90,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 {
@@ -481,6 +455,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;
@@ -548,7 +537,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;
@@ -600,7 +589,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;
@@ -629,4 +618,4 @@ export const PermissionForm: React.FC<PermissionFormProps> = ({ onClose }) => {
       )}
     </div>
   );
-}; 
+};

package/dist/NxtlinqAgentChat.d.ts

@@ -1,26 +0,0 @@
-import React from 'react';
-import type { NxtlinqAgentChatProps } from './types';
-/**
- * Drop-in React Web assistant UI wired to `@bytexbyte/nxtlinq-ai-agent-web-development`.
- *
- * @example
- * ```tsx
- * import { NxtlinqAgentChat } from '@bytexbyte/nxtlinq-ai-agent-ui-react-development';
- *
- * export default function Page() {
- *   return (
- *     <NxtlinqAgentChat
- *       style={{ height: '100vh' }}
- *       serviceId="..."
- *       apiKey="..."
- *       apiSecret="..."
- *       environment="staging"
- *       pseudoId={userId}
- *       loadHistoryOnMount
- *     />
- *   );
- * }
- * ```
- */
-export declare function NxtlinqAgentChat({ title, placeholder, presetMessages, loadHistoryOnMount, historyLast, enableVoice, enableFileUpload, startInVoiceMode, startWithMicMuted, holdMicDuringAssistant, theme, style, headerStyle, onMessage, onError, onToolUse, children, fetchImpl, getTimezone, resetOnIdentityChange, ...agentConfig }: NxtlinqAgentChatProps): React.ReactElement;
-//# sourceMappingURL=NxtlinqAgentChat.d.ts.map

package/dist/NxtlinqAgentChat.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"NxtlinqAgentChat.d.ts","sourceRoot":"","sources":["../src/NxtlinqAgentChat.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAAC,EAC/B,KAAK,EACL,WAAW,EACX,cAAc,EACd,kBAA0B,EAC1B,WAAW,EACX,WAAkB,EAClB,gBAAuB,EACvB,gBAAwB,EACxB,iBAAwB,EACxB,sBAA6B,EAC7B,KAAK,EACL,KAAK,EACL,WAAW,EACX,SAAS,EACT,OAAO,EACP,SAAS,EACT,QAAQ,EACR,SAAS,EACT,WAAW,EACX,qBAAqB,EACrB,GAAG,WAAW,EACf,EAAE,qBAAqB,GAAG,KAAK,CAAC,YAAY,CA6B5C"}

package/dist/NxtlinqAgentChat.js

@@ -1,28 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "@emotion/react/jsx-runtime";
-import { NxtlinqAgentProvider } from '@bytexbyte/nxtlinq-ai-agent-web-development';
-import { AgentAssistantShell } from './components/AgentAssistantShell';
-/**
- * Drop-in React Web assistant UI wired to `@bytexbyte/nxtlinq-ai-agent-web-development`.
- *
- * @example
- * ```tsx
- * import { NxtlinqAgentChat } from '@bytexbyte/nxtlinq-ai-agent-ui-react-development';
- *
- * export default function Page() {
- *   return (
- *     <NxtlinqAgentChat
- *       style={{ height: '100vh' }}
- *       serviceId="..."
- *       apiKey="..."
- *       apiSecret="..."
- *       environment="staging"
- *       pseudoId={userId}
- *       loadHistoryOnMount
- *     />
- *   );
- * }
- * ```
- */
-export function NxtlinqAgentChat({ title, placeholder, presetMessages, loadHistoryOnMount = false, historyLast, enableVoice = true, enableFileUpload = true, startInVoiceMode = false, startWithMicMuted = true, holdMicDuringAssistant = true, theme, style, headerStyle, onMessage, onError, onToolUse, children, fetchImpl, getTimezone, resetOnIdentityChange, ...agentConfig }) {
-    return (_jsxs(NxtlinqAgentProvider, { fetchImpl: fetchImpl, getTimezone: getTimezone, resetOnIdentityChange: resetOnIdentityChange, onMessage: onMessage, onError: onError, onToolUse: onToolUse, ...agentConfig, children: [_jsx(AgentAssistantShell, { title: title, placeholder: placeholder, presetMessages: presetMessages, loadHistoryOnMount: loadHistoryOnMount, historyLast: historyLast, enableVoice: enableVoice, enableFileUpload: enableFileUpload, startInVoiceMode: startInVoiceMode, startWithMicMuted: startWithMicMuted, holdMicDuringAssistant: holdMicDuringAssistant, theme: theme, style: style, headerStyle: headerStyle }), children] }));
-}

package/dist/components/AgentAssistantShell.d.ts

@@ -1,5 +0,0 @@
-import React from 'react';
-import type { NxtlinqAgentChatProps } from '../types';
-export type AgentAssistantShellProps = Pick<NxtlinqAgentChatProps, 'title' | 'placeholder' | 'presetMessages' | 'enableVoice' | 'enableFileUpload' | 'theme' | 'style' | 'headerStyle' | 'loadHistoryOnMount' | 'historyLast' | 'startInVoiceMode' | 'startWithMicMuted' | 'holdMicDuringAssistant'>;
-export declare function AgentAssistantShell(props: AgentAssistantShellProps): React.ReactElement;
-//# sourceMappingURL=AgentAssistantShell.d.ts.map

package/dist/components/AgentAssistantShell.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AgentAssistantShell.d.ts","sourceRoot":"","sources":["../../src/components/AgentAssistantShell.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAsC,MAAM,OAAO,CAAC;AAK3D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAOtD,MAAM,MAAM,wBAAwB,GAAG,IAAI,CACzC,qBAAqB,EACnB,OAAO,GACP,aAAa,GACb,gBAAgB,GAChB,aAAa,GACb,kBAAkB,GAClB,OAAO,GACP,OAAO,GACP,aAAa,GACb,oBAAoB,GACpB,aAAa,GACb,kBAAkB,GAClB,mBAAmB,GACnB,wBAAwB,CAC3B,CAAC;AA2DF,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,wBAAwB,GAAG,KAAK,CAAC,YAAY,CAiBvF"}

package/dist/components/AgentAssistantShell.js

@@ -1,52 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "@emotion/react/jsx-runtime";
-import { useEffect, useRef, useState } from 'react';
-import { AgentAssistantProvider, useAgentAssistant, } from '../context/AgentAssistantContext';
-import { AgentComposer } from './AgentComposer';
-import { AgentMessageList } from './AgentMessageList';
-import { AgentRemoteAudio } from './AgentRemoteAudio';
-import { AgentVoiceBar } from './AgentVoiceBar';
-import { PresetMessageChips } from './PresetMessageChips';
-function AgentAssistantInner({ title, headerStyle, style, loadHistoryOnMount, historyLast, startInVoiceMode, }) {
-    const { theme, loadHistory, startVoice, isVoiceAvailable } = useAgentAssistant();
-    const [historyReady, setHistoryReady] = useState(!loadHistoryOnMount);
-    const voiceAutoStartRef = useRef(false);
-    useEffect(() => {
-        if (loadHistoryOnMount) {
-            void loadHistory({ last: historyLast ?? 50 }).finally(() => setHistoryReady(true));
-        }
-    }, [loadHistory, loadHistoryOnMount, historyLast]);
-    useEffect(() => {
-        if (!startInVoiceMode || !isVoiceAvailable || voiceAutoStartRef.current)
-            return;
-        voiceAutoStartRef.current = true;
-        void startVoice();
-    }, [startInVoiceMode, isVoiceAvailable, startVoice]);
-    return (_jsxs("div", { style: {
-            display: 'flex',
-            flexDirection: 'column',
-            flex: 1,
-            minHeight: 0,
-            backgroundColor: theme.colors.background,
-            ...style,
-        }, children: [_jsx("header", { style: {
-                    padding: theme.spacing.md,
-                    borderBottom: `1px solid ${theme.colors.border}`,
-                    backgroundColor: theme.colors.surface,
-                    fontSize: theme.typography.titleSize,
-                    fontWeight: 600,
-                    color: theme.colors.assistantText,
-                    ...headerStyle,
-                }, children: title ?? 'AI Assistant' }), _jsx(PresetMessageChips, {}), historyReady ? _jsx(AgentMessageList, {}) : _jsx("div", { style: { flex: 1 } }), _jsx(AgentVoiceBar, {}), _jsx(AgentComposer, {}), _jsx(AgentRemoteAudio, {})] }));
-}
-export function AgentAssistantShell(props) {
-    return (_jsx(AgentAssistantProvider, { ui: {
-            title: props.title,
-            placeholder: props.placeholder,
-            presetMessages: props.presetMessages,
-            enableVoice: props.enableVoice,
-            enableFileUpload: props.enableFileUpload,
-            theme: props.theme,
-            startWithMicMuted: props.startWithMicMuted,
-            holdMicDuringAssistant: props.holdMicDuringAssistant,
-        }, children: _jsx(AgentAssistantInner, { ...props }) }));
-}

package/dist/components/AgentComposer.d.ts

@@ -1,3 +0,0 @@
-import React from 'react';
-export declare function AgentComposer(): React.ReactElement | null;
-//# sourceMappingURL=AgentComposer.d.ts.map

package/dist/components/AgentComposer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AgentComposer.d.ts","sourceRoot":"","sources":["../../src/components/AgentComposer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B,wBAAgB,aAAa,IAAI,KAAK,CAAC,YAAY,GAAG,IAAI,CAkIzD"}