ibm-watsonx-orchestrate 1.6.0b0__py3-none-any.whl → 1.6.1__py3-none-any.whl

ibm_watsonx_orchestrate/cli/commands/tools/tools_controller.py

@@ -24,6 +24,7 @@ from rich.console import Console
 from rich.panel import Panel
 
 from ibm_watsonx_orchestrate.agent_builder.tools import BaseTool, ToolSpec
+from ibm_watsonx_orchestrate.agent_builder.tools.flow_tool import create_flow_json_tool
 from ibm_watsonx_orchestrate.agent_builder.tools.openapi_tool import create_openapi_json_tools_from_uri,create_openapi_json_tools_from_content
 from ibm_watsonx_orchestrate.cli.commands.models.models_controller import ModelHighlighter
 from ibm_watsonx_orchestrate.cli.commands.tools.types import RegistryType
@@ -38,10 +39,9 @@ from ibm_watsonx_orchestrate.client.tools.tool_client import ToolClient
 from ibm_watsonx_orchestrate.client.toolkit.toolkit_client import ToolKitClient
 from ibm_watsonx_orchestrate.client.connections import get_connections_client, get_connection_type
 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.client.tools.tempus_client import TempusClient
-from ibm_watsonx_orchestrate.flow_builder.utils import import_flow_model
 
 from  ibm_watsonx_orchestrate import __version__
 
@@ -57,6 +57,12 @@ class ToolKind(str, Enum):
     flow = "flow"
     # skill = "skill"
 
+def _get_connection_environments() -> List[ConnectionEnvironment]:
+    if is_local_dev():
+        return [ConnectionEnvironment.DRAFT]
+    else:
+        return [env.value for env in ConnectionEnvironment]
+
 def validate_app_ids(kind: ToolKind, **args) -> None:
     app_ids = args.get("app_id")
     if not app_ids:
@@ -71,7 +77,14 @@ def validate_app_ids(kind: ToolKind, **args) -> None:
     connections_client = get_connections_client()
 
     imported_connections_list = connections_client.list()
-    imported_connections = {conn.app_id:conn for conn in imported_connections_list}
+    imported_connections = {}
+    for conn in imported_connections_list:
+        app_id = conn.app_id
+        conn_env = conn.environment
+        if app_id in imported_connections:
+            imported_connections[app_id][conn_env] = conn
+        else:
+            imported_connections[app_id] = {conn_env: conn}
 
     for app_id in app_ids:
         if kind == ToolKind.python:
@@ -89,9 +102,29 @@ def validate_app_ids(kind: ToolKind, **args) -> None:
         if app_id not in imported_connections:
             logger.warning(f"No connection found for provided app-id '{app_id}'. Please create the connection using `orchestrate connections add`")
         else:
-            if kind == ToolKind.openapi and imported_connections.get(app_id).security_scheme == ConnectionSecurityScheme.KEY_VALUE:
-                logger.error(f"Key value application connections can not be bound to an openapi tool")
-                exit(1)
+            # Validate that the connection is not key_value when the tool in openapi
+            if kind != ToolKind.openapi:
+                continue
+
+            environments = _get_connection_environments()
+
+            imported_connection = imported_connections.get(app_id)
+
+            for conn_environment in environments:
+                conn = imported_connection.get(conn_environment)
+
+                if conn is None or conn.security_scheme is None:
+                    message = f"Connection '{app_id}' is not configured in the '{conn_environment}' environment."
+                    if conn_environment == ConnectionEnvironment.DRAFT:
+                        logger.error(message)
+                        sys.exit(1)
+                    else:
+                        logger.warning(message + " If you deploy this tool without setting the live configuration the tool will error during execution.")
+                    continue
+
+                if conn.security_scheme == ConnectionSecurityScheme.KEY_VALUE:
+                    logger.error(f"Key value application connections can not be bound to an openapi tool")
+                    exit(1)
 
 def validate_params(kind: ToolKind, **args) -> None:
     if kind in {"openapi", "python"} and args["file"] is None:
@@ -157,7 +190,14 @@ def validate_python_connections(tool: BaseTool):
 
     provided_connections = list(connections.keys()) if connections else []
     imported_connections_list = connections_client.list()
