ibm-watsonx-orchestrate 1.11.1__py3-none-any.whl → 1.12.0__py3-none-any.whl

ibm_watsonx_orchestrate/cli/commands/toolkit/toolkit_command.py

@@ -47,11 +47,11 @@ def import_toolkit(
     ] = None,
     url: Annotated[
         Optional[str],
-        typer.Option("--url", "-u", help="The URL of the remote MCP server", hidden=True),
+        typer.Option("--url", "-u", help="The URL of the remote MCP server"),
     ] = None,
     transport: Annotated[
         ToolkitTransportKind,
-        typer.Option("--transport", help="The communication protocol to use for the remote MCP server. Only \"sse\" or \"streamable_http\" supported", hidden=True),
+        typer.Option("--transport", help="The communication protocol to use for the remote MCP server. Only \"sse\" or \"streamable_http\" supported"),
     ] = None,
     tools: Annotated[
         Optional[str],

ibm_watsonx_orchestrate/cli/commands/toolkit/toolkit_controller.py

@@ -12,7 +12,7 @@ from ibm_watsonx_orchestrate.client.tools.tool_client import ToolClient
 from ibm_watsonx_orchestrate.agent_builder.toolkits.base_toolkit import BaseToolkit, ToolkitSpec
 from ibm_watsonx_orchestrate.agent_builder.toolkits.types import ToolkitKind, Language, ToolkitSource, ToolkitTransportKind
 from ibm_watsonx_orchestrate.client.utils import instantiate_client
-from ibm_watsonx_orchestrate.utils.utils import sanatize_app_id
+from ibm_watsonx_orchestrate.utils.utils import sanitize_app_id
 from ibm_watsonx_orchestrate.client.connections import get_connections_client
 import typer
 import json
@@ -240,7 +240,7 @@ class ToolkitController:
             if not len(runtime_id.strip()) or not len(local_id.strip()):
                 raise typer.BadParameter(f"The provided --app-id '{app_id}' is not valid. --app-id cannot be empty or whitespace")
 
-            runtime_id = sanatize_app_id(runtime_id)
+            runtime_id = sanitize_app_id(runtime_id)
             is_local_mcp = self.package is not None or self.package_root is not None
             app_id_dict[runtime_id] = get_connection_id(local_id, is_local_mcp)
 

ibm_watsonx_orchestrate/cli/commands/tools/tools_command.py

@@ -61,9 +61,8 @@ relative to this package root folder or imported using relative imports from the
         requirements_file=requirements_file,
         package_root=package_root
     )
-    
-    tools_controller.publish_or_update_tools(tools, package_root=package_root)
-
+    tools_controller.publish_or_update_tools(tools=tools, package_root=package_root)
+ 
 @tools_app.command(name="list", help='List the imported tools in the active environment')
 def list_tools(
     verbose: Annotated[

ibm_watsonx_orchestrate/cli/commands/tools/tools_controller.py

@@ -11,7 +11,7 @@ import zipfile
 from enum import Enum
 from os import path
 from pathlib import Path
-from typing import Iterable, List
+from typing import Iterable, List, cast
 import rich
 import json
 from rich.json import JSON
@@ -25,6 +25,7 @@ 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.langflow_tool import LangflowTool, create_langflow_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
@@ -40,8 +41,9 @@ 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.utils.utils import sanitize_app_id
 from ibm_watsonx_orchestrate.utils.exceptions import BadRequest
+from ibm_watsonx_orchestrate.client.tools.tempus_client import TempusClient
 
 from  ibm_watsonx_orchestrate import __version__
 
@@ -50,11 +52,21 @@ logger = logging.getLogger(__name__)
 __supported_characters_pattern = re.compile("^(\\w|_)+$")
 
 
+DEFAULT_LANGFLOW_TOOL_REQUIREMENTS = [
+    "lfx==0.1.8"
+]
+
+DEFAULT_LANGFLOW_RUNNER_MODULES = [
+    "lfx",
+    "lfx-nightly"
+]
+
 class ToolKind(str, Enum):
     openapi = "openapi"
     python = "python"
     mcp = "mcp"
     flow = "flow"
+    langflow = "langflow"
     # skill = "skill"
 
 def _get_connection_environments() -> List[ConnectionEnvironment]:
@@ -64,6 +76,9 @@ def _get_connection_environments() -> List[ConnectionEnvironment]:
         return [env.value for env in ConnectionEnvironment]
 
 def validate_app_ids(kind: ToolKind, **args) -> None:
+    
+    environments = _get_connection_environments()
+    
     app_ids = args.get("app_id")
     if not app_ids:
         return
@@ -87,44 +102,62 @@ def validate_app_ids(kind: ToolKind, **args) -> None:
             imported_connections[app_id] = {conn_env: conn}
 
     for app_id in app_ids:
-        if kind == ToolKind.python:
-            # Split on = but not on \=
-            split_pattern = re.compile(r"(?<!\\)=")
-            split_id = re.split(split_pattern, app_id)
-            split_id = [x.replace("\\=", "=") for x in split_id]
-            if len(split_id) == 2:
-                _, app_id = split_id
-            elif len(split_id) == 1:
-                app_id = split_id[0]
-            else:
-                raise typer.BadParameter(f"The provided --app-id '{app_id}' is not valid. This is likely caused by having mutliple equal signs, please use '\\=' to represent a literal '=' character")
-
+        
         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:
-            # Validate that the connection is not key_value when the tool in openapi
-            if kind != ToolKind.openapi:
+            if kind != ToolKind.python:
                 continue
 
-            environments = _get_connection_environments()
+        permitted_connections_types = []
+
+        match(kind):
 
-            imported_connection = imported_connections.get(app_id)
+            case ToolKind.python:
+                # Split on = but not on \=
+                split_pattern = re.compile(r"(?<!\\)=")
+                split_id = re.split(split_pattern, app_id)
+                split_id = [x.replace("\\=", "=") for x in split_id]
+                if len(split_id) == 2:
+                    _, app_id = split_id
+                elif len(split_id) == 1:
+                    app_id = split_id[0]
+                else:
+                    raise typer.BadParameter(f"The provided --app-id '{app_id}' is not valid. This is likely caused by having mutliple equal signs, please use '\\=' to represent a literal '=' character")
+                continue
 
-            for conn_environment in environments:
-                conn = imported_connection.get(conn_environment)
+            # Validate that the connection is not key_value when the tool in openapi
+            case ToolKind.openapi:
+                permitted_connections_types.extend([
+                    ConnectionSecurityScheme.API_KEY_AUTH,
+                    ConnectionSecurityScheme.BASIC_AUTH,
+                    ConnectionSecurityScheme.BEARER_TOKEN,
+                    ConnectionSecurityScheme.OAUTH2
+                ])
 
-                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
+            # Validate that the connection is key_value when the tool in langflow
+            case ToolKind.langflow:
+                permitted_connections_types.append(ConnectionSecurityScheme.KEY_VALUE)
 
-                if conn.security_scheme == ConnectionSecurityScheme.KEY_VALUE:
-                    logger.error(f"Key value application connections can not be bound to an openapi tool")
-                    exit(1)
+        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 not in permitted_connections_types:
+                logger.error(f"{conn.security_scheme} application connections can not be bound to {kind.value} tools")
+                exit(1)
+
+
+            
 
 def validate_params(kind: ToolKind, **args) -> None:
     if kind in {"openapi", "python"} and args["file"] is None:
@@ -157,8 +190,37 @@ def get_connection_id(app_id: str) -> str:
         connection_id = connection.connection_id
     return connection_id
 
+def get_connections(app_ids: list[str] | str = None, environment: str = None, allow_missing: bool = True) -> dict:
+    if not app_ids:
+        return {}
+    if app_ids is str:
+        app_ids = [app_ids]
+
+    connections_client = get_connections_client()
+    if environment:
+        connections = { 
+            x.app_id:x for x in connections_client.list() \
+            if x.app_id in app_ids and x.environment == ConnectionEnvironment(environment) 
+        }
+    else:
+        connections = { x.app_id:x for x in connections_client.list() if x.app_id in app_ids }
+
+
+    missing = 0
+    for id in app_ids:
+        if not connections.get(id,None):
+            missing += 1
+
+    if missing > 0 and not allow_missing:
+        raise ValueError(f"Could not find {missing} of {len(app_ids)} required connections")
+
+    return connections
 
-def parse_python_app_ids(app_ids: List[str]) -> dict[str,str]:
+def get_connection_ids(app_ids: list[str] | str = None, environment: str = None, allow_missing: bool = True):
+    connections = get_connections(app_ids=app_ids, environment=environment, allow_missing=allow_missing)
+    return { k:v.connection_id for k,v in connections.items() }
+
+def parse_app_ids(app_ids: List[str]) -> dict[str,str]:
     app_id_dict = {}
     for app_id in app_ids:
         # Split on = but not on \=
@@ -176,7 +238,7 @@ def parse_python_app_ids(app_ids: List[str]) -> dict[str,str]:
         if not len(runtime_id.strip()) or not len(local_id.strip()):
             raise typer.BadParameter(f"The provided --app-id '{app_id}' is not valid. --app-id cannot be empty or whitespace")
 
-        runtime_id = sanatize_app_id(runtime_id)
+        runtime_id = sanitize_app_id(runtime_id)
         app_id_dict[runtime_id] = get_connection_id(local_id)
 
     return app_id_dict
@@ -211,7 +273,7 @@ def validate_python_connections(tool: BaseTool):
         else:
             expected_tool_conn_types = [expected_cred.type]
 
-        sanatized_expected_tool_app_id = sanatize_app_id(expected_tool_app_id)
+        sanatized_expected_tool_app_id = sanitize_app_id(expected_tool_app_id)
         if sanatized_expected_tool_app_id in existing_sanatized_expected_tool_app_ids:
             logger.error(f"Duplicate App ID found '{expected_tool_app_id}'. Multiple expected app ids in the tool '{tool.__tool_spec__.name}' collide after sanaitization to '{sanatized_expected_tool_app_id}'. Please rename the offending app id in your tool.")
             sys.exit(1)
@@ -289,6 +351,8 @@ def get_requirement_lines (requirements_file, remove_trailing_newlines=True):
 
     return requirements
 
+
+
 def import_python_tool(file: str, requirements_file: str = None, app_id: List[str] = None, package_root: str = None) -> List[BaseTool]:
     try:
         file_path = Path(file).absolute()
@@ -373,7 +437,7 @@ def import_python_tool(file: str, requirements_file: str = None, app_id: List[st
             obj.__tool_spec__.binding.python.function = f"{pkg}:{fn}"
 
         if app_id and len(app_id):
-            obj.__tool_spec__.binding.python.connections = parse_python_app_ids(app_id)
+            obj.__tool_spec__.binding.python.connections = parse_app_ids(app_id)
 
         validate_python_connections(obj)
         tools.append(obj)
@@ -495,11 +559,42 @@ The [bold]flow tool[/bold] is being imported from [green]`{file}`[/green].
 
     return tools
 
-
 async def import_openapi_tool(file: str, connection_id: str) -> List[BaseTool]:
     tools = await create_openapi_json_tools_from_uri(file, connection_id)
     return tools
 
+async def import_langflow_tool(file: str, app_id: List[str] = None):    
+    try:
+        file_path = Path(file).absolute()
+
+        if file_path.is_dir():
+            raise typer.BadParameter(f"Provided langflow file path is not a file.")
+
+        if file_path.is_symlink():
+            raise typer.BadParameter(f"Symbolic links are not supported for langflow file path.")
+
+        if file_path.suffix.lower() != ".json":
+            raise typer.BadParameter(f"Unsupported langflow file type. Only json files are supported.")
+        
+        with open(file) as f:
+            imported_tool = json.load(f)
+
+    except typer.BadParameter as ex:
+        raise BadRequest(ex)
+        
+
+    except Exception:
+        raise BadRequest(f"Failed to load langflow tool from file {file}")
+    
+    validate_app_ids(kind=ToolKind.langflow, app_ids=app_id)
+    connections = get_connection_ids(app_ids=app_id, environment='draft')
+    
+    tool = create_langflow_tool(tool_definition=imported_tool, connections=connections)
+
+
+    return tool    
+
+
 def _get_kind_from_spec(spec: dict) -> ToolKind:
     name = spec.get("name")
     tool_binding = spec.get("binding")
@@ -508,9 +603,11 @@ def _get_kind_from_spec(spec: dict) -> ToolKind:
         return ToolKind.python
     elif ToolKind.openapi in tool_binding:
         return ToolKind.openapi
+    elif ToolKind.langflow in tool_binding:
+        return ToolKind.langflow
     elif ToolKind.mcp in tool_binding:
         return ToolKind.mcp
-    elif 'wxflows' in tool_binding:
+    elif 'flow' in tool_binding:
         return ToolKind.flow
     else:
         logger.error(f"Could not determine 'kind' of tool '{name}'")
@@ -565,9 +662,14 @@ class ToolsController:
             case "skill":
                 tools = []
                 logger.warning("Skill Import not implemented yet")
+            case "langflow":
+                tools = asyncio.run(import_langflow_tool(file=args["file"],app_id=args.get('app_id',None)))
             case _:
                 raise BadRequest("Invalid kind selected")
 
+        if not isinstance(tools,list):
+            tools = [tools]
+
         for tool in tools:
             yield tool
 
@@ -631,6 +733,12 @@ class ToolsController:
                         else:
                             for conn in tool_binding.mcp.connections:
                                 connection_ids.append(tool_binding.mcp.connections[conn])
+                    elif tool_binding.langflow is not None and hasattr(tool_binding.langflow, "connections"):
+                        if tool_binding.langflow.connections is None:
+                            connection_ids.append(None)
+                        else:
+                            for conn in tool_binding.langflow.connections:
+                                connection_ids.append(tool_binding.langflow.connections[conn])
 
                 app_ids = []
                 for connection_id in connection_ids:
@@ -650,7 +758,9 @@ class ToolsController:
                 elif tool_binding.mcp is not None:
                         tool_type=ToolKind.mcp
                 elif tool_binding.flow is not None:
-                        tool_type=ToolKind.flow        
+                        tool_type=ToolKind.flow  
+                elif tool_binding.langflow is not None:
+                        tool_type=ToolKind.langflow      
                 else:
                         tool_type="Unknown"
                 
@@ -779,11 +889,51 @@ class ToolsController:
                         zip_tool_artifacts.write(requirements_file_path, arcname='requirements.txt')
 
                         zip_tool_artifacts.writestr("bundle-format", "2.0.0\n")
+                        
+                elif self.tool_kind == ToolKind.langflow:
+
+                    tool_artifact = path.join(tmpdir, "artifacts.zip")
+
+                    with zipfile.ZipFile(tool_artifact, "w", zipfile.ZIP_DEFLATED) as zip_tool_artifacts:
+                        tool_path = Path(self.file)
+                        zip_tool_artifacts.write(tool_path, arcname=f"{tool_path.stem}.json")
+
+                        requirements = []
+
+                        if self.requirements_file:
+                            requirements_file_path = Path(self.requirements_file)
+                            requirements.extend(
+                                get_requirement_lines(requirements_file=requirements_file_path, remove_trailing_newlines=False)
+                            )
+
+                        langflowTool = cast(LangflowTool, tool)
+                        # if there are additional requriements from the langflow model, we should add it to the requirement set
+                        if langflowTool.requirements and len(langflowTool.requirements) > 0:
+                            requirements.extend(langflowTool.requirements)
+
+                        # now check if the requirements contain modules listed in DEFAULT_LANGFLOW_RUNNER_MODULES
+                        # if it is needed, we are assuming the user wants to override the default langflow module
+                        # with a specific version
+                        runner_overridden = False
+                        for r in requirements:
+                            # get the module name from the requirements
+                            module_name = r.strip().split('==')[0].split('=')[0].split('>=')[0].split('<=')[0].split('~=')[0].lower()
+                            if not module_name.startswith('#'):
+                                if module_name in DEFAULT_LANGFLOW_RUNNER_MODULES:
+                                    runner_overridden = True
+                        
+                        if not runner_overridden:
+                            # add the default runner to the top of requirement list
+                            requirements = DEFAULT_LANGFLOW_TOOL_REQUIREMENTS + list(requirements)
+
+                        requirements_content = '\n'.join(requirements) + '\n'
+                        zip_tool_artifacts.writestr("requirements.txt",requirements_content)  
+                        zip_tool_artifacts.writestr("bundle-format", "2.0.0\n")
 
                 if exist:
                     self.update_tool(tool_id=tool_id, tool=tool, tool_artifact=tool_artifact)
                 else:
-                    self.publish_tool(tool, tool_artifact=tool_artifact)
+                    self.publish_tool(tool=tool, tool_artifact=tool_artifact)
 
     def publish_tool(self, tool: BaseTool, tool_artifact: str) -> None:
         tool_spec = tool.__tool_spec__.model_dump(mode='json', exclude_unset=True, exclude_none=True, by_alias=True)
@@ -792,7 +942,11 @@ class ToolsController:
         tool_id = response.get("id")
 
         if tool_artifact is not None:
-            self.get_client().upload_tools_artifact(tool_id=tool_id, file_path=tool_artifact)
+            match self.tool_kind:
+                case ToolKind.langflow | ToolKind.python:
+                    self.get_client().upload_tools_artifact(tool_id=tool_id, file_path=tool_artifact)
+                case _:
+                    raise ValueError(f"Unexpected artifact for {self.tool_kind} tool")
 
         logger.info(f"Tool '{tool.__tool_spec__.name}' imported successfully")
 
@@ -804,7 +958,11 @@ class ToolsController:
         self.get_client().update(tool_id, tool_spec)
 
         if tool_artifact is not None:
-            self.get_client().upload_tools_artifact(tool_id=tool_id, file_path=tool_artifact)
+            match self.tool_kind:
+                case ToolKind.langflow | ToolKind.python:
+                    self.get_client().upload_tools_artifact(tool_id=tool_id, file_path=tool_artifact)
+                case _:
+                    raise ValueError(f"Unexpected artifact for {self.tool_kind} tool")
 
         logger.info(f"Tool '{tool.__tool_spec__.name}' updated successfully")
 
@@ -826,6 +984,23 @@ class ToolsController:
             logger.error(e.response.text)
             exit(1)
 
+    def serialize_to_json_in_zip(self, obj: any, filename: str) -> bytes:
+        # Serialize the Python object to a JSON string
+        json_str = json.dumps(obj, indent=2)
+        
+        # Create a BytesIO object to hold the in-memory zip file
+        zip_in_memory = io.BytesIO()
+        
+        # Create a ZipFile object in append mode
+        with zipfile.ZipFile(zip_in_memory, 'a') as zip_file:
+            # Write the JSON string as a file named 'data.json' inside the zip
+            zip_file.writestr(filename, json_str)
+        
+        # Seek to the beginning of the BytesIO object to return the in-memory zip file as bytes
+        zip_in_memory.seek(0)
+    
+        return zip_in_memory.getvalue()
+    
     def download_tool(self, name: str) -> bytes | None:
         tool_client = self.get_client()
         draft_tools = tool_client.get_draft_by_name(tool_name=name)
@@ -840,13 +1015,27 @@ class ToolsController:
         draft_tool_kind = _get_kind_from_spec(draft_tool)
         
         # TODO: Add openapi tool support
-        if draft_tool_kind != ToolKind.python:
+        supported_toolkinds = [ToolKind.python,ToolKind.langflow,ToolKind.flow]
+        if draft_tool_kind not in supported_toolkinds:
             logger.warning(f"Skipping '{name}', {draft_tool_kind.value} tools are currently unsupported by export")
             return
 
         tool_id = draft_tool.get("id")
 
-        tool_artifacts_bytes = tool_client.download_tools_artifact(tool_id=tool_id)
+        if draft_tool_kind == ToolKind.python or draft_tool_kind == ToolKind.langflow:
+            tool_artifacts_bytes = tool_client.download_tools_artifact(tool_id=tool_id)
+        elif draft_tool_kind == ToolKind.flow:
+            if not is_local_dev():
+                logger.warning("Skipping '{name}', Flow tool export is only supported in local dev mode")
+                return
+            
+            client = instantiate_client(TempusClient)
+            flow_model = client.get_flow_model(tool_id)
+            # we need to fix the name as sometimes it is left as 'untitled' by the builder
+            if "data" in flow_model:
+                flow_model["data"]["spec"]["name"] = name
+            tool_artifacts_bytes = self.serialize_to_json_in_zip(flow_model["data"], f"{name}.json")
+
         return tool_artifacts_bytes
     
     def export_tool(self, name: str, output_path: str) -> None:

ibm_watsonx_orchestrate/cli/main.py

@@ -11,6 +11,7 @@ from ibm_watsonx_orchestrate.cli.commands.server.server_command import server_ap
 from ibm_watsonx_orchestrate.cli.commands.chat.chat_command import chat_app
 from ibm_watsonx_orchestrate.cli.commands.models.models_command import models_app
 from ibm_watsonx_orchestrate.cli.commands.environment.environment_command import environment_app
+from ibm_watsonx_orchestrate.cli.commands.partners.partners_command import partners_app
 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
@@ -44,6 +45,7 @@ app.add_typer(channel_app, name="channels", help="Configure channels where your
 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')
+app.add_typer(partners_app, name="partners", help='Generate a well-structured, submission-ready agent artifact package for partner-built agents')
 
 if __name__ == "__main__":
     app()

ibm_watsonx_orchestrate/client/connections/connections_client.py

@@ -6,7 +6,7 @@ from typing import Optional
 from enum import Enum
 
 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.agent_builder.connections.types import ConnectionEnvironment, ConnectionPreference, ConnectionConfiguration, ConnectionAuthType, ConnectionSecurityScheme, IdpConfigData, AppConfigData, ConnectionType
 from ibm_watsonx_orchestrate.client.utils import is_cpd_env, is_local_dev
 
 import logging
@@ -47,6 +47,9 @@ class GetConfigResponse(BaseModel):
     idp_config_data: Optional[IdpConfigData] = None
     app_config_data: Optional[AppConfigData] = None
 
+    def as_config(self):
+        return ConnectionConfiguration(**dict(self))
+
 class GetConnectionResponse(BaseModel):
     connection_id: str = None
     app_id: str = None

ibm_watsonx_orchestrate/client/tools/tempus_client.py

@@ -42,4 +42,7 @@ class TempusClient(BaseAPIClient):
     
     def arun_flow(self, flow_id: str, input: dict) -> dict:
         return self._post(f"/flows/{flow_id}/versions/TIP/run/async", data=input)
+    
+    def get_flow_model(self, flow_id: str, version: str = "TIP") -> dict:
+        return self._get(f"/flow-models/{flow_id}/versions/{version}")
 

ibm_watsonx_orchestrate/client/tools/tool_client.py

@@ -10,7 +10,7 @@ class ToolClient(BaseAPIClient):
     def create(self, payload: dict) -> dict:
         return self._post("/tools", data=payload)
 
-    def get(self) -> dict:
+    def get(self) -> dict:        
         return self._get("/tools")
 
     def update(self, agent_id: str, data: dict) -> dict:
@@ -21,10 +21,13 @@ class ToolClient(BaseAPIClient):
 
     def upload_tools_artifact(self, tool_id: str, file_path: str) -> dict:
         return self._post(f"/tools/{tool_id}/upload", files={"file": (f"{tool_id}.zip", open(file_path, "rb"), "application/zip", {"Expires": "0"})})
-    
+
     def download_tools_artifact(self, tool_id: str) -> bytes:
         response = self._get(f"/tools/{tool_id}/download", return_raw=True)
         return response.content
+    
+    def download_tools_json(self, tool_id: str) -> dict:
+        return self.download_tools_artifact(tool_id)
 
     def get_draft_by_name(self, tool_name: str) -> List[dict]:
         return self.get_drafts_by_names([tool_name])

ibm_watsonx_orchestrate/client/utils.py

@@ -1,3 +1,5 @@
+import platform
+
 from ibm_watsonx_orchestrate.cli.config import (
     Config,
     DEFAULT_CONFIG_FILE_FOLDER,
@@ -170,4 +172,32 @@ def instantiate_client(client: type[T] , url: str | None=None) -> T:
     except FileNotFoundError as e:
         message = "No active environment found. Please run `orchestrate env activate` to activate an environment"
         logger.error(message)
-        raise FileNotFoundError(message)
+        raise FileNotFoundError(message)
+
+
+def get_architecture () -> str:
+    arch = platform.machine().lower()
+    if arch in ("amd64", "x86_64"):
+        return "amd64"
+
+    elif arch == "i386":
+        return "386"
+
+    elif arch in ("aarch64", "arm64", "arm"):
+        return "arm"
+
+    else:
+        raise Exception("Unsupported architecture %s" % arch)
+
+
+def is_arm_architecture () -> bool:
+    return platform.machine().lower() in ("aarch64", "arm64", "arm")
+
+
+def get_os_type () -> str:
+    system = platform.system().lower()
+    if system in ("linux", "darwin", "windows"):
+        return system
+
+    else:
+        raise Exception("Unsupported operating system %s" % system)