ibm-watsonx-orchestrate 1.12.0b1__py3-none-any.whl → 1.13.0b0__py3-none-any.whl

ibm_watsonx_orchestrate/cli/commands/tools/tools_controller.py

@@ -1,5 +1,4 @@
 import logging
-import asyncio
 import importlib
 import inspect
 import sys
@@ -11,29 +10,28 @@ import zipfile
 from enum import Enum
 from os import path
 from pathlib import Path
-from typing import Iterable, List
+from typing import Iterable, List, Any, Optional, cast
 import rich
 import json
-from rich.json import JSON
 import glob
 
 import rich.table
 import typer
 
-from rich.console import Console
 from rich.panel import Panel
 
-from ibm_watsonx_orchestrate.agent_builder.tools import BaseTool, ToolSpec
+from ibm_watsonx_orchestrate.agent_builder.tools import BaseTool, ToolSpec, ToolListEntry
 from ibm_watsonx_orchestrate.agent_builder.tools.flow_tool import create_flow_json_tool
-from ibm_watsonx_orchestrate.agent_builder.tools.langflow_tool import create_langflow_tool
+from ibm_watsonx_orchestrate.agent_builder.tools.langflow_tool import LangflowTool, create_langflow_tool
 from ibm_watsonx_orchestrate.agent_builder.tools.openapi_tool import create_openapi_json_tools_from_uri,create_openapi_json_tools_from_content
 from ibm_watsonx_orchestrate.cli.commands.models.models_controller import ModelHighlighter
 from ibm_watsonx_orchestrate.cli.commands.tools.types import RegistryType
 from ibm_watsonx_orchestrate.cli.commands.connections.connections_controller import configure_connection, remove_connection, add_connection
+from ibm_watsonx_orchestrate.cli.common import ListFormats, rich_table_to_markdown
 from ibm_watsonx_orchestrate.agent_builder.connections.types import  ConnectionType, ConnectionEnvironment, ConnectionPreference
 from ibm_watsonx_orchestrate.cli.config import Config, CONTEXT_SECTION_HEADER, CONTEXT_ACTIVE_ENV_OPT, \
     PYTHON_REGISTRY_HEADER, PYTHON_REGISTRY_TYPE_OPT, PYTHON_REGISTRY_TEST_PACKAGE_VERSION_OVERRIDE_OPT, \
-    DEFAULT_CONFIG_FILE_CONTENT
+    DEFAULT_CONFIG_FILE_CONTENT, PYTHON_REGISTRY_SKIP_VERSION_CHECK_OPT
 from ibm_watsonx_orchestrate.agent_builder.connections import ConnectionSecurityScheme, ExpectedCredentials
 from ibm_watsonx_orchestrate.flow_builder.flows.decorators import FlowWrapper
 from ibm_watsonx_orchestrate.client.tools.tool_client import ToolClient
@@ -42,6 +40,7 @@ from ibm_watsonx_orchestrate.client.connections import get_connections_client, g
 from ibm_watsonx_orchestrate.client.utils import instantiate_client, is_local_dev
 from ibm_watsonx_orchestrate.flow_builder.utils import import_flow_support_tools
 from ibm_watsonx_orchestrate.utils.utils import sanitize_app_id
+from ibm_watsonx_orchestrate.utils.async_helpers import run_coroutine_sync
 from ibm_watsonx_orchestrate.utils.exceptions import BadRequest
 from ibm_watsonx_orchestrate.client.tools.tempus_client import TempusClient
 
@@ -56,6 +55,11 @@ DEFAULT_LANGFLOW_TOOL_REQUIREMENTS = [
     "lfx==0.1.8"
 ]
 
+DEFAULT_LANGFLOW_RUNNER_MODULES = [
+    "lfx",
+    "lfx-nightly"
+]
+
 class ToolKind(str, Enum):
     openapi = "openapi"
     python = "python"
@@ -615,7 +619,7 @@ def get_whl_in_registry(registry_url: str, version: str) -> str| None:
     return wheel_file
 
 class ToolsController:
-    def __init__(self, tool_kind: ToolKind = None, file: str = None, requirements_file: str = None):
+    def __init__(self, tool_kind: ToolKind = None, file: str = None, requirements_file: Optional[str] = None):
         self.client = None
         self.tool_kind = tool_kind
         self.file = file