-    imported_connections = {conn.connection_id:conn for conn in imported_connections_list}
+    imported_connections = {}
+    for conn in imported_connections_list:
+        conn_id = conn.connection_id
+        conn_env = conn.environment
+        if conn_id in imported_connections:
+            imported_connections[conn_id][conn_env] = conn
+        else:
+            imported_connections[conn_id] = {conn_env: conn}
 
     validation_failed = False
 
@@ -186,15 +226,30 @@ def validate_python_connections(tool: BaseTool):
             
         connection_id = connections.get(sanatized_expected_tool_app_id)
         imported_connection = imported_connections.get(connection_id)
-        imported_connection_auth_type = get_connection_type(security_scheme=imported_connection.security_scheme, auth_type=imported_connection.auth_type)
 
         if connection_id and not imported_connection:
             logger.error(f"The expected connection id '{connection_id}' does not match any known connection. This is likely caused by the connection being deleted. Please rec-reate the connection and re-import the tool")
             validation_failed = True
+        
+        environments = _get_connection_environments()
+
+        for conn_environment in environments:
+            conn = imported_connection.get(conn_environment)
+            conn_identifier = conn.app_id if conn is not None else connection_id
+            if conn is None or conn.security_scheme is None:
+                message = f"Connection '{conn_identifier}' is not configured in the '{conn_environment}' environment."
+                if conn_environment == ConnectionEnvironment.DRAFT:
+                    logger.error(message)
+                    sys.exit(1)
+                else:
+                    logger.warning(message + " If you deploy this tool without setting the live configuration the tool will error during execution.")
+                continue
 
-        if imported_connection and len(expected_tool_conn_types) and imported_connection_auth_type not in expected_tool_conn_types:
-            logger.error(f"The app-id '{imported_connection.app_id}' is of type '{imported_connection_auth_type.value}'. The tool '{tool.__tool_spec__.name}' accepts connections of the following types '{', '.join(expected_tool_conn_types)}'. Use `orchestrate connections list` to view current connections and use `orchestrate connections add` to create the relevent connection")
-            validation_failed = True
+            imported_connection_auth_type = get_connection_type(security_scheme=conn.security_scheme, auth_type=conn.auth_type)
+
+            if conn and len(expected_tool_conn_types) and imported_connection_auth_type not in expected_tool_conn_types:
+                logger.error(f"The app-id '{conn.app_id}' is of type '{imported_connection_auth_type.value}' in the '{conn_environment}' environment. The tool '{tool.__tool_spec__.name}' accepts connections of the following types '{', '.join(expected_tool_conn_types)}'. Use `orchestrate connections list` to view current connections and use `orchestrate connections add` to create the relevent connection")
+                validation_failed = True
 
     if validation_failed:
         exit(1)
