ibm-watsonx-orchestrate 1.6.3__py3-none-any.whl → 1.6.4__py3-none-any.whl

ibm_watsonx_orchestrate/cli/commands/server/server_command.py

@@ -33,6 +33,21 @@ logger = logging.getLogger(__name__)
 server_app = typer.Typer(no_args_is_help=True)
 
 
+_ALWAYS_UNSET: set[str] = {
+    "WO_API_KEY",
+    "WO_INSTANCE",
+    "DOCKER_IAM_KEY",
+    "WO_DEVELOPER_EDITION_SOURCE",
+    "WATSONX_SPACE_ID",
+    "WATSONX_APIKEY",
+    "WO_USERNAME",
+    "WO_PASSWORD",
+}
+  
+def define_saas_wdu_runtime(value: str = "none") -> None:
+    cfg = Config()
+    cfg.write(USER_ENV_CACHE_HEADER,"SAAS_WDU_RUNTIME",value)
+
 def ensure_docker_installed() -> None:
     try:
         subprocess.run(["docker", "--version"], check=True, capture_output=True)
@@ -261,6 +276,13 @@ def _check_exclusive_observibility(langfuse_enabled: bool, ibm_tele_enabled: boo
         return False
     return True
 
+def _prepare_clean_env(env_file: Path) -> None:
+    """Remove env vars so terminal definitions don't override"""
+    keys_from_file = set(dotenv_values(str(env_file)).keys())
+    keys_to_unset = keys_from_file | _ALWAYS_UNSET
+    for key in keys_to_unset:
+        os.environ.pop(key, None)
+
 def write_merged_env_file(merged_env: dict) -> Path:
     tmp = tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".env")
     with tmp:
@@ -293,7 +315,8 @@ NON_SECRET_ENV_ITEMS = {
     "WO_INSTANCE",
     "USE_SAAS_ML_TOOLS_RUNTIME",
     "AUTHORIZATION_URL",
-    "OPENSOURCE_REGISTRY_PROXY"
+    "OPENSOURCE_REGISTRY_PROXY",
+    "SAAS_WDU_RUNTIME"
 }
 def persist_user_env(env: dict, include_secrets: bool = False) -> None:
     if include_secrets:
@@ -313,10 +336,10 @@ def get_persisted_user_env() -> dict | None:
     user_env = cfg.get(USER_ENV_CACHE_HEADER) if cfg.get(USER_ENV_CACHE_HEADER) else None
     return user_env
 
-
-def run_compose_lite(final_env_file: Path, experimental_with_langfuse=False, experimental_with_ibm_telemetry=False) -> None:
+def run_compose_lite(final_env_file: Path, experimental_with_langfuse=False, experimental_with_ibm_telemetry=False, with_doc_processing=False) -> None:
     compose_path = get_compose_file()
     compose_command = ensure_docker_compose_installed()
+    _prepare_clean_env(final_env_file)  
     db_tag = read_env_file(final_env_file).get('DBTAG', None)
     logger.info(f"Detected architecture: {platform.machine()}, using DBTAG: {db_tag}")
 
