ibm-watsonx-orchestrate 1.10.2__py3-none-any.whl → 1.11.0__py3-none-any.whl

ibm_watsonx_orchestrate/cli/commands/connections/connections_command.py

@@ -1,6 +1,6 @@
 import typer
 from typing_extensions import Annotated, List
-from ibm_watsonx_orchestrate.agent_builder.connections.types import ConnectionEnvironment, ConnectionPreference, ConnectionKind
+from ibm_watsonx_orchestrate.agent_builder.connections.types import ConnectionEnvironment, ConnectionPreference, ConnectionKind, ConnectionCredentialsEntry
 from ibm_watsonx_orchestrate.cli.commands.connections.connections_controller import (
     add_connection,
     remove_connection,
@@ -8,7 +8,9 @@ from ibm_watsonx_orchestrate.cli.commands.connections.connections_controller imp
     import_connection,
     configure_connection,
     set_credentials_connection,
-    set_identity_provider_connection
+    set_identity_provider_connection,
+    token_entry_connection_credentials_parse,
+    auth_entry_connection_credentials_parse
 )
 
 connections_app = typer.Typer(no_args_is_help=True)
@@ -244,6 +246,22 @@ def set_credentials_connection_command(
             help="For key_value, a key value pair in the form '<key>=<value>'. Multiple values can be passed using `-e key1=value1 -e key2=value2`"
         )
     ] = None,
+    token_entries: Annotated[
+        List[ConnectionCredentialsEntry],
+        typer.Option(
+            '--token-entries', "-t",
+            parser=token_entry_connection_credentials_parse,
+            help="Custom field options for oauth types token request, a key value location option in the form 'location:<key>=<value>' or '<key>=<value>' with location defaulting to 'header'. Multiple values can be passed using `-t key1=value1 -t location:key2=value2`"
+        )
+    ] = None,
+    auth_entries: Annotated[
+        List[ConnectionCredentialsEntry],
+        typer.Option(
+            '--auth-entries',
+            parser=auth_entry_connection_credentials_parse,
+            help="Custom field options for oauth_auth_code_flow auth server request, a key value location option in the form 'location:<key>=<value>' or '<key>=<value>' with location defaulting to 'query'. Note only 'query' is a valid location. Multiple values can be passed using `--auth-entries key1=value1 --auth-entries location:key2=value2`"
+        )
+    ] = None,
 ):
     set_credentials_connection(
         app_id=app_id,
@@ -259,7 +277,9 @@ def set_credentials_connection_command(
         auth_url=auth_url,
         grant_type=grant_type,
         scope=scope,
-        entries=entries
+        entries=entries,
+        token_entries=token_entries,
+        auth_entries=auth_entries
     )
 
 @connections_app.command(name="set-identity-provider")
@@ -311,6 +331,14 @@ def set_identity_provider_connection_command(
             help='The grant-type of the the identity provider'
         )
     ],
+    token_entries: Annotated[
+        List[ConnectionCredentialsEntry],
+        typer.Option(
+            '--token-entries', "-t",
+            parser=token_entry_connection_credentials_parse,
+            help="Custom field options for oauth types token request, a key value location option in the form 'location:<key>=<value>' or '<key>=<value>' with location defaulting to 'header'. Multiple values can be passed using `-t key1=value1 -t location:key2=value2`"
+        )
+    ] = None,
 ):
     set_identity_provider_connection(
         app_id=app_id,
@@ -319,5 +347,6 @@ def set_identity_provider_connection_command(
         client_id=client_id,
         client_secret=client_secret,
         scope=scope,
-        grant_type=grant_type
+        grant_type=grant_type,
+        token_entries=token_entries
     )

ibm_watsonx_orchestrate/cli/commands/connections/connections_controller.py

@@ -27,7 +27,10 @@ from ibm_watsonx_orchestrate.agent_builder.connections.types import (
     KeyValueConnectionCredentials,
     CREDENTIALS,
     IdentityProviderCredentials,
-    OAUTH_CONNECTION_TYPES
+    OAUTH_CONNECTION_TYPES,
+    ConnectionCredentialsEntryLocation,
+    ConnectionCredentialsEntry,
+    ConnectionCredentialsCustomFields
 
 )
 
@@ -167,6 +170,13 @@ def _validate_connection_params(type: ConnectionType, **args) -> None:
             f"Missing flags --grant-type is required for type {type}"
         )
     
