@docyrus/ui-pro-ai-assistant 0.0.1

package/src/lib/api-client.ts

@@ -0,0 +1,77 @@
+'use client';
+
+import { useMemo } from 'react';
+
+import { AsyncTokenManager, RestApiClient } from '@docyrus/api-client';
+
+import { useAssistantConfig } from './assistant-config';
+
+// Response type that matches the API format
+export interface ApiResponse {
+  success: boolean;
+  data: unknown;
+  error?: string;
+  error_description?: string;
+}
+
+/**
+ * Hook to create an API client for the assistant
+ * Uses @docyrus/api-client with AsyncTokenManager
+ */
+export function useApiClient() {
+  const config = useAssistantConfig();
+
+  return useMemo(() => {
+    // Create async token manager that uses config.getAuthToken
+    const tokenManager = new AsyncTokenManager(
+      async () => {
+        const token = await config.getAuthToken();
+
+        return token || null;
+      },
+      async () => {
+        // No-op: Token is managed externally
+      },
+      async () => {
+        // No-op: Token is managed externally
+      }
+    );
+
+    // Create RestApiClient instance
+    const client = new RestApiClient({
+      baseURL: config.apiBaseUrl,
+      tokenManager
+    });
+
+    // Wrapper to catch errors and return consistent ApiResponse format
+    async function wrapRequest(request: () => Promise<unknown>): Promise<ApiResponse> {
+      try {
+        const data = await request();
+
+        // If the API returns { success, data, error }, pass it through
+        if (data && typeof data === 'object' && 'success' in data) {
+          return data as ApiResponse;
+        }
+
+        // Otherwise wrap in success response
+        return { success: true, data };
+      } catch (error: unknown) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+
+        return {
+          success: false,
+          data: undefined,
+          error: errorMessage
+        };
+      }
+    }
+
+    return {
+      get: <T = unknown>(endpoint: string, params?: Record<string, unknown>) => wrapRequest(() => client.get<T>(endpoint, params as Record<string, string | number | boolean | null | undefined>)),
+      post: (endpoint: string, body?: unknown) => wrapRequest(() => client.post(endpoint, body)),
+      put: (endpoint: string, body?: unknown) => wrapRequest(() => client.put(endpoint, body)),
+      patch: (endpoint: string, body?: unknown) => wrapRequest(() => client.patch(endpoint, body)),
+      delete: (endpoint: string) => wrapRequest(() => client.delete(endpoint))
+    };
+  }, [config]);
+}

package/src/lib/assistant-api-actions.ts

