ibm-watsonx-orchestrate 1.5.0b1__py3-none-any.whl → 1.6.0__py3-none-any.whl

ibm_watsonx_orchestrate/client/agents/agent_client.py

@@ -1,7 +1,79 @@
 from ibm_watsonx_orchestrate.client.base_api_client import BaseAPIClient, ClientAPIException
-from typing_extensions import List
+from typing_extensions import List, Optional
 from ibm_watsonx_orchestrate.client.utils import is_local_dev
+from pydantic import BaseModel
 
+def transform_agents_from_flat_agent_spec(agents: dict | list[dict] ) -> dict | list[dict]:
+    if isinstance(agents,list):
+        new_agents = []
+        for agent in agents:
+            new_agents.append(_transform_agent_from_flat_agent_spec(agent))
+        agents = new_agents
+    else:
+        agents = _transform_agent_from_flat_agent_spec(agents)
+    
+    return agents
+
+
+def _transform_agent_from_flat_agent_spec(agent_spec: dict ) -> dict:
+    transformed = {"additional_properties": {}}
+    for key,value in agent_spec.items():
+        if key == "starter_prompts":
+            if value:
+                value.pop("is_default_prompts",None)
+                value["customize"] = value.pop("prompts", [])
+
+            transformed["additional_properties"] |= { key: value }
+            
+        elif key == "welcome_content":
+            if value:
+                value.pop("is_default_message", None)
+
+            transformed["additional_properties"] |= { key: value }
+
+        else:
+            transformed |= { key: value }
+
+    return transformed
+
+def transform_agents_to_flat_agent_spec(agents: dict | list[dict] ) -> dict | list[dict]:
+    if isinstance(agents,list):
+        new_agents = []
+        for agent in agents:
+            new_agents.append(_transform_agent_to_flat_agent_spec(agent))
+        agents = new_agents
+    else:
+        agents = _transform_agent_to_flat_agent_spec(agents)
+
+    return agents
+
+def _transform_agent_to_flat_agent_spec(agent_spec: dict ) -> dict:
+    additional_properties = agent_spec.get("additional_properties", None)
+    if not additional_properties:
+        return agent_spec
+    
+    transformed = agent_spec
+    for key,value in additional_properties.items():
+        if key == "starter_prompts":
+            if value:
+                value["is_default_prompts"] = False
+                value["prompts"] = value.pop("customize", [])
+
+            transformed[key] = value
+            
+        elif key == "welcome_content":
+            if value:
+             value["is_default_message"] = False
+            
+            transformed[key] = value
+            
+    transformed.pop("additional_properties",None)
+
+    return transformed
+
+class AgentUpsertResponse(BaseModel):
+    id: Optional[str] = None
+    warning: Optional[str] = None
 
 class AgentClient(BaseAPIClient):
     """
@@ -12,14 +84,16 @@ class AgentClient(BaseAPIClient):
         self.base_endpoint = "/orchestrate/agents" if is_local_dev(self.base_url) else "/agents"
 
 
-    def create(self, payload: dict) -> dict:
-        return self._post(self.base_endpoint, data=payload)
+    def create(self, payload: dict) -> AgentUpsertResponse:
+        response = self._post(self.base_endpoint, data=transform_agents_from_flat_agent_spec(payload))
+        return AgentUpsertResponse.model_validate(response)
 
     def get(self) -> dict:
-        return self._get(self.base_endpoint)
+        return transform_agents_to_flat_agent_spec(self._get(f"{self.base_endpoint}?include_hidden=true"))
 
-    def update(self, agent_id: str, data: dict) -> dict:
-        return self._patch(f"{self.base_endpoint}/{agent_id}", data=data)
+    def update(self, agent_id: str, data: dict) -> AgentUpsertResponse:
+        response = self._patch(f"{self.base_endpoint}/{agent_id}", data=transform_agents_from_flat_agent_spec(data))
+        return AgentUpsertResponse.model_validate(response)
 
     def delete(self, agent_id: str) -> dict:
         return self._delete(f"{self.base_endpoint}/{agent_id}")
@@ -29,14 +103,14 @@ class AgentClient(BaseAPIClient):
 
     def get_drafts_by_names(self, agent_names: List[str]) -> List[dict]:
         formatted_agent_names = [f"names={x}" for x  in agent_names]
-        return self._get(f"{self.base_endpoint}?{'&'.join(formatted_agent_names)}")
+        return transform_agents_to_flat_agent_spec(self._get(f"{self.base_endpoint}?{'&'.join(formatted_agent_names)}&include_hidden=true"))
     
     def get_draft_by_id(self, agent_id: str) -> List[dict]:
         if agent_id is None:
             return ""
         else:
             try:
-                agent = self._get(f"{self.base_endpoint}/{agent_id}")
+                agent = transform_agents_to_flat_agent_spec(self._get(f"{self.base_endpoint}/{agent_id}"))
                 return agent
             except ClientAPIException as e:
                 if e.response.status_code == 404 and "not found with the given name" in e.response.text:
@@ -45,5 +119,5 @@ class AgentClient(BaseAPIClient):
     
     def get_drafts_by_ids(self, agent_ids: List[str]) -> List[dict]:
         formatted_agent_ids = [f"ids={x}" for x  in agent_ids]
-        return self._get(f"{self.base_endpoint}?{'&'.join(formatted_agent_ids)}")
+        return transform_agents_to_flat_agent_spec(self._get(f"{self.base_endpoint}?{'&'.join(formatted_agent_ids)}&include_hidden=true"))
     

ibm_watsonx_orchestrate/client/agents/assistant_agent_client.py

@@ -10,7 +10,7 @@ class AssistantAgentClient(BaseAPIClient):
         return self._post("/assistants/watsonx", data=payload)
 
     def get(self) -> dict:
-        return self._get("/assistants/watsonx")
+        return self._get("/assistants/watsonx?include_hidden=true")
 
     def update(self, agent_id: str, data: dict) -> dict:
         return self._patch(f"/assistants/watsonx/{agent_id}", data=data)
@@ -23,7 +23,7 @@ class AssistantAgentClient(BaseAPIClient):
 
     def get_drafts_by_names(self, agent_names: List[str]) -> List[dict]:
         formatted_agent_names = [f"names={x}" for x  in agent_names]
-        return self._get(f"/assistants/watsonx?{'&'.join(formatted_agent_names)}")
+        return self._get(f"/assistants/watsonx?{'&'.join(formatted_agent_names)}&include_hidden=true")
     
     def get_draft_by_id(self, agent_id: str) -> dict | str:
         if agent_id is None:
@@ -39,4 +39,4 @@ class AssistantAgentClient(BaseAPIClient):
     
     def get_drafts_by_ids(self, agent_ids: List[str]) -> List[dict]:
         formatted_agent_ids = [f"ids={x}" for x  in agent_ids]
-        return self._get(f"/assistants/watsonx?{'&'.join(formatted_agent_ids)}")
+        return self._get(f"/assistants/watsonx?{'&'.join(formatted_agent_ids)}&include_hidden=true")

ibm_watsonx_orchestrate/client/agents/external_agent_client.py

@@ -10,7 +10,7 @@ class ExternalAgentClient(BaseAPIClient):
         return self._post("/agents/external-chat", data=payload)
 
     def get(self) -> dict:
-        return self._get("/agents/external-chat")
+        return self._get("/agents/external-chat?include_hidden=true")
 
     def update(self, agent_id: str, data: dict) -> dict:
         return self._patch(f"/agents/external-chat/{agent_id}", data=data)
@@ -39,4 +39,4 @@ class ExternalAgentClient(BaseAPIClient):
 
     def get_drafts_by_ids(self, agent_ids: List[str]) -> List[dict]:
         formatted_agent_ids = [f"ids={x}" for x  in agent_ids]
-        return self._get(f"/agents/external-chat?{'&'.join(formatted_agent_ids)}")
+        return self._get(f"/agents/external-chat?{'&'.join(formatted_agent_ids)}&include_hidden=true")

ibm_watsonx_orchestrate/client/base_api_client.py

@@ -24,8 +24,7 @@ class ClientAPIException(requests.HTTPError):
 
 
 class BaseAPIClient:
-
-    def __init__(self, base_url: str, api_key: str = None, is_local: bool = False, authenticator: MCSPAuthenticator = None):
+    def __init__(self, base_url: str, api_key: str = None, is_local: bool = False, verify: str = None, authenticator: MCSPAuthenticator = None):
         self.base_url = base_url.rstrip("/")  # remove trailing slash
         self.api_key = api_key
         self.authenticator = authenticator
@@ -33,9 +32,12 @@ class BaseAPIClient:
         # api path can be re-written by api proxy when deployed
         # TO-DO: re-visit this when shipping to production
         self.is_local = is_local
+        self.verify = verify
 
         if not self.is_local:
             self.base_url = f"{self.base_url}/v1/orchestrate"
+        else:
+            self.base_url = f"{self.base_url}/v1"
 
     def _get_headers(self) -> dict:
         headers = {}
@@ -46,9 +48,8 @@ class BaseAPIClient:
         return headers
 
     def _get(self, path: str, params: dict = None, data=None, return_raw=False) -> dict:
-
         url = f"{self.base_url}{path}"
-        response = requests.get(url, headers=self._get_headers(), params=params, data=data)
+        response = requests.get(url, headers=self._get_headers(), params=params, data=data, verify=self.verify)
         self._check_response(response)
         if not return_raw:
             return response.json()
@@ -57,39 +58,39 @@ class BaseAPIClient:
 
     def _post(self, path: str, data: dict = None, files: dict = None) -> dict:
         url = f"{self.base_url}{path}"
-        response = requests.post(url, headers=self._get_headers(), json=data, files=files)
+        response = requests.post(url, headers=self._get_headers(), json=data, files=files, verify=self.verify)
         self._check_response(response)
         return response.json() if response.text else {}
     
     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
-        response = requests.post(url, headers=self._get_headers(), data=data, files=files)
+        response = requests.post(url, headers=self._get_headers(), data=data, files=files, verify=self.verify)
         self._check_response(response)
         return response.json() if response.text else {}
 
     def _put(self, path: str, data: dict = None) -> dict:
 
         url = f"{self.base_url}{path}"
-        response = requests.put(url, headers=self._get_headers(), json=data)
+        response = requests.put(url, headers=self._get_headers(), json=data, verify=self.verify)
         self._check_response(response)
         return response.json() if response.text else {}
 
     def _patch(self, path: str, data: dict = None) -> dict:
         url = f"{self.base_url}{path}"
-        response = requests.patch(url, headers=self._get_headers(), json=data)
+        response = requests.patch(url, headers=self._get_headers(), json=data, verify=self.verify)
         self._check_response(response)
         return response.json() if response.text else {}
     
     def _patch_form_data(self, path: str, data: dict = None, files = None) -> dict:
         url = f"{self.base_url}{path}"
-        response = requests.patch(url, headers=self._get_headers(), data=data, files=files)
+        response = requests.patch(url, headers=self._get_headers(), data=data, files=files, verify=self.verify)
         self._check_response(response)
         return response.json() if response.text else {}
 
     def _delete(self, path: str, data=None) -> dict:
         url = f"{self.base_url}{path}"
-        response = requests.delete(url, headers=self._get_headers(), json=data)
+        response = requests.delete(url, headers=self._get_headers(), json=data, verify=self.verify)
         self._check_response(response)
         return response.json() if response.text else {}
 

ibm_watsonx_orchestrate/client/connections/connections_client.py

@@ -1,10 +1,12 @@
 from typing import List
 
+from ibm_cloud_sdk_core.authenticators import MCSPAuthenticator
 from pydantic import BaseModel, ValidationError
 from typing import Optional
 
 from ibm_watsonx_orchestrate.client.base_api_client import BaseAPIClient, ClientAPIException
 from ibm_watsonx_orchestrate.agent_builder.connections.types import ConnectionEnvironment, ConnectionPreference, ConnectionAuthType, ConnectionSecurityScheme, IdpConfigData, AppConfigData, ConnectionType
+from ibm_watsonx_orchestrate.client.utils import is_cpd_env, is_local_dev
 
 import logging
 logger = logging.getLogger(__name__)
@@ -41,6 +43,12 @@ class GetConnectionResponse(BaseModel):
 
 
 class ConnectionsClient(BaseAPIClient):
+    def __init__(self, base_url: str, api_key: str = None, is_local: bool = False, verify: str = None, authenticator: MCSPAuthenticator = None):
+        super(ConnectionsClient, self).__init__(base_url, api_key, is_local, verify, authenticator)
+        if is_local_dev(base_url):
+            self.base_url = f"{base_url.rstrip('/')}/api/v1/orchestrate"
+        else:
+            self.base_url = f"{base_url.rstrip('/')}/v1/orchestrate"
     """
     Client to handle CRUD operations for Connections endpoint
     """
@@ -53,9 +61,14 @@ class ConnectionsClient(BaseAPIClient):
         return self._delete(f"/connections/applications/{app_id}")
 
     # GET /api/v1/connections/applications/{app_id}
-    def get(self, app_id: str) -> GetConnectionResponse:
+    def get(self, app_id: str) -> GetConnectionResponse | None:
         try:
-            return GetConnectionResponse.model_validate(self._get(f"/connections/applications/{app_id}"))
+            path = (
+                f"/connections/applications/{app_id}"
+                if is_cpd_env(self.base_url)
+                else f"/connections/applications?app_id={app_id}"
+            )
+            return GetConnectionResponse.model_validate(self._get(path))
         except ClientAPIException as e:
             if e.response.status_code == 404:
                 return None
@@ -65,7 +78,14 @@ class ConnectionsClient(BaseAPIClient):
     # GET api/v1/connections/applications
     def list(self) -> List[ListConfigsResponse]:
         try:
-            res = self._get(f"/connections/applications")
+            path = (
+                f"/connections/applications"
+                if is_cpd_env(self.base_url)
+                else f"/connections/applications?include_details=true"
+            )
+            res = self._get(path)
+            import json
+            json.dumps(res)
             return [ListConfigsResponse.model_validate(conn) for conn in res.get("applications", [])]
         except ValidationError as e:
             logger.error("Recieved unexpected response from server")
@@ -96,28 +116,38 @@ class ConnectionsClient(BaseAPIClient):
 
     # POST /api/v1/connections/applications/{app_id}/configs/{env}/credentials
     # POST /api/v1/connections/applications/{app_id}/configs/{env}/runtime_credentials
-    def create_credentials(self, app_id: str, env: ConnectionEnvironment, payload: dict, use_sso: bool) -> None:
-        if use_sso:
+    def create_credentials(self, app_id: str, env: ConnectionEnvironment, payload: dict, use_app_credentials: bool) -> None:
+        if use_app_credentials:
             self._post(f"/connections/applications/{app_id}/configs/{env}/credentials", data=payload)
         else:
             self._post(f"/connections/applications/{app_id}/configs/{env}/runtime_credentials", data=payload)
 
     # PATCH /api/v1/connections/applications/{app_id}/configs/{env}/credentials
     # PATCH /api/v1/connections/applications/{app_id}/configs/{env}/runtime_credentials
-    def update_credentials(self, app_id: str, env: ConnectionEnvironment, payload: dict, use_sso: bool) -> None:
-        if use_sso:
+    def update_credentials(self, app_id: str, env: ConnectionEnvironment, payload: dict, use_app_credentials: bool) -> None:
+        if use_app_credentials:
             self._patch(f"/connections/applications/{app_id}/configs/{env}/credentials", data=payload)
         else:
             self._patch(f"/connections/applications/{app_id}/configs/{env}/runtime_credentials", data=payload)
 
     # GET /api/v1/connections/applications/{app_id}/configs/credentials?env={env}
     # GET /api/v1/connections/applications/{app_id}/configs/runtime_credentials?env={env}
-    def get_credentials(self, app_id: str, env: ConnectionEnvironment, use_sso: bool) -> dict:
+    def get_credentials(self, app_id: str, env: ConnectionEnvironment, use_app_credentials: bool) -> dict:
         try:
-            if use_sso:
-                return self._get(f"/connections/applications/{app_id}/credentials?env={env}")
+            if use_app_credentials:
+                path = (
+                    f"/connections/applications/{app_id}/credentials?env={env}"
+                    if is_cpd_env(self.base_url)
+                    else f"/connections/applications/{app_id}/credentials/{env}"
+                )
+                return self._get(path)
             else:
-                return self._get(f"/connections/applications/{app_id}/configs/runtime_credentials?env={env}")
+                path = (
+                    f"/connections/applications/{app_id}/configs/runtime_credentials?env={env}"
+                    if is_cpd_env(self.base_url)
+                    else f"/connections/applications/runtime_credentials?app_id={app_id}&env={env}"
+                )
+                return self._get(path)
         except ClientAPIException as e:
             if e.response.status_code == 404:
                 return None
@@ -125,8 +155,8 @@ class ConnectionsClient(BaseAPIClient):
 
     # DELETE /api/v1/connections/applications/{app_id}/configs/{env}/credentials
     # DELETE /api/v1/connections/applications/{app_id}/configs/{env}/runtime_credentials
-    def delete_credentials(self, app_id: str, env: ConnectionEnvironment, use_sso: bool) -> None:
-        if use_sso:
+    def delete_credentials(self, app_id: str, env: ConnectionEnvironment, use_app_credentials: bool) -> None:
+        if use_app_credentials:
             self._delete(f"/connections/applications/{app_id}/configs/{env}/credentials")
         else:
             self._delete(f"/connections/applications/{app_id}/configs/{env}/runtime_credentials")
@@ -147,7 +177,12 @@ class ConnectionsClient(BaseAPIClient):
         if conn_id is None:
             return ""
         try:
-            app_details = self._get(f"/connections/applications/id/{conn_id}")
+            path = (
+                f"/connections/applications/id/{conn_id}"
+                if is_cpd_env(self.base_url)
+                else f"/connections/applications?connection_id={conn_id}"
+            )
+            app_details = self._get(path)
             return app_details.get("app_id")
         except ClientAPIException as e:
             if e.response.status_code == 404:

ibm_watsonx_orchestrate/client/connections/utils.py

@@ -17,14 +17,16 @@ def _get_connections_manager_url() -> str:
         url_parts = url.split(":")
         url_parts[-1] = str(LOCAL_CONNECTION_MANAGER_PORT)
         url = ":".join(url_parts)
-        url = url + "/api/v1"
         return url
     return None
 
 def get_connections_client() -> ConnectionsClient:
     return instantiate_client(client=ConnectionsClient, url=_get_connections_manager_url())
 
-def get_connection_type(security_scheme: ConnectionSecurityScheme, auth_type: ConnectionAuthType) -> ConnectionType:
+def get_connection_type(security_scheme: ConnectionSecurityScheme, auth_type: ConnectionAuthType) -> ConnectionType | None:
+    if security_scheme is None and auth_type is None:
+        return None
+
     if security_scheme != ConnectionSecurityScheme.OAUTH2:
         return ConnectionType(security_scheme)
     return ConnectionType(auth_type)

ibm_watsonx_orchestrate/client/credentials.py

@@ -31,6 +31,8 @@ class Credentials:
             url: str | None = None,
             iam_url: str | None = None,
             api_key: str | None = None,
+            username: str | None = None,
+            password: str | None = None,
             token: str | None = None,
             verify: str | bool | None = None,
             auth_type: str | None = None,
@@ -39,6 +41,8 @@ class Credentials:
         self.url = url
         self.iam_url = iam_url
         self.api_key = api_key
+        self.username = username
+        self.password = password
         self.token = token
         self.local_global_token = None
         self.verify = verify

ibm_watsonx_orchestrate/client/local_service_instance.py

@@ -14,7 +14,7 @@ DEFAULT_TENANT = {
 DEFAULT_USER = {"username": "wxo.archer@ibm.com", "password": "watsonx"}
 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}/tenants"
+DEFAULT_LOCAL_TENANT_URL = f"{DEFAULT_LOCAL_SERVICE_URL}/api/v1/tenants"
 DEFAULT_LOCAL_TENANT_AUTH_ENDPOINT = "{}/api/v1/auth/token?tenant_id={}"
 
 

ibm_watsonx_orchestrate/client/model_policies/model_policies_client.py

@@ -17,11 +17,11 @@ class ModelPoliciesClient(BaseAPIClient):
     """
     # POST api/v1/model_policy
     def create(self, model: ModelPolicy) -> None:
-        self._post("/model_policy", data=model.model_dump())
+        self._post("/model_policy", data=model.model_dump(exclude_none=True))
     
     # PUT api/v1/model_policy/{model_policy_id}
     def update(self, model_policy_id: str, model: ModelPolicy) -> None:
-        self._put(f"/model_policy/{model_policy_id}", data=model.model_dump())
+        self._put(f"/model_policy/{model_policy_id}", data=model.model_dump(exclude_none=True))
 
     # DELETE api/v1/model_policy/{model_policy_id}
     def delete(self, model_policy_id: str) -> dict:

ibm_watsonx_orchestrate/client/service_instance.py

@@ -7,8 +7,9 @@ from __future__ import annotations
 
 from ibm_cloud_sdk_core.authenticators import MCSPAuthenticator 
 from ibm_cloud_sdk_core.authenticators import IAMAuthenticator
+from ibm_cloud_sdk_core.authenticators import CloudPakForDataAuthenticator
 
-from ibm_watsonx_orchestrate.client.utils import check_token_validity
+from ibm_watsonx_orchestrate.client.utils import check_token_validity, is_cpd_env
 from ibm_watsonx_orchestrate.client.base_service_instance import BaseServiceInstance
 from ibm_watsonx_orchestrate.cli.commands.environment.types import EnvironmentAuthType
 
