ibm-watsonx-orchestrate 1.12.2__py3-none-any.whl → 1.13.0b1__py3-none-any.whl

ibm_watsonx_orchestrate/cli/commands/copilot/copilot_controller.py

@@ -2,13 +2,18 @@ import logging
 import os
 import sys
 import csv
+import difflib
+import re
+from datetime import datetime
 
 import rich
 from rich.console import Console
 from rich.prompt import Prompt
 from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.panel import Panel
+from rich.table import Table
 from requests import ConnectionError
-from typing import List
+from typing import List, Dict
 from ibm_watsonx_orchestrate.client.base_api_client import ClientAPIException
 from ibm_watsonx_orchestrate.agent_builder.knowledge_bases.types import KnowledgeBaseSpec
 from ibm_watsonx_orchestrate.agent_builder.tools import ToolSpec, ToolPermission, ToolRequestBody, ToolResponseBody
@@ -16,6 +21,7 @@ from ibm_watsonx_orchestrate.cli.commands.agents.agents_controller import Agents
 from ibm_watsonx_orchestrate.agent_builder.agents.types import DEFAULT_LLM, BaseAgentSpec
 from ibm_watsonx_orchestrate.client.agents.agent_client import AgentClient
 from ibm_watsonx_orchestrate.client.knowledge_bases.knowledge_base_client import KnowledgeBaseClient
+from ibm_watsonx_orchestrate.client.threads.threads_client import ThreadsClient
 from ibm_watsonx_orchestrate.client.tools.tool_client import ToolClient
 from ibm_watsonx_orchestrate.client.copilot.cpe.copilot_cpe_client import CPEClient
 from ibm_watsonx_orchestrate.client.utils import instantiate_client
@@ -63,6 +69,7 @@ def _get_incomplete_agent_from_name(agent_name: str) -> dict:
     spec = BaseAgentSpec(**{"name": agent_name, "description": agent_name, "kind": AgentKind.NATIVE})
     return spec.model_dump()
 
+
 def _get_incomplete_knowledge_base_from_name(kb_name: str) -> dict:
     spec = KnowledgeBaseSpec(**{"name": kb_name, "description": kb_name})
     return spec.model_dump()
@@ -123,6 +130,7 @@ def _get_agents_from_names(collaborators_names: List[str]) -> List[dict]:
 
     return agents
 
+
 def _get_knowledge_bases_from_names(kb_names: List[str]) -> List[dict]:
     if not len(kb_names):
         return []
@@ -168,6 +176,10 @@ def get_native_client(*args, **kwargs):
     return instantiate_client(AgentClient)
 
 
+def get_threads_client():
+    return instantiate_client(ThreadsClient)
+
+
 def gather_utterances(max: int) -> list[str]:
     utterances = []
     logger.info("Please provide 3 sample utterances you expect your agent to handle:")
@@ -207,12 +219,12 @@ def get_deployed_tools_agents_and_knowledge_bases():
     return {"tools": all_tools, "collaborators": all_agents, "knowledge_bases": all_knowledge_bases}
 
 
-def pre_cpe_step(cpe_client):
+def pre_cpe_step(cpe_client, chat_llm):
     tools_agents_and_knowledge_bases = get_deployed_tools_agents_and_knowledge_bases()
     user_message = ""
     with _get_progress_spinner() as progress:
         task = progress.add_task(description="Initializing Prompt Engine", total=None)
-        response = cpe_client.submit_pre_cpe_chat(user_message=user_message)
+        response = cpe_client.submit_pre_cpe_chat(chat_llm=chat_llm, user_message=user_message)
         progress.remove_task(task)
 
     res = {}
@@ -221,7 +233,8 @@ def pre_cpe_step(cpe_client):
             rich.print('\n🤖 Copilot: ' + response["message"])
             user_message = Prompt.ask("\n👤 You").strip()
             message_content = {"user_message": user_message}