@@ -0,0 +1,549 @@
+
+import { toast } from 'sonner';
+
+import { type ProjectState } from '../hooks/use-project-state';
+import { type SessionState } from '../hooks/use-session-state';
+import {
+  type ApiResponse, type AssistantSession, type Project, type Work
+} from '../types';
+
+import { processMessagesData } from './message-utils';
+
+type ApiClient = {
+  get: (url: string, params?: any) => Promise<any>;
+  post: (url: string, data?: any) => Promise<any>;
+  patch: (url: string, data?: any) => Promise<any>;
+  delete: (url: string) => Promise<any>;
+};
+
+type TranslationFn = (key: string) => string;
+
+// Fetch threads for an agent
+export async function fetchAgentThreads(
+  apiClient: ApiClient,
+  tenantAiAgentId: string,
+  onSuccess: (threads: AssistantSession[]) => void,
+  userId?: string | null,
+  deploymentId?: string | null
+) {
+  try {
+    const apiParams: any = {
+      columns: 'id,subject,created_on,last_modified_on,body_text,tenant_ai_agent_id,created_by',
+      orderBy: JSON.stringify({ field: 'created_on', direction: 'desc' })
+    };
+
+    const agentRule = deploymentId ? { field: 'tenant_ai_agent_deployment_id', operator: '=', value: deploymentId } : { field: 'tenant_ai_agent_id', operator: '=', value: tenantAiAgentId };
+
+    const rules: any[] = [agentRule, { field: 'archived', operator: '=', value: 'false' }];
+
+    if (userId) {
+      rules.push({
+        combinator: 'or',
+        rules: [{ field: 'record_owner', operator: '=', value: userId }, { field: 'record_owner', operator: 'shared_to_me' }]
+      });
+    }
+
+    apiParams.filters = JSON.stringify({ combinator: 'and', rules });
+
+    const response = (await apiClient.get('/apps/base/data-sources/thread/items', apiParams)) as ApiResponse<any[]>;
+
+    if (response.success && response.data) {
+      const items = Array.isArray(response.data) ? response.data : (response.data as any).items || [];
+      const threads: AssistantSession[] = items.map((item: any) => ({
+        id: item.id,
+        title: item.subject,
+        messages: [],
+        createdAt: new Date(item.created_on),
+        updatedAt: new Date(item.last_modified_on || item.created_on)
+      }));
+
+      onSuccess(threads);
+    } else {
+      console.error('Failed to fetch threads:', response.error || (response as any).message);
+    }
+  } catch (error) {
+    console.error('Failed to fetch threads:', error);
+  }
+}
+
+// Fetch threads for a specific project
+export async function fetchProjectThreads(
+  apiClient: ApiClient,
+  projectId: string,
+  onSuccess: (projectId: string, threads: AssistantSession[]) => void
+) {
+  try {
+    const apiParams: any = {
+      columns: 'id,subject,created_on,last_modified_on,body_text,tenant_ai_agent_id,tenant_ai_project_id ',
+      orderBy: JSON.stringify({ field: 'created_on', direction: 'desc' })
+    };
+
+    apiParams.filters = JSON.stringify({
+      rules: [{ field: 'tenant_ai_project_id ', operator: '=', value: projectId }]
+    });
+
+    const response = (await apiClient.get('/apps/base/data-sources/thread/items', apiParams)) as ApiResponse<any[]>;
+
+    if (response.success && response.data) {
+      const items = Array.isArray(response.data) ? response.data : (response.data as any).items || [];
+      const threads: AssistantSession[] = items.map((item: any) => ({
+        id: item.id,
+        title: item.subject,
+        messages: [],
+        createdAt: new Date(item.created_on),
+        updatedAt: new Date(item.last_modified_on)
+      }));
+
+      onSuccess(projectId, threads);
+    } else {
+      console.error('Failed to fetch project threads:', response.error || (response as any).message);
+    }
+  } catch (error) {
+    console.error('Failed to fetch project threads:', error);
+  }
+}
+
+// Fetch works for a specific project
+export async function fetchProjectWorks(
+  apiClient: ApiClient,
+  projectId: string,
+  onSuccess: (projectId: string, works: Work[]) => void,
+  tenantAiAgentId?: string,
+  userId?: string | null
+) {
+  try {
+    const response = (await apiClient.get('/ai/works')) as ApiResponse<any[]>;
+
+    if (response.success && response.data) {
+      const allWorks = Array.isArray(response.data) ? response.data : (response.data as any).items || [];
+      const projectWorks = allWorks.filter((work: any) => work.tenant_ai_project_id === projectId
+        && (!tenantAiAgentId || work.tenant_ai_agent_id === tenantAiAgentId)
+        && (!userId || work.created_by === userId || (Array.isArray(work.shared_to) && work.shared_to.includes(userId))));
+
+      const formattedWorks: Work[] = projectWorks.map((item: Work) => ({
+        id: item.id,
+        title: item.title,
+        base_thread_id: item.base_thread_id,
+        content_json: item.content_json,
+        content_text: item.content_text,
+        description: item.description,
+        tenant_ai_agent_deployment_id: item.tenant_ai_agent_deployment_id,
+        tenant_ai_agent_id: item.tenant_ai_agent_id,
+        tenant_data_source_id: item.tenant_data_source_id,
+        tenant_ai_project_id: item.tenant_ai_project_id,
+        type: item.type,
+        created_by: item.created_by,
+        created_on: item.created_on,
+        last_modified_on: item.last_modified_on,
+        image_url: item.image_url || undefined
+      }));
+
+      onSuccess(projectId, formattedWorks);
+    } else {
+      console.error('Failed to fetch project works:', response.error || (response as any).message);
+    }
+  } catch (error) {
+    console.error('Failed to fetch project works:', error);
+  }
+}
+
+// Fetch all projects
+export async function fetchProjects(
+  apiClient: ApiClient,
+  userId: string | null,
+  onSuccess: (projects: Project[]) => void,
+  onProjectLoaded: (project: Project) => void,
+  onComplete: () => void,
+  tenantAiAgentId?: string
+) {
+  try {
+    const response = (await apiClient.get('/ai/projects')) as ApiResponse<any[]>;
+
+    if (response.success && response.data) {
+      const responseItems = Array.isArray(response.data) ? response.data : (response.data as any).items || [];
+      const allProjects: Project[] = responseItems.map((item: any) => ({
+        id: item.id,
+        tenant_ai_agent_id: item.tenant_ai_agent_id,
+        tenant_ai_agent_deployment_id: item.tenant_ai_agent_deployment_id,
+        name: item.name,
+        description: item.description,
+        created_by: item.created_by,
+        shared_to: item.shared_to
+      }));
+
+      const filteredProjects = allProjects.filter((project) => {
+        const matchesAgent = !tenantAiAgentId || project.tenant_ai_agent_id === tenantAiAgentId;
+        const matchesUser = !userId || project.created_by === userId || (project.shared_to && project.shared_to.includes(userId));
+
+        return matchesAgent && matchesUser;
+      });
+
+      onSuccess(filteredProjects);
+      filteredProjects.forEach(onProjectLoaded);
+    } else {
+      console.error('Failed to fetch projects:', response.error || (response as any).message);
+    }
+  } catch (error) {
+    console.error('Failed to fetch projects:', error);
+  } finally {
+    onComplete();
+  }
+}
+
+// Fetch all works
+export async function fetchWorks(
+  apiClient: ApiClient,
+  onSuccess: (works: Work[]) => void,
+  tenantAiAgentId?: string,
+  userId?: string | null
+) {
+  try {
+    const response = (await apiClient.get('/ai/works')) as ApiResponse<any[]>;
+
+    if (response.success && response.data) {
+      const allItems = Array.isArray(response.data) ? response.data : (response.data as any).items || [];
+      const worksItems = allItems.filter((item: any) => {
+        const matchesAgent = !tenantAiAgentId || item.tenant_ai_agent_id === tenantAiAgentId;
+        const matchesUser = !userId || item.created_by === userId || (Array.isArray(item.shared_to) && item.shared_to.includes(userId));
+
+        return matchesAgent && matchesUser;
+      });
+      const formattedWorks: Work[] = worksItems.map((item: any) => ({
+        id: item.id,
+        title: item.title,
+        base_thread_id: item.base_thread_id,
+        content_json: item.content_json,
+        content_text: item.content_text,
+        description: item.description,
+        tenant_ai_agent_deployment_id: item.tenant_ai_agent_deployment_id,
+        tenant_ai_agent_id: item.tenant_ai_agent_id,
+        tenant_data_source_id: item.tenant_data_source_id,
+        type: item.type,
+        created_by: item.created_by,
+        created_on: item.created_on,
+        last_modified_on: item.last_modified_on,
+        image_url: item.image_url || undefined
+      }));
+
+      onSuccess(formattedWorks);
+    } else {
+      console.error('Failed to fetch works:', response.error || (response as any).message);
+    }
+  } catch (error) {
+    console.error('Failed to fetch works:', error);
+  }
+}
+
+// Load messages for a thread
+export async function loadThreadMessages(
+  apiClient: ApiClient,
+  threadId: string,
+  setMessages: (messages: any[]) => void
+) {
+  try {
+    const response = (await apiClient.get('/apps/base/data-sources/message/items', {
+      columns: 'body_json,created_on,record_owner,role',
+      filters: JSON.stringify({ rules: [{ field: 'thread', operator: '=', value: threadId }] }),
+      sort: JSON.stringify([{ field: 'created_on', direction: 'asc' }])
+    })) as ApiResponse<any[]>;
+
+    if (response.success && response.data) {
+      const formattedMessages = processMessagesData(response.data);
+
+      setMessages(formattedMessages as any);
+    } else {
+      console.info('No messages found for thread');
+      setMessages([]);
+    }
+  } catch (error) {
+    console.error('Error loading thread messages:', error);
+    setMessages([]);
+  }
+}
+
+// Update project
+export async function updateProject(
+  apiClient: ApiClient,
+  projectState: ProjectState,
+  projectActions: {
+    setSaving: (saving: boolean) => void;
+    stopEditing: () => void;
+  },
+  refreshProjects: () => void,
+  t: TranslationFn
+) {
+  if (!projectState.name.trim() || !projectState.selectedProject) return;
+
+  projectActions.setSaving(true);
+  try {
+    const response: ApiResponse = await apiClient.patch(`/ai/projects/${projectState.selectedProject.id}`, {
+      name: projectState.name.trim(),
+      description: projectState.description.trim()
+    });
+
+    if (response.success) {
+      projectActions.stopEditing();
+      refreshProjects();
+      toast.success(t('toast.project_updated_success'));
+    } else {
+      throw new Error('Failed to update project');
+    }
+  } catch (error) {
+    console.error('Error updating project:', error);
+    toast.error(t('toast.failed_update_project'));
+  } finally {
+    projectActions.setSaving(false);
+  }
+}
+
+// Delete project
+export async function deleteProject(
+  apiClient: ApiClient,
+  projectState: ProjectState,
+  projectActions: {
+    setDeleteDialogOpen: (open: boolean) => void;
+    setDeleting: (deleting: boolean) => void;
+  },
+  refreshProjects: () => void,
+  t: TranslationFn
+) {
+  if (!projectState.selectedProject) return;
+
+  projectActions.setDeleting(true);
+  try {
+    const response: ApiResponse = await apiClient.delete(`/ai/projects/${projectState.selectedProject.id}`);
+
+    if (response.success) {
+      projectActions.setDeleteDialogOpen(false);
+      projectActions.setDeleting(false);
+      refreshProjects();
+      toast.success(t('toast.project_deleted_success'));
+    } else {
+      toast.error(t('toast.failed_delete_project'));
+      throw new Error('Failed to delete project');
+    }
+  } catch (error) {
+    console.error('Error deleting project:', error);
+    toast.error(t('toast.failed_delete_project'));
+  } finally {
+    projectActions.setDeleting(false);
+  }
+}
+
+// Update session
+export async function updateSession(
+  apiClient: ApiClient,
+  sessionState: SessionState,
+  sessionActions: {
+    setSaving: (saving: boolean) => void;
+    stopEditing: () => void;
+  },
+  refreshThreads: () => void,
+  refreshProjectThreads: (projectId: string) => void,
+  projectContextId: string | null,
+  selectedProjectId: string | null,
+  t: TranslationFn
+) {
+  if (!sessionState.name.trim() || !sessionState.selectedSession) return;
+
+  sessionActions.setSaving(true);
+  try {
+    const response = (await apiClient.patch(
+      `/apps/base/data-sources/thread/items/${sessionState.selectedSession.id}`,
+      { subject: sessionState.name.trim() }
+    )) as ApiResponse<any>;
+
+    if (response.success) {
+      sessionActions.stopEditing();
+      refreshThreads();
+      if (projectContextId) refreshProjectThreads(projectContextId);
+      if (selectedProjectId) refreshProjectThreads(selectedProjectId);
+      toast.success(t('toast.session_renamed_success'));
+    } else {
+      toast.error(t('toast.failed_rename_session'));
+    }
+  } catch (error) {
+    console.error('Error updating session:', error);
+    toast.error(t('toast.failed_rename_session'));
+  } finally {
+    sessionActions.setSaving(false);
+  }
+}
+
+// Delete session
+export async function deleteSession(
+  apiClient: ApiClient,
+  sessionState: SessionState,
+  sessionActions: {
+    setDeleteDialogOpen: (open: boolean) => void;
+    setDeleting: (deleting: boolean) => void;
+  },
+  refreshThreads: () => void,
+  refreshProjectThreads: (projectId: string) => void,
+  projectContextId: string | null,
+  selectedProjectId: string | null,
+  t: TranslationFn
+) {
+  if (!sessionState.selectedSession) return;
+
+  sessionActions.setDeleting(true);
+  try {
+    const response = (await apiClient.delete(
+      `/apps/base/data-sources/thread/items/${sessionState.selectedSession.id}`
+    )) as ApiResponse<any>;
+
+    if (response.success) {
+      sessionActions.setDeleteDialogOpen(false);
+      refreshThreads();
+      if (projectContextId) refreshProjectThreads(projectContextId);
+      if (selectedProjectId) refreshProjectThreads(selectedProjectId);
+      toast.success(t('toast.session_deleted_success'));
+    } else {
+      toast.error(t('toast.failed_delete_session'));
+    }
+  } catch (error) {
+    console.error('Error deleting session:', error);
+    toast.error(t('toast.failed_delete_session'));
+  } finally {
+    sessionActions.setDeleting(false);
+  }
+}
+
+// Update project instructions
+export async function updateProjectInstructions(
+  apiClient: ApiClient,
+  projectState: ProjectState,
+  projectActions: {
+    setSavingInstructions: (saving: boolean) => void;
+    stopEditingInstructions: () => void;
+    updateProject: (project: Project) => void;
+  },
+  refreshProjects: () => void,
+  t: TranslationFn
+) {
+  if (!projectState.selectedProject) return;
+
+  projectActions.setSavingInstructions(true);
+  try {
+    const response = (await apiClient.patch(`/ai/projects/${projectState.selectedProject.id}`, {
+      instructions: projectState.instructions.trim() || null
+    })) as ApiResponse<any>;
+
+    if (response.success) {
+      projectActions.stopEditingInstructions();
+      projectActions.updateProject({
+        ...projectState.selectedProject,
+        instructions: projectState.instructions.trim() || undefined
+      });
+      refreshProjects();
+      toast.success(t('toast.instructions_updated_success'));
+    } else {
+      toast.error(t('toast.failed_update_instructions'));
+    }
+  } catch (error) {
+    console.error('Error updating instructions:', error);
+    toast.error(t('toast.failed_update_instructions'));
+  } finally {
+    projectActions.setSavingInstructions(false);
+  }
+}
+
+// Create new thread
+export async function createThread(
+  apiClient: ApiClient,
+  data: {
+    subject: string;
+    body_text: string;
+    sender_name: string;
+    deploymentId?: string;
+    tenantAiAgentId: string;
+    projectId?: string | null;
+  }
+): Promise<{
+  id: string; subject: string; created_on: string; last_modified_on: string;
+} | null> {
+  try {
+    const response = (await apiClient.post('/apps/base/data-sources/thread/items', {
+      subject: data.subject,
+      body_text: data.body_text,
+      sender_name: data.sender_name,
+      thread_type: 'assistant',
+      tenant_ai_agent_deployment_id: data.deploymentId ? String(data.deploymentId) : null,
+      tenant_ai_agent_id: String(data.tenantAiAgentId),
+      tenant_ai_project_id: data.projectId || null
+    })) as ApiResponse<any>;
+
+    if (response && response.success && response.data) {
+      return response.data;
+    } else {
+      console.error('Failed to create thread:', response?.error || 'Unknown error');
+
+      return null;
+    }
+  } catch (error) {
+    console.error('Failed to create thread:', error);
+
+    return null;
+  }
+}
+
+// Upload file to thread via REST API
+export async function uploadThreadFile(
+  apiClient: ApiClient,
+  threadId: string,
+  file: File
+): Promise<string | null> {
+  try {
+    const formData = new FormData();
+
+    formData.append('file', file);
+
+    const response = (await apiClient.post(
+      `/apps/base/data-sources/thread/items/${threadId}/files/upload`,
+      formData
+    )) as ApiResponse<any>;
+
+    if (response.success && response.data) {
+      // Return the storage path (file_name field)
+      const fileData = Array.isArray(response.data) ? response.data[0] : response.data;
+
+      return fileData?.file_name || fileData?.path || null;
+    }
+
+    console.error('Failed to upload file:', response.error);
+
+    return null;
+  } catch (error) {
+    console.error('Failed to upload file:', error);
+
+    return null;
+  }
+}
+
+// Create new project
+export async function createProject(
+  apiClient: ApiClient,
+  data: {
+    name: string;
+    description?: string;
+    tenantAiAgentId: string;
+  },
+  onSuccess: (project: any) => void,
+  onComplete: () => void
+) {
+  try {
+    const response: any = await apiClient.post('/ai/projects', {
+      name: data.name,
+      tenant_ai_agent_id: data.tenantAiAgentId,
+      description: data.description || undefined
+    });
+
+    if (response.success && response.data) {
+      onSuccess(response.data);
+    }
+  } catch (error) {
+    console.error('Failed to create project:', error);
+  } finally {
+    onComplete();
+  }
+}

