ibm-watsonx-orchestrate 1.5.0b0__py3-none-any.whl → 1.5.1__py3-none-any.whl

ibm_watsonx_orchestrate/cli/commands/models/model_provider_mapper.py

@@ -0,0 +1,191 @@
+# https://portkey.ai/
+from dotenv import dotenv_values
+import sys
+import logging
+from ibm_watsonx_orchestrate.agent_builder.models.types import  ProviderConfig, ModelProvider
+
+logger = logging.getLogger(__name__)
+
+_BASIC_PROVIDER_CONFIG_KEYS = {'provider', 'api_key', 'custom_host', 'url_to_fetch', 'forward_headers', 'request_timeout', 'transform_to_form_data'}
+
+PROVIDER_EXTRA_PROPERTIES_LUT = {
+    ModelProvider.ANTHROPIC: {'anthropic_beta', 'anthropic_version'},
+    # ModelProvider.AZURE_AI: {
+    #     'azure_resource_name',
+    #     'azure_deployment_id',
+    #     'azure_api_version',
+    #     'ad_auth',
+    #     'azure_auth_mode',
+    #     'azure_managed_client_id',
+    #     'azure_entra_client_id',
+    #     'azure_entra_client_secret',
+    #     'azure_entra_tenant_id',
+    #     'azure_ad_token',
+    #     'azure_model_name'
+    # },
+    # ModelProvider.BEDROCK: {
+    #     'aws_secret_access_key',
+    #     'aws_access_key_id',
+    #     'aws_session_token',
+    #     'aws_region',
+    #     'aws_auth_type',
+    #     'aws_role_arn',
+    #     'aws_external_id',
+    #     'aws_s3_bucket',
+    #     'aws_s3_object_key',
+    #     'aws_bedrock_model',
+    #     'aws_server_side_encryption',
+    #     'aws_server_side_encryption_kms_key_id'
+    # },
+    # ModelProvider.VERTEX_AI: {
+    #     'vertex_region',
+    #     'vertex_project_id',
+    #     'vertex_service_account_json',
+    #     'vertex_storage_bucket_name',
+    #     'vertex_model_name',
+    #     'filename'
+    # },
+    # ModelProvider.HUGGINGFACE: {'huggingfaceBaseUrl'},
+    ModelProvider.MISTRAL_AI: {'mistral_fim_completion'},
+    # ModelProvider.STABILITY_AI: {'stability_client_id', 'stability_client_user_id', 'stability_client_version'},
+    ModelProvider.WATSONX: {'watsonx_version', 'watsonx_space_id', 'watsonx_project_id', 'api_key', 'watsonx_deployment_id', 'watsonx_cpd_url', 'watsonx_cpd_username', 'watsonx_cpd_password'},
+
+    # 'palm': _bpp('PALM', {}),
+    # 'nomic': _bpp('NOMIC', {}),
+    # 'perplexity-ai': _bpp('PERPLEXITY_AI', {}),
+    # 'segmind': _bpp('SEGMIND', {}),
+    # 'deepinfra': _bpp('DEEPINFRA', {}),
+    # 'novita-ai': _bpp('NOVITA_AI', {}),
+    # 'fireworks-ai': _bpp('FIREWORKS',{
+    #     'FIREWORKS_ACCOUNT_ID': 'fireworks_account_id'
+    # }),
+    # 'deepseek': _bpp('DEEPSEEK', {}),
+    # 'voyage': _bpp('VOYAGE', {}),
+    # 'moonshot': _bpp('MOONSHOT', {}),
+    # 'lingyi': _bpp('LINGYI', {}),
+    # 'zhipu': _bpp('ZHIPU', {}),
+    # 'monsterapi': _bpp('MONSTERAPI', {}),
+    # 'predibase': _bpp('PREDIBASE', {}),
+
+    # 'github': _bpp('GITHUB', {}),
+    # 'deepbricks': _bpp('DEEPBRICKS', {}),
+    # 'sagemaker': _bpp('AMZN_SAGEMAKER', {
+    #     'AMZN_SAGEMAKER_CUSTOM_ATTRIBUTES': 'amzn_sagemaker_custom_attributes',
+    #     'AMZN_SAGEMAKER_TARGET_MODEL': 'amzn_sagemaker_target_model',
+    #     'AMZN_SAGEMAKER_TARGET_VARIANT': 'amzn_sagemaker_target_variant',
+    #     'AMZN_SAGEMAKER_TARGET_CONTAINER_HOSTNAME': 'amzn_sagemaker_target_container_hostname',
+    #     'AMZN_SAGEMAKER_INFERENCE_ID': 'amzn_sagemaker_inference_id',
+    #     'AMZN_SAGEMAKER_ENABLE_EXPLANATIONS': 'amzn_sagemaker_enable_explanations',
+    #     'AMZN_SAGEMAKER_INFERENCE_COMPONENT': 'amzn_sagemaker_inference_component',
+    #     'AMZN_SAGEMAKER_SESSION_ID': 'amzn_sagemaker_session_id',
+    #     'AMZN_SAGEMAKER_MODEL_NAME': 'amzn_sagemaker_model_name'
+    # }),
+    # '@cf': _bpp('WORKERS_AI', { # workers ai
+    #     'WORKERS_AI_ACCOUNT_ID': 'workers_ai_account_id'
+    # }),
+    # 'snowflake': _bpp('SNOWFLAKE', { # no provider prefix found
+    #     'SNOWFLAKE_ACCOUNT': 'snowflake_account'
+    # })
+}
+
+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'
+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']
+})
+
+# def env_file_to_model_ProviderConfig(model_name: str, env_file_path: str) -> ProviderConfig | None:
+#     provider = next(filter(lambda x: x not in ('virtual-policy', 'virtual-model'), model_name.split('/')))
+#     if provider not in ModelProvider:
+#         logger.error(f"Unsupported model provider {provider}")
+#         sys.exit(1)
+
+#     values = dotenv_values(str(env_file_path))
+
+#     if values is None:
+#         logger.error(f"No provider configuration in env file {env_file_path}")
+#         sys.exit(1)
+
+#     cfg = ProviderConfig()
+#     cfg.provider = PROVIDER_LUT[provider]
+
+#     cred_lut = PROVIDER_PROPERTIES_LUT[provider]
+
+
+#     consumed_credentials = []
+#     # Ollama requires some apikey but its content don't matter
+#     # Default it to 'ollama' to avoid users needing to specify
+#     if cfg.provider == ModelProvider.OLLAMA:
+#         consumed_credentials.append('api_key')
+#         setattr(cfg, 'api_key', ModelProvider.OLLAMA)
+    
+#     for key, value in values.items():
+#         if key in cred_lut:
+#             k = cred_lut[key]
+#             consumed_credentials.append(k)
+#             setattr(cfg, k, value)
+
+#     return cfg
+
+def _validate_provider(provider: str | ModelProvider) -> None:
+    if not ModelProvider.has_value(provider):
+        logger.error(f"Unsupported model provider {provider}")
+        sys.exit(1)
+
+def _validate_extra_fields(provider: ModelProvider, cfg: ProviderConfig) -> None:
+    accepted_fields = _BASIC_PROVIDER_CONFIG_KEYS.copy()
+    extra_accepted_fields = PROVIDER_EXTRA_PROPERTIES_LUT.get(provider)
+    if extra_accepted_fields:
+        accepted_fields = accepted_fields.union(extra_accepted_fields)
+    
+    for attr in cfg.__dict__:
+        if attr.startswith("__"):
+            continue
+
+        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 _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):
+                missing_credentials.append(cred)
+        else:
+            if cred not in provided_credentials:
+                missing_credentials.append(cred)
+
+    if len(missing_credentials) > 0:
+        if not app_id:
+            missing_credentials_string = f"Missing configuration variable(s) required for the provider {provider}:"
+        else:
+            missing_credentials_string = f"The following configuration variable(s) for the provider {provider} are not in the spec provider_config:"
+        for cred in missing_credentials:
+            if isinstance(cred, set):
+                cred_str = ' or '.join(list(cred))
+            else:
+                cred_str = cred
+            missing_credentials_string += f"\n\t  - {cred_str}"
+        
+        if not app_id:
+            logger.error(missing_credentials_string)
+            logger.error("Please provide the above values in the provider config. For secret values (e.g. 'api_key') create a key_value connection `orchestrate connections add` then bind it to the model with `--app-id`")
+            sys.exit(1)
+        else:
+            logger.info(missing_credentials_string)
+            logger.info(f"Please ensure these values are set in the connection '{app_id}'.")
+
+
+def validate_ProviderConfig(cfg: ProviderConfig, app_id: str)-> None:
+    if not cfg:
+        return
+
+    provider = cfg.provider
+
+    _validate_provider(provider)
+    _validate_extra_fields(provider=provider, cfg=cfg)
+    _validate_requirements(provider=provider, cfg=cfg, app_id=app_id)

