@fluxo-dev/api-client-base 25.3.3 → 25.3.4

package/index.cjs.js

@@ -9817,6 +9817,334 @@ class SessionHubService {
   }
 }
 
+class AiService {
+  /**
+   * ========================================
+   * LLM SETTINGS METHODS
+   * ========================================
+   */
+  /**
+   * Lista tutte le configurazioni LLM
+   */
+  getAllLLMSettings() {
+    return __awaiter(this, void 0, void 0, function* () {
+      return HttpClient$1.Instance().client.get('/ai/management/llm');
+    });
+  }
+  /**
+   * Ottieni una configurazione specifica
+   */
+  getLLMSettingsById(id) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return HttpClient$1.Instance().client.get(`/ai/management/llm/${id}`);
+    });
+  }
+  /**
+   * Crea una nuova configurazione LLM
+   */
+  createLLMSettings(command) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return HttpClient$1.Instance().client.post('/ai/management/llm', command);
+    });
+  }
+  /**
+   * Aggiorna una configurazione esistente
+   */
+  updateLLMSettings(id, command) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return HttpClient$1.Instance().client.put(`/ai/management/llm/${id}`, command);
+    });
+  }
+  /**
+   * Attiva una configurazione
+   */
+  activateLLMSettings(id) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return HttpClient$1.Instance().client.post(`/ai/management/llm/${id}/activate`, {});
+    });
+  }
+  /**
+   * Disattiva una configurazione
+   */
+  deactivateLLMSettings(id) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return HttpClient$1.Instance().client.post(`/ai/management/llm/${id}/deactivate`, {});
+    });
+  }
+  /**
+   * Elimina una configurazione
+   */
+  deleteLLMSettings(id) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return HttpClient$1.Instance().client.delete(`/ai/management/llm/${id}`);
+    });
+  }
+  /**
+   * ========================================
+   * AGENT METHODS
+   * ========================================
+   */
+  /**
+   * Lista tutti gli agenti
+   */
+  getAllAgents() {
+    return __awaiter(this, void 0, void 0, function* () {
+      return HttpClient$1.Instance().client.get('/ai/management/agent');
+    });
+  }
+  /**
+   * Ottieni un agente specifico
+   */
+  getAgentById(id) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return HttpClient$1.Instance().client.get(`/ai/management/agent/${id}`);
+    });
+  }
+  /**
+   * Crea un nuovo agente
+   */
+  createAgent(command) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return HttpClient$1.Instance().client.post('/ai/management/agent', command);
+    });
+  }
+  /**
+   * Aggiorna un agente esistente
+   */
+  updateAgent(id, command) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return HttpClient$1.Instance().client.put(`/ai/management/agent/${id}`, command);
+    });
+  }
+  /**
+   * Attiva un agente
+   */
+  activateAgent(id) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return HttpClient$1.Instance().client.post(`/ai/management/agent/${id}/activate`, {});
+    });
+  }
+  /**
+   * Disattiva un agente
+   */
+  deactivateAgent(id) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return HttpClient$1.Instance().client.post(`/ai/management/agent/${id}/deactivate`, {});
+    });
+  }
+  /**
+   * Elimina un agente
+   */
+  deleteAgent(id) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return HttpClient$1.Instance().client.delete(`/ai/management/agent/${id}`);
+    });
+  }
+  /**
+   * ========================================
+   * ORCHESTRATION METHODS
+   * ========================================
+   */
+  /**
+   * Lista tutte le orchestrazioni
+   */
+  getAllOrchestrations() {
+    return __awaiter(this, void 0, void 0, function* () {
+      return HttpClient$1.Instance().client.get('/ai/management/orchestration');
+    });
+  }
+  /**
+   * Ottieni un'orchestrazione specifica
+   */
+  getOrchestrationById(id) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return HttpClient$1.Instance().client.get(`/ai/management/orchestration/${id}`);
+    });
+  }
+  /**
+   * Crea una nuova orchestrazione
+   */
+  createOrchestration(command) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return HttpClient$1.Instance().client.post('/ai/management/orchestration', command);
+    });
+  }
+  /**
+   * Aggiorna un'orchestrazione esistente
+   */
+  updateOrchestration(id, command) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return HttpClient$1.Instance().client.put(`/ai/management/orchestration/${id}`, command);
+    });
+  }
+  /**
+   * Attiva un'orchestrazione
+   */
+  activateOrchestration(id) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return HttpClient$1.Instance().client.post(`/ai/management/orchestration/${id}/activate`, {});
+    });
+  }
+  /**
+   * Disattiva un'orchestrazione
+   */
+  deactivateOrchestration(id) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return HttpClient$1.Instance().client.post(`/ai/management/orchestration/${id}/deactivate`, {});
+    });
+  }
+  /**
+   * Elimina un'orchestrazione
+   */
+  deleteOrchestration(id) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return HttpClient$1.Instance().client.delete(`/ai/management/orchestration/${id}`);
+    });
+  }
+  /**
+   * ========================================
+   * MCP SERVER METHODS
+   * ========================================
+   */
+  /**
+   * Lista tutti i server MCP
+   */
+  getAllMcpServers() {
+    return __awaiter(this, void 0, void 0, function* () {
+      return HttpClient$1.Instance().client.get('/ai/management/mcp-server');
+    });
+  }
+  /**
+   * Ottieni un server MCP specifico
+   */
+  getMcpServerById(id) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return HttpClient$1.Instance().client.get(`/ai/management/mcp-server/${id}`);
+    });
+  }
+  /**
+   * Crea un nuovo server MCP
+   */
+  createMcpServer(command) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return HttpClient$1.Instance().client.post('/ai/management/mcp-server', command);
+    });
+  }
+  /**
+   * Aggiorna un server MCP esistente
+   */
+  updateMcpServer(id, command) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return HttpClient$1.Instance().client.put(`/ai/management/mcp-server/${id}`, command);
+    });
+  }
+  /**
+   * Attiva un server MCP
+   */
+  activateMcpServer(id) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return HttpClient$1.Instance().client.put(`/ai/management/mcp-server/${id}/activate`, {});
+    });
+  }
+  /**
+   * Disattiva un server MCP
+   */
+  deactivateMcpServer(id) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return HttpClient$1.Instance().client.put(`/ai/management/mcp-server/${id}/deactivate`, {});
+    });
+  }
+  /**
+   * Elimina un server MCP
+   */
+  deleteMcpServer(id) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return HttpClient$1.Instance().client.delete(`/ai/management/mcp-server/${id}`);
+    });
+  }
+  /**
+   * ========================================
+   * AGENT-MCP ASSOCIATION METHODS
+   * ========================================
+   */
+  /**
+   * Associa un server MCP ad un agente
+   */
+  associateMcpServerToAgent(agentId, mcpServerId) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return HttpClient$1.Instance().client.post(`/ai/management/agent/${agentId}/mcp-server/${mcpServerId}`, {});
+    });
+  }
+  /**
+   * Rimuovi l'associazione tra un server MCP e un agente
+   */
+  dissociateMcpServerFromAgent(agentId, mcpServerId) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return HttpClient$1.Instance().client.delete(`/ai/management/agent/${agentId}/mcp-server/${mcpServerId}`);
+    });
+  }
+}
+
+exports.LLMProviderType = void 0;
+(function (LLMProviderType) {
+  LLMProviderType[LLMProviderType["OpenAI"] = 1] = "OpenAI";
+  LLMProviderType[LLMProviderType["AzureOpenAI"] = 2] = "AzureOpenAI";
+  LLMProviderType[LLMProviderType["Anthropic"] = 3] = "Anthropic";
+  LLMProviderType[LLMProviderType["Ollama"] = 4] = "Ollama";
+  LLMProviderType[LLMProviderType["Gemini"] = 5] = "Gemini";
+})(exports.LLMProviderType || (exports.LLMProviderType = {}));
+
+exports.OrchestrationType = void 0;
+(function (OrchestrationType) {
+  OrchestrationType[OrchestrationType["Sequential"] = 0] = "Sequential";
+  OrchestrationType[OrchestrationType["Concurrent"] = 1] = "Concurrent";
+  OrchestrationType[OrchestrationType["Handoff"] = 2] = "Handoff";
+  OrchestrationType[OrchestrationType["GroupChat"] = 3] = "GroupChat";
+  OrchestrationType[OrchestrationType["Magentic"] = 4] = "Magentic";
+  OrchestrationType[OrchestrationType["Coordinator"] = 5] = "Coordinator";
+})(exports.OrchestrationType || (exports.OrchestrationType = {}));
+const orchestrationTypeLabels = {
+  [exports.OrchestrationType.Sequential]: "Sequenziale",
+  [exports.OrchestrationType.Concurrent]: "Concorrente",
+  [exports.OrchestrationType.Handoff]: "Handoff",
+  [exports.OrchestrationType.GroupChat]: "Group Chat",
+  [exports.OrchestrationType.Magentic]: "Magentic One",
+  [exports.OrchestrationType.Coordinator]: "Coordinator"
+};
+const orchestrationTypeDescriptions = {
+  [exports.OrchestrationType.Sequential]: "L'output di un agente diventa input del successivo",
+  [exports.OrchestrationType.Concurrent]: "Tutti gli agenti processano in parallelo",
+  [exports.OrchestrationType.Handoff]: "Passaggio dinamico di controllo basato su regole/contesto",
+  [exports.OrchestrationType.GroupChat]: "Conversazione di gruppo con manager coordinator",
+  [exports.OrchestrationType.Magentic]: "Orchestrazione MagenticOne di Microsoft Research",
+  [exports.OrchestrationType.Coordinator]: "Orchestrazione con pianificazione e coordinazione multi-step"
+};
+
+/**
+ * Enumerazione dei tipi di server MCP
+ */
+exports.McpServerType = void 0;
+(function (McpServerType) {
+  /** Processo comunicante via stdin/stdout */
+  McpServerType[McpServerType["Stdio"] = 0] = "Stdio";
+  /** Server HTTP con Server-Sent Events */
+  McpServerType[McpServerType["SSE"] = 1] = "SSE";
+})(exports.McpServerType || (exports.McpServerType = {}));
+/**
+ * Enumerazione dei tipi di autenticazione MCP
+ */
+exports.McpAuthType = void 0;
+(function (McpAuthType) {
+  /** Nessuna autenticazione */
+  McpAuthType[McpAuthType["None"] = 0] = "None";
+  /** API Key (header X-API-Key) */
+  McpAuthType[McpAuthType["ApiKey"] = 1] = "ApiKey";
+  /** Bearer Token OAuth/JWT */
+  McpAuthType[McpAuthType["BearerToken"] = 2] = "BearerToken";
+  /** Basic Authentication (username:password) */
+  McpAuthType[McpAuthType["BasicAuth"] = 3] = "BasicAuth";
+})(exports.McpAuthType || (exports.McpAuthType = {}));
+
 class FluxoClientBase {
   constructor() {
     this._authenticationType = null;
@@ -9832,6 +10160,7 @@ class FluxoClientBase {
     this._config = null;
     this._ravify = null;
     this._biFacade = null;
+    this._ai = null;
     this._sessionHub = null;
     this._modules = [];
     this.getBearerToken = () => {
@@ -9881,6 +10210,7 @@ class FluxoClientBase {
       this._communicationFacade = new CommunicationFacade();
       this._ravify = new RavifyFacade();
       this._biFacade = new BiFacade();
+      this._ai = new AiService();
       this._sessionHub = new SessionHubService(config.fluxoInstanceBaseUrl, this.getBearerToken);
       console.info('7) Sub services initialized');
       if (setState) state.store.dispatch(state.setFluxoClientConfiguration(config));
@@ -9924,6 +10254,9 @@ class FluxoClientBase {
   get bi() {
     return this._biFacade;
   }
+  get ai() {
+    return this._ai;
+  }
   get sessionHub() {
     return this._sessionHub;
   }
@@ -10229,6 +10562,7 @@ exports.RavifyEventStateType = void 0;
   RavifyEventStateType[RavifyEventStateType["JobDeleted"] = 7] = "JobDeleted";
 })(exports.RavifyEventStateType || (exports.RavifyEventStateType = {}));
 
+exports.AiService = AiService;
 exports.ApiKeyService = ApiKeyService;
 exports.AppService = AppService;
 exports.AppServiceService = AppServiceService;
@@ -10257,3 +10591,5 @@ exports.ServerFilterHelper = ServerFilterHelper;
 exports.SessionHubService = SessionHubService;
 exports.UserService = UserService;
 exports.WorkflowService = WorkflowService;
+exports.orchestrationTypeDescriptions = orchestrationTypeDescriptions;
+exports.orchestrationTypeLabels = orchestrationTypeLabels;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluxo-dev/api-client-base",
-  "version": "25.3.3",
+  "version": "25.3.4",
   "type": "commonjs",
   "peerDependencies": {
     "react": "^18.3.1",
@@ -8,7 +8,7 @@
     "react-router-dom": "^6.11.2",
     "react-redux": "^8.0.5",
     "@reduxjs/toolkit": "^1.9.1",
-    "@fluxo-dev/state": "^25.3.3"
+    "@fluxo-dev/state": "^25.3.4"
   },
   "main": "./index.cjs.js",
   "types": "./index.cjs.d.ts"

package/src/index.d.ts

@@ -22,3 +22,4 @@ export * from './lib/infrastructure';
 export * from './lib/ravify';
 export * from './lib/bi';
 export * from './lib/session-hub';
+export * from './lib/ai';

package/src/lib/ai/ai.service.d.ts

@@ -0,0 +1,148 @@
+import { CreateLLMSettingsCommand, LLMSettingsDto, UpdateLLMSettingsCommand, AgentDto, CreateAgentCommand, UpdateAgentCommand, CreateAgentOrchestrationCommand, AgentOrchestrationDto, UpdateAgentOrchestrationCommand, McpServerConfigurationDto, CreateMcpServerCommand, UpdateMcpServerCommand } from './models';
+export declare class AiService {
+    /**
+     * ========================================
+     * LLM SETTINGS METHODS
+     * ========================================
+     */
+    /**
+     * Lista tutte le configurazioni LLM
+     */
+    getAllLLMSettings(): Promise<LLMSettingsDto[]>;
+    /**
+     * Ottieni una configurazione specifica
+     */
+    getLLMSettingsById(id: string): Promise<LLMSettingsDto>;
+    /**
+     * Crea una nuova configurazione LLM
+     */
+    createLLMSettings(command: CreateLLMSettingsCommand): Promise<LLMSettingsDto>;
+    /**
+     * Aggiorna una configurazione esistente
+     */
+    updateLLMSettings(id: string, command: UpdateLLMSettingsCommand): Promise<LLMSettingsDto>;
+    /**
+     * Attiva una configurazione
+     */
+    activateLLMSettings(id: string): Promise<LLMSettingsDto>;
+    /**
+     * Disattiva una configurazione
+     */
+    deactivateLLMSettings(id: string): Promise<LLMSettingsDto>;
+    /**
+     * Elimina una configurazione
+     */
+    deleteLLMSettings(id: string): Promise<void>;
+    /**
+     * ========================================
+     * AGENT METHODS
+     * ========================================
+     */
+    /**
+     * Lista tutti gli agenti
+     */
+    getAllAgents(): Promise<AgentDto[]>;
+    /**
+     * Ottieni un agente specifico
+     */
+    getAgentById(id: string): Promise<AgentDto>;
+    /**
+     * Crea un nuovo agente
+     */
+    createAgent(command: CreateAgentCommand): Promise<AgentDto>;
+    /**
+     * Aggiorna un agente esistente
+     */
+    updateAgent(id: string, command: UpdateAgentCommand): Promise<AgentDto>;
+    /**
+     * Attiva un agente
+     */
+    activateAgent(id: string): Promise<AgentDto>;
+    /**
+     * Disattiva un agente
+     */
+    deactivateAgent(id: string): Promise<AgentDto>;
+    /**
+     * Elimina un agente
+     */
+    deleteAgent(id: string): Promise<void>;
+    /**
+     * ========================================
+     * ORCHESTRATION METHODS
+     * ========================================
+     */
+    /**
+     * Lista tutte le orchestrazioni
+     */
+    getAllOrchestrations(): Promise<AgentOrchestrationDto[]>;
+    /**
+     * Ottieni un'orchestrazione specifica
+     */
+    getOrchestrationById(id: string): Promise<AgentOrchestrationDto>;
+    /**
+     * Crea una nuova orchestrazione
+     */
+    createOrchestration(command: CreateAgentOrchestrationCommand): Promise<AgentOrchestrationDto>;
+    /**
+     * Aggiorna un'orchestrazione esistente
+     */
+    updateOrchestration(id: string, command: UpdateAgentOrchestrationCommand): Promise<AgentOrchestrationDto>;
+    /**
+     * Attiva un'orchestrazione
+     */
+    activateOrchestration(id: string): Promise<AgentOrchestrationDto>;
+    /**
+     * Disattiva un'orchestrazione
+     */
+    deactivateOrchestration(id: string): Promise<AgentOrchestrationDto>;
+    /**
+     * Elimina un'orchestrazione
+     */
+    deleteOrchestration(id: string): Promise<void>;
+    /**
+     * ========================================
+     * MCP SERVER METHODS
+     * ========================================
+     */
+    /**
+     * Lista tutti i server MCP
+     */
+    getAllMcpServers(): Promise<McpServerConfigurationDto[]>;
+    /**
+     * Ottieni un server MCP specifico
+     */
+    getMcpServerById(id: string): Promise<McpServerConfigurationDto>;
+    /**
+     * Crea un nuovo server MCP
+     */
+    createMcpServer(command: CreateMcpServerCommand): Promise<McpServerConfigurationDto>;
+    /**
+     * Aggiorna un server MCP esistente
+     */
+    updateMcpServer(id: string, command: UpdateMcpServerCommand): Promise<McpServerConfigurationDto>;
+    /**
+     * Attiva un server MCP
+     */
+    activateMcpServer(id: string): Promise<McpServerConfigurationDto>;
+    /**
+     * Disattiva un server MCP
+     */
+    deactivateMcpServer(id: string): Promise<McpServerConfigurationDto>;
+    /**
+     * Elimina un server MCP
+     */
+    deleteMcpServer(id: string): Promise<void>;
+    /**
+     * ========================================
+     * AGENT-MCP ASSOCIATION METHODS
+     * ========================================
+     */
+    /**
+     * Associa un server MCP ad un agente
+     */
+    associateMcpServerToAgent(agentId: string, mcpServerId: string): Promise<AgentDto>;
+    /**
+     * Rimuovi l'associazione tra un server MCP e un agente
+     */
+    dissociateMcpServerFromAgent(agentId: string, mcpServerId: string): Promise<AgentDto>;
+}

package/src/lib/ai/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ai.service';
+export * from './models';

package/src/lib/ai/models/agent.d.ts

@@ -0,0 +1,21 @@
+export interface AgentDto {
+    id: string;
+    name: string;
+    description?: string;
+    systemPrompt: string;
+    llmSettingsId: string;
+    llmSettings?: {
+        id: string;
+        name: string;
+        providerType: number;
+        modelId: string;
+        hasApiKey: boolean;
+        endpoint?: string;
+        temperature?: number;
+        maxTokens?: number;
+        isActive: boolean;
+    };
+    isActive: boolean;
+    /** Lista ID server MCP associati */
+    mcpServerIds?: string[];
+}

package/src/lib/ai/models/create-agent.d.ts

@@ -0,0 +1,6 @@
+export interface CreateAgentCommand {
+    name: string;
+    description?: string;
+    systemPrompt: string;
+    llmSettingsId: string;
+}

package/src/lib/ai/models/create-llm-settings.d.ts

@@ -0,0 +1,17 @@
+import { LLMProviderType } from './llm-settings';
+export interface CreateLLMSettingsCommand {
+    name: string;
+    providerType: LLMProviderType;
+    modelId: string;
+    apiKey: string;
+    endpoint?: string;
+    organizationId?: string;
+    deploymentName?: string;
+    apiVersion?: string;
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+    frequencyPenalty?: number;
+    presencePenalty?: number;
+    timeoutSeconds?: number;
+}

package/src/lib/ai/models/create-mcp-server.d.ts

@@ -0,0 +1,22 @@
+import { McpServerType, McpAuthType } from './mcp-server';
+/**
+ * Command per la creazione di un server MCP
+ */
+export interface CreateMcpServerCommand {
+    /** Nome del server (obbligatorio) */
+    name: string;
+    /** Descrizione del server (opzionale) */
+    description?: string;
+    /** Tipo di server: 0 (Stdio) o 1 (SSE) */
+    serverType: McpServerType;
+    /** Comando di esecuzione (obbligatorio se serverType = Stdio) */
+    command?: string;
+    /** Argomenti del comando (opzionale, solo per Stdio) */
+    arguments?: string;
+    /** Endpoint HTTP (obbligatorio se serverType = SSE) */
+    endpoint?: string;
+    /** Tipo di autenticazione (opzionale) */
+    authType?: McpAuthType;
+    /** Token/credenziale di autenticazione (opzionale) */
+    authToken?: string;
+}

package/src/lib/ai/models/create-orchestration.d.ts

@@ -0,0 +1,9 @@
+import { OrchestrationType } from './orchestration';
+export interface CreateAgentOrchestrationCommand {
+    name: string;
+    description?: string;
+    type: OrchestrationType;
+    agentIds: string[];
+    maxIterations?: number;
+    configuration?: Record<string, any>;
+}

package/src/lib/ai/models/index.d.ts

@@ -0,0 +1,12 @@
+export * from './create-llm-settings';
+export * from './llm-settings';
+export * from './update-llm-settings';
+export * from './agent';
+export * from './create-agent';
+export * from './update-agent';
+export * from './orchestration';
+export * from './create-orchestration';
+export * from './update-orchestration';
+export * from './mcp-server';
+export * from './create-mcp-server';
+export * from './update-mcp-server';

package/src/lib/ai/models/llm-settings.d.ts

@@ -0,0 +1,25 @@
+export declare enum LLMProviderType {
+    OpenAI = 1,
+    AzureOpenAI = 2,
+    Anthropic = 3,
+    Ollama = 4,
+    Gemini = 5
+}
+export interface LLMSettingsDto {
+    id: string;
+    name: string;
+    providerType: LLMProviderType;
+    modelId: string;
+    hasApiKey: boolean;
+    endpoint?: string;
+    organizationId?: string;
+    deploymentName?: string;
+    apiVersion?: string;
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+    frequencyPenalty?: number;
+    presencePenalty?: number;
+    timeoutSeconds?: number;
+    isActive: boolean;
+}

package/src/lib/ai/models/mcp-server.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Enumerazione dei tipi di server MCP
+ */
+export declare enum McpServerType {
+    /** Processo comunicante via stdin/stdout */
+    Stdio = 0,
+    /** Server HTTP con Server-Sent Events */
+    SSE = 1
+}
+/**
+ * Enumerazione dei tipi di autenticazione MCP
+ */
+export declare enum McpAuthType {
+    /** Nessuna autenticazione */
+    None = 0,
+    /** API Key (header X-API-Key) */
+    ApiKey = 1,
+    /** Bearer Token OAuth/JWT */
+    BearerToken = 2,
+    /** Basic Authentication (username:password) */
+    BasicAuth = 3
+}
+/**
+ * DTO per la configurazione di un server MCP
+ */
+export interface McpServerConfigurationDto {
+    id: string;
+    name: string;
+    description: string | null;
+    serverType: McpServerType;
+    command: string | null;
+    arguments: string | null;
+    endpoint: string | null;
+    authType: McpAuthType | null;
+    /** Indica se esiste un token (il token NON viene mai esposto) */
+    hasAuthToken: boolean;
+    isActive: boolean;
+}

package/src/lib/ai/models/orchestration.d.ts

@@ -0,0 +1,27 @@
+export declare enum OrchestrationType {
+    Sequential = 0,
+    Concurrent = 1,
+    Handoff = 2,
+    GroupChat = 3,
+    Magentic = 4,
+    Coordinator = 5
+}
+export interface AgentOrchestrationDto {
+    id: string;
+    name: string;
+    description?: string;
+    type: OrchestrationType;
+    agentIds: string[];
+    maxIterations: number;
+    configuration?: Record<string, any>;
+    isActive: boolean;
+    agents?: Array<{
+        id: string;
+        name: string;
+        systemPrompt: string;
+        llmSettingsId: string;
+        isActive: boolean;
+    }>;
+}
+export declare const orchestrationTypeLabels: Record<OrchestrationType, string>;
+export declare const orchestrationTypeDescriptions: Record<OrchestrationType, string>;

package/src/lib/ai/models/update-agent.d.ts

@@ -0,0 +1,6 @@
+export interface UpdateAgentCommand {
+    name?: string;
+    description?: string;
+    systemPrompt?: string;
+    llmSettingsId?: string;
+}

package/src/lib/ai/models/update-llm-settings.d.ts

@@ -0,0 +1,10 @@
+export interface UpdateLLMSettingsCommand {
+    name?: string;
+    apiKey?: string;
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+    frequencyPenalty?: number;
+    presencePenalty?: number;
+    timeoutSeconds?: number;
+}

package/src/lib/ai/models/update-mcp-server.d.ts

@@ -0,0 +1,20 @@
+import { McpAuthType } from './mcp-server';
+/**
+ * Command per l'aggiornamento di un server MCP
+ */
+export interface UpdateMcpServerCommand {
+    /** Nome del server (opzionale) */
+    name?: string;
+    /** Descrizione del server (opzionale) */
+    description?: string;
+    /** Comando di esecuzione (opzionale, solo se serverType = Stdio) */
+    command?: string;
+    /** Argomenti del comando (opzionale, solo se serverType = Stdio) */
+    arguments?: string;
+    /** Endpoint HTTP (opzionale, solo se serverType = SSE) */
+    endpoint?: string;
+    /** Tipo di autenticazione (opzionale) */
+    authType?: McpAuthType;
+    /** Token/credenziale di autenticazione (opzionale, null per rimuovere) */
+    authToken?: string;
+}

package/src/lib/ai/models/update-orchestration.d.ts

@@ -0,0 +1,9 @@
+import { OrchestrationType } from './orchestration';
+export interface UpdateAgentOrchestrationCommand {
+    name?: string;
+    description?: string;
+    type?: OrchestrationType;
+    agentIds?: string[];
+    maxIterations?: number;
+    configuration?: Record<string, any>;
+}

package/src/lib/fluxo-client-interface.d.ts

@@ -11,6 +11,7 @@ import { PrintingService } from "./printing";
 import { WorkflowService } from "./workflow";
 import { BiFacade } from "./bi";
 import { SessionHubService } from "./session-hub";
+import { AiService } from "./ai";
 export interface FluxoClientInterface {
     get clientConfig(): FluxoClientConfiguration;
     get security(): SecurityFacade;
@@ -25,4 +26,5 @@ export interface FluxoClientInterface {
     get ravify(): RavifyFacade;
     get bi(): BiFacade;
     get sessionHub(): SessionHubService;
+    get ai(): AiService;
 }

package/src/lib/fluxo-client.d.ts

@@ -13,6 +13,7 @@ import { CommunicationFacade } from "./communication";
 import { RavifyFacade } from "./ravify/ravify.facade";
 import { BiFacade } from "./bi";
 import { SessionHubService } from "./session-hub";
+import { AiService } from './ai';
 export declare abstract class FluxoClientBase implements FluxoClientInterface {
     get modules(): any[];
     static get HttpClient(): HttpClient;
@@ -29,6 +30,7 @@ export declare abstract class FluxoClientBase implements FluxoClientInterface {
     private _config;
     private _ravify;
     private _biFacade;
+    private _ai;
     private _sessionHub;
     private _modules;
     register(module: any): void;
@@ -49,6 +51,7 @@ export declare abstract class FluxoClientBase implements FluxoClientInterface {
     get workflow(): WorkflowService;
     get ravify(): RavifyFacade;
     get bi(): BiFacade;
+    get ai(): AiService;
     get sessionHub(): SessionHubService;
     private getBearerToken;
 }