ibm-watsonx-orchestrate 1.5.1__py3-none-any.whl → 1.6.0__py3-none-any.whl

ibm_watsonx_orchestrate/cli/commands/models/models_controller.py

@@ -18,7 +18,7 @@ from ibm_watsonx_orchestrate.agent_builder.model_policies.types import ModelPoli
     ModelPolicyRetry, ModelPolicyStrategy, ModelPolicyStrategyMode, ModelPolicyTarget
 from ibm_watsonx_orchestrate.client.models.models_client import ModelsClient
 from ibm_watsonx_orchestrate.agent_builder.models.types import VirtualModel, ProviderConfig, ModelType, ANTHROPIC_DEFAULT_MAX_TOKENS
-from ibm_watsonx_orchestrate.client.utils import instantiate_client
+from ibm_watsonx_orchestrate.client.utils import instantiate_client, is_cpd_env
 from ibm_watsonx_orchestrate.client.connections import get_connection_id, ConnectionType
 
 logger = logging.getLogger(__name__)
@@ -85,6 +85,11 @@ def import_python_policy(file: str) -> List[ModelPolicy]:
             models.append(obj)
     return models
 
+def validate_spec_content(content: dict) -> None:
+    if not content.get("spec_version"):
+        logger.error(f"Field 'spec_version' not provided. Please ensure provided spec conforms to a valid spec format")
+        sys.exit(1)
+
 def parse_model_file(file: str) -> List[VirtualModel]:
     if file.endswith('.yaml') or file.endswith('.yml') or file.endswith(".json"):
         with open(file, 'r') as f:
@@ -92,6 +97,7 @@ def parse_model_file(file: str) -> List[VirtualModel]:
                 content = json.load(f)
             else:
                 content = yaml.load(f, Loader=yaml.SafeLoader)
+        validate_spec_content(content)
         model = create_model_from_spec(spec=content)
         return [model]
     elif file.endswith('.py'):
@@ -107,6 +113,7 @@ def parse_policy_file(file: str) -> List[ModelPolicy]:
                 content = json.load(f)
             else:
                 content = yaml.load(f, Loader=yaml.SafeLoader)
+        validate_spec_content(content)
         policy = create_policy_from_spec(spec=content)
         return [policy]
     elif file.endswith('.py'):
@@ -160,13 +167,15 @@ class ModelsController:
             logger.error("Error: WATSONX_URL is required in the environment.")
             sys.exit(1)
 
-        logger.info("Retrieving virtual-model models list...")
-        virtual_models = models_client.list()
-
-
+        if is_cpd_env(models_client.base_url):
+            virtual_models = []
+            virtual_model_policies = []
+        else:
+            logger.info("Retrieving virtual-model models list...")
+            virtual_models = models_client.list()
 
-        logger.info("Retrieving virtual-policies models list...")
-        virtual_model_policies = model_policies_client.list()
+            logger.info("Retrieving virtual-policies models list...")
+            virtual_model_policies = model_policies_client.list()
 
         logger.info("Retrieving watsonx.ai models list...")
         found_models = _get_wxai_foundational_models()
@@ -382,7 +391,7 @@ class ModelsController:
             mode=strategy,
             on_status_codes=strategy_on_code
         )
-        inner.targets = [ModelPolicyTarget(weight=1, model_name=m) for m in models]
+        inner.targets = [ModelPolicyTarget(model_name=m) for m in models]
         if retry_on_code:
             inner.retry = ModelPolicyRetry(
                 on_status_codes=retry_on_code,

ibm_watsonx_orchestrate/cli/commands/server/server_command.py

@@ -67,23 +67,28 @@ def docker_login(api_key: str, registry_url: str, username:str = "iamapikey") ->
     logger.info("Successfully logged in to Docker.")
 
 def docker_login_by_dev_edition_source(env_dict: dict, source: str) -> None:
-    if not env_dict.get("REGISTRY_URL"):
-        raise ValueError("REGISTRY_URL is not set.")
-    registry_url = env_dict["REGISTRY_URL"].split("/")[0]
-    if source == "internal":
-        iam_api_key = env_dict.get("DOCKER_IAM_KEY")
-        if not iam_api_key:
-            raise ValueError("DOCKER_IAM_KEY is required in the environment file if WO_DEVELOPER_EDITION_SOURCE is set to 'internal'.")
-        docker_login(iam_api_key, registry_url, "iamapikey")
-    elif source == "myibm":
-        wo_entitlement_key = env_dict.get("WO_ENTITLEMENT_KEY")
-        if not wo_entitlement_key:
-            raise ValueError("WO_ENTITLEMENT_KEY is required in the environment file.")
-        docker_login(wo_entitlement_key, registry_url, "cp")
-    elif source == "orchestrate":
-        wo_auth_type = env_dict.get("WO_AUTH_TYPE")
-        api_key, username = get_docker_cred_by_wo_auth_type(env_dict, wo_auth_type)
-        docker_login(api_key, registry_url, username)
+    if env_dict.get('WO_DEVELOPER_EDITION_SKIP_LOGIN', None) == 'true':
+        logger.info('WO_DEVELOPER_EDITION_SKIP_LOGIN is set to true, skipping login.')
+        logger.warning('If the developer edition images are not already pulled this call will fail without first setting WO_DEVELOPER_EDITION_SKIP_LOGIN=false')
+    else:
+        if not env_dict.get("REGISTRY_URL"):
+            raise ValueError("REGISTRY_URL is not set.")
+        registry_url = env_dict["REGISTRY_URL"].split("/")[0]
+        if source == "internal":
+            iam_api_key = env_dict.get("DOCKER_IAM_KEY")
+            if not iam_api_key:
+                raise ValueError("DOCKER_IAM_KEY is required in the environment file if WO_DEVELOPER_EDITION_SOURCE is set to 'internal'.")
+            docker_login(iam_api_key, registry_url, "iamapikey")
+        elif source == "myibm":
+            wo_entitlement_key = env_dict.get("WO_ENTITLEMENT_KEY")
+            if not wo_entitlement_key:
+                raise ValueError("WO_ENTITLEMENT_KEY is required in the environment file.")
+            docker_login(wo_entitlement_key, registry_url, "cp")
+        elif source == "orchestrate":
+            wo_auth_type = env_dict.get("WO_AUTH_TYPE")
+            api_key, username = get_docker_cred_by_wo_auth_type(env_dict, wo_auth_type)
+            docker_login(api_key, registry_url, username)
+
 
 def get_compose_file() -> Path:
     with resources.as_file(
@@ -165,6 +170,8 @@ def get_docker_cred_by_wo_auth_type(env_dict: dict, auth_type: str | None) -> tu
                 auth_type = "ibm_iam"
             elif ".ibm.com" in instance_url:
                 auth_type = "mcsp"
+            elif "https://cpd" in instance_url:
+                auth_type = "cpd"
     
     if auth_type in {"mcsp", "ibm_iam"}:
         wo_api_key = env_dict.get("WO_API_KEY")
@@ -233,6 +240,27 @@ def apply_llm_api_key_defaults(env_dict: dict) -> None:
         env_dict.setdefault("ASSISTANT_EMBEDDINGS_SPACE_ID", space_value)
         env_dict.setdefault("ROUTING_LLM_SPACE_ID", space_value)
 
+def _is_docker_container_running(container_name):
+    ensure_docker_installed()
+    command = [ "docker",
+                "ps",
+                "-f",
+                f"name={container_name}"
+            ]
+    result = subprocess.run(command, env=os.environ, capture_output=True)
+    if container_name in str(result.stdout):
+        return True
+    return False
+
+def _check_exclusive_observibility(langfuse_enabled: bool, ibm_tele_enabled: bool):
+    if langfuse_enabled and ibm_tele_enabled:
+        return False
+    if langfuse_enabled and _is_docker_container_running("docker-frontend-server-1"):
+        return False
+    if ibm_tele_enabled and _is_docker_container_running("docker-langfuse-web-1"):
+        return False
+    return True
+
 def write_merged_env_file(merged_env: dict) -> Path:
     tmp = tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".env")
     with tmp:
@@ -285,7 +313,8 @@ 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) -> None:
+
+def run_compose_lite(final_env_file: Path, experimental_with_langfuse=False, experimental_with_ibm_telemetry=False) -> None:
     compose_path = get_compose_file()
     compose_command = ensure_docker_compose_installed()
     db_tag = read_env_file(final_env_file).get('DBTAG', None)
@@ -317,9 +346,15 @@ def run_compose_lite(final_env_file: Path, experimental_with_langfuse=False) ->
             '--profile',
             'langfuse'
         ]
+    elif experimental_with_ibm_telemetry:
+        command = compose_command + [
+            '--profile',
+            'ibm-telemetry'
+        ]
     else:
         command = compose_command
 
