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

ibm_watsonx_orchestrate/cli/commands/connections/connections_controller.py

@@ -1,4 +1,7 @@
+import io
 import logging
+from pathlib import Path
+import zipfile
 import requests
 import json
 import rich
@@ -7,6 +10,7 @@ import sys
 import typer
 
 from typing import List
+from ibm_watsonx_orchestrate.agent_builder.agents.types import SpecVersion
 from ibm_watsonx_orchestrate.client.utils import is_local_dev
 from ibm_watsonx_orchestrate.agent_builder.connections.types import (
     ConnectionEnvironment,
@@ -277,6 +281,48 @@ def _connection_credentials_parse_entry(text: str, default_location: ConnectionC
     
     return ConnectionCredentialsEntry(key=key, value=value, location=location)
     
+def _combine_connection_configs(configs: List[ConnectionConfiguration]) -> dict:
+    combined_configuration = {
+        'app_id': None,
+        'spec_version': SpecVersion.V1.value,
+        'kind': 'connection',
+        'environments': {
+
+        },
+        'catalog': {
+            'name': None,
+            'description': None,
+            'icon': None
+        }
+    }
+    for config in configs:
+        if combined_configuration.get('app_id') and config.app_id != combined_configuration.get('app_id'):
+            raise ValueError(f"Cannot combine config '{config.app_id}' with config '{combined_configuration.get('app_id')}'")
+        combined_configuration['app_id'] = config.app_id
+
+        current_env = config.environment.value.lower()
+        combined_configuration['environments'][current_env] = {}
+
+        for k,v in config.model_dump().items():
+            if not v:
+                continue
+            match(k):
+                case "app_id" | "environment" | "spec_version":
+                    continue
+                case _:
+                    try:
+                        combined_configuration['environments'][current_env][k] = str(v)
+                    except:
+                        logger.error(f"Couldn't represent {k} as a string")
+    
+    return combined_configuration
+
+def _resolve_connection_ids(connection_ids: list[str]) -> list[str]:
+    client = get_connections_client()
+    connections = client.list()
+    return list(set([c.app_id for c in connections if c.connection_id in connection_ids]))
+
+
 
 def add_configuration(config: ConnectionConfiguration) -> None:
     client = get_connections_client()
@@ -396,6 +442,21 @@ def add_connection(app_id: str) -> None:
         logger.error(response_text)
         exit(1)
 
+def get_connection_configs(app_id: str) -> List[ConnectionConfiguration]:
+    client = get_connections_client()
+    connection_configs = []
+    for env in ConnectionEnvironment:
+        try:
+            config = client.get_config(app_id=app_id,env=env)
+            if not config:
+                logger.warning(f"No {env.value.lower()} configuration found for connection '{app_id}'")
+            else:
+                connection_configs.append( config.as_config() )
+        except:
+            logger.error(f"Unable to get {env.value.lower()} configs for connection '{app_id}'")
+
+    return connection_configs
+
 def remove_connection(app_id: str) -> None:
     client = get_connections_client()
 
@@ -479,6 +540,59 @@ def list_connections(environment: ConnectionEnvironment | None, verbose: bool =
 def import_connection(file: str) -> None:
     _parse_file(file=file)
 
+def export_connection(output_file: str, app_id: str | None = None, connection_id: str | None = None) -> None:
+    if not app_id and not connection_id:
+        raise ValueError(f"Connection export requires at least one of 'app_id' or 'connection_id'")
+    
+    if app_id and connection_id:
+        logger.warning(f"Connection export recieved both 'app_id' and 'connection_id', preferring 'app_id'")
+    
+    if not app_id:
+        app_ids = _resolve_connection_ids([connection_id])
+        if len(app_ids) > 0:
+            app_id = app_ids[0]
+        else:
+            raise ValueError(f"No connections found with connection_id of '{connection_id}'")
+
+
+    # verify output folder
+    output_path = Path(output_file)
+    if output_path.exists():
+        logger.error(f"Specified output file already exists")
+        sys.exit(0)
+
+    output_type = output_path.suffix.lower()
+    if output_type not in ['.zip','.yaml','.yml']:
+        logger.error(f"Output file must end with the extension '.zip', '.yaml' or '.yml'")
+        sys.exit(0)
+
+    # get connection data
+    connections = get_connection_configs(app_id=app_id)
+    combined_connections = _combine_connection_configs(connections)
+
+    # write to folder
+    match(output_type):
+        case '.zip':
+            zip_file = zipfile.ZipFile(output_path, "w")
+                
+            connection_yaml = yaml.dump(combined_connections, sort_keys=False, default_flow_style=False, allow_unicode=True)
+            connection_yaml_bytes = connection_yaml.encode("utf-8")
+            connection_yaml_file = io.BytesIO(connection_yaml_bytes)
+
+            zip_file.writestr(
+                f"{output_path.stem}/{app_id}.yaml",
+                connection_yaml_file.getvalue()
+            )
+
+            zip_file.close()
+        case '.yaml' | '.yml':
+            with open(output_path,'w') as yaml_file:
+                yaml_file.write(
+                    yaml.dump(combined_connections, sort_keys=False, default_flow_style=False, allow_unicode=True)
+                )
+                
+    logger.info(f"Successfully exported connection file for {app_id}")
+
 def configure_connection(**kwargs) -> None:
     if is_local_dev() and kwargs.get("environment") != ConnectionEnvironment.DRAFT:
         logger.error(f"Cannot create configuration for environment '{kwargs.get('environment')}'. Local development does not support any environments other than 'draft'.")

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

@@ -54,7 +54,8 @@ def read_env_file(env_path: Path|str) -> dict:
 def validate_watsonx_credentials(user_env_file: str) -> bool:
     required_sets = [
         ["WATSONX_SPACE_ID", "WATSONX_APIKEY"],
-        ["WO_INSTANCE", "WO_API_KEY"]
+        ["WO_INSTANCE", "WO_API_KEY"],
+        ["WO_INSTANCE", "WO_PASSWORD", "WO_USERNAME"]
     ]
     
     def has_valid_keys(env: dict) -> bool:
@@ -75,7 +76,7 @@ def validate_watsonx_credentials(user_env_file: str) -> bool:
     user_env = read_env_file(user_env_file)
     
     if not has_valid_keys(user_env):
-        logger.error("Error: The environment file does not contain the required keys: either WATSONX_SPACE_ID and WATSONX_APIKEY or WO_INSTANCE and WO_API_KEY.")
+        logger.error("Error: The environment file does not contain the required keys: either WATSONX_SPACE_ID and WATSONX_APIKEY or WO_INSTANCE and WO_API_KEY or WO_INSTANCE and WO_USERNAME and WO_PASSWORD.")
         sys.exit(1)
 
     # Update os.environ with whichever set is present
@@ -386,6 +387,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/evaluations/evaluations_controller.py

@@ -52,7 +52,7 @@ class EvaluationsController:
 
         if "WATSONX_SPACE_ID" in os.environ and "WATSONX_APIKEY" in os.environ:
             provider = "watsonx"
-        elif "WO_INSTANCE" in os.environ and "WO_API_KEY" in os.environ:
+        elif "WO_INSTANCE" in os.environ and ("WO_API_KEY" in os.environ or "WO_PASSWORD" in os.environ):
             provider = "model_proxy"
         else:
             logger.error(

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)