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

ibm_watsonx_orchestrate/docker/default.env

@@ -58,16 +58,16 @@ REGISTRY_URL=
 
 
 
-SERVER_TAG=17-10-2025-8a9aff2
+SERVER_TAG=24-09-2025-17d7c67
 SERVER_REGISTRY=
 
-WORKER_TAG=17-10-2025-8a9aff2
+WORKER_TAG=24-09-2025-17d7c67
 WORKER_REGISTRY=
 
 AI_GATEWAY_TAG=20-08-2025-9ed6d40
 AI_GATEWAY_REGISTRY=
 
-AGENT_GATEWAY_TAG=16-09-2025-115ef29
+AGENT_GATEWAY_TAG=19-10-2025-e48ad3a
 AGENT_GATEWAY_REGISTRY=
 
 DB_REGISTRY=
@@ -78,7 +78,7 @@ AMDDBTAG=17-09-2025-8a9aff2
 ARM64DBTAG=17-09-2025-8a9aff2
 
 UI_REGISTRY=
-UITAG=19-09-2025-188b5fe
+UITAG=22-09-2025-e35f498
 
 CM_REGISTRY=
 CM_TAG=16-09-2025-e33b344
@@ -86,16 +86,16 @@ CM_TAG=16-09-2025-e33b344
 CONNECTIONS_UI_REGISTRY=
 CONNECTIONS_UI_TAG=15-09-2025-98aa9da
 
-TRM_TAG=15-09-2025-228f397
+TRM_TAG=16-09-2025-cb6b9df
 TRM_REGISTRY=
 
-TR_TAG=15-09-2025-228f397
+TR_TAG=24-09-2025-a515038
 TR_REGISTRY=
 
-BUILDER_TAG=19-09-2025-4ab5c88
+BUILDER_TAG=24-09-2025-f9b68d8
 BUILDER_REGISTRY=
 
-FLOW_RUNTIME_TAG=15-09-2025-c208dc5
+FLOW_RUNTIME_TAG=22-09-2025-0bd3f58
 FLOW_RUMTIME_REGISTRY=
 
 
@@ -108,7 +108,7 @@ JAEGER_PROXY_REGISTRY=
 SOCKET_HANDLER_TAG=29-05-2025
 SOCKET_HANDLER_REGISTRY=
 
-CPE_TAG=29-08-2025-e612bea
+CPE_TAG=24-09-2025-2be3101
 CPE_REGISTRY=
 
 VOICE_CONTROLLER_TAG=12-09-2025-0e04772
@@ -127,6 +127,12 @@ DOCPROC_CACHE_TAG=20250916-master-86-454157f
 DOCPROC_DPI_TAG=20250910-214413-288-a348dfd9
 DOCPROC_REGISTRY=
 
+ETCD_TAG=
+ETCD_REGISTRY=
+
+ELASTICSEARCH_TAG=
+ELASTICSEARCH_REGISTRY=
+
 # END -- IMAGE REGISTRIES AND TAGS
 
 CPD_VERIFY=true

ibm_watsonx_orchestrate/flow_builder/flows/decorators.py

@@ -35,6 +35,7 @@ def flow(*args,
          description: str|None=None,
          input_schema: type[BaseModel] | None = None,
          output_schema: type[BaseModel] | None = None,
+         private_schema: type[BaseModel] | None = None,
          initiators: Sequence[str] = (),
          schedulable: bool = False,
          llm_model: str|ListVirtualModel|None=None,
@@ -63,6 +64,7 @@ def flow(*args,
                              description = node_spec.description,
                              input_schema = input_schema,
                              output_schema = output_schema,
+                             private_schema = private_schema,
                              initiators = initiators,
                              schedulable = schedulable,
                              llm_model = llm_model,

ibm_watsonx_orchestrate/flow_builder/flows/flow.py

@@ -26,13 +26,15 @@ 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, 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
 )
 from .constants import CURRENT_USER, START, END, ANY_USER
 from ..node import (
-    EndNode, Node, PromptNode, StartNode, UserNode, AgentNode, DataMap, ToolNode, DocProcNode, DecisionsNode, DocExtNode, DocClassifierNode
+    EndNode, Node, PromptNode, ScriptNode, StartNode, UserNode, AgentNode, DataMap, ToolNode, DocProcNode, DecisionsNode, DocExtNode, DocClassifierNode
 )
 from ..types import (
     AgentNodeSpec, extract_node_spec, FlowContext, FlowEventType, FlowEvent, FlowSpec,
@@ -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:
@@ -357,6 +367,41 @@ class Flow(Node):
 
         node = self._add_node(node)
         return cast(ToolNode, node)
+    
+
+    def script(
+        self,
+        script: str | None = "",
+        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
+    ) -> ScriptNode:
+        '''create a script node in the flow'''    
+        name = name if name is not None and name != "" else ""
+
+        input_schema_obj = _get_json_schema_obj("input", input_schema)
+        output_schema_obj = _get_json_schema_obj("output", output_schema)
+
+        script_node_spec = ScriptNodeSpec(
+                                name = name,
+                                display_name = display_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,
+                                fn = script)
+
+        node = ScriptNode(spec=script_node_spec)
+
+        # setup input and output map
+        if input_map:
+            node.input_map = self._get_data_map(input_map)
+
+        node = self._add_node(node)
+        return cast(ScriptNode, node)
  
 
     def _add_node(self, node: Node) -> Node:
@@ -423,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.")
@@ -442,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
@@ -1245,6 +1292,7 @@ class FlowFactory(BaseModel):
                     initiators: Sequence[str]|None=None,
                     input_schema: type[BaseModel]|None=None,
                     output_schema: type[BaseModel]|None=None,
+                    private_schema: type[BaseModel]|None=None,
                     schedulable: bool=False,
                     llm_model: str|ListVirtualModel|None=None,
                     agent_conversation_memory_turns_limit: int|None = None) -> Flow:
@@ -1257,6 +1305,7 @@ class FlowFactory(BaseModel):
         input_schema_obj = _get_json_schema_obj(parameter_name = "input", type_def = input_schema)
         # create input spec
         output_schema_obj = _get_json_schema_obj("output", output_schema)
+        private_schema_obj = _get_json_schema_obj("private", private_schema)
         if initiators is None:
             initiators = []
 
@@ -1268,6 +1317,7 @@ class FlowFactory(BaseModel):
             initiators=initiators,
             input_schema=_get_tool_request_body(input_schema_obj),
             output_schema=_get_tool_response_body(output_schema_obj),
+            private_schema = private_schema_obj,
             output_schema_object = output_schema_obj,
             schedulable=schedulable,
         )

ibm_watsonx_orchestrate/flow_builder/node.py

@@ -6,7 +6,7 @@ import yaml
 from pydantic import BaseModel, Field, SerializeAsAny, create_model
 from enum import Enum
 
-from .types import Assignment, DocExtConfigField, EndNodeSpec, NodeSpec, AgentNodeSpec, PromptNodeSpec, TimerNodeSpec, StartNodeSpec, ToolNodeSpec, UserFieldKind, UserFieldOption, UserNodeSpec, DocProcSpec, \
+from .types import Assignment, DocExtConfigField, EndNodeSpec, NodeSpec, AgentNodeSpec, PromptNodeSpec, ScriptNodeSpec, TimerNodeSpec, StartNodeSpec, ToolNodeSpec, UserFieldKind, UserFieldOption, UserNodeSpec, DocProcSpec, \
                     DocExtSpec, DocExtConfig, DocClassifierSpec, DecisionsNodeSpec, DocClassifierConfig
 
 from .data_map import DataMap
@@ -132,6 +132,18 @@ class ToolNode(Node):
 
     def get_spec(self) -> ToolNodeSpec:
         return cast(ToolNodeSpec, self.spec)
+    
+
+class ScriptNode(Node):
+    def __repr__(self):
+        return f"ScriptNode(name='{self.spec.name}', description='{self.spec.description}')"
+
+    def get_spec(self) -> ScriptNodeSpec:
+        return cast(ScriptNodeSpec, self.spec)
+    
+    def updateScript(self, script: str):
+        '''Update the script of a script node'''
+        self.spec.fn = script
 
 class UserNode(Node):
     def __repr__(self):

ibm_watsonx_orchestrate/flow_builder/types.py

@@ -374,8 +374,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,12 +399,27 @@ 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)
             else:
                 model_spec["tool"] = self.tool
         return model_spec
+    
+class ScriptNodeSpec(NodeSpec):
+     fn: str = Field(default = None, description="the script to execute")
+
+     def __init__(self, **data):
+         super().__init__(**data)
+         self.kind = "script"
+
+     def to_json(self) -> dict[str, Any]:
+         model_spec = super().to_json()
+         if self.fn:
+             model_spec["fn"] = self.fn
+         return model_spec
 
 
 class UserFieldValue(BaseModel):
@@ -719,6 +750,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)
@@ -734,6 +766,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:
@@ -871,6 +905,9 @@ class FlowSpec(NodeSpec):
     initiators: Sequence[str] = [ANY_USER]
     schedulable: bool = False
 
