ibm-watsonx-orchestrate 1.0.1__tar.gz → 1.2.0__tar.gz

{ibm_watsonx_orchestrate-1.0.1 → ibm_watsonx_orchestrate-1.2.0}/PKG-INFO

@@ -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 → ibm_watsonx_orchestrate-1.2.0}/src/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-1.0.1 → ibm_watsonx_orchestrate-1.2.0}/src/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-1.0.1 → ibm_watsonx_orchestrate-1.2.0}/src/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-1.0.1 → ibm_watsonx_orchestrate-1.2.0}/src/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-1.2.0/src/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)