@hexabot-ai/api 3.0.0-alpha.3 → 3.1.1-alpha.0

package/src/config/i18n/fr/chatbot_settings.json

@@ -0,0 +1,17 @@
+{
+  "Chatbot": "Chatbot",
+  "Default NLU helper": "Utilitaire NLU par défaut",
+  "Helper used by default to run NLU tasks.": "Utilitaire utilisé par défaut pour exécuter les tâches NLU.",
+  "Default NLU penalty factor": "Facteur de pénalité NLU par défaut",
+  "Penalty factor applied to NLU confidence scoring.": "Facteur de pénalité appliqué au score de confiance NLU.",
+  "Default LLM helper": "Utilitaire LLM par défaut",
+  "Helper used by default for LLM generation tasks.": "Utilitaire utilisé par défaut pour les tâches de génération LLM.",
+  "Default storage helper": "Utilitaire de stockage par défaut",
+  "Helper used to persist chatbot data by default.": "Utilitaire utilisé par défaut pour persister les données du chatbot.",
+  "License key": "Clé de licence",
+  "Provide the license key associated with your subscription. Learn more about available plans at https://hexabot.ai/pricing#pricing.": "Indiquez la clé de licence liée à votre abonnement. Découvrez nos offres sur https://hexabot.ai/pricing#pricing.",
+  "Enable global fallback": "Activer le fallback global",
+  "Enable fallback handling when no intent or flow matches.": "Activer la gestion du fallback lorsqu'aucune intention ou aucun flux ne correspond.",
+  "Fallback messages": "Messages de fallback",
+  "Messages shown when fallback handling is triggered.": "Messages affichés lorsque la gestion du fallback est déclenchée."
+}

package/src/config/i18n/fr/contact.json

@@ -0,0 +1,23 @@
+{
+  "Contact": "Contact",
+  "Contact recipient email": "E-mail destinataire de contact",
+  "Email address that receives contact form submissions.": "Adresse e-mail qui reçoit les soumissions du formulaire de contact.",
+  "Company name": "Nom de l'entreprise",
+  "Company name displayed to end users.": "Nom de l'entreprise affiché aux utilisateurs finaux.",
+  "Company phone": "Téléphone de l'entreprise",
+  "Primary phone number displayed in contact information.": "Numéro de téléphone principal affiché dans les informations de contact.",
+  "Company email": "E-mail de l'entreprise",
+  "Public contact email address shown to users.": "Adresse e-mail publique de contact affichée aux utilisateurs.",
+  "Address line 1": "Adresse ligne 1",
+  "First line of the company postal address.": "Première ligne de l'adresse postale de l'entreprise.",
+  "Address line 2": "Adresse ligne 2",
+  "Second line of the company postal address.": "Deuxième ligne de l'adresse postale de l'entreprise.",
+  "City": "Ville",
+  "City for the company postal address.": "Ville de l'adresse postale de l'entreprise.",
+  "Postal code": "Code postal",
+  "Postal or ZIP code for the company address.": "Code postal pour l'adresse de l'entreprise.",
+  "State or region": "État ou région",
+  "State, region, or province for the company address.": "État, région ou province pour l'adresse de l'entreprise.",
+  "Country": "Pays",
+  "Country code for the company address.": "Code pays pour l'adresse de l'entreprise."
+}

package/src/config/i18n/fr/messages.json

