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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.2.11
+Version: 0.3.0
 Summary: model-compose: Declarative AI Model and Workflow Orchestrator
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT
@@ -20,10 +20,11 @@ Requires-Dist: pyngrok
 Requires-Dist: ulid
 Requires-Dist: gradio
 Requires-Dist: Pillow
-Requires-Dist: transformers
+Requires-Dist: transformers>=4.21.0
 Requires-Dist: torch
 Requires-Dist: sentencepiece
 Requires-Dist: accelerate
+Requires-Dist: docker
 Dynamic: license-file
 
 # model-compose: Declarative AI Model and Workflow Orchestrator

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

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.2.11"
+version = "0.3.0"
 description = "model-compose: Declarative AI Model and Workflow Orchestrator"
 authors = [
     { name = "Hanyeol Cho", email = "hanyeol.cho@gmail.com" }
@@ -21,10 +21,11 @@ dependencies = [
     "ulid", 
     "gradio",
     "Pillow",
-    "transformers",
+    "transformers>=4.21.0",
     "torch",
     "sentencepiece",
-    "accelerate"
+    "accelerate",
+    "docker"
 ]
 
 [project.scripts]
@@ -39,6 +40,10 @@ build-backend = "setuptools.build_meta"
 
 [tool.setuptools]
 package-dir = { "" = "src" }
+include-package-data = true
 
 [tool.setuptools.packages.find]
 where = ["src"]
+
+[tool.setuptools.package-data]
+"mindor.core.controller.runtime.docker" = ["context/*"]

{model_compose-0.2.11 → model_compose-0.3.0}/src/mindor/cli/compose.py

@@ -61,18 +61,20 @@ def up_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 down_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 shutdown_services(config)
+            await terminate_services(config, verbose)
         except Exception as e:
             click.echo(f"❌ {e}", err=True)
     asyncio.run(_async_command())
@@ -117,18 +119,20 @@ def start_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 stop_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 stop_services(config)
+            await stop_services(config, verbose)
         except Exception as e:
             click.echo(f"❌ {e}", err=True)
     asyncio.run(_async_command())
@@ -184,3 +188,6 @@ compose_command.add_command(down_command)
 compose_command.add_command(start_command)
 compose_command.add_command(stop_command)
 compose_command.add_command(run_command)
+
+if __name__ == "__main__":
+    compose_command()

{model_compose-0.2.11 → model_compose-0.3.0}/src/mindor/core/component/services/model/tasks/__init__.py

@@ -1,4 +1,5 @@
 from .text_generation import *
 from .summarization import *
 from .translation import *
+from .text_classification import *
 from .text_embedding import *

{model_compose-0.2.11 → model_compose-0.3.0}/src/mindor/core/component/services/model/tasks/summarization.py

@@ -16,7 +16,6 @@ class SummarizationTaskAction:
     async def run(self, context: ComponentActionContext) -> Any:
         text: Union[str, List[str]] = await context.render_variable(self.config.text)
 
-        # Model parameters
         max_input_length  = await context.render_variable(self.config.params.max_input_length)
         max_output_length = await context.render_variable(self.config.params.max_output_length)
         min_output_length = await context.render_variable(self.config.params.min_output_length)
@@ -24,28 +23,32 @@ class SummarizationTaskAction:
         length_penalty    = await context.render_variable(self.config.params.length_penalty)
         early_stopping    = await context.render_variable(self.config.params.early_stopping)
         do_sample         = await context.render_variable(self.config.params.do_sample)
+        batch_size        = await context.render_variable(self.config.params.batch_size)
 
-        # Tokenizing
-        inputs = self.tokenizer(text, return_tensors="pt", max_length=max_input_length, padding=True, truncation=True).to(self.model.device)
+        texts: List[str] = [ text ] if isinstance(text, str) else text
+        results = []
 
-        # Text Summarization
-        with torch.no_grad():
-            outputs = self.model.generate(
-                **inputs,
-                max_length=max_output_length,
-                min_length=min_output_length,
-                num_beams=num_beams,
-                length_penalty=length_penalty,
-                early_stopping=early_stopping,
-                do_sample=do_sample,
-                pad_token_id=getattr(self.tokenizer, "pad_token_id", None),
-                eos_token_id=getattr(self.tokenizer, "eos_token_id", None)
-            )
+        for index in range(0, len(texts), batch_size):
+            batch_texts = texts[index:index + batch_size]
+            inputs = self.tokenizer(batch_texts, return_tensors="pt", max_length=max_input_length, padding=True, truncation=True).to(self.model.device)
 
-        # Decoding output
-        outputs = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)
+            with torch.no_grad():
+                outputs = self.model.generate(
+                    **inputs,
+                    max_length=max_output_length,
+                    min_length=min_output_length,
+                    num_beams=num_beams,
+                    length_penalty=length_penalty,
+                    early_stopping=early_stopping,
+                    do_sample=do_sample,
+                    pad_token_id=getattr(self.tokenizer, "pad_token_id", None),
+                    eos_token_id=getattr(self.tokenizer, "eos_token_id", None)
+                )
+
+            outputs = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)
+            results.extend(outputs)
         