@@ -16,6 +17,16 @@ from ibm_watsonx_orchestrate.client.client_errors import (
     ClientError,
 )
 
+import logging
+logger = logging.getLogger(__name__)
+
+from ibm_watsonx_orchestrate.cli.config import (
+    Config,
+    CONTEXT_SECTION_HEADER,
+    CONTEXT_ACTIVE_ENV_OPT,
+    ENVIRONMENTS_SECTION_HEADER,
+    ENV_WXO_URL_OPT
+)
 
 class ServiceInstance(BaseServiceInstance):
     """Connect, get details, and check usage of a Watson Machine Learning service instance."""
@@ -40,8 +51,13 @@ 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")
                 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")
+                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)
         else:
             return self._authenticate(self._credentials.auth_type)
@@ -55,6 +71,31 @@ class ServiceInstance(BaseServiceInstance):
                     authenticator = MCSPAuthenticator(apikey=self._credentials.api_key, url=url)
                 case EnvironmentAuthType.IBM_CLOUD_IAM:
                     authenticator = IAMAuthenticator(apikey=self._credentials.api_key, url=self._credentials.iam_url)
+                case EnvironmentAuthType.CPD:
+                    url = ""
+                    if self._credentials.iam_url is not None: 
+                        url = self._credentials.iam_url
+                    else: 
+                        cfg = Config()
+                        env_cfg = cfg.get(ENVIRONMENTS_SECTION_HEADER)
+                        matching_wxo_url = next(
+                            (env_config['wxo_url'] for env_config in env_cfg.values() if 'bypass_ssl' in env_config and 'verify' in env_config),
+                            None
+                        )
+                        base_url = matching_wxo_url.split("/orchestrate")[0]
+                        url = f"{base_url}/icp4d-api"
+
+                    password = self._credentials.password if self._credentials.password is not None else None
+                    api_key = self._credentials.api_key if self._credentials.api_key is not None else None
+                    cpd_password=password if password else None
+                    cpd_apikey=api_key if api_key else None
+                    authenticator = CloudPakForDataAuthenticator(
+                        username=self._credentials.username, 
+                        password=cpd_password, 
+                        apikey=cpd_apikey, 
+                        url=url, 
+                        disable_ssl_verification=True
+                    )
                 case _:
                     raise ClientError(f"Unsupported authentication type: {auth_type}")
 

