ibm-watsonx-orchestrate 1.7.0a0__py3-none-any.whl → 1.8.0__py3-none-any.whl

ibm_watsonx_orchestrate/client/service_instance.py

@@ -6,6 +6,7 @@
 from __future__ import annotations
 
 from ibm_cloud_sdk_core.authenticators import MCSPAuthenticator 
+from ibm_cloud_sdk_core.authenticators import MCSPV2Authenticator
 from ibm_cloud_sdk_core.authenticators import IAMAuthenticator
 from ibm_cloud_sdk_core.authenticators import CloudPakForDataAuthenticator
 
@@ -51,24 +52,47 @@ class ServiceInstance(BaseServiceInstance):
     def _create_token(self) -> str:
         if not self._credentials.auth_type:
             if ".cloud.ibm.com" in self._credentials.url:
-                logger.warning("Using IBM IAM Auth Type. If this is incorrect please use the '--type' flag to explicitly choose one of 'ibm_iam' or 'mcsp' or 'cpd")
+                logger.warning("Using IBM IAM Auth Type. If this is incorrect please use the '--type' flag to explicitly choose one of 'mcsp', 'mcsp_v1', 'mcsp_v2' or 'cpd' ")
                 return self._authenticate(EnvironmentAuthType.IBM_CLOUD_IAM)
             elif is_cpd_env(self._credentials.url):
-                logger.warning("Using CPD Auth Type. If this is incorrect please use the '--type' flag to explicitly choose one of 'ibm_iam' or 'mcsp' or 'cpd")
+                logger.warning("Using CPD Auth Type. If this is incorrect please use the '--type' flag to explicitly choose one of 'ibm_iam', 'mcsp', 'mcsp_v1' or 'mcsp_v2' ")
                 return self._authenticate(EnvironmentAuthType.CPD)
             else:
-                logger.warning("Using MCSP Auth Type. If this is incorrect please use the '--type' flag to explicitly choose one of 'ibm_iam' or 'mcsp' or 'cpd' ")
-                return self._authenticate(EnvironmentAuthType.MCSP)
+                logger.warning("Using MCSP Auth Type. If this is incorrect please use the '--type' flag to explicitly choose one of 'ibm_iam', 'mcsp_v1', 'mcsp_v2' or 'cpd' ")
+                try:
+                    return self._authenticate(EnvironmentAuthType.MCSP_V1)
+                except:
+                    return self._authenticate(EnvironmentAuthType.MCSP_V2)
+        auth_type = self._credentials.auth_type.lower()
+        if auth_type == "mcsp":
+            try:
+                return self._authenticate(EnvironmentAuthType.MCSP_V1)
+            except:
+                return self._authenticate(EnvironmentAuthType.MCSP_V2)
+        elif auth_type == "mcsp_v1":
+            return self._authenticate(EnvironmentAuthType.MCSP_V1)
+        elif auth_type == "mcsp_v2":
+            return self._authenticate(EnvironmentAuthType.MCSP_V2)
         else:
-            return self._authenticate(self._credentials.auth_type)
+            return self._authenticate(auth_type)
 
     def _authenticate(self, auth_type: str) -> str:
         """Handles authentication based on the auth_type."""
         try:
             match auth_type:
-                case EnvironmentAuthType.MCSP:
+                case EnvironmentAuthType.MCSP | EnvironmentAuthType.MCSP_V1:
                     url = self._credentials.iam_url if self._credentials.iam_url is not None else "https://iam.platform.saas.ibm.com"
                     authenticator = MCSPAuthenticator(apikey=self._credentials.api_key, url=url)
+                case EnvironmentAuthType.MCSP_V2:
+                    url = self._credentials.iam_url if self._credentials.iam_url is not None else "https://account-iam.platform.saas.ibm.com"
+                    wxo_url = self._credentials.url
+                    instance_id = wxo_url.split("instances/")[1]
+                    authenticator = MCSPV2Authenticator(
+                        apikey=self._credentials.api_key, 
+                        url=url, 
+                        scope_collection_type="services", 
+                        scope_id=instance_id
+                    )
                 case EnvironmentAuthType.IBM_CLOUD_IAM:
                     authenticator = IAMAuthenticator(apikey=self._credentials.api_key, url=self._credentials.iam_url)
                 case EnvironmentAuthType.CPD:
@@ -100,8 +124,10 @@ class ServiceInstance(BaseServiceInstance):
                     raise ClientError(f"Unsupported authentication type: {auth_type}")
 
             return authenticator.token_manager.get_token()
+
         except Exception as e:
-            raise ClientError(f"Error getting {auth_type.upper()} Token", e)
+            raise ClientError(f"Error getting {auth_type.upper()} Token", logg_messages=False)
+
 
     
     def _is_token_refresh_possible(self) -> bool:

ibm_watsonx_orchestrate/client/utils.py

@@ -16,22 +16,26 @@ from ibm_watsonx_orchestrate.cli.config import (
 from threading import Lock
 from ibm_watsonx_orchestrate.client.base_api_client import BaseAPIClient
 from ibm_watsonx_orchestrate.utils.utils import yaml_safe_load
+from ibm_watsonx_orchestrate.cli.commands.channels.types import RuntimeEnvironmentType
 import logging
 from typing import TypeVar
 import os
 import jwt
 import time
+import sys
 
 logger = logging.getLogger(__name__)
 LOCK = Lock()
 T = TypeVar("T", bound=BaseAPIClient)
 
+def get_current_env_url() -> str:
+    cfg = Config()
+    active_env = cfg.read(CONTEXT_SECTION_HEADER, CONTEXT_ACTIVE_ENV_OPT)
+    return cfg.get(ENVIRONMENTS_SECTION_HEADER, active_env, ENV_WXO_URL_OPT)
 
 def is_local_dev(url: str | None = None) -> bool:
     if url is None:
-        cfg = Config()
-        active_env = cfg.read(CONTEXT_SECTION_HEADER, CONTEXT_ACTIVE_ENV_OPT)
-        url = cfg.get(ENVIRONMENTS_SECTION_HEADER, active_env, ENV_WXO_URL_OPT)
+        url = get_current_env_url()
 
     if url.startswith("http://localhost"):
         return True
@@ -47,21 +51,58 @@ def is_local_dev(url: str | None = None) -> bool:
 
     return False
 
-def is_ibm_cloud():
-    cfg = Config()
-    active_env = cfg.read(CONTEXT_SECTION_HEADER, CONTEXT_ACTIVE_ENV_OPT)
-    url = cfg.get(ENVIRONMENTS_SECTION_HEADER, active_env, ENV_WXO_URL_OPT)
+def is_ga_platform(url: str | None = None) -> bool:
+    if url is None:
+        url = get_current_env_url()
+
+    if url.__contains__("orchestrate.ibm.com"):
+        return True
+    return False
+
+def is_saas_env():
+    return is_ga_platform() or is_ibm_cloud_platform()
+
+def is_ibm_cloud_platform(url:str | None = None) -> bool:
+    if url is None:
+        url = get_current_env_url()
 
     if url.__contains__("cloud.ibm.com"):
         return True
     return False
 
+def is_cpd_env(url: str | None = None) -> bool:
+    if url is None:
+        url = get_current_env_url()
 
-def is_cpd_env(url: str) -> bool:
     if url.lower().startswith("https://cpd"):
         return True
     return False
 
+def get_cpd_instance_id_from_url(url: str | None = None) -> str:
+    if url is None:
+        url = get_current_env_url()
+
+    if not is_cpd_env(url):
+        logger.error(f"The host {url} is not a CPD instance")
+        sys.exit(1)
+
+    url_fragments = url.split('/')
+    return url_fragments[-1] if url_fragments[-1] else url_fragments[-2]
+
+
+
+
+def get_environment() -> str:
+    if is_local_dev():
+        return RuntimeEnvironmentType.LOCAL
+    if is_cpd_env():
+        return RuntimeEnvironmentType.CPD
+    if is_ibm_cloud_platform():
+        return RuntimeEnvironmentType.IBM_CLOUD
+    if is_ga_platform():
+        return RuntimeEnvironmentType.AWS
+    return None
+
 def check_token_validity(token: str) -> bool:
     try:
         token_claimset = jwt.decode(token, options={"verify_signature": False})

ibm_watsonx_orchestrate/docker/compose-lite.yml

@@ -46,7 +46,7 @@ services:
       WXO_SERVER_URL: http://wxo-server:4321
       MAX_POOL: 60
       DEPLOYMENT_MODE: laptop
-      SUFFIXLIST: '["global_05d7ba72", "ibm_184bdbd3"]'
+      SUFFIXLIST: ${CM_SUFFIXLIST:-[]}
     ports:
       - 3001:3001
 
@@ -120,7 +120,7 @@ services:
       TEMPUS_RUNTIME_ENDPOINT: http://wxo-tempus-runtime:9044
       CONNECTIONS_MANAGER_ENDPOINT: http://wxo-server-connection-manager:3001
       AGENT_OPS_API_KEY: ${AGENTOPS_API_KEY}
-      AGENTS_OPS_RUNTIME_ENDPOINT: https://host.docker.internal:8765
+      AGENTS_OPS_RUNTIME_ENDPOINT: https://frontend-server:443
       IS_OBSERVABILITY_FEATURE_ENABLED: "true"
       ALLOW_INSECURE_TLS: "true"
     command: 'npm start'
@@ -751,8 +751,8 @@ services:
       SERVER_HTTP_PORT: "9044"
       SERVER_CONTEXT_PATH:
       SERVER_JWK_URL: https://wo-ibm-dev.verify.ibm.com/v1.0/endpoint/default/jwks
-      SERVER_STANDALONE_TASK_CALLBACK_URL: http://localhost:9044/task/callback/{thread_id}/{requestId}
-      SERVER_FLOW_CALLBACK_URL: http://localhost:9044/v1/flows/{flow_instance_id}/{task_instance_id}/resume/async
+      SERVER_STANDALONE_TASK_CALLBACK_URL: http://wxo-tempus-runtime:9044/task/callback/{thread_id}/{requestId}
+      SERVER_FLOW_CALLBACK_URL: http://wxo-tempus-runtime:9044/v1/flows/{flow_instance_id}/{task_instance_id}/resume/async
       JWT_SECRET: ${JWT_SECRET}
       SERVER_INTERNAL_PROTOCOL: http
       SERVER_INTERNAL_HOSTNAME: wxo-tempus-runtime
@@ -782,6 +782,7 @@ services:
       LOG_LEVEL: info
       DISABLE_FLOW_BINDING: true
       DOCPROC_ENABLED: ${DOCPROC_ENABLED:-false}
+      DOCPROC_BASE_URL: http://wxo-doc-processing-infra-standalone:9080
       WO_API_KEY: ${WO_API_KEY}
       WO_INSTANCE: ${WO_INSTANCE}
       AUTHORIZATION_URL: ${AUTHORIZATION_URL}
@@ -795,6 +796,23 @@ services:
       - 9044:9044
     depends_on:
       - wxo-server-db
+  
+  cpe:
+    image: ${CPE_REGISTRY:-us.icr.io/watson-orchestrate-private}/wxo-prompt-optimizer:${CPE_TAG:-latest}
+    platform: linux/amd64
+    restart: unless-stopped
+    environment:
+      WATSONX_APIKEY: ${WATSONX_APIKEY}
+      WATSONX_SPACE_ID: ${WATSONX_SPACE_ID}
+      WO_API_KEY: ${WO_API_KEY}
+      WO_USERNAME: ${WO_USERNAME}
+      WO_PASSWORD: ${WO_PASSWORD}
+      WO_INSTANCE: ${WO_INSTANCE}
+      USE_SAAS_ML_TOOLS_RUNTIME: ${USE_SAAS_ML_TOOLS_RUNTIME}
+      WO_AUTH_TYPE: ${WO_AUTH_TYPE}
+      AUTHORIZATION_URL: ${AUTHORIZATION_URL}
+    ports:
+      - 8081:8080
 
 ########################
 # DOCPROC dependencies
@@ -863,7 +881,7 @@ services:
         condition: service_completed_successfully
 
   wdu-model-copy:
-    image: ${WDU_REGISTRY:-us.icr.io/watson-orchestrate-private}/document-processing/wdu-runtime:${WDU_TAG:-2.4.0}
+    image: ${WDU_REGISTRY:-us.icr.io/watson-orchestrate-private}/document-processing/wdu-models:${WDU_TAG:-2.4.0}
     platform: linux/amd64
     user: root
     profiles:
@@ -898,10 +916,11 @@ services:
       ENRICHMENT_BATCH_SIZE: "1000"
       CIPHER_AES_REALM_KEY: "dGVzdHRlc3R0ZXN0dGVzdA=="
       SIDECAR_METERED_ENABLED: "false"
-      DPI_DEBUG: true
+      DPI_DEBUG: "false"
       DPI_WO_WDU_SERVER_ENDPOINT: https://wxo-doc-processing-service:8080
       # DPI_RAG_SERVER_ENDPOINT: https://wxo-doc-processing-llm-service:8083
       DISABLE_TLS: true
+      STANDALONE_DPI: "true"
     depends_on:
       wxo-doc-processing-dpi-minio-init:
         condition: service_completed_successfully

ibm_watsonx_orchestrate/docker/default.env

@@ -53,16 +53,16 @@ EVENT_BROKER_TTL="-1"
 REGISTRY_URL=
 
 
-SERVER_TAG=26-06-2025
+SERVER_TAG=10-07-2025-beb40a3a
 SERVER_REGISTRY=
 
-WORKER_TAG=26-06-2025
+WORKER_TAG=10-07-2025-beb40a3a
 WORKER_REGISTRY=
 
-AI_GATEWAY_TAG=23-06-2025
+AI_GATEWAY_TAG=01-07-2025
 AI_GATEWAY_REGISTRY=
 
-AGENT_GATEWAY_TAG=23-06-2025
+AGENT_GATEWAY_TAG=07-07-2025
 AGENT_GATEWAY_REGISTRY=
 
 DB_REGISTRY=
@@ -73,41 +73,44 @@ AMDDBTAG=24-06-2025-v1
 ARM64DBTAG=24-06-2025-v1
 
 UI_REGISTRY=
-UITAG=26-06-2025
+UITAG=21-07-2025
 
 CM_REGISTRY=
-CM_TAG=18-06-2025
+CM_TAG=27-06-2025
 
-TRM_TAG=25-06-2025
+TRM_TAG=08-07-2025
 TRM_REGISTRY=
 
-TR_TAG=25-06-2025
+TR_TAG=08-07-2025
 TR_REGISTRY=
 
-BUILDER_TAG=26-06-2025-a
+BUILDER_TAG=22-07-2025-v1
 BUILDER_REGISTRY=
 
-FLOW_RUNTIME_TAG=23-06-2025
+FLOW_RUNTIME_TAG=15-07-2025
 FLOW_RUMTIME_REGISTRY=
 
 
-AGENT_ANALYTICS_TAG=24-06-2025
+AGENT_ANALYTICS_TAG=02-07-2025-v1
 AGENT_ANALYTICS_REGISTRY=
 
-JAEGER_PROXY_TAG=24-06-2025
+JAEGER_PROXY_TAG=01-07-2025
 JAEGER_PROXY_REGISTRY=
 
 SOCKET_HANDLER_TAG=29-05-2025
 SOCKET_HANDLER_REGISTRY=
 
+CPE_TAG=17-07-2025
+CPE_REGISTRY=
+
 # IBM Document Processing
-WDU_TAG=2.5.0-rc.2
+WDU_TAG=2.5.0
 WDU_REGISTRY=
 
 DOCPROC_DPS_TAG=20250610-183301-248-865fbc1
 DOCPROC_LLMSERVICE_TAG=20250604-192056-107-e1d4d66
 DOCPROC_CACHE_TAG=20250610-214940-68-f3258f4
-DOCPROC_DPI_TAG=20250624-155521-230-48b7f28b
+DOCPROC_DPI_TAG=20250702-000808-237-7b1e424d
 DOCPROC_REGISTRY=
 
 # END -- IMAGE REGISTRIES AND TAGS
@@ -161,6 +164,14 @@ DB_CONN_LIFE=
 DB_MAX_IDLE_CONN=
 DB_MAX_CONN=
 SERVER_HOST=
+WO_API_KEY=
+WO_PASSWORD=
+WO_USERNAME=
+WO_INSTANCE=
+AUTHORIZATION_URL=
+WO_AUTH_TYPE=
+PYTHONPATH=
+CM_SUFFIXLIST=
 
 # Use your machine's local IP address for external async tool communication.
 CALLBACK_HOST_URL=
@@ -172,4 +183,4 @@ RUNTIME_MANAGER_API_KEY=example
 
 
 # IBM Document Processing
-SERVICE_URL=https://wxo-doc-processing-cache:8080
+SERVICE_URL=https://wxo-doc-processing-cache:8080

ibm_watsonx_orchestrate/flow_builder/flows/__init__.py

@@ -1,6 +1,8 @@
 from .constants import START, END, RESERVED
-from ..types import FlowContext, TaskData, TaskEventType
-from ..node import UserNode, AgentNode, StartNode, EndNode, PromptNode, ToolNode
+
+from ..types import FlowContext, TaskData, TaskEventType, File, DecisionsCondition, DecisionsRule
+from ..node import UserNode, AgentNode, StartNode, EndNode, PromptNode, ToolNode, DecisionsNode
+
 from .flow import Flow, CompiledFlow, FlowRun, FlowEvent, FlowEventType, FlowFactory, MatchPolicy, WaitPolicy, ForeachPolicy, Branch, Foreach, Loop
 from .decorators import flow
 from ..data_map import Assignment, DataMap
@@ -14,13 +16,16 @@ __all__ = [
     "FlowContext",
     "TaskData",
     "TaskEventType",
+    "File",
 
+    "DocProcNode",
     "UserNode",
     "AgentNode",
     "StartNode",
     "EndNode",
     "PromptNode",
     "ToolNode",
+    "DecisionsNode",
     "Assignment",
     "DataMap",
 
@@ -36,8 +41,8 @@ __all__ = [
     "Branch",
     "Foreach",
     "Loop",
+    "DecisionsCondition",
+    "DecisionsRule",
 
-    "user",
-    "flow_spec",
     "flow"
 ]

ibm_watsonx_orchestrate/flow_builder/flows/decorators.py

@@ -33,7 +33,8 @@ def flow(*args,
          description: str|None=None,
          input_schema: type[BaseModel] | None = None,
          output_schema: type[BaseModel] | None = None,
-         initiators: Sequence[str] = ()):
+         initiators: Sequence[str] = (),
+         schedulable: bool = False):
     """Decorator to mark a function as a flow model builder."""
 
     def decorator(func: Callable):
@@ -58,7 +59,8 @@ def flow(*args,
                              description = node_spec.description,
                              input_schema = input_schema,
                              output_schema = output_schema,
-                             initiators = initiators)
+                             initiators = initiators,
+                             schedulable = schedulable)
 
         # logger.info("Creating flow model: %s", a_model.spec.name)
 

