waldiez 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

waldiez/__init__.py

@@ -2,14 +2,12 @@
 
 from ._version import __version__
 from .exporter import WaldiezExporter
-from .io_stream import WaldiezIOStream
 from .models import Waldiez
 from .runner import WaldiezRunner
 
 __all__ = [
     "Waldiez",
     "WaldiezExporter",
-    "WaldiezIOStream",
     "WaldiezRunner",
     "__version__",
 ]

waldiez/_version.py

@@ -1,3 +1,3 @@
 """Version information for Waldiez."""
 
-__version__ = "0.1.6"
+__version__ = "0.1.8"

waldiez/cli.py

@@ -6,14 +6,15 @@ import logging
 import os
 import sys
 from pathlib import Path
-from typing import Any, Dict, Optional
-
-from autogen import ChatResult  # type: ignore[import-untyped]
+from typing import TYPE_CHECKING, Any, Dict, Optional
 
 from . import Waldiez, __version__
 from .exporter import WaldiezExporter
 from .runner import WaldiezRunner
 
+if TYPE_CHECKING:
+    from autogen import ChatResult  # type: ignore[import-untyped]
+
 
 def get_parser() -> argparse.ArgumentParser:
     """Get the argument parser for the Waldiez package.
@@ -28,7 +29,7 @@ def get_parser() -> argparse.ArgumentParser:
         prog="waldiez",
     )
     parser.add_argument(
-        "waldiez",
+        "file",
         type=str,
         help="Path to the Waldiez flow (*.waldiez) file.",
     )
@@ -66,7 +67,7 @@ def get_parser() -> argparse.ArgumentParser:
     return parser
 
 
-def _log_result(result: ChatResult) -> None:
+def _log_result(result: "ChatResult") -> None:
     """Log the result of the Waldiez flow."""
     logger = logging.getLogger("waldiez::cli")
     logger.info("Chat History:\n")
@@ -94,9 +95,12 @@ def _run(data: Dict[str, Any], output_path: Optional[str]) -> None:
 def main() -> None:
     """Parse the command line arguments and run the Waldiez flow."""
     parser = get_parser()
+    if len(sys.argv) == 1:
+        parser.print_help()
+        sys.exit(0)
     args = parser.parse_args()
     logger = _get_logger()
-    waldiez_file: str = args.waldiez
+    waldiez_file: str = args.file
     if not os.path.exists(waldiez_file):
         logger.error("File not found: %s", waldiez_file)
         sys.exit(1)

waldiez/exporting/agents/rag_user/chroma_utils.py

@@ -109,8 +109,7 @@ def get_chroma_db_args(
         f"            embedding_function={embedding_function_arg},\n"
     )
     # The RAG example:
-    # https://microsoft.github.io/autogen/docs/\
-    #                                       notebooks/agentchat_groupchat_RAG
+    # https://ag2ai.github.io/ag2/docs/notebooks/agentchat_groupchat_RAG/
     # raises `InvalidCollectionException`: Collection groupchat does not exist.
     # https://github.com/chroma-core/chroma/issues/861
     # https://github.com/microsoft/autogen/issues/3551#issuecomment-2366930994

waldiez/exporting/chats/nested.py

@@ -14,7 +14,6 @@ from .helpers import escape_summary_args_quotes
 
 
 def get_nested_chat_trigger_agent_names(
-    all_chats: List[WaldiezChat],
     nested_chat: WaldiezAgentNestedChat,
     agent_names: Dict[str, str],
 ) -> str:
@@ -22,8 +21,6 @@ def get_nested_chat_trigger_agent_names(
 
     Parameters
     ----------
-    all_chats : List[WaldiezChat]
-        All the chats in the flow.
     nested_chat : WaldiezAgentNestedChat
         The nested chat.
     agent_names : Dict[str, str]
@@ -34,14 +31,7 @@ def get_nested_chat_trigger_agent_names(
     str
         The trigger agent names.
     """
-    trigger_agent_ids: List[str] = []
-    for message in nested_chat.triggered_by:
-        waldiez_chat = next(chat for chat in all_chats if chat.id == message.id)
-        if message.is_reply:
-            trigger_agent_ids.append(waldiez_chat.target)
-        else:
-            trigger_agent_ids.append(waldiez_chat.source)
-    agents = [agent_names[agent_id] for agent_id in trigger_agent_ids]
+    agents = [agent_names[agent_id] for agent_id in nested_chat.triggered_by]
     trigger_string = f'{[", ".join(agents)]}'
     return trigger_string.replace("'", '"')
 
