ibm-watsonx-orchestrate 1.7.0b1__tar.gz → 1.8.0b0__tar.gz

{ibm_watsonx_orchestrate-1.7.0b1 → ibm_watsonx_orchestrate-1.8.0b0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ibm-watsonx-orchestrate
-Version: 1.7.0b1
+Version: 1.8.0b0
 Summary: IBM watsonx.orchestrate SDK
 Author-email: IBM <support@ibm.com>
 License: MIT License

{ibm_watsonx_orchestrate-1.7.0b1 → ibm_watsonx_orchestrate-1.8.0b0}/src/ibm_watsonx_orchestrate/__init__.py

@@ -5,8 +5,7 @@
 
 pkg_name = "ibm-watsonx-orchestrate"
 
-__version__ = "1.7.0b1"
-
+__version__ = "1.8.0b0"
 
 
 

{ibm_watsonx_orchestrate-1.7.0b1 → ibm_watsonx_orchestrate-1.8.0b0}/src/ibm_watsonx_orchestrate/agent_builder/agents/types.py

@@ -14,7 +14,17 @@ from ibm_watsonx_orchestrate.utils.exceptions import BadRequest
 from ibm_watsonx_orchestrate.agent_builder.tools.types import JsonSchemaObject
 
 # TO-DO: this is just a placeholder. Will update this later to align with backend
-DEFAULT_LLM = "watsonx/meta-llama/llama-3-1-70b-instruct"
+DEFAULT_LLM = "watsonx/meta-llama/llama-3-2-90b-vision-instruct"
+
+# Handles yaml formatting for multiline strings to improve readability
+def str_presenter(dumper, data):
+    if len(data.splitlines()) > 1:  # check for multiline string
+        data = "\n".join([line.rstrip() for line in data.splitlines()])
+        return dumper.represent_scalar('tag:yaml.org,2002:str', data, style='|')
+    return dumper.represent_scalar('tag:yaml.org,2002:str', data)
+
+yaml.add_representer(str, str_presenter)
+yaml.representer.SafeRepresenter.add_representer(str, str_presenter) # to use with safe_dum
 
 class SpecVersion(str, Enum):
     V1 = "v1"
@@ -25,6 +35,12 @@ class AgentKind(str, Enum):
     EXTERNAL = "external"
     ASSISTANT = "assistant"
 
+    def __str__(self):
+        return self.value 
+
+    def __repr__(self):
+        return repr(self.value)
+
 class ExternalAgentAuthScheme(str, Enum):
     BEARER_TOKEN = 'BEARER_TOKEN'
     API_KEY = "API_KEY"

{ibm_watsonx_orchestrate-1.7.0b1 → ibm_watsonx_orchestrate-1.8.0b0}/src/ibm_watsonx_orchestrate/cli/commands/channels/webchat/channels_webchat_controller.py

@@ -4,7 +4,7 @@ import jwt
 import sys
 
 from ibm_watsonx_orchestrate.cli.config import Config, ENV_WXO_URL_OPT, ENVIRONMENTS_SECTION_HEADER, CONTEXT_SECTION_HEADER, CONTEXT_ACTIVE_ENV_OPT, CHAT_UI_PORT
-from ibm_watsonx_orchestrate.client.utils import is_local_dev, is_ibm_cloud, AUTH_CONFIG_FILE_FOLDER, AUTH_SECTION_HEADER, AUTH_MCSP_TOKEN_OPT, AUTH_CONFIG_FILE
+from ibm_watsonx_orchestrate.client.utils import is_local_dev, is_ibm_cloud_platform, get_environment, get_cpd_instance_id_from_url, is_saas_env, AUTH_CONFIG_FILE_FOLDER, AUTH_SECTION_HEADER, AUTH_MCSP_TOKEN_OPT, AUTH_CONFIG_FILE
 
 from ibm_watsonx_orchestrate.client.agents.agent_client import AgentClient
 
@@ -22,7 +22,7 @@ class ChannelsWebchatController:
         return self.native_client
     
     def extract_tenant_id_from_crn(self, crn: str) -> str:
-        is_ibm_cloud_env = is_ibm_cloud()
+        is_ibm_cloud_env = is_ibm_cloud_platform()
         if is_ibm_cloud_env:
             try:
                 parts = crn.split("a/")[1].split(":")
@@ -77,6 +77,7 @@ class ChannelsWebchatController:
         agent_environments = agent.get("environments", [])        
 
         is_local = is_local_dev()
+        is_saas = is_saas_env()
         target_env = env or 'draft'
 
         if is_local:
@@ -91,7 +92,7 @@ class ChannelsWebchatController:
                 logger.error(f'This agent does not exist in the {env} environment. You need to deploy it to {env} before you can embed the agent')
             exit(1)
 
-        if target_env == 'draft' and is_local == False:
+        if target_env == 'draft' and is_saas == True:
             logger.error(f'For SAAS, please ensure this agent exists in a Live Environment')
             exit(1)
              
@@ -99,7 +100,7 @@ class ChannelsWebchatController:
 
         return filtered_environments[0].get("id")
 
-    def get_tennent_id(self):
+    def get_tenant_id(self):
         auth_cfg = Config(AUTH_CONFIG_FILE_FOLDER, AUTH_CONFIG_FILE)
 
         cfg = Config()
@@ -154,30 +155,40 @@ class ChannelsWebchatController:
             
     def create_webchat_embed_code(self):
         crn = None
-        is_ibm_cloud_env = is_ibm_cloud()
-        is_local = is_local_dev()
-        if is_ibm_cloud_env is True:
-            crn = input("Please enter your CRN which can be gotten from the IBM Cloud UI: ")
-            if crn == "":
-                logger.error("You must enter your CRN for IBM Cloud instances")
+        environment = get_environment()
+
+        match (environment):
+            case "local":
+                tenant_id = self.get_tenant_id_local()
+
+            case "cpd":
+                tenant_id = get_cpd_instance_id_from_url()
+
+            case "ibmcloud":
+                crn = input("Please enter your CRN which can be retrieved from the IBM Cloud UI: ")
+                if crn == "":
+                    logger.error("You must enter your CRN for IBM Cloud instances")
+                    sys.exit(1)
+                is_crn_correct = self.check_crn_is_correct(crn)
+                if is_crn_correct == False:
+                    logger.error("Invalid CRN format provided.")
+                    sys.exit(1)
+                tenant_id = self.extract_tenant_id_from_crn(crn)
+
+            case "ga":
+                tenant_id = self.get_tenant_id()
+
+            case _:
+                logger.error("Environment not recognized")
                 sys.exit(1)
-            is_crn_correct = self.check_crn_is_correct(crn)
-            if is_crn_correct == False:
-                logger.error("Invalid CRN format provided.")
-
-        if is_ibm_cloud_env and crn is not None:
-            tenant_id = self.extract_tenant_id_from_crn(crn)
-        elif is_ibm_cloud_env is False and is_local is False:
-            tenant_id = self.get_tennent_id()
-        elif is_local:
-            tenant_id = self.get_tenant_id_local()
+            
         host_url = self.get_host_url()
         agent_id = self.get_agent_id(self.agent_name)
         agent_env_id = self.get_environment_id(self.agent_name, self.env)
 
         script_path = (
             "/wxoLoader.js?embed=true"
-            if is_local
+            if environment == "local"
             else "/wxochat/wxoLoader.js?embed=true"
         )
 
@@ -189,9 +200,8 @@ class ChannelsWebchatController:
         ]
 
         # Conditional fields for IBM Cloud