-        elif "description" in response and response["description"]:  # after we have a description, we pass the all tools
+        elif "description" in response and response[
+            "description"]:  # after we have a description, we pass the all tools
             res["description"] = response["description"]
             message_content = {"tools": tools_agents_and_knowledge_bases['tools']}
         elif "tools" in response and response[
@@ -234,17 +247,19 @@ def pre_cpe_step(cpe_client):
             res["collaborators"] = [a for a in tools_agents_and_knowledge_bases["collaborators"] if
                                     a["name"] in response["collaborators"]]
             message_content = {"knowledge_bases": tools_agents_and_knowledge_bases['knowledge_bases']}
-        elif "knowledge_bases" in response and response['knowledge_bases'] is not None:  # after we have knowledge bases, we pass selected=True to mark that all selection were done
+        elif "knowledge_bases" in response and response[
+            'knowledge_bases'] is not None:  # after we have knowledge bases, we pass selected=True to mark that all selection were done
             res["knowledge_bases"] = [a for a in tools_agents_and_knowledge_bases["knowledge_bases"] if
                                       a["name"] in response["knowledge_bases"]]
             message_content = {"selected": True}
-        elif "agent_name" in response and response['agent_name'] is not None:  # once we have a name and style, this phase has ended
+        elif "agent_name" in response and response[
+            'agent_name'] is not None:  # once we have a name and style, this phase has ended
             res["agent_name"] = response["agent_name"]
             res["agent_style"] = response["agent_style"]
             return res
         with _get_progress_spinner() as progress:
             task = progress.add_task(description="Thinking...", total=None)
-            response = cpe_client.submit_pre_cpe_chat(**message_content)
+            response = cpe_client.submit_pre_cpe_chat(chat_llm=chat_llm,**message_content)
             progress.remove_task(task)
 
 
@@ -300,7 +315,7 @@ def gather_examples(samples_file=None):
     return examples
 
 
-def talk_to_cpe(cpe_client, samples_file=None, context_data=None):
+def talk_to_cpe(cpe_client, chat_llm, samples_file=None, context_data=None):
     context_data = context_data or {}
     examples = gather_examples(samples_file)
     # upload or gather input examples
@@ -308,7 +323,7 @@ def talk_to_cpe(cpe_client, samples_file=None, context_data=None):
     response = None
     with _get_progress_spinner() as progress:
         task = progress.add_task(description="Thinking...", total=None)
-        response = cpe_client.init_with_context(context_data=context_data)
+        response = cpe_client.init_with_context(chat_llm=chat_llm, context_data=context_data)
         progress.remove_task(task)
     accepted_prompt = None
     while accepted_prompt is None:
@@ -320,13 +335,13 @@ def talk_to_cpe(cpe_client, samples_file=None, context_data=None):
             message = Prompt.ask("\n👤 You").strip()
             with _get_progress_spinner() as progress:
                 task = progress.add_task(description="Thinking...", total=None)
-                response = cpe_client.invoke(prompt=message)
+                response = cpe_client.invoke(chat_llm=chat_llm, prompt=message)
                 progress.remove_task(task)
 
     return accepted_prompt
 
 
-def prompt_tune(agent_spec: str, output_file: str | None, samples_file: str | None, dry_run_flag: bool) -> None:
+def prompt_tune(agent_spec: str, chat_llm: str | None, output_file: str | None, samples_file: str | None, dry_run_flag: bool) -> None:
     agent = AgentsController.import_agent(file=agent_spec, app_id=None)[0]
     agent_kind = agent.kind
 
@@ -339,6 +354,7 @@ def prompt_tune(agent_spec: str, output_file: str | None, samples_file: str | No
         output_file = agent_spec
 
     _validate_output_file(output_file, dry_run_flag)
+    _validate_chat_llm(chat_llm)
 
     client = get_cpe_client()
 
@@ -351,21 +367,22 @@ def prompt_tune(agent_spec: str, output_file: str | None, samples_file: str | No
     knowledge_bases = _get_knowledge_bases_from_names(agent.knowledge_base)
     try:
         new_prompt = talk_to_cpe(cpe_client=client,
-                                samples_file=samples_file,
-                                context_data={
-                                    "initial_instruction": instr,
-                                    'tools': tools,
-                                    'description': agent.description,
-                                    "collaborators": collaborators,
-                                    "knowledge_bases": knowledge_bases
-                                })
+                                 chat_llm=chat_llm,
+                                 samples_file=samples_file,
+                                 context_data={
+                                     "initial_instruction": instr,
+                                     'tools': tools,
+                                     'description': agent.description,
+                                     "collaborators": collaborators,
+                                     "knowledge_bases": knowledge_bases
+                                 })
     except ConnectionError:
         logger.error(
             "Failed to connect to Copilot server. Please ensure Copilot is running via `orchestrate copilot start`")
         sys.exit(1)
     except ClientAPIException:
         logger.error(
-            "An unexpected server error has occur with in the Copilot server. Please check the logs via `orchestrate server logs`")
+            "An unexpected server error has occurred with in the Copilot server. Please check the logs via `orchestrate server logs`")
         sys.exit(1)
 
     if new_prompt:
@@ -373,28 +390,34 @@ def prompt_tune(agent_spec: str, output_file: str | None, samples_file: str | No
         agent.instructions = new_prompt
 
         if dry_run_flag:
-            rich.print(agent.model_dump(exclude_none=True))
+            rich.print(agent.model_dump(exclude_none=True, mode="json"))
         else:
             if os.path.dirname(output_file):
                 os.makedirs(os.path.dirname(output_file), exist_ok=True)
             AgentsController.persist_record(agent, output_file=output_file)
 
+def _validate_chat_llm(chat_llm):
+    if chat_llm:
+        formatted_chat_llm = re.sub(r'[^a-zA-Z0-9/]', '-', chat_llm)
+        if "llama-3-3-70b-instruct" not in formatted_chat_llm:
+            raise BadRequest(f"Unsupported chat model for copilot {chat_llm}. Copilot supports only llama-3-3-70b-instruct at this point.")
 
-def create_agent(output_file: str, llm: str, samples_file: str | None, dry_run_flag: bool = False) -> None:
+def create_agent(output_file: str, llm: str, chat_llm: str | None, samples_file: str | None, dry_run_flag: bool = False) -> None:
     _validate_output_file(output_file, dry_run_flag)
+    _validate_chat_llm(chat_llm)
     # 1. prepare the clients
     cpe_client = get_cpe_client()
 
     # 2. Pre-CPE stage:
     try:
-        res = pre_cpe_step(cpe_client)
+        res = pre_cpe_step(cpe_client, chat_llm=chat_llm)
     except ConnectionError:
         logger.error(
             "Failed to connect to Copilot server. Please ensure Copilot is running via `orchestrate copilot start`")
         sys.exit(1)
     except ClientAPIException:
         logger.error(
-            "An unexpected server error has occur with in the Copilot server. Please check the logs via `orchestrate server logs`")
+            "An unexpected server error has occurred with in the Copilot server. Please check the logs via `orchestrate server logs`")
         sys.exit(1)
 
     tools = res["tools"]
@@ -405,7 +428,7 @@ def create_agent(output_file: str, llm: str, samples_file: str | None, dry_run_f
     agent_style = res["agent_style"]
 
     # 4. discuss the instructions
-    instructions = talk_to_cpe(cpe_client, samples_file,
+    instructions = talk_to_cpe(cpe_client, chat_llm, samples_file,
                                {'description': description, 'tools': tools, 'collaborators': collaborators,
                                 'knowledge_bases': knowledge_bases})
 
@@ -424,7 +447,7 @@ def create_agent(output_file: str, llm: str, samples_file: str | None, dry_run_f
     agent.spec_version = SpecVersion.V1
 
     if dry_run_flag:
-        rich.print(agent.model_dump(exclude_none=True))
+        rich.print(agent.model_dump(exclude_none=True, mode="json"))
         return
 
     if os.path.dirname(output_file):
@@ -446,3 +469,224 @@ def create_agent(output_file: str, llm: str, samples_file: str | None, dry_run_f
     for line in message_lines:
         rich.print("║  " + line.ljust(max_length) + "  ║")
     rich.print("╚" + "═" * frame_width + "╝")
+
+
+def _format_thread_messages(messages:List[dict]) -> List[dict]:
+    """
+        restructure and keep only the content relevant for refining the agent before sending to the refinement process
+    :param messages: List of messages as returned from the threads endpoint
+    :param messages:
+    :return: List of dictionaries where each dictionary represents a message
+    """
+    new_messages = []
+    for m in messages:
+        m_dict = {'role': m['role'], 'content': m['content'][0]['text'], 'type': 'text'} # text message
+        if m['step_history']:
+            step_history = m['step_history']
+            for step in step_history:
+                step_details = step['step_details'][0]
+                if step_details['type'] == 'tool_calls':  # tool call
+                    for t in step_details['tool_calls']:
+                        new_messages.append(
+                            {'role': m['role'], 'type': 'tool_call', 'args': t['args'], 'name': t['name']})
+                elif step_details['type'] == 'tool_response':  # tool response
+                    new_messages.append({'role': m['role'], 'type': 'tool_response', 'content': step_details['content']})
+        new_messages.append(m_dict)
+        if m['message_state']:
+            new_messages.append({'feedback': m['message_state']['content']['1']['feedback']})
+    return new_messages
+
+
+def _suggest_sorted(user_input: str, options: List[str]) -> List[str]:
+    # Sort by similarity score
+    return sorted(options, key=lambda x: difflib.SequenceMatcher(None, user_input, x).ratio(), reverse=True)
+
+
+def refine_agent_with_trajectories(agent_name: str, chat_llm: str | None, output_file: str | None,
+                                   use_last_chat: bool=False, dry_run_flag: bool = False) -> None:
+    """
+    Refines an existing agent's instructions using user selected chat trajectories and saves the updated agent configuration.
+
+    This function performs a multi-step process to enhance an agent's prompt instructions based on user interactions:
+
+    1. **Validation**: Ensures the output file path is valid and checks if the specified agent exists. If not found,
+       it suggests similar agent names.
+    2. **Chat Retrieval**: Fetches the 10 most recent chat threads associated with the agent. If no chats are found,
+       the user is prompted to initiate a conversation.
+    3. **User Selection**: Displays a summary of recent chats and allows the user to select which ones to use for refinement.
+    4. **Refinement**: Sends selected chat messages to the Copilot Prompt Engine (CPE) to generate refined instructions.
+    5. **Update and Save**: Updates the agent's instructions and either prints the
+       updated agent (if `dry_run_flag` is True) or saves it to the specified output file.
+
+    Parameters:
+        agent_name (str): The name of the agent to refine.
+        chat_llm (str): The name of the model used by the refiner. If None, default model (llama-3-3-70b) is used.
+        output_file (str): Path to the file where the refined agent configuration will be saved.
+        use_last_chat(bool): If true, optimize by using the last conversation with the agent, otherwise let the use choose
+        dry_run_flag (bool): If True, prints the refined agent configuration without saving it to disk.
+
+    Returns:
+        None
+    """
+
+    _validate_output_file(output_file, dry_run_flag)
+    _validate_chat_llm(chat_llm)
+    agents_controller = AgentsController()
+    agents_client = get_native_client()
+    threads_client = get_threads_client()
+    all_agents = agents_controller.get_all_agents(client=agents_client)
+
+    # Step 1 - validate agent exist. If not - list the agents sorted by their distance from the user input name
+    agent_id = all_agents.get(agent_name)
+    if agent_id is None:
+        if len(all_agents) == 0:
+            raise BadRequest("No agents in workspace\nCreate your first agent using `orchestrate copilot prompt-tune`")
+        else:
+            available_sorted_str = "\n".join(_suggest_sorted(agent_name, all_agents.keys()))
+            raise BadRequest(f'Agent "{agent_name}" does not exist.\n\n'
+                             f'Available agents:\n'
+                             f'{available_sorted_str}')
+
+    cpe_client = get_cpe_client()
+    # Step 2 - retrieve chats (threads)
+    try:
+        with _get_progress_spinner() as progress:
+            task = progress.add_task(description="Retrieve chats", total=None)
+            all_threads = threads_client.get_all_threads(agent_id)
+            if len(all_threads) == 0:
+                progress.remove_task(task)
+                progress.refresh()
+                raise BadRequest(
+                    f"No chats found for agent '{agent_name}'. To use autotune, please initiate at least one conversation with the agent. You can start a chat using `orchestrate chat start`.",
+                   )
+            last_10_threads = all_threads[:10] #TODO use batching when server allows
+            last_10_chats = [_format_thread_messages(chat) for chat in
+                             threads_client.get_threads_messages([thread['id'] for thread in last_10_threads])]
+
+            progress.remove_task(task)
+            progress.refresh()
+    except ConnectionError:
+        logger.error(
+            f"Failed to retrieve threads (chats) for agent {agent_name}")
+        sys.exit(1)
+    except ClientAPIException:
+        logger.error(
+            f"An unexpected server error has occurred while retrieving threads for agent {agent_name}. Please check the logs via `orchestrate server logs`")
+        sys.exit(1)
+
+    # Step 3 - show chats and let the user choose
+    if use_last_chat:
+        title = "Selected chat"
+    else:
+        title = "10 Most Recent Chats"
+    table = Table(title=title)
+    table.add_column("Number", justify="right")
+    table.add_column("Chat Date", justify="left")
+    table.add_column("Title", justify="left")
+    table.add_column("Last User Message", justify="left")
+    table.add_column("Last User Feedback", justify="left")
+
+    for i, (thread, chat) in enumerate(zip(last_10_threads, last_10_chats), start=1):
+        all_user_messages = [msg for msg in chat if 'role' in msg and msg['role'] == 'user']
+
+        if len(all_user_messages) == 0:
+            last_user_message = ""
+        else:
+            last_user_message = all_user_messages[-1]['content']
+        all_feedbacks = [msg for msg in chat if 'feedback' in msg and 'text' in msg['feedback']]
+        if len(all_feedbacks) == 0:
+            last_feedback = ""
+        else:
+            last_feedback = f"{'👍' if all_feedbacks[-1]['feedback']['is_positive'] else '👎'} {all_feedbacks[-1]['feedback']['text']}"
+
+        table.add_row(str(i), datetime.strptime(thread['created_on'], '%Y-%m-%dT%H:%M:%S.%fZ').strftime(
+            '%B %d, %Y at %I:%M %p'), thread['title'], last_user_message, last_feedback)
+        table.add_row("", "", "")
+        if  use_last_chat:
+            break
+
+    rich.print(table)
+
+    if use_last_chat:
+        rich.print("Tuning using the last conversation with the agent")
+        threads_messages = [last_10_chats[0]]
+    else:
+        threads_messages = get_user_selection(last_10_chats)
+
+    # Step 4 - run the refiner
+    try:
+        with _get_progress_spinner() as progress:
+            agent = agents_controller.get_agent_by_id(id=agent_id)
+            task = progress.add_task(description="Running Prompt Refiner", total=None)
+            tools_client = get_tool_client()
+            knowledge_base_client = get_knowledge_bases_client()
+            # loaded agent contains the ids of the tools/collabs/knowledge bases, convert them back to names.
+            agent.tools = [tools_client.get_draft_by_id(id)['name'] for id in agent.tools]
+            agent.knowledge_base = [knowledge_base_client.get_by_id(id)['name'] for id in agent.knowledge_base]
+            agent.collaborators = [agents_client.get_draft_by_id(id)['name'] for id in agent.collaborators]
+            tools = _get_tools_from_names(agent.tools)
+            collaborators = _get_agents_from_names(agent.collaborators)
+            knowledge_bases = _get_knowledge_bases_from_names(agent.knowledge_base)
+            if agent.instructions is None:
+                raise BadRequest("Agent must have instructions in order to use the autotune command. To build an instruction use `orchestrate copilot prompt-tune -f <path_to_agent_yaml> -o <path_to_new_agent_yaml>`")
+            response = cpe_client.refine_agent_with_chats(instruction=agent.instructions, chat_llm=chat_llm, tools=tools,
+                                                          collaborators=collaborators, knowledge_bases=knowledge_bases,
+                                                          trajectories_with_feedback=threads_messages)
+            progress.remove_task(task)
+            progress.refresh()
+    except ConnectionError:
+        logger.error(
+            "Failed to connect to Copilot server. Please ensure Copilot is running via `orchestrate copilot start`")
+        sys.exit(1)
+    except ClientAPIException:
+        logger.error(
+            "An unexpected server error has occurred with in the Copilot server. Please check the logs via `orchestrate server logs`")
+        sys.exit(1)
+
+    # Step 5 - update the agent and print/save the results
+    agent.instructions = response['instruction']
+
+    if dry_run_flag:
+        rich.print(agent.model_dump(exclude_none=True, mode="json"))
+        return
+
+    if os.path.dirname(output_file):
+        os.makedirs(os.path.dirname(output_file), exist_ok=True)
+    agent.id = None # remove existing agent id before saving
+    AgentsController.persist_record(agent, output_file=output_file)
+
+    logger.info(f"Your agent refinement session finished successfully!")
+    logger.info(f"Agent YAML with the updated instruction saved in file: {os.path.abspath(output_file)}")
+
+
+
+def get_user_selection(chats: List[List[Dict]]) -> List[List[Dict]]:
+    """
+    Prompts the user to select up to 5 chat threads by entering their indices.
+
+    Parameters:
+        chats (List[List[Dict]]): A list of chat threads, where each thread is a list of message dictionaries.
+
+    Returns:
+        List[List[Dict]]: A list of selected chat threads based on user input.
+    """
+    while True:
+        try:
+            eg_str = "1" if len(chats) < 2 else "1, 2"
+            input_str = input(
+                f"Please enter up to 5 indices of chats you'd like to select, separated by commas (e.g. {eg_str}): "
+            )
+
+            choices = [int(choice.strip()) for choice in input_str.split(',')]
+
+            if len(choices) > 5:
+                rich.print("You can select up to 5 chats only. Please try again.")
+                continue
+
+            if all(1 <= choice <= len(chats) for choice in choices):
+                selected_threads = [chats[choice - 1] for choice in choices]
+                return selected_threads
+            else:
+                rich.print(f"Please enter only numbers between 1 and {len(chats)}.")
+        except ValueError:
+            rich.print("Invalid input. Please enter valid integers separated by commas.")

ibm_watsonx_orchestrate/cli/commands/copilot/copilot_server_controller.py

@@ -1,9 +1,9 @@
 import logging
 import sys
-from pathlib import Path
 import time
+from pathlib import Path
+
 import requests
-from urllib.parse import urlparse
 
 from ibm_watsonx_orchestrate.cli.config import Config
 from ibm_watsonx_orchestrate.utils.docker_utils import DockerLoginService, DockerComposeCore, DockerUtils
@@ -45,7 +45,7 @@ def run_compose_lite_cpe(user_env_file: Path) -> bool:
 
     final_env_file = env_service.write_merged_env_file(merged_env_dict)
 
-    compose_core = DockerComposeCore(env_service)
+    compose_core = DockerComposeCore(env_service=env_service)
 
     result = compose_core.service_up(service_name="cpe", friendly_name="Copilot", final_env_file=final_env_file)
 
@@ -75,7 +75,7 @@ def run_compose_lite_cpe_down(is_reset: bool = False) -> None:
 
     cli_config = Config()
     env_service = EnvService(cli_config)
-    compose_core = DockerComposeCore(env_service)
+    compose_core = DockerComposeCore(env_service=env_service)
 
     result = compose_core.service_down(service_name="cpe", friendly_name="Copilot", final_env_file=final_env_file, is_reset=is_reset)
 

ibm_watsonx_orchestrate/cli/commands/evaluations/evaluations_command.py

@@ -17,10 +17,13 @@ from typing_extensions import Annotated
 
 from ibm_watsonx_orchestrate import __version__
 from ibm_watsonx_orchestrate.cli.commands.evaluations.evaluations_controller import EvaluationsController, EvaluateMode
+from ibm_watsonx_orchestrate.cli.commands.evaluations.evaluations_environment_manager import run_environment_manager
 from ibm_watsonx_orchestrate.cli.commands.agents.agents_controller import AgentsController
 
 logger = logging.getLogger(__name__)
 
+HIDE_ENVIRONMENT_MGR_PANEL = os.environ.get("HIDE_ENVIRONMENT_MGR_PANEL", "true").lower() == "true"
+
 evaluation_app = typer.Typer(no_args_is_help=True)
 
 def _native_agent_template():
@@ -142,14 +145,38 @@ def evaluate(
             "--env-file", "-e", 
             help="Path to a .env file that overrides default.env. Then environment variables override both."
         ),
-    ] = None
+    ] = None,
+    env_manager_path: Annotated[
+        Optional[str],
+        typer.Option(
+            "--env-manager-path",
+            help="""
+                Path to YAML configuration file containing environment settings.\n
+                See `./examples/evaluations/environment_manager` on how to create the environment manager file.
+                Note: When using this feature, you must pass the `output_dir`.
+            """,
+            rich_help_panel="Environment Manager",
+            hidden=HIDE_ENVIRONMENT_MGR_PANEL
+        )
+    ] = None,
 ):
+    validate_watsonx_credentials(user_env_file)
+
+    if env_manager_path:
+        if output_dir:
+            return run_environment_manager(
+                environment_manager_path=env_manager_path,
+                output_dir=output_dir,
+            )
+        else:
+            logger.error("Error: `--env_manager_path`, `--output_dir` must be provided to use the environment manager feature.")
+            sys.exit(1)
+
     if not config_file:
         if not test_paths or not output_dir:
             logger.error("Error: Both --test-paths and --output-dir must be provided when not using a config file")
             exit(1)
-    
-    validate_watsonx_credentials(user_env_file)
+
     controller = EvaluationsController()
     controller.evaluate(config_file=config_file, test_paths=test_paths, output_dir=output_dir)