ibm-watsonx-orchestrate 1.12.2__py3-none-any.whl → 1.13.0b1__py3-none-any.whl

ibm_watsonx_orchestrate/cli/config.py

@@ -87,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):
@@ -232,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/agents/agent_client.py

@@ -131,7 +131,7 @@ class AgentClient(BaseAPIClient):
                 agent = transform_agents_to_flat_agent_spec(self._get(f"{self.base_endpoint}/{agent_id}"))
                 return agent
             except ClientAPIException as e:
-                if e.response.status_code == 404 and "not found with the given name" in e.response.text:
+                if e.response.status_code == 404 and ("not found with the given name" in e.response.text or ("Agent" in e.response.text and "not found" in e.response.text)):
                     return ""
                 raise(e)
     

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
@@ -13,22 +13,26 @@ class CPEClient(BaseAPIClient):
         self.chat_id = str(uuid4())
         super().__init__(*args, **kwargs)
         self.base_url = kwargs.get("base_url", self.base_url)
-        self.chat_model_name = 'llama-3-3-70b-instruct'
 
     def _get_headers(self) -> dict:
         return {
             "chat_id": self.chat_id
         }
 
+    def _get_chat_model_name_or_default(self, chat_nodel_name):
+        if chat_nodel_name:
+            return chat_nodel_name
+        return 'watsonx/meta-llama/llama-3-3-70b-instruct'
 
-    def submit_pre_cpe_chat(self, user_message: str | None =None, tools: Dict[str, Any] = None, collaborators: Dict[str, Any] = None, knowledge_bases: Dict[str, Any] = None, selected:bool=False) -> dict:
+    def submit_pre_cpe_chat(self, chat_llm: str |None, user_message: str | None =None,
+                            tools: Dict[str, Any] = None, collaborators: Dict[str, Any] = None, knowledge_bases: Dict[str, Any] = None, selected:bool=False) -> dict:
         payload = {
             "message": user_message,
             "tools": tools,
             "collaborators": collaborators,
             "knowledge_bases": knowledge_bases,
             "chat_id": self.chat_id,
-            "chat_model_name": self.chat_model_name,
+            "chat_model_name": self._get_chat_model_name_or_default(chat_llm),
             'selected':selected
         }
 
@@ -37,31 +41,71 @@ class CPEClient(BaseAPIClient):
         if response:
             return response[-1]
 
+    def refine_agent_with_chats(self, instruction: str, chat_llm: str | None,
+                                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.
+            chat_llm(str): The name of the chat model
+            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.
+        """
 
-    def init_with_context(self, model: str | None = None, context_data: Dict[str, Any] = None) -> dict:
         payload = {
-            "context_data": context_data,
-            "chat_id": self.chat_id
+            "trajectories_with_feedback":trajectories_with_feedback,
+            "instruction":instruction,
+            "tools": tools,
+            "collaborators": collaborators,
+            "knowledge_bases": knowledge_bases,
+            "chat_model_name": self._get_chat_model_name_or_default(chat_llm),
         }
 
         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, chat_llm: str | None,
+                          target_model_name: str | None = None, context_data: Dict[str, Any] = None) -> dict:
+        payload = {
+            "context_data": context_data,
+            "chat_id": self.chat_id,
+            "chat_model_name": self._get_chat_model_name_or_default(chat_llm),
+        }
+
+        if target_model_name:
+            payload["target_model_name"] = target_model_name
+
         response = self._post_nd_json("/wxo-cpe/init_cpe_from_wxo", data=payload)
 
         if response:
             return response[-1]
 
 
-    def invoke(self, prompt: str, model: str | None = None, context_data: Dict[str, Any] = None) -> dict:
+    def invoke(self, prompt: str, chat_llm: str| None,
+               target_model_name: str | None = None, context_data: Dict[str, Any] = None) -> dict:
         payload = {
             "prompt": prompt,
             "context_data": context_data,
-            "chat_id": self.chat_id
+            "chat_id": self.chat_id,
+            "chat_model_name": self._get_chat_model_name_or_default(chat_llm),
         }
 
-        if model:
-            payload["target_model_name"] = model
+        if target_model_name:
+            payload["target_model_name"] = target_model_name
 
         response = self._post_nd_json("/wxo-cpe/invoke", data=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/tools/tempus_client.py

@@ -12,7 +12,7 @@ class TempusClient(BaseAPIClient):
     This may be temporary and may want to create a proxy API in wxo-server 
     to redirect to the internal tempus runtime, and add a new operation in the ToolClient instead
     """
-    def __init__(self, base_url: str, api_key: str = None, is_local: bool = False, authenticator: MCSPAuthenticator = None):
+    def __init__(self, base_url: str, api_key: str = None, is_local: bool = False, authenticator: MCSPAuthenticator = None, *args, **kwargs):
         parsed_url = urlparse(base_url)
        
         # Reconstruct netloc with new port - use default above - eventually we need to open up a way through the wxo-server API
@@ -26,7 +26,9 @@ class TempusClient(BaseAPIClient):
             base_url=new_url,
             api_key=api_key,
             is_local=is_local,
-            authenticator=authenticator
+            authenticator=authenticator,
+            *args,
+            **kwargs
         )
         
     def get_tempus_endpoint(self) -> str:

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