ibm_watsonx_orchestrate/cli/commands/models/models_command.py

@@ -1,32 +1,20 @@
 import logging
-import os
-import sys
 from typing import List
+import json
+import sys
 
-import requests
-import rich
-import rich.highlighter
 import typer
 from typing_extensions import Annotated
 
-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.client.model_policies.types import ModelPolicy, ModelPolicyInner, \
-    ModelPolicyRetry, ModelPolicyStrategy, ModelPolicyStrategyMode, ModelPolicyTarget
-from ibm_watsonx_orchestrate.client.models.models_client import ModelsClient
-from ibm_watsonx_orchestrate.client.models.types import CreateVirtualModel, ModelType, ANTHROPIC_DEFAULT_MAX_TOKENS
-from ibm_watsonx_orchestrate.client.utils import instantiate_client
+from ibm_watsonx_orchestrate.agent_builder.models.types import ModelType
+from ibm_watsonx_orchestrate.agent_builder.model_policies.types import  ModelPolicyStrategyMode
+from ibm_watsonx_orchestrate.cli.commands.models.models_controller import ModelsController
+
 
 logger = logging.getLogger(__name__)
 models_app = typer.Typer(no_args_is_help=True)
 models_policy_app = typer.Typer(no_args_is_help=True)
-# models_app.add_typer(models_policy_app, name='policy', help='Add or remove pseudo models which route traffic between multiple downstream models')
-
-WATSONX_URL = os.getenv("WATSONX_URL")
-
-class ModelHighlighter(rich.highlighter.RegexHighlighter):
-    base_style = "model."
-    highlights = [r"(?P<name>(watsonx|virtual[-]model|virtual[-]policy)\/.+\/.+):"]
+models_app.add_typer(models_policy_app, name='policy', help='Add or remove pseudo models which route traffic between multiple downstream models')
 
 @models_app.command(name="list", help="List available models")
 def model_list(
@@ -35,108 +23,33 @@ def model_list(
         typer.Option("--raw", "-r", help="Display the list of models in a non-tabular format"),
     ] = False,
 ):