-        result = outputs if isinstance(text, list) else outputs[0] 
+        result = results if len(results) > 1 else results[0]
         context.register_source("result", result)
 
         return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result

model_compose-0.3.0/src/mindor/core/component/services/model/tasks/text_classification.py

@@ -0,0 +1,78 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.component import ModelComponentConfig
+from mindor.dsl.schema.action import ModelActionConfig, TextClassificationModelActionConfig
+from mindor.core.logger import logging
+from ..base import ModelTaskService, ModelTaskType, register_model_task_service
+from ..base import ComponentActionContext
+from transformers import AutoModelForSequenceClassification, AutoTokenizer, PreTrainedModel, PreTrainedTokenizer
+from transformers.modeling_outputs import SequenceClassifierOutput
+import torch.nn.functional as F
+import torch
+
+class TextClassificationTaskAction:
+    def __init__(self, config: TextClassificationModelActionConfig, model: PreTrainedModel, tokenizer: PreTrainedTokenizer):
+        self.config: TextClassificationModelActionConfig = config
+        self.model: PreTrainedModel = model
+        self.tokenizer: PreTrainedTokenizer = tokenizer
+
+    async def run(self, context: ComponentActionContext, labels: Optional[List[str]]) -> Any:
+        text: Union[str, List[str]] = await context.render_variable(self.config.text)
+
+        return_probabilities = await context.render_variable(self.config.params.return_probabilities)
+        batch_size           = await context.render_variable(self.config.params.batch_size)
+
+        texts: List[str] = [ text ] if isinstance(text, str) else text
+        results = []
+
+        for index in range(0, len(texts), batch_size):
+            batch_texts = texts[index:index + batch_size]
+            inputs = self.tokenizer(batch_texts, return_tensors="pt", padding=True, truncation=True).to(self.model.device)
+
+            with torch.no_grad():
+                outputs: SequenceClassifierOutput = self.model(**inputs)
+                logits = outputs.logits  # shape: (batch_size, num_classes)
+                
+                predicted = []
+                if return_probabilities:
+                    probs = F.softmax(logits, dim=-1).cpu()
+                    for prob in probs:
+                        predicted_index = torch.argmax(prob).item()
+                        predicted.append({
+                            "label": labels[predicted_index] if labels else predicted_index,
+                            "probabilities": prob.tolist()
+                        })
+                else:
+                    predicted_indices = torch.argmax(logits, dim=-1).tolist()
+                    for predicted_index in predicted_indices:
+                        predicted.append(labels[predicted_index] if labels else predicted_index)
+
+            results.extend(predicted)
+
+        result = results if len(results) > 1 else results[0]
+        context.register_source("result", result)
+
+        return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result
+
+@register_model_task_service(ModelTaskType.TEXT_CLASSIFICATION)
+class TextClassificationTaskService(ModelTaskService):
+    def __init__(self, id: str, config: ModelComponentConfig, daemon: bool):
+        super().__init__(id, config, daemon)
+
+        self.model: Optional[PreTrainedModel] = None
+        self.tokenizer: Optional[PreTrainedTokenizer] = None
+
+    async def _serve(self) -> None:
+        try:
+            self.model = AutoModelForSequenceClassification.from_pretrained(self.config.model).to(torch.device(self.config.device))
+            self.tokenizer = AutoTokenizer.from_pretrained(self.config.model, use_fast=self.config.fast_tokenizer)
+            logging.info(f"Model and tokenizer loaded successfully on device '{self.config.device}': {self.config.model}")
+        except Exception as e:
+            logging.error(f"Failed to load model '{self.config.model}': {e}")
+            raise
+
+    async def _shutdown(self) -> None:
+        self.model = None
+        self.tokenizer = None
+
+    async def _run(self, action: ModelActionConfig, context: ComponentActionContext) -> Any:
+        return await TextClassificationTaskAction(action, self.model, self.tokenizer).run(context, self.config.labels)

{model_compose-0.2.11 → model_compose-0.3.0}/src/mindor/core/component/services/model/tasks/text_embedding.py

@@ -16,29 +16,33 @@ class TextEmbeddingTaskAction:
         self.tokenizer: PreTrainedTokenizer = tokenizer
 
     async def run(self, context: ComponentActionContext) -> Any:
-        text = await context.render_variable(self.config.text)
+        text: Union[str, List[str]] = await context.render_variable(self.config.text)
 
-        # Model parameters
         max_input_length = await context.render_variable(self.config.params.max_input_length)
         pooling          = await context.render_variable(self.config.params.pooling)
         normalize        = await context.render_variable(self.config.params.normalize)
+        batch_size       = await context.render_variable(self.config.params.batch_size)
 
-        # Tokenizing
-        inputs = self.tokenizer(text, return_tensors="pt", max_length=max_input_length, padding=True, truncation=True).to(self.model.device)
-        attention_mask: Tensor = inputs.get("attention_mask", None)
+        texts: List[str] = [ text ] if isinstance(text, str) else text
+        results = []
 
-        # Forward pass through the model
-        with torch.no_grad():
-            outputs: BaseModelOutput = self.model(**inputs)
-            last_hidden_state = outputs.last_hidden_state  # (batch_size, seq_len, hidden_size)
+        for index in range(0, len(texts), batch_size):
+            batch_texts = texts[index:index + batch_size]
+            inputs = self.tokenizer(batch_texts, return_tensors="pt", max_length=max_input_length, padding=True, truncation=True).to(self.model.device)
+            attention_mask: Tensor = inputs.get("attention_mask", None)
 
-        # Apply pooling strategy (mean, cls, max)
-        embedding = self._pool_hidden_state(last_hidden_state, attention_mask, pooling)
+            with torch.no_grad():
+                outputs: BaseModelOutput = self.model(**inputs)
+                last_hidden_state = outputs.last_hidden_state  # (batch_size, seq_len, hidden_size)
 
-        if normalize:
-            embedding = torch.nn.functional.normalize(embedding, p=2, dim=1)
+            embeddings = self._pool_hidden_state(last_hidden_state, attention_mask, pooling)
 
-        result = embedding.squeeze().tolist()
+            if normalize:
+                embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)
+
+            results.extend(embeddings.cpu().tolist())
+
+        result = results if len(results) > 1 else results[0]
         context.register_source("result", result)
 
         return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result

{model_compose-0.2.11 → model_compose-0.3.0}/src/mindor/core/component/services/model/tasks/text_generation.py

@@ -16,32 +16,35 @@ class TextGenerationTaskAction:
     async def run(self, context: ComponentActionContext) -> Any:
         prompt: Union[str, List[str]] = await context.render_variable(self.config.prompt)
 
-        # Model parameters
         max_output_length    = await context.render_variable(self.config.params.max_output_length)
         num_return_sequences = await context.render_variable(self.config.params.num_return_sequences)
         temperature          = await context.render_variable(self.config.params.temperature)
         top_k                = await context.render_variable(self.config.params.top_k)
         top_p                = await context.render_variable(self.config.params.top_p)
+        batch_size           = await context.render_variable(self.config.params.batch_size)
 
-        # Tokenizing
-        inputs = self.tokenizer(prompt, return_tensors="pt").to(self.model.device)
+        prompts: List[str] = [ prompt ] if isinstance(prompt, str) else prompt
+        results = []
 
-        # Text generation
-        with torch.no_grad():
-            outputs = self.model.generate(
-                **inputs,
-                max_length=max_output_length,
-                num_return_sequences=num_return_sequences,
-                temperature=temperature,
-                top_k=top_k,
-                top_p=top_p,
-                do_sample=True
-            )
+        for index in range(0, len(prompts), batch_size):
+            batch_prompts = prompts[index:index + batch_size]
+            inputs = self.tokenizer(batch_prompts, return_tensors="pt").to(self.model.device)
 
-        # Decoding output
-        outputs = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)
-        
-        result = outputs if isinstance(prompt, list) else outputs[0] 
+            with torch.no_grad():
+                outputs = self.model.generate(
+                    **inputs,
+                    max_new_tokens=max_output_length,
+                    num_return_sequences=num_return_sequences,
+                    temperature=temperature,
+                    top_k=top_k,
+                    top_p=top_p,
+                    do_sample=True
+                )
+
+            outputs = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)
+            results.extend(outputs)
+
+        result = results if len(results) > 1 else results[0] 
         context.register_source("result", result)
 
         return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result

{model_compose-0.2.11 → model_compose-0.3.0}/src/mindor/core/component/services/model/tasks/translation.py

@@ -16,33 +16,36 @@ class TranslationTaskAction:
     async def run(self, context: ComponentActionContext) -> Any:
         text: Union[str, List[str]] = await context.render_variable(self.config.text)
 
-        # Model parameters
         max_input_length  = await context.render_variable(self.config.params.max_input_length)
         max_output_length = await context.render_variable(self.config.params.max_output_length)
         min_output_length = await context.render_variable(self.config.params.min_output_length)
         num_beams         = await context.render_variable(self.config.params.num_beams)
         length_penalty    = await context.render_variable(self.config.params.length_penalty)
+        batch_size        = await context.render_variable(self.config.params.batch_size)
 
-        # Tokenizing
-        inputs = self.tokenizer(text, return_tensors="pt", max_length=max_input_length, padding=True, truncation=True).to(self.model.device)
+        texts: List[str] = [ text ] if isinstance(text, str) else text
+        results = []
 
-        # Text Translation
-        with torch.no_grad():
-            outputs = self.model.generate(
-                **inputs,
-                max_length=max_output_length,
-                min_length=min_output_length,
-                num_beams=num_beams,
-                length_penalty=length_penalty,
-                do_sample=False,
-                pad_token_id=getattr(self.tokenizer, "pad_token_id", None),
-                eos_token_id=getattr(self.tokenizer, "eos_token_id", None)
-            )
+        for index in range(0, len(texts), batch_size):
+            batch_texts = texts[index:index + batch_size]
+            inputs = self.tokenizer(batch_texts, return_tensors="pt", max_length=max_input_length, padding=True, truncation=True).to(self.model.device)
 
-        # Decoding output
-        outputs = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)
+            with torch.no_grad():
+                outputs = self.model.generate(
+                    **inputs,
+                    max_length=max_output_length,
+                    min_length=min_output_length,
+                    num_beams=num_beams,
+                    length_penalty=length_penalty,
+                    do_sample=False,
+                    pad_token_id=getattr(self.tokenizer, "pad_token_id", None),
+                    eos_token_id=getattr(self.tokenizer, "eos_token_id", None)
+                )
+
+            outputs = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)
+            results.extend(outputs)
         
-        result = outputs if isinstance(text, list) else outputs[0] 
+        result = results if len(results) > 1 else results[0]
         context.register_source("result", result)
 
         return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result

{model_compose-0.2.11 → model_compose-0.3.0}/src/mindor/core/compose/compose.py

@@ -5,14 +5,14 @@ from .manager import ComposeManager, TaskState
 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 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)
 
-async def stop_services(config: ComposeConfig):
-    await ComposeManager(config, daemon=False).stop_services()
+async def stop_services(config: ComposeConfig, verbose: bool):
+    await ComposeManager(config, daemon=False).stop_services(verbose)
 
 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.11 → model_compose-0.3.0}/src/mindor/core/compose/manager.py

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

{model_compose-0.2.11 → model_compose-0.3.0}/src/mindor/core/controller/base.py

@@ -1,12 +1,14 @@
 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.logger import LoggerConfig, LoggerType, ConsoleLoggerConfig
 from mindor.dsl.schema.workflow import WorkflowConfig
+from mindor.dsl.schema.runtime import RuntimeType, DockerBuildConfig
+from mindor.dsl.schema.logger import LoggerConfig, LoggerType, ConsoleLoggerConfig
 from mindor.core.services import AsyncService
 from mindor.core.component import ComponentService, ComponentGlobalConfigs, create_component
 from mindor.core.listener import ListenerService, create_listener
