Refine AI chatbot registration process (#11)

* improve error popover readability in «DeploymentStatus»

Enhance the error popover by adding a «panelStyle» property with word-wrapping. This ensures long text breaks properly, improving readability and preventing layout issues.

* improve error handling and enrich contextual information

Enhance error propagation and contextual data in HTTP client operations by introducing a detailed «HttpError» utility. Update test cases to validate enriched error messages, including status text and request details.

Refactor installation steps to incorporate structured error handling using «StepError», providing detailed context and possible causes for failures. Improve diagnostic messaging during installation, including step-specific details and enriched error descriptions.

Add utility functions to extract status codes and derive potential causes for issues, improving debugging capabilities. Update related unit tests to ensure comprehensive coverage of new behaviors.

* add rollback support to installation steps

Introduce rollback functionality to the installation process, enabling the reversal of completed steps upon failure. Extend «InstallationAIAssistantStep» with a new «rollback» method and update «InstallationProgressManager» to manage rollback execution. Add rollback handling for agent, connector, and model creation steps, ensuring created resources are cleaned up if subsequent steps fail.

Enhance integration tests to validate rollback behavior and update the «InstallationResult» structure to include «rollbackErrors» for improved error reporting.

* update error message in «TestModelConnectionStep» test

Refine the error message in the «TestModelConnectionStep» test to improve clarity and match the updated phrasing. This ensures the test provides more precise feedback when the step validation fails.

* remove handling of response body in «HttpError»

Simplify the «HttpError» implementation by removing all logic related to determining and handling the presence of a response body. Eliminate the «responseBodyOmitted» property, the «hasMeaningfulBody» function, and associated references.

This change reduces complexity and aligns with a security-focused approach by avoiding reliance on response body content.

* update tests to validate additional error details

Enhance the test for «WindowFetchHttpClient» by adding assertions for «status» and «statusText» in propagated HTTP errors, ensuring more comprehensive error validation.

Simplify the failure message validation in «InstallationProgressManager» tests by removing redundant details, improving clarity and focus on the core error message.

* refactor formatting and interface definitions

Simplify code structure by normalizing formatting for better readability across files. Replace «RollbackError» type with an «interface» for consistency. Update multiline constructs to align with style guidelines.

These changes improve code maintainability and adhere to standardized practices.

* add rollback handling and error collection in tests

Introduce an optional «onRollback» callback to the «TestStep» class, enabling custom rollback logic during test execution. Update the «rollback» method to invoke this callback if provided.

Add a new test case to verify proper rollback execution order for failed and completed steps. Ensure rollback errors are collected and validated.

Enhances test coverage and ensures consistent behavior during rollback scenarios.

* add unit test for «ModelRegister» component

Introduce a unit test to verify the behavior of the «ModelRegister» component during installation failure. Mock dependencies like «ModelForm» and «useAssistantInstallation» to simulate scenarios, ensuring proper handling of error states and absence of success messages.

* add rollback handling and summary display for installation errors

Introduce rollback tracking in the installation process to record reverted steps during failures. Update the response structure to include a «rollbacks» field and propagate this data through the installation workflow.

Enhance the UI to display rollback summaries using «addInfoToast» when installation errors occur. Modify tests to verify rollback behavior and ensure accurate reporting of reverted steps.

Improve error handling and state management by adding a reference to track the last rollback summary and avoid duplicate toasts.

* refactor test imports and rollback methods for consistency

Standardize imports across test files by replacing inline React imports with named imports. Simplify code structure for readability by reformatting multiline arrays and conditionals.

Remove the «override» keyword from rollback methods in multiple classes to align with TypeScript conventions and ensure compatibility.

Improve readability in «derivePossibleCauses» by reformatting conditional checks for network issues.

These changes enhance code consistency, maintainability, and readability.

* replace named imports with explicit «React» references in mocks

Update mocked components and hooks to use explicit «React» references
instead of named imports. This change ensures compatibility with Jest's
module mocking and avoids potential conflicts with React's internal
APIs.

Additionally, replace JSX syntax with «React.createElement» in the
mocked «MockModelForm» for consistency and clarity in the mock's
implementation.

Author: guidomodarelli

public/dashboard-assistant/components/__tests__/model-register.test.tsx

@@ -0,0 +1,108 @@
+/*
+ * Copyright Wazuh Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React from 'react';
+import userEvent from '@testing-library/user-event';
+import { render, screen, waitFor } from '../../../../test/test_utils';
+
+jest.mock('../model-form', () => {
+  const _React = jest.requireActual<typeof import('react')>('react');
+
+  const MockModelForm = ({ onChange, onValidationChange }: any) => {
+    _React.useEffect(() => {
+      onChange?.({
+        modelProvider: 'OpenAI',
+        model: 'gpt-4o',
+        apiUrl: 'https://api.openai.com/v1/chat/completions',
+        apiKey: 'mock-key',
+      });
+      onValidationChange?.(true);
+    }, [onChange, onValidationChange]);
+
+    return _React.createElement('div', { 'data-testid': 'mock-model-form' });
+  };
+
+  return {
+    __esModule: true,
+    ModelForm: MockModelForm,
+  };
+});
+
+jest.mock('../../modules/installation-manager/hooks/use-assistant-installation', () => {
+  const React = jest.requireActual<typeof import('react')>('react');
+  const { ExecutionState } = jest.requireActual<
+    typeof import('../../modules/installation-manager/domain')
+  >('../../modules/installation-manager/domain');
+
+  const failedStep = {
+    stepName: 'Create Model',
+    state: ExecutionState.FAILED,
+    error: new Error('Model step failed'),
+  };
+
+  const progress = {
+    getSteps: () => [
+      {
+        stepName: 'Persist ML Commons settings',
+        state: ExecutionState.FINISHED_SUCCESSFULLY,
+      },
+      failedStep,
+    ],
+    getFailedSteps: () => [failedStep],
+    isFinished: () => false,
+    isFinishedSuccessfully: () => false,
+    isFinishedWithWarnings: () => false,
+    hasFailed: () => true,
+  };
+
+  return {
+    __esModule: true,
+    useAssistantInstallation: () => {
+      const [error, setError] = React.useState<string | undefined>(undefined);
+
+      const install = React.useCallback(async () => {
+        setError('Steps: "Create Model" has failed');
+      }, []);
+
+      return {
+        install,
+        setModel: jest.fn(),
+        reset: jest.fn(),
+        isLoading: false,
+        error,
+        result: { success: false, rollbacks: ['Create Agent', 'Create Connector'] },
+        modelData: undefined,
+        progress,
+        isSuccess: false,
+      };
+    },
+  };
+});
+
+import { ModelRegister } from '../model-register';
+
+describe('ModelRegister', () => {
+  it('does not show success toast when installation fails', async () => {
+    const user = userEvent.setup();
+
+    render(<ModelRegister />);
+
+    const deployButton = await screen.findByRole('button', { name: /Deploy/i });
+    expect(deployButton).toBeEnabled();
+
+    await user.click(deployButton);
+
+    await screen.findByText(/Error deploying model/i);
+
+    await waitFor(() => {
+      expect(screen.queryByText('Model deployed successfully.')).not.toBeInTheDocument();
+    });
+
+    expect(await screen.findByText(/Rollback summary/i)).toBeInTheDocument();
+    expect(
+      await screen.findByText(/Reverted steps: Create Agent, Create Connector/i)
+    ).toBeInTheDocument();
+  });
+});

public/dashboard-assistant/components/deployment-status.tsx

@@ -96,6 +96,7 @@ export const DeploymentStatus = ({
               <div style={{ display: 'flex', alignItems: 'center' }}>
                 {uiStatus === StepStatus.ERROR && step?.error ? (
                   <EuiPopover
+                    panelStyle={{ wordBreak: 'break-word' }}
                     isOpen={openErrorPopoverKey === key}
                     closePopover={() => setOpenErrorPopoverKey(null)}
                     anchorPosition="rightCenter"

public/dashboard-assistant/components/model-register.tsx

@@ -3,7 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import React, { useState, useCallback, useEffect } from 'react';
+import React, { useState, useCallback, useEffect, useRef } from 'react';
 import {
   EuiButton,
   EuiButtonEmpty,
@@ -50,15 +50,17 @@ const ModelRegisterComponent = ({
   onDeployed,
 }: ModelRegisterProps) => {
   const [isDeployed, setIsDeployed] = useState(false);
-  const { addSuccessToast, addErrorToast } = useToast();
+  const { addSuccessToast, addErrorToast, addInfoToast } = useToast();
   const {
     install: startInstallationProcess,
     setModel,
     isLoading: isInstalling,
     error: installationError,
     progress: installationProgress,
     isSuccess: isInstallationSuccessful,
+    result: installationResult,
   } = useAssistantInstallation();
+  const lastRollbackKeyRef = useRef<string | null>(null);
 
   useEffect(() => {
     if (installationError) {
@@ -67,7 +69,19 @@ const ModelRegisterComponent = ({
         `${installationError}. Rolling back current installation. Please, verify data provided and try again.`
       );
     }
-  }, [addErrorToast, addSuccessToast, installationError]);
+  }, [addErrorToast, installationError]);
+
+  useEffect(() => {
+    if (installationError && installationResult?.rollbacks?.length) {
+      const rollbackSummary = installationResult.rollbacks.join(', ');
+      if (lastRollbackKeyRef.current !== rollbackSummary) {
+        addInfoToast('Rollback summary', `Reverted steps: ${rollbackSummary}`);
+        lastRollbackKeyRef.current = rollbackSummary;
+      }
+    } else if (!installationError) {
+      lastRollbackKeyRef.current = null;
+    }
+  }, [addInfoToast, installationError, installationResult]);
 
   useEffect(() => {
     if (isInstallationSuccessful) {

public/dashboard-assistant/modules/agent/application/ports/__mocks__/agent-repository.ts

@@ -8,6 +8,7 @@ import type { AgentRepository } from '../agent-repository';
 export function createAgentRepositoryMock(): jest.Mocked<AgentRepository> {
   return {
     create: jest.fn(),
+    delete: jest.fn(),
     execute: jest.fn(),
     getActive: jest.fn(),
     register: jest.fn(),

public/dashboard-assistant/modules/agent/application/ports/agent-repository.ts

@@ -3,11 +3,11 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { CreateRepository } from '../../../common/domain/entities/repository';
+import { CreateRepository, DeleteRepository } from '../../../common/domain/entities/repository';
 import { Agent } from '../../domain/entities/agent';
 import { CreateAgentDto } from '../dtos/create-agent-dto';
 
-export interface AgentRepository extends CreateRepository<Agent, CreateAgentDto> {
+export interface AgentRepository extends CreateRepository<Agent, CreateAgentDto>, DeleteRepository {
   execute(id: string, parameters: any): Promise<any>;
   getActive(): Promise<string | undefined>;
   register(agentId: string): Promise<void>;

public/dashboard-assistant/modules/agent/application/use-cases/delete-agent.ts

@@ -0,0 +1,12 @@
+/*
+ * Copyright Wazuh Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { AgentRepository } from '../ports/agent-repository';
+
+export const deleteAgentUseCase = (agentRepository: AgentRepository) => async (
+  agentId: string
+): Promise<void> => {
+  await agentRepository.delete(agentId);
+};

public/dashboard-assistant/modules/common/http/infrastructure/http-error.ts

@@ -0,0 +1,128 @@
+/*
+ * Copyright Wazuh Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const SENSITIVE_KEY_PATTERN = /(key|token|secret|password|authorization)$/i;
+const MAX_BODY_LENGTH = 1000;
+
+export class HttpError extends Error {
+  public response?: Response;
+  public status?: number;
+  public statusText?: string;
+  public request?: { method: string; url: string; body?: string };
+
+  private constructor(message: string) {
+    super(message);
+    this.name = 'HttpError';
+  }
+
+  public static async create(
+    response: Response,
+    options: RequestInit & { method: string },
+    url: string
+  ): Promise<HttpError> {
+    const method = options.method.toUpperCase();
+    const sanitizedUrl = this.sanitizeUrl(url);
+
+    const statusText = response.statusText?.trim();
+    const statusSummary = statusText ? `${response.status} ${statusText}` : `${response.status}`;
+
+    const message = this.buildFailureMessage({
+      method,
+      url: sanitizedUrl,
+      statusSummary,
+    });
+
+    const error = new HttpError(message);
+    error.response = response;
+    error.status = response.status;
+    error.statusText = response.statusText;
+    error.request = {
+      method,
+      url: sanitizedUrl,
+      body: this.sanitizeRequestBody(options.body ?? undefined),
+    };
+
+    return error;
+  }
+
+  private static buildFailureMessage(params: {
+    method: string;
+    url: string;
+    statusSummary: string;
+  }): string {
+    const { method, url, statusSummary } = params;
+
+    const messageParts = [`HTTP ${method} ${url} failed with status ${statusSummary}`].filter(
+      Boolean
+    );
+
+    return messageParts.join('. ');
+  }
+
+  private static sanitizeUrl(url: string): string {
+    try {
+      const base =
+        typeof window !== 'undefined' && window.location?.origin
+          ? window.location.origin
+          : 'http://localhost';
+      const parsed = new URL(url, base);
+      parsed.searchParams.forEach((value, key) => {
+        if (SENSITIVE_KEY_PATTERN.test(key)) {
+          parsed.searchParams.delete(key);
+        }
+      });
+
+      if (!url.startsWith('http')) {
+        return `${parsed.pathname}${parsed.search}${parsed.hash}` || parsed.pathname;
+      }
+
+      return parsed.toString();
+    } catch (error) {
+      return url;
+    }
+  }
+
+  private static sanitizeStructuredValue(value: unknown): unknown {
+    if (value == null) {
+      return value;
+    }
+
+    if (Array.isArray(value)) {
+      return value.map((item) => this.sanitizeStructuredValue(item));
+    }
+
+    if (typeof value === 'object') {
+      return Object.entries(value as Record<string, unknown>).reduce<Record<string, unknown>>(
+        (acc, [key, entryValue]) => {
+          if (typeof entryValue !== 'string' || !SENSITIVE_KEY_PATTERN.test(key)) {
+            acc[key] = this.sanitizeStructuredValue(entryValue);
+          }
+          return acc;
+        },
+        {}
+      );
+    }
+
+    return value;
+  }
+
+  private static sanitizeRequestBody(body?: BodyInit | null): string | undefined {
+    if (!body) {
+      return undefined;
+    }
+
+    if (typeof body === 'string') {
+      try {
+        const parsed = JSON.parse(body);
+        const sanitized = this.sanitizeStructuredValue(parsed);
+        return JSON.stringify(sanitized);
+      } catch (error) {
+        return body.length > MAX_BODY_LENGTH ? `${body.slice(0, MAX_BODY_LENGTH)}...` : body;
+      }
+    }
+
+    return '';
+  }
+}