@@ -341,19 +364,17 @@ def run_compose_lite(final_env_file: Path, experimental_with_langfuse=False, exp
 
 
     # Step 2: Start all remaining services (except DB)
+    profiles = []
     if experimental_with_langfuse:
-        command = compose_command + [
-            '--profile',
-            'langfuse'
-        ]
-    elif experimental_with_ibm_telemetry:
-        command = compose_command + [
-            '--profile',
-            'ibm-telemetry'
-        ]
-    else:
-        command = compose_command
+        profiles.append("langfuse")
+    if experimental_with_ibm_telemetry:
+        profiles.append("ibm-telemetry")
+    if with_doc_processing:
+        profiles.append("docproc")
 
+    command = compose_command[:]
+    for profile in profiles:
+        command += ["--profile", profile]
 
     command += [
         "-f", str(compose_path),
@@ -361,6 +382,8 @@ def run_compose_lite(final_env_file: Path, experimental_with_langfuse=False, exp
         "up",
         "--scale",
         "ui=0",
+        "--scale",
+        "cpe=0",
         "-d",
         "--remove-orphans",
     ]
@@ -431,6 +454,7 @@ def wait_for_wxo_ui_health_check(timeout_seconds=45, interval_seconds=2):
 def run_compose_lite_ui(user_env_file: Path) -> bool:
     compose_path = get_compose_file()
     compose_command = ensure_docker_compose_installed()
+    _prepare_clean_env(user_env_file)  
     ensure_docker_installed()
 
     default_env = read_env_file(get_default_env_file())
@@ -525,6 +549,7 @@ def run_compose_lite_ui(user_env_file: Path) -> bool:
 def run_compose_lite_down_ui(user_env_file: Path, is_reset: bool = False) -> None:
     compose_path = get_compose_file()
     compose_command = ensure_docker_compose_installed()
+    _prepare_clean_env(user_env_file)  
 
 
     ensure_docker_installed()
@@ -568,6 +593,7 @@ def run_compose_lite_down_ui(user_env_file: Path, is_reset: bool = False) -> Non
 def run_compose_lite_down(final_env_file: Path, is_reset: bool = False) -> None:
     compose_path = get_compose_file()
     compose_command = ensure_docker_compose_installed()
+    _prepare_clean_env(final_env_file)  
 
     command = compose_command + [
         '--profile', '*',
@@ -600,6 +626,7 @@ def run_compose_lite_down(final_env_file: Path, is_reset: bool = False) -> None:
 def run_compose_lite_logs(final_env_file: Path, is_reset: bool = False) -> None:
     compose_path = get_compose_file()
     compose_command = ensure_docker_compose_installed()
+    _prepare_clean_env(final_env_file)  
 
     command = compose_command + [
         "-f", str(compose_path),
@@ -655,63 +682,63 @@ def confirm_accepts_license_agreement(accepts_by_argument: bool):
 def auto_configure_callback_ip(merged_env_dict: dict) -> dict:
     """
     Automatically detect and configure CALLBACK_HOST_URL if it's empty.
-    
+
     Args:
         merged_env_dict: The merged environment dictionary
-        
+
     Returns:
         Updated environment dictionary with CALLBACK_HOST_URL set
     """
     callback_url = merged_env_dict.get('CALLBACK_HOST_URL', '').strip()
-    
+
     # Only auto-configure if CALLBACK_HOST_URL is empty
     if not callback_url:
         logger.info("Auto-detecting local IP address for async tool callbacks...")
-        
+
         system = platform.system()
         ip = None
-        
+
         try:
             if system in ("Linux", "Darwin"):
                 result = subprocess.run(["ifconfig"], capture_output=True, text=True, check=True)
                 lines = result.stdout.splitlines()
-                
+
                 for line in lines:
                     line = line.strip()
                     # Unix ifconfig output format: "inet 192.168.1.100 netmask 0xffffff00 broadcast 192.168.1.255"
                     if line.startswith("inet ") and "127.0.0.1" not in line:
                         candidate_ip = line.split()[1]
                         # Validate IP is not loopback or link-local
-                        if (candidate_ip and 
-                            not candidate_ip.startswith("127.") and 
+                        if (candidate_ip and
+                            not candidate_ip.startswith("127.") and
                             not candidate_ip.startswith("169.254")):
                             ip = candidate_ip
                             break
-            
+
             elif system == "Windows":
                 result = subprocess.run(["ipconfig"], capture_output=True, text=True, check=True)
                 lines = result.stdout.splitlines()
-                
+
                 for line in lines:
                     line = line.strip()
                     # Windows ipconfig output format: "   IPv4 Address. . . . . . . . . . . : 192.168.1.100"
                     if "IPv4 Address" in line and ":" in line:
                         candidate_ip = line.split(":")[-1].strip()
                         # Validate IP is not loopback or link-local
-                        if (candidate_ip and 
-                            not candidate_ip.startswith("127.") and 
+                        if (candidate_ip and
+                            not candidate_ip.startswith("127.") and
                             not candidate_ip.startswith("169.254")):
                             ip = candidate_ip
                             break
-            
+
             else:
                 logger.warning(f"Unsupported platform: {system}")
                 ip = None
-                
+
         except Exception as e:
             logger.debug(f"IP detection failed on {system}: {e}")
             ip = None
-        
+
         if ip:
             callback_url = f"http://{ip}:4321"
             merged_env_dict['CALLBACK_HOST_URL'] = callback_url
@@ -724,7 +751,7 @@ def auto_configure_callback_ip(merged_env_dict: dict) -> dict:
             logger.info("For external tools, consider using ngrok or similar tunneling service.")
     else:
         logger.info(f"Using existing CALLBACK_HOST_URL: {callback_url}")
-    
+
     return merged_env_dict
 
 @server_app.command(name="start")
@@ -755,9 +782,16 @@ def server_start(
         "--accept-terms-and-conditions",
         help="By providing this flag you accept the terms and conditions outlined in the logs on server start."
     ),
+    with_doc_processing: bool = typer.Option(
+        False,
+        '--with-doc-processing', '-d',
+        help='Enable IBM Document Processing to extract information from your business documents. Enabling this activates the Watson Document Understanding service.'
+    ),
 ):
     confirm_accepts_license_agreement(accept_terms_and_conditions)
 
+    define_saas_wdu_runtime()
+    
     if user_env_file and not Path(user_env_file).exists():
         logger.error(f"Error: The specified environment file '{user_env_file}' does not exist.")
         sys.exit(1)
@@ -789,10 +823,14 @@ def server_start(
         logger.error("Please select either langfuse or ibm telemetry for observability not both")
         sys.exit(1)
 
-    # Add LANGFUSE_ENABLED into the merged_env_dict, for tempus to pick up.
+    # Add LANGFUSE_ENABLED and DOCPROC_ENABLED into the merged_env_dict, for tempus to pick up.
     if experimental_with_langfuse:
         merged_env_dict['LANGFUSE_ENABLED'] = 'true'
-        
+
+    if with_doc_processing:
+        merged_env_dict['DOCPROC_ENABLED'] = 'true'
+        define_saas_wdu_runtime("local")
+
     if experimental_with_ibm_telemetry:
         merged_env_dict['USE_IBM_TELEMETRY'] = 'true'
 
@@ -806,10 +844,12 @@ def server_start(
 
 
     final_env_file = write_merged_env_file(merged_env_dict)
-    run_compose_lite(final_env_file=final_env_file, 
-                     experimental_with_langfuse=experimental_with_langfuse,
-                     experimental_with_ibm_telemetry=experimental_with_ibm_telemetry)
 
+    run_compose_lite(final_env_file=final_env_file,
+                     experimental_with_langfuse=experimental_with_langfuse,
+                     experimental_with_ibm_telemetry=experimental_with_ibm_telemetry,
+                     with_doc_processing=with_doc_processing)
+    
     run_db_migration()
 
     logger.info("Waiting for orchestrate server to be fully initialized and ready...")
@@ -836,6 +876,8 @@ def server_start(
 
     if experimental_with_langfuse:
         logger.info(f"You can access the observability platform Langfuse at http://localhost:3010, username: orchestrate@ibm.com, password: orchestrate")
+    if with_doc_processing:
+        logger.info(f"Document processing in Flows (Public Preview) has been enabled.")
 
 @server_app.command(name="stop")
 def server_stop(
@@ -845,6 +887,7 @@ def server_stop(
         help="Path to a .env file that overrides default.env. Then environment variables override both."
     )
 ):
+
     ensure_docker_installed()
     default_env_path = get_default_env_file()
     merged_env_dict = merge_env(
@@ -901,9 +944,24 @@ def server_logs(
 def run_db_migration() -> None:
     compose_path = get_compose_file()
     compose_command = ensure_docker_compose_installed()
+    default_env_path = get_default_env_file()
+    merged_env_dict = merge_env(default_env_path, user_env_path=None)
+    merged_env_dict['WATSONX_SPACE_ID']='X'
+    merged_env_dict['WATSONX_APIKEY']='X'
+    merged_env_dict['WXAI_API_KEY'] = ''
+    merged_env_dict['ASSISTANT_EMBEDDINGS_API_KEY'] = ''
+    merged_env_dict['ASSISTANT_LLM_SPACE_ID'] = ''
+    merged_env_dict['ROUTING_LLM_SPACE_ID'] = ''
+    merged_env_dict['USE_SAAS_ML_TOOLS_RUNTIME'] = ''
+    merged_env_dict['BAM_API_KEY'] = ''
+    merged_env_dict['ASSISTANT_EMBEDDINGS_SPACE_ID'] = ''
+    merged_env_dict['ROUTING_LLM_API_KEY'] = ''
+    merged_env_dict['ASSISTANT_LLM_API_KEY'] = ''
+    final_env_file = write_merged_env_file(merged_env_dict)
 
     command = compose_command + [
         "-f", str(compose_path),
+        "--env-file", str(final_env_file),
         "exec",
         "wxo-server-db",
         "bash",
@@ -943,4 +1001,4 @@ def run_db_migration() -> None:
         sys.exit(1)
 
 if __name__ == "__main__":
-    server_app()
+    server_app()

ibm_watsonx_orchestrate/cli/commands/toolkit/toolkit_command.py

@@ -47,7 +47,7 @@ def import_toolkit(
     ] = None,
     tools: Annotated[
         Optional[str],
-        typer.Option("--tools", "-t", help="Comma-separated list of tools to import. Or you can use `*` to use all tools"),
+        typer.Option("--tools", "-t", help="Comma-separated list of tools to import. Or you can use \"*\" to use all tools"),
     ] = None,
     app_id: Annotated[
         List[str],

ibm_watsonx_orchestrate/cli/commands/tools/tools_controller.py

@@ -41,7 +41,7 @@ from ibm_watsonx_orchestrate.client.connections import get_connections_client, g
 from ibm_watsonx_orchestrate.client.utils import instantiate_client, is_local_dev
 from ibm_watsonx_orchestrate.flow_builder.utils import import_flow_support_tools
 from ibm_watsonx_orchestrate.utils.utils import sanatize_app_id
-from ibm_watsonx_orchestrate.client.utils import is_local_dev
+from ibm_watsonx_orchestrate.utils.exceptions import BadRequest
 
 from  ibm_watsonx_orchestrate import __version__
 
@@ -400,7 +400,14 @@ The [bold]flow tool[/bold] is being imported from [green]`{file}`[/green].
     
 [bold cyan]Additional information:[/bold cyan]
 
-- The [bold green]Get flow status[/bold green] tool is being imported to support flow tools. This tool can query the status of a flow tool instance.  You can add it to your agent using the UI or including the following tool name in your agent definition: [green]i__get_flow_status_intrinsic_tool__[/green]. 
+- The [bold green]Get flow status[/bold green] tool is being imported to support flow tools. This tool can query the status of a flow tool instance. You can add it to your agent using the UI or including the following tool name in your agent definition: [green]i__get_flow_status_intrinsic_tool__[/green].
+
+[bold cyan]Experimental Features - Scheduling Flows and Agents: [/bold cyan]
+- You can now schedule any Flows to be run on a later time.  Just include the [bold green]"schedulable=True"[/bold green] attribute in the @flow decorator.
+- Once enabled, you can schedule a flow by saying something like: [bold green]Can you schedule the flow <flow_name> to run everyday at 7am EST for 3 times?[/bold green]
+- To schedule an agent, see the example in [bold green]examples/flow_builder/agent_scheduler[/bold green]. Use that to import the [bold green]agent_run[/bold green] tool to your agent. 
+- Use [bold green]agent_run[/bold green] tool to schedule an agent. For example: [bold green]Can you schedule the agent <agent_name> to run every weekday at 8am UK time?[/bold green]
+- In scheduling, it is important to mention timezone or UTC time (also known as Greenwich Mean Time or Coordinated Universal Time) will be used.
 
     """
 
@@ -477,7 +484,7 @@ The [bold]flow tool[/bold] is being imported from [green]`{file}`[/green].
                                  permission="read_only", 
                                  flow_model=model)   
     
-    tools = import_flow_support_tools()
+    tools = import_flow_support_tools(model=model)
     
     tools.append(tool)
 
@@ -554,7 +561,7 @@ class ToolsController:
                 tools = []
                 logger.warning("Skill Import not implemented yet")
             case _:
-                raise ValueError("Invalid kind selected")
+                raise BadRequest("Invalid kind selected")
 
         for tool in tools:
             yield tool

ibm_watsonx_orchestrate/cli/config.py

@@ -6,6 +6,7 @@ from copy import deepcopy
 from ibm_watsonx_orchestrate.cli.commands.tools.types import RegistryType
 from ibm_watsonx_orchestrate.utils.utils import yaml_safe_load
 from enum import Enum
+from ibm_watsonx_orchestrate.utils.exceptions import BadRequest
 
 # Section Headers
 AUTH_SECTION_HEADER = "auth"
@@ -82,7 +83,6 @@ def _check_if_default_config_file(folder, file):
 def _check_if_auth_config_file(folder, file):
     return folder == AUTH_CONFIG_FILE_FOLDER and file == AUTH_CONFIG_FILE
 
-
 def clear_protected_env_credentials_token():
     auth_cfg = Config(config_file_folder=AUTH_CONFIG_FILE_FOLDER, config_file=AUTH_CONFIG_FILE)
     auth_cfg.delete(AUTH_SECTION_HEADER, PROTECTED_ENV_NAME, AUTH_MCSP_TOKEN_OPT)
@@ -91,7 +91,7 @@ def clear_protected_env_credentials_token():
 class ConfigFileTypes(str, Enum):
     AUTH = 'auth'
     CONFIG = 'config'
-
+    DOCPROC_FEATURE_CONF= 'docproc_feature'
 
 class Config:
 
@@ -209,7 +209,7 @@ class Config:
         as keys to access deeper sections of the config and then deleting the last specified key.
         """
         if len(args) < 1:
-            raise ValueError("Config.delete() requires at least one positional argument")
+            raise BadRequest("Config.delete() requires at least one positional argument")
 
         config_data = {}
         try:

ibm_watsonx_orchestrate/cli/init_helper.py

@@ -4,6 +4,7 @@ from typing import Optional
 from rich import print as pprint
 from dotenv import dotenv_values
 import typer
+import sys
 
 from ibm_watsonx_orchestrate.cli.config import Config, PYTHON_REGISTRY_HEADER, \
     PYTHON_REGISTRY_TEST_PACKAGE_VERSION_OVERRIDE_OPT
@@ -29,7 +30,6 @@ def version_callback(checkVersion: bool=True):
 
         raise typer.Exit()
 
-    
 
 def init_callback(
     ctx: typer.Context,
@@ -38,6 +38,15 @@ def init_callback(
       "--version",
       help="Show the installed version of the ADK and Developer Edition Tags",
       callback=version_callback
+    ),
+    debug: Optional[bool] = typer.Option(
+        False,
+        "--debug",
+        help="Enable debug mode"
     )
 ):
+    if debug:
+        sys.tracebacklimit = 40
+    else:
+        sys.tracebacklimit = 0
     pass

ibm_watsonx_orchestrate/cli/main.py

@@ -1,4 +1,6 @@
+
 import typer
+import sys
 
 from ibm_watsonx_orchestrate.cli.commands.connections.connections_command import connections_app
 from ibm_watsonx_orchestrate.cli.commands.login.login_command import login_app
@@ -13,6 +15,7 @@ from ibm_watsonx_orchestrate.cli.commands.channels.channels_command import chann
 from ibm_watsonx_orchestrate.cli.commands.knowledge_bases.knowledge_bases_command import knowledge_bases_app
 from ibm_watsonx_orchestrate.cli.commands.toolkit.toolkit_command import toolkits_app
 from ibm_watsonx_orchestrate.cli.commands.evaluations.evaluations_command import evaluation_app
+from ibm_watsonx_orchestrate.cli.commands.copilot.copilot_command import copilot_app
 from ibm_watsonx_orchestrate.cli.init_helper import init_callback
 
 import urllib3
@@ -24,6 +27,7 @@ app = typer.Typer(
     pretty_exceptions_enable=False,
     callback=init_callback
 )
+
 app.add_typer(login_app)
 app.add_typer(environment_app, name="env", help='Add, remove, or select the activate env other commands will interact with (either your local server or a production instance)')
 app.add_typer(agents_app, name="agents", help='Interact with the agents in your active env')
@@ -36,6 +40,7 @@ app.add_typer(chat_app, name="chat", help='Launch the chat ui for your local Dev
 app.add_typer(models_app, name="models", help='List the available large language models (llms) that can be used in your agent definitions')
 app.add_typer(channel_app, name="channels", help="Configure channels where your agent can exist on (such as embedded webchat)")
 app.add_typer(evaluation_app, name="evaluations", help='Evaluate the performance of your agents in your active env')
+app.add_typer(copilot_app, name="copilot", help='Access AI powered assistance to help refine your agents')
 app.add_typer(settings_app, name="settings", help='Configure the settings for your active env')
 
 if __name__ == "__main__":

ibm_watsonx_orchestrate/client/base_api_client.py

@@ -3,6 +3,7 @@ import json
 import requests
 from abc import ABC, abstractmethod
 from ibm_cloud_sdk_core.authenticators import MCSPAuthenticator
+from typing_extensions import List
 
 
 class ClientAPIException(requests.HTTPError):
@@ -62,6 +63,17 @@ class BaseAPIClient:
         self._check_response(response)
         return response.json() if response.text else {}
     
+    def _post_nd_json(self, path: str, data: dict = None, files: dict = None) -> List[dict]:
+        url = f"{self.base_url}{path}"
+        response = requests.post(url, headers=self._get_headers(), json=data, files=files)
+        self._check_response(response)
+
+        res = []
+        if response.text:
+            for line in response.text.splitlines():
+                res.append(json.loads(line))
+        return res
+    
     def _post_form_data(self, path: str, data: dict = None, files: dict = None) -> dict:
         url = f"{self.base_url}{path}"
         # Use data argument instead of json so data is encoded as application/x-www-form-urlencoded

ibm_watsonx_orchestrate/client/copilot/cpe/copilot_cpe_client.py

@@ -0,0 +1,67 @@
+from typing import Dict, Any
+from uuid import uuid4
+
+from ibm_watsonx_orchestrate.client.base_api_client import BaseAPIClient
+
+
+class CPEClient(BaseAPIClient):
+    """
+    Client to handle CRUD operations for Conversational Prompt Engineering Service
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.chat_id = str(uuid4())
+        super().__init__(*args, **kwargs)
+        self.base_url = kwargs.get("base_url", self.base_url)
+        self.chat_model_name = 'llama-3-3-70b-instruct'
+
+    def _get_headers(self) -> dict:
+        return {
+            "chat_id": self.chat_id
+        }
+
+
+    def submit_pre_cpe_chat(self, user_message: str | None =None, tools: Dict[str, Any] = None, agents: Dict[str, Any] = None) -> dict:
+        payload = {
+            "message": user_message,
+            "tools": tools,
+            "agents": agents,
+            "chat_id": self.chat_id,
+            "chat_model_name": self.chat_model_name
+        }
+
+        response = self._post_nd_json("/wxo-cpe/create-agent", data=payload)
+
+        if response:
+            return response[-1]
+
+
+    def init_with_context(self, model: str | None = None, context_data: Dict[str, Any] = None) -> dict:
+        payload = {
+            "context_data": context_data,
+            "chat_id": self.chat_id
+        }
+
+        if model:
+            payload["target_model_name"] = model
+
+        response = self._post_nd_json("/wxo-cpe/init_cpe_from_wxo", data=payload)
+
+        if response:
+            return response[-1]
+
+
+    def invoke(self, prompt: str, model: str | None = None, context_data: Dict[str, Any] = None) -> dict:
+        payload = {
+            "prompt": prompt,
+            "context_data": context_data,
+            "chat_id": self.chat_id
+        }
+
+        if model:
+            payload["target_model_name"] = model
+
+        response = self._post_nd_json("/wxo-cpe/invoke", data=payload)
+
+        if response:
+            return response[-1]

ibm_watsonx_orchestrate/client/knowledge_bases/knowledge_base_client.py

@@ -1,4 +1,4 @@
-from ibm_watsonx_orchestrate.client.base_api_client import BaseAPIClient
+from ibm_watsonx_orchestrate.client.base_api_client import BaseAPIClient, ClientAPIException
 import json
 from typing_extensions import List
 from ibm_watsonx_orchestrate.client.utils import is_local_dev

ibm_watsonx_orchestrate/client/local_service_instance.py

@@ -2,6 +2,8 @@ from ibm_watsonx_orchestrate.client.base_service_instance import BaseServiceInst
 import logging
 import requests
 from ibm_watsonx_orchestrate.client.credentials import Credentials
+import json
+import base64
 
 logger = logging.getLogger(__name__)
 
@@ -11,7 +13,7 @@ DEFAULT_TENANT = {
     "tags": ["test"]
 }
 
-DEFAULT_USER = {"username": "wxo.archer@ibm.com", "password": "watsonx"}
+DEFAULT_USER = json.loads(base64.b64decode('eyJ1c2VybmFtZSI6ICJ3eG8uYXJjaGVyQGlibS5jb20iLCJwYXNzd29yZCI6ICJ3YXRzb254In0='))
 DEFAULT_LOCAL_SERVICE_URL = "http://localhost:4321"
 DEFAULT_LOCAL_AUTH_ENDPOINT = f"{DEFAULT_LOCAL_SERVICE_URL}/api/v1/auth/token"
 DEFAULT_LOCAL_TENANT_URL = f"{DEFAULT_LOCAL_SERVICE_URL}/api/v1/tenants"

ibm_watsonx_orchestrate/client/service_instance.py

@@ -6,6 +6,7 @@
 from __future__ import annotations
 
 from ibm_cloud_sdk_core.authenticators import MCSPAuthenticator 
+from ibm_cloud_sdk_core.authenticators import MCSPV2Authenticator
 from ibm_cloud_sdk_core.authenticators import IAMAuthenticator
 from ibm_cloud_sdk_core.authenticators import CloudPakForDataAuthenticator
 
@@ -51,24 +52,47 @@ class ServiceInstance(BaseServiceInstance):
     def _create_token(self) -> str:
         if not self._credentials.auth_type:
             if ".cloud.ibm.com" in self._credentials.url:
-                logger.warning("Using IBM IAM Auth Type. If this is incorrect please use the '--type' flag to explicitly choose one of 'ibm_iam' or 'mcsp' or 'cpd")
+                logger.warning("Using IBM IAM Auth Type. If this is incorrect please use the '--type' flag to explicitly choose one of 'mcsp', 'mcsp_v1', 'mcsp_v2' or 'cpd' ")
                 return self._authenticate(EnvironmentAuthType.IBM_CLOUD_IAM)
             elif is_cpd_env(self._credentials.url):
-                logger.warning("Using CPD Auth Type. If this is incorrect please use the '--type' flag to explicitly choose one of 'ibm_iam' or 'mcsp' or 'cpd")
+                logger.warning("Using CPD Auth Type. If this is incorrect please use the '--type' flag to explicitly choose one of 'ibm_iam', 'mcsp', 'mcsp_v1' or 'mcsp_v2' ")
                 return self._authenticate(EnvironmentAuthType.CPD)
             else:
-                logger.warning("Using MCSP Auth Type. If this is incorrect please use the '--type' flag to explicitly choose one of 'ibm_iam' or 'mcsp' or 'cpd' ")
-                return self._authenticate(EnvironmentAuthType.MCSP)
+                logger.warning("Using MCSP Auth Type. If this is incorrect please use the '--type' flag to explicitly choose one of 'ibm_iam', 'mcsp_v1', 'mcsp_v2' or 'cpd' ")
+                try:
+                    return self._authenticate(EnvironmentAuthType.MCSP_V1)
+                except:
+                    return self._authenticate(EnvironmentAuthType.MCSP_V2)
+        auth_type = self._credentials.auth_type.lower()
+        if auth_type == "mcsp":
+            try:
+                return self._authenticate(EnvironmentAuthType.MCSP_V1)
+            except:
+                return self._authenticate(EnvironmentAuthType.MCSP_V2)
+        elif auth_type == "mcsp_v1":
+            return self._authenticate(EnvironmentAuthType.MCSP_V1)
+        elif auth_type == "mcsp_v2":
+            return self._authenticate(EnvironmentAuthType.MCSP_V2)
         else:
-            return self._authenticate(self._credentials.auth_type)
+            return self._authenticate(auth_type)
 
     def _authenticate(self, auth_type: str) -> str:
         """Handles authentication based on the auth_type."""
         try:
             match auth_type:
-                case EnvironmentAuthType.MCSP:
+                case EnvironmentAuthType.MCSP | EnvironmentAuthType.MCSP_V1:
                     url = self._credentials.iam_url if self._credentials.iam_url is not None else "https://iam.platform.saas.ibm.com"
                     authenticator = MCSPAuthenticator(apikey=self._credentials.api_key, url=url)
+                case EnvironmentAuthType.MCSP_V2:
+                    url = self._credentials.iam_url if self._credentials.iam_url is not None else "https://account-iam.platform.saas.ibm.com"
+                    wxo_url = self._credentials.url
+                    instance_id = wxo_url.split("instances/")[1]
+                    authenticator = MCSPV2Authenticator(
+                        apikey=self._credentials.api_key, 
+                        url=url, 
+                        scope_collection_type="services", 
+                        scope_id=instance_id
+                    )
                 case EnvironmentAuthType.IBM_CLOUD_IAM:
                     authenticator = IAMAuthenticator(apikey=self._credentials.api_key, url=self._credentials.iam_url)
                 case EnvironmentAuthType.CPD:
@@ -100,8 +124,10 @@ class ServiceInstance(BaseServiceInstance):
                     raise ClientError(f"Unsupported authentication type: {auth_type}")
 
             return authenticator.token_manager.get_token()
+
         except Exception as e:
-            raise ClientError(f"Error getting {auth_type.upper()} Token", e)
+            raise ClientError(f"Error getting {auth_type.upper()} Token", logg_messages=False)
+
 
     
     def _is_token_refresh_possible(self) -> bool: