ibm-watsonx-orchestrate 1.11.0b1__py3-none-any.whl → 1.12.0b1__py3-none-any.whl

ibm_watsonx_orchestrate/cli/commands/copilot/copilot_controller.py

@@ -327,11 +327,7 @@ def talk_to_cpe(cpe_client, samples_file=None, context_data=None):
 
 
 def prompt_tune(agent_spec: str, output_file: str | None, samples_file: str | None, dry_run_flag: bool) -> None:
-    agents = AgentsController.import_agent(file=agent_spec, app_id=None)
-    if not agents:
-        logger.error("Invalid agent spec file provided, no agent found.")
-        sys.exit(1)
-    agent = agents[0]
+    agent = AgentsController.import_agent(file=agent_spec, app_id=None)[0]
     agent_kind = agent.kind
 
     if agent_kind != AgentKind.NATIVE:
@@ -346,7 +342,7 @@ def prompt_tune(agent_spec: str, output_file: str | None, samples_file: str | No
 
     client = get_cpe_client()
 
-    instr = agent.instructions if agent.instructions else ""
+    instr = agent.instructions
 
     tools = _get_tools_from_names(agent.tools)
 

ibm_watsonx_orchestrate/cli/commands/copilot/copilot_server_controller.py

@@ -1,24 +1,13 @@
 import logging
 import sys
 from pathlib import Path
-import subprocess
 import time
 import requests
 from urllib.parse import urlparse
-from ibm_watsonx_orchestrate.cli.commands.server.server_command import (
-    get_compose_file,
-    ensure_docker_compose_installed,
-    _prepare_clean_env,
-    ensure_docker_installed,
-    read_env_file,
-    get_default_env_file,
-    get_persisted_user_env,
-    get_dev_edition_source,
-    get_default_registry_env_vars_by_dev_edition_source,
-    docker_login_by_dev_edition_source,
-    write_merged_env_file,
-    apply_server_env_dict_defaults
-)
+
+from ibm_watsonx_orchestrate.cli.config import Config
+from ibm_watsonx_orchestrate.utils.docker_utils import DockerLoginService, DockerComposeCore, DockerUtils
+from ibm_watsonx_orchestrate.utils.environment import EnvService
 
 logger = logging.getLogger(__name__)
 
@@ -39,71 +28,26 @@ def wait_for_wxo_cpe_health_check(timeout_seconds=45, interval_seconds=2):
         time.sleep(interval_seconds)
     return False
 
-def _trim_authorization_urls(env_dict: dict) -> dict:
-    auth_url_key = "AUTHORIZATION_URL"
-    env_dict_copy = env_dict.copy()
-
-    auth_url = env_dict_copy.get(auth_url_key)
-    if not auth_url:
-        return env_dict_copy
-    
-    
-    parsed_url = urlparse(auth_url)
-    new_url = f"{parsed_url.scheme}://{parsed_url.netloc}"
-    env_dict_copy[auth_url_key] = new_url
-
-    return env_dict_copy
-
-    
-
-
 def run_compose_lite_cpe(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())
-    user_env = read_env_file(user_env_file) if user_env_file else {}
-    if not user_env:
-        user_env = get_persisted_user_env() or {}
-
-    dev_edition_source = get_dev_edition_source(user_env)
-    default_registry_vars = get_default_registry_env_vars_by_dev_edition_source(default_env, user_env, source=dev_edition_source)
-
-    # Update the default environment with the default registry variables only if they are not already set
-    for key in default_registry_vars:
-        if key not in default_env or not default_env[key]:
-            default_env[key] = default_registry_vars[key]
-
-    # Merge the default environment with the user environment
-    merged_env_dict = {
-        **default_env,
-        **user_env,
-    }
-    
-    merged_env_dict = apply_server_env_dict_defaults(merged_env_dict)
-    merged_env_dict = _trim_authorization_urls(merged_env_dict)
+    DockerUtils.ensure_docker_installed()
+
+    cli_config = Config()
+    env_service = EnvService(cli_config)
+    env_service.prepare_clean_env(user_env_file)
+    user_env = env_service.get_user_env(user_env_file)
+    merged_env_dict = env_service.prepare_server_env_vars(user_env=user_env, should_drop_auth_routes=True)
 
     try:
-        docker_login_by_dev_edition_source(merged_env_dict, dev_edition_source)
+        DockerLoginService(env_service=env_service).login_by_dev_edition_source(merged_env_dict)
     except ValueError as ignored:
         # do nothing, as the docker login here is not mandatory
         pass
 
-    final_env_file = write_merged_env_file(merged_env_dict)
+    final_env_file = env_service.write_merged_env_file(merged_env_dict)
 
-    command = compose_command + [
-        "-f", str(compose_path),
-        "--env-file", str(final_env_file),
-        "up",
-        "cpe",
-        "-d",
-        "--remove-orphans"
-    ]
+    compose_core = DockerComposeCore(env_service)
 
-    logger.info(f"Starting docker-compose Copilot service...")
-    result = subprocess.run(command, capture_output=False)
+    result = compose_core.service_up(service_name="cpe", friendly_name="Copilot", final_env_file=final_env_file)
 
     if result.returncode == 0:
         logger.info("Copilot Service started successfully.")
@@ -124,27 +68,16 @@ def run_compose_lite_cpe(user_env_file: Path) -> bool:
     return True
 
 def run_compose_lite_cpe_down(is_reset: bool = False) -> None:
-    compose_path = get_compose_file()
-    compose_command = ensure_docker_compose_installed()
-    ensure_docker_installed()
-
-    default_env = read_env_file(get_default_env_file())
-    final_env_file = write_merged_env_file(default_env)
-
-    command = compose_command + [
-        "-f", str(compose_path),
-        "--env-file", final_env_file,
-        "down",
-        "cpe"
-    ]
-
-    if is_reset:
-        command.append("--volumes")
-        logger.info("Stopping docker-compose Copilot service and resetting volumes...")
-    else:
-        logger.info("Stopping docker-compose Copilot service...")
+    DockerUtils.ensure_docker_installed()
+
+    default_env = EnvService.read_env_file(EnvService.get_default_env_file())
+    final_env_file = EnvService.write_merged_env_file(default_env)
+
+    cli_config = Config()
+    env_service = EnvService(cli_config)
+    compose_core = DockerComposeCore(env_service)
 
-    result = subprocess.run(command, capture_output=False)
+    result = compose_core.service_down(service_name="cpe", friendly_name="Copilot", final_env_file=final_env_file, is_reset=is_reset)
 
     if result.returncode == 0:
         logger.info("Copilot service stopped successfully.")

ibm_watsonx_orchestrate/cli/commands/evaluations/evaluations_command.py

@@ -386,6 +386,55 @@ def validate_external(
 
         rich.print(Panel(msg))
 
+@evaluation_app.command(name="validate-native", help="Validate native agents against a set of inputs")
+def validate_native(
+    data_path: Annotated[
+        str,
+        typer.Option(
+            "--tsv", "-t",
+            help="Path to .tsv file of inputs. The first column of the TSV is the user story, the second column is the  expected final output from the agent, and the third column is the name of the agent"
+        )
+    ],
+    output_dir: Annotated[
+        str,
+        typer.Option(
+            "--output", "-o",
+            help="where to save the validation results"
+        )
+    ] = "./test_native_agent",
+    user_env_file: Annotated[
+        Optional[str],
+        typer.Option(
+            "--env-file", "-e", 
+            help="Path to a .env file that overrides default.env. Then environment variables override both."
+        ),
+    ] = None,
+):
+    validate_watsonx_credentials(user_env_file)
+    
+    eval_dir = os.path.join(output_dir, "native_agent_evaluations")
+    if os.path.exists(eval_dir):
+        rich.print(f"[yellow]: found existing {eval_dir} in target directory. All content is removed.")
+        shutil.rmtree(eval_dir)
+    Path(eval_dir).mkdir(exist_ok=True, parents=True)
+
+    test_data_path = Path(eval_dir) / "generated_test_data"
+    test_data_path.mkdir(exist_ok=True, parents=True)
+    
+    controller = EvaluationsController()
+    test_data = read_csv(data_path) # tab seperated file containing the user story, the final outcome, and the agent name
+    
+    for idx, row in enumerate(test_data):
+        agent_name = row[2] # agent name
+        dataset = [row[0:2]] # user story, expected final outcome
+        generated_test_data = controller.generate_performance_test(agent_name=agent_name, test_data=dataset)
+        for test_data in generated_test_data:
+            test_name = f"native_agent_evaluation_test_{idx}.json"
+            with open(test_data_path / test_name, encoding="utf-8", mode="w+") as f:
+                json.dump(test_data, f, indent=4)
+    
+    evaluate(output_dir=eval_dir, test_paths=str(test_data_path))
+
 @evaluation_app.command(name="quick-eval",
                         short_help="Evaluate agent against a suite of static metrics and LLM-as-a-judge metrics",
                         help="""

ibm_watsonx_orchestrate/cli/commands/models/model_provider_mapper.py

@@ -101,10 +101,11 @@ PROVIDER_EXTRA_PROPERTIES_LUT = {
 PROVIDER_REQUIRED_FIELDS = {k:['api_key'] for k in ModelProvider}
 # Update required fields for each provider
 # Use sets to denote when a requirement is 'or'
+# Tuples denote combined requirements like 'and'
 PROVIDER_REQUIRED_FIELDS.update({
     ModelProvider.WATSONX: PROVIDER_REQUIRED_FIELDS[ModelProvider.WATSONX] + [{'watsonx_space_id', 'watsonx_project_id', 'watsonx_deployment_id'}],
     ModelProvider.OLLAMA: PROVIDER_REQUIRED_FIELDS[ModelProvider.OLLAMA] + ['custom_host'],
-    ModelProvider.BEDROCK: [],
+    ModelProvider.BEDROCK: [{'api_key', ('aws_secret_access_key', 'aws_access_key_id')}],
 })
 
 # def env_file_to_model_ProviderConfig(model_name: str, env_file_path: str) -> ProviderConfig | None:
@@ -158,16 +159,34 @@ def _validate_extra_fields(provider: ModelProvider, cfg: ProviderConfig) -> None
         if  cfg.__dict__.get(attr) is not None and attr not in accepted_fields:
             logger.warning(f"The config option '{attr}' is not used by provider '{provider}'")
 
+def _check_credential_provided(cred: str | tuple, provided_creds: set) -> bool:
+    if isinstance(cred, tuple):
+        return all(item in provided_creds for item in cred)
+    else:
+        return cred in provided_creds
+
+def _format_missing_credential(missing_credential: set) -> str:
+    parts = []
+    for cred in missing_credential:
+        if isinstance(cred, tuple):
+            formatted = " and ".join(f"{x}" for x in cred)
+            parts.append(f"({formatted})")
+        else:
+            parts.append(f"{cred}")
+
+    return " or ".join(parts)
+
+
 def _validate_requirements(provider: ModelProvider, cfg: ProviderConfig, app_id: str = None) -> None:
     provided_credentials = set([k for k,v in dict(cfg).items() if v is not None])
     required_creds = PROVIDER_REQUIRED_FIELDS[provider]
     missing_credentials = []
     for cred in required_creds:
         if isinstance(cred, set):
-            if not any(c in provided_credentials for c in cred):
+            if not any(_check_credential_provided(c, provided_credentials) for c in cred):
                 missing_credentials.append(cred)
         else:
-            if cred not in provided_credentials:
+            if not _check_credential_provided(cred, provided_credentials):
                 missing_credentials.append(cred)
 
     if len(missing_credentials) > 0:
@@ -177,7 +196,7 @@ def _validate_requirements(provider: ModelProvider, cfg: ProviderConfig, app_id:
             missing_credentials_string = f"Be sure to include the following required fields for provider '{provider}' in the connection '{app_id}':"
         for cred in missing_credentials:
             if isinstance(cred, set):
-                cred_str = ' or '.join(list(cred))
+                cred_str = _format_missing_credential(cred)
             else:
                 cred_str = cred
             missing_credentials_string += f"\n\t  - {cred_str}"

ibm_watsonx_orchestrate/cli/commands/models/models_controller.py

@@ -12,7 +12,6 @@ import requests
 import rich
 import rich.highlighter
 
-from ibm_watsonx_orchestrate.cli.commands.server.server_command import get_default_env_file, merge_env
 from ibm_watsonx_orchestrate.client.model_policies.model_policies_client import ModelPoliciesClient
 from ibm_watsonx_orchestrate.agent_builder.model_policies.types import ModelPolicy, ModelPolicyInner, \
     ModelPolicyRetry, ModelPolicyStrategy, ModelPolicyStrategyMode, ModelPolicyTarget
@@ -20,6 +19,7 @@ from ibm_watsonx_orchestrate.client.models.models_client import ModelsClient
 from ibm_watsonx_orchestrate.agent_builder.models.types import VirtualModel, ProviderConfig, ModelType, ANTHROPIC_DEFAULT_MAX_TOKENS
 from ibm_watsonx_orchestrate.client.utils import instantiate_client, is_cpd_env
 from ibm_watsonx_orchestrate.client.connections import get_connection_id, ConnectionType
+from ibm_watsonx_orchestrate.utils.environment import EnvService
 
 logger = logging.getLogger(__name__)
 
@@ -153,8 +153,8 @@ class ModelsController:
         models_client: ModelsClient = self.get_models_client()
         model_policies_client: ModelPoliciesClient = self.get_model_policies_client()
         global WATSONX_URL
-        default_env_path = get_default_env_file()
-        merged_env_dict = merge_env(
+        default_env_path = EnvService.get_default_env_file()
+        merged_env_dict = EnvService.merge_env(
             default_env_path,
             None
         )

ibm_watsonx_orchestrate/cli/commands/partners/offering/partners_offering_command.py

@@ -0,0 +1,56 @@
+import typer
+from typing_extensions import Annotated
+from ibm_watsonx_orchestrate.cli.commands.partners.offering.partners_offering_controller import PartnersOfferingController
+from typing_extensions import Annotated
+from ibm_watsonx_orchestrate.cli.commands.partners.offering.types import AgentKind
+
+
+partners_offering = typer.Typer(no_args_is_help=True)
+
+@partners_offering.command(
+        name="create",
+        help="Export Items from your environment to create an offering"
+    )
+def create_offering(
+    offering: Annotated[
+        str,
+        typer.Option("--offering", "-o", help="Name of the offering"),
+    ],
+    publisher_name: Annotated[
+        str,
+        typer.Option("--publisher", "-p", help="Publisher name"),
+    ],
+    type: Annotated[
+        AgentKind,
+        typer.Option("--type", "-t", help="Type of agent: native|external"),
+    ],
+    agent_name: Annotated[
+        str,
+        typer.Option("--agent-name", "-a", help="Agent name to create"),
+    ],
+):
+    controller = PartnersOfferingController()
+    controller.create(
+        offering=offering,
+        publisher_name=publisher_name,
+        agent_type=type,
+        agent_name=agent_name,
+    )
+
+
+@partners_offering.command(
+        name="package",
+        help="Validate your exported offering and package for upload"
+    )
+def package_offering(
+    offering: Annotated[
+        str,
+        typer.Option("--offering", "-o", help="Name of the offering to package"),
+    ],
+    folder_path: Annotated[
+        str,
+        typer.Option("--folder", "-f", help="Path to folder containing the specified offering")
+    ] = None
+):
+    controller = PartnersOfferingController()
+    controller.package(offering=offering, folder_path=folder_path)