+    # flow can have private schema
+    private_schema: JsonSchemaObject | SchemaRef | None = None
+
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.kind = "flow"
@@ -879,6 +916,8 @@ class FlowSpec(NodeSpec):
         model_spec = super().to_json()
         if self.initiators:
             model_spec["initiators"] = self.initiators
+        if self.private_schema:
+             model_spec["private_schema"] = _to_json_from_json_schema(self.private_schema)
         
         model_spec["schedulable"] = self.schedulable
 

ibm_watsonx_orchestrate/langflow/langflow_utils.py

@@ -0,0 +1,195 @@
+import logging
+import ast
+import sys
+from pathlib import Path
+import importlib.util
+
+from pydantic import BaseModel
+
+from .lfx_deps import LFX_DEPENDENCIES
+
+logger = logging.getLogger(__name__)
+
+class LangflowComponent(BaseModel):
+    id: str
+    name: str
+    credentials: dict
+    requirements: list[str] = []
+
+class LangflowModelSpec(BaseModel):
+    version: str
+    components: list[LangflowComponent]
+
+_MODULE_MAP = {
+    "mem0":"mem0ai",
+}
+
+import math
+from collections import Counter
+
+def _calculate_entropy(s):
+    """
+    Calculates the Shannon entropy of a string.
+
+    Parameters:
+        s (str): Input string.
+
+    Returns:
+        float: Shannon entropy value.
+    """
+    if not s:
+        return 0.0
+
+    freq = Counter(s)
+    length = len(s)
+
+    entropy = -sum((count / length) * math.log2(count / length) for count in freq.values())
+    return entropy
+
+def _mask_api_key(key):
+    """
+    Masks an API key by keeping the first 5 characters visible,
+    masking the rest with asterisks, and truncating the result to a maximum of 25 characters.
+
+    Parameters:
+        key (str): The API key string.
+
+    Returns:
+        str: Masked and truncated API key.
+    """
+    if not isinstance(key, str):
+        return key
+    
+    # if this is a potential real API key -- mask it
+    if _calculate_entropy(key) > 4.1:
+        visible_part = key[:5]
+        masked_part = '*' * (len(key) - 5)
+        masked_key = visible_part + masked_part
+
+        return masked_key[:25]
+    elif len(key) > 25:
+        # if the key is longer than 25 characters, truncates it anyway
+        return key[:22] + '...'
+    
+    return key
+
+def _extract_imports(source_code) -> list[str]:
+    tree = ast.parse(source_code)
+    imports = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                # we only need the module name, not sub-module
+                imports.add(alias.name.split('.')[0])
+        elif isinstance(node, ast.ImportFrom):
+            if node.module:
+                # we only need the module name, not sub-module
+                imports.add(node.module.split('.')[0])
+    return sorted(imports)
+
+
+
+def _is_builtin_module(module_name: str) -> bool:
+    underscore_module_name = f"_{module_name}"
+
+    # Check against the list of standard modules 
+    if module_name in sys.stdlib_module_names:
+        return True
+    
+    if underscore_module_name in sys.stdlib_module_names:
+        return True
+
+    # Check against the list of built-in module names
+    if module_name in sys.builtin_module_names:
+        return True
+
+    if underscore_module_name in sys.builtin_module_names:
+        return True
+    
+    # Use importlib to find the module spec
+    spec = importlib.util.find_spec(module_name)
+    if spec is None:
+        return False  # Module not found
+
+    # Check if the loader is a BuiltinImporter
+    return isinstance(spec.loader, importlib.machinery.BuiltinImporter)
+
+
+def _find_missing_requirements(imported_modules, requirements_modules: list[str]) -> list[str]:
+    """
+    Compare imported modules with requirements.txt and return missing ones.
+
+    Parameters:
+        imported_modules (list): List of module names used in the code.
+        requirements_file_path (str): Path to the requirements.txt file.
+
+    Returns:
+        list: Modules that are imported but not listed in requirements.txt.
+    """
+    def normalize_module_name(name):
+        module_name = name.split('.')[0].lower()
+        # sometimes the module name in pipy is different than the real name
+        if module_name in _MODULE_MAP:
+            module_name = _MODULE_MAP[module_name]
+        return module_name
+
+    # Normalize imported module names
+    normalized_imports = [normalize_module_name(mod) for mod in imported_modules]
+
+    # filter out all built-ins
+    filtered_imports = [
+        module for module in normalized_imports
+        if _is_builtin_module(module) is False
+    ]
+
+    # Compare and find missing modules
+    missing_modules = [
+        module for module in filtered_imports
+        if module not in requirements_modules
+    ]
+
+    return missing_modules
+
+
+
+def parse_langflow_model(model) -> LangflowModelSpec:
+    """
+    Extracts component details and Langflow version from a Langflow JSON object.
+
+    Parameters:
+        model (dict): The Langflow JSON object.
+
+    Returns:
+        LangflowModelSpec: A LangflowModelSpec object containing the extracted version and component information.
+    """
+    version = model.get("last_tested_version", "Unknown")
+    components = []
+    data = model.get('data', {} )
+
+    # get the list of available modules
+    requirements_modules = LFX_DEPENDENCIES
+
+    for node in data.get("nodes", []):
+        node_data = node.get("data", {})
+        node_info = node_data.get("node", {})
+        template = node_info.get("template", {})
+        code = template.get("code")
+        credentials = {}
+
+        missing_imports = []
+        for field_name, field_info in template.items():
+            if isinstance(field_info, dict) and field_info.get("password", False) == True:
+                credentials[field_name] = _mask_api_key(field_info.get("value"))
+
+        if code and code.get("value") != None:
+            imports = _extract_imports(code.get("value"))
+            if len(imports) > 0:
+                missing_imports = _find_missing_requirements(imports, requirements_modules)
+
+        component_info = LangflowComponent(name=node_info.get("display_name", "Unknown"), id=node_data.get("id", "Unknown"), 
+                                           credentials=credentials, requirements=missing_imports)
+
+        components.append(component_info)
+
+    return LangflowModelSpec(version=version, components=components)
+

