model-compose 0.2.6__tar.gz → 0.2.7__tar.gz

{model_compose-0.2.6/src/model_compose.egg-info → model_compose-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.2.6
+Version: 0.2.7
 Summary: model-compose: Declarative AI Model and Workflow Orchestrator
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT

{model_compose-0.2.6 → model_compose-0.2.7}/pyproject.toml

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

{model_compose-0.2.6 → model_compose-0.2.7}/src/mindor/cli/compose.py

@@ -31,19 +31,21 @@ def compose_command(ctx: click.Context, config_files: List[Path]) -> None:
     "--env", "-e", "env_data", multiple=True,
     help="Environment variable in the form KEY=VALUE. Repeatable.",
 )
+@click.option("--verbose", "-v", is_flag=True, help="Enable verbose output.")
 @click.pass_context
 def up_command(
     ctx: click.Context, 
     detach: bool,
     env_files: List[Path],
-    env_data: List[str]
+    env_data: List[str],
+    verbose: bool
 ) -> None:
     config_files = ctx.obj.get("config_files", [])
     async def _async_command():
         try:
             env = load_env_files(".", env_files or [])
             config = load_compose_config(".", config_files, env)
-            await launch_services(config, detach)
+            await launch_services(config, detach, verbose)
         except Exception as e:
             click.echo(f"❌ {e}", err=True)
     asyncio.run(_async_command())
@@ -86,18 +88,20 @@ def down_command(
     "--env", "-e", "env_data", multiple=True,
     help="Environment variable in the form KEY=VALUE. Repeatable.",
 )
+@click.option("--verbose", "-v", is_flag=True, help="Enable verbose output.")
 @click.pass_context
 def start_command(
     ctx: click.Context,
     env_files: List[Path],
     env_data: List[str],
+    verbose: bool
 ) -> None:
     config_files = ctx.obj.get("config_files", [])
     async def _async_command():
         try:
             env = load_env_files(".", env_files or [])
             config = load_compose_config(".", config_files, env)
-            await start_services(config)
+            await start_services(config, verbose)
         except Exception as e:
             click.echo(f"❌ {e}", err=True)
     asyncio.run(_async_command())
@@ -147,6 +151,7 @@ def stop_command(
     "--env", "-e", "env_data", multiple=True,
     help="Environment variable in the form KEY=VALUE. Repeatable.",
 )