@@ -175,6 +175,7 @@ services:
       ENABLE_EDIT_PROMPTS: "true"
       LANGFLOW_ENABLED: ${LANGFLOW_ENABLED:-false}
       ENABLE_EMBED_SCRIPT: "true"
+      ENABLE_BULK_TESTING: "true"
     command: 'npm start'
     ports:
       - "4025:4025"
@@ -241,7 +242,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 +581,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

ibm_watsonx_orchestrate/docker/default.env

@@ -73,13 +73,12 @@ AGENT_GATEWAY_REGISTRY=
 DB_REGISTRY=
 # If you build multiarch set all three of these to the same, we have a pr against main
 # to not have this separation, but we can merge it later
-DBTAG=17-09-2025-8a9aff2
-AMDDBTAG=17-09-2025-8a9aff2
-ARM64DBTAG=17-09-2025-8a9aff2
+DBTAG=06-10-2025-87419d6
+AMDDBTAG=06-10-2025-87419d6
+ARM64DBTAG=06-10-2025-87419d6
 
 UI_REGISTRY=
-UITAG=22-09-2025-e35f498
-
+UITAG=10-10-2025-f91ab60
 CM_REGISTRY=
 CM_TAG=16-09-2025-e33b344
 
@@ -92,10 +91,10 @@ TRM_REGISTRY=
 TR_TAG=24-09-2025-a515038
 TR_REGISTRY=
 
-BUILDER_TAG=24-09-2025-f9b68d8
+BUILDER_TAG=06-10-2025-6387930
 BUILDER_REGISTRY=
 
-FLOW_RUNTIME_TAG=22-09-2025-0bd3f58
+FLOW_RUNTIME_TAG=06-10-2025-1bc69ec
 FLOW_RUMTIME_REGISTRY=
 
 
@@ -108,13 +107,13 @@ JAEGER_PROXY_REGISTRY=
 SOCKET_HANDLER_TAG=29-05-2025
 SOCKET_HANDLER_REGISTRY=
 
-CPE_TAG=29-08-2025-e612bea
+CPE_TAG=06-10-2025-74e5ca0  
 CPE_REGISTRY=
 
 VOICE_CONTROLLER_TAG=12-09-2025-0e04772
 VOICE_CONTROLLER_REGISTRY=
 
-LANGFLOW_TAG=1.5.0.post2
+LANGFLOW_TAG=
 LANGFLOW_IMAGE=
 
 # IBM Document Processing
@@ -124,9 +123,15 @@ WDU_REGISTRY=
 DOCPROC_DPS_TAG=20250910-165658-290-c566031
 DOCPROC_LLMSERVICE_TAG=20250915-main-139-7a36ad3
 DOCPROC_CACHE_TAG=20250916-master-86-454157f
-DOCPROC_DPI_TAG=20250910-214413-288-a348dfd9
+DOCPROC_DPI_TAG=20250926-122324-302-cb9b3a46
 DOCPROC_REGISTRY=
 
+ETCD_TAG=
+ETCD_REGISTRY=
+
+ELASTICSEARCH_TAG=
+ELASTICSEARCH_REGISTRY=
+
 # END -- IMAGE REGISTRIES AND TAGS
 
 CPD_VERIFY=true

ibm_watsonx_orchestrate/flow_builder/flows/flow.py

@@ -26,7 +26,9 @@ from ibm_watsonx_orchestrate.client.tools.tool_client import ToolClient
 from ibm_watsonx_orchestrate.client.tools.tempus_client import TempusClient
 from ibm_watsonx_orchestrate.client.utils import instantiate_client
 from ..types import (
-    DocProcKVPSchema, Assignment, Conditions, EndNodeSpec, Expression, ForeachPolicy, ForeachSpec, LoopSpec, BranchNodeSpec, MatchPolicy, NodeIdCondition, PlainTextReadingOrder, PromptExample, PromptLLMParameters, PromptNodeSpec, ScriptNodeSpec, TimerNodeSpec,
+    DocProcKVPSchema, Assignment, Conditions, EndNodeSpec, Expression, ForeachPolicy, ForeachSpec, LoopSpec, BranchNodeSpec, MatchPolicy,
+    NodeIdCondition, PlainTextReadingOrder, PromptExample, PromptLLMParameters, PromptNodeSpec, ScriptNodeSpec, TimerNodeSpec,
+    NodeErrorHandlerConfig, NodeIdCondition, PlainTextReadingOrder, PromptExample, PromptLLMParameters, PromptNodeSpec,
     StartNodeSpec, ToolSpec, JsonSchemaObject, ToolRequestBody, ToolResponseBody, UserFieldKind, UserFieldOption, UserFlowSpec, UserNodeSpec, WaitPolicy,
     DocProcSpec, TextExtractionResponse, DocProcInput, DecisionsNodeSpec, DecisionsRule, DocExtSpec, File, DocumentClassificationResponse, DocClassifierSpec, DocumentProcessingCommonInput
 )
@@ -269,7 +271,8 @@ class Flow(Node):
                 
     def _create_node_from_tool_fn(
         self,
-        tool: Callable
+        tool: Callable,
+        error_handler_config: Optional[NodeErrorHandlerConfig] = None
     ) -> ToolNode:
         if not isinstance(tool, Callable):
             raise ValueError("Only functions with @tool decorator can be added.")
@@ -292,7 +295,8 @@ class Flow(Node):
                                      input_schema = tool_spec.input_schema,
                                      output_schema = tool_spec.output_schema,
                                      output_schema_object = spec.output_schema_object,
-                                     tool = tool_spec.name)
+                                     tool = tool_spec.name,
+                                     error_handler_config = error_handler_config,)
 
         return ToolNode(spec=toolnode_spec)
 
@@ -302,14 +306,18 @@ class Flow(Node):
         name: str | None = None,
         display_name: str | None = None,
         description: str | None = None,
-
         input_schema: type[BaseModel] | None = None,
         output_schema: type[BaseModel] | None = None,
-        input_map: DataMap = None
+        input_map: DataMap = None,
+        error_handler_config: NodeErrorHandlerConfig | None = None
     ) -> ToolNode:
         '''create a tool node in the flow'''
         if tool is None:
             raise ValueError("tool must be provided")
+
+
+        if isinstance(error_handler_config, dict):
+            error_handler_config = NodeErrorHandlerConfig.model_validate(error_handler_config)    
         
         if isinstance(tool, str):        
             name = name if name is not None and name != "" else tool
@@ -338,14 +346,16 @@ class Flow(Node):
                                      input_schema= _get_tool_request_body(input_schema_obj),
                                      output_schema= _get_tool_response_body(output_schema_obj),
                                      output_schema_object = output_schema_obj,
-                                     tool = tool)
+                                     tool = tool,
+                                     error_handler_config = error_handler_config
+                                     )
 
             node = ToolNode(spec=toolnode_spec)
         elif isinstance(tool, PythonTool):
             if callable(tool):
                 tool_spec = getattr(tool, "__tool_spec__", None)
                 if tool_spec:
-                    node = self._create_node_from_tool_fn(tool)
+                    node = self._create_node_from_tool_fn(tool, error_handler_config = error_handler_config)
                 else:
                     raise ValueError("Only functions with @tool decorator can be added.")
         else:
@@ -458,7 +468,8 @@ class Flow(Node):
             description: str | None = None,
             input_schema: type[BaseModel]|None = None, 
             output_schema: type[BaseModel]|None=None,
-            input_map: DataMap = None) -> PromptNode:
+            input_map: DataMap = None,
+            error_handler_config: NodeErrorHandlerConfig | None = None,) -> PromptNode:
 
         if name is None:
             raise ValueError("name must be provided.")
@@ -477,6 +488,7 @@ class Flow(Node):
             prompt_examples=prompt_examples,
             llm=llm,
             llm_parameters=llm_parameters,
+            error_handler_config=error_handler_config,
             input_schema=_get_tool_request_body(input_schema_obj),
             output_schema=_get_tool_response_body(output_schema_obj),
             output_schema_object = output_schema_obj
@@ -499,7 +511,8 @@ class Flow(Node):
             classes: type[BaseModel]| None = None, 
             description: str | None = None,
             min_confidence: float = 0.0,
-            input_map: DataMap = None) -> DocClassifierNode:
+            input_map: DataMap = None,
+            enable_review: bool = False) -> DocClassifierNode:
         
         if name is None :
             raise ValueError("name must be provided.")
@@ -520,7 +533,8 @@ class Flow(Node):
             output_schema=_get_tool_response_body(output_schema_obj),
             output_schema_object = output_schema_obj,
             config=doc_classifier_config,
-            version=version
+            version=version,
+            enable_review=enable_review
         )
         node = DocClassifierNode(spec=task_spec)
 
@@ -572,7 +586,8 @@ class Flow(Node):
             input_map: DataMap = None,
             enable_hw: bool = False,
             min_confidence: float = 0, # Setting a small value because htil is not supported for pro code. 
-            review_fields: List[str] = []) -> tuple[DocExtNode, type[BaseModel]]:
+            review_fields: List[str] = [],
+            enable_review: bool = False) -> tuple[DocExtNode, type[BaseModel]]:
         
         if name is None :
             raise ValueError("name must be provided.")
@@ -599,7 +614,8 @@ class Flow(Node):
             version=version,
             enable_hw=enable_hw,
             min_confidence=min_confidence,
-            review_fields=review_fields
+            review_fields=review_fields,
+            enable_review=enable_review
         )
         node = DocExtNode(spec=task_spec)
 

ibm_watsonx_orchestrate/flow_builder/types.py

@@ -256,6 +256,7 @@ class DocProcCommonNodeSpec(NodeSpec):
 class DocClassifierSpec(DocProcCommonNodeSpec):
     version : str = Field(description="A version of the spec")
     config : DocClassifierConfig
+    enable_review: bool = Field(description="Indicate if enable human in the loop review", default=False)
 
     def __init__(self, **data):
         super().__init__(**data)
@@ -266,6 +267,7 @@ class DocClassifierSpec(DocProcCommonNodeSpec):
         model_spec["version"] = self.version
         model_spec["config"] = self.config.model_dump()
         model_spec["task"] = DocProcTask.custom_document_classification