+    if type != ConnectionType.OAUTH2_AUTH_CODE and (
+        args.get('auth_entries')
+    ):
+        raise typer.BadParameter(
+            f"The flag --auth-entries is only supported by type {type}"
+        )
+    
 
 def _parse_entry(entry: str) -> dict[str,str]:
     split_entry = entry.split('=', 1)
@@ -176,6 +186,19 @@ def _parse_entry(entry: str) -> dict[str,str]:
         exit(1)
     return {split_entry[0]: split_entry[1]}
 
+def _get_oauth_custom_fields(token_entries: List[ConnectionCredentialsEntry] | None, auth_entries: List[ConnectionCredentialsEntry] | None) -> dict:
+    custom_fields = ConnectionCredentialsCustomFields()
+
+    if token_entries:
+        for entry in token_entries:
+            custom_fields.add_field(entry, is_token=True)
+    
+    if auth_entries:
+        for entry in auth_entries:
+            custom_fields.add_field(entry, is_token=False)
+    
+    return custom_fields.model_dump(exclude_none=True)
+
 def _get_credentials(type: ConnectionType, **kwargs):
     match type:
         case ConnectionType.BASIC_AUTH:
@@ -192,18 +215,21 @@ def _get_credentials(type: ConnectionType, **kwargs):
                 api_key=kwargs.get("api_key")
             )
         case ConnectionType.OAUTH2_AUTH_CODE:
+            custom_fields = _get_oauth_custom_fields(kwargs.get("token_entries"), kwargs.get("auth_entries"))
             return OAuth2AuthCodeCredentials(
                 authorization_url=kwargs.get("auth_url"),
                 client_id=kwargs.get("client_id"),
                 client_secret=kwargs.get("client_secret"),
                 token_url=kwargs.get("token_url"),
-                scope=kwargs.get("scope")
+                scope=kwargs.get("scope"),
+                **custom_fields
             )
         case ConnectionType.OAUTH2_CLIENT_CREDS:
             # 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)
+            custom_fields = _get_oauth_custom_fields(kwargs.get("token_entries"), kwargs.get("auth_entries"))
+            return OAuth2ClientCredentials(**filtered_args, **custom_fields)
         # case ConnectionType.OAUTH2_IMPLICIT:
         #     return OAuth2ImplicitCredentials(
         #         authorization_url=kwargs.get("auth_url"),
@@ -212,13 +238,16 @@ def _get_credentials(type: ConnectionType, **kwargs):
         case ConnectionType.OAUTH2_PASSWORD:
             keys = ["username", "password", "client_id","client_secret","token_url","grant_type", "scope"]
             filtered_args = { key_name: kwargs[key_name] for key_name in keys if kwargs.get(key_name) }
-            return OAuth2PasswordCredentials(**filtered_args)
+            custom_fields = _get_oauth_custom_fields(kwargs.get("token_entries"), kwargs.get("auth_entries"))
+            return OAuth2PasswordCredentials(**filtered_args, **custom_fields)
         
         case ConnectionType.OAUTH_ON_BEHALF_OF_FLOW:
+            custom_fields = _get_oauth_custom_fields(kwargs.get("token_entries"), kwargs.get("auth_entries"))
             return OAuthOnBehalfOfCredentials(
                 client_id=kwargs.get("client_id"),
                 access_token_url=kwargs.get("token_url"),
-                grant_type=kwargs.get("grant_type")
+                grant_type=kwargs.get("grant_type"),
+                **custom_fields
             )
         case ConnectionType.KEY_VALUE:
             env = {}
@@ -231,6 +260,23 @@ def _get_credentials(type: ConnectionType, **kwargs):
         case _:
             raise ValueError(f"Invalid type '{type}' selected")
 