package/src/lib/assistant-config.tsx

@@ -0,0 +1,71 @@
+'use client';
+
+import {
+  createContext, type ReactNode, use, useMemo
+} from 'react';
+
+import { Toaster } from 'sonner';
+
+import { AssistantI18nProvider } from '../i18n';
+
+// User interface for assistant
+export interface AssistantUser {
+  id: string;
+  email?: string;
+  firstname?: string;
+  lastname?: string;
+  photo?: string;
+}
+
+export interface DataSourceField {
+  id: string;
+  name: string;
+  slug: string;
+  type: string;
+  read_only?: boolean;
+  sort_order?: number;
+}
+
+export interface DataSourceSchema {
+  id: string;
+  name: string;
+  slug: string;
+  app: { id: string; name: string; slug: string };
+  fields: DataSourceField[];
+}
+
+export interface AssistantConfig {
+  apiBaseUrl: string;
+  getAuthToken: () => Promise<string>;
+  user?: AssistantUser | null;
+  getDataSourceSchema?: (id: string) => Promise<DataSourceSchema | null>;
+}
+
+const AssistantConfigContext = createContext<AssistantConfig | null>(null);
+
+export interface AssistantProviderProps {
+  config: AssistantConfig;
+  children: ReactNode;
+}
+
+export function AssistantProvider({ config, children }: AssistantProviderProps) {
+  // Stabilize context value so consumers only re-render when config actually changes
+  const value = useMemo(() => config, [config]);
+
+  return (
+    <AssistantConfigContext value={value}>
+      <AssistantI18nProvider>{children}</AssistantI18nProvider>
+      <Toaster />
+    </AssistantConfigContext>
+  );
+}
+
+export function useAssistantConfig(): AssistantConfig {
+  const config = use(AssistantConfigContext);
+
+  if (!config) {
+    throw new Error('useAssistantConfig must be used within an AssistantProvider');
+  }
+
+  return config;
+}