ibm_watsonx_orchestrate/langflow/lfx_deps.py

@@ -0,0 +1,84 @@
+LFX_DEPENDENCIES = [
+    "aiofile",
+    "aiofiles",
+    "annotated-types",
+    "anyio",
+    "asyncer",
+    "cachetools",
+    "caio",
+    "certifi",
+    "chardet",
+    "charset-normalizer",
+    "click",
+    "defusedxml",
+    "docstring_parser",
+    "emoji",
+    "fastapi",
+    "h11",
+    "h2",
+    "hpack",
+    "httpcore",
+    "httpx",
+    "hyperframe",
+    "idna",
+    "json_repair",
+    "jsonpatch",
+    "jsonpointer",
+    "langchain",
+    "langchain-core",
+    "langchain-text-splitters",
+    "langsmith",
+    "lfx-nightly",
+    "loguru",
+    "markdown-it-py",
+    "mdurl",
+    "nanoid",
+    "networkx",
+    "numpy",
+    "orjson",
+    "packaging",
+    "pandas",
+    "passlib",
+    "pillow",
+    "platformdirs",
+    "pydantic",
+    "pydantic-settings",
+    "pydantic_core",
+    "Pygments",
+    "python-dateutil",
+    "python-dotenv",
+    "pytz",
+    "PyYAML",
+    "requests",
+    "requests-toolbelt",
+    "rich",
+    "shellingham",
+    "six",
+    "sniffio",
+    "SQLAlchemy",
+    "starlette",
+    "structlog",
+    "tenacity",
+    "tomli",
+    "typer",
+    "typing-inspection",
+    "typing_extensions",
+    "tzdata",
+    "urllib3",
+    "uvicorn",
+    "validators",
+    "zstandard",
+    "langflow",
+    "langchain_openai",
+    "langchain_core",
+    "langchain_text_splitters",
+    "collections",
+    "typing",
+    "datetime",
+    "zoneinfo",
+    "or",
+    "re",
+    "os",
+    "copy",
+    "json"
+]

ibm_watsonx_orchestrate/utils/async_helpers.py

@@ -0,0 +1,31 @@
+import asyncio
+import threading
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, Coroutine, TypeVar, Optional
+
+T = TypeVar("T")
+
+
+def run_coroutine_sync(coroutine: Coroutine[Any, Any, T], timeout: Optional[float] = None) -> T:
+    def run_in_new_loop():
+        new_loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(new_loop)
+        try:
+            return new_loop.run_until_complete(coroutine)
+        finally:
+            new_loop.close()
+
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(coroutine)
+
+    if threading.current_thread() is threading.main_thread():
+        if not loop.is_running():
+            return loop.run_until_complete(coroutine)
+        else:
+            with ThreadPoolExecutor() as pool:
+                future = pool.submit(run_in_new_loop)
+                return future.result(timeout=timeout)
+    else:
+        return asyncio.run_coroutine_threadsafe(coroutine, loop).result()