@@ -651,14 +655,14 @@ class ToolsController:
                     app_id = app_id[0]
                     connection = connections_client.get_draft_by_app_id(app_id=app_id)
                     connection_id = connection.connection_id
-                tools = asyncio.run(import_openapi_tool(file=args["file"], connection_id=connection_id))
+                tools = run_coroutine_sync(import_openapi_tool(file=args["file"], connection_id=connection_id))
             case "flow":
-                tools = asyncio.run(import_flow_tool(file=args["file"]))
+                tools = run_coroutine_sync(import_flow_tool(file=args["file"]))
             case "skill":
                 tools = []
                 logger.warning("Skill Import not implemented yet")
             case "langflow":
-                tools = asyncio.run(import_langflow_tool(file=args["file"],app_id=args.get('app_id',None)))
+                tools = run_coroutine_sync(import_langflow_tool(file=args["file"],app_id=args.get('app_id',None)))
             case _:
                 raise BadRequest("Invalid kind selected")
 
@@ -669,14 +673,18 @@ class ToolsController:
             yield tool
 
 
-    def list_tools(self, verbose=False):
+    def list_tools(self, verbose=False, format: ListFormats| None = None) -> List[dict[str, Any]] | str | None:
+        if verbose and format:
+            logger.error("For tools list, `--verbose` and `--format` are mutually exclusive options")
+            sys.exit(1)
+
         response = self.get_client().get()
         tool_specs = []
         parse_errors = []
 
         for tool in response:
             try:
-                tool_specs.append(ToolSpec.model_validate(tool))
+                tool_specs.append(ToolSpec.model_validate(tool, context="list"))
             except Exception as e:
                 name = tool.get('name', None)
                 parse_errors.append([
@@ -693,12 +701,19 @@ class ToolsController:
                 tools_list.append(json.loads(tool.dumps_spec()))
 
             rich.print_json(json.dumps(tools_list, indent=4))
+            return tools_list
         else:
+            tool_details = []
+
+            connections_client = get_connections_client()
+            connections = connections_client.list()
+
+            connections_dict = {conn.connection_id: conn for conn in connections}
+
             table = rich.table.Table(show_header=True, header_style="bold white", show_lines=True)
             column_args = {
                 "Name": {"overflow": "fold"},
                 "Description": {},
-                "Permission": {}, 
                 "Type": {}, 
                 "Toolkit": {}, 
                 "App ID": {"overflow": "fold"}
@@ -706,11 +721,6 @@ class ToolsController:
             for column in column_args:
                 table.add_column(column,**column_args[column])
 
-            connections_client = get_connections_client()
-            connections = connections_client.list()
-
-            connections_dict = {conn.connection_id: conn for conn in connections}
-
             for tool in tools:
                 tool_binding = tool.__tool_spec__.binding
 
@@ -768,22 +778,31 @@ class ToolsController:
                         toolkit_name = toolkit["name"]
                     elif toolkit:
                         toolkit_name = str(toolkit)
-
                 
-                table.add_row(
-                    tool.__tool_spec__.name,
-                    tool.__tool_spec__.description,
-                    tool.__tool_spec__.permission,
-                    tool_type,
-                    toolkit_name,
-                    ", ".join(app_ids),
+                entry = ToolListEntry(
+                    name=tool.__tool_spec__.name,
+                    description=tool.__tool_spec__.description,
+                    type=tool_type,
+                    toolkit=toolkit_name,
+                    app_ids=app_ids
                 )
 
-            rich.print(table)
+                if format == ListFormats.JSON:
+                    tool_details.append(entry)
+                else:
+                    table.add_row(*entry.get_row_details())
+
+            match format:
+                case ListFormats.JSON:
+                    return tool_details
+                case ListFormats.Table:
+                    return rich_table_to_markdown(table)
+                case _:
+                    rich.print(table)
 
-            for error in parse_errors:
-                for l in error:
-                    logger.error(l)
+        for error in parse_errors:
+            for l in error:
+                logger.error(l)
 
     def get_all_tools(self) -> dict:
         return {entry["name"]: entry["id"] for entry in self.get_client().get()}
@@ -851,15 +870,18 @@ class ToolsController:
 
                         cfg = Config()
                         registry_type = cfg.read(PYTHON_REGISTRY_HEADER, PYTHON_REGISTRY_TYPE_OPT) or DEFAULT_CONFIG_FILE_CONTENT[PYTHON_REGISTRY_HEADER][PYTHON_REGISTRY_TYPE_OPT]
+                        skip_version_check = cfg.read(PYTHON_REGISTRY_HEADER, PYTHON_REGISTRY_SKIP_VERSION_CHECK_OPT) or DEFAULT_CONFIG_FILE_CONTENT[PYTHON_REGISTRY_HEADER][PYTHON_REGISTRY_SKIP_VERSION_CHECK_OPT]
 
                         version = __version__
                         if registry_type == RegistryType.LOCAL:
+                            logger.warning(f"Using a local registry which is for development purposes only")
                             requirements.append(f"/packages/ibm_watsonx_orchestrate-0.6.0-py3-none-any.whl\n")
                         elif registry_type == RegistryType.PYPI:
-                            wheel_file = get_whl_in_registry(registry_url='https://pypi.org/simple/ibm-watsonx-orchestrate', version=version)
-                            if not wheel_file:
-                                logger.error(f"Could not find ibm-watsonx-orchestrate@{version} on https://pypi.org/project/ibm-watsonx-orchestrate")
-                                exit(1)
+                            if not skip_version_check:
+                                wheel_file = get_whl_in_registry(registry_url='https://pypi.org/simple/ibm-watsonx-orchestrate', version=version)
+                                if not wheel_file:
+                                    logger.error(f"Could not find ibm-watsonx-orchestrate@{version} on https://pypi.org/project/ibm-watsonx-orchestrate")
+                                    exit(1)
                             requirements.append(f"ibm-watsonx-orchestrate=={version}\n")
                         elif registry_type == RegistryType.TESTPYPI:
                             override_version = cfg.get(PYTHON_REGISTRY_HEADER, PYTHON_REGISTRY_TEST_PACKAGE_VERSION_OVERRIDE_OPT) or version
@@ -890,13 +912,34 @@ class ToolsController:
                         tool_path = Path(self.file)
                         zip_tool_artifacts.write(tool_path, arcname=f"{tool_path.stem}.json")
 
-                        requirements = DEFAULT_LANGFLOW_TOOL_REQUIREMENTS
+                        requirements = []
 
                         if self.requirements_file:
                             requirements_file_path = Path(self.requirements_file)
                             requirements.extend(
                                 get_requirement_lines(requirements_file=requirements_file_path, remove_trailing_newlines=False)
                             )
+
+                        langflowTool = cast(LangflowTool, tool)
+                        # if there are additional requriements from the langflow model, we should add it to the requirement set
+                        if langflowTool.requirements and len(langflowTool.requirements) > 0:
+                            requirements.extend(langflowTool.requirements)
+
+                        # now check if the requirements contain modules listed in DEFAULT_LANGFLOW_RUNNER_MODULES
+                        # if it is needed, we are assuming the user wants to override the default langflow module
+                        # with a specific version
+                        runner_overridden = False
+                        for r in requirements:
+                            # get the module name from the requirements
+                            module_name = r.strip().split('==')[0].split('=')[0].split('>=')[0].split('<=')[0].split('~=')[0].lower()
+                            if not module_name.startswith('#'):
+                                if module_name in DEFAULT_LANGFLOW_RUNNER_MODULES:
+                                    runner_overridden = True
+                        
+                        if not runner_overridden:
+                            # add the default runner to the top of requirement list
+                            requirements = DEFAULT_LANGFLOW_TOOL_REQUIREMENTS + list(requirements)
+
                         requirements_content = '\n'.join(requirements) + '\n'
                         zip_tool_artifacts.writestr("requirements.txt",requirements_content)  
                         zip_tool_artifacts.writestr("bundle-format", "2.0.0\n")

ibm_watsonx_orchestrate/cli/commands/voice_configurations/voice_configurations_controller.py

@@ -3,10 +3,12 @@ import sys
 import rich
 import yaml
 import logging
-from ibm_watsonx_orchestrate.agent_builder.voice_configurations import VoiceConfiguration
+from typing import Optional, List, Any
+from ibm_watsonx_orchestrate.agent_builder.voice_configurations import VoiceConfiguration, VoiceConfigurationListEntry
 from ibm_watsonx_orchestrate.client.utils import instantiate_client
 from ibm_watsonx_orchestrate.client.voice_configurations.voice_configurations_client import VoiceConfigurationsClient
 from ibm_watsonx_orchestrate.utils.exceptions import BadRequest
+from ibm_watsonx_orchestrate.cli.common import ListFormats, rich_table_to_markdown
 
 logger = logging.getLogger(__name__)
 
@@ -69,12 +71,13 @@ class VoiceConfigurationsController:
       
     return configs[0]
 
-  def list_voice_configs(self, verbose: bool) -> None:
+  def list_voice_configs(self, verbose: bool, format: Optional[ListFormats]=None) -> List[dict[str | Any]] | List[VoiceConfigurationListEntry] | str | None:
     voice_configs = self.fetch_voice_configs()
 
     if verbose:
       json_configs = [json.loads(x.dumps_spec()) for x in voice_configs]
       rich.print_json(json.dumps(json_configs, indent=4))
+      return json_configs
     else:
       config_table = rich.table.Table(
         show_header=True, 
@@ -94,18 +97,27 @@ class VoiceConfigurationsController:
       for column in column_args:
         config_table.add_column(column, **column_args[column])
 
+      config_details = []
+
       for config in voice_configs:
-        attached_agents = [x.display_name or x.name or x.id for x in config.attached_agents]
-        config_table.add_row(
-          config.name,
-          config.voice_configuration_id,
-          config.speech_to_text.provider,
-          config.text_to_speech.provider,
-          ",".join(attached_agents)
+        attached_agents = [x.name or x.id for x in config.attached_agents]
+        entry = VoiceConfigurationListEntry(
+          name=config.name,
+          id=config.voice_configuration_id,
+          speech_to_text_provider=config.speech_to_text.provider,
+          text_to_speech_provider=config.text_to_speech.provider,
+          attached_agents=attached_agents
         )
+        config_details.append(entry)
+        config_table.add_row(*entry.get_row_details())
       
-      rich.print(config_table)
-
+      match format:
+        case ListFormats.JSON:
+          return config_details
+        case ListFormats.Table:
+          return rich_table_to_markdown(config_table)
+        case _:
+          rich.print(config_table)
 
   def create_voice_config(self, voice_config: VoiceConfiguration) -> str | None:
     client = self.get_voice_configurations_client()

ibm_watsonx_orchestrate/cli/common.py

@@ -0,0 +1,26 @@
+from enum import Enum
+from rich.table import Table
+
+class ListFormats(str, Enum):
+    Table = "table"
+    JSON = "json"
+
+    def __str__(self):
+        return self.value 
+
+    def __repr__(self):
+        return repr(self.value)
+
+def rich_table_to_markdown(table: Table) -> str:
+    headers = [column.header for column in table.columns]
+    cols = [[cell for cell in col.cells] for col in table.columns]
+    rows = list(map(list, zip(*cols)))
+
+    # Header row
+    md = "| " + " | ".join(headers) + " |\n"
+    # Separator row
+    md += "| " + " | ".join(["---"] * len(headers)) + " |\n"
+    # # Data rows
+    for row in rows:
+        md += "| " + " | ".join(row) + " |\n"
+    return md

ibm_watsonx_orchestrate/cli/config.py

@@ -22,6 +22,7 @@ AUTH_MCSP_TOKEN_OPT = "wxo_mcsp_token"
 AUTH_MCSP_TOKEN_EXPIRY_OPT = "wxo_mcsp_token_expiry"
 CONTEXT_ACTIVE_ENV_OPT = "active_environment"
 PYTHON_REGISTRY_TYPE_OPT = "type"
+PYTHON_REGISTRY_SKIP_VERSION_CHECK_OPT = "skip_version_check"
 PYTHON_REGISTRY_TEST_PACKAGE_VERSION_OVERRIDE_OPT = "test_package_version_override"
 ENV_WXO_URL_OPT = "wxo_url"
 ENV_IAM_URL_OPT = "iam_url"
@@ -40,7 +41,8 @@ DEFAULT_CONFIG_FILE_CONTENT = {
     CONTEXT_SECTION_HEADER: {CONTEXT_ACTIVE_ENV_OPT: None},
     PYTHON_REGISTRY_HEADER: {
         PYTHON_REGISTRY_TYPE_OPT: str(RegistryType.PYPI),
-        PYTHON_REGISTRY_TEST_PACKAGE_VERSION_OVERRIDE_OPT: None
+        PYTHON_REGISTRY_TEST_PACKAGE_VERSION_OVERRIDE_OPT: None,
+        PYTHON_REGISTRY_SKIP_VERSION_CHECK_OPT: False
     },
     ENVIRONMENTS_SECTION_HEADER: {
         PROTECTED_ENV_NAME: {
@@ -85,7 +87,8 @@ def _check_if_auth_config_file(folder, file):
 
 def clear_protected_env_credentials_token():
     auth_cfg = Config(config_file_folder=AUTH_CONFIG_FILE_FOLDER, config_file=AUTH_CONFIG_FILE)
-    auth_cfg.delete(AUTH_SECTION_HEADER, PROTECTED_ENV_NAME, AUTH_MCSP_TOKEN_OPT)
+    if auth_cfg.exists(AUTH_SECTION_HEADER, PROTECTED_ENV_NAME, AUTH_MCSP_TOKEN_OPT):
+        auth_cfg.delete(AUTH_SECTION_HEADER, PROTECTED_ENV_NAME, AUTH_MCSP_TOKEN_OPT)
 
 
 class ConfigFileTypes(str, Enum):
@@ -230,3 +233,31 @@ class Config:
 
         with open(self.config_file_path, 'w') as conf_file:
             yaml.dump(deletion_data, conf_file, allow_unicode=True)
+
+    def exists(self, *args) -> bool:
+        """
+        Determines if an item of arbitrary depth exists in the config file.
+        Takes an arbitrary number of args. Uses the args in order
+        as keys to access deeper sections of the config and then deleting the last specified key.
+        """
+        if len(args) < 1:
+            raise BadRequest("Config.delete() requires at least one positional argument")
+
+        config_data = {}
+        try:
+            with open(self.config_file_path, 'r') as conf_file:
+                config_data = yaml_safe_load(conf_file) or {}
+        except FileNotFoundError:
+            pass
+
+        expression = "config_data"
+        for key in args:
+            temp = eval(expression)
+
+            if not isinstance(temp, dict) or key not in temp:
+                return False
+
+            else:
+                expression += f"['{key}']"
+
+        return True

ibm_watsonx_orchestrate/client/connections/connections_client.py

@@ -3,27 +3,14 @@ from typing import List
 from ibm_cloud_sdk_core.authenticators import MCSPAuthenticator
 from pydantic import BaseModel, ValidationError
 from typing import Optional
-from enum import Enum
 
 from ibm_watsonx_orchestrate.client.base_api_client import BaseAPIClient, ClientAPIException
-from ibm_watsonx_orchestrate.agent_builder.connections.types import ConnectionEnvironment, ConnectionPreference, ConnectionConfiguration, ConnectionAuthType, ConnectionSecurityScheme, IdpConfigData, AppConfigData, ConnectionType
+from ibm_watsonx_orchestrate.agent_builder.connections.types import ConnectionEnvironment, ConnectionPreference, ConnectionConfiguration, ConnectionAuthType, ConnectionSecurityScheme, IdpConfigData, AppConfigData, ConnectionType, FetchConfigAuthTypes
 from ibm_watsonx_orchestrate.client.utils import is_cpd_env, is_local_dev
 
 import logging
 logger = logging.getLogger(__name__)
 
-
-class FetchConfigAuthTypes(str, Enum):
-    BASIC_AUTH = ConnectionType.BASIC_AUTH.value
-    BEARER_TOKEN = ConnectionType.BEARER_TOKEN.value
-    API_KEY_AUTH = ConnectionType.API_KEY_AUTH.value
-    OAUTH2_AUTH_CODE = ConnectionType.OAUTH2_AUTH_CODE.value
-    OAUTH2_IMPLICIT = 'oauth2_implicit'
-    OAUTH2_PASSWORD = ConnectionType.OAUTH2_PASSWORD.value
-    OAUTH2_CLIENT_CREDS = ConnectionType.OAUTH2_CLIENT_CREDS.value
-    OAUTH_ON_BEHALF_OF_FLOW = ConnectionType.OAUTH_ON_BEHALF_OF_FLOW.value
-    KEY_VALUE = ConnectionType.KEY_VALUE.value
-
 class ListConfigsResponse(BaseModel):
     connection_id: str = None,
     app_id: str = None

ibm_watsonx_orchestrate/client/copilot/cpe/copilot_cpe_client.py

@@ -1,4 +1,4 @@
-from typing import Dict, Any
+from typing import Dict, Any, List
 from uuid import uuid4
 
 from ibm_watsonx_orchestrate.client.base_api_client import BaseAPIClient
@@ -37,6 +37,39 @@ class CPEClient(BaseAPIClient):
         if response:
             return response[-1]
 
+    def refine_agent_with_chats(self, instruction: str, tools: Dict[str, Any], collaborators: Dict[str, Any], knowledge_bases: Dict[str, Any], trajectories_with_feedback: List[List[dict]], model: str | None = None) -> dict:
+        """
+        Refines an agent's instruction using provided chat trajectories and optional model name.
+        This method sends a payload containing the agent's current instruction and a list of chat trajectories
+        to the Copilot Prompt Engine (CPE) for refinement.
+        Optionally, a target model name can be specified to use in the refinement process.
+        Parameters:
+            instruction (str): The current instruction or prompt associated with the agent.
+            tools (Dict[str, Any]) - a dictionary containing the selected tools
+            collaborators (Dict[str, Any]) - a dictionary containing the selected collaborators
+            knowledge_bases (Dict[str, Any]) - a dictionary containing the selected knowledge_bases
+            trajectories_with_feedback (List[List[dict]]): A list of chat trajectories, where each trajectory is a list
+                of message dictionaries that may include user feedback.
+            model (str | None): Optional. The name of the model to use for refinement.
+        Returns:
+            dict: The last response from the CPE containing the refined instruction.
+        """
+
+        payload = {
+            "trajectories_with_feedback":trajectories_with_feedback,
+            "instruction":instruction,
+            "tools": tools,
+            "collaborators": collaborators,
+            "knowledge_bases": knowledge_bases
+        }
+
+        if model:
+            payload["target_model_name"] = model
+
+        response = self._post_nd_json("/wxo-cpe/refine-agent-with-trajectories", data=payload)
+
+        if response:
+            return response[-1]
 
     def init_with_context(self, model: str | None = None, context_data: Dict[str, Any] = None) -> dict:
         payload = {

ibm_watsonx_orchestrate/client/knowledge_bases/knowledge_base_client.py

@@ -30,8 +30,12 @@ class KnowledgeBaseClient(BaseAPIClient):
     def get_by_id(self, knowledge_base_id: str) -> dict:
         return self._get(f"{self.base_endpoint}/{knowledge_base_id}")
 
-    def get_by_names(self, name: List[str]) -> List[dict]:
-        formatted_names = [f"names={x}" for x in name]
+    def get_by_names(self, names: List[str]) -> List[dict]:
+        formatted_names = [f"names={x}" for x in names]
+        return self._get(f"{self.base_endpoint}?{'&'.join(formatted_names)}")
+    
+    def get_by_ids(self, ids: List[str]) -> List[dict]:
+        formatted_names = [f"ids={x}" for x in ids]
         return self._get(f"{self.base_endpoint}?{'&'.join(formatted_names)}")
     
     def status(self, knowledge_base_id: str) -> dict:

ibm_watsonx_orchestrate/client/model_policies/model_policies_client.py

@@ -58,7 +58,7 @@ class ModelPoliciesClient(BaseAPIClient):
                 return []
             raise e
     
-    def get_draft_by_name(self, policy_name: str) -> ModelPolicy:
+    def get_draft_by_name(self, policy_name: str) -> List[ModelPolicy]:
         return self.get_drafts_by_names([policy_name])
 
 

ibm_watsonx_orchestrate/client/models/models_client.py

@@ -60,7 +60,7 @@ class ModelsClient(BaseAPIClient):
                 return []
             raise e
     
-    def get_draft_by_name(self, model_name: str) -> ListVirtualModel:
+    def get_draft_by_name(self, model_name: str) -> List[ListVirtualModel]:
         return self.get_drafts_by_names([model_name])
 
 

ibm_watsonx_orchestrate/client/threads/threads_client.py

@@ -0,0 +1,34 @@
+from ibm_watsonx_orchestrate.client.base_api_client import BaseAPIClient
+
+
+class ThreadsClient(BaseAPIClient):
+    """
+    Client to handle read operations for Threads (chat history- trajectories) endpoints
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.base_endpoint = "/threads"
+
+    def get_all_threads(self, agent_id) -> dict:
+        return self._get(self.base_endpoint, params={"agent_id": agent_id})
+
+    def get_thread_messages(self, thread_id) -> dict:
+        return self._get(f"{self.base_endpoint}/{thread_id}/messages")
+
+    def get(self) -> dict:
+        return self._get(self.base_endpoint)
+
+    def get_threads_messages(self, thread_ids: list[str]):
+        """
+        get the messages for a list of threads (chats) ids
+        :param thread_ids:
+        :param threads_client:
+        :return:
+        """
+        all_thread_messages = []
+        for thread_id in thread_ids:
+            thread_messages = self.get_thread_messages(thread_id=thread_id)
+            all_thread_messages.append(thread_messages)
+
+        return all_thread_messages

ibm_watsonx_orchestrate/client/utils.py

@@ -175,23 +175,24 @@ def instantiate_client(client: type[T] , url: str | None=None) -> T:
         raise FileNotFoundError(message)
 
 
+def get_arm_architectures () -> list[str]:
+    # NOTE: intentionally omitting 32 bit arm architectures.
+    return ["aarch64", "arm64", "arm", "aarch64_be", "armv8b", "armv8l"]
+
+
 def get_architecture () -> str:
     arch = platform.machine().lower()
     if arch in ("amd64", "x86_64"):
         return "amd64"
-
-    elif arch == "i386":
-        return "386"
-
-    elif arch in ("aarch64", "arm64", "arm"):
-        return "arm"
+    elif arch in get_arm_architectures():
+        return arch
 
     else:
         raise Exception("Unsupported architecture %s" % arch)
 
 
 def is_arm_architecture () -> bool:
-    return platform.machine().lower() in ("aarch64", "arm64", "arm")
+    return platform.machine().lower() in get_arm_architectures()
 
 
 def get_os_type () -> str:
@@ -201,3 +202,24 @@ def get_os_type () -> str:
 
     else:
         raise Exception("Unsupported operating system %s" % system)
+
+def concat_bin_files(target_bin_file: str, source_files: list[str], read_chunk_size: int = None,
+                     delete_source_files_post: bool = True) -> None:
+    if read_chunk_size is None:
+        # default read chunk size is 100 MB.
+        read_chunk_size = 100 * 1024 * 1024
+
+    with open(target_bin_file, "wb") as target:
+        for source_file in source_files:
+            with open(source_file, "rb") as source:
+                while True:
+                    source_chunk = source.read(read_chunk_size)
+
+                    if source_chunk:
+                        target.write(source_chunk)
+
+                    else:
+                        break
+
+            if delete_source_files_post is True:
+                os.remove(source_file)

ibm_watsonx_orchestrate/docker/compose-lite.yml

@@ -241,7 +241,7 @@ services:
       - "wxo-server-minio"
 
   wxo-milvus-etcd:
-    image: quay.io/coreos/etcd:v3.5.18
+    image: ${ETCD_REGISTRY:-quay.io}/coreos/etcd:${ETCD_TAG:-v3.5.18}
     environment:
       - ETCD_AUTO_COMPACTION_MODE=revision
       - ETCD_AUTO_COMPACTION_RETENTION=1000
@@ -580,7 +580,7 @@ services:
   # IBM AGENT-OPS
   ########################
   elasticsearch:
-    image: docker.elastic.co/elasticsearch/elasticsearch:8.19.0
+    image: ${ELASTICSEARCH_REGISTRY:-docker.elastic.co}/elasticsearch/elasticsearch:${ELASTICSEARCH_TAG:-8.19.0}
     profiles: [ibm-telemetry]
     environment:
       - discovery.type=single-node