-        if is_ibm_cloud_env:
+        if environment == "ibmcloud":
             config_lines.append(f'crn: "{crn}"')
-        if is_ibm_cloud_env:
             config_lines.append(f'deploymentPlatform: "ibmcloud"')
 
         config_lines.append(f"""chatOptions: {{

ibm_watsonx_orchestrate-1.8.0b0/src/ibm_watsonx_orchestrate/cli/commands/copilot/copilot_command.py

@@ -0,0 +1,65 @@
+import typer
+from typing_extensions import Annotated
+from pathlib import Path
+from ibm_watsonx_orchestrate.cli.commands.copilot.copilot_controller import prompt_tune, create_agent
+from ibm_watsonx_orchestrate.cli.commands.copilot.copilot_server_controller import start_server, stop_server
+
+copilot_app = typer.Typer(no_args_is_help=True)
+
+# Server Commands
+@copilot_app.command(name="start", help='Start the copilot server')
+def start_server_command(
+    user_env_file: str = typer.Option(
+        None,
+        "--env-file", "-e",
+        help="Path to a .env file that overrides default.env. Then environment variables override both."
+    )
+):
+    user_env_file_path = Path(user_env_file) if user_env_file else None
+
+    start_server(user_env_file_path=user_env_file_path)
+
+@copilot_app.command(name="stop", help='Stop the copilot server')
+def stop_server_command():
+    stop_server()
+
+# Functional Commands
+@copilot_app.command(name="prompt-tune", help='Tune the instructions of an Agent using IBM Conversational Prompt Engineering (CPE) to improve agent performance')
+def prompt_tume_command(
+    file: Annotated[
+        str,
+        typer.Option("--file", "-f", help="Path to agent spec file"),
+    ] = None,
+    output_file: Annotated[
+        str,
+        typer.Option("--output-file", "-o", help="Optional output file to avoid overwriting existing agent spec"),
+    ] = None,
+    dry_run_flag: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Dry run will prevent the tuned content being saved and output the results to console"),
+    ] = False,
+    llm: Annotated[
+        str,
+        typer.Option("--llm", help="Select the agent LLM"),
+    ] = None,
+    samples: Annotated[
+        str,
+        typer.Option("--samples", "-s", help="Path to utterances sample file (txt file where each line is a utterance, or csv file with a single \"input\" column)"),
+    ] = None
+):
+    if file is None:
+        # create agent yaml from scratch
+        create_agent(
+            llm=llm,
+            output_file=output_file,
+            samples_file=samples,
+            dry_run_flag=dry_run_flag
+        )
+    else:
+        # improve existing agent instruction
+        prompt_tune(
+            agent_spec=file,
+            samples_file=samples,
+            output_file=output_file,
+            dry_run_flag=dry_run_flag,
+        )

ibm_watsonx_orchestrate-1.8.0b0/src/ibm_watsonx_orchestrate/cli/commands/copilot/copilot_controller.py

@@ -0,0 +1,293 @@
+import logging
+import os
+import sys
+import csv
+
+import rich
+from rich.console import Console
+from rich.prompt import Prompt
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from requests import ConnectionError
+from typing import List
+from ibm_watsonx_orchestrate.client.base_api_client import ClientAPIException
+from ibm_watsonx_orchestrate.agent_builder.tools import ToolSpec, ToolPermission, ToolRequestBody, ToolResponseBody
+from ibm_watsonx_orchestrate.cli.commands.agents.agents_controller import AgentsController, AgentKind
+from ibm_watsonx_orchestrate.agent_builder.agents.types import DEFAULT_LLM
+from ibm_watsonx_orchestrate.client.tools.tool_client import ToolClient
+from ibm_watsonx_orchestrate.client.copilot.cpe.copilot_cpe_client import CPEClient
+from ibm_watsonx_orchestrate.client.utils import instantiate_client
+from ibm_watsonx_orchestrate.utils.exceptions import BadRequest
+
+logger = logging.getLogger(__name__)
+
+def _validate_output_file(output_file: str, dry_run_flag: bool) -> None:
+    if not output_file and not dry_run_flag:
+        logger.error("Please provide a valid yaml output file. Or use the `--dry-run` flag to output generated agent content to terminal")
+        sys.exit(1)
+    
+    if output_file and dry_run_flag:
+        logger.error("Cannot set output file when performing a dry run")
+        sys.exit(1)
+    
+    if output_file:
+        _, file_extension = os.path.splitext(output_file)
+        if file_extension not in  {".yaml", ".yml", ".json"}:
+            logger.error("Output file must be of type '.yaml', '.yml' or '.json'")
+            sys.exit(1)
+
+def _get_progress_spinner() -> Progress:
+    console = Console()
+    return Progress(
+        SpinnerColumn(spinner_name="dots"),
+        TextColumn("[progress.description]{task.description}"),
+        transient=True,
+        console=console,
+    )
+
+def _get_incomplete_tool_from_name(tool_name: str) -> dict:
+    input_schema = ToolRequestBody(**{"type": "object", "properties": {}})
+    output_schema = ToolResponseBody(**{"description": "None"})
+    spec = ToolSpec(**{"name": tool_name, "description": tool_name, "permission": ToolPermission.ADMIN, "input_schema": input_schema, "output_schema": output_schema})
+    return spec.model_dump()
+
+def _get_tools_from_names(tool_names: List[str]) -> List[dict]:
+    if not len(tool_names):
+        return []
+    
+    tool_client = get_tool_client()
+
+    try:
+        with _get_progress_spinner() as progress:
+            task = progress.add_task(description="Fetching tools", total=None)
+            tools = tool_client.get_drafts_by_names(tool_names)
+            found_tools = {tool.get("name") for tool in tools}
+            rich.print("\n")
+            for tool_name in tool_names:
+                if tool_name not in found_tools:
+                    logger.warning(f"Failed to find tool named '{tool_name}'. Falling back to incomplete tool definition. Copilot performance maybe effected.")
+                    tools.append(_get_incomplete_tool_from_name(tool_name))
+            progress.remove_task(task)
+    except ConnectionError:
+        logger.warning(f"Failed to fetch tools from server. For optimal results please start the server and import the relevant tools {', '.join(tool_names)}.")
+        tools = []
+        for tool_name in tool_names:
+            tools.append(_get_incomplete_tool_from_name(tool_name))
+
+    return tools
+
+def get_cpe_client() -> CPEClient:
+    url = os.getenv('CPE_URL', "http://localhost:8081")
+    return instantiate_client(client=CPEClient, url=url)
+
+
+def gather_utterances(max: int) -> list[str]:
+    utterances = []
+    logger.info("Please provide 3 sample utterances you expect your agent to handle:")
+
+    count = 0
+
+    while count < max:
+        utterance = Prompt.ask("  [green]>[/green]").strip()
+
+        if utterance.lower() == 'q':
+            break
+
+        if utterance:
+            utterances.append(utterance)
+            count += 1
+
+    return utterances
+
+def pre_cpe_step(cpe_client, tool_client):
+    user_message = ""
+    with _get_progress_spinner() as progress:
+        task = progress.add_task(description="Initilizing Prompt Engine", total=None)
+        response = cpe_client.submit_pre_cpe_chat(user_message=user_message)
+        progress.remove_task(task)
+
+    res = {}
+    while True:
+        if "message" in response and response["message"]:
+            rich.print('\n🤖 Copilot: ' + response["message"])
+            user_message = Prompt.ask("\n👤 You").strip()
+            message_content = {"user_message": user_message}
+        elif "description" in response and response["description"]:
+            res["description"] = response["description"]
+            tools = find_tools_by_description(res["description"], tool_client)
+            message_content = {"tools": tools}
+        elif "metadata" in response:
+            res["agent_name"] = response["metadata"]["agent_name"]
+            res["agent_style"] = response["metadata"]["style"]
+            res["tools"] = [t for t in tools if t["name"] in response["metadata"]["tools"]]
+            return res
+        with _get_progress_spinner() as progress:
+            task = progress.add_task(description="Thinking...", total=None)
+            response = cpe_client.submit_pre_cpe_chat(**message_content)
+            progress.remove_task(task)
+
+# TODO: Add description RAG search
+def find_tools_by_description(description, tool_client):
+    with _get_progress_spinner() as progress:
+        task = progress.add_task(description="Fetching Tools", total=None)
+        try:
+            tools = tool_client.get()
+        except ConnectionError:
+            tools = []
+            rich.print("\n")
+            logger.warning("Failed to contact wxo server to fetch tools. Proceeding with empty tool list")
+        progress.remove_task(task)
+    return tools
+
+def gather_examples(samples_file=None):
+    if samples_file:
+        if samples_file.endswith('.txt'):
+            with open(samples_file) as f:
+                examples = f.read().split('\n')
+        elif samples_file.endswith('.csv'):
+            with open(samples_file, 'r', encoding='utf-8') as f:
+                reader = csv.DictReader(f)
+                if 'utterance' not in reader.fieldnames:
+                    raise BadRequest("CSV must have a column named 'utterance'")
+                examples = [row['utterance'].strip() for row in reader if row['utterance'].strip()]
+        else:
+            raise BadRequest(f'Unsupported samples file format: {os.path.basename(samples_file)}')
+    else:
+        examples = gather_utterances(3)
+
+    console = Console()
+    logger.info("You provided the following samples:")
+    for i, utterance in enumerate(examples, 1):
+        console.print(f"  {i}. {utterance}")
+
+    return examples
+
+
+def talk_to_cpe(cpe_client, samples_file=None, context_data=None):
+    context_data = context_data or {}
+    examples = gather_examples(samples_file)
+    # upload or gather input examples
+    context_data['examples'] = examples
+    response=None
+    with _get_progress_spinner() as progress:
+        task = progress.add_task(description="Thinking...", total=None)
+        response = cpe_client.init_with_context(context_data=context_data)
+        progress.remove_task(task)
+    accepted_prompt = None
+    while accepted_prompt is None:
+        resp = response.get('response')[0]
+        accepted_prompt = resp.get("final_zsh_prompt", None)
+        if not accepted_prompt:
+            cpe_message = resp.get("message", "")
+            rich.print('\n🤖 Copilot: ' + cpe_message)
+            message = Prompt.ask("\n👤 You").strip()
+            with _get_progress_spinner() as progress:
+                task = progress.add_task(description="Thinking...", total=None)
+                response = cpe_client.invoke(prompt=message)
+                progress.remove_task(task)
+
+    return accepted_prompt
+
+
+def prompt_tune(agent_spec: str, output_file: str | None, samples_file: str | None, dry_run_flag: bool) -> None:
+    agent = AgentsController.import_agent(file=agent_spec, app_id=None)[0]
+    agent_kind = agent.kind
+
+    if agent_kind != AgentKind.NATIVE:
+        logger.error(
+            f"Only native agents are supported for prompt tuning. Provided agent spec is on kind '{agent_kind}'")
+        sys.exit(1)
+
+    if not output_file and not dry_run_flag:
+        output_file = agent_spec
+    
+    _validate_output_file(output_file, dry_run_flag)
+
+    client = get_cpe_client()
+
+    instr = agent.instructions
+    prompt = 'My current prompt is:\n' + instr if instr else "I don't have an initial prompt."
+
+    tools = _get_tools_from_names(agent.tools)
+
+    try:
+        new_prompt = talk_to_cpe(cpe_client=client, samples_file=samples_file, context_data={"prompt": prompt, 'tools': tools, 'description': agent.description})
+    except ConnectionError:
+        logger.error("Failed to connect to Copilot server. Please ensure Copilot is running via `orchestrate copilot start`")
+        sys.exit(1)
+    except ClientAPIException:
+        logger.error("An unexpected server error has occur with in the Copilot server. Please check the logs via `orchestrate server logs`")
+        sys.exit(1)
+
+    if new_prompt:
+        logger.info(f"The new instruction is: {new_prompt}")
+        agent.instructions = new_prompt
+
+        if dry_run_flag:
+            rich.print(agent.model_dump())
+        else:
+            if os.path.dirname(output_file):
+                os.makedirs(os.path.dirname(output_file), exist_ok=True)
+            AgentsController.persist_record(agent, output_file=output_file)
+
+
+def get_tool_client(*args, **kwargs):
+    return instantiate_client(ToolClient)
+
+def create_agent(output_file: str, llm: str, samples_file: str | None, dry_run_flag: bool = False) -> None:
+    _validate_output_file(output_file, dry_run_flag)
+    # 1. prepare the clients
+    cpe_client = get_cpe_client()
+    tool_client = get_tool_client()
+
+    # 2. Pre-CPE stage:
+    try:
+        res = pre_cpe_step(cpe_client, tool_client)
+    except ConnectionError:
+        logger.error("Failed to connect to Copilot server. Please ensure Copilot is running via `orchestrate copilot start`")
+        sys.exit(1)
+    except ClientAPIException:
+        logger.error("An unexpected server error has occur with in the Copilot server. Please check the logs via `orchestrate server logs`")
+        sys.exit(1)
+        
+    tools = res["tools"]
+    description = res["description"]
+    agent_name = res["agent_name"]
+    agent_style = res["agent_style"]
+
+    # 4. discuss the instructions
+    instructions = talk_to_cpe(cpe_client, samples_file, {'tools': tools, 'description': description})
+
+    # 6. create and save the agent
+    llm = llm if llm else DEFAULT_LLM
+    params = {
+        'style': agent_style,
+        'tools': [t['name'] for t in tools],
+        'llm': llm
+    }
+    agent = AgentsController.generate_agent_spec(agent_name, AgentKind.NATIVE, description, **params)
+    agent.instructions = instructions
+
+    if dry_run_flag:
+        rich.print(agent.model_dump())
+        return
+
+    if os.path.dirname(output_file):
+        os.makedirs(os.path.dirname(output_file), exist_ok=True)
+    AgentsController.persist_record(agent, output_file=output_file)
+
+
+    message_lines = [
+        "Your agent building session finished successfully!",
+        f"Agent YAML saved in file:",
+        f"{os.path.abspath(output_file)}"
+    ]
+
+    # Determine the width of the frame
+    max_length = max(len(line) for line in message_lines)
+    frame_width = max_length + 4  # Padding for aesthetics
+
+    # Print the framed message
+    rich.print("╔" + "═" * frame_width + "╗")
+    for line in message_lines:
+        rich.print("║  " + line.ljust(max_length) + "  ║")
+    rich.print("╚" + "═" * frame_width + "╝")

ibm_watsonx_orchestrate-1.8.0b0/src/ibm_watsonx_orchestrate/cli/commands/copilot/copilot_server_controller.py

@@ -0,0 +1,154 @@
+import logging
+import sys
+from pathlib import Path
+import subprocess
+import time
+import requests
+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,
+)
+
+logger = logging.getLogger(__name__)
+
+def _verify_env_contents(env: dict) -> None:
+    if not env.get("WATSONX_APIKEY") or not env.get("WATSONX_SPACE_ID"):
+        logger.error("The Copilot feature requires wx.ai credentials to passed through the provided env file. Please set 'WATSONX_SPACE_ID' and 'WATSONX_APIKEY'")
+        sys.exit(1)
+
+def wait_for_wxo_cpe_health_check(timeout_seconds=45, interval_seconds=2):
+    url = "http://localhost:8081/version"
+    logger.info("Waiting for Copilot component to be initialized...")
+    start_time = time.time()
+    while time.time() - start_time <= timeout_seconds:
+        try:
+            response = requests.get(url)
+            if 200 <= response.status_code < 300:
+                return True
+            else:
+                pass
+        except requests.RequestException as e:
+            pass
+
+        time.sleep(interval_seconds)
+    return False
+
+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,
+    }
+
+    _verify_env_contents(merged_env_dict)
+
+    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
+
+    final_env_file = 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"
+    ]
+
+    logger.info(f"Starting docker-compose Copilot service...")
+    result = subprocess.run(command, capture_output=False)
+
+    if result.returncode == 0:
+        logger.info("Copilot Service started successfully.")
+        # Remove the temp file if successful
+        if final_env_file.exists():
+            final_env_file.unlink()
+    else:
+        error_message = result.stderr.decode('utf-8') if result.stderr else "Error occurred."
+        logger.error(
+            f"Error running docker-compose (temporary env file left at {final_env_file}):\n{error_message}"
+        )
+        return False
+    
+    is_successful_cpe_healthcheck = wait_for_wxo_cpe_health_check()
+    if not is_successful_cpe_healthcheck:
+        logger.error("The Copilot service did not initialize within the expected time.  Check the logs for any errors.")
+
+    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...")
+
+    result = subprocess.run(command, capture_output=False)
+
+    if result.returncode == 0:
+        logger.info("Copilot service stopped successfully.")
+        # Remove the temp file if successful
+        if final_env_file.exists():
+            final_env_file.unlink()
+    else:
+        error_message = result.stderr.decode('utf-8') if result.stderr else "Error occurred."
+        logger.error(
+            f"Error running docker-compose (temporary env file left at {final_env_file}):\n{error_message}"
+        )
+        sys.exit(1)
+
+def start_server(user_env_file_path: Path) -> None:
+    is_server_started = run_compose_lite_cpe(user_env_file=user_env_file_path)
+
+    if is_server_started:
+        logger.info("Copilot service successfully started")
+    else:
+        logger.error("Unable to start orchestrate Copilot service.  Please check error messages and logs")
+
+def stop_server() -> None:
+    run_compose_lite_cpe_down()

{ibm_watsonx_orchestrate-1.7.0b1 → ibm_watsonx_orchestrate-1.8.0b0}/src/ibm_watsonx_orchestrate/cli/commands/server/server_command.py

@@ -390,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",
     ]