model-compose 0.4.31__tar.gz → 0.4.32__tar.gz

{model_compose-0.4.31 → model_compose-0.4.32}/PKG-INFO

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

{model_compose-0.4.31 → model_compose-0.4.32}/pyproject.toml

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

{model_compose-0.4.31 → model_compose-0.4.32}/src/mindor/core/controller/adapters/services/mcp_server.py

@@ -67,7 +67,7 @@ class McpServerControllerAdapterService(ControllerAdapterService):
             annotations=None
         )
 
-    async def _run_workflow_as_tool(self, workflow_id: Optional[str], input: Any) -> List[ContentBlock]:
+    async def _run_workflow_as_tool(self, workflow_id: Optional[str], input: Any, context: Any = None) -> List[ContentBlock]:
         state = await self.controller.run_workflow(workflow_id, input, wait_for_completion=True)
         return await self._build_state_response(state)
 
@@ -85,17 +85,17 @@ class McpServerControllerAdapterService(ControllerAdapterService):
             }))]
 
         if state.status == TaskStatus.FAILED:
-            return [TextContent(type="text", text=json.dumps({"status": "failed", "error": state.error}))]
+            return [ TextContent(type="text", text=json.dumps({"status": "failed", "error": state.error})) ]
 
         workflow = self.controller.workflow_schemas.get(state.workflow_id) if state.workflow_id else None
         if workflow:
             return await self._build_output_value(state, workflow)
 
         if state.output is None:
-            return [TextContent(type="text", text=json.dumps({"status": "completed"}))]
+            return [ TextContent(type="text", text=json.dumps({"status": "completed"})) ]
         if isinstance(state.output, (dict, list)):
-            return [TextContent(type="text", text=json.dumps(state.output))]
-        return [TextContent(type="text", text=str(state.output))]
+            return [ TextContent(type="text", text=json.dumps(state.output)) ]
+        return [ TextContent(type="text", text=str(state.output)) ]
 
     async def _build_output_value(self, state: TaskState, workflow: WorkflowSchema) -> List[ContentBlock]:
         output: List[ContentBlock] = []

{model_compose-0.4.31 → model_compose-0.4.32}/src/mindor/core/controller/base.py

@@ -29,6 +29,7 @@ from mindor.core.utils.time import parse_duration
 from .runtime.specs import ControllerRuntimeSpecs
 from .runtime.native import NativeRuntimeLauncher
 from .runtime.docker import DockerRuntimeLauncher
+from .runtime.apple_container import AppleContainerRuntimeLauncher
 from threading import Lock
 from pathlib import Path
 import asyncio, ulid, os, logging, threading
@@ -140,6 +141,12 @@ class ControllerService(AsyncService):
             await self._stop_loggers()
             return
 
+        if self.config.runtime.type == RuntimeType.APPLE_CONTAINER:
+            await self._start_loggers()
+            await AppleContainerRuntimeLauncher(self.config, verbose).launch(self._get_runtime_specs(), detach)
+            await self._stop_loggers()
+            return
+
     async def terminate_services(self, verbose: bool) -> None:
         if self.config.runtime.type == RuntimeType.NATIVE:
             await self._start_loggers(verbose)
@@ -157,6 +164,12 @@ class ControllerService(AsyncService):
             await self._stop_loggers()
             return
 
+        if self.config.runtime.type == RuntimeType.APPLE_CONTAINER:
+            await self._start_loggers()
+            await AppleContainerRuntimeLauncher(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_loggers(verbose)
@@ -175,6 +188,12 @@ class ControllerService(AsyncService):
             await self._stop_loggers()
             return
 
+        if self.config.runtime.type == RuntimeType.APPLE_CONTAINER:
+            await self._start_loggers()
+            await AppleContainerRuntimeLauncher(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(verbose)
@@ -188,6 +207,12 @@ class ControllerService(AsyncService):
             await self._stop_loggers()
             return
 
+        if self.config.runtime.type == RuntimeType.APPLE_CONTAINER:
+            await self._start_loggers()
+            await AppleContainerRuntimeLauncher(self.config, verbose).stop()
+            await self._stop_loggers()
+            return
+
     async def run_workflow(
         self,
         workflow_id: str,

model_compose-0.4.32/src/mindor/core/controller/runtime/apple_container/__init__.py

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

model_compose-0.4.32/src/mindor/core/controller/runtime/apple_container/apple_container.py

@@ -0,0 +1,127 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.controller import ControllerConfig
+from mindor.dsl.schema.runtime import AppleContainerRuntimeConfig, AppleContainerBuildConfig, AppleContainerVolumeConfig
+from mindor.core.runtime.apple_container import AppleContainerRuntimeManager
+from mindor.core.logger import logging
+from ..specs import ControllerRuntimeSpecs
+from pathlib import Path
+import mindor, shutil, yaml, os
+
+class AppleContainerRuntimeLauncher:
+    def __init__(self, config: ControllerConfig, verbose: bool):
+        self.config: ControllerConfig = config
+        self.verbose: bool = verbose
+
+        self._configure_runtime_config()
+
+    def _configure_runtime_config(self) -> None:
+        adapter_ports = [ adapter.port for adapter in self.config.adapters if hasattr(adapter, 'port') ]
+        first_port = adapter_ports[0] if adapter_ports else 8080
+
+        if not self.config.runtime.image:
+            if not self.config.runtime.build:
+                self.config.runtime.build = AppleContainerBuildConfig(context=".container", dockerfile="Dockerfile")
+            self.config.runtime.image = f"mindor/controller-{first_port}:latest"
+
+        if not self.config.runtime.container_name:
+            self.config.runtime.container_name = self.config.name or f"mindor-controller-{first_port}"
+
+        if not self.config.runtime.ports:
+            webui_port = getattr(self.config.webui, "port", None)
+            self.config.runtime.ports = list(set(adapter_ports + ([webui_port] if webui_port else [])))
+
+    async def launch(self, specs: ControllerRuntimeSpecs, detach: bool) -> None:
+        manager = AppleContainerRuntimeManager(self.config.runtime, self.verbose)
+
+        await self._prepare_build_context(specs)
+
+        if not await manager.exists_image():
+            logging.debug("Checking if container image can be pulled...")
+            try:
+                await manager.pull_image()
+            except Exception as e:
+                logging.debug("Container image pull failed: %s — will try building instead.", e)
+            else:
+                if not await manager.exists_image():
+                    raise RuntimeError("Container image pull completed, but image is still missing.")
+                logging.info("Container image pulled successfully.")
+
+        if not await manager.exists_image():
+            logging.debug("Building container image locally. This may take a few minutes...")
+            try:
+                await manager.build_image()
+                logging.info("Container image build completed successfully.")
+            except Exception as e:
+                logging.error("Container image build failed: %s", e)
+                raise
+
+        # Create volumes and setup DNS (Apple Container specific)
+        await manager.create_volumes()
+        await manager.setup_dns()
+
+        if await manager.is_container_running():
+            logging.info("Stopping running container before restarting...")
+            await manager.stop_container()
+
+        logging.info("Starting container (%s mode)...", "detached" if detach else "foreground")
+        await manager.start_container(detach)
+
+    async def terminate(self) -> None:
+        manager = AppleContainerRuntimeManager(self.config.runtime, self.verbose)
+
+        if await manager.exists_container():
+            await manager.remove_container(force=True)
+
+        if await manager.exists_image():
+            await manager.remove_image()
+
+    async def start(self) -> None:
+        pass
+
+    async def stop(self) -> None:
+        pass
+
+    async def _prepare_build_context(self, specs: ControllerRuntimeSpecs) -> None:
+        context_dir = Path.cwd() / ".container"
+        if context_dir.exists():
+            shutil.rmtree(context_dir)
+
+        # Copy source files
+        source_files_root = Path(mindor.__file__).resolve().parent
+        target_dir = context_dir / "src" / source_files_root.name
+        shutil.copytree(
+            src=source_files_root,
+            dst=target_dir,
+            ignore=shutil.ignore_patterns("__pycache__", "*.pyc")
+        )
+
+        # Copy or generate requirements.txt
+        file_path = Path.cwd() / "requirements.txt"
+        target_path = Path(context_dir) / file_path.name
+        if file_path.exists():
+            shutil.copy(file_path, target_path)
+        else:
+            target_path.touch()
+
+        # Copy or generate webui directory
+        Path(context_dir / "webui").mkdir(parents=True, exist_ok=True)
+
+        if getattr(self.config.webui, "server_dir", None):
+            server_dir = Path.cwd() / self.config.webui.server_dir
+            target_dir = context_dir / "webui" / "server"
+            shutil.copytree(
+                src=server_dir,
+                dst=target_dir
+            )
+
+        if getattr(self.config.webui, "static_dir", None):
+            static_dir = Path.cwd() / self.config.webui.static_dir
+            target_dir = context_dir / "webui" / "static"
+            shutil.copytree(
+                src=static_dir,
+                dst=target_dir
+            )
+
+        # Generate model-compose.yml
+        with open(context_dir / "model-compose.yml", "w") as f:
+            yaml.dump(specs.generate_native_runtime_specs(), f, sort_keys=False)

{model_compose-0.4.31 → model_compose-0.4.32}/src/mindor/core/controller/runtime/docker/context/Dockerfile

@@ -27,7 +27,9 @@ RUN pip install --no-cache-dir \
     pyngrok \
     ulid \
     gradio \
-    Pillow
+    Pillow \
+    beautifulsoup4 \
+    lxml
 
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt

{model_compose-0.4.31 → model_compose-0.4.32}/src/mindor/core/foundation/process_manager.py

@@ -1,5 +1,4 @@
 from typing import Any, Dict, Optional, Callable
-from mindor.core.logger import logging
 from .ipc_messages import IpcMessage, IpcMessageType
 from .process_worker import ProcessWorkerParams
 from multiprocessing import Process, Queue
@@ -55,7 +54,6 @@ class ProcessRuntimeManager:
                 os.environ[key] = value
 
         self.subprocess.start()
-        logging.info(f"Started subprocess for worker {self.worker_id} (PID: {self.subprocess.pid})")
 
         await self._wait_for_ready()
 
@@ -65,8 +63,6 @@ class ProcessRuntimeManager:
 
     async def stop(self) -> None:
         """Stop the subprocess"""
-        logging.info(f"Stopping subprocess for worker {self.worker_id}")
-
         stop_message = IpcMessage(
             type=IpcMessageType.STOP,
             request_id=str(uuid.uuid4())
@@ -76,11 +72,9 @@ class ProcessRuntimeManager:
         try:
             self.subprocess.join(timeout=self.worker_params.stop_timeout)
         except TimeoutError:
-            logging.warning(f"Process {self.worker_id} did not stop gracefully, terminating")
             self.subprocess.terminate()
             self.subprocess.join(timeout=5)
             if self.subprocess.is_alive():
-                logging.error(f"Process {self.worker_id} did not terminate, killing")
                 self.subprocess.kill()
 
         if self.response_handler_task:
@@ -125,8 +119,8 @@ class ProcessRuntimeManager:
                 await asyncio.sleep(0.01)
             except asyncio.CancelledError:
                 break
-            except Exception as e:
-                logging.error(f"Error handling response: {e}")
+            except Exception:
+                pass
 
     async def _wait_for_ready(self) -> None:
         """Wait for subprocess to be ready"""
@@ -138,9 +132,12 @@ class ProcessRuntimeManager:
                 message = IpcMessage(**self.response_queue.get())
 
                 if message.type == IpcMessageType.STATUS and message.payload.get("status") == "ready":
-                    logging.info(f"Subprocess {self.worker_id} is ready")
                     return
 
+                if message.type == IpcMessageType.ERROR:
+                    error = message.payload.get("error", "Unknown error") if message.payload else "Unknown error"
+                    raise RuntimeError(f"Process {self.worker_id} failed to start: {error}")
+
             await asyncio.sleep(0.5)
 
         raise TimeoutError(f"Process {self.worker_id} did not start within {timeout}s")

model_compose-0.4.32/src/mindor/core/runtime/apple_container/__init__.py

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

model_compose-0.4.32/src/mindor/core/runtime/apple_container/apple_container.py

@@ -0,0 +1,222 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.runtime import AppleContainerRuntimeConfig, AppleContainerBuildConfig, AppleContainerVolumeConfig
+from mindor.core.logger import logging
+import sys, asyncio, signal
+
+class AppleContainerPortsResolver:
+    def __init__(self, ports: Optional[List[Union[str, int]]]):
+        self.ports: Optional[List[Union[str, int]]] = ports
+
+    def resolve(self) -> List[str]:
+        args: List[str] = []
+        for port in self.ports or []:
+            if isinstance(port, int):
+                args.extend([ "-p", f"{port}:{port}" ])
+                continue
+            if isinstance(port, str):
+                args.extend([ "-p", port ])
+                continue
+        return args
+
+class AppleContainerMountsResolver:
+    def __init__(self, volumes: Optional[List[Union[str, AppleContainerVolumeConfig]]]):
+        self.volumes: Optional[List[Union[str, AppleContainerVolumeConfig]]] = volumes
+
+    def resolve(self) -> List[str]:
+        args: List[str] = []
+        for volume in self.volumes or []:
+            if isinstance(volume, str):
+                args.extend([ "--volume", volume ])
+                continue
+            if isinstance(volume, AppleContainerVolumeConfig):
+                mount_str = f"{volume.name}:{volume.target}"
+                args.extend([ "--volume", mount_str ])
+                continue
+        return args
+
+class AppleContainerRuntimeManager:
+    def __init__(self, config: AppleContainerRuntimeConfig, verbose: bool):
+        self.config: AppleContainerRuntimeConfig = config
+        self.verbose: bool = verbose
+        self._shutdown_event: asyncio.Event = asyncio.Event()
+
+    # ===== Container Lifecycle =====
+
+    async def start_container(self, detach: bool) -> None:
+        args = ["run"]
+
+        if self.config.container_name:
+            args.extend(["--name", self.config.container_name])
+
+        if detach:
+            args.append("-d")
+
+        args.extend(AppleContainerPortsResolver(self.config.ports).resolve())
+        args.extend(AppleContainerMountsResolver(self.config.volumes).resolve())
+
+        for key, value in (self.config.environment or {}).items():
+            args.extend(["-e", f"{key}={value}"])
+
+        if self.config.cpus is not None:
+            args.extend(["--cpus", str(self.config.cpus)])
+        if self.config.mem_limit is not None:
+            args.extend(["--memory", self.config.mem_limit])
+
+        args.append(self.config.image)
+
+        if self.config.command:
+            if isinstance(self.config.command, str):
+                args.append(self.config.command)
+            else:
+                args.extend(self.config.command)
+
+        await self._run_command(args, capture_output=detach)
+
+        if not detach:
+            await self._run_foreground_container()
+
+    async def stop_container(self) -> None:
+        try:
+            await self._run_command(["stop", self.config.container_name])
+        except RuntimeError as e:
+            logging.warning("Failed to stop container '%s': %s", self.config.container_name, e)
+
+    async def remove_container(self, force: bool = False) -> None:
+        args = ["rm"]
+        if force:
+            args.append("-f")
+        args.append(self.config.container_name)
+
+        try:
+            await self._run_command(args)
+        except RuntimeError:
+            pass
+
+    async def is_container_running(self) -> bool:
+        try:
+            process = await self._run_command(["ls"], check=False)
+            stdout, _ = await process.communicate()
+            return self.config.container_name in stdout.decode()
+        except Exception:
+            return False
+
+    async def exists_container(self) -> bool:
+        try:
+            process = await self._run_command(["ls"], check=False)
+            stdout, _ = await process.communicate()
+            return self.config.container_name in stdout.decode()
+        except Exception:
+            return False
+
+    # ===== Image Management =====
+
+    async def build_image(self) -> None:
+        if not self.config.build:
+            raise RuntimeError("Build configuration is required")
+
+        args = ["build"]
+
+        if self.config.image:
+            args.extend(["-t", self.config.image])
+
+        if self.config.build.dockerfile:
+            args.extend(["-f", self.config.build.dockerfile])
+
+        for key, value in (self.config.build.args or {}).items():
+            args.extend(["--build-arg", f"{key}={value}"])
+
+        args.append(self.config.build.context or ".")
+
+        await self._run_command(args, capture_output=False)
+
+    async def pull_image(self) -> None:
+        await self._run_command(["image", "pull", self.config.image], capture_output=False)
+
+    async def remove_image(self, force: bool = False) -> None:
+        try:
+            await self._run_command(["image", "rm", self.config.image])
+        except RuntimeError:
+            pass
+
+    async def exists_image(self) -> bool:
+        try:
+            process = await self._run_command(["image", "ls"], check=False)
+            stdout, _ = await process.communicate()
+            return self.config.image in stdout.decode()
+        except Exception:
+            return False
+
+    # ===== DNS Management =====
+
+    async def setup_dns(self) -> None:
+        if not self.config.dns:
+            return
+
+        try:
+            await self._run_command(
+                ["system", "dns", "create", self.config.dns.domain]
+            )
+            logging.info(
+                "DNS domain '%s' created. Container accessible at: %s.%s",
+                self.config.dns.domain,
+                self.config.dns.hostname or self.config.container_name,
+                self.config.dns.domain
+            )
+        except RuntimeError as e:
+            logging.warning("Failed to setup DNS: %s", e)
+
+    # ===== Volume Management =====
+
+    async def create_volumes(self) -> None:
+        for volume in self.config.volumes or []:
+            if isinstance(volume, AppleContainerVolumeConfig):
+                try:
+                    await self._run_command(["volume", "create", volume.name])
+                except RuntimeError:
+                    pass  # may already exist
+
+    # ===== Private Helpers =====
+
+    async def _run_command(
+        self,
+        args: List[str],
+        check: bool = True,
+        capture_output: bool = True
+    ) -> asyncio.subprocess.Process:
+        command = ["container"] + args
+
+        logging.debug("Running: %s", " ".join(command))
+
+        process = await asyncio.create_subprocess_exec(
+            *command,
+            stdout=asyncio.subprocess.PIPE if capture_output else sys.stdout,
+            stderr=asyncio.subprocess.PIPE if capture_output else sys.stderr
+        )
+
+        if check:
+            stdout, stderr = await process.communicate()
+            if process.returncode != 0:
+                error_msg = stderr.decode() if stderr else "Unknown error"
+                raise RuntimeError(
+                    f"Command '{' '.join(command)}' failed (exit {process.returncode}): {error_msg}"
+                )
+
+        return process
+
+    async def _run_foreground_container(self) -> None:
+        self._register_shutdown_signals()
+
+        await self._shutdown_event.wait()
+
+        logging.info(
+            "Stopping container '%s' gracefully...",
+            self.config.container_name
+        )
+        await self.stop_container()
+
+    def _register_shutdown_signals(self) -> None:
+        signal.signal(signal.SIGINT,  self._handle_shutdown_signal)
+        signal.signal(signal.SIGTERM, self._handle_shutdown_signal)
+
+    def _handle_shutdown_signal(self, signum, frame) -> None:
+        self._shutdown_event.set()

{model_compose-0.4.31 → model_compose-0.4.32}/src/mindor/dsl/schema/action/impl/http_client.py

@@ -20,7 +20,7 @@ class HttpClientPollingCompletionConfig(HttpClientCommonCompletionConfig):
     method: Literal[ "GET", "POST", "PUT", "DELETE", "PATCH" ] = Field(default="GET", description="HTTP method for polling requests.")
     headers: Dict[str, str] = Field(default_factory=dict, description="HTTP headers to include in polling requests.")
     body: Dict[str, Any] = Field(default_factory=dict, description="Request body data for polling requests.")
-    params: Dict[str, str] = Field(default_factory=dict, description="URL query parameters for polling requests.")
+    params: Dict[str, Any] = Field(default_factory=dict, description="URL query parameters for polling requests.")
     status: Optional[str] = Field(default=None, description="Field path to check for completion status in polling response.")
     success_when: Optional[List[Union[int, str]]] = Field(default=None, description="Status codes or values that indicate successful completion.")
     fail_when: Optional[List[Union[int, str]]] = Field(default=None, description="Status codes or values that indicate failed completion.")
@@ -58,7 +58,7 @@ class HttpClientActionConfig(CommonActionConfig):
     method: Literal[ "GET", "POST", "PUT", "DELETE", "PATCH" ] = Field(default="POST", description="HTTP method to use for the request")
     headers: Dict[str, str] = Field(default_factory=dict, description="HTTP headers to include in the request")
     body: Dict[str, Any] = Field(default_factory=dict, description="Request body data to send with the HTTP request")
-    params: Dict[str, str] = Field(default_factory=dict, description="URL query parameters to append to the request")
+    params: Dict[str, Any] = Field(default_factory=dict, description="URL query parameters to append to the request")
     stream_format: Optional[HttpStreamFormat] = Field(default=None, description="Format of stream payload.")
     completion: Optional[HttpClientCompletionConfig] = Field(default=None, description="Configuration for handling asynchronous request completion via polling or callbacks")
 

{model_compose-0.4.31 → model_compose-0.4.32}/src/mindor/dsl/schema/action/impl/http_server.py

@@ -19,7 +19,7 @@ class HttpServerPollingCompletionConfig(HttpServerCommonCompletionConfig):
     method: Literal[ "GET", "POST", "PUT", "DELETE", "PATCH" ] = Field(default="GET", description="HTTP method for polling completion status.")
     headers: Dict[str, str] = Field(default_factory=dict, description="HTTP headers to include in polling requests.")
     body: Dict[str, Any] = Field(default_factory=dict, description="Request body data for polling requests.")
-    params: Dict[str, str] = Field(default_factory=dict, description="URL query parameters for polling requests.")
+    params: Dict[str, Any] = Field(default_factory=dict, description="URL query parameters for polling requests.")
     status: Optional[str] = Field(default=None, description="Field path to check for completion status in polling response.")
     success_when: Optional[List[Union[int, str]]] = Field(default=None, description="Status codes or values that indicate successful completion.")
     fail_when: Optional[List[Union[int, str]]] = Field(default=None, description="Status codes or values that indicate failed completion.")
@@ -50,6 +50,6 @@ class HttpServerActionConfig(CommonActionConfig):
     method: Literal[ "GET", "POST", "PUT", "DELETE", "PATCH" ] = Field(default="POST", description="HTTP method this endpoint will accept.")
     headers: Dict[str, str] = Field(default_factory=dict, description="HTTP headers to include in responses from this endpoint.")
     body: Dict[str, Any] = Field(default_factory=dict, description="Default response body template for this endpoint.")
-    params: Dict[str, str] = Field(default_factory=dict, description="Expected URL query parameters for this endpoint.")
+    params: Dict[str, Any] = Field(default_factory=dict, description="Expected URL query parameters for this endpoint.")
     stream_format: Optional[HttpStreamFormat] = Field(default=None, description="Format of stream payload.")
     completion: Optional[HttpServerCompletionConfig] = Field(default=None, description="Configuration for handling asynchronous request completion via polling or callbacks.")

{model_compose-0.4.31 → model_compose-0.4.32}/src/mindor/dsl/schema/runtime/impl/__init__.py

@@ -3,3 +3,4 @@ from .native import *
 from .embedded import *
 from .process import *
 from .docker import *
+from .apple_container import *

model_compose-0.4.32/src/mindor/dsl/schema/runtime/impl/apple_container.py

@@ -0,0 +1,49 @@
+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 RuntimeType, CommonRuntimeConfig
+
+class AppleContainerBuildConfig(BaseModel):
+    context: Optional[str] = Field(default=None, description="Build context path.")
+    dockerfile: Optional[str] = Field(default=None, description="Path to Dockerfile relative to context.")
+    args: Optional[Dict[str, Union[str, int, float, bool]]] = Field(default=None, description="Build arguments as key-value pairs.")
+
+class AppleContainerVolumeConfig(BaseModel):
+    name: str = Field(..., description="Volume name.")
+    target: str = Field(..., description="Mount path inside the container.")
+    read_only: Optional[bool] = Field(default=None, description="Mount as read-only.")
+
+class AppleContainerDnsConfig(BaseModel):
+    domain: str = Field(..., description="DNS domain name (e.g., 'test', 'dev').")
+    hostname: Optional[str] = Field(default=None, description="Container hostname within the domain.")
+
+class AppleContainerHealthCheck(BaseModel):
+    test: Union[str, List[str]] = Field(..., description="Health check command.")
+    interval: str = Field(default="30s", description="Time between checks.")
+    timeout: str = Field(default="30s", description="Timeout for each check.")
+    max_retry_count: Optional[int] = Field(default=3, description="Number of failures before marking as unhealthy.")
+    start_period: Optional[str] = Field(default="0s", description="Startup grace period before checks start.")
+
+class AppleContainerRuntimeConfig(CommonRuntimeConfig):
+    type: Literal[RuntimeType.APPLE_CONTAINER]
+    # Image or build
+    image: Optional[str] = Field(default=None, description="Container image name with optional tag.")
+    build: Optional[AppleContainerBuildConfig] = Field(default=None, description="Build configuration for building image locally.")
+    # Container identity
+    container_name: Optional[str] = Field(default=None, description="Name of the container.")
+    # Networking
+    ports: Optional[List[Union[str, int]]] = Field(default=None, description="Port mappings (e.g., '8080:80', 8080).")
+    dns: Optional[AppleContainerDnsConfig] = Field(default=None, description="DNS domain configuration for dedicated IP access.")
+    # Volumes
+    volumes: Optional[List[Union[str, AppleContainerVolumeConfig]]] = Field(default=None, description="Named volume mounts.")
+    # Environment variables
+    environment: Optional[Dict[str, Union[str, int, float, bool]]] = Field(default=None, description="Environment variables.")
+    # Command overrides
+    command: Optional[Union[str, List[str]]] = Field(default=None, description="Override the default command.")
+    # Resource limits
+    cpus: Optional[Union[str, float]] = Field(default=None, description="CPU core limit.")
+    mem_limit: Optional[str] = Field(default=None, description="Memory limit (e.g., '1G', '512M').")
+    # Health check
+    healthcheck: Optional[AppleContainerHealthCheck] = Field(default=None, description="Health check configuration.")
+    # Miscellaneous
+    labels: Optional[Dict[str, str]] = Field(default=None, description="Container labels.")

model_compose-0.4.32/src/mindor/dsl/schema/runtime/impl/types.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+class RuntimeType(str, Enum):
+    NATIVE          = "native"
+    EMBEDDED        = "embedded"
+    PROCESS         = "process"
+    DOCKER          = "docker"
+    APPLE_CONTAINER = "apple-container"

{model_compose-0.4.31 → model_compose-0.4.32}/src/mindor/dsl/schema/runtime/runtime.py

@@ -8,7 +8,8 @@ RuntimeConfig = Annotated[
         NativeRuntimeConfig,
         EmbeddedRuntimeConfig,
         ProcessRuntimeConfig,
-        DockerRuntimeConfig
+        DockerRuntimeConfig,
+        AppleContainerRuntimeConfig
     ],
     Field(discriminator="type")
 ]

{model_compose-0.4.31 → model_compose-0.4.32}/src/model_compose.egg-info/PKG-INFO

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