ibm_watsonx_orchestrate/flow_builder/flows/events.py

@@ -5,9 +5,11 @@ from dotenv import load_dotenv
 import os
 
 from typing import (
-    AsyncIterator, Union
+    AsyncIterator, TypeVar, Union
 )
 
+from enum import Enum
+
 from ..types import (
     FlowEventType, TaskEventType, FlowEvent, FlowContext
 )
@@ -66,12 +68,11 @@ def deserialize_flow_event(byte_data: bytes) -> FlowEvent:
     
     return flow_event
 
+def is_valid_enum_value(value: str, enum_type: type[Enum]) -> bool:
+    return value in (item.value for item in enum_type)
+
 def get_event_type(selected_event_type: str) -> Union[FlowEventType, TaskEventType]:
-    """Selects the right event type from the corresponding enumerator"""
-    eventKind = selected_event_type.upper()
-    if eventKind in FlowEventType.__members__:
-        return FlowEventType(selected_event_type)
-    elif eventKind in TaskEventType.__members__:
-        return TaskEventType(selected_event_type)
-    else:
-        raise ValueError(f"Invalid event type: {eventKind}")
+    for enum_type in [FlowEventType, TaskEventType]:
+        if is_valid_enum_value(selected_event_type, enum_type):
+            return enum_type(selected_event_type)
+    raise ValueError(f"Invalid event type: {selected_event_type}")

