model-compose 0.3.0__tar.gz → 0.3.1__tar.gz

{model_compose-0.3.0/src/model_compose.egg-info → model_compose-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.3.0
+Version: 0.3.1
 Summary: model-compose: Declarative AI Model and Workflow Orchestrator
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT
@@ -33,22 +33,21 @@ Dynamic: license-file
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](http://makeapullrequest.com)
 
-![Screenshots](docs/images/screenshots.png)
-
 **model-compose** is an open-source, declarative workflow orchestrator inspired by `docker-compose`. It lets you define and run AI model pipelines using simple YAML files — no custom code required. Effortlessly connect external AI services or run local AI models, all within powerful, composable workflows.
 
 ---
 
 ## ✨ Features
 
-- **Declarative by Design:** Define complete AI workflows using simple YAML files—no complex scripting required.
-- **Compose Anything:** Combine multiple AI models, APIs, and tools into a single, unified pipeline.
-- **Built for Orchestration:**  Orchestrate multi-step model interactions with ease. Transform individual API calls into maintainable, end-to-end systems.
-- **Multi-Workflow Support:** Define multiple named workflows in one project. Run them by name or set a default for quick execution.
-- **Modular Components:** Break down logic into reusable components and jobs. Easily plug, swap, and extend them across workflows.
-- **Flexible I/O Routing:** Connect inputs and outputs between jobs using clean, scoped variables—no glue code needed.
-- **Run Locally, Serve Remotely:** Execute workflows from the CLI or expose them as HTTP or MCP endpoints with an optional Web UI.
-- **Environment Variable Support:** Easily inject secrets and configuration via `.env` files or environment variables to keep your YAML clean and secure.
+- **Declarative by Design**: Define complete AI workflows using simple YAML files—no complex scripting required.
+- **Compose Anything**: Combine multiple AI models, APIs, and tools into a single, unified pipeline.
+- **Built for Orchestration**:  Orchestrate multi-step model interactions with ease. Transform individual API calls into maintainable, end-to-end systems.
+- **Multi-Workflow Support**: Define multiple named workflows in one project. Run them by name or set a default for quick execution.
+- **Modular Components**: Break down logic into reusable components and jobs. Easily plug, swap, and extend them across workflows.
+- **Flexible I/O Routing**: Connect inputs and outputs between jobs using clean, scoped variables—no glue code needed.
+- **Run Locally, Serve Remotely**: Execute workflows from the CLI or expose them as HTTP or MCP endpoints with an optional Web UI.
+- **Docker Deployment**: Build and deploy your workflow controller as a Docker container for consistent and portable execution environments.
+- **Environment Variable Support**: Easily inject secrets and configuration via `.env` files or environment variables to keep your YAML clean and secure.
 
 ---
 
@@ -85,8 +84,8 @@ By default, this command will:
 
 - Look for a file named `model-compose.yml` in the **current working directory**
 - Automatically load environment variables from a `.env` file in the **same directory**, if it exists
-- Start the workflow controller (default: http://localhost:8080)
-- Optionally launch the Web UI (default: http://localhost:8081, if configured)
+- Start the workflow controller (default: `http://localhost:8080`)
+- Optionally launch the Web UI (default: `http://localhost:8081`, if configured)
 
 To run in the background (detached mode):
 
@@ -114,7 +113,7 @@ model-compose up --env OPENAI_API_KEY=... --env ELEVENLABS_API_KEY=...
 
 > 💡 Once the controller is running, you can trigger workflows via the REST API or, if using MCP, via JSON-RPC. You can also access them through the Web UI.
 
-#### 📉 Shutting Down the Server (`down`)
+#### 🔽 Shutting Down the Server (`down`)
 To gracefully stop and remove the workflow controller and all associated services:
 
 ```
@@ -140,19 +139,18 @@ This is useful for testing, automation, or scripting.
 | `model-compose stop` | Temporarily pause the currently running controller |
 
 ---
-
 ## 🧾 `model-compose.yml`
 
 The `model-compose.yml` file is the central configuration file that defines how your workflows are composed and executed.
 
 It includes:
 
-- **Controller** – configures the HTTP/MCP server, API endpoints, and optional Web UI
-- **Components** – reusable definitions for calling APIs, running local AI models, or executing commands
-- **Workflows** – named sets of jobs that define the flow of data
-- **Jobs** – steps that execute specific components, with support for inputs, outputs, and dependencies
-- **Listeners** – optional callback listeners that handle asynchronous responses from external services
-- **Gateways** - optional tunneling services that expose your local controller to the public internet
+- **Controller**: configures the HTTP/MCP server, API endpoints, and optional Web UI
+- **Components**: reusable definitions for calling APIs, running local AI models, or executing commands
+- **Workflows**: named sets of jobs that define the flow of data
+- **Jobs**: steps that execute specific components, with support for inputs, outputs, and dependencies
+- **Listeners**: optional callback listeners that handle asynchronous responses from external services
+- **Gateways**: optional tunneling services that expose your local controller to the public internet
 
 By default, `model-compose` automatically looks for a file named `model-compose.yml` in the current working directory when running commands like `up` or `run`.
 
@@ -162,6 +160,7 @@ By default, `model-compose` automatically looks for a file named `model-compose.
 controller:
   type: http-server
   port: 8080
+  base_path: /api
   webui:
     port: 8081
 
@@ -214,7 +213,7 @@ listener:
       result: ${item.choices[0].message.content}
 ```
 
-This listener sets up an HTTP callback endpoint at http://localhost:8090/callbacks/chat-ai to handle asynchronous responses from an external service that behaves like ChatGPT but supports delayed or push-based results. This is useful when integrating with services that notify results via webhook-style callbacks.
+This listener sets up an HTTP callback endpoint at `http://localhost:8090/callbacks/chat-ai` to handle asynchronous responses from an external service that behaves like ChatGPT but supports delayed or push-based results. This is useful when integrating with services that notify results via webhook-style callbacks.
 
 #### 🌐 Gateway Example
 
@@ -225,10 +224,146 @@ gateway:
   port: 8090
 ```
 
-This gateway configuration exposes the local listener defined above to the public internet using an HTTP tunnel powered by ngrok. It forwards incoming traffic from a secure, public URL (e.g., https://abc123.ngrok.io) directly to your local callback endpoint at http://localhost:8090. This is essential when integrating with third-party services that need to push data back to your workflow via webhooks or asynchronous callbacks.
+This gateway configuration exposes the local listener defined above to the public internet using an HTTP tunnel powered by ngrok. It forwards incoming traffic from a secure, public URL (e.g., `https://abc123.ngrok.io`) directly to your local callback endpoint at `http://localhost:8090`. This is essential when integrating with third-party services that need to push data back to your workflow via webhooks or asynchronous callbacks.
 
 > 📁 For more example model-compose.yml configurations, check the [examples directory](examples) in the source code.
 
+---
+## 🖥 Web UI
+**model-compose** optionally provides a lightweight **Web UI** to help you visually trigger workflows, inspect inputs and outputs, and monitor execution logs.
+
+![Screenshots](docs/images/webui.png)
+
+#### ✅ Enabling the Web UI
+To enable the Web UI, simply add the `webui` section under your `controller` in the `model-compose.yml` file:
+```
+controller:
+  type: http-server
+  port: 8080
+  webui:
+    port: 8081
+```
+
+Once enabled, the Web UI will be available at:
+```
+http://localhost:8081
+```
+> By default, the Web UI is powered by [Gradio](https://www.gradio.app), but support for other drivers may be added in the future.
+
+---
+## 🛰 MCP Server Support
+You can also expose your workflows via the **Model Context Protocol (MCP)** server to enable remote execution, automation, or system integration using a lightweight JSON-RPC interface.
+
+#### ✅ Minimal MCP Server Example
+
+```
+controller:
+  type: mcp-server
+  port: 8080
+  base_path: /mcp
+
+components:
+  chatgpt:
+    type: http-client
+    base_url: https://api.openai.com/v1
+    path: /chat/completions
+    method: POST
+    headers:
+      Authorization: Bearer ${env.OPENAI_API_KEY}
+      Content-Type: application/json
+    body:
+      model: gpt-4o
+      messages:
+        - role: user
+          content: "Write an inspiring quote."
+    output:
+      quote: ${response.choices[0].message.content}
+
+workflows:
+  generate-quote:
+    default: true
+    jobs:
+      get-quote:
+        component: chatgpt
+```
+This configuration launches the controller as an **MCP server**, which listens on port 8080 and exposes your workflows over a **JSON-RPC API**.
+
+Once running, you can invoke workflows remotely using a standard MCP request:
+
+```
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "callTool",
+  "params": {
+    "name": "generate-quote",
+    "arguments": {}
+  }
+}
+```
+
+You can send this request via any HTTP client to:
+```
+POST http://localhost:8080/mcp
+```
+
+---
+## 🐳 Docker Runtime Support
+You can run the workflow controller inside a Docker container by specifying the runtime option in your `model-compose.yml` file.
+
+#### ✅ Minimal Docker Runtime Example
+
+```
+controller:
+  type: http-server
+  port: 8080
+  runtime: docker
+```
+
+This configuration will launch the controller inside a lightweight Docker container automatically managed by **model-compose**. It uses default settings such as container name, image, and volume mappings.
+
+#### ⚙️ Advanced Docker Runtime Options
+You can fully configure the Docker runtime by using an object under the `runtime` key:
+
+```
+controller:
+  type: http-server
+  port: 8080
+  runtime:
+    type: docker
+    image: 192.168.0.23/custom-image:latest
+    container_name: my-controller
+    volumes:
+      - ./models:/models
+      - ./cache:/cache
+    ports:
+      - "5000:8080"
+      - "5001:8081"
+    env:
+      MODEL_STORAGE_PATH: /models
+    command: [ "python", "-m", "mindor.cli.compose", "up" ]
+    ...
+```
+
+This gives you full control over:
+
+- **container_name**: Custom name for the container
+- **image**: Docker image to use
+- **volumes**: Bind mounts for sharing files between host and container
+- **ports**: Port mappings for host ↔ container communication
+- **env**: Environment variables to inject
+- **command**: Override the default entrypoint
+- *and many more*
+
+All of these are optional, allowing you to start simple and customize only what you need.
+
+#### 🐳 Benefits of Docker Runtime
+
+- Run your controller in a clean, isolated environment
+- Avoid dependency conflicts with your host Python setup
+- Easily deploy your project to remote servers or CI pipelines
+- Share reproducible workflows with others
+
 ---
 ## 🏗 Architecture
 

{model_compose-0.3.0 → model_compose-0.3.1}/README.md

@@ -4,22 +4,21 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](http://makeapullrequest.com)
 
-![Screenshots](docs/images/screenshots.png)
-
 **model-compose** is an open-source, declarative workflow orchestrator inspired by `docker-compose`. It lets you define and run AI model pipelines using simple YAML files — no custom code required. Effortlessly connect external AI services or run local AI models, all within powerful, composable workflows.
 
 ---
 
 ## ✨ Features
 
-- **Declarative by Design:** Define complete AI workflows using simple YAML files—no complex scripting required.
-- **Compose Anything:** Combine multiple AI models, APIs, and tools into a single, unified pipeline.
-- **Built for Orchestration:**  Orchestrate multi-step model interactions with ease. Transform individual API calls into maintainable, end-to-end systems.
-- **Multi-Workflow Support:** Define multiple named workflows in one project. Run them by name or set a default for quick execution.
-- **Modular Components:** Break down logic into reusable components and jobs. Easily plug, swap, and extend them across workflows.
-- **Flexible I/O Routing:** Connect inputs and outputs between jobs using clean, scoped variables—no glue code needed.
-- **Run Locally, Serve Remotely:** Execute workflows from the CLI or expose them as HTTP or MCP endpoints with an optional Web UI.
-- **Environment Variable Support:** Easily inject secrets and configuration via `.env` files or environment variables to keep your YAML clean and secure.
+- **Declarative by Design**: Define complete AI workflows using simple YAML files—no complex scripting required.
+- **Compose Anything**: Combine multiple AI models, APIs, and tools into a single, unified pipeline.
+- **Built for Orchestration**:  Orchestrate multi-step model interactions with ease. Transform individual API calls into maintainable, end-to-end systems.
+- **Multi-Workflow Support**: Define multiple named workflows in one project. Run them by name or set a default for quick execution.
+- **Modular Components**: Break down logic into reusable components and jobs. Easily plug, swap, and extend them across workflows.
+- **Flexible I/O Routing**: Connect inputs and outputs between jobs using clean, scoped variables—no glue code needed.
+- **Run Locally, Serve Remotely**: Execute workflows from the CLI or expose them as HTTP or MCP endpoints with an optional Web UI.
+- **Docker Deployment**: Build and deploy your workflow controller as a Docker container for consistent and portable execution environments.
+- **Environment Variable Support**: Easily inject secrets and configuration via `.env` files or environment variables to keep your YAML clean and secure.
 
 ---
 
@@ -56,8 +55,8 @@ By default, this command will:
 
 - Look for a file named `model-compose.yml` in the **current working directory**
 - Automatically load environment variables from a `.env` file in the **same directory**, if it exists
-- Start the workflow controller (default: http://localhost:8080)
-- Optionally launch the Web UI (default: http://localhost:8081, if configured)
+- Start the workflow controller (default: `http://localhost:8080`)
+- Optionally launch the Web UI (default: `http://localhost:8081`, if configured)
 
 To run in the background (detached mode):
 
@@ -85,7 +84,7 @@ model-compose up --env OPENAI_API_KEY=... --env ELEVENLABS_API_KEY=...
 
 > 💡 Once the controller is running, you can trigger workflows via the REST API or, if using MCP, via JSON-RPC. You can also access them through the Web UI.
 
-#### 📉 Shutting Down the Server (`down`)
+#### 🔽 Shutting Down the Server (`down`)
 To gracefully stop and remove the workflow controller and all associated services:
 
 ```
@@ -111,19 +110,18 @@ This is useful for testing, automation, or scripting.
 | `model-compose stop` | Temporarily pause the currently running controller |
 
 ---
-
 ## 🧾 `model-compose.yml`
 
 The `model-compose.yml` file is the central configuration file that defines how your workflows are composed and executed.
 
 It includes:
 
-- **Controller** – configures the HTTP/MCP server, API endpoints, and optional Web UI
-- **Components** – reusable definitions for calling APIs, running local AI models, or executing commands
-- **Workflows** – named sets of jobs that define the flow of data
-- **Jobs** – steps that execute specific components, with support for inputs, outputs, and dependencies
-- **Listeners** – optional callback listeners that handle asynchronous responses from external services
-- **Gateways** - optional tunneling services that expose your local controller to the public internet
+- **Controller**: configures the HTTP/MCP server, API endpoints, and optional Web UI
+- **Components**: reusable definitions for calling APIs, running local AI models, or executing commands
+- **Workflows**: named sets of jobs that define the flow of data
+- **Jobs**: steps that execute specific components, with support for inputs, outputs, and dependencies
+- **Listeners**: optional callback listeners that handle asynchronous responses from external services
+- **Gateways**: optional tunneling services that expose your local controller to the public internet
 
 By default, `model-compose` automatically looks for a file named `model-compose.yml` in the current working directory when running commands like `up` or `run`.
 
@@ -133,6 +131,7 @@ By default, `model-compose` automatically looks for a file named `model-compose.
 controller:
   type: http-server
   port: 8080
+  base_path: /api
   webui:
     port: 8081
 
@@ -185,7 +184,7 @@ listener:
       result: ${item.choices[0].message.content}
 ```
 
-This listener sets up an HTTP callback endpoint at http://localhost:8090/callbacks/chat-ai to handle asynchronous responses from an external service that behaves like ChatGPT but supports delayed or push-based results. This is useful when integrating with services that notify results via webhook-style callbacks.
+This listener sets up an HTTP callback endpoint at `http://localhost:8090/callbacks/chat-ai` to handle asynchronous responses from an external service that behaves like ChatGPT but supports delayed or push-based results. This is useful when integrating with services that notify results via webhook-style callbacks.
 
 #### 🌐 Gateway Example
 
@@ -196,10 +195,146 @@ gateway:
   port: 8090
 ```
 
-This gateway configuration exposes the local listener defined above to the public internet using an HTTP tunnel powered by ngrok. It forwards incoming traffic from a secure, public URL (e.g., https://abc123.ngrok.io) directly to your local callback endpoint at http://localhost:8090. This is essential when integrating with third-party services that need to push data back to your workflow via webhooks or asynchronous callbacks.
+This gateway configuration exposes the local listener defined above to the public internet using an HTTP tunnel powered by ngrok. It forwards incoming traffic from a secure, public URL (e.g., `https://abc123.ngrok.io`) directly to your local callback endpoint at `http://localhost:8090`. This is essential when integrating with third-party services that need to push data back to your workflow via webhooks or asynchronous callbacks.
 
 > 📁 For more example model-compose.yml configurations, check the [examples directory](examples) in the source code.
 
+---
+## 🖥 Web UI
+**model-compose** optionally provides a lightweight **Web UI** to help you visually trigger workflows, inspect inputs and outputs, and monitor execution logs.
+
+![Screenshots](docs/images/webui.png)
+
+#### ✅ Enabling the Web UI
+To enable the Web UI, simply add the `webui` section under your `controller` in the `model-compose.yml` file:
+```
+controller:
+  type: http-server
+  port: 8080
+  webui:
+    port: 8081
+```
+
+Once enabled, the Web UI will be available at:
+```
+http://localhost:8081
+```
+> By default, the Web UI is powered by [Gradio](https://www.gradio.app), but support for other drivers may be added in the future.
+
+---
+## 🛰 MCP Server Support
+You can also expose your workflows via the **Model Context Protocol (MCP)** server to enable remote execution, automation, or system integration using a lightweight JSON-RPC interface.
+
+#### ✅ Minimal MCP Server Example
+
+```
+controller:
+  type: mcp-server
+  port: 8080
+  base_path: /mcp
+
+components:
+  chatgpt:
+    type: http-client
+    base_url: https://api.openai.com/v1
+    path: /chat/completions
+    method: POST
+    headers:
+      Authorization: Bearer ${env.OPENAI_API_KEY}
+      Content-Type: application/json
+    body:
+      model: gpt-4o
+      messages:
+        - role: user
+          content: "Write an inspiring quote."
+    output:
+      quote: ${response.choices[0].message.content}
+
+workflows:
+  generate-quote:
+    default: true
+    jobs:
+      get-quote:
+        component: chatgpt
+```
+This configuration launches the controller as an **MCP server**, which listens on port 8080 and exposes your workflows over a **JSON-RPC API**.
+
+Once running, you can invoke workflows remotely using a standard MCP request:
+
+```
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "callTool",
+  "params": {
+    "name": "generate-quote",
+    "arguments": {}
+  }
+}
+```
+
+You can send this request via any HTTP client to:
+```
+POST http://localhost:8080/mcp
+```
+
+---
+## 🐳 Docker Runtime Support
+You can run the workflow controller inside a Docker container by specifying the runtime option in your `model-compose.yml` file.
+
+#### ✅ Minimal Docker Runtime Example
+
+```
+controller:
+  type: http-server
+  port: 8080
+  runtime: docker
+```
+
+This configuration will launch the controller inside a lightweight Docker container automatically managed by **model-compose**. It uses default settings such as container name, image, and volume mappings.
+
+#### ⚙️ Advanced Docker Runtime Options
+You can fully configure the Docker runtime by using an object under the `runtime` key:
+
+```
+controller:
+  type: http-server
+  port: 8080
+  runtime:
+    type: docker
+    image: 192.168.0.23/custom-image:latest
+    container_name: my-controller
+    volumes:
+      - ./models:/models
+      - ./cache:/cache
+    ports:
+      - "5000:8080"
+      - "5001:8081"
+    env:
+      MODEL_STORAGE_PATH: /models
+    command: [ "python", "-m", "mindor.cli.compose", "up" ]
+    ...
+```
+
+This gives you full control over:
+
+- **container_name**: Custom name for the container
+- **image**: Docker image to use
+- **volumes**: Bind mounts for sharing files between host and container
+- **ports**: Port mappings for host ↔ container communication
+- **env**: Environment variables to inject
+- **command**: Override the default entrypoint
+- *and many more*
+
+All of these are optional, allowing you to start simple and customize only what you need.
+
+#### 🐳 Benefits of Docker Runtime
+
+- Run your controller in a clean, isolated environment
+- Avoid dependency conflicts with your host Python setup
+- Easily deploy your project to remote servers or CI pipelines
+- Share reproducible workflows with others
+
 ---
 ## 🏗 Architecture
 

{model_compose-0.3.0 → model_compose-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.3.0"
+version = "0.3.1"
 description = "model-compose: Declarative AI Model and Workflow Orchestrator"
 authors = [
     { name = "Hanyeol Cho", email = "hanyeol.cho@gmail.com" }

{model_compose-0.3.0 → model_compose-0.3.1}/src/mindor/core/controller/webui/gradio.py

@@ -106,7 +106,7 @@ class GradioWebUIBuilder:
         if type in [ WorkflowVariableType.IMAGE, WorkflowVariableType.AUDIO, WorkflowVariableType.VIDEO, WorkflowVariableType.FILE ] and (not internal or not format):
             if internal and format and format != "path":
                 value = await self._save_value_to_temporary_file(value, subtype, format)
-            return create_upload_file(value, type.value, subtype)
+            return create_upload_file(value, type.value, subtype) if value is not None else None
 
         return value if value != "" else None
 
@@ -157,17 +157,17 @@ class GradioWebUIBuilder:
         flattened = []
         for variable in variables:
             if isinstance(variable, WorkflowVariableGroupConfig):
-                group = output[variable.name] if variable.name else output
-                for value in group:
+                group = output[variable.name] if variable.name in output else None if variable.name else output
+                for value in group or ():
                     flattened.extend(await self._flatten_output_value(value, variable.variables))
             else:
-                value = output[variable.name] if variable.name else output
+                value = output[variable.name] if variable.name in output else None if variable.name else output
                 flattened.append(await self._convert_output_value(value, variable.type, variable.subtype, variable.format, variable.internal))
         return flattened
 
     async def _convert_output_value(self, value: Any, type: WorkflowVariableType, subtype: Optional[str], format: Optional[WorkflowVariableFormat], internal: bool) -> Any:
         if type == WorkflowVariableType.STRING:
-            return json.dumps(value) if isinstance(value, (dict, list)) else str(value)
+            return json.dumps(value) if isinstance(value, (dict, list)) else str(value) if value is not None else None
 
         if type == WorkflowVariableType.IMAGE:
             return await self._load_image_from_value(value, subtype, format)

{model_compose-0.3.0 → model_compose-0.3.1}/src/mindor/core/runtime/docker/docker.py

@@ -105,9 +105,7 @@ class DockerRuntimeManager:
                     privileged=self.config.privileged,
                     security_opt=self.config.security_opt,
                     restart_policy={ "Name": self.config.restart },
-                    tty=True,
-                    stdin_open=True,
-                    detach=True
+                    tty=True, stdin_open=True, detach=True
                 )
             container.start()
 
@@ -163,9 +161,7 @@ class DockerRuntimeManager:
                 labels=self.config.build.labels or {},
                 network_mode=self.config.build.network,
                 pull=self.config.build.pull,
-                rm=True,
-                forcerm=True,
-                decode=True
+                rm=True, forcerm=True, decode=True
             )
 
             for chunk in response:

{model_compose-0.3.0 → model_compose-0.3.1}/src/mindor/core/workflow/job/base.py

@@ -5,6 +5,10 @@ from mindor.dsl.schema.component import ComponentConfig
 from mindor.core.component import ComponentGlobalConfigs
 from mindor.core.workflow.context import WorkflowContext
 
+class RoutingTarget:
+    def __init__(self, job_id):
+        self.job_id = job_id
+
 class Job(ABC):
     def __init__(self, id: str, config: JobConfig, global_configs: ComponentGlobalConfigs):
         self.id: str = id
@@ -12,7 +16,7 @@ class Job(ABC):
         self.global_configs: ComponentGlobalConfigs = global_configs
 
     @abstractmethod
-    async def run(self, context: WorkflowContext) -> Any:
+    async def run(self, context: WorkflowContext) -> Union[Any, RoutingTarget]:
         pass
 
 def register_job(type: JobType):

{model_compose-0.3.0 → model_compose-0.3.1}/src/mindor/core/workflow/job/impl/__init__.py

@@ -1,2 +1,4 @@
 from .action import *
 from .delay import *
+from .if_ import *
+from .switch import *

{model_compose-0.3.0 → model_compose-0.3.1}/src/mindor/core/workflow/job/impl/action.py

@@ -4,7 +4,7 @@ from mindor.dsl.schema.component import ComponentConfig
 from mindor.core.component import ComponentService, ComponentGlobalConfigs, ComponentResolver, create_component
 from mindor.core.utils.time import TimeTracker
 from mindor.core.logger import logging
-from ..base import Job, JobType, WorkflowContext, register_job
+from ..base import Job, JobType, WorkflowContext, RoutingTarget, register_job
 from datetime import datetime
 import asyncio, ulid
 
@@ -13,7 +13,7 @@ class ActionJob(Job):
     def __init__(self, id: str, config: ActionJobConfig, global_configs: ComponentGlobalConfigs):
         super().__init__(id, config, global_configs)
 
-    async def run(self, context: WorkflowContext) -> Any:
+    async def run(self, context: WorkflowContext) -> Union[Any, RoutingTarget]:
         component: ComponentService = self._create_component(self.id, await context.render_variable(self.config.component))
 
         if not component.started:

{model_compose-0.3.0 → model_compose-0.3.1}/src/mindor/core/workflow/job/impl/delay.py

@@ -3,7 +3,7 @@ from mindor.dsl.schema.job import DelayJobConfig, DelayJobMode
 from mindor.dsl.schema.component import ComponentConfig
 from mindor.core.utils.time import parse_duration, parse_datetime, TimeTracker
 from mindor.core.logger import logging
-from ..base import Job, JobType, WorkflowContext, register_job
+from ..base import Job, JobType, WorkflowContext, RoutingTarget, register_job
 from datetime import datetime, timedelta
 import asyncio
 
@@ -13,13 +13,21 @@ class DelayJob(Job):
         super().__init__(id, config, components)
 
     async def run(self, context: WorkflowContext) -> Any:
-        if self.config.mode == DelayJobMode.TIME_INTERVAL:
+        output = await self._delay(self.config.mode, context)
+        
+        output = (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else output
+        context.register_source("output", output)
+
+        return output
+
+    async def _delay(self, mode: DelayJobMode, context: WorkflowContext) -> Any:
+        if mode == DelayJobMode.TIME_INTERVAL:
             return await self._delay_for_time_interval(context)
 
-        if self.config.mode == DelayJobMode.SPECIFIC_TIME:
+        if mode == DelayJobMode.SPECIFIC_TIME:
             return await self._delay_until_specific_time(context)
 
-        return None
+        raise ValueError(f"Unsupported delay mode: {mode}")
     
     async def _delay_for_time_interval(self, context: WorkflowContext) -> Any:
         duration = parse_duration((await context.render_variable(self.config.duration)) or 0.0)
@@ -35,7 +43,7 @@ class DelayJob(Job):
 
         return None
 
-    async def _delay_until_specific_time(self, context: WorkflowContext) -> Any:
+    async def _delay_until_specific_time(self, context: WorkflowContext) -> Union[Any, RoutingTarget]:
         timezone = await context.render_variable(self.config.timezone)
         time = parse_datetime((await context.render_variable(self.config.time)) or datetime(2000, 1, 1, 0, 0, 0), timezone)