@docyrus/ui-pro-ai-assistant 0.0.2 → 0.0.3

package/src/lib/api-client.ts

@@ -1,77 +0,0 @@
-'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

@@ -1,549 +0,0 @@
-
-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

@@ -1,75 +0,0 @@
-'use client';
-
-import {
-  createContext, type ReactNode, use, useMemo
-} from 'react';
-
-import { Toaster } from 'sonner';
-
-import { TooltipProvider } from '@docyrus/ui-pro-shared/components/tooltip';
-
-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}>
-      <TooltipProvider>
-        <AssistantI18nProvider>{children}</AssistantI18nProvider>
-        <Toaster />
-      </TooltipProvider>
-    </AssistantConfigContext>
-  );
-}
-
-export function useAssistantConfig(): AssistantConfig {
-  const config = use(AssistantConfigContext);
-
-  if (!config) {
-    throw new Error('useAssistantConfig must be used within an AssistantProvider');
-  }
-
-  return config;
-}