@@ -345,17 +400,12 @@ 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. To get a flow's current status, ensure [bold]both this tools and the one you are importing are added to your agent[/bold] to retrieve the flow output. 
-- Include additional instructions in your agent to call the [bold green]get_flow_status[/bold green] tool to retrieve the flow output. For example: [green]"If you get an instance_id, use the tool get_flow_status to retrieve the current status of a flow."[/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]. 
 
     """
 
     console.print(Panel(message,  title="[bold blue]Flow tool support information[/bold blue]", border_style="bright_blue"))
    
-
-    if not is_local_dev():
-        raise typer.BadParameter(f"Flow tools are only supported in local environment.")
-
     model = None
     
     # Load the Flow JSON model from the file
@@ -422,7 +472,16 @@ The [bold]flow tool[/bold] is being imported from [green]`{file}`[/green].
     except Exception as e:
         raise typer.BadParameter(f"Failed to load model from file {file}: {e}")
     
-    return await import_flow_model(model)
+    tool = create_flow_json_tool(name=model["spec"]["name"],
+                                 description=model["spec"]["description"], 
+                                 permission="read_only", 
+                                 flow_model=model)   
+    
+    tools = import_flow_support_tools()
+    
+    tools.append(tool)
+
+    return tools
 
 
 async def import_openapi_tool(file: str, connection_id: str) -> List[BaseTool]:
@@ -503,7 +562,20 @@ class ToolsController:
 
     def list_tools(self, verbose=False):
         response = self.get_client().get()
-        tool_specs = [ToolSpec.model_validate(tool) for tool in response]
+        tool_specs = []
+        parse_errors = []
+
+        for tool in response:
+            try:
+                tool_specs.append(ToolSpec.model_validate(tool))
+            except Exception as e:
+                name = tool.get('name', None)
+                parse_errors.append([
+                    f"Tool '{name}' could not be parsed",
+                    json.dumps(tool),
+                    e
+                ])
+
         tools = [BaseTool(spec=spec) for spec in tool_specs]
 
         if verbose:
@@ -514,9 +586,16 @@ class ToolsController:
             rich.print(JSON(json.dumps(tools_list, indent=4)))
         else:
             table = rich.table.Table(show_header=True, header_style="bold white", show_lines=True)
-            columns = ["Name", "Description", "Permission", "Type", "Toolkit", "App ID"]
-            for column in columns:
-                table.add_column(column)
+            column_args = {
+                "Name": {"overflow": "fold"},
+                "Description": {},
+                "Permission": {}, 
+                "Type": {}, 
+                "Toolkit": {}, 
+                "App ID": {"overflow": "fold"}
+            }
+            for column in column_args:
+                table.add_column(column,**column_args[column])
 
             connections_client = get_connections_client()
             connections = connections_client.list()
@@ -558,6 +637,8 @@ class ToolsController:
                         tool_type=ToolKind.openapi
                 elif tool_binding.mcp is not None:
                         tool_type=ToolKind.mcp
+                elif tool_binding.flow is not None:
+                        tool_type=ToolKind.flow        
                 else:
                         tool_type="Unknown"
                 
@@ -583,6 +664,10 @@ class ToolsController:
 
             rich.print(table)
 
+            for error in parse_errors:
+                for l in error:
+                    logger.error(l)
+
     def get_all_tools(self) -> dict:
         return {entry["name"]: entry["id"] for entry in self.get_client().get()}
 

ibm_watsonx_orchestrate/client/agents/agent_client.py

@@ -3,6 +3,74 @@ 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
@@ -17,14 +85,14 @@ class AgentClient(BaseAPIClient):
 
 
     def create(self, payload: dict) -> AgentUpsertResponse:
-        response = self._post(self.base_endpoint, data=payload)
+        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(f"{self.base_endpoint}?include_hidden=true")
+        return transform_agents_to_flat_agent_spec(self._get(f"{self.base_endpoint}?include_hidden=true"))
 
     def update(self, agent_id: str, data: dict) -> AgentUpsertResponse:
-        response = self._patch(f"{self.base_endpoint}/{agent_id}", data=data)
+        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:
@@ -35,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)}&include_hidden=true")
+        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:
@@ -51,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)}&include_hidden=true")
+        return transform_agents_to_flat_agent_spec(self._get(f"{self.base_endpoint}?{'&'.join(formatted_agent_ids)}&include_hidden=true"))
     

ibm_watsonx_orchestrate/client/base_api_client.py

@@ -36,6 +36,8 @@ class BaseAPIClient:
 
         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,7 +48,6 @@ 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, verify=self.verify)
         self._check_response(response)

ibm_watsonx_orchestrate/client/connections/connections_client.py

@@ -1,11 +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
+from ibm_watsonx_orchestrate.client.utils import is_cpd_env, is_local_dev
 
 import logging
 logger = logging.getLogger(__name__)
@@ -42,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
     """
@@ -77,6 +84,8 @@ class ConnectionsClient(BaseAPIClient):
                 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")
@@ -107,25 +116,25 @@ 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:
+            if use_app_credentials:
                 path = (
                     f"/connections/applications/{app_id}/credentials?env={env}"
                     if is_cpd_env(self.base_url)
@@ -146,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")

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/orchestrate"
         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/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/service_instance.py

@@ -51,13 +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 'mscp' or 'cpd")
+                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 'mscp' or 'cpd")
+                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 'mscp' or 'cpd' ")
+                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)

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

@@ -47,6 +47,16 @@ 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