-    models_client: ModelsClient = instantiate_client(ModelsClient)
-    model_policies_client: ModelPoliciesClient = instantiate_client(ModelPoliciesClient)
-    global WATSONX_URL
-    default_env_path = get_default_env_file()
-    merged_env_dict = merge_env(
-        default_env_path,
-        None
-    )
-
-    if 'WATSONX_URL' in merged_env_dict and merged_env_dict['WATSONX_URL']:
-        WATSONX_URL = merged_env_dict['WATSONX_URL']
-
-    watsonx_url = merged_env_dict.get("WATSONX_URL")
-    if not watsonx_url:
-        logger.error("Error: WATSONX_URL is required in the environment.")
-        sys.exit(1)
-
-    logger.info("Retrieving virtual-model models list...")
-    virtual_models = models_client.list()
-
-
-
-    logger.info("Retrieving virtual-policies models list...")
-    virtual_model_policies = model_policies_client.list()
-
-    logger.info("Retrieving watsonx.ai models list...")
-    found_models = _get_wxai_foundational_models()
-
-
-    preferred_str = merged_env_dict.get('PREFERRED_MODELS', '')
-    incompatible_str = merged_env_dict.get('INCOMPATIBLE_MODELS', '') 
-
-    preferred_list = _string_to_list(preferred_str)
-    incompatible_list = _string_to_list(incompatible_str)
-
-    models = found_models.get("resources", [])
-    if not models:
-        logger.error("No models found.")
-    else:
-        # Remove incompatible models
-        filtered_models = []
-        for model in models:
-            model_id = model.get("model_id", "")
-            short_desc = model.get("short_description", "")
-            if any(incomp in model_id.lower() for incomp in incompatible_list):
-                continue
-            if any(incomp in short_desc.lower() for incomp in incompatible_list):
-                continue
-            filtered_models.append(model)
-        
-        # Sort to put the preferred first
-        def sort_key(model):
-            model_id = model.get("model_id", "").lower()
-            is_preferred = any(pref in model_id for pref in preferred_list)
-            return (0 if is_preferred else 1, model_id)
-        
-        sorted_models = sorted(filtered_models, key=sort_key)
-        
-        if print_raw:
-            theme = rich.theme.Theme({"model.name": "bold cyan"})
-            console = rich.console.Console(highlighter=ModelHighlighter(), theme=theme)
-            console.print("[bold]Available Models:[/bold]")
-
-            for model in virtual_models:
-                console.print(f"- ✨️ {model.name}:", model.description or 'No description provided.')
-
-            for model in virtual_model_policies:
-                console.print(f"- ✨️ {model.name}:", 'No description provided.')
-
-            for model in sorted_models:
-                model_id = model.get("model_id", "N/A")
-                short_desc = model.get("short_description", "No description provided.")
-                full_model_name = f"watsonx/{model_id}: {short_desc}"
-                marker = "★ " if any(pref in model_id.lower() for pref in preferred_list) else ""
-                console.print(f"- [yellow]{marker}[/yellow]{full_model_name}")
-
-            console.print("[yellow]★[/yellow] [italic dim]indicates a supported and preferred model[/italic dim]\n[blue dim]✨️[/blue dim] [italic dim]indicates a model from a custom provider[/italic dim]" )
-        else:
-            table = rich.table.Table(
-                show_header=True,
-                title="[bold]Available Models[/bold]",
-                caption="[yellow]★ [/yellow] indicates a supported and preferred model from watsonx\n[blue]✨️[/blue] indicates a model from a custom provider",
-                show_lines=True)
-            columns = ["Model", "Description"]
-            for col in columns:
-                table.add_column(col)
-
-            for model in virtual_models:
-                table.add_row(f"✨️ {model.name}", model.description or 'No description provided.')
-
-            for model in virtual_model_policies:
-                table.add_row(f"✨️ {model.name}", 'No description provided.')
-
-            for model in sorted_models:
-                model_id = model.get("model_id", "N/A")
-                short_desc = model.get("short_description", "No description provided.")
-                marker = "★ " if any(pref in model_id.lower() for pref in preferred_list) else ""
-                table.add_row(f"[yellow]{marker}[/yellow]watsonx/{model_id}", short_desc)
-        
-            rich.print(table)
-
+    models_controller = ModelsController()
+    models_controller.list_models(print_raw=print_raw)
 
