model-compose 0.0.12__tar.gz → 0.0.13__tar.gz

{model_compose-0.0.12/src/model_compose.egg-info → model_compose-0.0.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.0.12
+Version: 0.0.13
 Summary: model-compose: Declarative AI Model and Workflow Orchestrator (from Mindor)
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT
@@ -16,6 +16,7 @@ Requires-Dist: requests
 Requires-Dist: fastapi
 Requires-Dist: uvicorn
 Requires-Dist: ulid
+Requires-Dist: gradio
 Dynamic: license-file
 
 # model-compose: Declarative AI Model and Workflow Orchestrator (from Mindor)

{model_compose-0.0.12 → model_compose-0.0.13}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.0.12"
+version = "0.0.13"
 description = "model-compose: Declarative AI Model and Workflow Orchestrator (from Mindor)"
 authors = [
     { name = "Hanyeol Cho", email = "hanyeol.cho@gmail.com" }
@@ -8,7 +8,16 @@ authors = [
 readme = "README.md"
 license = "MIT"
 dependencies = [
-    "click", "pyyaml", "pydantic", "python-dotenv", "aiohttp", "requests", "fastapi", "uvicorn", "ulid"
+    "click", 
+    "pyyaml", 
+    "pydantic", 
+    "python-dotenv", 
+    "aiohttp", 
+    "requests", 
+    "fastapi", 
+    "uvicorn", 
+    "ulid", 
+    "gradio"
 ]
 
 [project.scripts]

{model_compose-0.0.12 → model_compose-0.0.13}/src/mindor/core/component/component.py

@@ -1,8 +1,8 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.component import ComponentConfig
-from .engine import BaseComponent, ComponentEngineMap
+from .engine import ComponentEngine, ComponentEngineMap
 
-ComponentInstances: Dict[str, BaseComponent] = {}
+ComponentInstances: Dict[str, ComponentEngine] = {}
 
 class ComponentResolver:
     def __init__(self, components: Dict[str, ComponentConfig]):
@@ -27,7 +27,7 @@ class ComponentResolver:
 
         return default_ids[0] if default_ids else "__default__"
 
-def create_component(id: str, config: ComponentConfig, env: Dict[str, str], daemon: bool) -> BaseComponent:
+def create_component(id: str, config: ComponentConfig, env: Dict[str, str], daemon: bool) -> ComponentEngine:
     try:
         component = ComponentInstances[id] if id in ComponentInstances else None
 

{model_compose-0.0.12 → model_compose-0.0.13}/src/mindor/core/component/engine/base.py

@@ -30,14 +30,15 @@ class ActionResolver:
 
         return default_ids[0] if default_ids else "__default__"
 
-class BaseComponent(AsyncService):
+class ComponentEngine(AsyncService):
     def __init__(self, id: str, config: ComponentConfig, env: Dict[str, str], daemon: bool):
         super().__init__(daemon)
 
         self.id: str = id
         self.config: ComponentConfig = config
         self.env: Dict[str, str] = env
-        
+        self.queue: Optional[WorkQueue] = None
+
         if self.config.max_concurrent_count > 0:
             self.queue = WorkQueue(self.config.max_concurrent_count, self._run)
 
@@ -66,4 +67,4 @@ class BaseComponent(AsyncService):
     async def _run(self, action: ActionConfig, context: ComponentContext) -> Any:
         pass
 
-ComponentEngineMap: Dict[ComponentType, Type[BaseComponent]] = {}
+ComponentEngineMap: Dict[ComponentType, Type[ComponentEngine]] = {}

{model_compose-0.0.12 → model_compose-0.0.13}/src/mindor/core/component/engine/http_client.py

@@ -4,7 +4,7 @@ from mindor.dsl.schema.action import ActionConfig, HttpClientActionConfig, HttpC
 from mindor.core.listener import HttpCallbackListener
 from mindor.core.utils.http_client import HttpClient
 from mindor.core.utils.time import parse_duration
-from .base import BaseComponent, ComponentType, ComponentEngineMap
+from .base import ComponentEngine, ComponentType, ComponentEngineMap
 from .context import ComponentContext
 from datetime import datetime, timezone
 import asyncio
@@ -79,7 +79,7 @@ class HttpClientAction:
         body    = context.render_template(self.config.body)
         headers = context.render_template(self.config.headers)
 
-        response = await self.client.request(url, method, params, body, headers)
+        response, result = await self.client.request(url, method, params, body, headers), None
 
         if response:
             context.register_source("response", response)
@@ -90,9 +90,7 @@ class HttpClientAction:
             if result:
                 context.register_source("result", result)
 
-            return context.render_template(self.config.output) if self.config.output else result
-        
-        return context.render_template(self.config.output) if self.config.output else response
+        return context.render_template(self.config.output) if self.config.output else (result or response)
 
     def _resolve_request_url(self, context: ComponentContext) -> str:
         if self.base_url and self.config.path:
@@ -109,7 +107,7 @@ class HttpClientAction:
 
         return None
 
-class HttpClientComponent(BaseComponent):
+class HttpClientComponent(ComponentEngine):
     def __init__(self, id: str, config: HttpClientComponentConfig, env: Dict[str, str], daemon: bool):
         super().__init__(id, config, env, daemon)
 

{model_compose-0.0.12 → model_compose-0.0.13}/src/mindor/core/component/engine/http_server.py

@@ -1,9 +1,9 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.component import HttpServerComponentConfig
-from .base import BaseComponent, ComponentType, ComponentEngineMap, ActionConfig
+from .base import ComponentEngine, ComponentType, ComponentEngineMap, ActionConfig
 from .context import ComponentContext
 
-class HttpServerComponent(BaseComponent):
+class HttpServerComponent(ComponentEngine):
     def __init__(self, id: str, config: HttpServerComponentConfig, env: Dict[str, str], daemon: bool):
         super().__init__(id, config, env, daemon)
 

{model_compose-0.0.12 → model_compose-0.0.13}/src/mindor/core/compose/manager.py

@@ -1,11 +1,11 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.compose import ComposeConfig
-from mindor.core.controller import BaseController, TaskState, create_controller
+from mindor.core.controller import ControllerEngine, TaskState, create_controller
 
 class ComposeManager:
     def __init__(self, config: ComposeConfig, env: Dict[str, str], daemon: bool = True):
         self.config: ComposeConfig = config
-        self.controller: BaseController = create_controller(self.config.controller, self.config.components, self.config.listeners, self.config.workflows, env, daemon)
+        self.controller: ControllerEngine = create_controller(self.config.controller, self.config.components, self.config.listeners, self.config.workflows, env, daemon)
 
     async def launch_services(self, detach: bool, background: bool = False):
         await self.controller.start(background=background)

{model_compose-0.0.12 → model_compose-0.0.13}/src/mindor/core/controller/controller.py

@@ -3,9 +3,9 @@ from mindor.dsl.schema.controller import ControllerConfig
 from mindor.dsl.schema.component import ComponentConfig
 from mindor.dsl.schema.listener import ListenerConfig
 from mindor.dsl.schema.workflow import WorkflowConfig
-from .engine import BaseController, ControllerEngineMap
+from .engine import ControllerEngine, ControllerEngineMap
 
-def create_controller(config: ControllerConfig, components: Dict[str, ComponentConfig], listeners: List[ListenerConfig], workflows: Dict[str, WorkflowConfig], env: Dict[str, str], daemon: bool) -> BaseController:
+def create_controller(config: ControllerConfig, components: Dict[str, ComponentConfig], listeners: List[ListenerConfig], workflows: Dict[str, WorkflowConfig], env: Dict[str, str], daemon: bool) -> ControllerEngine:
     try:
         return ControllerEngineMap[config.type](config, components, listeners, workflows, env, daemon)
     except KeyError:

{model_compose-0.0.12 → model_compose-0.0.13}/src/mindor/core/controller/engine/base.py

@@ -6,9 +6,10 @@ from mindor.dsl.schema.component import ComponentConfig
 from mindor.dsl.schema.listener import ListenerConfig
 from mindor.dsl.schema.workflow import WorkflowConfig
 from mindor.core.services import AsyncService
-from mindor.core.component import BaseComponent, create_component
-from mindor.core.listener import BaseListener, create_listener
+from mindor.core.component import ComponentEngine, create_component
+from mindor.core.listener import ListenerEngine, create_listener
 from mindor.core.workflow import Workflow, WorkflowResolver, create_workflow
+from mindor.core.controller.webui import ControllerWebUI
 from mindor.core.utils.workqueue import WorkQueue
 from mindor.core.utils.expiring import ExpiringDict
 
@@ -22,8 +23,16 @@ class TaskState:
     output: Optional[Any] = None
     error: Optional[Any] = None
 
-class BaseController(AsyncService):
-    def __init__(self, config: ControllerConfig, components: Dict[str, ComponentConfig], listeners: List[ListenerConfig], workflows: Dict[str, WorkflowConfig], env: Dict[str, str], daemon: bool):
+class ControllerEngine(AsyncService):
+    def __init__(
+        self,
+        config: ControllerConfig,
+        components: Dict[str, ComponentConfig],
+        listeners: List[ListenerConfig],
+        workflows: Dict[str, WorkflowConfig],
+        env: Dict[str, str],
+        daemon: bool
+    ):
         super().__init__(daemon)
 
         self.config: ControllerConfig = config
@@ -66,6 +75,9 @@ class BaseController(AsyncService):
             await self._start_components()
             await self._start_listeners()
 
+            if self.config.webui:
+                await self._start_webui()
+
         await super()._start()
 
     async def _stop(self) -> None:
@@ -76,6 +88,9 @@ class BaseController(AsyncService):
             await self._stop_listeners()
             await self._stop_components()
 
+            if self.config.webui:
+                await self._stop_webui()
+
         await super()._stop()
 
     async def _start_components(self) -> None:
@@ -90,6 +105,12 @@ class BaseController(AsyncService):
     async def _stop_listeners(self) -> None:
         await asyncio.gather(*[ listener.stop() for listener in self._create_listeners() ])
 
+    async def _start_webui(self) -> None:
+        await asyncio.gather(*[ self._create_webui().start() ])
+
+    async def _stop_webui(self) -> None:
+        await asyncio.gather(*[ self._create_webui().stop() ])
+
     async def _run_workflow(self, task_id: str, workflow_id: Optional[str], input: Dict[str, Any]) -> TaskState:
         state = TaskState(task_id=task_id, status="processing")
         with self.task_states_lock:
@@ -107,13 +128,16 @@ class BaseController(AsyncService):
 
         return state
 
-    def _create_components(self) -> List[BaseComponent]:
+    def _create_components(self) -> List[ComponentEngine]:
         return [ create_component(component_id, config, self.env, self.daemon) for component_id, config in self.components.items() ]
     
-    def _create_listeners(self) -> List[BaseListener]:
+    def _create_listeners(self) -> List[ListenerEngine]:
         return [ create_listener(config, self.env, self.daemon) for config in self.listeners ]
     
+    def _create_webui(self) -> ControllerWebUI:
+        return ControllerWebUI(self.config.webui, self.config, self.components, self.workflows, self.env, self.daemon)
+
     def _create_workflow(self, workflow_id: Optional[str]) -> Workflow:
         return create_workflow(*WorkflowResolver(self.workflows).resolve(workflow_id), self.components, self.env)
 
-ControllerEngineMap: Dict[ControllerType, Type[BaseController]] = {}
+ControllerEngineMap: Dict[ControllerType, Type[ControllerEngine]] = {}

{model_compose-0.0.12 → model_compose-0.0.13}/src/mindor/core/controller/engine/http_server.py

@@ -7,7 +7,7 @@ from mindor.dsl.schema.listener import ListenerConfig
 from mindor.dsl.schema.component import ComponentConfig
 from mindor.dsl.schema.workflow import WorkflowConfig
 from mindor.core.utils.resources import StreamResource 
-from .base import BaseController, ControllerType, ControllerEngineMap, TaskState
+from .base import ControllerEngine, ControllerType, ControllerEngineMap, TaskState
 
 from fastapi import FastAPI, APIRouter, Body, HTTPException
 from fastapi.responses import Response, JSONResponse, StreamingResponse
@@ -35,8 +35,16 @@ class TaskResult(BaseModel):
             error=instance.error
         )
 
-class HttpServerController(BaseController):
-    def __init__(self, config: HttpServerControllerConfig, components: Dict[str, ComponentConfig], listeners: List[ListenerConfig], workflows: Dict[str, WorkflowConfig], env: Dict[str, str], daemon: bool):
+class HttpServerController(ControllerEngine):
+    def __init__(
+        self,
+        config: HttpServerControllerConfig,
+        components: Dict[str, ComponentConfig],
+        listeners: List[ListenerConfig],
+        workflows: Dict[str, WorkflowConfig],
+        env: Dict[str, str],
+        daemon: bool
+    ):
         super().__init__(config, components, listeners, workflows, env, daemon)
         
         self.server: Optional[uvicorn.Server] = None

{model_compose-0.0.12 → model_compose-0.0.13}/src/mindor/core/controller/engine/mcp_server.py

@@ -3,10 +3,18 @@ from mindor.dsl.schema.controller import McpServerControllerConfig
 from mindor.dsl.schema.listener import ListenerConfig
 from mindor.dsl.schema.component import ComponentConfig
 from mindor.dsl.schema.workflow import WorkflowConfig
-from .base import BaseController, ControllerType, ControllerEngineMap
+from .base import ControllerEngine, ControllerType, ControllerEngineMap
 
-class McpServerController(BaseController):
-    def __init__(self, config: McpServerControllerConfig, components: Dict[str, ComponentConfig], listeners: List[ListenerConfig], workflows: Dict[str, WorkflowConfig], env: Dict[str, str], daemon: bool):
+class McpServerController(ControllerEngine):
+    def __init__(
+        self,
+        config: McpServerControllerConfig,
+        components: Dict[str, ComponentConfig],
+        listeners: List[ListenerConfig],
+        workflows: Dict[str, WorkflowConfig],
+        env: Dict[str, str],
+        daemon: bool
+    ):
         super().__init__(config, components, listeners, workflows, env, daemon)
 
     async def _serve(self) -> None:

model_compose-0.0.13/src/mindor/core/controller/runner/__init__.py

@@ -0,0 +1 @@
+from .runner import *

model_compose-0.0.13/src/mindor/core/controller/runner/client.py

@@ -0,0 +1,11 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from abc import ABC, abstractmethod
+from mindor.dsl.schema.controller import ControllerConfig
+
+class ControllerClient(ABC):
+    def __init__(self, config: ControllerConfig):
+        self.config: ControllerConfig = config
+
+    @abstractmethod
+    async def run_workflow(self, workflow_id: Optional[str], input: Any) -> Any:
+        pass

model_compose-0.0.13/src/mindor/core/controller/runner/http_client.py

@@ -0,0 +1,26 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.controller import ControllerConfig
+from mindor.core.utils.http_client import HttpClient
+from .runner import ControllerClient
+
+class HttpControllerClient(ControllerClient):
+    def __init__(self, config: ControllerConfig):
+        super().__init__(config)
+
+        self.client: HttpClient = HttpClient()
+
+    async def run_workflow(self, workflow_id: Optional[str], input: Any) -> Any:
+        base_path = self.config.base_path if self.config.base_path else ""
+        url = f"http://localhost:{self.config.port}{base_path}/workflows"
+        method = "POST"
+        body = {
+            "workflow_id": workflow_id,
+            "input": input,
+            "wait_for_completion": True,
+            "output_only": True
+        }
+        headers = {
+            "Content-Type": "application/json"
+        }
+
+        return await self.client.request(url, method, None, body, headers)

model_compose-0.0.13/src/mindor/core/controller/runner/mcp_client.py

@@ -0,0 +1,10 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.controller import ControllerConfig
+from .runner import ControllerClient
+
+class McpControllerClient(ControllerClient):
+    def __init__(self, config: ControllerConfig):
+        super().__init__(config)
+
+    async def run_workflow(self, workflow_id: Optional[str], input: Any) -> Any:
+        pass

model_compose-0.0.13/src/mindor/core/controller/runner/runner.py

@@ -0,0 +1,33 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from abc import ABC, abstractmethod
+from mindor.dsl.schema.controller import ControllerConfig
+from .client import ControllerClient
+from .http_client import HttpControllerClient
+from .mcp_client import McpControllerClient
+
+class ControllerClient(ABC):
+    def __init__(self, config: ControllerConfig):
+        self.config: ControllerConfig = config
+
+    @abstractmethod
+    async def run_workflow(self, workflow_id: Optional[str], input: Any) -> Any:
+        pass
+
+class ControllerRunner:
+    def __init__(self, config: ControllerConfig):
+        self.config: ControllerConfig = config
+        self.client: ControllerClient = None
+
+        self._configure_client()
+
+    def _configure_client(self) -> None:
+        if self.config.type == "http-server":
+            self.client = HttpControllerClient(self.config)
+            return
+        
+        if self.config.type == "mcp-server":
+            self.client = McpControllerClient(self.config)
+            return
+    
+    async def run_workflow(self, workflow_id: Optional[str], input: Any) -> Any:
+        return await self.client.run_workflow(workflow_id, input)

model_compose-0.0.13/src/mindor/core/controller/webui/__init__.py

@@ -0,0 +1 @@
+from .webui import *

model_compose-0.0.13/src/mindor/core/controller/webui/gradio.py

@@ -0,0 +1,88 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Awaitable, Any
+from mindor.dsl.schema.workflow import WorkflowVariableConfig
+from .schema import WorkflowSchema
+import gradio, json
+
+class GradioWebUIBuilder:
+    def build(self, schema: Dict[str, WorkflowSchema], runner: Callable[[Optional[str], Any], Awaitable[Any]]) -> gradio.Blocks:
+        with gradio.Blocks() as blocks:
+            for workflow_id, workflow in schema.items():
+                async def run_workflow(input: Any, workflow_id=workflow_id) -> Any:
+                    return await runner(workflow_id, input)
+
+                if len(schema) > 1:
+                    with gradio.Tab(label=workflow.name or workflow_id):
+                        self._build_workflow_section(workflow, run_workflow)
+                else:
+                    self._build_workflow_section(workflow, run_workflow)
+
+        return blocks
+
+    def _build_workflow_section(self, workflow: WorkflowSchema, runner: Callable[[Any], Awaitable[Any]]) -> gradio.Column:
+        with gradio.Column() as section:
+            gradio.Markdown(f"## **{workflow.title or 'Untitled Workflow'}**")  
+
+            if workflow.description:
+                gradio.Markdown(f"📝 {workflow.description}")
+
+            gradio.Markdown("#### 📥 Input Parameters")
+            input_components = [ self._build_input_component(variable) for variable in workflow.input ]
+            run_button = gradio.Button("🚀 Run Workflow", variant="primary")
+
+            gradio.Markdown("#### 📤 Output Values")
+            output_components = [ self._build_output_component(variable) for variable in workflow.output ]
+
+            if not output_components:
+                output_components = gradio.Textbox(label="", lines=8, interactive=False, show_copy_button=True)
+
+            async def run_workflow(*args):
+                input = { variable.name: value for variable, value in zip(workflow.input, args) }
+                output = await runner(input)
+
+                if workflow.output and isinstance(output, dict):
+                    output = [ output[variable.name] for variable in workflow.output ]
+                    output = output[0] if len(output) == 1 else output
+
+                return output
+
+            run_button.click(
+                fn=run_workflow,
+                inputs=input_components,
+                outputs=output_components
+            )
+
+        return section
+
+    def _build_input_component(self, variable: WorkflowVariableConfig) -> gradio.Component:
+        label = f"{variable.name} {'*' if variable.required else ''}"
+        info = variable.description or ""
+        default = variable.default
+
+        if variable.type == "string":
+            return gradio.Textbox(label=label, value=default or "", info=info)
+        
+        if variable.type == "integer":
+            return gradio.Number(label=label, value=default or 0, precision=0, info=info)
+        
+        if variable.type == "float":
+            return gradio.Number(label=label, value=default or 0.0, info=info)
+        
+        if variable.type == "boolean":
+            return gradio.Checkbox(label=label, value=default or False, info=info)
+        
+        if variable.type == "file":
+            return gradio.File(label=label, file_types=["*"], info=info)
+        
+        if variable.type == "select":
+            return gradio.Dropdown(choices=variable.options or [], label=label, value=default, info=info)
+        
+        return gradio.Textbox(label=label, value=default or "", info=f"Unsupported type: {variable.type}")
+
+    def _build_output_component(self, variable: WorkflowVariableConfig) -> gradio.Component:
+        label = variable.name
+        info = variable.description or ""
+        
+        if variable.type == "string":
+            return gradio.Textbox(label=label, interactive=False, show_copy_button=True, info=info)
+        
+        return gradio.Textbox(label=label, info=f"Unsupported type: {variable.type}")

model_compose-0.0.13/src/mindor/core/controller/webui/schema.py

@@ -0,0 +1,94 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel
+from mindor.dsl.schema.workflow import WorkflowConfig, WorkflowVariableConfig
+from mindor.dsl.schema.component import ComponentConfig
+import re
+
+class WorkflowVariableResolver:
+    def __init__(self):
+        self.patterns: Dict[str, re.Pattern] = {
+            "variable": re.compile(
+                r"""\$\{                   # ${ 
+                    ([a-zA-Z_][\w\-]*)     # key: input, env, etc.
+                    (?:\.([^\|\}]+))?      # path: key, key.path[0], etc.
+                    (?:\s*\|\s*([^\}]+))?  # default value after `|`
+                \}""",                     # }
+                re.VERBOSE,
+            )
+        }
+
+    def _enumerate_variables(self, data: Any, wanted_key: str) -> Any:
+        if isinstance(data, str):
+            variables = []
+
+            for match in self.patterns["variable"].finditer(data):
+                key, path = match.group(1), match.group(2)
+                
+                if key == wanted_key:
+                    variables.append(path)
+
+            return variables
+
+        if isinstance(data, BaseModel):
+            return self._enumerate_variables(data.model_dump(exclude_none=True), wanted_key)
+        
+        if isinstance(data, dict):
+            return sum([ self._enumerate_variables(v, wanted_key) for v in data.values() ], [])
+
+        if isinstance(data, list):
+            return sum([ self._enumerate_variables(v, wanted_key) for v in data ], [])
+        
+        return []
+
+class WorkflowInputResolver(WorkflowVariableResolver):
+    def resolve(self, workflow: WorkflowConfig, components: Dict[str, ComponentConfig]) -> List[WorkflowVariableConfig]:
+        variables = []
+        for job in workflow.jobs.values():
+            if not job.input or job.input == "${input}":
+                action_id = job.action or "__default__"
+                if isinstance(job.component, str):
+                    component: ComponentConfig = components[job.component] if job.component in components else None
+                    if component:
+                        variables.extend(self._enumerate_variables(component.actions[action_id], "input"))
+                else:
+                    variables.extend(self._enumerate_variables(job.component.actions[action_id], "input"))
+            else:
+                variables.extend(self._enumerate_variables(job.input, "input"))
+
+        return [ WorkflowVariableConfig(name=name, type="string") for name in set(variables) ]
+
+class WorkflowOutputResolver(WorkflowVariableResolver):
+    def resolve(self, workflow: WorkflowConfig, components: Dict[str, ComponentConfig]) -> List[WorkflowVariableConfig]:
+        variables = []
+        for job_id, job in workflow.jobs.items():
+            if not self._is_terminal_job(workflow, job_id):
+                continue
+            
+            if not job.output or job.output == "${output}":
+                action_id = job.action or "__default__"
+                if isinstance(job.component, str):
+                    component: ComponentConfig = components[job.component] if job.component in components else None
+                    if component:
+                        action = component.actions[action_id]
+                        if isinstance(action.output, dict):
+                            variables.extend(action.output.keys())
+                else:
+                    action = component.actions[action_id]
+                    if isinstance(action.output, dict):
+                        variables.extend(action.output.keys())
+            else:
+                if isinstance(job.output, dict):
+                    variables.extend(job.output.keys())
+
+        return [ WorkflowVariableConfig(name=name, type="string") for name in set(variables) ]
+    
+    def _is_terminal_job(self, workflow: WorkflowConfig, job_id: str) -> bool:
+        return all(job_id not in job.depends_on for other_id, job in workflow.jobs.items() if other_id != job_id)
+
+class WorkflowSchema:
+    def __init__(self, name: str, title: str, description: Optional[str], input: List[WorkflowVariableConfig], output: List[WorkflowVariableConfig]):
+        self.name: str = name
+        self.title: str = title
+        self.description: Optional[str] = description
+        self.input: List[WorkflowVariableConfig] = input
+        self.output: List[WorkflowVariableConfig] = output

model_compose-0.0.13/src/mindor/core/controller/webui/webui.py

@@ -0,0 +1,74 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.controller import ControllerWebUIConfig, ControllerConfig
+from mindor.dsl.schema.component import ComponentConfig
+from mindor.dsl.schema.workflow import WorkflowConfig
+from mindor.core.controller.runner import ControllerRunner
+from mindor.core.services import AsyncService
+from .schema import WorkflowSchema, WorkflowInputResolver, WorkflowOutputResolver
+from .gradio import GradioWebUIBuilder
+
+from fastapi import FastAPI, APIRouter, Body, HTTPException
+import asyncio, uvicorn
+from gradio import mount_gradio_app
+import gradio, re
+
+class ControllerWebUI(AsyncService):
+    def __init__(
+        self,
+        config: ControllerWebUIConfig,
+        controller: ControllerConfig,
+        components: Dict[str, ComponentConfig],
+        workflows: Dict[str, WorkflowConfig],
+        env: Dict[str, str],
+        daemon: bool
+    ):
+        super().__init__(daemon)
+
+        self.config: ControllerWebUIConfig = config
+        self.controller: ControllerConfig = controller
+        self.components: Dict[str, ComponentConfig] = components
+        self.workflows: Dict[str, WorkflowConfig] = workflows
+        self.env: Dict[str, str] = env
+        self.server: Optional[uvicorn.Server] = None
+        self.app: FastAPI = FastAPI()
+        self.runner: ControllerRunner = ControllerRunner(controller)
+
+        self._configure_driver()
+
+    def _configure_driver(self) -> None:
+        if self.config.driver == "gradio":
+            blocks: gradio.Blocks = GradioWebUIBuilder().build(
+                schema=self._resolve_workflow_schema(),
+                runner=self._run_workflow
+            )
+            self.app = mount_gradio_app(self.app, blocks, path="")
+            return
+
+    async def _serve(self) -> None:
+        self.server = uvicorn.Server(uvicorn.Config(
+            self.app,
+            host=self.config.host,
+            port=self.config.port,
+            log_level="info"
+        ))
+        await self.server.serve()
+    
+    async def _shutdown(self) -> None:
+        self.server.should_exit = True
+    
+    async def _run_workflow(self, workflow_id: Optional[str], input: Any) -> Any:
+        return await self.runner.run_workflow(workflow_id, input)
+
+    def _resolve_workflow_schema(self) -> Dict[str, WorkflowSchema]:
+        schema: Dict[str, WorkflowSchema] = {}
+
+        for workflow_id, workflow in self.workflows.items():
+            schema[workflow_id] = WorkflowSchema(
+                name=workflow.name,
+                title=workflow.title, 
+                description=workflow.description,
+                input=WorkflowInputResolver().resolve(workflow, self.components),
+                output=WorkflowOutputResolver().resolve(workflow, self.components)
+            )
+
+        return schema