@@ -16,6 +18,8 @@ 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
+from .runtime.specs import ControllerRuntimeSpecs
+from .runtime.docker import DockerRuntimeLauncher
 from threading import Lock
 import asyncio, ulid
 
@@ -58,6 +62,29 @@ class ControllerService(AsyncService):
         if self.config.max_concurrent_count > 0:
             self.queue = WorkQueue(self.config.max_concurrent_count, self._run_workflow)
 
+    async def launch(self, detach: bool, verbose: bool) -> None:
+        if self.config.runtime.type == RuntimeType.NATIVE:
+            if detach:
+                pass
+            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).launch(self._get_runtime_specs(), detach)
+            return
+
+    async def terminate(self, verbose: bool) -> None:
+        if self.config.runtime.type == RuntimeType.NATIVE:
+            await self.stop()
+            return
+        
+        if self.config.runtime.type == RuntimeType.DOCKER:
+            await self._start_loggers()
+            await DockerRuntimeLauncher(self.config, verbose).terminate()
+            return
+
     async def run_workflow(self, workflow_id: Optional[str], input: Dict[str, Any], wait_for_completion: bool = True) -> TaskState:
         task_id = ulid.ulid()
         state = TaskState(task_id=task_id, status=TaskStatus.PENDING)
@@ -138,23 +165,6 @@ class ControllerService(AsyncService):
     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=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)
-            state = TaskState(task_id=task_id, status=TaskStatus.COMPLETED, output=output)
-        except Exception as e:
-            state = TaskState(task_id=task_id, status=TaskStatus.FAILED, error=str(e))
-
-        with self.task_states_lock:
-            self.task_states.set(task_id, state, 1 * 3600)
-
-        return state
-
     def _create_listeners(self) -> List[ListenerService]:
         return [ create_listener(f"listener-{index}", config, self.daemon) for index, config in enumerate(self.listeners) ]
     
@@ -175,12 +185,32 @@ class ControllerService(AsyncService):
         global_configs = self._get_component_global_configs()
         return create_workflow(*WorkflowResolver(self.workflows).resolve(workflow_id), global_configs)
 
+    def _get_runtime_specs(self) -> ControllerRuntimeSpecs:
+        return ControllerRuntimeSpecs(self.config, self.components, self.listeners, self.gateways, self.workflows)
+
     def _get_component_global_configs(self) -> ComponentGlobalConfigs:
         return ComponentGlobalConfigs(self.components, self.listeners, self.gateways, self.workflows)
 
     def _get_default_logger_config(self) -> LoggerConfig:
         return ConsoleLoggerConfig(type=LoggerType.CONSOLE)
 
+    async def _run_workflow(self, task_id: str, workflow_id: Optional[str], input: Dict[str, Any]) -> TaskState:
+        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)
+            state = TaskState(task_id=task_id, status=TaskStatus.COMPLETED, output=output)
+        except Exception as e:
+            state = TaskState(task_id=task_id, status=TaskStatus.FAILED, error=str(e))
+
+        with self.task_states_lock:
+            self.task_states.set(task_id, state, 1 * 3600)
+
+        return state
+
 def register_controller(type: ControllerType):
     def decorator(cls: Type[ControllerService]) -> Type[ControllerService]:
         ControllerRegistry[type] = cls

model_compose-0.3.0/src/mindor/core/controller/runtime/docker/__init__.py

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

model_compose-0.3.0/src/mindor/core/controller/runtime/docker/context/Dockerfile

@@ -0,0 +1,42 @@
+FROM ubuntu:22.04
+
+WORKDIR /app
+
+RUN apt update && apt install -y \
+    python3.11 \
+    python3.11-venv \
+    python3-pip \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN ln -sf /usr/bin/python3.11 /usr/bin/python && \
+    ln -sf /usr/bin/python3.11 /usr/bin/python3
+
+RUN python -m pip install --upgrade pip
+RUN pip install --no-cache-dir \
+    click \
+    pyyaml \
+    pydantic \
+    python-dotenv \
+    aiohttp \
+    requests \
+    fastapi \
+    uvicorn \
+    'mcp>=1.10.1' \
+    pyngrok \
+    ulid \
+    gradio \
+    Pillow \
+    'transformers>=4.21.0' \
+    torch \
+    sentencepiece \
+    accelerate \
+    docker
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY src .
+COPY model-compose.yml .
+
+CMD [ "python", "-m", "mindor.cli.compose", "up" ]