ibm_watsonx_orchestrate/client/tools/tempus_client.py

@@ -29,12 +29,17 @@ class TempusClient(BaseAPIClient):
             authenticator=authenticator
         )
         
+    def get_tempus_endpoint(self) -> str:
+        """
+        Returns the Tempus endpoint URL
+        """
+        return self.base_url
     def create_update_flow_model(self, flow_id: str, model: dict) -> dict:
-        return self._post(f"/v1/flow-models/{flow_id}", data=model)
+        return self._post(f"/flow-models/{flow_id}", data=model)
     
     def run_flow(self, flow_id: str, input: dict) -> dict:
-        return self._post(f"/v1/flows/{flow_id}/versions/TIP/run", data=input)
+        return self._post(f"/flows/{flow_id}/versions/TIP/run", data=input)
     
     def arun_flow(self, flow_id: str, input: dict) -> dict:
-        return self._post(f"/v1/flows/{flow_id}/versions/TIP/run/async", data=input)
+        return self._post(f"/flows/{flow_id}/versions/TIP/run/async", data=input)
 

ibm_watsonx_orchestrate/client/utils.py

@@ -9,7 +9,9 @@ from ibm_watsonx_orchestrate.cli.config import (
     CONTEXT_SECTION_HEADER,
     CONTEXT_ACTIVE_ENV_OPT,
     ENVIRONMENTS_SECTION_HEADER,
-    ENV_WXO_URL_OPT
+    ENV_WXO_URL_OPT,
+    BYPASS_SSL,
+    VERIFY
 )
 from threading import Lock
 from ibm_watsonx_orchestrate.client.base_api_client import BaseAPIClient
