ibm-watsonx-orchestrate 1.0.1__py3-none-any.whl → 1.2.0__py3-none-any.whl

ibm_watsonx_orchestrate/__init__.py

@@ -5,7 +5,8 @@
 
 pkg_name = "ibm-watsonx-orchestrate"
 
-__version__ = "1.0.1"
+__version__ = "1.2.0"
+
 
 
 from ibm_watsonx_orchestrate.utils.logging.logger import setup_logging

ibm_watsonx_orchestrate/agent_builder/tools/python_tool.py

@@ -121,6 +121,7 @@ def tool(
         _desc = description
         if description is None and doc is not None:
             _desc = doc.description
+
         
         spec = ToolSpec(
             name=name or fn.__name__,
@@ -150,7 +151,11 @@ def tool(
 
         sig = inspect.signature(fn)
         if not input_schema:
-            input_schema_model: type[BaseModel] = create_schema_from_function(spec.name, fn, parse_docstring=True)
+            try:
+                input_schema_model: type[BaseModel] = create_schema_from_function(spec.name, fn, parse_docstring=True)
+            except:
+                logger.warning("Unable to properly parse parameter descriptions due to incorrectly formatted docstring. This may result in degraded agent performance. To fix this, please ensure the docstring conforms to Google's docstring format.")
+                input_schema_model: type[BaseModel] = create_schema_from_function(spec.name, fn, parse_docstring=False)
             input_schema_json = input_schema_model.model_json_schema()
             input_schema_json = dereference_refs(input_schema_json)
 
@@ -165,7 +170,7 @@ def tool(
             )
         else:
             spec.input_schema = input_schema
-
+        
         _validate_input_schema(spec.input_schema)
 
         if not output_schema:

ibm_watsonx_orchestrate/agent_builder/tools/types.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import List, Any, Dict, Literal, Optional
+from typing import List, Any, Dict, Literal, Optional, Union
 
 from pydantic import BaseModel, model_validator, ConfigDict, Field, AliasChoices
 
@@ -14,7 +14,7 @@ class ToolPermission(str, Enum):
 class JsonSchemaObject(BaseModel):
     model_config = ConfigDict(extra='allow')
 
-    type: Optional[Literal['object', 'string', 'number', 'integer', 'boolean', 'array', 'null']] = None
+    type: Optional[Union[Literal['object', 'string', 'number', 'integer', 'boolean', 'array', 'null'], List[Literal['object', 'string', 'number', 'integer', 'boolean', 'array', 'null']]]] = None
     title: str | None = None
     description: str | None = None
     properties: Optional[Dict[str, 'JsonSchemaObject']] = None
@@ -34,13 +34,19 @@ class JsonSchemaObject(BaseModel):
     aliasName: str | None = None
     "Runtime feature where the sdk can provide the original name of a field before prefixing"
 
+    @model_validator(mode='after')
+    def normalize_type_field(self) -> 'JsonSchemaObject':
+        if isinstance(self.type, list):
+            self.type = self.type[0]
+        return self
+
 
 class ToolRequestBody(BaseModel):
     model_config = ConfigDict(extra='allow')
 
     type: Literal['object']
     properties: Dict[str, JsonSchemaObject]
-    required: List[str]
+    required: Optional[List[str]] = None
 
 
 class ToolResponseBody(BaseModel):
@@ -52,7 +58,7 @@ class ToolResponseBody(BaseModel):
     items: JsonSchemaObject = None
     uniqueItems: bool = None
     anyOf: List['JsonSchemaObject'] = None
-    required: List[str] = None
+    required: Optional[List[str]] = None
 
 class OpenApiSecurityScheme(BaseModel):
     type: Literal['apiKey', 'http', 'oauth2', 'openIdConnect']
@@ -128,6 +134,10 @@ class SkillToolBinding(BaseModel):
 class ClientSideToolBinding(BaseModel):
     pass
 
+class McpToolBinding(BaseModel):
+    server_url: Optional[str] = None
+    source: str
+    connections: Dict[str, str]
 
 class ToolBinding(BaseModel):
     openapi: OpenApiToolBinding = None
@@ -135,6 +145,7 @@ class ToolBinding(BaseModel):
     wxflows: WxFlowsToolBinding = None
     skill: SkillToolBinding = None
     client_side: ClientSideToolBinding = None
+    mcp: McpToolBinding = None
 
     @model_validator(mode='after')
     def validate_binding_type(self) -> 'ToolBinding':
@@ -143,7 +154,8 @@ class ToolBinding(BaseModel):
             self.python is not None,
             self.wxflows is not None,
             self.skill is not None,
-            self.client_side is not None
+            self.client_side is not None,
+            self.mcp is not None
         ]
         if sum(bindings) == 0:
             raise ValueError("One binding must be set")
@@ -159,4 +171,5 @@ class ToolSpec(BaseModel):
     input_schema: ToolRequestBody = None
     output_schema: ToolResponseBody = None
     binding: ToolBinding = None
+    toolkit_id: str | None = None
 

ibm_watsonx_orchestrate/cli/commands/server/server_command.py

@@ -1,30 +1,25 @@
+import importlib.resources as resources
 import logging
-import sys
+import os
+import platform
 import subprocess
+import sys
 import tempfile
-from pathlib import Path
-import requests
 import time
-import os
-import platform
-
+from pathlib import Path
 
-import typer
-import importlib.resources as resources
 import jwt
+import requests
+import typer
+from dotenv import dotenv_values
 
-from dotenv import dotenv_values, load_dotenv
-
-from ibm_watsonx_orchestrate.client.agents.agent_client import AgentClient
-from ibm_watsonx_orchestrate.client.analytics.llm.analytics_llm_client import AnalyticsLLMClient, AnalyticsLLMConfig, \
-    AnalyticsLLMUpsertToolIdentifier
 from ibm_watsonx_orchestrate.client.utils import instantiate_client, check_token_validity, is_local_dev
-
-from ibm_watsonx_orchestrate.cli.commands.environment.environment_controller import _login, _decode_token
+from ibm_watsonx_orchestrate.cli.commands.environment.environment_controller import _login
+from ibm_watsonx_orchestrate.cli.config import LICENSE_HEADER, \
+    ENV_ACCEPT_LICENSE
 from ibm_watsonx_orchestrate.cli.config import PROTECTED_ENV_NAME, clear_protected_env_credentials_token, Config, \
-    AUTH_CONFIG_FILE_FOLDER, AUTH_CONFIG_FILE, AUTH_MCSP_TOKEN_OPT, ENVIRONMENTS_SECTION_HEADER, ENV_WXO_URL_OPT, \
-    CONTEXT_SECTION_HEADER, CONTEXT_ACTIVE_ENV_OPT, AUTH_SECTION_HEADER
-from dotenv import dotenv_values, load_dotenv
+    AUTH_CONFIG_FILE_FOLDER, AUTH_CONFIG_FILE, AUTH_MCSP_TOKEN_OPT, AUTH_SECTION_HEADER, USER_ENV_CACHE_HEADER
+from ibm_watsonx_orchestrate.client.agents.agent_client import AgentClient
 
 logger = logging.getLogger(__name__)
 
@@ -52,11 +47,11 @@ def ensure_docker_compose_installed() -> list:
         typer.echo("Unable to find an installed docker-compose or docker compose")
         sys.exit(1)
 
-def docker_login(iam_api_key: str, registry_url: str) -> None:
+def docker_login(api_key: str, registry_url: str, username:str = "iamapikey") -> None:
     logger.info(f"Logging into Docker registry: {registry_url} ...")
     result = subprocess.run(
-        ["docker", "login", "-u", "iamapikey", "--password-stdin", registry_url],
-        input=iam_api_key.encode("utf-8"),
+        ["docker", "login", "-u", username, "--password-stdin", registry_url],
+        input=api_key.encode("utf-8"),
         capture_output=True,
     )
     if result.returncode != 0:
@@ -64,6 +59,24 @@ def docker_login(iam_api_key: str, registry_url: str) -> None:
         sys.exit(1)
     logger.info("Successfully logged in to Docker.")
 
+def docker_login_by_dev_edition_source(env_dict: dict, source: str) -> None:
+    registry_url = env_dict["REGISTRY_URL"]
+    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")
+        if not wo_auth_type:
+            raise ValueError("WO_AUTH_TYPE is required in the environment file if WO_DEVELOPER_EDITION_SOURCE is set to 'orchestrate'.")
+        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(
@@ -93,9 +106,51 @@ def merge_env(
         user_env = dotenv_values(str(user_env_path))
         merged.update(user_env)
 
-
     return merged
 
+def get_default_registry_env_vars_by_dev_edition_source(env_dict: dict, source: str) -> dict[str,str]:
+    component_registry_var_names = {key for key in env_dict if key.endswith("_REGISTRY")}
+
+    result = {}
+    if source == "internal":
+        result["REGISTRY_URL"] = "us.icr.io"
+        for name in component_registry_var_names:
+            result[name] = "us.icr.io/watson-orchestrate-private"
+    elif source == "myibm":
+        result["REGISTRY_URL"] = "cp.icr.io"
+        for name in component_registry_var_names:
+            result[name] = "cp.icr.io/cp/wxo-lite"
+    elif source == "orchestrate":
+        raise NotImplementedError("The 'orchestrate' source is not implemented yet.")
+        # TODO: confirm with Tej about the registry url for orchestrate source
+    return result
+
+def get_dev_edition_source(env_dict: dict) -> str:
+    source = env_dict.get("WO_DEVELOPER_EDITION_SOURCE")
+
+    if source:
+        return source
+    if env_dict.get("WO_INSTANCE"):
+        return "orchestrate"
+    return "myibm"
+
+def get_docker_cred_by_wo_auth_type(env_dict: dict, auth_type: str) -> tuple[str, str]:
+    if auth_type in {"mcsp", "ibm_iam"}:
+        wo_api_key = env_dict.get("WO_API_KEY")
+        if not wo_api_key:
+            raise ValueError("WO_API_KEY is required in the environment file if the WO_AUTH_TYPE is set to 'mcsp' or 'ibm_iam'.")
+        return wo_api_key, "wouser"
+    elif auth_type == "cpd":
+        wo_api_key = env_dict.get("WO_API_KEY")
+        wo_password = env_dict.get("WO_PASSWORD")
+        if not wo_api_key and not wo_password:
+            raise ValueError("WO_API_KEY or WO_PASSWORD is required in the environment file if the WO_AUTH_TYPE is set to 'cpd'.")
+        wo_username = env_dict.get("WO_USERNAME")
+        if not wo_username:
+            raise ValueError("WO_USERNAME is required in the environment file if the WO_AUTH_TYPE is set to 'cpd'.")
+        return wo_api_key or wo_password, wo_username  # type: ignore[return-value]
+    else:
+        raise ValueError(f"Unknown value for WO_AUTH_TYPE: {auth_type}. Must be one of ['mcsp', 'ibm_iam', 'cpd'].")
 
 def apply_llm_api_key_defaults(env_dict: dict) -> None:
     llm_value = env_dict.get("WATSONX_APIKEY")
@@ -138,7 +193,30 @@ def refresh_local_credentials() -> None:
     clear_protected_env_credentials_token()
     _login(name=PROTECTED_ENV_NAME, apikey=None)
 
+NON_SECRET_ENV_ITEMS = {
+    "WO_DEVELOPER_EDITION_SOURCE",
+    "WO_INSTANCE",
+    "USE_SAAS_ML_TOOLS_RUNTIME",
+    "WXO_MCSP_EXCHANGE_URL",
+    "OPENSOURCE_REGISTRY_PROXY"
+}
+def persist_user_env(env: dict, include_secrets: bool = False) -> None:
+    if include_secrets:
+        persistable_env = env
+    else:
+        persistable_env = {k:env[k] for k in NON_SECRET_ENV_ITEMS if k in env}
 
+    cfg = Config()
+    cfg.save(
+        {
+            USER_ENV_CACHE_HEADER: persistable_env
+        }
+    )
+
+def get_persisted_user_env() -> dict | None:
+    cfg = Config()
+    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, with_flow_runtime=False) -> None:
     compose_path = get_compose_file()
@@ -256,12 +334,20 @@ def run_compose_lite_ui(user_env_file: Path) -> bool:
     compose_path = get_compose_file()
     compose_command = ensure_docker_compose_installed()
     ensure_docker_installed()
-    default_env_path = get_default_env_file()
-    logger.debug(f"user env file: {user_env_file}")
-    merged_env_dict = merge_env(
-        default_env_path,
-        user_env_file if user_env_file else None
-    )
+
+    default_env = read_env_file(get_default_env_file())
+    user_env = read_env_file(user_env_file) if user_env_file else {}
+    if not user_env:
+        user_env = get_persisted_user_env()
+
+    dev_edition_source = get_dev_edition_source(user_env)
+    default_registry_vars = get_default_registry_env_vars_by_dev_edition_source(default_env, source=dev_edition_source)
+
+    merged_env_dict = {
+        **default_env,
+        **default_registry_vars,
+        **user_env,
+    }
 
     _login(name=PROTECTED_ENV_NAME)
     auth_cfg = Config(AUTH_CONFIG_FILE_FOLDER, AUTH_CONFIG_FILE)
@@ -271,21 +357,17 @@ def run_compose_lite_ui(user_env_file: Path) -> bool:
     tenant_id = token.get('woTenantId', None)
     merged_env_dict['REACT_APP_TENANT_ID'] = tenant_id
 
-
-    registry_url = merged_env_dict.get("REGISTRY_URL")
-    if not registry_url:
-        logger.error("Error: REGISTRY_URL is required in the environment file.")
-        sys.exit(1)
-
     agent_client = instantiate_client(AgentClient)
     agents = agent_client.get()
     if not agents:
         logger.error("No agents found for the current environment. Please create an agent before starting the chat.")
         sys.exit(1)
 
-    iam_api_key = merged_env_dict.get("DOCKER_IAM_KEY")
-    if iam_api_key:
-        docker_login(iam_api_key, registry_url)
+    try:
+        docker_login_by_dev_edition_source(merged_env_dict, dev_edition_source)
+    except ValueError as ignored:
+        # do nothing, as the docker login here is not mandatory
+        pass
 
     #These are to removed warning and not used in UI component
     if not 'WATSONX_SPACE_ID' in merged_env_dict:
@@ -436,6 +518,35 @@ def run_compose_lite_logs(final_env_file: Path, is_reset: bool = False) -> None:
         )
         sys.exit(1)
 
+def confirm_accepts_license_agreement(accepts_by_argument: bool):
+    cfg = Config()
+    accepts_license = cfg.read(LICENSE_HEADER, ENV_ACCEPT_LICENSE)
+    if accepts_license != True:
+        logger.warning(('''
+            By running the following command your machine will install IBM watsonx Orchestrate Developer Edition, which is governed by the following IBM license agreement:
+            - * https://www.ibm.com/support/customer/csol/terms/?id=L-YRMZ-PB6MHM&lc=en
+            Additionally, the following prerequisite open source programs will be obtained from Docker Hub and will be installed on your machine. Each of the below programs are Separately Licensed Code, and are governed by the separate license agreements identified below, and not by the IBM license agreement:
+            * redis (7.2)               - https://github.com/redis/redis/blob/7.2.7/COPYING
+            * minio                     - https://github.com/minio/minio/blob/master/LICENSE
+            * milvus-io                 - https://github.com/milvus-io/milvus/blob/master/LICENSE
+            * etcd                      - https://github.com/etcd-io/etcd/blob/main/LICENSE
+            * clickhouse-server         - https://github.com/ClickHouse/ClickHouse/blob/master/LICENSE
+            * langfuse                  - https://github.com/langfuse/langfuse/blob/main/LICENSE
+            After installation, you are solely responsible for obtaining and installing updates and fixes, including security patches, for the above prerequisite open source programs. To update images the customer will run `orchestrate server reset && orchestrate server start -e .env`.
+        ''').strip())
+        if not accepts_by_argument:
+            result = input('\nTo accept the terms and conditions of the IBM license agreement and the Separately Licensed Code licenses above please enter "I accept": ')
+        else:
+            result = None
+        if result == 'I accept' or accepts_by_argument:
+            cfg.write(LICENSE_HEADER, ENV_ACCEPT_LICENSE, True)
+        else:
+            logger.error('The terms and conditions were not accepted, exiting.')
+            exit(1)
+
+
+
+
 @server_app.command(name="start")
 def server_start(
     user_env_file: str = typer.Option(
@@ -454,33 +565,46 @@ def server_start(
         help='Option to start server with tempus-runtime.',
         hidden=True
     )
+    ,
+    persist_env_secrets: bool = typer.Option(
+        False,
+        '--persist-env-secrets', '-p',
+        help='Option to store secret values from the provided env file in the config file (~/.config/orchestrate/config.yaml)',
+        hidden=True
+    ),
+    accept_terms_and_conditions: bool = typer.Option(
+        False,
+        "--accept-terms-and-conditions",
+        help="By providing this flag you accept the terms and conditions outlined in the logs on server start."
+    ),
 ):
+    confirm_accepts_license_agreement(accept_terms_and_conditions)
+
     if user_env_file and not Path(user_env_file).exists():
         logger.error(f"Error: The specified environment file '{user_env_file}' does not exist.")
         sys.exit(1)
     ensure_docker_installed()
 
-    default_env_path = get_default_env_file()
+    default_env = read_env_file(get_default_env_file())
+    user_env = read_env_file(user_env_file) if user_env_file else {}
+    persist_user_env(user_env, include_secrets=persist_env_secrets)
+    dev_edition_source = get_dev_edition_source(user_env)
+    default_registry_vars = get_default_registry_env_vars_by_dev_edition_source(default_env, source=dev_edition_source)
 
-    merged_env_dict = merge_env(
-        default_env_path,
-        Path(user_env_file) if user_env_file else None
-    )
+    merged_env_dict = {
+        **default_env,
+        **default_registry_vars,
+        **user_env,
+    }
 
     merged_env_dict['DBTAG'] = get_dbtag_from_architecture(merged_env_dict=merged_env_dict)
 
-    iam_api_key = merged_env_dict.get("DOCKER_IAM_KEY")
-    if not iam_api_key:
-        logger.error("Error: DOCKER_IAM_KEY is required in the environment file.")
-        sys.exit(1)
-
-    registry_url = merged_env_dict.get("REGISTRY_URL")
-    if not registry_url:
-        logger.error("Error: REGISTRY_URL is required in the environment file.")
+    try:
+        docker_login_by_dev_edition_source(merged_env_dict, dev_edition_source)
+    except ValueError as e:
+        logger.error(f"Error: {e}")
         sys.exit(1)
 
-    docker_login(iam_api_key, registry_url)
-
     apply_llm_api_key_defaults(merged_env_dict)
 
 
@@ -511,6 +635,9 @@ def server_start(
 
     logger.info(f"You can run `orchestrate env activate local` to set your environment or `orchestrate chat start` to start the UI service and begin chatting.")
 
+    if experimental_with_langfuse:
+        logger.info(f"You can access the observability platform Langfuse at http://localhost:3010, username: orchestrate@ibm.com, password: orchestrate")
+
     if with_flow_runtime:
         logger.info(f"Starting with flow runtime")
 

ibm_watsonx_orchestrate/cli/commands/toolkit/toolkit_command.py

@@ -0,0 +1,71 @@
+import typer
+from typing import List
+from typing_extensions import Annotated, Optional
+from ibm_watsonx_orchestrate.cli.commands.toolkit.toolkit_controller import ToolkitController, ToolkitKind
+
+toolkits_app = typer.Typer(no_args_is_help=True)
+
+@toolkits_app.command(name="import")
+def import_toolkit(
+    kind: Annotated[
+        ToolkitKind,
+        typer.Option("--kind", "-k", help="Kind of toolkit, currently only MCP is supported"),
+    ],
+    name: Annotated[
+        str,
+        typer.Option("--name", "-n", help="Name of the toolkit"),
+    ],
+    description: Annotated[
+        str,
+        typer.Option("--description", help="Description of the toolkit"),
+    ],
+    package_root: Annotated[
+        str,
+        typer.Option("--package-root", "-p", help="Root directory of the MCP server package"),
+    ],
+    command: Annotated[
+        str,
+        typer.Option(
+            "--command", 
+            help="Command to start the MCP server. Can be a string (e.g. 'node dist/index.js --transport stdio') "
+                "or a JSON-style list of arguments (e.g. '[\"node\", \"dist/index.js\", \"--transport\", \"stdio\"]'). "
+                "The first argument will be used as the executable, the rest as its arguments."
+        ),
+    ],
+    tools: Annotated[
+        Optional[str],
+        typer.Option("--tools", "-t", help="Comma-separated list of tools to import. Or you can use `*` to use all tools"),
+    ] = None,
+    app_id: Annotated[
+        List[str],
+        typer.Option(
+            "--app-id", "-a", 
+            help='The app id of the connection to associate with this tool. A application connection represents the server authentication credentials needed to connect to this tool. Only type key_value is currently supported for MCP.'
+        )
+    ] = None
+):
+    if tools == "*":
+        tool_list = ["*"] # Wildcard to use all tools
+    elif tools:
+        tool_list = [tool.strip() for tool in tools.split(",")]
+    else:
+        tool_list = None
+
+    toolkit_controller = ToolkitController(
+    kind=kind,
+    name=name,
+    description=description,
+    package_root=package_root,
+    command=command,
+)
+    toolkit_controller.import_toolkit(tools=tool_list, app_id=app_id)
+
+@toolkits_app.command(name="remove")
+def remove_toolkit(
+    name: Annotated[
+        str,
+        typer.Option("--name", "-n", help="Name of the toolkit you wish to remove"),
+    ],
+):  
+    toolkit_controller = ToolkitController()
+    toolkit_controller.remove_toolkit(name=name)

ibm_watsonx_orchestrate/cli/commands/toolkit/toolkit_controller.py

@@ -0,0 +1,212 @@
+import os
+import zipfile
+import tempfile
+from typing import List, Optional
+from enum import Enum
+import logging
+import sys
+import re
+import requests
+from ibm_watsonx_orchestrate.client.toolkit.toolkit_client import ToolKitClient
+from ibm_watsonx_orchestrate.client.utils import instantiate_client
+from ibm_watsonx_orchestrate.utils.utils import sanatize_app_id
+from ibm_watsonx_orchestrate.client.connections import get_connections_client
+import typer
+import json
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from ibm_watsonx_orchestrate.client.utils import is_local_dev
+
+logger = logging.getLogger(__name__)
+
+class ToolkitKind(str, Enum):
+    MCP = "mcp"
+
+def get_connection_id(app_id: str) -> str:
+    connections_client = get_connections_client()
+    existing_draft_configuration = connections_client.get_config(app_id=app_id, env='draft')
+    existing_live_configuration = connections_client.get_config(app_id=app_id, env='live')
+
+    for config in [existing_draft_configuration, existing_live_configuration]:
+        if config and config.security_scheme != 'key_value_creds':
+            logger.error("Only key_value credentials are currently supported")
+            exit(1)
+    connection_id = None
+    if app_id is not None:
+        connection = connections_client.get(app_id=app_id)
+        if  not connection:
+            logger.error(f"No connection exists with the app-id '{app_id}'")
+            exit(1)
+        connection_id = connection.connection_id
+    return connection_id
+
+def validate_params(kind: str):
+    if kind != ToolkitKind.MCP:
+        raise ValueError(f"Unsupported toolkit kind: {kind}")
+
+
+class ToolkitController:
+    def __init__(
+        self, 
+        kind: ToolkitKind = None,
+        name: str = None,
+        description: str = None,
+        package_root: str  = None,
+        command: str  = None,
+    ):
+        self.kind = kind
+        self.name = name
+        self.description = description
+        self.package_root = package_root
+        self.command = command
+        self.client = None
+
+    def get_client(self) -> ToolKitClient:
+        if not self.client:
+            self.client = instantiate_client(ToolKitClient)
+        return self.client
+
+    def import_toolkit(self, tools: Optional[List[str]] = None, app_id: Optional[List[str]] = None):
+        if not is_local_dev():
+            logger.error("This functionality is only available for Local Environments")
+            sys.exit(1)
+
+        if app_id and isinstance(app_id, str):
+            app_id = [app_id]
+        elif not app_id:
+            app_id = []
+
+        validate_params(kind=self.kind)
+
+        remapped_connections = self._remap_connections(app_id)
+
+        client = self.get_client()
+        draft_toolkits = client.get_draft_by_name(toolkit_name=self.name)
+        if len(draft_toolkits) > 0:
+            logger.error(f"Existing toolkit found with name '{self.name}'. Failed to create toolkit.")
+            sys.exit(1)
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Handle zip file or directory
+            if self.package_root.endswith(".zip") and os.path.isfile(self.package_root):
+                zip_file_path = self.package_root
+            else:
+                zip_file_path = os.path.join(tmpdir, os.path.basename(f"{self.package_root.rstrip(os.sep)}.zip"))
+                with zipfile.ZipFile(zip_file_path, "w", zipfile.ZIP_DEFLATED) as mcp_zip_tool_artifacts:
+                    self._populate_zip(self.package_root, mcp_zip_tool_artifacts)
+
+            try:
+                command_parts = json.loads(self.command)
+                if not isinstance(command_parts, list):
+                    raise ValueError("JSON command must be a list of strings")
+            except (json.JSONDecodeError, ValueError):
+                command_parts = self.command.split()
+
+            command = command_parts[0]
+            args = command_parts[1:]
+
+            console = Console()
+            # List tools if not provided
+            if tools is None:
+                with Progress(
+                    SpinnerColumn(spinner_name="dots"),
+                    TextColumn("[progress.description]{task.description}"),
+                    transient=True,
+                    console=console,
+                ) as progress:
+                    progress.add_task(description="No tools specified, retrieving all tools from provided MCP server", total=None)
+                    tools = self.get_client().list_tools(
+                    zip_file_path=zip_file_path,
+                    command=command,
+                    args=args,
+                )
+                # Normalize tools to a list of tool names
+                tools = [
+                    tool["name"] if isinstance(tool, dict) and "name" in tool else tool
+                    for tool in tools
+                ]
+
+
+                logger.info("✅ The following tools will be imported:")
+                for tool in tools:
+                    console.print(f"  • {tool}")
+
+
+            # Create toolkit metadata
+            payload = {
+                "name": self.name,
+                "description": self.description,
+                "mcp": {
+                    "source": "files",
+                    "command": command,
+                    "args": args,
+                    "tools": tools,
+                    "connections": remapped_connections,
+                }
+            }
+            toolkit = self.get_client().create_toolkit(payload)
+            toolkit_id = toolkit["id"]
+
+            console = Console()
+            # Upload zip file
+            with Progress(
+                SpinnerColumn(spinner_name="dots"),
+                TextColumn("[progress.description]{task.description}"),
+                transient=True,
+                console=console,
+            ) as progress:
+                progress.add_task(description="Uploading toolkit zip file...", total=None)
+                self.get_client().upload(toolkit_id=toolkit_id, zip_file_path=zip_file_path)
+            logger.info(f"Successfully imported tool kit {self.name}")
+
+    def _populate_zip(self, package_root: str, zipfile: zipfile.ZipFile) -> str:
+        for root, _, files in os.walk(package_root):
+            for file in files:
+                full_path = os.path.join(root, file)
+                relative_path = os.path.relpath(full_path, start=package_root)
+                zipfile.write(full_path, arcname=relative_path)
+        return zipfile
+
+    def _remap_connections(self, app_ids: List[str]):
+        app_id_dict = {}
+        for app_id in app_ids:        
+            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:
+                runtime_id, local_id = split_id
+            elif len(split_id) == 1:
+                runtime_id = split_id[0]
+                local_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 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)
+            app_id_dict[runtime_id] = get_connection_id(local_id)
+
+        return app_id_dict
+
+    
+    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)
+            if len(draft_toolkits) > 1:
+                logger.error(f"Multiple existing toolkits found with name '{name}'. Failed to remove toolkit")
+                sys.exit(1)
+            if len(draft_toolkits) > 0:
+                draft_toolkit = draft_toolkits[0]
+                toolkit_id = draft_toolkit.get("id")
+                self.get_client().delete(toolkit_id=toolkit_id)
+                logger.info(f"Successfully removed tool {name}")
+            else:
+                logger.warning(f"No toolkit named '{name}' found")
+        except requests.HTTPError as e:
+            logger.error(e.response.text)
+            exit(1)

ibm_watsonx_orchestrate/cli/commands/tools/tools_controller.py

@@ -27,8 +27,9 @@ from ibm_watsonx_orchestrate.cli.config import Config, CONTEXT_SECTION_HEADER, C
     DEFAULT_CONFIG_FILE_CONTENT
 from ibm_watsonx_orchestrate.agent_builder.connections import ConnectionSecurityScheme, ExpectedCredentials
 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
+from ibm_watsonx_orchestrate.client.utils import instantiate_client, is_local_dev
 from ibm_watsonx_orchestrate.utils.utils import sanatize_app_id
 
 from  ibm_watsonx_orchestrate import __version__
@@ -41,6 +42,7 @@ __supported_characters_pattern = re.compile("^(\\w|_)+$")
 class ToolKind(str, Enum):
     openapi = "openapi"
     python = "python"
+    mcp = "mcp"
     # skill = "skill"
 
 def validate_app_ids(kind: ToolKind, **args) -> None:
@@ -275,14 +277,8 @@ def import_python_tool(file: str, requirements_file: str = None, app_id: List[st
     resolved_requirements_file = get_resolved_py_tool_reqs_file(tool_file=file, requirements_file=requirements_file,
                                                                 package_root=resolved_package_root)
 
-    if resolved_requirements_file is None:
-        logger.warning(f"No requirements file.")
-
-    if resolved_requirements_file != requirements_file:
-        logger.info(f"Resolved Requirements file: \"{resolved_requirements_file}\"")
-
-    else:
-        logger.info(f"Requirements file: \"{requirements_file}\"")
+    if resolved_requirements_file is not None:
+        logger.info(f"Using requirement file: \"{resolved_requirements_file}\"")
 
     if resolved_requirements_file is not None:
         try:
@@ -374,21 +370,24 @@ class ToolsController:
         response = self.get_client().get()
         tool_specs = [ToolSpec.model_validate(tool) for tool in response]
         tools = [BaseTool(spec=spec) for spec in tool_specs]
-        
 
         if verbose:
             tools_list = []
             for tool in tools:
-
                 tools_list.append(json.loads(tool.dumps_spec()))
 
             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", "App ID"]
+            columns = ["Name", "Description", "Permission", "Type", "Toolkit", "App ID"]
             for column in columns:
                 table.add_column(column)
-            
+
+            connections_client = get_connections_client()
+            connections = connections_client.list()
+
+            connections_dict = {conn.connection_id: conn for conn in connections}
+
             for tool in tools:
                 tool_binding = tool.__tool_spec__.binding
                 
@@ -400,25 +399,49 @@ class ToolsController:
                     elif tool_binding.python is not None and hasattr(tool_binding.python, "connections") and tool_binding.python.connections is not None:
                         for conn in tool_binding.python.connections:
                             connection_ids.append(tool_binding.python.connections[conn])
-                
-                connections_client = get_connections_client()
+                    elif tool_binding.mcp is not None and hasattr(tool_binding.mcp, "connections"):
+                        for conn in tool_binding.mcp.connections:
+                            connection_ids.append(tool_binding.mcp.connections[conn])
+
+
                 app_ids = []
                 for connection_id in connection_ids:
-                    app_id = str(connections_client.get_draft_by_id(connection_id))
+                    connection = connections_dict.get(connection_id)
+                    if connection:
+                        app_id = str(connection.app_id or connection.connection_id)
+                    elif connection_id:
+                        app_id = str(connection_id)
+                    else:
+                        app_id = ""
                     app_ids.append(app_id)
 
                 if tool_binding.python is not None:
                         tool_type=ToolKind.python
                 elif tool_binding.openapi is not None:
                         tool_type=ToolKind.openapi
+                elif tool_binding.mcp is not None:
+                        tool_type=ToolKind.mcp
                 else:
                         tool_type="Unknown"
                 
+                toolkit_name = ""
+
+                if is_local_dev():
+                    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)
+
+                
                 table.add_row(
                     tool.__tool_spec__.name,
                     tool.__tool_spec__.description,
                     tool.__tool_spec__.permission,
                     tool_type,
+                    toolkit_name,
                     ", ".join(app_ids),
                 )
 
@@ -472,7 +495,7 @@ class ToolsController:
                                     raise typer.BadParameter(f"Symbolic links in packages are not supported. - {path_str}")
 
                                 try:
-                                    zip_tool_artifacts.write(path_str, arcname=path_str[len(str(Path(resolved_package_root))) + 1:])
+                                    zip_tool_artifacts.write(path_str, arcname=str(Path(path_str).relative_to(Path(resolved_package_root))))
 
                                 except Exception as ex:
                                     logger.error(f"Could not write file {path_str} to artifact. {ex}")

ibm_watsonx_orchestrate/cli/config.py

@@ -12,6 +12,8 @@ AUTH_SECTION_HEADER = "auth"
 CONTEXT_SECTION_HEADER = "context"
 ENVIRONMENTS_SECTION_HEADER = "environments"
 PYTHON_REGISTRY_HEADER = "python_registry"
+USER_ENV_CACHE_HEADER = "cached_user_env"
+LICENSE_HEADER = "license"
 
 # Option Names
 AUTH_MCSP_API_KEY_OPT = "wxo_mcsp_api_key"
@@ -24,6 +26,7 @@ ENV_WXO_URL_OPT = "wxo_url"
 ENV_IAM_URL_OPT = "iam_url"
 PROTECTED_ENV_NAME = "local"
 ENV_AUTH_TYPE = "auth_type"
+ENV_ACCEPT_LICENSE = 'accepts_license_agreements'
 
 DEFAULT_LOCAL_SERVICE_URL = "http://localhost:4321"
 CHAT_UI_PORT = "3000"
@@ -40,7 +43,8 @@ DEFAULT_CONFIG_FILE_CONTENT = {
         PROTECTED_ENV_NAME: {
             ENV_WXO_URL_OPT: DEFAULT_LOCAL_SERVICE_URL
         }
-    }
+    },
+    USER_ENV_CACHE_HEADER: {}
 }
 
 AUTH_CONFIG_FILE_FOLDER = f"{os.path.expanduser('~')}/.cache/orchestrate"

ibm_watsonx_orchestrate/cli/main.py

@@ -11,6 +11,7 @@ from ibm_watsonx_orchestrate.cli.commands.models.models_command import models_ap
 from ibm_watsonx_orchestrate.cli.commands.environment.environment_command import environment_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
 
 app = typer.Typer(
     no_args_is_help=True,
@@ -18,15 +19,16 @@ app = typer.Typer(
 )
 app.add_typer(login_app)
 app.add_typer(environment_app, name="env", help='Add, remove, or select the activate env other commands will interact with (either your local server or a production instance)')
-app.add_typer(tools_app, name="tools", help='Interact with the tools in your active env')
 app.add_typer(agents_app, name="agents", help='Interact with the agents in your active env')
+app.add_typer(tools_app, name="tools", help='Interact with the tools in your active env')
+app.add_typer(toolkits_app, name="toolkits", help="Interact with the toolkits in your active env")
+app.add_typer(knowledge_bases_app, name="knowledge-bases", help="Upload knowledge your agents can search through to your active env")
 app.add_typer(connections_app, name="connections", help='Interact with the agents in your active env')
-app.add_typer(server_app, name="server", help='Manipulate your local wxo lite server [requires docker pull credentials]')
-app.add_typer(chat_app, name="chat", help='Launch the chat ui for your local list wxo lite server [requires docker pull credentials]')
+app.add_typer(server_app, name="server", help='Manipulate your local Orchestrate Developer Edition server [requires entitlement]')
+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(settings_app, name="settings", help='Configure the settings for your active env')
-app.add_typer(channel_app, name="channels")
-app.add_typer(knowledge_bases_app, name="knowledge-bases")
 
 if __name__ == "__main__":
     app()

ibm_watsonx_orchestrate/client/toolkit/toolkit_client.py

@@ -0,0 +1,81 @@
+from ibm_watsonx_orchestrate.client.base_api_client import BaseAPIClient, ClientAPIException
+from typing_extensions import List
+import os
+import json
+
+class ToolKitClient(BaseAPIClient):
+    # POST /toolkits/prepare/list-tools
+    def list_tools(self, zip_file_path: str, command: str, args: List[str]) -> List[str]:
+        """
+        List the available tools inside the MCP server
+        """
+
+        filename = os.path.basename(zip_file_path)
+
+        list_toolkit_obj = {
+            "source": "files",
+            "command": command,
+            "args": args,
+        }
+
+        with open(zip_file_path, "rb") as f:
+            files = {
+                "list_toolkit_obj": (None, json.dumps(list_toolkit_obj), "application/json"),
+                "file": (filename, f, "application/zip"),
+            }
+
+            response = self._post("/orchestrate/toolkits/prepare/list-tools", files=files)
+
+        return response.get("tools", [])
+
+
+    # POST /api/v1/orchestrate/toolkits
+    def create_toolkit(self, payload) -> dict:
+        """
+        Creates new toolkit metadata
+        """
+        try:
+            return self._post("/orchestrate/toolkits", data=payload)
+        except ClientAPIException as e:
+            if e.response.status_code == 400 and "already exists" in e.response.text:
+                raise ClientAPIException(
+                    status_code=400,
+                    message=f"There is already a Toolkit with the same name that exists for this tenant."
+                )
+            raise(e)
+    
+    # POST /toolkits/{toolkit-id}/upload
+    def upload(self, toolkit_id: str, zip_file_path: str) -> dict:
+        """
+        Upload zip file to the toolkit.
+        """
+        filename = os.path.basename(zip_file_path)
+        with open(zip_file_path, "rb") as f:
+            files = {
+                "file": (filename, f, "application/zip", {"Expires": "0"})
+            }
+            return self._post(f"/orchestrate/toolkits/{toolkit_id}/upload", files=files)
+        
+    # DELETE /toolkits/{toolkit-id} 
+    def delete(self, toolkit_id: str) -> dict:
+        return self._delete(f"/orchestrate/toolkits/{toolkit_id}")
+
+    def get_draft_by_name(self, toolkit_name: str) -> List[dict]:
+        return self.get_drafts_by_names([toolkit_name])
+
+    def get_drafts_by_names(self, toolkit_names: List[str]) -> List[dict]:
+        formatted_toolkit_names = [f"names={x}" for x in toolkit_names]
+        return self._get(f"/orchestrate/toolkits?{'&'.join(formatted_toolkit_names)}")
+    
+    def get_draft_by_id(self, toolkit_id: str) -> dict:
+        if toolkit_id is None:
+            return ""
+        else:
+            try:
+                toolkit = self._get(f"/orchestrate/toolkits/{toolkit_id}")
+                return toolkit
+            except ClientAPIException as e:
+                if e.response.status_code == 404 and "not found with the given name" in e.response.text:
+                    return ""
+                raise(e)
+

ibm_watsonx_orchestrate/docker/compose-lite.yml

@@ -13,7 +13,7 @@ services:
     command: redis-server --loglevel warning
 
   wxo-server-db:
-    image: us.icr.io/${DB_REGISTRY:-watson-orchestrate-private}/wxo-server-db:${DBTAG:-latest}
+    image: ${DB_REGISTRY:-us.icr.io/watson-orchestrate-private}/wxo-server-db:${DBTAG:-latest}
     restart: unless-stopped
     environment:
       POSTGRES_USER: ${POSTGRES_USER:-postgres}
@@ -32,7 +32,7 @@ services:
     command: -c shared_preload_libraries=pgsodium
 
   wxo-server-connection-manager:
-    image: us.icr.io/${CM_REGISTRY:-watson-orchestrate-private}/wxo-connections:${CM_TAG:-latest}
+    image: ${CM_REGISTRY:-us.icr.io/watson-orchestrate-private}/wxo-connections:${CM_TAG:-latest}
     platform: linux/amd64
     restart: unless-stopped
     environment:
@@ -44,12 +44,13 @@ services:
       DB_PORT: ${DB_PORT:-5432}
       DB_ENCRYPTION_KEY: abc
       WXO_SERVER_URL: http://wxo-server:4321
-      MAX_POOL: 10
+      MAX_POOL: 60
+      DEPLOYMENT_MODE: laptop
     ports:
       - 3001:3001
 
   ui:
-    image: us.icr.io/${UI_REGISTRY:-watson-orchestrate-private}/wxo-chat:${UITAG:-latest}
+    image: ${UI_REGISTRY:-us.icr.io/watson-orchestrate-private}/wxo-chat:${UITAG:-latest}
     platform: linux/amd64
     restart: unless-stopped
     environment:
@@ -74,6 +75,7 @@ services:
       MAX_FILE_UPLOAD_SIZE_BYTES_EXCEL: 1048576
       VCAP_APP_HOST: localhost
       DEPLOYMENT_PLATFORM: laptop
+      CONNECTION_MANAGER_URL: http://localhost:3001
       DISMISS_NOTIFICATION_TIMEOUT: 10000
       STANDALONE: "true"
       STREAM_TIMEOUT: ${STREAM_TIMEOUT:-120000}
@@ -87,7 +89,7 @@ services:
       - ui-data:/data
 
   wxo-builder:
-    image: us.icr.io/${BUILDER_REGISTRY:-watson-orchestrate-private}/wxo-builder:${BUILDER_TAG:-latest}
+    image: ${BUILDER_REGISTRY:-us.icr.io/watson-orchestrate-private}/wxo-builder:${BUILDER_TAG:-latest}
     platform: linux/amd64
     restart: unless-stopped
     environment:
@@ -199,7 +201,7 @@ services:
       - wxo-server-redis
 
   wxo-server:
-    image: us.icr.io/${SERVER_REGISTRY:-watson-orchestrate-private}/wxo-server-server:${SERVER_TAG:-latest}
+    image: ${SERVER_REGISTRY:-us.icr.io/watson-orchestrate-private}/wxo-server-server:${SERVER_TAG:-latest}
     platform: linux/amd64
     restart: unless-stopped
     ports:
@@ -294,7 +296,7 @@ services:
       MILVUS_PASSWORD: Milvus
 
   wxo-server-worker:
-    image: us.icr.io/${WORKER_REGISTRY:-watson-orchestrate-private}/wxo-server-conversation_controller:${WORKER_TAG:-latest}
+    image: ${WORKER_REGISTRY:-us.icr.io/watson-orchestrate-private}/wxo-server-conversation_controller:${WORKER_TAG:-latest}
     platform: linux/amd64
     restart: unless-stopped
     depends_on:
@@ -372,7 +374,7 @@ services:
       MILVUS_PASSWORD: Milvus
   
   tools-runtime-manager:
-    image: us.icr.io/${TRM_REGISTRY:-watson-orchestrate-private}/tools-runtime-manager:${TRM_TAG:-latest}
+    image: ${TRM_REGISTRY:-us.icr.io/watson-orchestrate-private}/tools-runtime-manager:${TRM_TAG:-latest}
     platform: linux/amd64
     restart: unless-stopped
     ports:
@@ -409,7 +411,7 @@ services:
       - "host.docker.internal:host-gateway"
 
   tools-runtime:
-    image: us.icr.io/${TR_REGISTRY:-watson-orchestrate-private}/tools-runtime:${TR_TAG:-latest}
+    image: ${TR_REGISTRY:-us.icr.io/watson-orchestrate-private}/tools-runtime:${TR_TAG:-latest}
     platform: linux/amd64
     ports:
       - "8000:8000"
@@ -527,7 +529,7 @@ services:
 
 
   wxo-tempus-runtime:
-    image: us.icr.io/watson-orchestrate-private/wxo-tempus-runtime:${FLOW_RUNTIME_TAG:-latest}
+    image: ${FLOW_RUMTIME_REGISTRY:-us.icr.io/watson-orchestrate-private}/wxo-tempus-runtime:${FLOW_RUNTIME_TAG:-latest}
     restart: unless-stopped
     platform: linux/amd64
     profiles: [with-tempus-runtime]
@@ -593,3 +595,4 @@ volumes:
 networks:
   default:
     name: wxo-server
+    

ibm_watsonx_orchestrate/docker/default.env

@@ -1,4 +1,3 @@
-REGISTRY_URL=us.icr.io
 #DOCKER_IAM_KEY=dummy #Must Define in env
 #You can generate any JWT_SECRET with python -c 'import secrets; print(secrets.token_hex(32))'
 JWT_SECRET=11759cbc89dbec64956715e10a854eb38f8b7a1775bdf68142786170f5e8b5b2
@@ -47,35 +46,39 @@ CELERY_RESULTS_TTL="3600"
 EVENT_BROKER_TTL="-1"
 
 # START -- IMAGE REGISTRIES AND TAGS
-SERVER_TAG=29-04-2025
-SERVER_REGISTRY=watson-orchestrate-private
+# THE VALUES FOR REGISTRY_URL AND *_REGISTRY ARE NOT SET HERE; THEY ARE EITHER PROVIDED BY THE USER OR DETERMINED AT RUNTIME BASED ON WO_DEVELOPER_EDITION_SOURCE.
+REGISTRY_URL=
 
-WORKER_TAG=29-04-2025
-WORKER_REGISTRY=watson-orchestrate-private
+SERVER_TAG=03-05-2025
+SERVER_REGISTRY=
 
-DB_REGISTRY=watson-orchestrate-private
+WORKER_TAG=03-05-2025
+WORKER_REGISTRY=
+
+DB_REGISTRY=
 # If you build multiarch set all three of these to the same, we have a pr against main
 # to not have this separation, but we can merge it later
-DBTAG=29-04-2025
-AMDDBTAG=22-04-2025
-ARM64DBTAG=22-04-2025
+DBTAG=02-05-2025
+AMDDBTAG=02-05-2025
+ARM64DBTAG=02-05-2025
 
-UI_REGISTRY=watson-orchestrate-private
-UITAG=29-04-2025
+UI_REGISTRY=
+UITAG=01-05-2025
 
-CM_REGISTRY=watson-orchestrate-private
+CM_REGISTRY=
 CM_TAG=30-04-2025
 
-TRM_TAG=30-04-2025
-TRM_REGISTRY=watson-orchestrate-private
+TRM_TAG=02-05-2025
+TRM_REGISTRY=
 
-TR_TAG=30-04-2025
-TR_REGISTRY=watson-orchestrate-private
+TR_TAG=02-05-2025
+TR_REGISTRY=
 
-BUILDER_REGISTRY=watson-orchestrate-private
-BUILDER_TAG=29-04-2025
+BUILDER_REGISTRY=
+BUILDER_TAG=02-05-2025
 
 FLOW_RUNTIME_TAG=31-03-2025
+FLOW_RUMTIME_REGISTRY=
 
 # END -- IMAGE REGISTRIES AND TAGS
 

{ibm_watsonx_orchestrate-1.0.1.dist-info → ibm_watsonx_orchestrate-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ibm-watsonx-orchestrate
-Version: 1.0.1
+Version: 1.2.0
 Summary: IBM watsonx.orchestrate SDK
 Author-email: IBM <support@ibm.com>
 License: MIT License

{ibm_watsonx_orchestrate-1.0.1.dist-info → ibm_watsonx_orchestrate-1.2.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-ibm_watsonx_orchestrate/__init__.py,sha256=SrlQDGttogEX9VFQltBr-eZPkFA_rUB44zQv2zVKDN4,424
+ibm_watsonx_orchestrate/__init__.py,sha256=QYUW_dfyamR2JbmoR89HSm5oP6_1q9B_-nA05eXp5BI,425
 ibm_watsonx_orchestrate/agent_builder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ibm_watsonx_orchestrate/agent_builder/agents/__init__.py,sha256=v4G0MGh11eOCkUJP_4AMOcFgzW14oE41G3iFp7G2vvw,376
 ibm_watsonx_orchestrate/agent_builder/agents/agent.py,sha256=PcBg2dRi-IOzvl24u8fa3B0jLaM5hzgkpTS8k56L9Ag,919
@@ -14,13 +14,13 @@ ibm_watsonx_orchestrate/agent_builder/knowledge_bases/types.py,sha256=yvtf4zM0Ms
 ibm_watsonx_orchestrate/agent_builder/tools/__init__.py,sha256=adkYX0wgB-RKFCUBw6LPJhNVelUjUdsxipGPk2ghLns,479
 ibm_watsonx_orchestrate/agent_builder/tools/base_tool.py,sha256=unJBOJUY8DAq3T3YX5d1H5KehJUCjObAdpGLVoWIfzw,1156
 ibm_watsonx_orchestrate/agent_builder/tools/openapi_tool.py,sha256=GD2yQkBSRHcnyq1LqA3crfo05rruqCj9vBS9xVDR2r0,14738
-ibm_watsonx_orchestrate/agent_builder/tools/python_tool.py,sha256=wvJVC4VJuedkld_JFib1Le3o958bIvo7qhBr0VEI7wc,7940
-ibm_watsonx_orchestrate/agent_builder/tools/types.py,sha256=lA_BxWR_vQ0KTGYh3V0LPtNx9jG-IhwuptFf-VzhZAk,5280
+ibm_watsonx_orchestrate/agent_builder/tools/python_tool.py,sha256=gh38bToYRnoqmsoR7pHCwqQTI6ENbxOPOV5aVSqECrg,8359
+ibm_watsonx_orchestrate/agent_builder/tools/types.py,sha256=LcMEWTUYx_bAKK_gA8Uav-hSU5qsKl4_lJ7oWYgdfLc,5813
 ibm_watsonx_orchestrate/agent_builder/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ibm_watsonx_orchestrate/agent_builder/utils/pydantic_utils.py,sha256=QEanM6FpkmntvS02whdhWx1d4v6zT_1l9ipEbfTgHs8,7623
 ibm_watsonx_orchestrate/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ibm_watsonx_orchestrate/cli/config.py,sha256=v-Yse4QnjEFrs_sT90tjL86BRsmp1LDn2YJbyikGWQY,8018
-ibm_watsonx_orchestrate/cli/main.py,sha256=AZtBEb1Dm_gh1uo98AnMo-D_LKhsLIUrRx-xJFnprog,2177
+ibm_watsonx_orchestrate/cli/config.py,sha256=C_iSP6WSb5SO6cVPTueQ9lEX16gYOLXD12cKXD6w_KQ,8168
+ibm_watsonx_orchestrate/cli/main.py,sha256=Tey0gm3_z4JUbrKMSVFh_PEbCQqUGCohvnHRAU73KQA,2522
 ibm_watsonx_orchestrate/cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ibm_watsonx_orchestrate/cli/commands/agents/agents_command.py,sha256=GVHM1wv28zGzOcc__3BXHt0Y5NXZuOr7PH8exwVqn-o,6640
 ibm_watsonx_orchestrate/cli/commands/agents/agents_controller.py,sha256=mOoBwLltv5dpGdawoyXClUIsO3bIpZLOXrIXZ7Cney4,27920
@@ -39,15 +39,17 @@ ibm_watsonx_orchestrate/cli/commands/knowledge_bases/knowledge_bases_command.py,
 ibm_watsonx_orchestrate/cli/commands/knowledge_bases/knowledge_bases_controller.py,sha256=mK9rMzslwIYDx8ebUs7QHVYAak6xm830_pKu3xH6F-s,8245
 ibm_watsonx_orchestrate/cli/commands/login/login_command.py,sha256=xArMiojoozg7Exn6HTpbTcjDO2idZRA-y0WV-_Ic1Sk,651
 ibm_watsonx_orchestrate/cli/commands/models/models_command.py,sha256=lxh0YpATogJRroHItwVuHmsZlHctVzWw_dEWkJlbwOI,4893
-ibm_watsonx_orchestrate/cli/commands/server/server_command.py,sha256=BRUUsZQddPSTSFQywFdJkqKtcxcWFwbIOf11WLx7sTQ,21976
+ibm_watsonx_orchestrate/cli/commands/server/server_command.py,sha256=fleb0JwH1PJ67M4ArL5l4vxoJAK1mtsIRFjHWSsKenI,28774
 ibm_watsonx_orchestrate/cli/commands/settings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ibm_watsonx_orchestrate/cli/commands/settings/settings_command.py,sha256=CzXRkd-97jXyS6LtaaNtMah-aZu0919dYl-mDwzGThc,344
 ibm_watsonx_orchestrate/cli/commands/settings/observability/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ibm_watsonx_orchestrate/cli/commands/settings/observability/observability_command.py,sha256=TAkpKwoqocsShSgEeR6LzHCzJx16VDQ6cYsbpljxeqI,372
 ibm_watsonx_orchestrate/cli/commands/settings/observability/langfuse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ibm_watsonx_orchestrate/cli/commands/settings/observability/langfuse/langfuse_command.py,sha256=Wa0L8E44EdxH9LdOvmnluLk_ApJVfTLauNOC1kV4W8k,6515
+ibm_watsonx_orchestrate/cli/commands/toolkit/toolkit_command.py,sha256=hsVazoC25DUHtCFt3nmzkF5Eai59-tnNIJR51Emjk0E,2494
+ibm_watsonx_orchestrate/cli/commands/toolkit/toolkit_controller.py,sha256=QRVyfXJAOHA4D5pgVcq7m4TnKwSSwwtyns3_rKc1Jcc,8499
 ibm_watsonx_orchestrate/cli/commands/tools/tools_command.py,sha256=2GK5AKwEYXsOZaASG15J8yNIPakI0NYkSXBTkeuHj6s,3343
-ibm_watsonx_orchestrate/cli/commands/tools/tools_controller.py,sha256=vjOncBJ3K7hGaEo-SjzURm_DZ_mToTithwuuzkjn82M,26468
+ibm_watsonx_orchestrate/cli/commands/tools/tools_controller.py,sha256=i6JmF0sObMmIVWuWH2DVCirKLLW-NkFtj7n06dg3Yos,27688
 ibm_watsonx_orchestrate/cli/commands/tools/types.py,sha256=_md0GEa_cTH17NO_moWDY_LNdFvyEFQ1UVB9_FltYiA,173
 ibm_watsonx_orchestrate/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ibm_watsonx_orchestrate/client/base_api_client.py,sha256=0ozLUudIrQH0RTdKaX0Y5c35FRNZPTemaAp71AsoMsQ,4410
@@ -68,9 +70,10 @@ ibm_watsonx_orchestrate/client/connections/__init__.py,sha256=u821r2ZiYXLYNTknxd
 ibm_watsonx_orchestrate/client/connections/connections_client.py,sha256=aenYRfywM0lPlJWipFuy-Dnp2ljmpeP11oaWvPd69sA,7053
 ibm_watsonx_orchestrate/client/connections/utils.py,sha256=XqgYoiehiqIZ-LnduIAiJ9DIIF7IR7QvkKTc9784Ii0,1326
 ibm_watsonx_orchestrate/client/knowledge_bases/knowledge_base_client.py,sha256=U-pG_H0I8992f0V13Li_e1dksKp54MrYX3X9bvr-09w,2181
+ibm_watsonx_orchestrate/client/toolkit/toolkit_client.py,sha256=1ZcOcjULV8xXqEVQpuDx_Nhh3dOFC2DA-RXMddl-wH0,2974
 ibm_watsonx_orchestrate/client/tools/tool_client.py,sha256=pEKOBH488YbLVc71ucucX0rr8YoulvDCxejuyWd0K8s,1588
-ibm_watsonx_orchestrate/docker/compose-lite.yml,sha256=T_d2xi20fNX8fwByhkAErXf21BLIWz-F2alsvvWhD9c,24575
-ibm_watsonx_orchestrate/docker/default.env,sha256=0dGbBljxmmxOxEGNP1vgVlQ9dxv9Ii6h_3p0QviEtnY,4639
+ibm_watsonx_orchestrate/docker/compose-lite.yml,sha256=Br6wNrRNYVYeIpc4q_Usc-ENK0RzccE-67GSlYhwggw,24688
+ibm_watsonx_orchestrate/docker/default.env,sha256=kuLLcXI24G4plLW8_7Af9K8VEVpt_zAhCOL1p-FVqS0,4609
 ibm_watsonx_orchestrate/docker/start-up.sh,sha256=LTtwHp0AidVgjohis2LXGvZnkFQStOiUAxgGABOyeUI,1811
 ibm_watsonx_orchestrate/docker/sdk/ibm_watsonx_orchestrate-0.6.0-py3-none-any.whl,sha256=Hi3-owh5OM0Jz2ihX9nLoojnr7Ky1TV-GelyqLcewLE,2047417
 ibm_watsonx_orchestrate/docker/sdk/ibm_watsonx_orchestrate-0.6.0.tar.gz,sha256=e5T-q7XPAtiCyQljwZp6kk3Q_4Tg6y5sijHTkscmqqQ,2025466
@@ -82,8 +85,8 @@ ibm_watsonx_orchestrate/utils/utils.py,sha256=3JWk1J9A04yVZeetE3TQH82I53Sn20KvU_
 ibm_watsonx_orchestrate/utils/logging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ibm_watsonx_orchestrate/utils/logging/logger.py,sha256=FzeGnidXAjC7yHrvIaj4KZPeaBBSCniZFlwgr5yV3oA,1037
 ibm_watsonx_orchestrate/utils/logging/logging.yaml,sha256=9_TKfuFr1barnOKP0fZT5D6MhddiwsXVTFjtRbcOO5w,314
-ibm_watsonx_orchestrate-1.0.1.dist-info/METADATA,sha256=HAjcx8665Xir9Y1n3SkqrK1anhiDNs3bMvIItdHd1dY,1251
-ibm_watsonx_orchestrate-1.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ibm_watsonx_orchestrate-1.0.1.dist-info/entry_points.txt,sha256=SfIT02-Jen5e99OcLhzbcM9Bdyf8SGVOCtnSplgZdQI,69
-ibm_watsonx_orchestrate-1.0.1.dist-info/licenses/LICENSE,sha256=Shgxx7hTdCOkiVRmfGgp_1ISISrwQD7m2f0y8Hsapl4,1083
-ibm_watsonx_orchestrate-1.0.1.dist-info/RECORD,,
+ibm_watsonx_orchestrate-1.2.0.dist-info/METADATA,sha256=ecvKQFIj26BZT-5M9fPjcfs371MR-NQIV89qrn6GNRQ,1251
+ibm_watsonx_orchestrate-1.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ibm_watsonx_orchestrate-1.2.0.dist-info/entry_points.txt,sha256=SfIT02-Jen5e99OcLhzbcM9Bdyf8SGVOCtnSplgZdQI,69
+ibm_watsonx_orchestrate-1.2.0.dist-info/licenses/LICENSE,sha256=Shgxx7hTdCOkiVRmfGgp_1ISISrwQD7m2f0y8Hsapl4,1083
+ibm_watsonx_orchestrate-1.2.0.dist-info/RECORD,,