@@ -1,20 +1,13 @@
 {
-  "invitation_subject": "[Hexabot] Invitation à s'inscrire",
   "account_confirmation_subject": "[Hexabot] Confirmation de compte",
   "password_reset_subject": "[Hexabot] Réinitialisation du mot de passe",
   "welcome": "Bienvenue",
   "hi": "Bonjour",
-  "invitation_to_join": "Invitation",
-  "invitation_for_account_creation": "Vous avez été invités pour créer un ",
-  "account": "compte",
-  "create_account": "Cliquez sur le bouton ci-dessous pour créer votre compte :",
-  "registration_failed": "Échec de l'inscription! L'adresse e-mail ou le jeton d'invitation n'est pas valide.",
-  "join": "Inscription",
-  "account_successfully_created_confirm_password": "Vous avez créé avec succès un compte mais vous devrez confirmez votre adresse email.",
-  "confirm_account": "Cliquez sur le bouton ci-dessous pour confirmer votre compte:",
+  "account_successfully_created_confirm_password": "Vous avez créé un compte avec succès, mais vous devrez confirmer votre adresse e-mail.",
+  "confirm_account": "Cliquez sur le bouton ci-dessous pour confirmer votre compte :",
   "password_reset_request": "Une demande de réinitialisation du mot de passe de votre compte a été effectuée.",
   "reset": "Réinitialiser",
-  "click_to_reset_password": "Cliquez sur le bouton ci-dessous pour définir un nouveau mot de passe:",
-  "confirm": "Confirmez",
+  "click_to_reset_password": "Cliquez sur le bouton ci-dessous pour définir un nouveau mot de passe :",
+  "confirm": "Confirmer",
   "best_regards": "Cordialement"
 }

package/src/config/i18n/fr/rag_settings.json

@@ -0,0 +1,21 @@
+{
+  "RAG": "RAG",
+  "Enable RAG": "Activer RAG",
+  "Enable retrieval-augmented generation.": "Activer la génération augmentée par récupération.",
+  "Default RAG mode": "Mode RAG par défaut",
+  "Default retrieval mode used for RAG queries.": "Mode de récupération par défaut utilisé pour les requêtes RAG.",
+  "Embedding provider": "Fournisseur d'embeddings",
+  "Provider used to generate embedding vectors.": "Fournisseur utilisé pour générer les vecteurs d'embeddings.",
+  "Embedding model": "Modèle d'embeddings",
+  "Embedding model identifier used by the selected provider.": "Identifiant du modèle d'embeddings utilisé par le fournisseur sélectionné.",
+  "Embedding API key": "Clé API d'embeddings",
+  "API key used by the configured embedding provider.": "Clé API utilisée par le fournisseur d'embeddings configuré.",
+  "Embedding base URL": "URL de base des embeddings",
+  "Custom base URL used for embedding API requests.": "URL de base personnalisée utilisée pour les requêtes API d'embeddings.",
+  "Embedding dimensions": "Dimensions des embeddings",
+  "Number of dimensions expected for embedding vectors.": "Nombre de dimensions attendues pour les vecteurs d'embeddings.",
+  "Top K results": "Top K résultats",
+  "Maximum number of retrieved chunks returned per query.": "Nombre maximal de segments récupérés retournés par requête.",
+  "Index only active content": "Indexer uniquement le contenu actif",
+  "Include only active content entries in the retrieval index.": "Inclure uniquement les entrées de contenu actives dans l'index de récupération."
+}

package/src/config/index.ts