+
     command += [
         "-f", str(compose_path),
         "--env-file", str(final_env_file),
@@ -437,6 +472,9 @@ def run_compose_lite_ui(user_env_file: Path) -> bool:
         # do nothing, as the docker login here is not mandatory
         pass
 
+    # Auto-configure callback IP for async tools
+    merged_env_dict = auto_configure_callback_ip(merged_env_dict)
+
     #These are to removed warning and not used in UI component
     if not 'WATSONX_SPACE_ID' in merged_env_dict:
         merged_env_dict['WATSONX_SPACE_ID']='X'
@@ -614,8 +652,80 @@ def confirm_accepts_license_agreement(accepts_by_argument: bool):
             logger.error('The terms and conditions were not accepted, exiting.')
             exit(1)
 
-
-
+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 
+                            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 
+                            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
+            logger.info(f"Auto-configured CALLBACK_HOST_URL to: {callback_url}")
+        else:
+            # Fallback for localhost
+            callback_url = "http://host.docker.internal:4321"
+            merged_env_dict['CALLBACK_HOST_URL'] = callback_url
+            logger.info(f"Using Docker internal URL: {callback_url}")
+            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")
 def server_start(
@@ -629,6 +739,11 @@ def server_start(
         '--with-langfuse', '-l',
         help='Option to enable Langfuse support.'
     ),
+    experimental_with_ibm_telemetry: bool = typer.Option(
+        False,
+        '--with-ibm-telemetry', '-i',
+        help=''
+    ),
     persist_env_secrets: bool = typer.Option(
         False,
         '--persist-env-secrets', '-p',
@@ -668,9 +783,18 @@ def server_start(
 
     merged_env_dict = apply_server_env_dict_defaults(merged_env_dict)
 
+    # Auto-configure callback IP for async tools
+    merged_env_dict = auto_configure_callback_ip(merged_env_dict)
+    if not _check_exclusive_observibility(experimental_with_langfuse, experimental_with_ibm_telemetry):
+        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.
     if experimental_with_langfuse:
         merged_env_dict['LANGFUSE_ENABLED'] = 'true'
+        
+    if experimental_with_ibm_telemetry:
+        merged_env_dict['USE_IBM_TELEMETRY'] = 'true'
 
     try:
         docker_login_by_dev_edition_source(merged_env_dict, dev_edition_source)
@@ -682,7 +806,9 @@ 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)
+    run_compose_lite(final_env_file=final_env_file, 
+                     experimental_with_langfuse=experimental_with_langfuse,
+                     experimental_with_ibm_telemetry=experimental_with_ibm_telemetry)
 
     run_db_migration()
 

ibm_watsonx_orchestrate/cli/commands/server/types.py

@@ -26,7 +26,8 @@ def _infer_auth_type_from_instance_url(instance_url: str) -> WoAuthType:
           return WoAuthType.IBM_IAM
      if ".ibm.com" in instance_url:
           return WoAuthType.MCSP
-     return WoAuthType.CPD
+     if "https://cpd" in instance_url:
+          return WoAuthType.CPD
 
 
 class WatsonXAIEnvConfig(BaseModel):

ibm_watsonx_orchestrate/cli/commands/toolkit/toolkit_controller.py

@@ -213,9 +213,6 @@ class ToolkitController:
 
     
     def remove_toolkit(self, name: str):
-        if not is_local_dev():
-            logger.error("This functionality is only available for Local Environments")
-            sys.exit(1)
         try:
             client = self.get_client()
             draft_toolkits = client.get_draft_by_name(toolkit_name=name)
@@ -246,9 +243,15 @@ class ToolkitController:
             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", "Kind", "Description", "Tools", "App ID"]
-            for column in columns:
-                table.add_column(column)
+            column_args = {
+                "Name": {"overflow": "fold"},
+                "Kind": {},
+                "Description": {},
+                "Tools": {},
+                "App ID": {"overflow": "fold"}
+            }
+            for column in column_args:
+                table.add_column(column,**column_args[column])
 
             tools_client = instantiate_client(ToolClient)
 

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
@@ -33,15 +34,14 @@ from ibm_watsonx_orchestrate.cli.config import Config, CONTEXT_SECTION_HEADER, C
     PYTHON_REGISTRY_HEADER, PYTHON_REGISTRY_TYPE_OPT, PYTHON_REGISTRY_TEST_PACKAGE_VERSION_OVERRIDE_OPT, \
     DEFAULT_CONFIG_FILE_CONTENT
 from ibm_watsonx_orchestrate.agent_builder.connections import ConnectionSecurityScheme, ExpectedCredentials
-from ibm_watsonx_orchestrate.experimental.flow_builder.flows.decorators import FlowWrapper
+from ibm_watsonx_orchestrate.flow_builder.flows.decorators import FlowWrapper
 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.experimental.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,23 @@ 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)
+            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:
+                    logger.error(f"Connection '{app_id}' is not configured in the '{conn_environment}' environment.")
+                    if conn_environment == ConnectionEnvironment.DRAFT:
+                        sys.exit(1)
+                    logger.error("If you deploy this tool without setting the live configuration the tool will error during execution.")
+                    continue
+
+                if kind == ToolKind.openapi and 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 +184,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 +220,28 @@ 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:
+                logger.error(f"Connection '{conn_identifier}' is not configured in the '{conn_environment}' environment.")
+                if conn_environment == ConnectionEnvironment.DRAFT:
+                    sys.exit(1)
+                logger.error("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)
@@ -339,24 +386,18 @@ async def import_flow_tool(file: str) -> None:
     theme = rich.theme.Theme({"model.name": "bold cyan"})
     console = rich.console.Console(highlighter=ModelHighlighter(), theme=theme)
     
-    message = f"""[bold cyan]Flow Tools: Experimental Feature[/bold cyan]
+    message = f"""[bold cyan]Flow Tools[/bold cyan]
    
 The [bold]flow tool[/bold] is being imported from [green]`{file}`[/green].  
     
 [bold cyan]Additional information:[/bold cyan]
 
-- Ensure the flow engine is running by issuing the [bold cyan]orchestrate server start[/bold cyan] command with the [bold cyan]--with-flow-runtime[/bold cyan] option
-- The [bold green]get_flow_status[/bold green] tool is being imported to support flow tools. 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
@@ -423,7 +464,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]:
@@ -438,6 +488,10 @@ def _get_kind_from_spec(spec: dict) -> ToolKind:
         return ToolKind.python
     elif ToolKind.openapi in tool_binding:
         return ToolKind.openapi
+    elif ToolKind.mcp in tool_binding:
+        return ToolKind.mcp
+    elif 'wxflows' in tool_binding:
+        return ToolKind.flow
     else:
         logger.error(f"Could not determine 'kind' of tool '{name}'")
         sys.exit(1) 
@@ -500,7 +554,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:
@@ -511,9 +578,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()
@@ -555,19 +629,20 @@ 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"
                 
                 toolkit_name = ""
 
-                if is_local_dev():
+                if tool.__tool_spec__.toolkit_id:
                     toolkit_client = instantiate_client(ToolKitClient)
-                    if tool.__tool_spec__.toolkit_id:
-                        toolkit = toolkit_client.get_draft_by_id(tool.__tool_spec__.toolkit_id)
-                        if isinstance(toolkit, dict) and "name" in toolkit:
-                            toolkit_name = toolkit["name"]
-                        elif toolkit:
-                            toolkit_name = str(toolkit)
+                    toolkit = toolkit_client.get_draft_by_id(tool.__tool_spec__.toolkit_id)
+                    if isinstance(toolkit, dict) and "name" in toolkit:
+                        toolkit_name = toolkit["name"]
+                    elif toolkit:
+                        toolkit_name = str(toolkit)
 
                 
                 table.add_row(
@@ -581,6 +656,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/cli/config.py

@@ -26,6 +26,8 @@ ENV_WXO_URL_OPT = "wxo_url"
 ENV_IAM_URL_OPT = "iam_url"
 PROTECTED_ENV_NAME = "local"
 ENV_AUTH_TYPE = "auth_type"
+BYPASS_SSL = "bypass_ssl"
+VERIFY = "verify"
 ENV_ACCEPT_LICENSE = 'accepts_license_agreements'
 
 DEFAULT_LOCAL_SERVICE_URL = "http://localhost:4321"

ibm_watsonx_orchestrate/cli/main.py

@@ -12,8 +12,13 @@ from ibm_watsonx_orchestrate.cli.commands.environment.environment_command import
 from ibm_watsonx_orchestrate.cli.commands.channels.channels_command import channel_app
 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.init_helper import init_callback
 
+import urllib3
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+
 app = typer.Typer(
     no_args_is_help=True,
     pretty_exceptions_enable=False,
@@ -30,6 +35,7 @@ app.add_typer(server_app, name="server", help='Manipulate your local Orchestrate
 app.add_typer(chat_app, name="chat", help='Launch the chat ui for your local Developer Edition server [requires entitlement]')
 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(settings_app, name="settings", help='Configure the settings for your active env')
 
 if __name__ == "__main__":