ibm-watsonx-orchestrate 1.8.0b0__py3-none-any.whl → 1.8.0b1__py3-none-any.whl

ibm_watsonx_orchestrate/__init__.py

@@ -5,7 +5,7 @@
 
 pkg_name = "ibm-watsonx-orchestrate"
 
-__version__ = "1.8.0b0"
+__version__ = "1.8.0b1"
 
 
 

ibm_watsonx_orchestrate/agent_builder/agents/types.py

@@ -29,6 +29,12 @@ yaml.representer.SafeRepresenter.add_representer(str, str_presenter) # to use wi
 class SpecVersion(str, Enum):
     V1 = "v1"
 
+    def __str__(self):
+        return self.value 
+
+    def __repr__(self):
+        return repr(self.value)
+
 
 class AgentKind(str, Enum):
     NATIVE = "native"
@@ -104,6 +110,12 @@ class AgentStyle(str, Enum):
     REACT = "react"
     PLANNER = "planner"
 
+    def __str__(self):
+        return self.value 
+
+    def __repr__(self):
+        return repr(self.value)
+
 class AgentGuideline(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
 

ibm_watsonx_orchestrate/agent_builder/connections/types.py

@@ -75,6 +75,16 @@ class ConnectionType(str, Enum):
 
     def __repr__(self):
         return repr(self.value)
+    
+class ConnectionSendVia(str,Enum):
+    HEADER = 'header'
+    BODY = 'body'
+
+    def __str__(self):
+        return self.value
+    
+    def __repr__(self):
+        return repr(self.value)
 
 OAUTH_CONNECTION_TYPES = {
     ConnectionType.OAUTH2_AUTH_CODE,
@@ -177,7 +187,7 @@ class OAuth2AuthCodeCredentials(BaseModel):
     client_secret: str
     token_url: str
     authorization_url: str
-    scopes : Optional[List[str]] = None
+    scope : Optional[str] = None
 
 # class OAuth2ImplicitCredentials(BaseModel):
 #     client_id: str
@@ -193,7 +203,9 @@ class OAuth2ClientCredentials(BaseModel):
     client_id: str
     client_secret: str
     token_url: str
-    scopes : Optional[List[str]] = None
+    scope : Optional[str] = None
+    send_via: ConnectionSendVia = ConnectionSendVia.HEADER
+    grant_type: str = "client_credentials"
 
 class OAuthOnBehalfOfCredentials(BaseModel):
     client_id: str

ibm_watsonx_orchestrate/cli/commands/channels/types.py

@@ -1,6 +1,6 @@
 from enum import Enum
 
-class  EnvironmentType(str, Enum):
+class EnvironmentType(str, Enum):
     DRAFT ='draft'
     LIVE = 'live'
 
@@ -8,8 +8,21 @@ class  EnvironmentType(str, Enum):
         return self.value
     
 
-class  ChannelType(str, Enum):
+class ChannelType(str, Enum):
     WEBCHAT ='webchat'
 
     def __str__(self):
+        return self.value
+    
+    
+class RuntimeEnvironmentType(str, Enum):
+    LOCAL = 'local'
+    CPD = 'cpd'
+    IBM_CLOUD = 'ibmcloud'
+    AWS = 'aws'
+
+    def __str__(self):
+        return self.value
+
+    def __repr__(self):
         return self.value

ibm_watsonx_orchestrate/cli/commands/channels/webchat/channels_webchat_controller.py

@@ -4,6 +4,7 @@ import jwt
 import sys
 
 from ibm_watsonx_orchestrate.cli.config import Config, ENV_WXO_URL_OPT, ENVIRONMENTS_SECTION_HEADER, CONTEXT_SECTION_HEADER, CONTEXT_ACTIVE_ENV_OPT, CHAT_UI_PORT
+from ibm_watsonx_orchestrate.cli.commands.channels.types import RuntimeEnvironmentType
 from ibm_watsonx_orchestrate.client.utils import is_local_dev, is_ibm_cloud_platform, get_environment, get_cpd_instance_id_from_url, is_saas_env, AUTH_CONFIG_FILE_FOLDER, AUTH_SECTION_HEADER, AUTH_MCSP_TOKEN_OPT, AUTH_CONFIG_FILE
 
 from ibm_watsonx_orchestrate.client.agents.agent_client import AgentClient
@@ -158,13 +159,13 @@ class ChannelsWebchatController:
         environment = get_environment()
 
         match (environment):
-            case "local":
+            case RuntimeEnvironmentType.LOCAL:
                 tenant_id = self.get_tenant_id_local()
 
-            case "cpd":
+            case RuntimeEnvironmentType.CPD:
                 tenant_id = get_cpd_instance_id_from_url()
 
-            case "ibmcloud":
+            case RuntimeEnvironmentType.IBM_CLOUD:
                 crn = input("Please enter your CRN which can be retrieved from the IBM Cloud UI: ")
                 if crn == "":
                     logger.error("You must enter your CRN for IBM Cloud instances")
@@ -175,7 +176,7 @@ class ChannelsWebchatController:
                     sys.exit(1)
                 tenant_id = self.extract_tenant_id_from_crn(crn)
 
-            case "ga":
+            case RuntimeEnvironmentType.AWS:
                 tenant_id = self.get_tenant_id()
 
             case _:

ibm_watsonx_orchestrate/cli/commands/connections/connections_command.py

@@ -201,6 +201,13 @@ def set_credentials_connection_command(
             help='For oauth_auth_client_credentials_flow, the client_secret to authenticate with'
         )
     ] = None,
+    send_via: Annotated[
+        str,
+        typer.Option(
+            '--send-via',
+            help='For oauth_auth_client_credentials_flow, how the token will be sent to the server. Defaults to using `header`'
+        )
+    ] = None,
     token_url: Annotated[
         str,
         typer.Option(
@@ -220,14 +227,14 @@ def set_credentials_connection_command(
         str,
         typer.Option(
             '--grant-type',
-            help='For oauth_auth_on_behalf_of_flow, the grant type used by the application token server'
+            help='For oauth_auth_on_behalf_of_flow and oauth_auth_client_credentials_flow, the grant type used by the application token server'
         )
     ] = None,
-    scopes: Annotated[
-        List[str],
+    scope: Annotated[
+        str,
         typer.Option(
-            '--scopes',
-            help='For oauth_auth_code_flow and oauth_auth_client_credentials_flow, the optional scopes used by the application token server'
+            '--scope',
+            help='For oauth_auth_code_flow and oauth_auth_client_credentials_flow, the optional scopes used by the application token server. Should be in the form of a space seperated string.'
         )
     ] = None,
     entries: Annotated[
@@ -247,10 +254,11 @@ def set_credentials_connection_command(
         api_key=api_key,
         client_id=client_id,
         client_secret=client_secret,
+        send_via=send_via,
         token_url=token_url,
         auth_url=auth_url,
         grant_type=grant_type,
-        scopes=scopes,
+        scope=scope,
         entries=entries
     )
 

ibm_watsonx_orchestrate/cli/commands/connections/connections_controller.py

@@ -160,13 +160,13 @@ def _validate_connection_params(type: ConnectionType, **args) -> None:
             f"Missing flags --token-url is required for type {type}"
         )
 
-
     if type == ConnectionType.OAUTH_ON_BEHALF_OF_FLOW and (
             args.get('grant_type') is None
     ):
         raise typer.BadParameter(
             f"Missing flags --grant-type is required for type {type}"
         )
+    
 
 def _parse_entry(entry: str) -> dict[str,str]:
     split_entry = entry.split('=')
@@ -197,15 +197,13 @@ def _get_credentials(type: ConnectionType, **kwargs):
                 client_id=kwargs.get("client_id"),
                 client_secret=kwargs.get("client_secret"),
                 token_url=kwargs.get("token_url"),
-                scopes=kwargs.get("scopes")
+                scope=kwargs.get("scope")
             )
         case ConnectionType.OAUTH2_CLIENT_CREDS:
-            return OAuth2ClientCredentials(
-                client_id=kwargs.get("client_id"),
-                client_secret=kwargs.get("client_secret"),
-                token_url=kwargs.get("token_url"),
-                scopes=kwargs.get("scopes")
-            )
+            # using filtered args as default values will not be set if 'None' is passed, causing validation errors
+            keys = ["client_id","client_secret","token_url","grant_type","send_via", "scope"]
+            filtered_args = { key_name: kwargs[key_name] for key_name in keys if kwargs.get(key_name) }
+            return OAuth2ClientCredentials(**filtered_args)
         # case ConnectionType.OAUTH2_IMPLICIT:
         #     return OAuth2ImplicitCredentials(
         #         authorization_url=kwargs.get("auth_url"),

ibm_watsonx_orchestrate/cli/commands/copilot/copilot_controller.py

@@ -11,8 +11,9 @@ from requests import ConnectionError
 from typing import List
 from ibm_watsonx_orchestrate.client.base_api_client import ClientAPIException
 from ibm_watsonx_orchestrate.agent_builder.tools import ToolSpec, ToolPermission, ToolRequestBody, ToolResponseBody
-from ibm_watsonx_orchestrate.cli.commands.agents.agents_controller import AgentsController, AgentKind
-from ibm_watsonx_orchestrate.agent_builder.agents.types import DEFAULT_LLM
+from ibm_watsonx_orchestrate.cli.commands.agents.agents_controller import AgentsController, AgentKind, SpecVersion
+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.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
@@ -20,21 +21,24 @@ from ibm_watsonx_orchestrate.utils.exceptions import BadRequest
 
 logger = logging.getLogger(__name__)
 
+
 def _validate_output_file(output_file: str, dry_run_flag: bool) -> None:
     if not output_file and not dry_run_flag:
-        logger.error("Please provide a valid yaml output file. Or use the `--dry-run` flag to output generated agent content to terminal")
+        logger.error(
+            "Please provide a valid yaml output file. Or use the `--dry-run` flag to output generated agent content to terminal")
         sys.exit(1)
-    
+
     if output_file and dry_run_flag:
         logger.error("Cannot set output file when performing a dry run")
         sys.exit(1)
-    
+
     if output_file:
         _, file_extension = os.path.splitext(output_file)
-        if file_extension not in  {".yaml", ".yml", ".json"}:
+        if file_extension not in {".yaml", ".yml", ".json"}:
             logger.error("Output file must be of type '.yaml', '.yml' or '.json'")
             sys.exit(1)
 
+
 def _get_progress_spinner() -> Progress:
     console = Console()
     return Progress(
@@ -44,16 +48,22 @@ def _get_progress_spinner() -> Progress:
         console=console,
     )
 
+
 def _get_incomplete_tool_from_name(tool_name: str) -> dict:
     input_schema = ToolRequestBody(**{"type": "object", "properties": {}})
     output_schema = ToolResponseBody(**{"description": "None"})
-    spec = ToolSpec(**{"name": tool_name, "description": tool_name, "permission": ToolPermission.ADMIN, "input_schema": input_schema, "output_schema": output_schema})
+    spec = ToolSpec(**{"name": tool_name, "description": tool_name, "permission": ToolPermission.ADMIN,
+                       "input_schema": input_schema, "output_schema": output_schema})
+    return spec.model_dump()
+
+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_tools_from_names(tool_names: List[str]) -> List[dict]:
     if not len(tool_names):
         return []
-    
+
     tool_client = get_tool_client()
 
     try:
@@ -61,25 +71,63 @@ def _get_tools_from_names(tool_names: List[str]) -> List[dict]:
             task = progress.add_task(description="Fetching tools", total=None)
             tools = tool_client.get_drafts_by_names(tool_names)
             found_tools = {tool.get("name") for tool in tools}
-            rich.print("\n")
+            progress.remove_task(task)
+            progress.refresh()
             for tool_name in tool_names:
                 if tool_name not in found_tools:
-                    logger.warning(f"Failed to find tool named '{tool_name}'. Falling back to incomplete tool definition. Copilot performance maybe effected.")
+                    logger.warning(
+                        f"Failed to find tool named '{tool_name}'. Falling back to incomplete tool definition. Copilot performance maybe effected.")
                     tools.append(_get_incomplete_tool_from_name(tool_name))
-            progress.remove_task(task)
     except ConnectionError:
-        logger.warning(f"Failed to fetch tools from server. For optimal results please start the server and import the relevant tools {', '.join(tool_names)}.")
+        logger.warning(
+            f"Failed to fetch tools from server. For optimal results please start the server and import the relevant tools {', '.join(tool_names)}.")
         tools = []
         for tool_name in tool_names:
             tools.append(_get_incomplete_tool_from_name(tool_name))
 
     return tools
 
+
+def _get_agents_from_names(collaborators_names: List[str]) -> List[dict]:
+    if not len(collaborators_names):
+        return []
+
+    native_agents_client = get_native_client()
+
+    try:
+        with _get_progress_spinner() as progress:
+            task = progress.add_task(description="Fetching agents", total=None)
+            agents = native_agents_client.get_drafts_by_names(collaborators_names)
+            found_agents = {tool.get("name") for tool in agents}
+            progress.remove_task(task)
+            progress.refresh()
+            for collaborator_name in collaborators_names:
+                if collaborator_name not in found_agents:
+                    logger.warning(
+                        f"Failed to find agent named '{collaborator_name}'. Falling back to incomplete agent definition. Copilot performance maybe effected.")
+                    agents.append(_get_incomplete_agent_from_name(collaborator_name))
+    except ConnectionError:
+        logger.warning(
+            f"Failed to fetch tools from server. For optimal results please start the server and import the relevant tools {', '.join(collaborators_names)}.")
+        agents = []
+        for collaborator_name in collaborators_names:
+            agents.append(_get_incomplete_agent_from_name(collaborator_name))
+
+    return agents
+
 def get_cpe_client() -> CPEClient:
     url = os.getenv('CPE_URL', "http://localhost:8081")
     return instantiate_client(client=CPEClient, url=url)
 
 
+def get_tool_client(*args, **kwargs):
+    return instantiate_client(ToolClient)
+
+
+def get_native_client(*args, **kwargs):
+    return instantiate_client(AgentClient)
+
+
 def gather_utterances(max: int) -> list[str]:
     utterances = []
     logger.info("Please provide 3 sample utterances you expect your agent to handle:")
@@ -98,7 +146,16 @@ def gather_utterances(max: int) -> list[str]:
 
     return utterances
 
-def pre_cpe_step(cpe_client, tool_client):
+
+def get_deployed_tools_agents():
+    all_tools = find_tools_by_description(tool_client=get_tool_client(), description=None)
+    # TODO: this brings only the "native" agents. Can external and assistant agents also be collaborators?
+    all_agents = find_agents(agent_client=get_native_client())
+    return {"tools": all_tools, "agents": all_agents}
+
+
+def pre_cpe_step(cpe_client):
+    tools_agents = get_deployed_tools_agents()
     user_message = ""
     with _get_progress_spinner() as progress:
         task = progress.add_task(description="Initilizing Prompt Engine", total=None)
@@ -113,31 +170,47 @@ def pre_cpe_step(cpe_client, tool_client):
             message_content = {"user_message": user_message}
         elif "description" in response and response["description"]:
             res["description"] = response["description"]
-            tools = find_tools_by_description(res["description"], tool_client)
-            message_content = {"tools": tools}
+            message_content = tools_agents
         elif "metadata" in response:
             res["agent_name"] = response["metadata"]["agent_name"]
             res["agent_style"] = response["metadata"]["style"]
-            res["tools"] = [t for t in tools if t["name"] in response["metadata"]["tools"]]
+            res["tools"] = [t for t in tools_agents["tools"] if t["name"] in response["metadata"]["tools"]]
+            res["collaborators"] = [a for a in tools_agents["agents"] if
+                                    a["name"] in response["metadata"]["collaborators"]]
             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)
             progress.remove_task(task)
 
-# TODO: Add description RAG search
+
 def find_tools_by_description(description, tool_client):
     with _get_progress_spinner() as progress:
         task = progress.add_task(description="Fetching Tools", total=None)
         try:
             tools = tool_client.get()
+            progress.remove_task(task)
         except ConnectionError:
             tools = []
-            rich.print("\n")
+            progress.remove_task(task)
+            progress.refresh()
             logger.warning("Failed to contact wxo server to fetch tools. Proceeding with empty tool list")
-        progress.remove_task(task)
     return tools
 
+def find_agents(agent_client):
+    with _get_progress_spinner() as progress:
+        task = progress.add_task(description="Fetching Agents", total=None)
+        try:
+            agents = agent_client.get()
+            progress.remove_task(task)
+        except ConnectionError:
+            agents = []
+            progress.remove_task(task)
+            progress.refresh()
+            logger.warning("Failed to contact wxo server to fetch agents. Proceeding with empty agent list")
+    return agents
+
+
 def gather_examples(samples_file=None):
     if samples_file:
         if samples_file.endswith('.txt'):
@@ -167,7 +240,7 @@ def talk_to_cpe(cpe_client, samples_file=None, context_data=None):
     examples = gather_examples(samples_file)
     # upload or gather input examples
     context_data['examples'] = examples
-    response=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)
@@ -199,20 +272,23 @@ def prompt_tune(agent_spec: str, output_file: str | None, samples_file: str | No
 
     if not output_file and not dry_run_flag:
         output_file = agent_spec
-    
+
     _validate_output_file(output_file, dry_run_flag)
 
     client = get_cpe_client()
 
     instr = agent.instructions
-    prompt = 'My current prompt is:\n' + instr if instr else "I don't have an initial prompt."
 
     tools = _get_tools_from_names(agent.tools)
 
+    collaborators = _get_agents_from_names(agent.collaborators)
     try:
-        new_prompt = talk_to_cpe(cpe_client=client, samples_file=samples_file, context_data={"prompt": prompt, 'tools': tools, 'description': agent.description})
+        new_prompt = talk_to_cpe(cpe_client=client, samples_file=samples_file,
+                                 context_data={"initial_instruction": instr, 'tools': tools, 'description': agent.description,
+                                               "collaborators": collaborators})
     except ConnectionError:
-        logger.error("Failed to connect to Copilot server. Please ensure Copilot is running via `orchestrate copilot start`")
+        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`")
@@ -223,59 +299,58 @@ 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())
+            rich.print(agent.model_dump(exclude_none=True))
         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 get_tool_client(*args, **kwargs):
-    return instantiate_client(ToolClient)
-
 def create_agent(output_file: str, llm: str, samples_file: str | None, dry_run_flag: bool = False) -> None:
     _validate_output_file(output_file, dry_run_flag)
     # 1. prepare the clients
     cpe_client = get_cpe_client()
-    tool_client = get_tool_client()
 
     # 2. Pre-CPE stage:
     try:
-        res = pre_cpe_step(cpe_client, tool_client)
+        res = pre_cpe_step(cpe_client)
     except ConnectionError:
-        logger.error("Failed to connect to Copilot server. Please ensure Copilot is running via `orchestrate copilot start`")
+        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`")
         sys.exit(1)
         
     tools = res["tools"]
+    collaborators = res["collaborators"]
     description = res["description"]
     agent_name = res["agent_name"]
     agent_style = res["agent_style"]
 
     # 4. discuss the instructions
-    instructions = talk_to_cpe(cpe_client, samples_file, {'tools': tools, 'description': description})
+    instructions = talk_to_cpe(cpe_client, samples_file, {'description': description, 'tools': tools, 'collaborators': collaborators})
 
     # 6. create and save the agent
     llm = llm if llm else DEFAULT_LLM
     params = {
         'style': agent_style,
         'tools': [t['name'] for t in tools],
-        'llm': llm
+        'llm': llm,
+        'collaborators': [c['name'] for c in collaborators]
     }
     agent = AgentsController.generate_agent_spec(agent_name, AgentKind.NATIVE, description, **params)
     agent.instructions = instructions
+    agent.spec_version = SpecVersion.V1
 
     if dry_run_flag:
-        rich.print(agent.model_dump())
+        rich.print(agent.model_dump(exclude_none=True))
         return
 
     if os.path.dirname(output_file):
         os.makedirs(os.path.dirname(output_file), exist_ok=True)
     AgentsController.persist_record(agent, output_file=output_file)
 
-
     message_lines = [
         "Your agent building session finished successfully!",
         f"Agent YAML saved in file:",
@@ -290,4 +365,4 @@ def create_agent(output_file: str, llm: str, samples_file: str | None, dry_run_f
     rich.print("╔" + "═" * frame_width + "╗")
     for line in message_lines:
         rich.print("║  " + line.ljust(max_length) + "  ║")
-    rich.print("╚" + "═" * frame_width + "╝")
+    rich.print("╚" + "═" * frame_width + "╝")

ibm_watsonx_orchestrate/cli/commands/copilot/copilot_server_controller.py

@@ -4,6 +4,7 @@ from pathlib import Path
 import subprocess
 import time
 import requests
+from urllib.parse import urlparse
 from ibm_watsonx_orchestrate.cli.commands.server.server_command import (
     get_compose_file,
     ensure_docker_compose_installed,
@@ -16,15 +17,11 @@ from ibm_watsonx_orchestrate.cli.commands.server.server_command import (
     get_default_registry_env_vars_by_dev_edition_source,
     docker_login_by_dev_edition_source,
     write_merged_env_file,
+    apply_server_env_dict_defaults
 )
 
 logger = logging.getLogger(__name__)
 
-def _verify_env_contents(env: dict) -> None:
-    if not env.get("WATSONX_APIKEY") or not env.get("WATSONX_SPACE_ID"):
-        logger.error("The Copilot feature requires wx.ai credentials to passed through the provided env file. Please set 'WATSONX_SPACE_ID' and 'WATSONX_APIKEY'")
-        sys.exit(1)
-
 def wait_for_wxo_cpe_health_check(timeout_seconds=45, interval_seconds=2):
     url = "http://localhost:8081/version"
     logger.info("Waiting for Copilot component to be initialized...")
@@ -42,6 +39,24 @@ def wait_for_wxo_cpe_health_check(timeout_seconds=45, interval_seconds=2):
         time.sleep(interval_seconds)
     return False
 
+def _trim_authorization_urls(env_dict: dict) -> dict:
+    auth_url_key = "AUTHORIZATION_URL"
+    env_dict_copy = env_dict.copy()
+
+    auth_url = env_dict_copy.get(auth_url_key)
+    if not auth_url:
+        return env_dict_copy
+    
+    
+    parsed_url = urlparse(auth_url)
+    new_url = f"{parsed_url.scheme}://{parsed_url.netloc}"
+    env_dict_copy[auth_url_key] = new_url
+
+    return env_dict_copy
+
+    
+
+
 def run_compose_lite_cpe(user_env_file: Path) -> bool:
     compose_path = get_compose_file()
     compose_command = ensure_docker_compose_installed()
@@ -66,8 +81,9 @@ def run_compose_lite_cpe(user_env_file: Path) -> bool:
         **default_env,
         **user_env,
     }
-
-    _verify_env_contents(merged_env_dict)
+    
+    merged_env_dict = apply_server_env_dict_defaults(merged_env_dict)
+    merged_env_dict = _trim_authorization_urls(merged_env_dict)
 
     try:
         docker_login_by_dev_edition_source(merged_env_dict, dev_edition_source)

ibm_watsonx_orchestrate/cli/commands/environment/types.py

@@ -9,4 +9,4 @@ class EnvironmentAuthType(str, Enum):
     CPD = 'cpd'
 
     def __str__(self):
-        return self.value
+        return self.value

ibm_watsonx_orchestrate/cli/commands/evaluations/evaluations_command.py

@@ -25,14 +25,20 @@ def read_env_file(env_path: Path|str) -> dict:
     return dotenv_values(str(env_path))
 
 def validate_watsonx_credentials(user_env_file: str) -> bool:
-    required_keys = ["WATSONX_SPACE_ID", "WATSONX_APIKEY"]
+    required_sets = [
+        ["WATSONX_SPACE_ID", "WATSONX_APIKEY"],
+        ["WO_INSTANCE", "WO_API_KEY"]
+    ]
     
-    if all(key in os.environ for key in required_keys):
+    def has_valid_keys(env: dict) -> bool:
+        return any(all(key in env for key in key_set) for key_set in required_sets)
+
+    if has_valid_keys(os.environ):
         logger.info("WatsonX credentials validated successfully.")
         return
     
     if user_env_file is None:
-        logger.error("WatsonX credentials are not set. Please set WATSONX_SPACE_ID and WATSONX_APIKEY in your system environment variables or include them in your enviroment file and pass it with --env-file option.")
+        logger.error("WatsonX credentials are not set. Please set either WATSONX_SPACE_ID and WATSONX_APIKEY or WO_INSTANCE and WO_API_KEY in your system environment variables or include them in your environment file and pass it with --env-file option.")
         sys.exit(1)
 
     if not Path(user_env_file).exists():
@@ -41,11 +47,15 @@ def validate_watsonx_credentials(user_env_file: str) -> bool:
     
     user_env = read_env_file(user_env_file)
     
-    if not all(key in user_env for key in required_keys):
-        logger.error("Error: The environment file does not contain the required keys: WATSONX_SPACE_ID and WATSONX_APIKEY.")
+    if not has_valid_keys(user_env):
+        logger.error("Error: The environment file does not contain the required keys: either WATSONX_SPACE_ID and WATSONX_APIKEY or WO_INSTANCE and WO_API_KEY.")
         sys.exit(1)
 
-    os.environ.update({key: user_env[key] for key in required_keys})
+    # Update os.environ with whichever set is present
+    for key_set in required_sets:
+        if all(key in user_env for key in key_set):
+            os.environ.update({key: user_env[key] for key in key_set})
+            break
     logger.info("WatsonX credentials validated successfully.")
 
 def read_csv(data_path: str, delimiter="\t"):