@@ -76,12 +76,13 @@ export const config: Config = {
       /^\/auth\/local$/, // login
       /^\/auth\/logout$/, // logout
       /^\/webhook\//, // Any webhook channel
+      /^\/reset(\/[^\/]+)?$/, // Reset request / Change password
     ],
   },
   sockets: {
     path: '/socket.io',
     // transports to allow connections to (e.g. ['polling', 'websocket'])
-    transports: ['websocket'],
+    transports: ['websocket', 'polling'],
     beforeConnect(_handshake: any): boolean {
       // `true` allows the socket to connect.
       // (`false` would reject the connection)
@@ -222,13 +223,6 @@ export const config: Config = {
       expiresIn: (process.env.JWT_EXPIRES_IN || '24h') as any,
     },
   },
-  invitation: {
-    jwtOptions: {
-      salt: parseInt(process.env.SALT_LENGTH || '12'),
-      secret: process.env.INVITATION_JWT_SECRET || 'DEFAULT_INVITATION_SECRET',
-      expiresIn: (process.env.INVITATION_EXPIRES_IN || '24h') as any,
-    },
-  },
   password_reset: {
     jwtOptions: {
       salt: parseInt(process.env.SALT_LENGTH || '12'),

package/src/config/types.ts

@@ -125,9 +125,6 @@ export type Config = {
   authentication: {
     jwtOptions: JwtConfigOptions;
   };
-  invitation: {
-    jwtOptions: JwtConfigOptions;
-  };
   password_reset: {
     jwtOptions: JwtConfigOptions;
   };

package/src/database/decorators/orm-event-hooks.decorator.ts

@@ -0,0 +1,84 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import 'reflect-metadata';
+import { InsertEvent, RemoveEvent, UpdateEvent } from 'typeorm';
+
+import { BaseOrmEntity } from '..';
+
+export const ORM_HOOK_NAMES = [
+  'beforeInsert',
+  'afterInsert',
+  'beforeUpdate',
+  'afterUpdate',
+  'beforeRemove',
+  'afterRemove',
+] as const;
+
+export type OrmHookName = (typeof ORM_HOOK_NAMES)[number];
+
+export type OrmLifecycleEvent<Entity extends BaseOrmEntity> =
+  | InsertEvent<Entity>
+  | UpdateEvent<Entity>
+  | RemoveEvent<Entity>;
+
+const HOOKS_KEY = Symbol('hooks');
+const hook =
+  (name: OrmHookName): MethodDecorator =>
+  (target, key) => {
+    const meta = Reflect.getOwnMetadata(HOOKS_KEY, target.constructor) || {};
+    (meta[name] ??= []).push(key);
+    Reflect.defineMetadata(HOOKS_KEY, meta, target.constructor);
+  };
+
+export const OnBeforeInsert = () => hook('beforeInsert');
+
+export const OnAfterInsert = () => hook('afterInsert');
+
+export const OnBeforeUpdate = () => hook('beforeUpdate');
+
+export const OnAfterUpdate = () => hook('afterUpdate');
+
+export const OnBeforeRemove = () => hook('beforeRemove');
+
+export const OnAfterRemove = () => hook('afterRemove');
+
+export const getOrmHookMethods = (
+  target: any,
+  name: OrmHookName,
+): Array<string | symbol> => {
+  const constructor =
+    typeof target === 'function' ? target : target.constructor;
+
+  return Reflect.getMetadata(HOOKS_KEY, constructor)?.[name] ?? [];
+};
+
+export const invokeOrmHooks = async <
+  Entity extends BaseOrmEntity<{
+    actions: {};
+    transformers: {
+      full: Entity['fullCls'];
+      plain: Entity['plainCls'];
+    };
+  }>,
+>(
+  entity: any,
+  hook: OrmHookName,
+  event: OrmLifecycleEvent<Entity>,
+  targetClass?: any,
+): Promise<void> => {
+  if (!entity) return;
+
+  const constructor = targetClass ?? entity.constructor;
+  const methods = getOrmHookMethods(constructor, hook);
+
+  for (const key of methods) {
+    const handler = entity[key];
+    if (typeof handler === 'function') {
+      await handler.call(entity, event);
+    }
+  }
+};

package/src/database/entities/base.entity.ts

@@ -6,17 +6,18 @@
 
 import { randomUUID } from 'crypto';
 
-import {
-  BeforeInsert,
-  BeforeUpdate,
-  EntityManager,
-  PrimaryColumn,
-} from 'typeorm';
+import { plainToInstance } from 'class-transformer';
+import { BeforeInsert, BeforeUpdate, PrimaryColumn } from 'typeorm';
 
 import { DatetimeColumn } from '@/database/decorators/datetime-column.decorator';
+import { InferTransformDto, TDto } from '@/utils';
 
-export abstract class BaseOrmEntity {
-  private static entityManagerProvider?: () => EntityManager;
+export abstract class BaseOrmEntity<Dto extends TDto = TDto> {
+  abstract plainCls: Dto['transformers']['plain'];
+
+  abstract fullCls: Dto['transformers']['full'];
+
+  declare readonly __dtoType: Dto;
 
   @PrimaryColumn()
   id!: string;
@@ -42,29 +43,15 @@ export abstract class BaseOrmEntity {
     this.updatedAt = new Date();
   }
 
-  static registerEntityManagerProvider(provider: () => EntityManager): void {
-    this.entityManagerProvider = provider;
+  public toPlainCls(): InferTransformDto<Dto['transformers']['plain']> {
+    return plainToInstance(this.plainCls as any, this, {
+      exposeUnsetFields: false,
+    });
   }
 
-  protected static getEntityManager(): EntityManager {
-    if (!this.entityManagerProvider) {
-      throw new Error(
-        `Entity manager provider not registered for ${this.name}`,
-      );
-    }
-
-    try {
-      const manager = this.entityManagerProvider();
-      if (!manager) {
-        throw new Error('Entity manager provider returned no manager');
-      }
-
-      return manager;
-    } catch (error) {
-      const reason = error instanceof Error ? error.message : String(error);
-      throw new Error(
-        `Unable to resolve entity manager for ${this.name}: ${reason}`,
-      );
-    }
+  public toFullCls(): InferTransformDto<Dto['transformers']['full']> {
+    return plainToInstance(this.fullCls as any, this, {
+      exposeUnsetFields: false,
+    });
   }
 }

package/src/extension/cleanup.service.ts

@@ -5,15 +5,15 @@
  */
 
 import { Injectable } from '@nestjs/common';
-import { In, Like } from 'typeorm';
+import { In } from 'typeorm';
+import { DeleteResult } from 'typeorm/driver/mongodb/typings';
 
 import { ChannelService } from '@/channel/channel.service';
 import { HelperService } from '@/helper/helper.service';
 import { LoggerService } from '@/logger/logger.service';
 import { SettingService } from '@/setting/services/setting.service';
-import { DeleteResult } from '@/utils/generics/base-orm.repository';
 
-import { TCriteria, TExtractExtension, TExtractNamespace } from './types';
+import { TCriteria, TExtractGroup } from './types';
 
 @Injectable()
 export class CleanupService {
@@ -28,28 +28,28 @@ export class CleanupService {
    * Deletes unused settings with the specified criteria.
    *
    * @param criteria - An array of criteria objects containing:
-   *                   - suffix: Regex pattern to match setting groups
-   *                   - namespaces: Array of namespaces to exclude from deletion
+   *                   - extensionType: Extension type marker stored in setting subgroup
+   *                   - groups: Array of groups to exclude from deletion
    * @returns A promise that resolves to the result of the deletion operation.
    */
-  private async deleteManyBySuffixAndNamespaces(
+  private async deleteManyBySubgroupAndGroups(
     criteria: TCriteria[],
   ): Promise<DeleteResult> {
     const groupsToDelete = new Set<string>();
 
-    for (const { suffix, namespaces } of criteria) {
+    for (const { extensionType, groups } of criteria) {
       const matchingSettings = await this.settingService.find({
-        where: { group: Like(`%${suffix}`) },
+        where: { subgroup: extensionType },
       });
 
       if (!matchingSettings.length) {
         continue;
       }
 
-      const namespacesSet = new Set<string>(namespaces);
+      const groupsSet = new Set<string>(groups);
 
       matchingSettings.forEach(({ group }) => {
-        if (!namespacesSet.has(group)) {
+        if (!groupsSet.has(group)) {
           groupsToDelete.add(group);
         }
       });
@@ -65,25 +65,25 @@ export class CleanupService {
   }
 
   /**
-   * Retrieves a list of channel Namespaces.
+   * Retrieves a list of channel setting groups.
    *
-   * @returns An array of channel Namespaces.
+   * @returns An array of channel groups.
    */
-  public getChannelNamespaces(): TExtractNamespace<'channel'>[] {
+  public getChannelGroups(): TExtractGroup<'channel'>[] {
     return this.channelService
       .getAll()
-      .map((channel) => channel.getNamespace<TExtractExtension<'channel'>>());
+      .map((channel) => channel.getName() as TExtractGroup<'channel'>);
   }
 
   /**
-   * Retrieves a list of helper Namespaces.
+   * Retrieves a list of helper setting groups.
    *
-   * @returns An array of helper Namespaces.
+   * @returns An array of helper groups.
    */
-  public getHelperNamespaces(): TExtractNamespace<'helper'>[] {
+  public getHelperGroups(): TExtractGroup<'helper'>[] {
     return this.helperService
       .getAll()
-      .map((helper) => helper.getNamespace<TExtractExtension<'helper'>>());
+      .map((helper) => helper.getName() as TExtractGroup<'helper'>);
   }
 
   /**
@@ -91,11 +91,11 @@ export class CleanupService {
    *
    */
   public async pruneExtensionSettings(): Promise<void> {
-    const channels = this.getChannelNamespaces();
-    const helpers = this.getHelperNamespaces();
-    const { deletedCount } = await this.deleteManyBySuffixAndNamespaces([
-      { suffix: '_channel', namespaces: channels },
-      { suffix: '_helper', namespaces: helpers },
+    const channels = this.getChannelGroups();
+    const helpers = this.getHelperGroups();
+    const { deletedCount } = await this.deleteManyBySubgroupAndGroups([
+      { extensionType: 'channel', groups: channels },
+      { extensionType: 'helper', groups: helpers },
     ]);
 
     if (deletedCount > 0) {

package/src/extension/types.ts

@@ -4,36 +4,16 @@
  * Full terms: see LICENSE.md.
  */
 
-import { ExtensionName } from '@/utils/types/extension';
+import { ChannelName } from '@/channel/types';
+import { HelperName } from '@/helper/types';
 
-type TExcludedExtension = 'plugin';
+export type TExtension = 'channel' | 'helper';
 
-type TExcludeSuffix<
-  T,
-  S extends string = '_',
-  Suffix extends string = `${S}${TExcludedExtension}`,
-> = T extends `${infer _Base}${Suffix}` ? never : T;
+export type TExtractGroup<T extends TExtension> = T extends 'channel'
+  ? ChannelName
+  : HelperName;
 
-export type TExtensionName = TExcludeSuffix<ExtensionName, '-'>;
-
-export type TExtension =
-  Extract<TExtensionName, `${string}-${string}`> extends `${string}-${infer S}`
-    ? `${S}`
-    : never;
-
-export type TNamespace = HyphenToUnderscore<TExtensionName>;
-
-export type TExtractNamespace<
-  T extends TExtension = TExtension,
-  M extends TExtensionName = TExtensionName,
-> = M extends `${string}${T}` ? HyphenToUnderscore<M> : never;
-
-export type TExtractExtension<
-  T extends TExtension = TExtension,
-  M extends TExtensionName = TExtensionName,
-> = M extends `${string}${T}` ? M : never;
-
-export type TCriteria = {
-  suffix: `_${TExtension}`;
-  namespaces: TNamespace[];
+export type TCriteria<T extends TExtension = TExtension> = {
+  extensionType: T;
+  groups: TExtractGroup<T>[];
 };

package/src/extensions/actions/ai/agent.action.ts

@@ -0,0 +1,148 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { Injectable } from '@nestjs/common';
+import { ToolLoopAgent, ToolSet } from 'ai';
+
+import { ExecArgs } from '@/actions';
+import { ActionService } from '@/actions/actions.service';
+import { WorkflowRuntimeContext } from '@/workflow/contexts/workflow-runtime.context';
+
+import { AiBaseAction } from './ai-base.action';
+import {
+  AiAgentInput,
+  AiAgentOutput,
+  AiAgentSettings,
+  aiAgentInputSchema,
+  aiAgentOutputSchema,
+  aiAgentSettingsSchema,
+} from './ai-schemas';
+
+@Injectable()
+export class AiAgentAction extends AiBaseAction<
+  AiAgentInput,
+  AiAgentOutput,
+  WorkflowRuntimeContext,
+  AiAgentSettings
+> {
+  constructor(actionService: ActionService) {
+    super(
+      {
+        name: 'ai_agent',
+        description:
+          'Runs a ToolLoopAgent with optional tools to generate multi-step outputs via the Vercel AI SDK.',
+        inputSchema: aiAgentInputSchema,
+        outputSchema: aiAgentOutputSchema,
+        settingsSchema: aiAgentSettingsSchema,
+      },
+      actionService,
+    );
+  }
+
+  async execute({
+    input,
+    settings,
+    context,
+    bindings,
+  }: ExecArgs<AiAgentInput, WorkflowRuntimeContext, AiAgentSettings>) {
+    const logger = context.services.logger;
+    const modelBinding = bindings.model;
+    const providerName = modelBinding?.settings?.provider ?? 'openai';
+    const modelId = this.resolveModelId(modelBinding);
+    const credentials = await context.services.credentials.findOneValue(
+      modelBinding?.settings?.api_key,
+    );
+    const providerOptions = this.buildProviderInitOptions(
+      providerName,
+      modelBinding,
+      credentials,
+    );
+    const provider = await this.loadProvider(providerName, providerOptions);
+    const model = this.createModel(provider, modelId);
+    const selectedMemorySlugs = this.resolveMemoryBindingSlugs(
+      context,
+      bindings.memory,
+    );
+    const promptPayload = await this.buildPrompt(
+      input,
+      context,
+      selectedMemorySlugs,
+    );
+    const callSettings = this.buildCallSettings(settings);
+    const tools = (await this.buildTools(
+      context,
+      bindings.tools,
+      bindings.mcp,
+      selectedMemorySlugs,
+    )) as ToolSet | undefined;
+    const toolNames = [
+      ...Object.keys(bindings.tools ?? {}),
+      ...Object.keys(bindings.mcp ?? {}),
+    ];
+    const { stopWhen, stepCount, toolCall } = this.buildStopWhen(
+      settings,
+      tools,
+    );
+    const agent = new ToolLoopAgent({
+      ...callSettings,
+      ...(promptPayload.system ? { instructions: promptPayload.system } : {}),
+      ...(stopWhen ? { stopWhen } : {}),
+      model,
+      tools,
+    });
+
+    logger.debug(
+      `Calling model "${modelId}" via ai_agent action using provider "${providerName}"`,
+      {
+        provider: providerName,
+        base_url: providerOptions.baseURL,
+        tools: toolNames,
+        stop_when: {
+          step_count: stepCount,
+          tool_call: toolCall,
+        },
+      },
+    );
+    const agentPrompt =
+      'messages' in promptPayload
+        ? promptPayload.messages
+        : promptPayload.prompt;
+
+    if (!agentPrompt) {
+      throw new Error('Prompt is required to call the agent.');
+    }
+
+    const result = await agent.generate({ prompt: agentPrompt });
+
+    return {
+      text: result.text,
+      content: result.content,
+      reasoning:
+        result.reasoningText ??
+        (result.reasoning?.length
+          ? result.reasoning.map((part) => part.text).join('\n')
+          : undefined),
+      files: result.files,
+      sources: result.sources,
+      tool_calls: result.toolCalls,
+      tool_results: result.toolResults,
+      finish_reason: result.finishReason,
+      raw_finish_reason: result.rawFinishReason,
+      model: modelId,
+      usage: this.normalizeUsage(result.usage),
+      total_usage: this.normalizeUsage(result.totalUsage),
+      steps: result.steps,
+      raw: {
+        request: result.request,
+        response: result.response,
+        provider_metadata: result.providerMetadata,
+        warnings: result.warnings,
+      },
+    };
+  }
+}
+
+export default AiAgentAction;