+@models_app.command(name="import", help="Import models from spec file")
+def models_import(
+     file: Annotated[
+        str,
+        typer.Option(
+            "--file",
+            "-f",
+            help="Path to spec file containing model details.",
+        ),
+    ],
+    app_id: Annotated[
+        str, typer.Option(
+            '--app-id', '-a',
+            help='The app id of a key_value connection containing authentications details for the model provider.'
+        )
+    ] = None,
+):
+    models_controller = ModelsController()
+    models = models_controller.import_model(
+        file=file,
+        app_id=app_id
+    )
+    for model in models:
+        models_controller.publish_or_update_models(model=model)
 
 @models_app.command(name="add", help="Add an llm from a custom provider")
 def models_add(
@@ -144,10 +57,6 @@ def models_add(
         str,
         typer.Option("--name", "-n", help="The name of the model to add"),
     ],
-    env_file: Annotated[
-        str,
-        typer.Option('--env-file', '-e', help='The path to an .env file containing the credentials for your llm provider'),
-    ],
     description: Annotated[
         str,
         typer.Option('--description', '-d', help='The description of the model to add'),
@@ -156,38 +65,42 @@ def models_add(
         str,
         typer.Option('--display-name', help='What name should this llm appear as within the ui'),
     ] = None,
+    provider_config: Annotated[
+        str,
+        typer.Option(
+            "--provider-config",
+            help="LLM provider configuration in JSON format (e.g., '{\"customHost\": \"xyz\"}')",
+        ),
+    ] = None,
+    app_id: Annotated[
+        str, typer.Option(
+            '--app-id', '-a',
+            help='The app id of a key_value connection containing authentications details for the model provider.'
+        )
+    ] = None,
     type: Annotated[
         ModelType,
         typer.Option('--type', help='What type of model is it'),
     ] = ModelType.CHAT,
-
 ):
-    from ibm_watsonx_orchestrate.cli.commands.models.env_file_model_provider_mapper import env_file_to_model_ProviderConfig # lazily import this because the lut building is expensive
-
-    models_client: ModelsClient = instantiate_client(ModelsClient)
-    provider_config = env_file_to_model_ProviderConfig(model_name=name, env_file_path=env_file)
-    if not name.startswith('virtual-model/'):
-        name = f"virtual-model/{name}"
-    
-    config=None
-    # Anthropic has no default for max_tokens
-    if "anthropic" in name:
-        config = {
-            "max_tokens": ANTHROPIC_DEFAULT_MAX_TOKENS
-        }
-
-    model = CreateVirtualModel(
+    provider_config_dict = {}
+    if provider_config:
+        try:
+            provider_config_dict = json.loads(provider_config)
+        except:
+            logger.error(f"Failed to parse provider config. '{provider_config}' is not valid json")
+            sys.exit(1)
+
+    models_controller = ModelsController()
+    model = models_controller.create_model(
         name=name,
-        display_name=display_name or name,
         description=description,
-        tags=[],
-        provider_config=provider_config,
-        config=config,
-        model_type=type
+        display_name=display_name,
+        provider_config_dict = provider_config_dict,
+        model_type=type,
+        app_id=app_id,
     )
-
-    models_client.create(model)
-    logger.info(f"Successfully added the model '{name}'")
+    models_controller.publish_or_update_models(model=model)
 
 
 
@@ -198,122 +111,86 @@ def models_remove(
             typer.Option("--name", "-n", help="The name of the model to remove"),
         ]
 ):
-    models_client: ModelsClient = instantiate_client(ModelsClient)
-    models = models_client.list()
-    model = next(filter(lambda x: x.name == name or x.name == f"virtual-model/{name}", models), None)
-    if not model:
-        logger.error(f"No model found with the name '{name}'")
-        sys.exit(1)
-    
-    models_client.delete(model_id=model.id)
-    logger.info(f"Successfully removed the model '{name}'")
-        
-
-# @models_policy_app.command(name='add', help='Add a model policy')
-# def models_policy_add(
-#         name: Annotated[
-#             str,
-#             typer.Option("--name", "-n", help="The name of the model to remove"),
-#         ],
-#         models: Annotated[
-#             List[str],
-#             typer.Option('--model', '-m', help='The name of the model to add'),
-#         ],
-#         strategy: Annotated[
-#             ModelPolicyStrategyMode,
-#             typer.Option('--strategy', '-s', help='How to spread traffic across models'),
-#         ],
-#         strategy_on_code: Annotated[
-#             List[int],
-#             typer.Option('--strategy-on-code', help='The http status to consider invoking the strategy'),
-#         ],
-#         retry_on_code: Annotated[
-#             List[int],
-#             typer.Option('--retry-on-code', help='The http status to consider retrying the llm call'),
-#         ],
-#         retry_attempts: Annotated[
-#             int,
-#             typer.Option('--retry-attempts', help='The number of attempts to retry'),
-#         ],
-#         display_name: Annotated[
-#             str,
-#             typer.Option('--display-name', help='What name should this llm appear as within the ui'),
-#         ] = None
-# ):
-#     model_policies_client: ModelPoliciesClient = instantiate_client(ModelPoliciesClient)
-#     model_client: ModelsClient = instantiate_client(ModelsClient)
-#     model_lut = {m.name: m.id for m in model_client.list()}
-#     for m in models:
-#         if m not in model_lut:
-#             logger.error(f"No model found with the name '{m}'")
-#             exit(1)
-
-#     inner = ModelPolicyInner()
-#     inner.strategy = ModelPolicyStrategy(
-#         mode=strategy,
-#         on_status_codes=strategy_on_code
-#     )
-#     inner.targets = [ModelPolicyTarget(model_id=model_lut[m], weight=1) for m in models]
-#     if retry_on_code:
-#         inner.retry = ModelPolicyRetry(
-#             on_status_codes=retry_on_code,
-#             attempts=retry_attempts
-#         )
-
-#     if not display_name:
-#         display_name = name
-
-
-#     policy = ModelPolicy(
-#         name=name,
-#         display_name=display_name,
-#         policy=inner
-#     )
-#     model_policies_client.create(policy)
-#     logger.info(f"Successfully added the model policy '{name}'")
-
-
-
-# @models_policy_app.command(name='remove', help='Remove a model policy')
-# def models_policy_remove(
-#         name: Annotated[
-#             str,
-#             typer.Option("--name", "-n", help="The name of the model policy to remove"),
-#         ]
-# ):
-#     model_policies_client: ModelPoliciesClient = instantiate_client(ModelPoliciesClient)
-#     model_policies = model_policies_client.list()
-
-#     policy = next(filter(lambda x: x.name == name or x.name == f"virtual-policy/{name}", model_policies), None)
-#     if not policy:
-#         logger.error(f"No model found with the name '{name}'")
-#         exit(1)
-
-#     model_policies_client.delete(model_policy_id=policy.id)
-#     logger.info(f"Successfully removed the model '{name}'")
+    models_controller = ModelsController()
+    models_controller.remove_model(name=name)
 
+@models_policy_app.command(name='import', help='Add a model policy')
+def models_policy_import(
+    file: Annotated[
+        str,
+        typer.Option(
+            "--file",
+            "-f",
+            help="Path to spec file containing model details.",
+        ),
+    ],
+):
+    models_controller = ModelsController()
+    policies = models_controller.import_model_policy(
+        file=file
+    )
+    for policy in policies:
+        models_controller.publish_or_update_model_policies(policy=policy)
 
-def _get_wxai_foundational_models():
-    foundation_models_url = WATSONX_URL + "/ml/v1/foundation_model_specs?version=2024-05-01"
+@models_policy_app.command(name='add', help='Add a model policy')
+def models_policy_add(
+        name: Annotated[
+            str,
+            typer.Option("--name", "-n", help="The name of the model to remove"),
+        ],
+        models: Annotated[
+            List[str],
+            typer.Option('--model', '-m', help='The name of the model to add'),
+        ],
+        strategy: Annotated[
+            ModelPolicyStrategyMode,
+            typer.Option('--strategy', '-s', help='How to spread traffic across models'),
+        ],
+        strategy_on_code: Annotated[
+            List[int],
+            typer.Option('--strategy-on-code', help='The http status to consider invoking the strategy'),
+        ],
+        retry_on_code: Annotated[
+            List[int],
+            typer.Option('--retry-on-code', help='The http status to consider retrying the llm call'),
+        ],
+        retry_attempts: Annotated[
+            int,
+            typer.Option('--retry-attempts', help='The number of attempts to retry'),
+        ],
+        display_name: Annotated[
+            str,
+            typer.Option('--display-name', help='What name should this llm appear as within the ui'),
+        ] = None,
+        description: Annotated[
+            str,
+            typer.Option('--description', help='Description of the policy for display in the ui'),
+        ] = None
+):
+    models_controller = ModelsController()
+    policy = models_controller.create_model_policy(
+        name=name,
+        models=models,
+        strategy=strategy,
+        strategy_on_code=strategy_on_code,
+        retry_on_code=retry_on_code,
+        retry_attempts=retry_attempts,
+        display_name=display_name,
+        description=description
+    )
+    models_controller.publish_or_update_model_policies(policy=policy)
 
-    try:
-        response = requests.get(foundation_models_url)
-    except requests.exceptions.RequestException as e:
-        logger.exception(f"Exception when connecting to Watsonx URL: {foundation_models_url}")
-        raise
 
-    if response.status_code != 200:
-        error_message = (
-            f"Failed to retrieve foundational models from {foundation_models_url}. "
-            f"Status code: {response.status_code}. Response: {response.content}"
-        )
-        raise Exception(error_message)
-    
-    json_response = response.json()
-    return json_response
 
-def _string_to_list(env_value):
-    return [item.strip().lower() for item in env_value.split(",") if item.strip()]
+@models_policy_app.command(name='remove', help='Remove a model policy')
+def models_policy_remove(
+        name: Annotated[
+            str,
+            typer.Option("--name", "-n", help="The name of the model policy to remove"),
+        ]
+):
+    models_controller = ModelsController()
+    models_controller.remove_policy(name=name)
 
 if __name__ == "__main__":
     models_app()