+def _connection_credentials_parse_entry(text: str, default_location: ConnectionCredentialsEntryLocation) -> ConnectionCredentialsEntry:
+    location_kv_pair = text.split(":", 1)
+    key_value = location_kv_pair[-1]
+    location = location_kv_pair[0] if len(location_kv_pair)>1 else default_location
+
+    valid_locations = [item.value for item in ConnectionCredentialsEntryLocation]
+    if location not in valid_locations:
+        raise typer.BadParameter(f"The provided location '{location}' is not in the allowed values {valid_locations}.")
+
+    key_value_pair = key_value.split('=', 1)
+    if len(key_value_pair) != 2:
+        message = f"The entry '{text}' is not in the expected form '<location>:<key>=<value>' or '<key>=<value>'"
+        raise typer.BadParameter(message)
+    key, value = key_value_pair[0], key_value_pair[1]
+    
+    return ConnectionCredentialsEntry(key=key, value=value, location=location)
+    
 
 def add_configuration(config: ConnectionConfiguration) -> None:
     client = get_connections_client()
@@ -524,5 +570,15 @@ def set_identity_provider_connection(
         logger.error(f"Cannot set Identity Provider when 'sso' is false in configuration. Please enable sso for connection '{app_id}' in environment '{environment}' and try again.")
         sys.exit(1)
 
-    idp = IdentityProviderCredentials.model_validate(kwargs)
+    custom_fields = _get_oauth_custom_fields(token_entries=kwargs.get("token_entries"), auth_entries=None)
+    idp = IdentityProviderCredentials(**kwargs, **custom_fields)
     add_identity_provider(app_id=app_id, environment=environment, idp=idp)
+
+def token_entry_connection_credentials_parse(text: str) -> ConnectionCredentialsEntry:
+    return _connection_credentials_parse_entry(text=text, default_location=ConnectionCredentialsEntryLocation.HEADER)
+    
+def auth_entry_connection_credentials_parse(text: str) -> ConnectionCredentialsEntry:
+    entry = _connection_credentials_parse_entry(text=text, default_location=ConnectionCredentialsEntryLocation.QUERY)
+    if entry.location != ConnectionCredentialsEntryLocation.QUERY:
+        raise typer.BadParameter(f"Only location '{ConnectionCredentialsEntryLocation.QUERY}' is supported for --auth-entry")
+    return entry

ibm_watsonx_orchestrate/cli/commands/copilot/copilot_controller.py

@@ -327,7 +327,11 @@ def talk_to_cpe(cpe_client, samples_file=None, context_data=None):
 
 
 def prompt_tune(agent_spec: str, output_file: str | None, samples_file: str | None, dry_run_flag: bool) -> None:
-    agent = AgentsController.import_agent(file=agent_spec, app_id=None)[0]
+    agents = AgentsController.import_agent(file=agent_spec, app_id=None)
+    if not agents:
+        logger.error("Invalid agent spec file provided, no agent found.")
+        sys.exit(1)
+    agent = agents[0]
     agent_kind = agent.kind
 
     if agent_kind != AgentKind.NATIVE:
@@ -342,7 +346,7 @@ def prompt_tune(agent_spec: str, output_file: str | None, samples_file: str | No
 
     client = get_cpe_client()
 
-    instr = agent.instructions
+    instr = agent.instructions if agent.instructions else ""
 
     tools = _get_tools_from_names(agent.tools)
 

ibm_watsonx_orchestrate/cli/commands/environment/environment_command.py

@@ -70,7 +70,7 @@ def add_env(
         ] = None,
         type: Annotated[
             EnvironmentAuthType,
-            typer.Option("--type", "-t", help="The type of auth you wish to use"),
+            typer.Option("--type", "-t", help="The type of auth you wish to use. This overrides the auth type that is inferred from the url"),
         ] = None,
         insecure: Annotated[
             bool,

ibm_watsonx_orchestrate/cli/commands/evaluations/evaluations_command.py

@@ -16,7 +16,7 @@ from typing import Optional
 from typing_extensions import Annotated
 
 from ibm_watsonx_orchestrate import __version__
-from ibm_watsonx_orchestrate.cli.commands.evaluations.evaluations_controller import EvaluationsController
+from ibm_watsonx_orchestrate.cli.commands.evaluations.evaluations_controller import EvaluationsController, EvaluateMode
 from ibm_watsonx_orchestrate.cli.commands.agents.agents_controller import AgentsController
 
 logger = logging.getLogger(__name__)
@@ -220,6 +220,13 @@ def analyze(data_path: Annotated[
             help="Path to the directory that has the saved results"
         )
     ],
+    tool_definition_path: Annotated[
+        Optional[str],
+        typer.Option(
+            "--tools-path", "-t",
+            help="Path to the directory containing tool definitions."
+        )
+    ] = None,
     user_env_file: Annotated[
         Optional[str],
         typer.Option(
@@ -230,7 +237,10 @@ def analyze(data_path: Annotated[
 
     validate_watsonx_credentials(user_env_file)
     controller = EvaluationsController()
-    controller.analyze(data_path=data_path)
+    controller.analyze(
+        data_path=data_path,
+        tool_definition_path=tool_definition_path
+        )
 
 @evaluation_app.command(name="validate-external", help="Validate an external agent against a set of inputs")
 def validate_external(
@@ -375,3 +385,165 @@ def validate_external(
             msg = f"[dark_orange]Schema validation did not succeed. See '{str(validation_folder)}' for failures.[/dark_orange]"
 
         rich.print(Panel(msg))
+
+@evaluation_app.command(name="quick-eval",
+                        short_help="Evaluate agent against a suite of static metrics and LLM-as-a-judge metrics",
+                        help="""
+                        Use the quick-eval command to evaluate your agent against a suite of static metrics and LLM-as-a-judge metrics.
+                        """)
+def quick_eval(
+    config_file: Annotated[
+        Optional[str],
+        typer.Option(
+            "--config", "-c",
+            help="Path to YAML configuration file containing evaluation settings."
+        )
+    ] = None,
+    test_paths: Annotated[
+        Optional[str],
+        typer.Option(
+            "--test-paths", "-p", 
+            help="Paths to the test files and/or directories to evaluate, separated by commas."
+        ),
+    ] = None,
+    tools_path: Annotated[
+        str,
+        typer.Option(
+            "--tools-path", "-t",
+            help="Path to the directory containing tool definitions."
+        )
+    ] = None,
+    output_dir: Annotated[
+        Optional[str], 
+        typer.Option(
+            "--output-dir", "-o",
+            help="Directory to save the evaluation results."
+        )
+    ] = None,
+    user_env_file: Annotated[
+        Optional[str],
+        typer.Option(
+            "--env-file", "-e", 
+            help="Path to a .env file that overrides default.env. Then environment variables override both."
+        ),
+    ] = None
+):
+    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)
+
+    if tools_path is None:
+        logger.error("When running `quick-eval`, please provide the path to your tools file.")
+        sys.exit(1)
+    
+    controller = EvaluationsController()
+    controller.evaluate(
+        config_file=config_file,
+        test_paths=test_paths,
+        output_dir=output_dir,
+        tools_path=tools_path, mode=EvaluateMode.referenceless
+    )
+
+
+red_teaming_app = typer.Typer(no_args_is_help=True)
+evaluation_app.add_typer(red_teaming_app, name="red-teaming")
+
+
+@red_teaming_app.command("list", help="List available red-teaming attack plans")
+def list_plans():
+    controller = EvaluationsController()
+    controller.list_red_teaming_attacks()
+
+
+@red_teaming_app.command("plan", help="Generate red-teaming attacks")
+def plan(
+    attacks_list: Annotated[
+        str,
+        typer.Option(
+            "--attacks-list",
+            "-a",
+            help="Comma-separated list of red-teaming attacks to generate.",
+        ),
+    ],
+    datasets_path: Annotated[
+        str,
+        typer.Option(
+            "--datasets-path",
+            "-d",
+            help="Path to datasets for red-teaming. This can also be a comma-separated list of files or directories.",
+        ),
+    ],
+    agents_path: Annotated[
+        str, typer.Option("--agents-path", "-g", help="Path to the directory containing all agent definitions.")
+    ],
+    target_agent_name: Annotated[
+        str,
+        typer.Option(
+            "--target-agent-name",
+            "-t",
+            help="Name of the target agent to attack (should be present in agents-path).",
+        ),
+    ],
+    output_dir: Annotated[
+        Optional[str],
+        typer.Option("--output-dir", "-o", help="Directory to save generated attacks.")
+    ]=None,
+    user_env_file: Annotated[
+        Optional[str],
+        typer.Option(
+            "--env-file",
+            "-e",
+            help="Path to a .env file that overrides default.env. Then environment variables override both.",
+        ),
+    ] = None,
+    max_variants: Annotated[
+        Optional[int],
+        typer.Option(
+            "--max_variants",
+            "-n",
+            help="Number of variants to generate per attack type.",
+        ),
+    ] = None,
+
+):
+    validate_watsonx_credentials(user_env_file)
+    controller = EvaluationsController()
+    controller.generate_red_teaming_attacks(
+        attacks_list=attacks_list,
+        datasets_path=datasets_path,
+        agents_path=agents_path,
+        target_agent_name=target_agent_name,
+        output_dir=output_dir,
+        max_variants=max_variants,
+    )
+
+
+@red_teaming_app.command("run", help="Run red-teaming attacks")
+def run(
+    attack_paths: Annotated[
+        str,
+        typer.Option(
+            "--attack-paths",
+            "-a",
+            help="Path or list of paths (comma-separated) to directories containing attack files.",
+        ),
+    ],
+    output_dir: Annotated[
+        Optional[str],
+        typer.Option("--output-dir", "-o", help="Directory to save attack results."),
+    ] = None,
+    user_env_file: Annotated[
+        Optional[str],
+        typer.Option(
+            "--env-file",
+            "-e",
+            help="Path to a .env file that overrides default.env. Then environment variables override both.",
+        ),
+    ] = None,
+):
+    validate_watsonx_credentials(user_env_file)
+    controller = EvaluationsController()
+    controller.run_red_teaming_attacks(attack_paths=attack_paths, output_dir=output_dir)

ibm_watsonx_orchestrate/cli/commands/evaluations/evaluations_controller.py

@@ -1,17 +1,23 @@
 import logging
 import os.path
 from typing import List, Dict, Optional, Tuple
+from enum import StrEnum
 import csv
 from pathlib import Path
 import sys
 from wxo_agentic_evaluation import main as evaluate
+from wxo_agentic_evaluation import quick_eval
 from wxo_agentic_evaluation.tool_planner import build_snapshot
-from wxo_agentic_evaluation.analyze_run import analyze
+from wxo_agentic_evaluation.analyze_run import Analyzer
 from wxo_agentic_evaluation.batch_annotate import generate_test_cases_from_stories
-from wxo_agentic_evaluation.arg_configs import TestConfig, AuthConfig, LLMUserConfig, ChatRecordingConfig, AnalyzeConfig, ProviderConfig
+from wxo_agentic_evaluation.arg_configs import TestConfig, AuthConfig, LLMUserConfig, ChatRecordingConfig, AnalyzeConfig, ProviderConfig, AttackConfig, QuickEvalConfig
 from wxo_agentic_evaluation.record_chat import record_chats
 from wxo_agentic_evaluation.external_agent.external_validate import ExternalAgentValidation
 from wxo_agentic_evaluation.external_agent.performance_test import ExternalAgentPerformanceTest
+from wxo_agentic_evaluation.red_teaming.attack_list import print_attacks
+from wxo_agentic_evaluation.red_teaming import attack_generator
+from wxo_agentic_evaluation.red_teaming.attack_runner import run_attacks
+from wxo_agentic_evaluation.arg_configs import AttackGeneratorConfig
 from ibm_watsonx_orchestrate import __version__
 from ibm_watsonx_orchestrate.cli.config import Config, ENV_WXO_URL_OPT, AUTH_CONFIG_FILE, AUTH_CONFIG_FILE_FOLDER, AUTH_SECTION_HEADER, AUTH_MCSP_TOKEN_OPT
 from ibm_watsonx_orchestrate.utils.utils import yaml_safe_load
@@ -21,6 +27,9 @@ import uuid
 
 logger = logging.getLogger(__name__)
 
+class EvaluateMode(StrEnum):
+    default = "default" # referenceFUL evaluation
+    referenceless = "referenceless"
 
 class EvaluationsController:
     def __init__(self):
@@ -38,7 +47,7 @@ class EvaluationsController:
 
         return url, tenant_name, token
 
-    def evaluate(self, config_file: Optional[str] = None, test_paths: Optional[str] = None, output_dir: Optional[str] = None) -> None:
+    def evaluate(self, config_file: Optional[str] = None, test_paths: Optional[str] = None, output_dir: Optional[str] = None, tools_path: str = None, mode: str = EvaluateMode.default) -> None:
         url, tenant_name, token = self._get_env_config()
 
         if "WATSONX_SPACE_ID" in os.environ and "WATSONX_APIKEY" in os.environ:
@@ -90,9 +99,13 @@ class EvaluationsController:
             config_data["output_dir"] = output_dir
             logger.info(f"Using output directory: {config_data['output_dir']}")
 
-        config = TestConfig(**config_data)
-        
-        evaluate.main(config)
+        if mode == EvaluateMode.default:
+            config = TestConfig(**config_data)
+            evaluate.main(config)
+        elif mode == EvaluateMode.referenceless:
+            config_data["tools_path"] = tools_path
+            config = QuickEvalConfig(**config_data)
+            quick_eval.main(config)
 
     def record(self, output_dir) -> None:
 
@@ -160,9 +173,13 @@ class EvaluationsController:
 
         logger.info("Test cases stored at: %s", output_dir)
 
-    def analyze(self, data_path: str) -> None:
-        config = AnalyzeConfig(data_path=data_path)
-        analyze(config)
+    def analyze(self, data_path: str, tool_definition_path: str) -> None:
+        config = AnalyzeConfig(
+            data_path=data_path,
+            tool_definition_path=tool_definition_path
+            )
+        analyzer = Analyzer()
+        analyzer.analyze(config)
 
     def summarize(self) -> None:
         pass
@@ -187,3 +204,70 @@ class EvaluationsController:
         generated_performance_tests = performance_test.generate_tests()
 
         return generated_performance_tests
+    
+    def list_red_teaming_attacks(self):
+        print_attacks()
+
+    def generate_red_teaming_attacks(
+        self,
+        attacks_list: str,
+        datasets_path: str,
+        agents_path: str,
+        target_agent_name: str,
+        output_dir: Optional[str] = None,
+        max_variants: Optional[int] = None,
+    ):
+        if output_dir is None:
+            output_dir = os.path.join(os.getcwd(), "red_teaming_attacks")
+            os.makedirs(output_dir, exist_ok=True)
+            logger.info(f"No output directory specified. Using default: {output_dir}")
+
+        results = attack_generator.main(
+            AttackGeneratorConfig(
+                attacks_list=attacks_list.split(","),
+                datasets_path=datasets_path.split(","),
+                agents_path=agents_path,
+                target_agent_name=target_agent_name,
+                output_dir=output_dir,
+                max_variants=max_variants,
+            )
+        )
+        logger.info(f"Generated {len(results)} attacks and saved to {output_dir}")
+
+    def run_red_teaming_attacks(self, attack_paths: str, output_dir: Optional[str] = None) -> None:
+        url, tenant_name, token = self._get_env_config()
+
+        if "WATSONX_SPACE_ID" in os.environ and "WATSONX_APIKEY" in os.environ:
+            provider = "watsonx"
+        elif "WO_INSTANCE" in os.environ and "WO_API_KEY" in os.environ:
+            provider = "model_proxy"
+        else:
+            logger.error(
+                "No provider found. Please either provide a config_file or set either WATSONX_SPACE_ID and WATSONX_APIKEY or WO_INSTANCE and WO_API_KEY in your system environment variables."
+            )
+            sys.exit(1)
+
+        config_data = {
+            "auth_config": AuthConfig(
+                url=url,
+                tenant_name=tenant_name,
+                token=token,
+            ),
+            "provider_config": ProviderConfig(
+                provider=provider,
+                model_id="meta-llama/llama-3-405b-instruct",
+            ),
+        }
+
+        config_data["attack_paths"] = attack_paths.split(",")
+        if output_dir:
+            config_data["output_dir"] = output_dir
+        else:
+            config_data["output_dir"] = os.path.join(os.getcwd(), "red_teaming_results")
+            os.makedirs(config_data["output_dir"], exist_ok=True)
+            logger.info(f"No output directory specified. Using default: {config_data['output_dir']}")
+            
+
+        config = AttackConfig(**config_data)
+
+        run_attacks(config)

ibm_watsonx_orchestrate/cli/commands/server/server_command.py

@@ -191,9 +191,6 @@ def get_default_registry_env_vars_by_dev_edition_source(default_env: dict, user_
             parsed = urlparse(wo_url)
             hostname = parsed.hostname
             
-            if not hostname or not hostname.startswith("api."):
-                raise ValueError(f"Invalid WO_INSTANCE URL: '{wo_url}'. It should starts with 'api.'")
-            
             registry_url = f"registry.{hostname[4:]}/cp/wxo-lite"
         else:
             raise ValueError(f"Unknown value for developer edition source: {source}. Must be one of ['internal', 'myibm', 'orchestrate'].")

ibm_watsonx_orchestrate/cli/commands/server/types.py

@@ -1,5 +1,6 @@
 import logging
 import sys
+import uuid
 from enum import Enum
 from pydantic import BaseModel, model_validator, ConfigDict
 
@@ -43,9 +44,6 @@ class WatsonXAIEnvConfig(BaseModel):
         if not config.get("WATSONX_SPACE_ID") and not config.get("WATSONX_APIKEY"):
              raise ValueError("Missing configuration requirements 'WATSONX_SPACE_ID' and 'WATSONX_APIKEY'")
         
-        if config.get("WATSONX_SPACE_ID") and not config.get("WATSONX_APIKEY"):
-            logger.error("Cannot use env var 'WATSONX_SPACE_ID' without setting the corresponding 'WATSONX_APIKEY'")
-            sys.exit(1)
         
         if not config.get("WATSONX_SPACE_ID") and config.get("WATSONX_APIKEY"):
             logger.error("Cannot use env var 'WATSONX_APIKEY' without setting the corresponding 'WATSONX_SPACE_ID'")
@@ -54,6 +52,12 @@ class WatsonXAIEnvConfig(BaseModel):
         config["USE_SAAS_ML_TOOLS_RUNTIME"] = False
         return config
 
+def is_valid_uuid(value) -> bool:
+    try:
+        uuid.UUID(str(value))
+        return True
+    except (ValueError, TypeError, AttributeError):
+        return False
 
 class ModelGatewayEnvConfig(BaseModel):
     WO_API_KEY: str | None = None
@@ -84,8 +88,11 @@ class ModelGatewayEnvConfig(BaseModel):
         if not config.get("AUTHORIZATION_URL"):
             inferred_auth_url = AUTH_TYPE_DEFAULT_URL_MAPPING.get(auth_type)
             if not inferred_auth_url:
-                logger.error(f"No 'AUTHORIZATION_URL' found. Auth type '{auth_type}' does not support defaulting. Please set the 'AUTHORIZATION_URL' explictly")
-                sys.exit(1)
+                if auth_type == WoAuthType.CPD:
+                    inferred_auth_url = config.get("WO_INSTANCE") + '/icp4d-api/v1/authorize'   
+                else: 
+                    logger.error(f"No 'AUTHORIZATION_URL' found. Auth type '{auth_type}' does not support defaulting. Please set the 'AUTHORIZATION_URL' explictly")
+                    sys.exit(1)
             config["AUTHORIZATION_URL"] = inferred_auth_url
         
         if auth_type != WoAuthType.CPD:
@@ -101,6 +108,7 @@ class ModelGatewayEnvConfig(BaseModel):
                 sys.exit(1)
         
         config["USE_SAAS_ML_TOOLS_RUNTIME"] = True
-        # Fake (but valid) UUIDv4 for knowledgebase check
-        config["WATSONX_SPACE_ID"] = "aaaaaaaa-aaaa-4aaa-aaaa-aaaaaaaaaaaa"
+        if not is_valid_uuid(config.get("WATSONX_SPACE_ID")):
+            # Fake (but valid) UUIDv4 for knowledgebase check
+            config["WATSONX_SPACE_ID"] = "aaaaaaaa-aaaa-4aaa-aaaa-aaaaaaaaaaaa"
         return config