@@ -45,6 +47,21 @@ def is_local_dev(url: str | None = None) -> bool:
 
     return False
 
+def is_ibm_cloud():
+    cfg = Config()
+    active_env = cfg.read(CONTEXT_SECTION_HEADER, CONTEXT_ACTIVE_ENV_OPT)
+    url = cfg.get(ENVIRONMENTS_SECTION_HEADER, active_env, ENV_WXO_URL_OPT)
+
+    if url.__contains__("cloud.ibm.com"):
+        return True
+    return False
+
+
+def is_cpd_env(url: str) -> bool:
+    if url.lower().startswith("https://cpd"):
+        return True
+    return False
+
 def check_token_validity(token: str) -> bool:
     try:
         token_claimset = jwt.decode(token, options={"verify_signature": False})
@@ -65,6 +82,17 @@ def instantiate_client(client: type[T] , url: str | None=None) -> T:
             with open(os.path.join(DEFAULT_CONFIG_FILE_FOLDER, DEFAULT_CONFIG_FILE), "r") as f:
                 config = yaml_safe_load(f)
             active_env = config.get(CONTEXT_SECTION_HEADER, {}).get(CONTEXT_ACTIVE_ENV_OPT)
+            bypass_ssl = (
+                config.get(ENVIRONMENTS_SECTION_HEADER, {})
+                    .get(active_env, {})
+                    .get(BYPASS_SSL, None)
+            )
+
+            verify = (
+                config.get(ENVIRONMENTS_SECTION_HEADER, {})
+                    .get(active_env, {})
+                    .get(VERIFY, None)
+            )
 
             if not url:
                 url = config.get(ENVIRONMENTS_SECTION_HEADER, {}).get(active_env, {}).get(ENV_WXO_URL_OPT)
@@ -86,7 +114,14 @@ def instantiate_client(client: type[T] , url: str | None=None) -> T:
             if not check_token_validity(token):
                 logger.error(f"The token found for environment '{active_env}' is missing or expired. Use `orchestrate env activate {active_env}` to fetch a new one")
                 exit(1)
-            client_instance = client(base_url=url, api_key=token, is_local=is_local_dev(url))
+            is_cpd = is_cpd_env(url)
+            if is_cpd:
+                if bypass_ssl is True:
+                    client_instance = client(base_url=url, api_key=token, is_local=is_local_dev(url), verify=False)
+                elif verify is not None:
+                    client_instance = client(base_url=url, api_key=token, is_local=is_local_dev(url), verify=verify)
+            else:
+                client_instance = client(base_url=url, api_key=token, is_local=is_local_dev(url))
 
         return client_instance
     except FileNotFoundError as e: