ibm-watsonx-orchestrate 1.7.0a0__py3-none-any.whl → 1.8.0b0__py3-none-any.whl

ibm_watsonx_orchestrate/cli/commands/evaluations/evaluations_command.py

@@ -5,10 +5,12 @@ import os
 import yaml
 import csv
 import rich
-from pathlib import Path
 import sys
-from dotenv import dotenv_values
+import shutil
 
+from rich.panel import Panel
+from pathlib import Path
+from dotenv import dotenv_values
 from typing import Optional
 from typing_extensions import Annotated
 
@@ -46,6 +48,32 @@ def validate_watsonx_credentials(user_env_file: str) -> bool:
     os.environ.update({key: user_env[key] for key in required_keys})
     logger.info("WatsonX credentials validated successfully.")
 
+def read_csv(data_path: str, delimiter="\t"):
+    data = []
+    with open(data_path, "r") as f:
+        tsv_reader = csv.reader(f, delimiter=delimiter)
+        for line in tsv_reader:
+            data.append(line)
+    
+    return data
+
+def performance_test(agent_name, data_path, output_dir = None, user_env_file = None):
+    test_data = read_csv(data_path)
+
+    controller = EvaluationsController()
+    generated_performance_tests = controller.generate_performance_test(agent_name, test_data)
+    
+    generated_perf_test_dir = Path(output_dir) / "generated_performance_tests"
+    generated_perf_test_dir.mkdir(exist_ok=True, parents=True)
+
+    for idx, test in enumerate(generated_performance_tests):
+        test_name = f"validate_external_agent_evaluation_test_{idx}.json"
+        with open(generated_perf_test_dir / test_name, encoding="utf-8", mode="w+") as f:
+            json.dump(test, f, indent=4)
+
+    rich.print(f"Performance test cases saved at path '{str(generated_perf_test_dir)}'")
+    rich.print("[gold3]Running Performance Test")
+    evaluate(output_dir=output_dir, test_paths=str(generated_perf_test_dir))
 
 @evaluation_app.command(name="evaluate", help="Evaluate an agent against a set of test cases")
 def evaluate(
@@ -115,7 +143,7 @@ def generate(
     stories_path: Annotated[
         str,
         typer.Option(
-            "--stories_path", "-s",
+            "--stories-path", "-s",
             help="Path to the CSV file containing user stories for test case generation. "
                  "The file has 'story' and 'agent' columns."
         )
@@ -123,14 +151,14 @@ def generate(
     tools_path: Annotated[
         str,
         typer.Option(
-            "--tools_path", "-t",
+            "--tools-path", "-t",
             help="Path to the directory containing tool definitions."
         )
     ],
     output_dir: Annotated[
         Optional[str],
         typer.Option(
-            "--output_dir", "-o",
+            "--output-dir", "-o",
             help="Directory to save the generated test cases."
         )
     ] = None,
@@ -151,7 +179,7 @@ def generate(
 def analyze(data_path: Annotated[
         str,
         typer.Option(
-            "--data_path", "-d",
+            "--data-path", "-d",
             help="Path to the directory that has the saved results"
         )
     ],
@@ -167,30 +195,31 @@ def analyze(data_path: Annotated[
     controller = EvaluationsController()
     controller.analyze(data_path=data_path)
 
-
-@evaluation_app.command(name="validate_external", help="Validate an external agent against a set of inputs")
+@evaluation_app.command(name="validate-external", help="Validate an external agent against a set of inputs")
 def validate_external(
     data_path: Annotated[
         str,
         typer.Option(
-            "--csv", "-c",
-            help="Path to .csv file of inputs"
+            "--tsv", "-t",
+            help="Path to .tsv file of inputs"
         )
     ],
-    config: Annotated[
+    external_agent_config: Annotated[
             str,
             typer.Option(
-                "--config", "-cf",
-                help="Path to the external agent yaml"
+                "--external-agent-config", "-ext",
+                help="Path to the external agent yaml",
+
             )
         ],
     credential: Annotated[
         str,
         typer.Option(
             "--credential", "-crd",
-            help="credential string"
+            help="credential string",
+            rich_help_panel="Parameters for Validation"
         )
-    ],
+    ] = None,
     output_dir: Annotated[
         str,
         typer.Option(
@@ -204,21 +233,80 @@ def validate_external(
             "--env-file", "-e", 
             help="Path to a .env file that overrides default.env. Then environment variables override both."
         ),
+    ] = None,
+    agent_name: Annotated[
+        str,
+        typer.Option(
+            "--agent_name", "-a",
+            help="Name of the native agent which has the external agent to test registered as a collaborater. See: https://developer.watson-orchestrate.ibm.com/agents/build_agent#native-agents)." \
+            " If this parameter is pased, validation of the external agent is not run.",
+            rich_help_panel="Parameters for Input Evaluation"
+        )
     ] = None
 ):
-    
+
     validate_watsonx_credentials(user_env_file)
-    with open(config, "r") as f:
-        config = yaml.safe_load(f)
-    controller = EvaluationsController()
-    test_data = []
-    with open(data_path, "r") as f:
-        csv_reader = csv.reader(f)
-        for line in csv_reader:
-            test_data.append(line[0])
-    results = controller.external_validate(config, test_data, credential)
-    os.makedirs(output_dir, exist_ok=True)
-    with open(os.path.join(output_dir, "validation_results.json"), "w") as f:
-        json.dump(results, f)
-
-    rich.print(f"[green] validation result is saved to {output_dir} [/green]")
+    Path(output_dir).mkdir(exist_ok=True)
+    shutil.copy(data_path, os.path.join(output_dir, "input_sample.tsv"))
+
+    if agent_name is not None:
+        eval_dir = os.path.join(output_dir, "evaluation")
+        if os.path.exists(eval_dir):
+            rich.print(f"[yellow]: found existing {eval_dir} in target directory. All content is removed.")
+            shutil.rmtree(os.path.join(output_dir, "evaluation"))
+        Path(eval_dir).mkdir(exist_ok=True)
+        # save external agent config even though its not used for evaluation
+        # it can help in later debugging customer agents
+        with open(os.path.join(eval_dir, "external_agent_cfg.yaml"), "w+") as f:
+            with open(external_agent_config, "r") as cfg:
+                external_agent_config = yaml.safe_load(cfg)
+            yaml.safe_dump(external_agent_config, f, indent=4)
+
+        rich.print(f"[gold3]Starting evaluation of inputs in '{data_path}' against '{agent_name}'[/gold3]")
+        performance_test(
+            agent_name=agent_name,
+            data_path=data_path,
+            output_dir=eval_dir,
+            user_env_file=user_env_file
+        )
+    
+    else:
+        with open(external_agent_config, "r") as f:
+            external_agent_config = yaml.safe_load(f)
+        controller = EvaluationsController()
+        test_data = []
+        with open(data_path, "r") as f:
+            csv_reader = csv.reader(f, delimiter="\t")
+            for line in csv_reader:
+                test_data.append(line[0])
+
+        # save validation results in "validation_results" sub-dir
+        validation_folder = Path(output_dir) / "validation_results"
+        if os.path.exists(validation_folder):
+            rich.print(f"[yellow]: found existing {validation_folder} in target directory. All content is removed.")
+            shutil.rmtree(validation_folder)
+        validation_folder.mkdir(exist_ok=True, parents=True)
+
+        # validate the inputs in the provided csv file
+        summary = controller.external_validate(external_agent_config, test_data, credential)
+        with open(validation_folder / "validation_results.json", "w") as f:
+            json.dump(summary, f, indent=4)
+        
+        # validate sample block inputs
+        rich.print("[gold3]Validating external agent to see if it can handle an array of messages.")
+        block_input_summary = controller.external_validate(external_agent_config, test_data, credential, add_context=True)
+        with open(validation_folder / "sample_block_validation_results.json", "w") as f:
+            json.dump(block_input_summary, f, indent=4)
+
+        user_validation_successful = all([item["success"] for item in summary])
+        block_validation_successful = all([item["success"] for item in block_input_summary])
+
+        if user_validation_successful and block_validation_successful:
+            msg = (
+                f"[green]Validation is successful. The result is saved to '{str(validation_folder)}'.[/green]\n"
+                "You can add the external agent as a collaborator agent. See: https://developer.watson-orchestrate.ibm.com/agents/build_agent#native-agents."
+            )
+        else:
+            msg = f"[dark_orange]Schema validation did not succeed. See '{str(validation_folder)}' for failures.[/dark_orange]"
+
+        rich.print(Panel(msg))

ibm_watsonx_orchestrate/cli/commands/evaluations/evaluations_controller.py

@@ -1,5 +1,6 @@
 import logging
-from typing import List, Dict, Optional
+import os.path
+from typing import List, Dict, Optional, Tuple
 import csv
 from pathlib import Path
 import rich
@@ -10,12 +11,13 @@ from wxo_agentic_evaluation.batch_annotate import generate_test_cases_from_stori
 from wxo_agentic_evaluation.arg_configs import TestConfig, AuthConfig, LLMUserConfig, ChatRecordingConfig, AnalyzeConfig
 from wxo_agentic_evaluation.record_chat import record_chats
 from wxo_agentic_evaluation.external_agent.external_validate import ExternalAgentValidation
+from wxo_agentic_evaluation.external_agent.performance_test import ExternalAgentPerformanceTest
 from ibm_watsonx_orchestrate import __version__
 from ibm_watsonx_orchestrate.cli.config import Config, ENV_WXO_URL_OPT, AUTH_CONFIG_FILE, AUTH_CONFIG_FILE_FOLDER, AUTH_SECTION_HEADER, AUTH_MCSP_TOKEN_OPT
 from ibm_watsonx_orchestrate.utils.utils import yaml_safe_load
 from ibm_watsonx_orchestrate.cli.commands.agents.agents_controller import AgentsController
 from ibm_watsonx_orchestrate.agent_builder.agents import AgentKind
-
+import uuid
 
 logger = logging.getLogger(__name__)
 
@@ -75,9 +77,13 @@ class EvaluationsController:
         evaluate.main(config)
 
     def record(self, output_dir) -> None:
+
+
+        random_uuid = str(uuid.uuid4())
+
         url, tenant_name, token = self._get_env_config()
         config_data = {
-            "output_dir": Path.cwd() if output_dir is None else Path(output_dir),
+            "output_dir": Path(os.path.join(Path.cwd(), random_uuid)) if output_dir is None else Path(os.path.join(output_dir,random_uuid)),
             "service_url": url,
             "tenant_name": tenant_name,
             "token": token
@@ -143,16 +149,23 @@ class EvaluationsController:
     def summarize(self) -> None:
         pass
 
-    def external_validate(self, config: Dict, data: List[str], credential:str):
+    def external_validate(self, config: Dict, data: List[str], credential:str, add_context: bool = False):
         validator = ExternalAgentValidation(credential=credential,
                                 auth_scheme=config["auth_scheme"],
                                 service_url=config["api_url"])
+        
         summary = []
         for entry in data:
-            results = validator.call_validation(entry)
-            if len(results) == 0:
-                rich.print(f"[red] No events are generated for input {entry} [/red]")
-            summary.append({entry: results})
+            results = validator.call_validation(entry, add_context)
+            summary.append(results)
 
         return summary
-
+    
+    def generate_performance_test(self, agent_name: str, test_data: List[Tuple[str, str]]):
+        performance_test = ExternalAgentPerformanceTest(
+            agent_name=agent_name,
+            test_data=test_data
+        )
+        generated_performance_tests = performance_test.generate_tests()
+
+        return generated_performance_tests

ibm_watsonx_orchestrate/cli/commands/knowledge_bases/knowledge_bases_command.py

@@ -21,24 +21,6 @@ def knowledge_base_import(
     controller = KnowledgeBaseController()
     controller.import_knowledge_base(file=file, app_id=app_id)
 
-@knowledge_bases_app.command(name="patch", help="Patch a knowledge base by uploading documents, or providing an external vector index")
-def knowledge_base_patch(
-    file: Annotated[
-        str,
-        typer.Option("--file", "-f", help="YAML or JSON file with knowledge base definition"),
-    ],
-    name: Annotated[
-        str,
-        typer.Option("--name", "-n", help="Name of the knowledge base you wish to update"),
-    ]=None,
-    id: Annotated[
-        str,
-        typer.Option("--id", "-i", help="ID of the knowledge base you wish to update"),
-    ]=None
-):
-    controller = KnowledgeBaseController()
-    controller.update_knowledge_base(id=id, name=name, file=file)
-
 
 @knowledge_bases_app.command(name="list", help="List all knowledge bases")
 def list_knowledge_bases(

ibm_watsonx_orchestrate/cli/commands/knowledge_bases/knowledge_bases_controller.py

@@ -8,7 +8,6 @@ import inspect
 from pathlib import Path
 from typing import List
 
-from ibm_watsonx_orchestrate.agent_builder.knowledge_bases.knowledge_base_requests import KnowledgeBaseUpdateRequest
 from ibm_watsonx_orchestrate.agent_builder.knowledge_bases.knowledge_base import KnowledgeBase
 from ibm_watsonx_orchestrate.client.knowledge_bases.knowledge_base_client import KnowledgeBaseClient
 from ibm_watsonx_orchestrate.client.base_api_client import ClientAPIException
@@ -72,11 +71,20 @@ class KnowledgeBaseController:
         client = self.get_client()
 
         knowledge_bases = parse_file(file=file)
+        existing_knowledge_bases = client.get_by_names([kb.name for kb in knowledge_bases])
+        
         for kb in knowledge_bases:
             try:
+                file_dir = "/".join(file.split("/")[:-1])
+
+                existing = list(filter(lambda ex: ex.get('name') == kb.name, existing_knowledge_bases))
+                if len(existing) > 0:
+                    logger.info(f"Existing knowledge base '{kb.name}' found. Updating...")
+                    self.update_knowledge_base(existing[0].get("id"), kb=kb, file_dir=file_dir)
+                    continue
+
                 kb.validate_documents_or_index_exists()
                 if kb.documents:
-                    file_dir = "/".join(file.split("/")[:-1])
                     files = [('files', (get_file_name(file_path), open(get_relative_file_path(file_path, file_dir), 'rb'))) for file_path in kb.documents]
                     
                     kb.prioritize_built_in_index = True
@@ -106,10 +114,7 @@ class KnowledgeBaseController:
                 
                 logger.info(f"Successfully imported knowledge base '{kb.name}'")
             except ClientAPIException as e:
-                if "duplicate key value violates unique constraint" in e.response.text:
-                    logger.error(f"A knowledge base with the name '{kb.name}' already exists. Failed to import knowledge base")
-                else:
-                    logger.error(f"Error importing knowledge base '{kb.name}\n' {e.response.text}")
+                logger.error(f"Error importing knowledge base '{kb.name}\n' {e.response.text}")
     
     def get_id(
         self, id: str, name: str
@@ -131,27 +136,36 @@ class KnowledgeBaseController:
 
 
     def update_knowledge_base(
-        self, id: str, name: str, file: str
+        self, knowledge_base_id: str, kb: KnowledgeBase, file_dir: str
     ) -> None:
-        knowledge_base_id = self.get_id(id, name)
-        update_request = KnowledgeBaseUpdateRequest.from_spec(file=file)
+        filtered_files = []
+        
+        if kb.documents:
+            status = self.get_client().status(knowledge_base_id)
+            existing_docs = [doc.get("metadata", {}).get("original_file_name", "") for doc in status.get("documents", [])]
+            
+            for filepath in kb.documents:
+                filename = get_file_name(filepath)
 
-        if update_request.documents:
-            file_dir = "/".join(file.split("/")[:-1])
-            files = [('files', (get_file_name(file_path), open(get_relative_file_path(file_path, file_dir), 'rb'))) for file_path in update_request.documents]
+                if filename in existing_docs:
+                    logger.warning(f'Document \"{filename}\" already exists in knowledge base, skipping.')
+                else:
+                    filtered_files.append(filepath)
+
+        if filtered_files:
+            files = [('files', (get_file_name(file_path), open(get_relative_file_path(file_path, file_dir), 'rb'))) for file_path in filtered_files]
             
-            update_request.prioritize_built_in_index = True
-            payload = update_request.model_dump(exclude_none=True);
+            kb.prioritize_built_in_index = True
+            payload = kb.model_dump(exclude_none=True);
             payload.pop('documents');
 
             self.get_client().update_with_documents(knowledge_base_id, payload=payload, files=files)
         else:
-            if update_request.conversational_search_tool and update_request.conversational_search_tool.index_config:
-                update_request.prioritize_built_in_index = False
-            self.get_client().update(knowledge_base_id, update_request.model_dump(exclude_none=True))
+            if kb.conversational_search_tool and kb.conversational_search_tool.index_config:
+                kb.prioritize_built_in_index = False
+            self.get_client().update(knowledge_base_id, kb.model_dump(exclude_none=True))
 
-        logEnding = f"with ID '{id}'" if id else f"'{name}'"
-        logger.info(f"Successfully updated knowledge base {logEnding}")
+        logger.info(f"Knowledge base '{kb.name}' updated successfully")
 
 
     def knowledge_base_status( self, id: str, name: str) -> None:

ibm_watsonx_orchestrate/cli/commands/models/models_command.py

@@ -149,7 +149,7 @@ def models_policy_add(
         retry_attempts: Annotated[
             int,
             typer.Option('--retry-attempts', help='The number of attempts to retry'),
-        ],
+        ] = None,
         strategy_on_code: Annotated[
             List[int],
             typer.Option('--strategy-on-code', help='The http status to consider invoking the strategy'),

ibm_watsonx_orchestrate/cli/commands/server/server_command.py

@@ -33,6 +33,29 @@ logger = logging.getLogger(__name__)
 server_app = typer.Typer(no_args_is_help=True)
 
 
+_ALWAYS_UNSET: set[str] = {
+    "WO_API_KEY",
+    "WO_INSTANCE",
+    "DOCKER_IAM_KEY",
+    "WO_DEVELOPER_EDITION_SOURCE",
+    "WATSONX_SPACE_ID",
+    "WATSONX_APIKEY",
+    "WO_USERNAME",
+    "WO_PASSWORD",
+}
+  
+def define_saas_wdu_runtime(value: str = "none") -> None:
+    cfg = Config()
+
+    current_config_file_values = cfg.get(USER_ENV_CACHE_HEADER)
+    current_config_file_values["SAAS_WDU_RUNTIME"] = value
+
+    cfg.save(
+        {
+            USER_ENV_CACHE_HEADER: current_config_file_values
+        }
+    )
+
 def ensure_docker_installed() -> None:
     try:
         subprocess.run(["docker", "--version"], check=True, capture_output=True)
@@ -261,6 +284,13 @@ def _check_exclusive_observibility(langfuse_enabled: bool, ibm_tele_enabled: boo
         return False
     return True
 
+def _prepare_clean_env(env_file: Path) -> None:
+    """Remove env vars so terminal definitions don't override"""
+    keys_from_file = set(dotenv_values(str(env_file)).keys())
+    keys_to_unset = keys_from_file | _ALWAYS_UNSET
+    for key in keys_to_unset:
+        os.environ.pop(key, None)
+
 def write_merged_env_file(merged_env: dict) -> Path:
     tmp = tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".env")
     with tmp:
@@ -293,7 +323,8 @@ NON_SECRET_ENV_ITEMS = {
     "WO_INSTANCE",
     "USE_SAAS_ML_TOOLS_RUNTIME",
     "AUTHORIZATION_URL",
-    "OPENSOURCE_REGISTRY_PROXY"
+    "OPENSOURCE_REGISTRY_PROXY",
+    "SAAS_WDU_RUNTIME"
 }
 def persist_user_env(env: dict, include_secrets: bool = False) -> None:
     if include_secrets:
@@ -313,9 +344,10 @@ def get_persisted_user_env() -> dict | None:
     user_env = cfg.get(USER_ENV_CACHE_HEADER) if cfg.get(USER_ENV_CACHE_HEADER) else None
     return user_env
 
-def run_compose_lite(final_env_file: Path, experimental_with_langfuse=False, experimental_with_ibm_telemetry=False, with_docproc=False) -> None:
+def run_compose_lite(final_env_file: Path, experimental_with_langfuse=False, experimental_with_ibm_telemetry=False, with_doc_processing=False) -> None:
     compose_path = get_compose_file()
     compose_command = ensure_docker_compose_installed()
+    _prepare_clean_env(final_env_file)  
     db_tag = read_env_file(final_env_file).get('DBTAG', None)
     logger.info(f"Detected architecture: {platform.machine()}, using DBTAG: {db_tag}")
 
@@ -345,7 +377,7 @@ def run_compose_lite(final_env_file: Path, experimental_with_langfuse=False, exp
         profiles.append("langfuse")
     if experimental_with_ibm_telemetry:
         profiles.append("ibm-telemetry")
-    if with_docproc:
+    if with_doc_processing:
         profiles.append("docproc")
 
     command = compose_command[:]
@@ -358,6 +390,8 @@ def run_compose_lite(final_env_file: Path, experimental_with_langfuse=False, exp
         "up",
         "--scale",
         "ui=0",
+        "--scale",
+        "cpe=0",
         "-d",
         "--remove-orphans",
     ]
@@ -428,6 +462,7 @@ def wait_for_wxo_ui_health_check(timeout_seconds=45, interval_seconds=2):
 def run_compose_lite_ui(user_env_file: Path) -> bool:
     compose_path = get_compose_file()
     compose_command = ensure_docker_compose_installed()
+    _prepare_clean_env(user_env_file)  
     ensure_docker_installed()
 
     default_env = read_env_file(get_default_env_file())
@@ -522,6 +557,7 @@ def run_compose_lite_ui(user_env_file: Path) -> bool:
 def run_compose_lite_down_ui(user_env_file: Path, is_reset: bool = False) -> None:
     compose_path = get_compose_file()
     compose_command = ensure_docker_compose_installed()
+    _prepare_clean_env(user_env_file)  
 
 
     ensure_docker_installed()
@@ -565,6 +601,7 @@ def run_compose_lite_down_ui(user_env_file: Path, is_reset: bool = False) -> Non
 def run_compose_lite_down(final_env_file: Path, is_reset: bool = False) -> None:
     compose_path = get_compose_file()
     compose_command = ensure_docker_compose_installed()
+    _prepare_clean_env(final_env_file)  
 
     command = compose_command + [
         '--profile', '*',
@@ -597,6 +634,7 @@ def run_compose_lite_down(final_env_file: Path, is_reset: bool = False) -> None:
 def run_compose_lite_logs(final_env_file: Path, is_reset: bool = False) -> None:
     compose_path = get_compose_file()
     compose_command = ensure_docker_compose_installed()
+    _prepare_clean_env(final_env_file)  
 
     command = compose_command + [
         "-f", str(compose_path),
@@ -752,14 +790,16 @@ def server_start(
         "--accept-terms-and-conditions",
         help="By providing this flag you accept the terms and conditions outlined in the logs on server start."
     ),
-    with_docproc: bool = typer.Option(
+    with_doc_processing: bool = typer.Option(
         False,
-        '--with-docproc', '-d',
+        '--with-doc-processing', '-d',
         help='Enable IBM Document Processing to extract information from your business documents. Enabling this activates the Watson Document Understanding service.'
     ),
 ):
     confirm_accepts_license_agreement(accept_terms_and_conditions)
 
+    define_saas_wdu_runtime()
+    
     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)
@@ -795,8 +835,9 @@ def server_start(
     if experimental_with_langfuse:
         merged_env_dict['LANGFUSE_ENABLED'] = 'true'
 
-    if with_docproc:
+    if with_doc_processing:
         merged_env_dict['DOCPROC_ENABLED'] = 'true'
+        define_saas_wdu_runtime("local")
 
     if experimental_with_ibm_telemetry:
         merged_env_dict['USE_IBM_TELEMETRY'] = 'true'
@@ -815,8 +856,8 @@ def server_start(
     run_compose_lite(final_env_file=final_env_file,
                      experimental_with_langfuse=experimental_with_langfuse,
                      experimental_with_ibm_telemetry=experimental_with_ibm_telemetry,
-                     with_docproc=with_docproc)
-
+                     with_doc_processing=with_doc_processing)
+    
     run_db_migration()
 
     logger.info("Waiting for orchestrate server to be fully initialized and ready...")
@@ -843,7 +884,7 @@ def server_start(
 
     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_docproc:
+    if with_doc_processing:
         logger.info(f"Document processing capabilities are now available for use in Flows (both ADK and runtime). Note: This option is currently available only in the Developer edition.")
 
 @server_app.command(name="stop")
@@ -854,6 +895,7 @@ def server_stop(
         help="Path to a .env file that overrides default.env. Then environment variables override both."
     )
 ):
+
     ensure_docker_installed()
     default_env_path = get_default_env_file()
     merged_env_dict = merge_env(
@@ -910,9 +952,24 @@ def server_logs(
 def run_db_migration() -> None:
     compose_path = get_compose_file()
     compose_command = ensure_docker_compose_installed()
+    default_env_path = get_default_env_file()
+    merged_env_dict = merge_env(default_env_path, user_env_path=None)
+    merged_env_dict['WATSONX_SPACE_ID']='X'
+    merged_env_dict['WATSONX_APIKEY']='X'
+    merged_env_dict['WXAI_API_KEY'] = ''
+    merged_env_dict['ASSISTANT_EMBEDDINGS_API_KEY'] = ''
+    merged_env_dict['ASSISTANT_LLM_SPACE_ID'] = ''
+    merged_env_dict['ROUTING_LLM_SPACE_ID'] = ''
+    merged_env_dict['USE_SAAS_ML_TOOLS_RUNTIME'] = ''
+    merged_env_dict['BAM_API_KEY'] = ''
+    merged_env_dict['ASSISTANT_EMBEDDINGS_SPACE_ID'] = ''
+    merged_env_dict['ROUTING_LLM_API_KEY'] = ''
+    merged_env_dict['ASSISTANT_LLM_API_KEY'] = ''
+    final_env_file = write_merged_env_file(merged_env_dict)
 
     command = compose_command + [
         "-f", str(compose_path),
+        "--env-file", str(final_env_file),
         "exec",
         "wxo-server-db",
         "bash",

ibm_watsonx_orchestrate/cli/commands/toolkit/toolkit_command.py

@@ -47,7 +47,7 @@ def import_toolkit(
     ] = None,
     tools: Annotated[
         Optional[str],
-        typer.Option("--tools", "-t", help="Comma-separated list of tools to import. Or you can use `*` to use all tools"),
+        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],