+@click.option("--verbose", "-v", is_flag=True, help="Enable verbose output.")
 @click.pass_context
 def run_command(
     ctx: click.Context,
@@ -154,6 +159,7 @@ def run_command(
     input_json: Optional[str],
     env_files: List[Path],
     env_data: List[str],
+    verbose: bool
 ) -> None:
     config_files = ctx.obj.get("config_files", [])
     async def _async_command():
@@ -161,7 +167,7 @@ def run_command(
             env = load_env_files(".", env_files or [])
             config = load_compose_config(".", config_files, env)
             input = json.loads(input_json) if input_json else {}
-            state = await run_workflow(config, workflow, input)
+            state = await run_workflow(config, workflow, input, verbose)
             click.echo(json.dumps(
                 state.error if state.error else state.output, 
                 indent=2, 

{model_compose-0.2.6 → model_compose-0.2.7}/src/mindor/core/component/base.py

@@ -45,7 +45,7 @@ class ComponentGlobalConfigs:
         self.gateways: List[GatewayConfig] = gateways
         self.workflows: Dict[str, WorkflowConfig] = workflows
 
-class ComponentEngine(AsyncService):
+class ComponentService(AsyncService):
     def __init__(self, id: str, config: ComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
         super().__init__(daemon)
 
@@ -83,9 +83,9 @@ class ComponentEngine(AsyncService):
         pass
 
 def register_component(type: ComponentType):
-    def decorator(cls: Type[ComponentEngine]) -> Type[ComponentEngine]:
+    def decorator(cls: Type[ComponentService]) -> Type[ComponentService]:
         ComponentRegistry[type] = cls
         return cls
     return decorator
 
-ComponentRegistry: Dict[ComponentType, Type[ComponentEngine]] = {}
+ComponentRegistry: Dict[ComponentType, Type[ComponentService]] = {}

{model_compose-0.2.6 → model_compose-0.2.7}/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 .base import ComponentEngine, ComponentGlobalConfigs, ComponentRegistry
+from .base import ComponentService, ComponentGlobalConfigs, ComponentRegistry
 
-ComponentInstances: Dict[str, ComponentEngine] = {}
+ComponentInstances: Dict[str, ComponentService] = {}
 
 class ComponentResolver:
     def __init__(self, components: Dict[str, ComponentConfig]):
@@ -27,13 +27,13 @@ class ComponentResolver:
 
         return default_ids[0] if default_ids else "__default__"
 
-def create_component(id: str, config: ComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool) -> ComponentEngine:
+def create_component(id: str, config: ComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool) -> ComponentService:
     try:
         component = ComponentInstances[id] if id in ComponentInstances else None
 
         if not component:
             if not ComponentRegistry:
-                from . import engine
+                from . import services
             component = ComponentRegistry[config.type](id, config, global_configs, daemon)
             ComponentInstances[id] = component
 

{model_compose-0.2.6/src/mindor/core/component/engine → model_compose-0.2.7/src/mindor/core/component/services}/http_client.py

@@ -6,7 +6,7 @@ from mindor.core.listener import HttpCallbackListener
 from mindor.core.utils.http_client import HttpClient
 from mindor.core.utils.http_status import is_status_code_matched
 from mindor.core.utils.time import parse_duration
-from ..base import ComponentEngine, ComponentType, ComponentGlobalConfigs, register_component
+from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
 from ..context import ComponentActionContext
 from datetime import datetime, timezone
 import asyncio
@@ -109,7 +109,7 @@ class HttpClientAction:
         return await context.render_variable(self.config.endpoint)
 
 @register_component(ComponentType.HTTP_CLIENT)
-class HttpClientComponent(ComponentEngine):
+class HttpClientComponent(ComponentService):
     def __init__(self, id: str, config: HttpClientComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
         super().__init__(id, config, global_configs, daemon)
 

{model_compose-0.2.6/src/mindor/core/component/engine → model_compose-0.2.7/src/mindor/core/component/services}/http_server.py

@@ -1,11 +1,11 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.component import HttpServerComponentConfig
 from mindor.dsl.schema.action import ActionConfig, HttpServerActionConfig
-from ..base import ComponentEngine, ComponentType, ComponentGlobalConfigs, register_component
+from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
 from ..context import ComponentActionContext
 
 @register_component(ComponentType.HTTP_SERVER)
-class HttpServerComponent(ComponentEngine):
+class HttpServerComponent(ComponentService):
     def __init__(self, id: str, config: HttpServerComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
         super().__init__(id, config, global_configs, daemon)
 

{model_compose-0.2.6/src/mindor/core/component/engine → model_compose-0.2.7/src/mindor/core/component/services}/mcp_client.py

@@ -2,7 +2,7 @@ from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annot
 from mindor.dsl.schema.component import McpClientComponentConfig
 from mindor.dsl.schema.action import ActionConfig, McpClientActionConfig
 from mindor.core.utils.mcp_client import McpClient, ContentBlock, TextContent, ImageContent, AudioContent
-from ..base import ComponentEngine, ComponentType, ComponentGlobalConfigs, register_component
+from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
 from ..context import ComponentActionContext
 
 class McpClientAction():
@@ -28,7 +28,7 @@ class McpClientAction():
         return None
 
 @register_component(ComponentType.MCP_CLIENT)
-class McpClientComponent(ComponentEngine):
+class McpClientComponent(ComponentService):
     def __init__(self, id: str, config: McpClientComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
         super().__init__(id, config, global_configs, daemon)
 

{model_compose-0.2.6/src/mindor/core/component/engine → model_compose-0.2.7/src/mindor/core/component/services}/mcp_server.py

@@ -1,11 +1,11 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.component import McpServerComponentConfig
 from mindor.dsl.schema.action import ActionConfig, McpServerActionConfig
-from ..base import ComponentEngine, ComponentType, ComponentGlobalConfigs, register_component
+from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
 from ..context import ComponentActionContext
 
 @register_component(ComponentType.MCP_SERVER)
-class McpServerComponent(ComponentEngine):
+class McpServerComponent(ComponentService):
     def __init__(self, id: str, config: McpServerComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
         super().__init__(id, config, global_configs, daemon)
 

{model_compose-0.2.6/src/mindor/core/component/engine → model_compose-0.2.7/src/mindor/core/component/services}/shell.py

@@ -1,7 +1,7 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.component import ShellComponentConfig
 from mindor.dsl.schema.action import ActionConfig, ShellActionConfig
-from ..base import ComponentEngine, ComponentType, ComponentGlobalConfigs, register_component
+from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
 from ..context import ComponentActionContext
 from asyncio.subprocess import Process
 import asyncio, os
@@ -65,7 +65,7 @@ class ShellAction:
         return working_dir
 
 @register_component(ComponentType.SHELL)
-class ShellComponent(ComponentEngine):
+class ShellComponent(ComponentService):
     def __init__(self, id: str, config: ShellComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
         super().__init__(id, config, global_configs, daemon)
 

{model_compose-0.2.6/src/mindor/core/component/engine → model_compose-0.2.7/src/mindor/core/component/services}/workflow.py

@@ -3,7 +3,7 @@ from mindor.dsl.schema.component import ComponentConfig, WorkflowComponentConfig
 from mindor.dsl.schema.action import ActionConfig, WorkflowActionConfig
 from mindor.dsl.schema.workflow import WorkflowConfig
 from mindor.core.workflow import Workflow, WorkflowResolver, create_workflow
-from ..base import ComponentEngine, ComponentType, ComponentGlobalConfigs, register_component
+from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
 from ..context import ComponentActionContext
 import asyncio, os
 
@@ -26,7 +26,7 @@ class WorkflowAction:
         return create_workflow(*WorkflowResolver(self.global_configs.workflows).resolve(workflow_id), self.global_configs)
 
 @register_component(ComponentType.WORKFLOW)
-class WorkflowComponent(ComponentEngine):
+class WorkflowComponent(ComponentService):
     def __init__(self, id: str, config: WorkflowComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
         super().__init__(id, config, global_configs, daemon)
 

{model_compose-0.2.6 → model_compose-0.2.7}/src/mindor/core/compose/compose.py

@@ -2,17 +2,17 @@ from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annot
 from mindor.dsl.schema.compose import ComposeConfig
 from .manager import ComposeManager, TaskState
 
-async def launch_services(config: ComposeConfig, detach: bool):
-    await ComposeManager(config, daemon=True).launch_services(detach=detach)
+async def launch_services(config: ComposeConfig, detach: bool, verbose: bool):
+    await ComposeManager(config, daemon=True).launch_services(detach, verbose)
 
 async def shutdown_services(config: ComposeConfig):
     await ComposeManager(config, daemon=False).shutdown_services()
 
-async def start_services(config: ComposeConfig, detach: bool):
-    await ComposeManager(config, daemon=False).start_services()
+async def start_services(config: ComposeConfig, verbose: bool):
+    await ComposeManager(config, daemon=False).start_services(verbose)
 
 async def stop_services(config: ComposeConfig):
     await ComposeManager(config, daemon=False).stop_services()
 
-async def run_workflow(config: ComposeConfig, workflow_id: Optional[str], input: Dict[str, Any]) -> TaskState:
-    return await ComposeManager(config, daemon=False).run_workflow(workflow_id, input)
+async def run_workflow(config: ComposeConfig, workflow_id: Optional[str], input: Dict[str, Any], verbose: bool) -> TaskState:
+    return await ComposeManager(config, daemon=False).run_workflow(workflow_id, input, verbose)

{model_compose-0.2.6 → model_compose-0.2.7}/src/mindor/core/compose/manager.py

@@ -1,34 +1,35 @@
 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 ControllerEngine, TaskState, create_controller
+from mindor.core.controller import ControllerService, TaskState, create_controller
 
 class ComposeManager:
-    def __init__(self, config: ComposeConfig, daemon: bool = True):
+    def __init__(self, config: ComposeConfig, daemon: bool):
         self.config: ComposeConfig = config
-        self.controller: ControllerEngine = create_controller(
+        self.controller: ControllerService = create_controller(
             self.config.controller,
+            self.config.workflows,
             self.config.components,
             self.config.listeners,
             self.config.gateways,
-            self.config.workflows,
+            self.config.loggers,
             daemon
         )
 
-    async def launch_services(self, detach: bool, background: bool = False):
-        await self.controller.start(background=background)
+    async def launch_services(self, detach: bool, verbose: bool):
+        await self.controller.start()
         await self.controller.wait_until_stopped()
 
     async def shutdown_services(self):
         await self.controller.stop()
 
-    async def start_services(self, background: bool = False):
-        await self.controller.start(background=background)
+    async def start_services(self, verbose: bool):
+        await self.controller.start()
         await self.controller.wait_until_stopped()
 
     async def stop_services(self):
         await self.controller.stop()
 
-    async def run_workflow(self, workflow_id: Optional[str], input: Dict[str, Any]) -> TaskState:
+    async def run_workflow(self, workflow_id: Optional[str], input: Dict[str, Any], verbose: bool) -> TaskState:
         if not self.controller.started:
             await self.controller.start()
 

model_compose-0.2.7/src/mindor/core/controller/__init__.py

@@ -0,0 +1,2 @@
+from .controller import *
+from .base import TaskState

{model_compose-0.2.6 → model_compose-0.2.7}/src/mindor/core/controller/base.py

@@ -5,12 +5,14 @@ from mindor.dsl.schema.controller import ControllerConfig, ControllerType
 from mindor.dsl.schema.component import ComponentConfig
 from mindor.dsl.schema.listener import ListenerConfig
 from mindor.dsl.schema.gateway import GatewayConfig
+from mindor.dsl.schema.logger import LoggerConfig
 from mindor.dsl.schema.workflow import WorkflowConfig
 from mindor.core.services import AsyncService
-from mindor.core.component import ComponentEngine, ComponentGlobalConfigs, create_component
-from mindor.core.listener import ListenerEngine, create_listener
-from mindor.core.gateway import GatewayEngine, create_gateway
+from mindor.core.component import ComponentService, ComponentGlobalConfigs, create_component
+from mindor.core.listener import ListenerService, create_listener
+from mindor.core.gateway import GatewayService, create_gateway
 from mindor.core.workflow import Workflow, WorkflowResolver, create_workflow
+from mindor.core.logger import LoggerService, create_logger
 from mindor.core.controller.webui import ControllerWebUI
 from mindor.core.utils.workqueue import WorkQueue
 from mindor.core.utils.expiring import ExpiringDict
@@ -30,23 +32,25 @@ class TaskState:
     output: Optional[Any] = None
     error: Optional[Any] = None
 
-class ControllerEngine(AsyncService):
+class ControllerService(AsyncService):
     def __init__(
         self,
         config: ControllerConfig,
+        workflows: Dict[str, WorkflowConfig],
         components: Dict[str, ComponentConfig],
         listeners: List[ListenerConfig],
         gateways: List[GatewayConfig],
-        workflows: Dict[str, WorkflowConfig],
+        loggers: List[LoggerConfig],
         daemon: bool
     ):
         super().__init__(daemon)
 
         self.config: ControllerConfig = config
+        self.workflows: Dict[str, WorkflowConfig] = workflows
         self.components: Dict[str, ComponentConfig] = components
         self.listeners: List[ListenerConfig] = listeners
         self.gateways: List[GatewayConfig] = gateways
-        self.workflows: Dict[str, WorkflowConfig] = workflows
+        self.loggers: List[LoggerConfig] = loggers
         self.queue: Optional[WorkQueue] = None
         self.task_states: ExpiringDict[TaskState] = ExpiringDict()
         self.task_states_lock: Lock = Lock()
@@ -79,9 +83,10 @@ class ControllerEngine(AsyncService):
             await self.queue.start()
 
         if self.daemon:
-            await self._start_components()
-            await self._start_listeners()
+            await self._start_loggers()
             await self._start_gateways()
+            await self._start_listeners()
+            await self._start_components()
 
             if self.config.webui:
                 await self._start_webui()
@@ -93,21 +98,16 @@ class ControllerEngine(AsyncService):
             await self.queue.stop()
 
         if self.daemon:
-            await self._stop_gateways()
-            await self._stop_listeners()
             await self._stop_components()
+            await self._stop_listeners()
+            await self._stop_gateways()
+            await self._stop_loggers()
 
             if self.config.webui:
                 await self._stop_webui()
 
         await super()._stop()
 
-    async def _start_components(self) -> None:
-        await asyncio.gather(*[ component.start() for component in self._create_components() ])
-
-    async def _stop_components(self) -> None:
-        await asyncio.gather(*[ component.stop() for component in self._create_components() ])
-
     async def _start_listeners(self) -> None:
         await asyncio.gather(*[ listener.start() for listener in self._create_listeners() ])
 
@@ -120,6 +120,18 @@ class ControllerEngine(AsyncService):
     async def _stop_gateways(self) -> None:
         await asyncio.gather(*[ gateway.stop() for gateway in self._create_gateways() ])
 
+    async def _start_components(self) -> None:
+        await asyncio.gather(*[ component.start() for component in self._create_components() ])
+
+    async def _stop_components(self) -> None:
+        await asyncio.gather(*[ component.stop() for component in self._create_components() ])
+
+    async def _start_loggers(self) -> None:
+        await asyncio.gather(*[ logger.start() for logger in self._create_loggers() ])
+
+    async def _stop_loggers(self) -> None:
+        await asyncio.gather(*[ logger.stop() for logger in self._create_loggers() ])
+
     async def _start_webui(self) -> None:
         await asyncio.gather(*[ self._create_webui().start() ])
 
@@ -143,16 +155,19 @@ class ControllerEngine(AsyncService):
 
         return state
 
-    def _create_components(self) -> List[ComponentEngine]:
-        global_configs = self._get_component_global_configs()
-        return [ create_component(component_id, config, global_configs, self.daemon) for component_id, config in self.components.items() ]
-    
-    def _create_listeners(self) -> List[ListenerEngine]:
+    def _create_listeners(self) -> List[ListenerService]:
         return [ create_listener(f"listener-{index}", config, self.daemon) for index, config in enumerate(self.listeners) ]
     
-    def _create_gateways(self) -> List[GatewayEngine]:
+    def _create_gateways(self) -> List[GatewayService]:
         return [ create_gateway(f"gateway-{index}", config, self.daemon) for index, config in enumerate(self.gateways) ]
+
+    def _create_components(self) -> List[ComponentService]:
+        global_configs = self._get_component_global_configs()
+        return [ create_component(component_id, config, global_configs, self.daemon) for component_id, config in self.components.items() ]
     
+    def _create_loggers(self) -> List[LoggerService]:
+        return [ create_logger(f"logger-{index}", config, self.daemon) for index, config in enumerate(self.loggers) ]
+
     def _create_webui(self) -> ControllerWebUI:
         return ControllerWebUI(self.config.webui, self.config, self.components, self.workflows, self.daemon)
 
@@ -164,9 +179,9 @@ class ControllerEngine(AsyncService):
         return ComponentGlobalConfigs(self.components, self.listeners, self.gateways, self.workflows)
 
 def register_controller(type: ControllerType):
-    def decorator(cls: Type[ControllerEngine]) -> Type[ControllerEngine]:
+    def decorator(cls: Type[ControllerService]) -> Type[ControllerService]:
         ControllerRegistry[type] = cls
         return cls
     return decorator
 
-ControllerRegistry: Dict[ControllerType, Type[ControllerEngine]] = {}
+ControllerRegistry: Dict[ControllerType, Type[ControllerService]] = {}

{model_compose-0.2.6 → model_compose-0.2.7}/src/mindor/core/controller/controller.py

@@ -4,19 +4,21 @@ from mindor.dsl.schema.component import ComponentConfig
 from mindor.dsl.schema.listener import ListenerConfig
 from mindor.dsl.schema.gateway import GatewayConfig
 from mindor.dsl.schema.workflow import WorkflowConfig
-from .base import ControllerEngine, ControllerRegistry
+from mindor.dsl.schema.logger import LoggerConfig
+from .base import ControllerService, ControllerRegistry
 
 def create_controller(
-    config: ControllerConfig, 
+    config: ControllerConfig,
+    workflows: Dict[str, WorkflowConfig],
     components: Dict[str, ComponentConfig],
     listeners: List[ListenerConfig],
     gateways: List[GatewayConfig],
-    workflows: Dict[str, WorkflowConfig],
+    loggers: List[LoggerConfig],
     daemon: bool
-) -> ControllerEngine:
+) -> ControllerService:
     try:
         if not ControllerRegistry:
-            from . import engine
-        return ControllerRegistry[config.type](config, components, listeners, gateways, workflows, daemon)
+            from . import services
+        return ControllerRegistry[config.type](config, workflows, components, listeners, gateways, loggers, daemon)
     except KeyError:
         raise ValueError(f"Unsupported controller type: {config.type}")

{model_compose-0.2.6 → model_compose-0.2.7}/src/mindor/core/controller/runner/client.py

@@ -8,5 +8,9 @@ class ControllerClient(ABC):
         self.config: ControllerConfig = config
 
     @abstractmethod
-    async def run_workflow(self, workflow_id: Optional[str], input: Any, workflow: WorkflowSchema) -> Any:
+    async def run_workflow(self, workflow_id: Optional[str], input: Any) -> Any:
+        pass
+
+    @abstractmethod
+    async def close(self) -> None:
         pass

{model_compose-0.2.6 → model_compose-0.2.7}/src/mindor/core/controller/runner/http_client.py

@@ -2,7 +2,7 @@ from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annot
 from mindor.dsl.schema.controller import ControllerConfig
 from mindor.core.workflow.schema import WorkflowSchema
 from mindor.core.utils.http_client import HttpClient
-from .runner import ControllerClient
+from .client import ControllerClient
 from starlette.datastructures import UploadFile
 
 class HttpControllerClient(ControllerClient):

{model_compose-0.2.6 → model_compose-0.2.7}/src/mindor/core/controller/runner/mcp_client.py

@@ -7,7 +7,7 @@ from mindor.core.utils.streaming import StreamResource, FileStreamResource, Base
 from mindor.core.utils.streaming import encode_stream_to_base64
 from mindor.core.utils.http_client import create_stream_with_url
 from mindor.core.utils.image import load_image_from_stream
-from .runner import ControllerClient
+from .client import ControllerClient
 import json, os
 
 class McpControllerClient(ControllerClient):

{model_compose-0.2.6 → model_compose-0.2.7}/src/mindor/core/controller/runner/runner.py

@@ -6,18 +6,6 @@ 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
-
-    @abstractmethod
-    async def close(self) -> None:
-        pass
-
 class ControllerRunner:
     def __init__(self, config: ControllerConfig):
         self.config: ControllerConfig = config

{model_compose-0.2.6/src/mindor/core/controller/engine → model_compose-0.2.7/src/mindor/core/controller/services}/http_server.py

@@ -5,10 +5,11 @@ from mindor.dsl.schema.controller import HttpServerControllerConfig
 from mindor.dsl.schema.component import ComponentConfig
 from mindor.dsl.schema.listener import ListenerConfig
 from mindor.dsl.schema.gateway import GatewayConfig
+from mindor.dsl.schema.logger import LoggerConfig
 from mindor.dsl.schema.workflow import WorkflowConfig
 from mindor.core.utils.http_request import parse_request_body, parse_options_header
 from mindor.core.utils.streaming import StreamResource
-from ..base import ControllerEngine, ControllerType, TaskState, TaskStatus, register_controller
+from ..base import ControllerService, ControllerType, TaskState, TaskStatus, register_controller
 from fastapi import FastAPI, APIRouter, Request, Body, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import Response, JSONResponse, StreamingResponse
@@ -37,7 +38,7 @@ class TaskResult(BaseModel):
         )
 
 @register_controller(ControllerType.HTTP_SERVER)
-class HttpServerController(ControllerEngine):
+class HttpServerController(ControllerService):
     def __init__(
         self,
         config: HttpServerControllerConfig,
@@ -45,9 +46,10 @@ class HttpServerController(ControllerEngine):
         listeners: List[ListenerConfig],
         gateways: List[GatewayConfig],
         workflows: Dict[str, WorkflowConfig],
+        loggers: List[LoggerConfig],
         daemon: bool
     ):
-        super().__init__(config, components, listeners, gateways, workflows, daemon)
+        super().__init__(config, components, listeners, gateways, workflows, loggers, daemon)
 
         self.server: Optional[uvicorn.Server] = None
         self.app: FastAPI = FastAPI(openapi_url=None, docs_url=None, redoc_url=None)

{model_compose-0.2.6/src/mindor/core/controller/engine → model_compose-0.2.7/src/mindor/core/controller/services}/mcp_server.py

@@ -3,12 +3,13 @@ from mindor.dsl.schema.controller import McpServerControllerConfig
 from mindor.dsl.schema.component import ComponentConfig
 from mindor.dsl.schema.listener import ListenerConfig
 from mindor.dsl.schema.gateway import GatewayConfig
+from mindor.dsl.schema.logger import LoggerConfig
 from mindor.dsl.schema.workflow import WorkflowConfig, WorkflowVariableConfig, WorkflowVariableType, WorkflowVariableFormat
 from mindor.core.workflow.schema import WorkflowSchema, create_workflow_schema
 from mindor.core.utils.streaming import StreamResource, Base64StreamResource
 from mindor.core.utils.streaming import save_stream_to_temporary_file
 from mindor.core.utils.http_client import create_stream_with_url
-from ..base import ControllerEngine, ControllerType, TaskState, register_controller
+from ..base import ControllerService, ControllerType, TaskState, register_controller
 from mcp.server.fastmcp.server import FastMCP
 from mcp.types import TextContent, ImageContent, AudioContent
 import uvicorn, re, json
@@ -128,17 +129,18 @@ class WorkflowToolGenerator():
         return "str"
 
 @register_controller(ControllerType.MCP_SERVER)
-class McpServerController(ControllerEngine):
+class McpServerController(ControllerService):
     def __init__(
         self,
         config: McpServerControllerConfig,
+        workflows: Dict[str, WorkflowConfig],
         components: Dict[str, ComponentConfig],
         listeners: List[ListenerConfig],
         gateways: List[GatewayConfig],
-        workflows: Dict[str, WorkflowConfig],
+        loggers: List[LoggerConfig],
         daemon: bool
     ):
-        super().__init__(config, components, listeners, gateways, workflows, daemon)
+        super().__init__(config, workflows, components, listeners, gateways, loggers, daemon)
 
         self.server: Optional[uvicorn.Server] = None
         self.app: FastMCP = FastMCP(self.config.name, **{

{model_compose-0.2.6 → model_compose-0.2.7}/src/mindor/core/gateway/base.py

@@ -3,7 +3,7 @@ from abc import abstractmethod
 from mindor.dsl.schema.gateway import GatewayConfig, GatewayType
 from mindor.core.services import AsyncService
 
-class GatewayEngine(AsyncService):
+class GatewayService(AsyncService):
     def __init__(self, id: str, config: GatewayConfig, daemon: bool):
         super().__init__(daemon)
 
@@ -15,9 +15,9 @@ class GatewayEngine(AsyncService):
         pass
 
 def register_gateway(type: GatewayType):
-    def decorator(cls: Type[GatewayEngine]) -> Type[GatewayEngine]:
+    def decorator(cls: Type[GatewayService]) -> Type[GatewayService]:
         GatewayRegistry[type] = cls
         return cls
     return decorator
 
-GatewayRegistry: Dict[GatewayType, Type[GatewayEngine]] = {}
+GatewayRegistry: Dict[GatewayType, Type[GatewayService]] = {}