model-compose 0.2.12__tar.gz → 0.3.1__tar.gz

{model_compose-0.2.12/src/model_compose.egg-info → model_compose-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.2.12
+Version: 0.3.1
 Summary: model-compose: Declarative AI Model and Workflow Orchestrator
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT
@@ -24,6 +24,7 @@ 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
@@ -32,22 +33,21 @@ Dynamic: license-file
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](http://makeapullrequest.com)
 
-![Screenshots](docs/images/screenshots.png)
-
 **model-compose** is an open-source, declarative workflow orchestrator inspired by `docker-compose`. It lets you define and run AI model pipelines using simple YAML files — no custom code required. Effortlessly connect external AI services or run local AI models, all within powerful, composable workflows.
 
 ---
 
 ## ✨ Features
 
-- **Declarative by Design:** Define complete AI workflows using simple YAML files—no complex scripting required.
-- **Compose Anything:** Combine multiple AI models, APIs, and tools into a single, unified pipeline.
-- **Built for Orchestration:**  Orchestrate multi-step model interactions with ease. Transform individual API calls into maintainable, end-to-end systems.
-- **Multi-Workflow Support:** Define multiple named workflows in one project. Run them by name or set a default for quick execution.
-- **Modular Components:** Break down logic into reusable components and jobs. Easily plug, swap, and extend them across workflows.
-- **Flexible I/O Routing:** Connect inputs and outputs between jobs using clean, scoped variables—no glue code needed.
-- **Run Locally, Serve Remotely:** Execute workflows from the CLI or expose them as HTTP or MCP endpoints with an optional Web UI.
-- **Environment Variable Support:** Easily inject secrets and configuration via `.env` files or environment variables to keep your YAML clean and secure.
+- **Declarative by Design**: Define complete AI workflows using simple YAML files—no complex scripting required.
+- **Compose Anything**: Combine multiple AI models, APIs, and tools into a single, unified pipeline.
+- **Built for Orchestration**:  Orchestrate multi-step model interactions with ease. Transform individual API calls into maintainable, end-to-end systems.
+- **Multi-Workflow Support**: Define multiple named workflows in one project. Run them by name or set a default for quick execution.
+- **Modular Components**: Break down logic into reusable components and jobs. Easily plug, swap, and extend them across workflows.
+- **Flexible I/O Routing**: Connect inputs and outputs between jobs using clean, scoped variables—no glue code needed.
+- **Run Locally, Serve Remotely**: Execute workflows from the CLI or expose them as HTTP or MCP endpoints with an optional Web UI.
+- **Docker Deployment**: Build and deploy your workflow controller as a Docker container for consistent and portable execution environments.
+- **Environment Variable Support**: Easily inject secrets and configuration via `.env` files or environment variables to keep your YAML clean and secure.
 
 ---
 
@@ -84,8 +84,8 @@ By default, this command will:
 
 - Look for a file named `model-compose.yml` in the **current working directory**
 - Automatically load environment variables from a `.env` file in the **same directory**, if it exists
-- Start the workflow controller (default: http://localhost:8080)
-- Optionally launch the Web UI (default: http://localhost:8081, if configured)
+- Start the workflow controller (default: `http://localhost:8080`)
+- Optionally launch the Web UI (default: `http://localhost:8081`, if configured)
 
 To run in the background (detached mode):
 
@@ -113,7 +113,7 @@ model-compose up --env OPENAI_API_KEY=... --env ELEVENLABS_API_KEY=...
 
 > 💡 Once the controller is running, you can trigger workflows via the REST API or, if using MCP, via JSON-RPC. You can also access them through the Web UI.
 
-#### 📉 Shutting Down the Server (`down`)
+#### 🔽 Shutting Down the Server (`down`)
 To gracefully stop and remove the workflow controller and all associated services:
 
 ```
@@ -139,19 +139,18 @@ This is useful for testing, automation, or scripting.
 | `model-compose stop` | Temporarily pause the currently running controller |
 
 ---
-
 ## 🧾 `model-compose.yml`
 
 The `model-compose.yml` file is the central configuration file that defines how your workflows are composed and executed.
 
 It includes:
 
-- **Controller** – configures the HTTP/MCP server, API endpoints, and optional Web UI
-- **Components** – reusable definitions for calling APIs, running local AI models, or executing commands
-- **Workflows** – named sets of jobs that define the flow of data
-- **Jobs** – steps that execute specific components, with support for inputs, outputs, and dependencies
-- **Listeners** – optional callback listeners that handle asynchronous responses from external services
-- **Gateways** - optional tunneling services that expose your local controller to the public internet
+- **Controller**: configures the HTTP/MCP server, API endpoints, and optional Web UI
+- **Components**: reusable definitions for calling APIs, running local AI models, or executing commands
+- **Workflows**: named sets of jobs that define the flow of data
+- **Jobs**: steps that execute specific components, with support for inputs, outputs, and dependencies
+- **Listeners**: optional callback listeners that handle asynchronous responses from external services
+- **Gateways**: optional tunneling services that expose your local controller to the public internet
 
 By default, `model-compose` automatically looks for a file named `model-compose.yml` in the current working directory when running commands like `up` or `run`.
 
@@ -161,6 +160,7 @@ By default, `model-compose` automatically looks for a file named `model-compose.
 controller:
   type: http-server
   port: 8080
+  base_path: /api
   webui:
     port: 8081
 
@@ -213,7 +213,7 @@ listener:
       result: ${item.choices[0].message.content}
 ```
 
-This listener sets up an HTTP callback endpoint at http://localhost:8090/callbacks/chat-ai to handle asynchronous responses from an external service that behaves like ChatGPT but supports delayed or push-based results. This is useful when integrating with services that notify results via webhook-style callbacks.
+This listener sets up an HTTP callback endpoint at `http://localhost:8090/callbacks/chat-ai` to handle asynchronous responses from an external service that behaves like ChatGPT but supports delayed or push-based results. This is useful when integrating with services that notify results via webhook-style callbacks.
 
 #### 🌐 Gateway Example
 
@@ -224,10 +224,146 @@ gateway:
   port: 8090
 ```
 
-This gateway configuration exposes the local listener defined above to the public internet using an HTTP tunnel powered by ngrok. It forwards incoming traffic from a secure, public URL (e.g., https://abc123.ngrok.io) directly to your local callback endpoint at http://localhost:8090. This is essential when integrating with third-party services that need to push data back to your workflow via webhooks or asynchronous callbacks.
+This gateway configuration exposes the local listener defined above to the public internet using an HTTP tunnel powered by ngrok. It forwards incoming traffic from a secure, public URL (e.g., `https://abc123.ngrok.io`) directly to your local callback endpoint at `http://localhost:8090`. This is essential when integrating with third-party services that need to push data back to your workflow via webhooks or asynchronous callbacks.
 
 > 📁 For more example model-compose.yml configurations, check the [examples directory](examples) in the source code.
 
+---
+## 🖥 Web UI
+**model-compose** optionally provides a lightweight **Web UI** to help you visually trigger workflows, inspect inputs and outputs, and monitor execution logs.
+
+![Screenshots](docs/images/webui.png)
+
+#### ✅ Enabling the Web UI
+To enable the Web UI, simply add the `webui` section under your `controller` in the `model-compose.yml` file:
+```
+controller:
+  type: http-server
+  port: 8080
+  webui:
+    port: 8081
+```
+
+Once enabled, the Web UI will be available at:
+```
+http://localhost:8081
+```
+> By default, the Web UI is powered by [Gradio](https://www.gradio.app), but support for other drivers may be added in the future.
+
+---
+## 🛰 MCP Server Support
+You can also expose your workflows via the **Model Context Protocol (MCP)** server to enable remote execution, automation, or system integration using a lightweight JSON-RPC interface.
+
+#### ✅ Minimal MCP Server Example
+
+```
+controller:
+  type: mcp-server
+  port: 8080
+  base_path: /mcp
+
+components:
+  chatgpt:
+    type: http-client
+    base_url: https://api.openai.com/v1
+    path: /chat/completions
+    method: POST
+    headers:
+      Authorization: Bearer ${env.OPENAI_API_KEY}
+      Content-Type: application/json
+    body:
+      model: gpt-4o
+      messages:
+        - role: user
+          content: "Write an inspiring quote."
+    output:
+      quote: ${response.choices[0].message.content}
+
+workflows:
+  generate-quote:
+    default: true
+    jobs:
+      get-quote:
+        component: chatgpt
+```
+This configuration launches the controller as an **MCP server**, which listens on port 8080 and exposes your workflows over a **JSON-RPC API**.
+
+Once running, you can invoke workflows remotely using a standard MCP request:
+
+```
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "callTool",
+  "params": {
+    "name": "generate-quote",
+    "arguments": {}
+  }
+}
+```
+
+You can send this request via any HTTP client to:
+```
+POST http://localhost:8080/mcp
+```
+
+---
+## 🐳 Docker Runtime Support
+You can run the workflow controller inside a Docker container by specifying the runtime option in your `model-compose.yml` file.
+
+#### ✅ Minimal Docker Runtime Example
+
+```
+controller:
+  type: http-server
+  port: 8080
+  runtime: docker
+```
+
+This configuration will launch the controller inside a lightweight Docker container automatically managed by **model-compose**. It uses default settings such as container name, image, and volume mappings.
+
+#### ⚙️ Advanced Docker Runtime Options
+You can fully configure the Docker runtime by using an object under the `runtime` key:
+
+```
+controller:
+  type: http-server
+  port: 8080
+  runtime:
+    type: docker
+    image: 192.168.0.23/custom-image:latest
+    container_name: my-controller
+    volumes:
+      - ./models:/models
+      - ./cache:/cache
+    ports:
+      - "5000:8080"
+      - "5001:8081"
+    env:
+      MODEL_STORAGE_PATH: /models
+    command: [ "python", "-m", "mindor.cli.compose", "up" ]
+    ...
+```
+
+This gives you full control over:
+
+- **container_name**: Custom name for the container
+- **image**: Docker image to use
+- **volumes**: Bind mounts for sharing files between host and container
+- **ports**: Port mappings for host ↔ container communication
+- **env**: Environment variables to inject
+- **command**: Override the default entrypoint
+- *and many more*
+
+All of these are optional, allowing you to start simple and customize only what you need.
+
+#### 🐳 Benefits of Docker Runtime
+
+- Run your controller in a clean, isolated environment
+- Avoid dependency conflicts with your host Python setup
+- Easily deploy your project to remote servers or CI pipelines
+- Share reproducible workflows with others
+
 ---
 ## 🏗 Architecture
 

{model_compose-0.2.12 → model_compose-0.3.1}/README.md

@@ -4,22 +4,21 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](http://makeapullrequest.com)
 
-![Screenshots](docs/images/screenshots.png)
-
 **model-compose** is an open-source, declarative workflow orchestrator inspired by `docker-compose`. It lets you define and run AI model pipelines using simple YAML files — no custom code required. Effortlessly connect external AI services or run local AI models, all within powerful, composable workflows.
 
 ---
 
 ## ✨ Features
 
-- **Declarative by Design:** Define complete AI workflows using simple YAML files—no complex scripting required.
-- **Compose Anything:** Combine multiple AI models, APIs, and tools into a single, unified pipeline.
-- **Built for Orchestration:**  Orchestrate multi-step model interactions with ease. Transform individual API calls into maintainable, end-to-end systems.
-- **Multi-Workflow Support:** Define multiple named workflows in one project. Run them by name or set a default for quick execution.
-- **Modular Components:** Break down logic into reusable components and jobs. Easily plug, swap, and extend them across workflows.
-- **Flexible I/O Routing:** Connect inputs and outputs between jobs using clean, scoped variables—no glue code needed.
-- **Run Locally, Serve Remotely:** Execute workflows from the CLI or expose them as HTTP or MCP endpoints with an optional Web UI.
-- **Environment Variable Support:** Easily inject secrets and configuration via `.env` files or environment variables to keep your YAML clean and secure.
+- **Declarative by Design**: Define complete AI workflows using simple YAML files—no complex scripting required.
+- **Compose Anything**: Combine multiple AI models, APIs, and tools into a single, unified pipeline.
+- **Built for Orchestration**:  Orchestrate multi-step model interactions with ease. Transform individual API calls into maintainable, end-to-end systems.
+- **Multi-Workflow Support**: Define multiple named workflows in one project. Run them by name or set a default for quick execution.
+- **Modular Components**: Break down logic into reusable components and jobs. Easily plug, swap, and extend them across workflows.
+- **Flexible I/O Routing**: Connect inputs and outputs between jobs using clean, scoped variables—no glue code needed.
+- **Run Locally, Serve Remotely**: Execute workflows from the CLI or expose them as HTTP or MCP endpoints with an optional Web UI.
+- **Docker Deployment**: Build and deploy your workflow controller as a Docker container for consistent and portable execution environments.
+- **Environment Variable Support**: Easily inject secrets and configuration via `.env` files or environment variables to keep your YAML clean and secure.
 
 ---
 
@@ -56,8 +55,8 @@ By default, this command will:
 
 - Look for a file named `model-compose.yml` in the **current working directory**
 - Automatically load environment variables from a `.env` file in the **same directory**, if it exists
-- Start the workflow controller (default: http://localhost:8080)
-- Optionally launch the Web UI (default: http://localhost:8081, if configured)
+- Start the workflow controller (default: `http://localhost:8080`)
+- Optionally launch the Web UI (default: `http://localhost:8081`, if configured)
 
 To run in the background (detached mode):
 
@@ -85,7 +84,7 @@ model-compose up --env OPENAI_API_KEY=... --env ELEVENLABS_API_KEY=...
 
 > 💡 Once the controller is running, you can trigger workflows via the REST API or, if using MCP, via JSON-RPC. You can also access them through the Web UI.
 
-#### 📉 Shutting Down the Server (`down`)
+#### 🔽 Shutting Down the Server (`down`)
 To gracefully stop and remove the workflow controller and all associated services:
 
 ```
@@ -111,19 +110,18 @@ This is useful for testing, automation, or scripting.
 | `model-compose stop` | Temporarily pause the currently running controller |
 
 ---
-
 ## 🧾 `model-compose.yml`
 
 The `model-compose.yml` file is the central configuration file that defines how your workflows are composed and executed.
 
 It includes:
 
-- **Controller** – configures the HTTP/MCP server, API endpoints, and optional Web UI
-- **Components** – reusable definitions for calling APIs, running local AI models, or executing commands
-- **Workflows** – named sets of jobs that define the flow of data
-- **Jobs** – steps that execute specific components, with support for inputs, outputs, and dependencies
-- **Listeners** – optional callback listeners that handle asynchronous responses from external services
-- **Gateways** - optional tunneling services that expose your local controller to the public internet
+- **Controller**: configures the HTTP/MCP server, API endpoints, and optional Web UI
+- **Components**: reusable definitions for calling APIs, running local AI models, or executing commands
+- **Workflows**: named sets of jobs that define the flow of data
+- **Jobs**: steps that execute specific components, with support for inputs, outputs, and dependencies
+- **Listeners**: optional callback listeners that handle asynchronous responses from external services
+- **Gateways**: optional tunneling services that expose your local controller to the public internet
 
 By default, `model-compose` automatically looks for a file named `model-compose.yml` in the current working directory when running commands like `up` or `run`.
 
@@ -133,6 +131,7 @@ By default, `model-compose` automatically looks for a file named `model-compose.
 controller:
   type: http-server
   port: 8080
+  base_path: /api
   webui:
     port: 8081
 
@@ -185,7 +184,7 @@ listener:
       result: ${item.choices[0].message.content}
 ```
 
-This listener sets up an HTTP callback endpoint at http://localhost:8090/callbacks/chat-ai to handle asynchronous responses from an external service that behaves like ChatGPT but supports delayed or push-based results. This is useful when integrating with services that notify results via webhook-style callbacks.
+This listener sets up an HTTP callback endpoint at `http://localhost:8090/callbacks/chat-ai` to handle asynchronous responses from an external service that behaves like ChatGPT but supports delayed or push-based results. This is useful when integrating with services that notify results via webhook-style callbacks.
 
 #### 🌐 Gateway Example
 
@@ -196,10 +195,146 @@ gateway:
   port: 8090
 ```
 
-This gateway configuration exposes the local listener defined above to the public internet using an HTTP tunnel powered by ngrok. It forwards incoming traffic from a secure, public URL (e.g., https://abc123.ngrok.io) directly to your local callback endpoint at http://localhost:8090. This is essential when integrating with third-party services that need to push data back to your workflow via webhooks or asynchronous callbacks.
+This gateway configuration exposes the local listener defined above to the public internet using an HTTP tunnel powered by ngrok. It forwards incoming traffic from a secure, public URL (e.g., `https://abc123.ngrok.io`) directly to your local callback endpoint at `http://localhost:8090`. This is essential when integrating with third-party services that need to push data back to your workflow via webhooks or asynchronous callbacks.
 
 > 📁 For more example model-compose.yml configurations, check the [examples directory](examples) in the source code.
 
+---
+## 🖥 Web UI
+**model-compose** optionally provides a lightweight **Web UI** to help you visually trigger workflows, inspect inputs and outputs, and monitor execution logs.
+
+![Screenshots](docs/images/webui.png)
+
+#### ✅ Enabling the Web UI
+To enable the Web UI, simply add the `webui` section under your `controller` in the `model-compose.yml` file:
+```
+controller:
+  type: http-server
+  port: 8080
+  webui:
+    port: 8081
+```
+
+Once enabled, the Web UI will be available at:
+```
+http://localhost:8081
+```
+> By default, the Web UI is powered by [Gradio](https://www.gradio.app), but support for other drivers may be added in the future.
+
+---
+## 🛰 MCP Server Support
+You can also expose your workflows via the **Model Context Protocol (MCP)** server to enable remote execution, automation, or system integration using a lightweight JSON-RPC interface.
+
+#### ✅ Minimal MCP Server Example
+
+```
+controller:
+  type: mcp-server
+  port: 8080
+  base_path: /mcp
+
+components:
+  chatgpt:
+    type: http-client
+    base_url: https://api.openai.com/v1
+    path: /chat/completions
+    method: POST
+    headers:
+      Authorization: Bearer ${env.OPENAI_API_KEY}
+      Content-Type: application/json
+    body:
+      model: gpt-4o
+      messages:
+        - role: user
+          content: "Write an inspiring quote."
+    output:
+      quote: ${response.choices[0].message.content}
+
+workflows:
+  generate-quote:
+    default: true
+    jobs:
+      get-quote:
+        component: chatgpt
+```
+This configuration launches the controller as an **MCP server**, which listens on port 8080 and exposes your workflows over a **JSON-RPC API**.
+
+Once running, you can invoke workflows remotely using a standard MCP request:
+
+```
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "callTool",
+  "params": {
+    "name": "generate-quote",
+    "arguments": {}
+  }
+}
+```
+
+You can send this request via any HTTP client to:
+```
+POST http://localhost:8080/mcp
+```
+
+---
+## 🐳 Docker Runtime Support
+You can run the workflow controller inside a Docker container by specifying the runtime option in your `model-compose.yml` file.
+
+#### ✅ Minimal Docker Runtime Example
+
+```
+controller:
+  type: http-server
+  port: 8080
+  runtime: docker
+```
+
+This configuration will launch the controller inside a lightweight Docker container automatically managed by **model-compose**. It uses default settings such as container name, image, and volume mappings.
+
+#### ⚙️ Advanced Docker Runtime Options
+You can fully configure the Docker runtime by using an object under the `runtime` key:
+
+```
+controller:
+  type: http-server
+  port: 8080
+  runtime:
+    type: docker
+    image: 192.168.0.23/custom-image:latest
+    container_name: my-controller
+    volumes:
+      - ./models:/models
+      - ./cache:/cache
+    ports:
+      - "5000:8080"
+      - "5001:8081"
+    env:
+      MODEL_STORAGE_PATH: /models
+    command: [ "python", "-m", "mindor.cli.compose", "up" ]
+    ...
+```
+
+This gives you full control over:
+
+- **container_name**: Custom name for the container
+- **image**: Docker image to use
+- **volumes**: Bind mounts for sharing files between host and container
+- **ports**: Port mappings for host ↔ container communication
+- **env**: Environment variables to inject
+- **command**: Override the default entrypoint
+- *and many more*
+
+All of these are optional, allowing you to start simple and customize only what you need.
+
+#### 🐳 Benefits of Docker Runtime
+
+- Run your controller in a clean, isolated environment
+- Avoid dependency conflicts with your host Python setup
+- Easily deploy your project to remote servers or CI pipelines
+- Share reproducible workflows with others
+
 ---
 ## 🏗 Architecture
 

{model_compose-0.2.12 → model_compose-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.2.12"
+version = "0.3.1"
 description = "model-compose: Declarative AI Model and Workflow Orchestrator"
 authors = [
     { name = "Hanyeol Cho", email = "hanyeol.cho@gmail.com" }
@@ -24,7 +24,8 @@ dependencies = [
     "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.12 → model_compose-0.3.1}/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.12 → model_compose-0.3.1}/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.12 → model_compose-0.3.1}/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: