model-compose 0.3.7__tar.gz → 0.3.9__tar.gz

{model_compose-0.3.7 → model_compose-0.3.9}/PKG-INFO

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

{model_compose-0.3.7 → model_compose-0.3.9}/pyproject.toml

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

{model_compose-0.3.7 → model_compose-0.3.9}/src/mindor/core/component/base.py

@@ -57,11 +57,11 @@ class ComponentService(AsyncService):
         if self.config.max_concurrent_count > 0:
             self.queue = WorkQueue(self.config.max_concurrent_count, self._run)
 
-    async def install(self) -> None:
-        await self._install()
+    async def setup(self) -> None:
+        await self._setup()
 
-    async def build(self) -> None:
-        await self._build()
+    async def teardown(self) -> None:
+        await self._teardown()
 
     async def run(self, action_id: Union[str, None], run_id: str, input: Dict[str, Any]) -> Dict[str, Any]:
         _, action = ActionResolver(self.config.actions).resolve(action_id)
@@ -72,10 +72,10 @@ class ComponentService(AsyncService):
 
         return await self._run(action, context)
 
-    async def _install(self) -> None:
+    async def _setup(self) -> None:
         pass
 
-    async def _build(self) -> None:
+    async def _teardown(self) -> None:
         pass
 
     async def _start(self) -> None:

{model_compose-0.3.7 → model_compose-0.3.9}/src/mindor/core/component/services/http_server.py

@@ -10,7 +10,7 @@ from mindor.core.utils.shell import run_command_streaming
 from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
 from ..context import ComponentActionContext
 from datetime import datetime, timezone
-import asyncio, os
+import asyncio
 
 class HttpServerCompletion(ABC):
     def __init__(self, config: HttpServerCompletionConfig):
@@ -104,13 +104,19 @@ class HttpServerComponent(ComponentService):
 
         self.client: Optional[HttpClient] = None
 
-    async def _install(self) -> None:
-        if self.config.commands.install:
-            await run_command_streaming(self.config.commands.install, self.config.working_dir, self.config.env)
+    async def _setup(self) -> None:
+        if self.config.manage.scripts.install:
+            for command in self.config.manage.scripts.install:
+                await run_command_streaming(command, self.config.manage.working_dir, self.config.manage.env)
 
-    async def _build(self) -> None:
-        if self.config.commands.build:
-            await run_command_streaming(self.config.commands.build, self.config.working_dir, self.config.env)
+        if self.config.manage.scripts.build:
+            for command in self.config.manage.scripts.build:
+                await run_command_streaming(command, self.config.manage.working_dir, self.config.manage.env)
+
+    async def _teardown(self):
+        if self.config.manage.scripts.clean:
+            for command in self.config.manage.scripts.clean:
+                await run_command_streaming(command, self.config.manage.working_dir, self.config.manage.env)
 
     async def _start(self) -> None:
         base_url = f"http://localhost:{self.config.port}" + (self.config.base_path or "")
@@ -123,8 +129,8 @@ class HttpServerComponent(ComponentService):
         self.client = None
 
     async def _serve(self) -> None:
-        if self.config.commands.start:
-            await run_command_streaming(self.config.commands.start, self.config.working_dir, self.config.env, block=False)
+        if self.config.manage.scripts.start:
+            await run_command_streaming(self.config.manage.scripts.start, self.config.manage.working_dir, self.config.manage.env, block=False)
 
     async def _shutdown(self) -> None:
         pass

model_compose-0.3.9/src/mindor/core/component/services/mcp_server.py

@@ -0,0 +1,70 @@
+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 mindor.core.utils.mcp_client import McpClient, ContentBlock, TextContent, ImageContent, AudioContent
+from mindor.core.utils.shell import run_command_streaming
+from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
+from ..context import ComponentActionContext
+
+class McpServerAction:
+    def __init__(self, config: McpServerActionConfig):
+        self.config: McpServerActionConfig = config
+
+    async def run(self, context: ComponentActionContext, client: McpClient) -> Any:
+        tool      = await context.render_variable(self.config.tool)
+        arguments = await context.render_variable(self.config.arguments)
+
+        response = [ await self._convert_output_value(content) for content in await client.call_tool(tool, arguments) ]
+        context.register_source("response", response)
+
+        return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else response
+
+    async def _convert_output_value(self, content: ContentBlock) -> Any:
+        if isinstance(content, TextContent):
+            return content.text
+
+        if isinstance(content, (ImageContent, AudioContent)):
+            return content.data
+
+        return None
+
+@register_component(ComponentType.MCP_SERVER)
+class McpServerComponent(ComponentService):
+    def __init__(self, id: str, config: McpServerComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
+        super().__init__(id, config, global_configs, daemon)
+
+        self.client: Optional[McpClient] = None 
+
+    async def _setup(self) -> None:
+        if self.config.manage.scripts.install:
+            for command in self.config.manage.scripts.install:
+                await run_command_streaming(command, self.config.manage.working_dir, self.config.manage.env)
+
+        if self.config.manage.scripts.build:
+            for command in self.config.manage.scripts.build:
+                await run_command_streaming(command, self.config.manage.working_dir, self.config.manage.env)
+
+    async def _teardown(self):
+        if self.config.manage.scripts.clean:
+            for command in self.config.manage.scripts.clean:
+                await run_command_streaming(command, self.config.manage.working_dir, self.config.manage.env)
+
+    async def _start(self) -> None:
+        base_url = f"http://localhost:{self.config.port}" + (self.config.base_path or "")
+        self.client = McpClient(base_url, self.config.headers)
+        await super()._start()
+
+    async def _stop(self) -> None:
+        await super()._stop()
+        await self.client.close()
+        self.client = None
+
+    async def _serve(self) -> None:
+        if self.config.manage.scripts.start:
+            await run_command_streaming(self.config.manage.scripts.start, self.config.manage.working_dir, self.config.manage.env, block=False)
+
+    async def _shutdown(self) -> None:
+        pass
+
+    async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
+        return await McpServerAction(action).run(context, self.client)

{model_compose-0.3.7 → model_compose-0.3.9}/src/mindor/core/component/services/shell.py

@@ -1,11 +1,10 @@
 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 mindor.core.utils.shell import run_command
+from mindor.core.utils.shell import run_command_streaming, run_command
 from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
 from ..context import ComponentActionContext
-from asyncio.subprocess import Process
-import asyncio, os
+import os
 
 class ShellAction:
     def __init__(self, config: ShellActionConfig, base_dir: Optional[str], env: Optional[Dict[str, str]]):
@@ -25,23 +24,12 @@ class ShellAction:
     async def _run_command(self, command: List[str], working_dir: str, env: Dict[str, str], timeout: Optional[float]) -> Dict[str, Any]:
         stdout, stderr, exit_code = await run_command(command, working_dir, env, timeout)
 
-        return { 
-            "stdout": stdout.decode().strip(), 
+        return {
+            "stdout": stdout.decode().strip(),
             "stderr": stderr.decode().strip(),
             "exit_code": exit_code
         }
 
-    async def _kill_process(self, process: Process) -> bool:
-        if process.returncode is None:
-            process.kill()
-            try:
-                await process.wait()
-            except Exception as e:
-                pass
-            return True
-        else:
-            return False
-
     async def _resolve_working_directory(self) -> str:
         working_dir = self.config.working_dir
 
@@ -60,5 +48,15 @@ class ShellComponent(ComponentService):
     def __init__(self, id: str, config: ShellComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
         super().__init__(id, config, global_configs, daemon)
 
+    async def _setup(self) -> None:
+        if self.config.manage.scripts.install:
+            for command in self.config.manage.scripts.install:
+                await run_command_streaming(command, self.config.manage.working_dir, self.config.manage.env)
+
+    async def _teardown(self):
+        if self.config.manage.scripts.clean:
+            for command in self.config.manage.scripts.clean:
+                await run_command_streaming(command, self.config.manage.working_dir, self.config.manage.env)
+
     async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
         return await ShellAction(action, self.config.base_dir, self.config.env).run(context)

{model_compose-0.3.7 → model_compose-0.3.9}/src/mindor/core/compose/compose.py

@@ -9,7 +9,7 @@ async def terminate_services(config: ComposeConfig, verbose: bool):
     await ComposeManager(config, daemon=False).terminate_services(verbose)
 
 async def start_services(config: ComposeConfig, verbose: bool):
-    await ComposeManager(config, daemon=False).start_services(verbose)
+    await ComposeManager(config, daemon=True).start_services(verbose)
 
 async def stop_services(config: ComposeConfig, verbose: bool):
     await ComposeManager(config, daemon=False).stop_services(verbose)

{model_compose-0.3.7 → model_compose-0.3.9}/src/mindor/core/compose/manager.py

@@ -16,16 +16,16 @@ class ComposeManager:
         )
 
     async def launch_services(self, detach: bool, verbose: bool):
-        await self.controller.launch(detach, verbose)
+        await self.controller.launch_services(detach, verbose)
 
     async def terminate_services(self, verbose: bool):
-        await self.controller.terminate(verbose)
+        await self.controller.terminate_services(verbose)
 
     async def start_services(self, verbose: bool):
-        await self.controller.start()
+        await self.controller.start_services(verbose)
 
     async def stop_services(self, verbose: bool):
-        await self.controller.stop()
+        await self.controller.stop_services(verbose)
 
     async def run_workflow(self, workflow_id: Optional[str], input: Dict[str, Any], output_path: Optional[str], verbose: bool) -> TaskState:
         if not self.controller.started:

{model_compose-0.3.7 → model_compose-0.3.9}/src/mindor/core/controller/base.py

@@ -1,13 +1,12 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from enum import Enum
 from dataclasses import dataclass
-from pydantic import BaseModel
 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.workflow import WorkflowConfig
-from mindor.dsl.schema.runtime import RuntimeType, DockerBuildConfig
+from mindor.dsl.schema.runtime import RuntimeType
 from mindor.dsl.schema.logger import LoggerConfig, LoggerType, ConsoleLoggerConfig
 from mindor.core.services import AsyncService
 from mindor.core.component import ComponentService, ComponentGlobalConfigs, create_component
@@ -20,9 +19,11 @@ from mindor.core.workflow.schema import WorkflowSchema, create_workflow_schemas
 from mindor.core.utils.workqueue import WorkQueue
 from mindor.core.utils.caching import ExpiringDict
 from .runtime.specs import ControllerRuntimeSpecs
+from .runtime.native import NativeRuntimeLauncher
 from .runtime.docker import DockerRuntimeLauncher
 from threading import Lock
-import asyncio, ulid
+from pathlib import Path
+import asyncio, ulid, os
 
 class TaskStatus(str, Enum):
     PENDING    = "pending"
@@ -64,10 +65,15 @@ class ControllerService(AsyncService):
         if self.config.max_concurrent_count > 0:
             self.task_queue = WorkQueue(self.config.max_concurrent_count, self._run_workflow)
 
-    async def launch(self, detach: bool, verbose: bool) -> None:
+    async def launch_services(self, detach: bool, verbose: bool) -> None:
         if self.config.runtime.type == RuntimeType.NATIVE:
             if detach:
-                pass
+                await self._start_loggers()
+                await NativeRuntimeLauncher().launch_detached()
+                await self._stop_loggers()
+                return
+
+            await self._setup_components()
             await self.start()
             await self.wait_until_stopped()
             return
@@ -75,16 +81,46 @@ class ControllerService(AsyncService):
         if self.config.runtime.type == RuntimeType.DOCKER:
             await self._start_loggers()
             await DockerRuntimeLauncher(self.config, verbose).launch(self._get_runtime_specs(), detach)
+            await self._stop_loggers()
             return
 
-    async def terminate(self, verbose: bool) -> None:
+    async def terminate_services(self, verbose: bool) -> None:
         if self.config.runtime.type == RuntimeType.NATIVE:
-            await self.stop()
+            await self._start_loggers()
+            await NativeRuntimeLauncher().stop()
+            await self._teardown_components()
+            await self._stop_loggers()
             return
-        
+
         if self.config.runtime.type == RuntimeType.DOCKER:
             await self._start_loggers()
             await DockerRuntimeLauncher(self.config, verbose).terminate()
+            await self._stop_loggers()
+            return
+
+    async def start_services(self, verbose: bool) -> None:
+        if self.config.runtime.type == RuntimeType.NATIVE:
+            await self.start()
+            await self.wait_until_stopped()
+            return
+
+        if self.config.runtime.type == RuntimeType.DOCKER:
+            await self._start_loggers()
+            await DockerRuntimeLauncher(self.config, verbose).start()
+            await self._stop_loggers()
+            return
+
+    async def stop_services(self, verbose: bool) -> None:
+        if self.config.runtime.type == RuntimeType.NATIVE:
+            await self._start_loggers()
+            await NativeRuntimeLauncher().stop()
+            await self._stop_loggers()
+            return
+
+        if self.config.runtime.type == RuntimeType.DOCKER:
+            await self._start_loggers()
+            await DockerRuntimeLauncher(self.config, verbose).stop()
+            await self._stop_loggers()
             return
 
     async def run_workflow(self, workflow_id: Optional[str], input: Dict[str, Any], wait_for_completion: bool = True) -> TaskState:
@@ -111,8 +147,9 @@ class ControllerService(AsyncService):
         if self.task_queue:
             await self.task_queue.start()
 
+        await self._start_loggers()
+
         if self.daemon:
-            await self._start_loggers()
             await self._start_gateways()
             await self._start_listeners()
             await self._start_components()
@@ -120,6 +157,8 @@ class ControllerService(AsyncService):
             if self.config.webui:
                 await self._start_webui()
 
+            asyncio.create_task(self._watch_stop_request())
+
         await super()._start()
 
     async def _stop(self) -> None:
@@ -130,13 +169,26 @@ class ControllerService(AsyncService):
             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 _on_stop(self) -> None:
+        await self._stop_loggers()
+
+    async def _watch_stop_request(self, interval: float = 1.0) -> None:
+        stop_file = Path.cwd() / ".stop"
+
+        while self.started:
+            if stop_file.exists():
+                await self.stop()
+                break
+            await asyncio.sleep(interval)
+
+        os.unlink(stop_file)
+
     async def _start_listeners(self) -> None:
         await asyncio.gather(*[ listener.start() for listener in self._create_listeners() ])
 
@@ -149,6 +201,12 @@ class ControllerService(AsyncService):
     async def _stop_gateways(self) -> None:
         await asyncio.gather(*[ gateway.stop() for gateway in self._create_gateways() ])
 
+    async def _setup_components(self) -> None:
+        await asyncio.gather(*[ component.setup() for component in self._create_components() ])
+
+    async def _teardown_components(self) -> None:
+        await asyncio.gather(*[ component.teardown() for component in self._create_components() ])
+
     async def _start_components(self) -> None:
         await asyncio.gather(*[ component.start() for component in self._create_components() ])
 
@@ -200,7 +258,7 @@ class ControllerService(AsyncService):
         state = TaskState(task_id=task_id, status=TaskStatus.PROCESSING)
         with self.task_states_lock:
             self.task_states.set(task_id, state)
-        
+
         try:
             workflow = self._create_workflow(workflow_id)
             output = await workflow.run(task_id, input)

{model_compose-0.3.7 → model_compose-0.3.9}/src/mindor/core/controller/runtime/docker/docker.py

@@ -14,7 +14,7 @@ class DockerRuntimeLauncher:
 
         self._configure_runtime_config()
 
-    def _configure_runtime_config(self):
+    def _configure_runtime_config(self) -> None:
         if not self.config.runtime.image:
             if not self.config.runtime.build:
                 self.config.runtime.build = DockerBuildConfig(context=".docker", dockerfile="Dockerfile")
@@ -26,7 +26,7 @@ class DockerRuntimeLauncher:
         if not self.config.runtime.ports:
             self.config.runtime.ports = [ port for port in [ self.config.port, getattr(self.config.webui, "port", None) ] if port ]
 
-    async def launch(self, specs: ControllerRuntimeSpecs, detach: bool):
+    async def launch(self, specs: ControllerRuntimeSpecs, detach: bool) -> None:
         docker = DockerRuntimeManager(self.config.runtime, self.verbose)
 
         await self._prepare_docker_context(specs)
@@ -58,7 +58,7 @@ class DockerRuntimeLauncher:
         logging.info("Starting Docker container (%s mode)...", "detached" if detach else "foreground")
         await docker.start_container(detach)
 
-    async def terminate(self):
+    async def terminate(self) -> None:
         docker = DockerRuntimeManager(self.config.runtime, self.verbose)
 
         if await docker.exists_container():
@@ -67,6 +67,12 @@ class DockerRuntimeLauncher:
         if await docker.exists_image():
             await docker.remove_image()
 
+    async def start(self) -> None:
+        pass
+
+    async def stop(self) -> None:
+        pass
+
     async def _prepare_docker_context(self, specs: ControllerRuntimeSpecs) -> None:
         # Prepare context directory
         context_dir = Path.cwd() / ".docker"

model_compose-0.3.9/src/mindor/core/controller/runtime/native/__init__.py

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

model_compose-0.3.9/src/mindor/core/controller/runtime/native/native.py

@@ -0,0 +1,24 @@
+from mindor.core.logger import logging
+from pathlib import Path
+import sys, os, subprocess
+
+class NativeRuntimeLauncher:
+    async def launch_detached(self) -> None:
+        command = [ sys.executable ] + [ arg for arg in sys.argv if arg not in ( "--detach", "-d" ) ]
+        env = os.environ.copy()
+
+        logging.debug(f"Detaching and spawning: %s", " ".join(command))
+
+        subprocess.Popen(
+            command,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            stdin=subprocess.DEVNULL,
+            env=env,
+            close_fds=True,
+            start_new_session=True,
+        )
+
+    async def stop(self) -> None:
+        stop_file = Path.cwd() / ".stop"
+        stop_file.touch()

{model_compose-0.3.7 → model_compose-0.3.9}/src/mindor/core/services/async_service.py

@@ -42,6 +42,8 @@ class AsyncService(ABC):
         if self.daemon_task:
             await self.daemon_task
 
+        await self._on_stop()
+
     def run_in_thread(self, runner: Callable[[], Awaitable[Any]]) -> asyncio.Future:
         loop = asyncio.get_running_loop()
         future: asyncio.Future = loop.create_future()
@@ -79,6 +81,9 @@ class AsyncService(ABC):
 
         self.started = False
 
+    async def _on_stop(self) -> None:
+        pass
+
     @abstractmethod
     async def _serve(self) -> None:
         pass

model_compose-0.3.9/src/mindor/dsl/schema/action/impl/mcp_server.py

@@ -0,0 +1,9 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+from .common import CommonActionConfig
+
+class McpServerActionConfig(CommonActionConfig):
+    tool: str = Field(default="__default__", description="Name of the tool to invoke.")
+    arguments: Dict[str, Any] = Field(default_factory=dict, description="Arguments to pass to the tool.")
+    headers: Dict[str, str] = Field(default_factory=dict, description="Optional HTTP headers to include in the tool call.")

{model_compose-0.3.7 → model_compose-0.3.9}/src/mindor/dsl/schema/component/impl/http_client.py

@@ -8,7 +8,7 @@ class HttpClientComponentConfig(CommonComponentConfig):
     type: Literal[ComponentType.HTTP_CLIENT]
     base_url: Optional[str] = Field(default=None, description="")
     headers: Dict[str, Any] = Field(default_factory=dict, description="")
-    actions: Dict[str, HttpClientActionConfig] = Field(default_factory=dict, description="")
+    actions: Dict[str, HttpClientActionConfig] = Field(default_factory=dict)
 
     @model_validator(mode="before")
     def inflate_single_action(cls, values: Dict[str, Any]):

model_compose-0.3.9/src/mindor/dsl/schema/component/impl/http_server.py

@@ -0,0 +1,52 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+from mindor.dsl.schema.action import HttpServerActionConfig
+from .common import ComponentType, CommonComponentConfig
+
+class HttpServerManageScripts(BaseModel):
+    install: Optional[List[List[str]]] = Field(default=None, description="One or more scripts to install dependencies.")
+    build: Optional[List[List[str]]] = Field(default=None, description="One or more scripts to build the server.")
+    clean: Optional[List[List[str]]] = Field(default=None, description="One or more scripts to clean the server environment.")
+    start: Optional[List[str]] = Field(default=None, description="Script to start the server.")
+
+    @model_validator(mode="before")
+    def normalize_scripts(cls, values):
+        for key in [ "install", "build", "clean" ]:
+            script = values.get(key)
+            if script and isinstance(script, list) and all(isinstance(token, str) for token in script):
+                values[key] = [ script ]
+        return values
+
+class HttpServerManageConfig(BaseModel):
+    scripts: HttpServerManageScripts = Field(..., description="Shell scripts used to install, build, clean, and start the server.")
+    working_dir: Optional[str] = Field(default=None, description="Working directory for the scripts.")
+    env: Dict[str, str] = Field(default_factory=dict, description="Environment variables to set when executing the scripts.")
+
+    @model_validator(mode="before")
+    def inflate_single_script(cls, values: Dict[str, Any]):
+        if "scripts" not in values:
+            values["scripts"] = { key: values.pop(key) for key in HttpServerManageScripts.model_fields.keys() if key in values }
+        return values
+
+class HttpServerComponentConfig(CommonComponentConfig):
+    type: Literal[ComponentType.HTTP_SERVER]
+    manage: HttpServerManageConfig = Field(default_factory=HttpServerManageConfig, description="Configuration used to manage the HTTP server lifecycle.")
+    port: int = Field(default=8000, ge=1, le=65535, description="Port on which the HTTP server will listen for incoming requests.")
+    base_path: Optional[str] = Field(default=None, description="Base path to prefix all HTTP routes exposed by this component.")
+    headers: Dict[str, Any] = Field(default_factory=dict, description="Headers to be included in all outgoing HTTP requests.")
+    actions: Dict[str, HttpServerActionConfig] = Field(default_factory=dict)
+
+    @model_validator(mode="before")
+    def inflate_single_script(cls, values: Dict[str, Any]):
+        if "manage" not in values:
+            values["manage"] = { key: values.pop(key) for key in HttpServerManageScripts.model_fields.keys() if key in values }
+        return values
+
+    @model_validator(mode="before")
+    def inflate_single_action(cls, values: Dict[str, Any]):
+        if "actions" not in values:
+            action_keys = set(HttpServerActionConfig.model_fields.keys())
+            if any(k in values for k in action_keys):
+                values["actions"] = { "__default__": { k: values.pop(k) for k in action_keys if k in values } }
+        return values

{model_compose-0.3.7 → model_compose-0.3.9}/src/mindor/dsl/schema/component/impl/mcp_client.py

@@ -8,7 +8,7 @@ class McpClientComponentConfig(CommonComponentConfig):
     type: Literal[ComponentType.MCP_CLIENT]
     url: str = Field(..., description="URL of the MCP server to invoke tools.")
     headers: Dict[str, Any] = Field(default_factory=dict, description="")
-    actions: Dict[str, McpClientActionConfig] = Field(default_factory=dict, description="")
+    actions: Dict[str, McpClientActionConfig] = Field(default_factory=dict)
 
     @model_validator(mode="before")
     def inflate_single_action(cls, values: Dict[str, Any]):

model_compose-0.3.9/src/mindor/dsl/schema/component/impl/mcp_server.py

@@ -0,0 +1,51 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+from mindor.dsl.schema.action import McpServerActionConfig
+from .common import ComponentType, CommonComponentConfig
+
+class McpServerManageScripts(BaseModel):
+    install: Optional[List[List[str]]] = Field(default=None, description="One or more scripts to install dependencies.")
+    build: Optional[List[List[str]]] = Field(default=None, description="One or more scripts to build the server.")
+    clean: Optional[List[List[str]]] = Field(default=None, description="One or more scripts to clean the server environment.")
+    start: Optional[List[str]] = Field(default=None, description="Script to start the server.")
+
+    @model_validator(mode="before")
+    def normalize_scripts(cls, values):
+        for key in [ "install", "build", "clean" ]:
+            script = values.get(key)
+            if script and isinstance(script, list) and all(isinstance(token, str) for token in script):
+                values[key] = [ script ]
+        return values
+
+class McpServerManageConfig(BaseModel):
+    scripts: McpServerManageScripts = Field(..., description="Shell scripts used to install, build, clean, and start the server.")
+    working_dir: Optional[str] = Field(default=None, description="Working directory for the scripts.")
+    env: Dict[str, str] = Field(default_factory=dict, description="Environment variables to set when executing the scripts.")
+
+    @model_validator(mode="before")
+    def inflate_single_script(cls, values: Dict[str, Any]):
+        if "scripts" not in values:
+            values["scripts"] = { key: values.pop(key) for key in McpServerManageScripts.model_fields.keys() if key in values }
+        return values
+
+class McpServerComponentConfig(CommonComponentConfig):
+    type: Literal[ComponentType.MCP_SERVER]
+    manage: McpServerManageConfig = Field(default_factory=McpServerManageConfig, description="Configuration used to manage the MCP server lifecycle.")
+    port: int = Field(default=8000, ge=1, le=65535, description="Port on which the MCP server will listen for incoming requests.")
+    base_path: Optional[str] = Field(default=None, description="Base path to prefix all MCP routes exposed by this component.")
+    actions: Dict[str, McpServerActionConfig] = Field(default_factory=dict)
+
+    @model_validator(mode="before")
+    def inflate_single_script(cls, values: Dict[str, Any]):
+        if "manage" not in values:
+            values["manage"] = { key: values.pop(key) for key in McpServerManageScripts.model_fields.keys() if key in values }
+        return values
+
+    @model_validator(mode="before")
+    def inflate_single_action(cls, values: Dict[str, Any]):
+        if "actions" not in values:
+            action_keys = set(McpServerActionConfig.model_fields.keys())
+            if any(k in values for k in action_keys):
+                values["actions"] = { "__default__": { k: values.pop(k) for k in action_keys if k in values } }
+        return values

{model_compose-0.3.7 → model_compose-0.3.9}/src/mindor/dsl/schema/component/impl/model/impl/summarization.py

@@ -6,4 +6,4 @@ from .common import CommonModelComponentConfig, ModelTaskType
 
 class SummarizationModelComponentConfig(CommonModelComponentConfig):
     task: Literal[ModelTaskType.SUMMARIZATION]
-    actions: Dict[str, SummarizationModelActionConfig] = Field(default_factory=dict, description="")
+    actions: Dict[str, SummarizationModelActionConfig] = Field(default_factory=dict)

{model_compose-0.3.7 → model_compose-0.3.9}/src/mindor/dsl/schema/component/impl/model/impl/text_classification.py

@@ -6,4 +6,4 @@ from .common import ClassificationModelComponentConfig, ModelTaskType
 
 class TextClassificationModelComponentConfig(ClassificationModelComponentConfig):
     task: Literal[ModelTaskType.TEXT_CLASSIFICATION]
-    actions: Dict[str, TextClassificationModelActionConfig] = Field(default_factory=dict, description="")
+    actions: Dict[str, TextClassificationModelActionConfig] = Field(default_factory=dict)