ibm_watsonx_orchestrate/flow_builder/flows/flow.py

@@ -15,6 +15,7 @@ import logging
 import copy
 import uuid
 import pytz
+import os
 
 from typing_extensions import Self
 from pydantic import BaseModel, Field, SerializeAsAny
@@ -25,11 +26,12 @@ from ibm_watsonx_orchestrate.client.tools.tempus_client import TempusClient
 from ibm_watsonx_orchestrate.client.utils import instantiate_client
 from ..types import (
     EndNodeSpec, Expression, ForeachPolicy, ForeachSpec, LoopSpec, BranchNodeSpec, MatchPolicy, PromptLLMParameters, PromptNodeSpec, 
-    StartNodeSpec, ToolSpec, JsonSchemaObject, ToolRequestBody, ToolResponseBody, UserFieldKind, UserFieldOption, UserFlowSpec, UserNodeSpec, WaitPolicy
+    StartNodeSpec, ToolSpec, JsonSchemaObject, ToolRequestBody, ToolResponseBody, UserFieldKind, UserFieldOption, UserFlowSpec, UserNodeSpec, WaitPolicy,
+    DocProcSpec, TextExtractionResponse, File, DecisionsNodeSpec, DecisionsRule
 )
 from .constants import CURRENT_USER, START, END, ANY_USER
 from ..node import (
-    EndNode, Node, PromptNode, StartNode, UserNode, AgentNode, DataMap, ToolNode
+    EndNode, Node, PromptNode, StartNode, UserNode, AgentNode, DataMap, ToolNode, DocProcNode, DecisionsNode
 )
 from ..types import (
     AgentNodeSpec, extract_node_spec, FlowContext, FlowEventType, FlowEvent, FlowSpec,
@@ -114,7 +116,7 @@ class Flow(Node):
                 # pydantic suppport nested comparison by default
 
                 schema.title = title
-                
+
                 if schema == existing_schema:
                     return existing_schema
                 # we need to do a deep compare
@@ -354,6 +356,7 @@ class Flow(Node):
               name: str, 
               agent: str, 
               display_name: str|None=None,
+              title: str | None = None,
               message: str | None = "Follow the agent instructions.",
               description: str | None = None,
               input_schema: type[BaseModel]|None = None, 
@@ -371,6 +374,7 @@ class Flow(Node):
             display_name=display_name,
             description=description,
             agent=agent,
+            title=title,
             message=message,
             guidelines=guidelines,
             input_schema=_get_tool_request_body(input_schema_obj),
@@ -428,6 +432,91 @@ class Flow(Node):
         # add the node to the list of node
         node = self._add_node(node)
         return cast(PromptNode, node)
+    
+    def decisions(self, 
+            name: str, 
+            display_name: str|None=None,
+            rules: list[DecisionsRule] | None = None,
+            default_actions: dict[str, Any] = None,
+            locale: str | None = None,
+            description: str | None = None,
+            input_schema: type[BaseModel]|None = None, 
+            output_schema: type[BaseModel]|None=None,
+            input_map: DataMap = None) -> PromptNode:
+
+        if name is None:
+            raise ValueError("name must be provided.")
+        
+        if rules is None:
+            raise ValueError("rules must be specified.")
+
+         # create input spec
+        input_schema_obj = _get_json_schema_obj(parameter_name = "input", type_def = input_schema)
+        output_schema_obj = _get_json_schema_obj("output", output_schema)
+
+        # Create the tool spec
+        task_spec = DecisionsNodeSpec(
+            name=name,
+            display_name=display_name if display_name is not None else name,
+            description=description,
+            rules=rules,
+            default_actions=default_actions,
+            locale=locale,
+            input_schema=_get_tool_request_body(input_schema_obj),
+            output_schema=_get_tool_response_body(output_schema_obj),
+            output_schema_object = output_schema_obj
+        )
+
+        node = DecisionsNode(spec=task_spec)
+        # setup input map
+        if input_map:
+            node.input_map = self._get_data_map(input_map)
+        
+        # add the node to the list of node
+        node = self._add_node(node)
+        return cast(DecisionsNode, node)
+    
+    def docproc(self, 
+            name: str, 
+            task: str,
+            display_name: str|None=None,
+            description: str | None = None,
+            input_map: DataMap = None) -> DocProcNode:
+
+        if name is None :
+            raise ValueError("name must be provided.")
+        
+        if task is None:
+            raise ValueError("task must be provided.")
+        
+        output_schema_dict = { 
+            "text_extraction" : TextExtractionResponse
+        }
+         # create input spec
+        input_schema_obj = _get_json_schema_obj(parameter_name = "input", type_def = File)
+        output_schema_obj = _get_json_schema_obj("output", output_schema_dict[task])
+        if "$defs" in output_schema_obj.model_extra:
+            output_schema_obj.model_extra.pop("$defs")
+        # Create the docproc spec
+        task_spec = DocProcSpec(
+            name=name,
+            display_name=display_name if display_name is not None else name,
+            description=description,
+            input_schema=_get_tool_request_body(input_schema_obj),
+            output_schema=_get_tool_response_body(output_schema_obj),
+            output_schema_object = output_schema_obj,
+            task=task
+        )
+
+        node = DocProcNode(spec=task_spec)
+        # setup input map
+        if input_map:
+            node.input_map = self._get_data_map(input_map)
+        
+        # add the node to the list of node
+        node = self._add_node(node)
+        return cast(DocProcNode, node)
+    
 
     def node_exists(self, node: Union[str, Node]):
      
@@ -921,7 +1010,8 @@ class FlowFactory(BaseModel):
                     description: str|None=None,
                     initiators: Sequence[str]|None=None,
                     input_schema: type[BaseModel]|None=None,
-                    output_schema: type[BaseModel]|None=None) -> Flow:
+                    output_schema: type[BaseModel]|None=None,
+                    schedulable: bool=False) -> Flow:
         if isinstance(name, Callable):
             flow_spec = getattr(name, "__flow_spec__", None)
             if not flow_spec:
@@ -942,7 +1032,8 @@ class FlowFactory(BaseModel):
             initiators=initiators,
             input_schema=_get_tool_request_body(input_schema_obj),
             output_schema=_get_tool_response_body(output_schema_obj),
-            output_schema_object = output_schema_obj
+            output_schema_object = output_schema_obj,
+            schedulable=schedulable,
         )
 
         return Flow(spec = flow_spec)
@@ -1228,10 +1319,12 @@ class UserFlow(Flow):
               kind: UserFieldKind = UserFieldKind.Text,
               display_name: str | None = None,
               description: str | None = None,
-              owners: list[str] = [],
               default: Any | None = None,
-              text: str = None,
+              text: str = None, # The text used to ask question to the user, e.g. 'what is your name?'
               option: UserFieldOption | None = None,
+              is_list: bool = False,
+              min: Any | None = None,
+              max: Any | None = None,
               input_map: DataMap = None,
               custom: dict[str, Any] = {}) -> UserNode:
         '''create a node in the flow'''
@@ -1246,20 +1339,42 @@ class UserFlow(Flow):
         schema_obj.properties = {}
         schema_obj.properties[name] = UserFieldKind.convert_kind_to_schema_property(kind, name, description, default, option, custom)
 
-        return self.user(name, 
-                         display_name=display_name,
-                         description=description,
-                         owners=owners,
-                         text=text,
-                         output_schema=schema_obj,
-                         input_map=input_map)
+        task_spec = UserNodeSpec(
+            name=name,
+            display_name=display_name,
+            description=description,
+            owners=[CURRENT_USER],
+            input_schema=_get_tool_request_body(schema_obj),
+            output_schema=_get_tool_response_body(schema_obj),
+            text=text,
+            output_schema_object = schema_obj
+        )
+
+        node = UserNode(spec = task_spec)
+        node.field(name = name,
+                   kind = kind,
+                   display_name = display_name,
+                   description = description,
+                   default = default,
+                   text = text,
+                   option = option,
+                   is_list = is_list,
+                   min = min,
+                   max = max,
+                   custom = custom)
+
+        # setup input map
+        if input_map:
+            node.input_map = self._get_data_map(input_map)
+
+        node = self._add_node(node)
+        return cast(UserNode, node)
 
     def user(
         self,
         name: str | None = None,
         display_name: str | None = None,
         description: str | None = None,
-        owners: list[str] = [],
         text: str | None = None,
         output_schema: type[BaseModel] | JsonSchemaObject| None = None,
         input_map: DataMap = None,
@@ -1273,16 +1388,12 @@ class UserFlow(Flow):
         # input and output is always the same in an user node
         output_schema_obj = output_schema_obj
 
-        # identify owner
-        if not owners:
-            owners = [ANY_USER]
-
         # Create the tool spec
         task_spec = UserNodeSpec(
             name=name,
             display_name=display_name,
             description=description,
-            owners=owners,
+            owners=[CURRENT_USER],
             input_schema=_get_tool_request_body(output_schema_obj),
             output_schema=_get_tool_response_body(output_schema_obj),
             text=text,