@@ -228,7 +218,7 @@ def export_nested_chat(
     use_suffix = len(agent.data.nested_chats) > 1
     for index, entry in enumerate(agent.data.nested_chats):
         trigger_names = get_nested_chat_trigger_agent_names(
-            all_chats=all_chats, nested_chat=entry, agent_names=agent_names
+            nested_chat=entry, agent_names=agent_names
         )
         chat_queue, extra_methods = get_nested_chat_queue(
             nested_chat=entry,

waldiez/exporting/utils/logging_utils.py

@@ -14,6 +14,7 @@ get_sqlite_to_csv_call_string
 
 
 # Check issue:
+# Also check if in ag2 this still applies
 # https://github.com/microsoft/autogen/issues/2286
 # we cannot log new agents if they have code_execution enabled
 # we get `Path` is not JSON serializable (on code_executor)

waldiez/io/__init__.py

@@ -0,0 +1,142 @@
+"""Custom IOStream class to use with autogen.
+
+It is meant to be used when we want to use custom
+`print` and `input`. For example, when a websocket
+is used to trigger a UI element that requires user input.
+and sends back the user's input to the websocket. In the same
+way, we can use it to forward what is meant to be printed.
+"""
+
+import threading
+from typing import Any, Callable, Optional
+
+from autogen.io import IOStream  # type: ignore[import-untyped]
+
+
+class WaldiezIOStream(IOStream):
+    """Custom IOStream class to handle `print` and `input` functions."""
+
+    def __init__(
+        self,
+        input_timeout: float = 60.0,
+        print_function: Optional[Callable[..., None]] = None,
+        on_prompt_input: Optional[Callable[[str], None]] = None,
+    ) -> None:
+        """
+        Initialize the IOStream.
+
+        Parameters
+        ----------
+        input_timeout : float, optional
+            The input timeout in seconds, by default 60.0.
+        print_function : Optional[Callable[..., None]], optional
+            The function to handle print operations, by default None.
+        on_prompt_input : Optional[Callable[[str], None]], optional
+            The function to call for processing input prompts, by default None.
+
+        Notes
+        -----
+        - on_prompt_input: It does not return a string (like 'input' does).
+            Instead, it is meant to be used to forward the prompt somewhere else
+            (e.g., a websocket). When we get the input, we can call
+            `waldiez_io_stream.set_input(input_data)` with the input data.
+        """
+        self.input_timeout = input_timeout  # Timeout for input
+        self.print_function = print_function  # Custom print handler
+        self._on_prompt_input = on_prompt_input  # Custom input prompt handler
+        self.current_input: Optional[str] = None  # Store the current input
+        self._input_event = threading.Event()  # Event to signal input readiness
+        self.allow_input = True  # Flag to allow or block input setting
+
+    def print(
+        self,
+        *objects: Any,
+        sep: str = " ",
+        end: str = "\n",
+        flush: bool = False,
+    ) -> None:
+        """
+        Mock the `print` function.
+
+        Parameters
+        ----------
+        objects : Any
+            The objects to print.
+        sep : str, optional
+            The separator, by default " ".
+        end : str, optional
+            The ending string, by default a new line.
+        flush : bool, optional
+            Whether to flush the output, by default False.
+        """
+        print_function: Callable[..., None] = self.print_function or print
+        print_function(*objects, sep=sep, end=end, flush=flush)
+
+    def input(self, prompt: str = "", *, password: bool = False) -> str:
+        """
+        Mock the `input` function with optional timeout handling.
+
+        Parameters
+        ----------
+        prompt : str, optional
+            The prompt to show, by default "".
+        password : bool, optional
+            Whether to hide the input as password (not used), by default False.
+
+        Returns
+        -------
+        str
+            The user's input or '\n' if timeout occurs.
+        """
+        _prompt = prompt or "Your input:"
+        if _prompt in (">", "> "):  # pragma: no cover
+            _prompt = "Your input:"
+        if prompt:
+            if self._on_prompt_input:
+                self._on_prompt_input(_prompt)
+            self.print(_prompt, end="")
+
+        # Only reset if no input is currently set
+        # e.g. handle the case when we call set_input(..) before input(..)
+        already_set = self._input_event.is_set()
+        if not self._input_event.is_set():
+            self.current_input = None  # Reset previous input
+            self._input_event.clear()  # Clear the event before waiting
+
+        # Wait for input or timeout
+        if not self._input_event.wait(self.input_timeout):
+            # Timeout occurred, return what we have so far
+            to_return = (
+                self.current_input if self.current_input is not None else "\n"
+            )
+            self.current_input = None
+            self._input_event.clear()
+            # if we had already set the input, return it
+            return to_return if already_set else "\n"
+
+        # Input is ready, return it
+        to_return = (
+            self.current_input if self.current_input is not None else "\n"
+        )
+        self.current_input = None
+        self._input_event.clear()  # Clear the event after waiting
+        return to_return
+
+    def set_input(self, value: str) -> None:
+        """
+        Set the input value and signal that input is ready.
+
+        Parameters
+        ----------
+        value : str
+            The value to set as input.
+        """
+        if self.allow_input:  # Respect the allow_input flag
+            self.current_input = value
+            self._input_event.set()  # Signal that input is ready
+
+    def reset_state(self) -> None:
+        """Reset the IOStream state for testing."""
+        self.current_input = None
+        self._input_event.clear()
+        self.allow_input = True  # Re-enable input setting

waldiez/models/agents/agent/nested_chat.py

@@ -40,22 +40,18 @@ class WaldiezAgentNestedChat(WaldiezBase):
 
     Attributes
     ----------
-    triggered_by : List[WaldiezAgentNestedChatMessage]
-        A list of chats (id and is_reply) to determine
-        the triggering of the nested chat.
+    triggered_by : List[str]
+        A list of agent ids that trigger the nested chat.
     messages : List[WaldiezAgentNestedChatMessage]
         The list of messages (chat ids and 'is_reply'z)
         to include the in the nested chat registration.
     """
 
     triggered_by: Annotated[
-        List[WaldiezAgentNestedChatMessage],
+        List[str],
         Field(
             title="Triggered By",
-            description=(
-                "A list of chats (id and is_reply) to determine"
-                "the triggering of the nested chat."
-            ),
+            description=("A list of agent ids that trigger the nested chat."),
             alias="triggeredBy",
             default_factory=list,
         ),

waldiez/models/waldiez.py

@@ -7,12 +7,10 @@ definitions and their optional additional skills to be used.
 
 import json
 from dataclasses import dataclass
+from functools import cache
 from pathlib import Path
 from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
 
-#  let's be strict with autogen version
-from autogen.version import __version__ as autogen_version  # type: ignore
-
 from .agents import WaldiezAgent
 from .chat import WaldiezChat
 from .flow import WaldiezFlow
@@ -203,21 +201,20 @@ class Waldiez:
     @property
     def requirements(self) -> List[str]:
         """Get the flow requirements."""
+        autogen_version = _get_autogen_version()
         requirements_list = filter(
             lambda requirement: not (
                 requirement.startswith("pyautogen")
-                or requirement.startswith("autogen-agentchat")
+                or requirement.startswith("ag2")
             ),
             self.flow.requirements,
         )
         requirements = set(requirements_list)
         if self.has_rag_agents:
-            requirements.add(
-                f"autogen-agentchat[retrievechat]=={autogen_version}"
-            )
+            requirements.add(f"ag2[retrievechat]=={autogen_version}")
         else:
-            requirements.add(f"autogen-agentchat=={autogen_version}")
-        # ref: https://github.com/microsoft/autogen/blob/main/setup.py
+            requirements.add(f"ag2=={autogen_version}")
+        # ref: https://github.com/ag2ai/ag2/blob/main/setup.py
         models_with_additional_requirements = [
             "together",
             "gemini",
@@ -230,8 +227,7 @@ class Waldiez:
         for model in self.models:
             if model.data.api_type in models_with_additional_requirements:
                 requirements.add(
-                    f"autogen-agentchat[{model.data.api_type}]=="
-                    f"{autogen_version}"
+                    f"ag2[{model.data.api_type}]==" f"{autogen_version}"
                 )
         return list(requirements)
 
@@ -299,3 +295,14 @@ def _get_flow(
     if "requirements" not in data:
         data["requirements"] = []
     return data
+
+
+@cache
+def _get_autogen_version() -> str:
+    """Get the autogen version."""
+    # pylint: disable=import-outside-toplevel
+    try:
+        from autogen.version import __version__ as atg_version  # type: ignore
+    except ImportError:  # pragma: no cover
+        atg_version = "0.0.0"
+    return atg_version

waldiez/runner.py

@@ -19,14 +19,25 @@ from contextlib import contextmanager
 from contextvars import ContextVar
 from pathlib import Path
 from types import TracebackType
-from typing import Callable, Dict, Iterator, List, Optional, Type, Union
-
-from autogen import ChatResult  # type: ignore
+from typing import (
+    TYPE_CHECKING,
+    Callable,
+    Dict,
+    Iterator,
+    List,
+    Optional,
+    Type,
+    Union,
+)
 
 from .exporter import WaldiezExporter
-from .io_stream import WaldiezIOStream
 from .models.waldiez import Waldiez
 
+if TYPE_CHECKING:
+    from autogen import ChatResult  # type: ignore
+
+    from .io import WaldiezIOStream
+
 
 @contextmanager
 def _chdir(to: Union[str, Path]) -> Iterator[None]:
@@ -60,7 +71,7 @@ class WaldiezRunner:
         self._waldiez = waldiez
         self._running = False
         self._file_path = file_path
-        self._stream: ContextVar[Optional[WaldiezIOStream]] = ContextVar(
+        self._stream: ContextVar[Optional["WaldiezIOStream"]] = ContextVar(
             "waldiez_stream", default=None
         )
         self._exporter = WaldiezExporter(waldiez)
@@ -225,9 +236,9 @@ class WaldiezRunner:
 
     def _do_run(
         self, output_path: Optional[Union[str, Path]]
-    ) -> Union[ChatResult, List[ChatResult]]:
+    ) -> Union["ChatResult", List["ChatResult"]]:
         """Run the Waldiez workflow."""
-        results: Union[ChatResult, List[ChatResult]] = []
+        results: Union["ChatResult", List["ChatResult"]] = []
         temp_dir = Path(tempfile.mkdtemp())
         file_name = "flow.py" if not output_path else Path(output_path).name
         if file_name.endswith((".json", ".waldiez")):
@@ -259,19 +270,22 @@ class WaldiezRunner:
     def _run(
         self,
         output_path: Optional[Union[str, Path]],
-    ) -> Union[ChatResult, List[ChatResult]]:
+    ) -> Union["ChatResult", List["ChatResult"]]:
         self._install_requirements()
         token = self._stream.get()
         if token is not None:
+            # pylint: disable=import-outside-toplevel
+            from .io import WaldiezIOStream
+
             with WaldiezIOStream.set_default(token):
                 return self._do_run(output_path)
         return self._do_run(output_path)
 
     def run(
         self,
-        stream: Optional[WaldiezIOStream] = None,
+        stream: Optional["WaldiezIOStream"] = None,
         output_path: Optional[Union[str, Path]] = None,
-    ) -> Union[ChatResult, List[ChatResult]]:
+    ) -> Union["ChatResult", List["ChatResult"]]:
         """Run the Waldiez workflow.
 
         Parameters

waldiez-0.1.8.dist-info/METADATA

@@ -0,0 +1,241 @@
+Metadata-Version: 2.3
+Name: waldiez
+Version: 0.1.8
+Summary: waldiez
+Project-URL: homepage, https://waldiez.github.io/waldiez/
+Project-URL: repository, https://github.com/waldiez/waldiez.git
+Author-email: Panagiotis Kasnesis <pkasnesis@thingenious.io>, Lazaros Toumanidis <laztoum@protonmail.com>
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: <3.13,>=3.10
+Requires-Dist: ag2==0.3.2
+Requires-Dist: jupytext
+Provides-Extra: ag2-extras
+Requires-Dist: ag2[anthropic]==0.3.2; extra == 'ag2-extras'
+Requires-Dist: ag2[bedrock]==0.3.2; extra == 'ag2-extras'
+Requires-Dist: ag2[gemini]==0.3.2; extra == 'ag2-extras'
+Requires-Dist: ag2[groq]==0.3.2; extra == 'ag2-extras'
+Requires-Dist: ag2[mistral]==0.3.2; extra == 'ag2-extras'
+Requires-Dist: ag2[retrievechat-mongodb]==0.3.2; extra == 'ag2-extras'
+Requires-Dist: ag2[retrievechat-pgvector]==0.3.2; extra == 'ag2-extras'
+Requires-Dist: ag2[retrievechat-qdrant]==0.3.2; extra == 'ag2-extras'
+Requires-Dist: ag2[retrievechat]==0.3.2; extra == 'ag2-extras'
+Requires-Dist: ag2[together]==0.3.2; extra == 'ag2-extras'
+Requires-Dist: ag2[websurfer]==0.3.2; extra == 'ag2-extras'
+Requires-Dist: chromadb==0.5.3; extra == 'ag2-extras'
+Requires-Dist: fastembed==0.4.2; extra == 'ag2-extras'
+Requires-Dist: pgvector>=0.2.5; extra == 'ag2-extras'
+Requires-Dist: psycopg[binary]>=3.1.18; extra == 'ag2-extras'
+Requires-Dist: pymongo==4.10.1; extra == 'ag2-extras'
+Requires-Dist: qdrant-client==1.12.1; extra == 'ag2-extras'
+Provides-Extra: dev
+Requires-Dist: autoflake==2.3.1; extra == 'dev'
+Requires-Dist: bandit==1.7.10; extra == 'dev'
+Requires-Dist: black[jupyter]==24.10.0; extra == 'dev'
+Requires-Dist: flake8==7.1.1; extra == 'dev'
+Requires-Dist: isort==5.13.2; extra == 'dev'
+Requires-Dist: mypy==1.13.0; extra == 'dev'
+Requires-Dist: pre-commit==4.0.1; extra == 'dev'
+Requires-Dist: pydocstyle==6.3.0; extra == 'dev'
+Requires-Dist: pylint==3.3.1; extra == 'dev'
+Requires-Dist: python-dotenv==1.0.1; extra == 'dev'
+Requires-Dist: ruff==0.7.4; extra == 'dev'
+Requires-Dist: types-pyyaml==6.0.12; extra == 'dev'
+Requires-Dist: yamllint==1.35.1; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mdx-include==1.4.2; extra == 'docs'
+Requires-Dist: mdx-truly-sane-lists==1.3; extra == 'docs'
+Requires-Dist: mkdocs-jupyter==0.25.1; extra == 'docs'
+Requires-Dist: mkdocs-macros-plugin==1.3.7; extra == 'docs'
+Requires-Dist: mkdocs-material==9.5.44; extra == 'docs'
+Requires-Dist: mkdocs-minify-html-plugin==0.2.3; extra == 'docs'
+Requires-Dist: mkdocs==1.6.1; extra == 'docs'
+Requires-Dist: mkdocstrings-python==1.12.2; extra == 'docs'
+Requires-Dist: mkdocstrings[crystal,python]==0.27.0; extra == 'docs'
+Provides-Extra: test
+Requires-Dist: pytest-cov==6.0.0; extra == 'test'
+Requires-Dist: pytest-html==4.1.1; extra == 'test'
+Requires-Dist: pytest-sugar==1.0.0; extra == 'test'
+Requires-Dist: pytest-timeout==2.3.1; extra == 'test'
+Requires-Dist: pytest-xdist==3.6.1; extra == 'test'
+Requires-Dist: pytest==8.3.3; extra == 'test'
+Description-Content-Type: text/markdown
+
+# Waldiez
+
+![CI Build](https://github.com/waldiez/waldiez/actions/workflows/main.yaml/badge.svg) [![Coverage Status](https://coveralls.io/repos/github/waldiez/waldiez/badge.svg)](https://coveralls.io/github/waldiez/waldiez) [![PyPI version](https://badge.fury.io/waldiez/waldiez.svg)](https://badge.fury.io/py/waldiez)
+
+Translate a Waldiez flow:
+
+![Flow](https://raw.githubusercontent.com/waldiez/waldiez/refs/heads/main/docs/static/images/overview.webp)
+
+To a python script or a jupyter notebook with the corresponding [ag2](https://github.com/ag2ai/ag2/) agents and chats.
+
+## Features
+
+- Export .waldiez flows to .py or .ipynb
+- Run a .waldiez flow
+- Include a `logs` folder with the logs of the flow in csv format
+- Provide a custom [IOSStream](https://ag2ai.github.io/ag2/docs/reference/io/base#iostream) to handle input and output.
+
+## Installation
+
+On PyPI:
+
+```bash
+python -m pip install waldiez
+```
+
+From the repository:
+
+```bash
+python -m pip install git+https://github.com/waldiez/waldiez.git
+```
+
+## Usage
+
+### CLI
+
+```bash
+# Export a Waldiez flow to a python script or a jupyter notebook
+waldiez --export /path/to/a/flow.waldiez --output /path/to/an/output/flow[.py|.ipynb]
+# Export and run the script, optionally force generation if the output file already exists
+waldiez /path/to/a/flow.waldiez --output /path/to/an/output/flow[.py] [--force]
+```
+
+### Using docker/podman
+
+```shell
+CONTAINER_COMMAND=docker # or podman
+# pull the image
+$CONTAINER_COMMAND pull waldiez/waldiez
+# Export a Waldiez flow to a python script or a jupyter notebook
+$CONTAINER_COMMAND run \
+  --rm \
+  -v /path/to/a/flow.waldiez:/flow.waldiez \
+  -v /path/to/an/output:/output \
+  waldiez/waldiez --export /flow.waldiez --output /output/flow[.py|.ipynb]
+
+# with selinux and/or podman, you might get permission (or file not found) errors, so you can try:
+$CONTAINER_COMMAND run \
+  --rm \
+  -v /path/to/a/flow.waldiez:/flow.waldiez \
+  -v /path/to/an/output:/output \
+  --userns=keep-id \
+  --security-opt label=disable \
+  waldiez/waldiez --export /flow.waldiez --output /output/flow[.py|.ipynb]
+```
+
+```shell
+# Export and run the script
+$CONTAINER_COMMAND run --rm -v /path/to/a/flow.waldiez:/flow.waldiez -v /path/to/an/output:/output waldiez/waldiez /flow.waldiez --output /output/output[.py]
+```
+
+### As a library
+
+#### Export a flow
+
+```python
+# Export a Waldiez flow to a python script or a jupyter notebook
+from waldiez import WaldiezExporter
+flow_path = "/path/to/a/flow.waldiez"
+output_path = "/path/to/an/output.py"  # or .ipynb
+exporter = WaldiezExporter.load(flow_path)
+exporter.export(output_path)
+```
+  
+#### Run a flow
+
+```python
+# Run a flow
+from waldiez import WaldiezRunner
+flow_path = "/path/to/a/flow.waldiez"
+output_path = "/path/to/an/output.py"
+runner = WaldiezRunner.load(flow_path)
+runner.run(output_path=output_path)
+```
+
+#### Run a flow with a custom IOStream
+
+```python
+# Run the flow with a custom IOStream
+# In case the standard 'input' and 'print' functions cannot be used
+import time
+import threading
+
+from typing import Any
+
+from waldiez import WaldiezRunner
+from waldiez.io import WaldiezIOStream
+
+flow_path = "/path/to/a/flow.waldiez"
+output_path = "/path/to/an/output.py"
+
+
+def custom_print_function(*args: Any, sep: str = " ", **kwargs: Any) -> None:
+    """Custom print function."""
+    print(*args, sep=sep, **kwargs)
+
+
+# Custom input handler
+class InputProcessorWrapper:
+    """Wrapper input processor.
+    
+    To manage the interaction between the custom input processor and IOStream.
+    """
+
+    def __init__(self):
+        self.stream = None  # Placeholder for the WaldiezIOStream instance
+        self.lock = threading.Lock()  # Ensure thread-safe operations
+
+    def custom_input_processor(self, prompt: str) -> None:
+        """Simulate external input and send it back to the IOStream."""
+        def external_input_simulation():
+            with self.lock:  # Ensure thread-safe access
+                time.sleep(2)  # Simulate delay for network input
+                if self.stream:
+                    self.stream.set_input("Simulated external input")
+                else:
+                    raise RuntimeError("Stream reference not set!")
+
+        threading.Thread(target=external_input_simulation, daemon=True).start()
+
+    def set_stream(self, stream: "WaldiezIOStream"):
+        """Set the WaldiezIOStream instance."""
+        with self.lock:  # Ensure thread-safe setting of the stream
+            self.stream = stream
+
+processor_wrapper = InputProcessorWrapper()
+
+stream = WaldiezIOStream(
+    input_timeout=30,
+    print_function=
+    on_prompt_input=processor_wrapper.custom_input_processor,
+)
+
+# Link the processor wrapper to the WaldiezIOStream instance
+processor_wrapper.set_stream(custom_stream)
+
+with WaldiezIOStream.set_default(io_stream):
+    runner = WaldiezRunner.load(flow_path)
+    runner.run(stream=io_stream, output_path=output_path)
+
+```
+
+### Tools
+
+- [ag2 (formerly AutoGen)](https://github.com/ag2ai/ag2)
+- [juptytext](https://github.com/mwouts/jupytext)
+- [pydantic](https://github.com/pydantic/pydantic)
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](https://github.com/waldiez/waldiez/blob/main/LICENSE) file for details.