+        model_spec["enable_review"] = self.enable_review
         return model_spec
     
 class DocExtSpec(DocProcCommonNodeSpec):
@@ -273,6 +275,7 @@ class DocExtSpec(DocProcCommonNodeSpec):
     config : DocExtConfig
     min_confidence: float = Field(description="The minimal confidence acceptable for an extracted field value", default=0.0,le=1.0, ge=0.0 ,title="Minimum Confidence")
     review_fields: List[str] = Field(description="The fields that require user to review", default=[])
+    enable_review: bool = Field(description="Enable human in the loop review", default=False)
 
     def __init__(self, **data):
         super().__init__(**data)
@@ -285,6 +288,7 @@ class DocExtSpec(DocProcCommonNodeSpec):
         model_spec["task"] = DocProcTask.custom_field_extraction
         model_spec["min_confidence"] = self.min_confidence
         model_spec["review_fields"] = self.review_fields
+        model_spec["enable_review"] = self.enable_review
         return model_spec
     
 class DocProcField(BaseModel):
@@ -374,8 +378,24 @@ class EndNodeSpec(NodeSpec):
     def __init__(self, **data):
         super().__init__(**data)
         self.kind = "end"
+
+class NodeErrorHandlerConfig(BaseModel):
+    error_message: Optional[str] = None
+    max_retries: Optional[int] = None
+    retry_interval: Optional[int] = None
+        
+    def to_json(self) -> dict[str, Any]:
+        model_spec = {}
+        if self.error_message:
+            model_spec["error_message"] = self.error_message
+        if self.max_retries:
+            model_spec["max_retries"] = self.max_retries
+        if self.retry_interval:
+            model_spec["retry_interval"] = self.retry_interval
+        return model_spec
 class ToolNodeSpec(NodeSpec):
     tool: Union[str, ToolSpec] = Field(default = None, description="the tool to use")
+    error_handler_config: Optional[NodeErrorHandlerConfig] = None
 
     def __init__(self, **data):
         super().__init__(**data)
@@ -383,6 +403,8 @@ class ToolNodeSpec(NodeSpec):
 
     def to_json(self) -> dict[str, Any]:
         model_spec = super().to_json()
+        if self.error_handler_config:
+            model_spec["error_handler_config"] = self.error_handler_config.to_json()  
         if self.tool:
             if isinstance(self.tool, ToolSpec):
                 model_spec["tool"] = self.tool.model_dump(exclude_defaults=True, exclude_none=True, exclude_unset=True)
@@ -732,6 +754,7 @@ class PromptNodeSpec(NodeSpec):
     prompt_examples: Optional[list[PromptExample]]
     llm: Optional[str] 
     llm_parameters: Optional[PromptLLMParameters] 
+    error_handler_config: Optional[NodeErrorHandlerConfig] 
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
@@ -747,6 +770,8 @@ class PromptNodeSpec(NodeSpec):
             model_spec["llm"] = self.llm
         if self.llm_parameters:
             model_spec["llm_parameters"] = self.llm_parameters.to_json()
+        if self.error_handler_config:
+            model_spec["error_handler_config"] = self.error_handler_config.to_json()            
         if self.prompt_examples:
             model_spec["prompt_examples"] = []
             for example in self.prompt_examples:

ibm_watsonx_orchestrate/flow_builder/utils.py

@@ -170,19 +170,11 @@ async def import_flow_model(model):
 
     return tool_id
 
-def import_flow_support_tools(model):
-
-    if not is_local_dev():
-        # we can't import support tools into non-local environments yet
-        return []
-
-        
+def import_flow_support_tools(model):     
     schedulable = False
     if "schedulable" in model["spec"]:
         schedulable = model["spec"]["schedulable"]
 
-    client = instantiate_client(TempusClient)
-
     logger.info(f"Import 'get_flow_status' tool spec...")
     tools = [create_flow_status_tool("i__get_flow_status_intrinsic_tool__")]