model-compose 0.4.83__tar.gz → 0.4.85__tar.gz

{model_compose-0.4.83 → model_compose-0.4.85}/PKG-INFO

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

{model_compose-0.4.83 → model_compose-0.4.85}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.4.83"
+version = "0.4.85"
 description = "model-compose: Declarative AI Workflow Orchestrator"
 authors = [
     { name = "Hanyeol Cho", email = "hanyeol.cho@gmail.com" }
@@ -46,8 +46,9 @@ include-package-data = true
 where = ["src"]
 
 [tool.setuptools.package-data]
-"mindor.core.runtime.base.bootstrap" = ["requirements.txt"]
-"mindor.core.runtime.base.container" = ["Dockerfile"]
+"mindor.core.runtime.bootstrap" = ["requirements.txt"]
+"mindor.core.component.runtime.container.assets" = ["Dockerfile.*", "*.stub.txt", "*.stub.sh"]
+"mindor.core.controller.runtime.container.assets" = ["Dockerfile.*", "*.stub.txt", "*.stub.sh", "bootstrap.sh"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

model_compose-0.4.85/src/mindor/core/component/runtime/container/assets/Dockerfile.derived

@@ -0,0 +1,15 @@
+ARG BASE_IMAGE
+FROM ${BASE_IMAGE}
+
+# System-level setup hook (apt install, etc.). Runs before pip install so
+# python packages that need native deps can find them. Missing setup.sh is
+# a no-op — the file is always injected by the runtime builder, empty when
+# the user did not provide one.
+COPY user-setup.sh /tmp/user-setup.sh
+RUN chmod +x /tmp/user-setup.sh \
+    && /tmp/user-setup.sh \
+    && rm /tmp/user-setup.sh
+
+COPY user-requirements.txt /tmp/user-requirements.txt
+RUN pip install --no-cache-dir -r /tmp/user-requirements.txt \
+    && rm /tmp/user-requirements.txt

model_compose-0.4.85/src/mindor/core/component/runtime/container/assets/Dockerfile.standard

@@ -0,0 +1,31 @@
+ARG BASE_IMAGE=python:3.11-slim
+FROM ${BASE_IMAGE}
+
+# Ensure python3 + pip are available. Debian / Ubuntu / NVIDIA CUDA base
+# images use apt; other distros (alpine, ubi, ...) are not supported here.
+RUN if ! command -v python3 >/dev/null 2>&1; then \
+        apt-get update && \
+        apt-get install -y --no-install-recommends python3 python3-pip python3-venv && \
+        rm -rf /var/lib/apt/lists/*; \
+    fi && \
+    ln -sf "$(command -v python3)" /usr/local/bin/python
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN python -m pip install --upgrade pip
+
+COPY standard-requirements.txt /tmp/standard-requirements.txt
+RUN pip install --no-cache-dir -r /tmp/standard-requirements.txt \
+    && rm /tmp/standard-requirements.txt
+
+# Resolve site-packages from the chosen python instead of hardcoding the
+# path. Different base images (and python versions) place purelib under
+# different directories.
+COPY src/mindor /tmp/mindor-src
+RUN target="$(python -c 'import sysconfig; print(sysconfig.get_paths()["purelib"])')/mindor" \
+    && cp -r /tmp/mindor-src "$target" \
+    && rm -rf /tmp/mindor-src
+
+WORKDIR /workspace

model_compose-0.4.85/src/mindor/core/component/runtime/container/assets/requirements.stub.txt

@@ -0,0 +1,2 @@
+# Injected in place of the user's requirements.txt when the project has none.
+# Provides an empty file so the derived Dockerfile can COPY unconditionally.

model_compose-0.4.85/src/mindor/core/component/runtime/container/assets/setup.stub.sh

@@ -0,0 +1,4 @@
+#!/bin/sh
+# Injected in place of the user's setup.sh when the project has none.
+# Provides a no-op so the derived Dockerfile can COPY unconditionally.
+exit 0

{model_compose-0.4.83 → model_compose-0.4.85}/src/mindor/core/component/services/model/tasks/music_generation/custom/ace_step.py

@@ -99,9 +99,10 @@ class AceStepMusicGenerationTaskService(MusicGenerationTaskService):
 
     def get_setup_requirements(self) -> Optional[List[str]]:
         return [
-            "torch==2.10.0+cu128@https://download.pytorch.org/whl/cu128",
-            "torchaudio==2.10.0+cu128@https://download.pytorch.org/whl/cu128",
-            "torchvision==0.25.0+cu128@https://download.pytorch.org/whl/cu128",
+            "torch==2.8.0+cu128@https://download.pytorch.org/whl/cu128",
+            "torchaudio==2.8.0+cu128@https://download.pytorch.org/whl/cu128",
+            "torchvision==0.23.0+cu128@https://download.pytorch.org/whl/cu128",
+            "flash-attn==2.8.3.post1@https://github.com/Dao-AILab/flash-attention/releases/download/v2.8.3/flash_attn-2.8.3.post1+cu12torch2.8cxx11abiFALSE-cp310-cp310-linux_x86_64.whl",
             "nano-vllm@git+https://github.com/GeeeekExplorer/nano-vllm.git",
             "ace-step@git+https://github.com/ace-step/ACE-Step-1.5.git",
             "numpy",

model_compose-0.4.85/src/mindor/core/component/services/model/tasks/text_to_speech/custom/cosyvoice.py

@@ -0,0 +1,280 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from typing import Union, Dict, Optional, List, Tuple, Any
+from abc import abstractmethod
+from mindor.dsl.schema.component import ModelComponentConfig, HuggingfaceModelConfig
+from mindor.dsl.schema.action import ModelActionConfig, TextToSpeechActionMethod
+from mindor.dsl.schema.action import CommonTextToSpeechModelActionConfig
+from mindor.dsl.schema.action import CosyvoiceTextToSpeechModelGenerateActionConfig
+from mindor.dsl.schema.action import CosyvoiceTextToSpeechModelCloneActionConfig
+from mindor.dsl.schema.action import CosyvoiceTextToSpeechModelDesignActionConfig
+from mindor.core.foundation.cancellation import CancellationToken
+from mindor.core.foundation.streaming.audio import PcmStreamResource
+from mindor.core.foundation.streaming.resources import StreamResource
+from mindor.core.utils.audio import encode_waveform_to_pcm
+from ......base import ComponentActionContext
+from ..common import TextToSpeechTaskService, TextToSpeechTaskAction
+
+if TYPE_CHECKING:
+    import torch
+
+class CosyvoiceTextToSpeechTaskAction(TextToSpeechTaskAction):
+    config: CommonTextToSpeechModelActionConfig
+
+    def __init__(self, config: CommonTextToSpeechModelActionConfig, model: Any, sample_rate: int, device: Optional[torch.device]):
+        super().__init__(config, device)
+
+        self.model = model
+        self.sample_rate = sample_rate
+
+    async def _generate(
+        self,
+        texts: List[str],
+        params: Dict[str, Any],
+        cancellation_token: Optional[CancellationToken] = None,
+    ) -> List[StreamResource]:
+        def _generate() -> List[StreamResource]:
+            import numpy as np
+
+            results: List[StreamResource] = []
+
+            for text in texts:
+                # inference_* returns a generator of {'tts_speech': tensor} dicts.
+                # With stream=False the LLM produces one chunk per normalized
+                # sentence; concatenate them so a single input text produces a
+                # single output audio.
+                chunks: List[Any] = []
+                for output in self._invoke(text, params):
+                    speech = output["tts_speech"]  # shape (1, samples)
+                    chunks.append(speech.detach().cpu().numpy().squeeze(0))
+
+                samples = np.concatenate(chunks, axis=0) if len(chunks) > 1 else chunks[0]
+                samples = samples.astype(np.float32)
+                frames, channels = encode_waveform_to_pcm(samples)
+
+                results.append(PcmStreamResource(frames, {
+                    "sample_rate": str(self.sample_rate),
+                    "channels":    str(channels),
+                    "bit_depth":   "16",
+                }))
+
+            return results
+
+        return await self._run_in_executor(_generate)
+
+    @abstractmethod
+    def _invoke(self, text: str, params: Dict[str, Any]) -> Any:
+        pass
+
+class CosyvoiceTextToSpeechGenerateTaskAction(CosyvoiceTextToSpeechTaskAction):
+    config: CosyvoiceTextToSpeechModelGenerateActionConfig
+
+    async def _resolve_params(self, context: ComponentActionContext) -> Dict[str, Any]:
+        params = await super()._resolve_params(context)
+
+        voice         = await context.render_variable(self.config.voice)
+        speed         = await context.render_variable(self.config.speed)
+        text_frontend = await context.render_variable(self.config.text_frontend)
+
+        params.update({
+            "voice":         voice,
+            "speed":         float(speed) if speed is not None else 1.0,
+            "text_frontend": bool(text_frontend) if text_frontend is not None else True,
+        })
+
+        return params
+
+    def _invoke(self, text: str, params: Dict[str, Any]) -> Any:
+        # inference_sft is defined on the base CosyVoice class. CosyVoice2/3
+        # inherit the method but only reach real preset speakers when the
+        # loaded model_dir includes an spk2info.pt (typically CosyVoice-300M-SFT
+        # or a v2/v3 checkpoint with pre-registered zero-shot speakers).
+        if not hasattr(self.model, "inference_sft"):
+            raise RuntimeError(
+                "The loaded CosyVoice model does not support the 'generate' method. "
+                "Use family=cosyvoice with a *-SFT checkpoint, or switch to method=clone."
+            )
+
+        available = getattr(self.model, "list_available_spks", lambda: [])()
+        if available and params["voice"] not in available:
+            raise ValueError(
+                f"Unknown voice '{params['voice']}'. Available speakers: {available}"
+            )
+
+        return self.model.inference_sft(
+            tts_text=text,
+            spk_id=params["voice"],
+            stream=False,
+            speed=params["speed"],
+            text_frontend=params["text_frontend"],
+        )
+
+class CosyvoiceTextToSpeechCloneTaskAction(CosyvoiceTextToSpeechTaskAction):
+    config: CosyvoiceTextToSpeechModelCloneActionConfig
+
+    async def _resolve_params(self, context: ComponentActionContext) -> Dict[str, Any]:
+        params = await super()._resolve_params(context)
+
+        reference_audio = await context.render_file(self.config.reference_audio)
+        reference_text  = await context.render_variable(self.config.reference_text)
+        speed           = await context.render_variable(self.config.speed)
+        text_frontend   = await context.render_variable(self.config.text_frontend)
+
+        params.update({
+            "reference_audio": reference_audio,
+            "reference_text":  reference_text,
+            "speed":           float(speed) if speed is not None else 1.0,
+            "text_frontend":   bool(text_frontend) if text_frontend is not None else True,
+        })
+
+        return params
+
+    def _invoke(self, text: str, params: Dict[str, Any]) -> Any:
+        from cosyvoice.utils.file_utils import load_wav
+
+        # CosyVoice's frontend expects a 16kHz mono tensor for the prompt wav.
+        prompt_wav = load_wav(str(params["reference_audio"]), 16000)
+
+        # With a transcript, use zero_shot (better speaker similarity). Without
+        # one, fall back to cross_lingual — which accepts any language and does
+        # not require reference text.
+        if params["reference_text"]:
+            return self.model.inference_zero_shot(
+                tts_text=text,
+                prompt_text=params["reference_text"],
+                prompt_wav=prompt_wav,
+                stream=False,
+                speed=params["speed"],
+                text_frontend=params["text_frontend"],
+            )
+
+        return self.model.inference_cross_lingual(
+            tts_text=text,
+            prompt_wav=prompt_wav,
+            stream=False,
+            speed=params["speed"],
+            text_frontend=params["text_frontend"],
+        )
+
+class CosyvoiceTextToSpeechDesignTaskAction(CosyvoiceTextToSpeechTaskAction):
+    config: CosyvoiceTextToSpeechModelDesignActionConfig
+
+    async def _resolve_params(self, context: ComponentActionContext) -> Dict[str, Any]:
+        params = await super()._resolve_params(context)
+
+        instructions    = await context.render_variable(self.config.instructions)
+        reference_audio = await context.render_file(self.config.reference_audio)
+        speed           = await context.render_variable(self.config.speed)
+        text_frontend   = await context.render_variable(self.config.text_frontend)
+
+        params.update({
+            "instructions":    instructions,
+            "reference_audio": reference_audio,
+            "speed":           float(speed) if speed is not None else 1.0,
+            "text_frontend":   bool(text_frontend) if text_frontend is not None else True,
+        })
+
+        return params
+
+    def _invoke(self, text: str, params: Dict[str, Any]) -> Any:
+        # inference_instruct2 only exists on CosyVoice2/3. The original
+        # CosyVoice-Instruct model exposes inference_instruct with a different
+        # signature (spk_id-based, no prompt wav) — refuse rather than silently
+        # loading the wrong path.
+        if not hasattr(self.model, "inference_instruct2"):
+            raise RuntimeError(
+                "The loaded CosyVoice model does not support the 'design' method. "
+                "Use family=cosyvoice with a CosyVoice2/3 checkpoint (e.g. FunAudioLLM/CosyVoice2-0.5B)."
+            )
+
+        from cosyvoice.utils.file_utils import load_wav
+
+        prompt_wav = load_wav(str(params["reference_audio"]), 16000)
+
+        return self.model.inference_instruct2(
+            tts_text=text,
+            instruct_text=params["instructions"],
+            prompt_wav=prompt_wav,
+            stream=False,
+            speed=params["speed"],
+            text_frontend=params["text_frontend"],
+        )
+
+class CosyvoiceTextToSpeechTaskService(TextToSpeechTaskService):
+    def __init__(self, id: str, config: ModelComponentConfig, daemon: bool):
+        super().__init__(id, config, daemon)
+
+        self.model: Optional[Any] = None
+        self.sample_rate: int = 24000
+        self.device: Optional[torch.device] = None
+
+    def get_setup_requirements(self) -> Optional[List[str]]:
+        # cosyvoice itself is installed from source (see the repo README). We
+        # still declare its runtime deps so the environment matches what the
+        # inference paths expect.
+        return [ "cosyvoice", "torch", "torchaudio", "modelscope", "hyperpyyaml", "numpy", "soundfile" ]
+
+    async def _load_model(self) -> None:
+        self.model, self.sample_rate, self.device = self._load_pretrained_model()
+
+    async def _unload_model(self) -> None:
+        self.model = None
+        self.device = None
+
+    def _load_pretrained_model(self) -> Tuple[Any, int, Any]:
+        # CosyVoice ships an AutoModel factory that picks CosyVoice / CosyVoice2 /
+        # CosyVoice3 by looking for cosyvoice{,2,3}.yaml inside model_dir, and
+        # calls snapshot_download() itself if model_dir isn't a local path.
+        from cosyvoice.cli.cosyvoice import AutoModel
+
+        if isinstance(self.config.model, HuggingfaceModelConfig):
+            model_dir = self.config.model.repository
+        else:
+            model_dir = self._get_model_path()
+
+        device = self._resolve_device(self.config.device)
+
+        # jit/trt/vllm/fp16 are CUDA-only; AutoModel warns and silently disables
+        # them on CPU, but we filter here so the intent is visible in logs.
+        load_jit  = bool(getattr(self.config, "load_jit",  False)) and device.type == "cuda"
+        load_trt  = bool(getattr(self.config, "load_trt",  False)) and device.type == "cuda"
+        load_vllm = bool(getattr(self.config, "load_vllm", False)) and device.type == "cuda"
+        fp16      = bool(getattr(self.config, "fp16",      False)) and device.type == "cuda"
+
+        # AutoModel returns CosyVoice / CosyVoice2 / CosyVoice3. Only v2/v3
+        # accept load_vllm, so pass it conditionally by peeking at the yaml.
+        import os
+        kwargs: Dict[str, Any] = {
+            "model_dir": model_dir,
+            "load_jit":  load_jit,
+            "load_trt":  load_trt,
+            "fp16":      fp16,
+        }
+        resolved_dir = model_dir if os.path.exists(model_dir) else None
+        if resolved_dir and (
+            os.path.exists(os.path.join(resolved_dir, "cosyvoice2.yaml")) or
+            os.path.exists(os.path.join(resolved_dir, "cosyvoice3.yaml"))
+        ):
+            kwargs["load_vllm"] = load_vllm
+        elif load_vllm:
+            # We don't yet know the version (AutoModel will download); attempt
+            # anyway and let AutoModel raise a clear TypeError if unsupported.
+            kwargs["load_vllm"] = load_vllm
+
+        model = AutoModel(**kwargs)
+        sample_rate = int(getattr(model, "sample_rate", 24000))
+
+        return model, sample_rate, device
+
+    async def _run(self, action: ModelActionConfig, context: ComponentActionContext) -> Any:
+        if action.method == TextToSpeechActionMethod.GENERATE:
+            return await CosyvoiceTextToSpeechGenerateTaskAction(action, self.model, self.sample_rate, self.device).run(context)
+
+        if action.method == TextToSpeechActionMethod.CLONE:
+            return await CosyvoiceTextToSpeechCloneTaskAction(action, self.model, self.sample_rate, self.device).run(context)
+
+        if action.method == TextToSpeechActionMethod.DESIGN:
+            return await CosyvoiceTextToSpeechDesignTaskAction(action, self.model, self.sample_rate, self.device).run(context)
+
+        raise ValueError(f"Unknown method: {action.method}")

{model_compose-0.4.83 → model_compose-0.4.85}/src/mindor/core/component/services/model/tasks/text_to_speech/custom/custom.py

@@ -24,4 +24,8 @@ class CustomTextToSpeechTaskService:
             from .tada import TadaTextToSpeechTaskService
             return TadaTextToSpeechTaskService(id, config, daemon)
 
+        if config.family == TextToSpeechModelFamily.COSYVOICE:
+            from .cosyvoice import CosyvoiceTextToSpeechTaskService
+            return CosyvoiceTextToSpeechTaskService(id, config, daemon)
+
         raise ValueError(f"Unknown family: {config.family}")

{model_compose-0.4.83 → model_compose-0.4.85}/src/mindor/core/component/services/screen_capture/drivers/ffmpeg.py

@@ -15,7 +15,8 @@ from mindor.core.utils.shell import kill_process
 from mindor.core.logger import logging
 from ..base import ScreenCaptureService, ScreenCaptureDriver, register_screen_capture_service
 from ..base import ComponentActionContext
-from .common import ScreenCaptureAction, VideoAudioEncodingParams
+from mindor.core.foundation.media.encoding import VideoAudioEncodingParams
+from .common import ScreenCaptureAction
 import asyncio, os, platform, shutil, time
 
 # Sentinel put on the chunk queue to signal end-of-stream to the consumer.

model_compose-0.4.85/src/mindor/core/controller/runtime/container/assets/Dockerfile.derived

@@ -0,0 +1,15 @@
+ARG BASE_IMAGE
+FROM ${BASE_IMAGE}
+
+# System-level setup hook (apt install, etc.). Runs before pip install so
+# python packages that need native deps can find them. Missing setup.sh is
+# a no-op — the file is always injected by the runtime builder, empty when
+# the user did not provide one.
+COPY user-setup.sh /tmp/user-setup.sh
+RUN chmod +x /tmp/user-setup.sh \
+    && /tmp/user-setup.sh \
+    && rm /tmp/user-setup.sh
+
+COPY user-requirements.txt /tmp/user-requirements.txt
+RUN pip install --no-cache-dir -r /tmp/user-requirements.txt \
+    && rm /tmp/user-requirements.txt

model_compose-0.4.85/src/mindor/core/controller/runtime/container/assets/Dockerfile.standard

@@ -0,0 +1,35 @@
+ARG BASE_IMAGE=python:3.11-slim
+FROM ${BASE_IMAGE}
+
+# Ensure python3 + pip are available. Debian / Ubuntu / NVIDIA CUDA base
+# images use apt; other distros (alpine, ubi, ...) are not supported here.
+RUN if ! command -v python3 >/dev/null 2>&1; then \
+        apt-get update && \
+        apt-get install -y --no-install-recommends python3 python3-pip python3-venv && \
+        rm -rf /var/lib/apt/lists/*; \
+    fi && \
+    ln -sf "$(command -v python3)" /usr/local/bin/python
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN python -m pip install --upgrade pip
+
+COPY standard-requirements.txt /tmp/standard-requirements.txt
+RUN pip install --no-cache-dir -r /tmp/standard-requirements.txt \
+    && rm /tmp/standard-requirements.txt
+
+# Resolve site-packages from the chosen python instead of hardcoding the
+# path. Different base images (and python versions) place purelib under
+# different directories.
+COPY src/mindor /tmp/mindor-src
+RUN target="$(python -c 'import sysconfig; print(sysconfig.get_paths()["purelib"])')/mindor" \
+    && cp -r /tmp/mindor-src "$target" \
+    && rm -rf /tmp/mindor-src
+
+COPY bootstrap.sh /usr/local/bin/bootstrap.sh
+RUN chmod +x /usr/local/bin/bootstrap.sh
+
+WORKDIR /workspace
+ENTRYPOINT [ "/usr/local/bin/bootstrap.sh" ]

model_compose-0.4.85/src/mindor/core/controller/runtime/container/assets/bootstrap.sh

@@ -0,0 +1,14 @@
+#!/bin/sh
+# Controller container entrypoint.
+#
+# When the manager mounts a workspace bundle at /mnt/bootstrap (model-compose.yml
+# and webui dirs), copy it into /workspace before exec'ing the real command.
+# The bundle is rebuilt per launch and mounted read-only so the container can
+# treat /workspace as writable scratch space without affecting the host.
+set -e
+
+if [ -d /mnt/bootstrap ]; then
+    cp -a /mnt/bootstrap/. /workspace/
+fi
+
+exec "$@"

model_compose-0.4.85/src/mindor/core/controller/runtime/container/assets/requirements.stub.txt

@@ -0,0 +1,2 @@
+# Injected in place of the user's requirements.txt when the project has none.
+# Provides an empty file so the derived Dockerfile can COPY unconditionally.

model_compose-0.4.85/src/mindor/core/controller/runtime/container/assets/setup.stub.sh

@@ -0,0 +1,4 @@
+#!/bin/sh
+# Injected in place of the user's setup.sh when the project has none.
+# Provides a no-op so the derived Dockerfile can COPY unconditionally.
+exit 0

{model_compose-0.4.83 → model_compose-0.4.85}/src/mindor/core/foundation/async_service.py

@@ -176,7 +176,11 @@ class AsyncService(ABC):
                 await self._install_package(package_spec, repository)
     
     async def _install_package(self, package_spec: str, repository: Optional[str]) -> None:
-        if repository and not repository.startswith("git+"):
+        if repository and repository.startswith("git+"):
+            await install_package(f"{package_spec} @ {repository}" if package_spec else repository)
+        elif repository and repository.endswith((".whl", ".tar.gz", ".zip")):
+            await install_package(f"{package_spec} @ {repository}" if package_spec else repository)
+        elif repository:
             await install_package(package_spec, ["--index-url", repository])
         else:
-            await install_package(repository or package_spec)
+            await install_package(package_spec)

model_compose-0.4.85/src/mindor/core/runtime/bootstrap/requirements.txt

@@ -0,0 +1,17 @@
+click
+pyyaml
+pydantic
+python-dotenv
+packaging
+docker
+aiohttp
+aiofiles
+brotlicffi
+requests
+fastapi
+websockets
+uvicorn
+mcp>=1.10.1
+ulid
+Pillow
+async_timeout>=4.0; python_version < '3.11'

{model_compose-0.4.83 → model_compose-0.4.85}/src/mindor/core/runtime/virtualenv.py

@@ -146,14 +146,11 @@ class VirtualEnvRuntime:
         if self.config.driver == VirtualEnvDriver.PYENV:
             version = self.config.python
             if not version:
-                raise ValueError(
-                    "VirtualEnvRuntimeConfig.python must be set when driver is 'pyenv'."
-                )
+                raise ValueError("VirtualEnvRuntimeConfig.python must be set when driver is 'pyenv'.")
+
+            logging.info(f"Creating virtualenv at {self._venv_path} (pyenv driver, python {version})")
 
             python_path = self._resolve_pyenv_python(version)
-            logging.info(
-                f"Creating virtualenv at {self._venv_path} (pyenv driver, python {version})"
-            )
             subprocess.run([str(python_path), "-m", "venv", str(self._venv_path)], check=True)
             return
 
@@ -162,29 +159,22 @@ class VirtualEnvRuntime:
     def _resolve_pyenv_python(self, version: str) -> Path:
         try:
             installed = subprocess.check_output([ "pyenv", "versions", "--bare" ], text=True).splitlines()
-        except FileNotFoundError as e:
-            raise RuntimeError(
-                "pyenv command not found. Install pyenv or switch to driver: python."
-            ) from e
+        except FileNotFoundError:
+            raise RuntimeError("pyenv command not found. Install pyenv or switch to driver: python.")
         except subprocess.CalledProcessError as e:
-            raise RuntimeError(f"Failed to list pyenv versions: {e}") from e
+            raise RuntimeError(f"Failed to list pyenv versions: {e}")
 
         if version not in [ v.strip() for v in installed ]:
-            raise RuntimeError(
-                f"Python version '{version}' is not installed in pyenv. "
-                f"Run `pyenv install {version}` first."
-            )
+            raise RuntimeError(f"Python version '{version}' is not installed in pyenv. Run `pyenv install {version}` first.")
 
         try:
             pyenv_root = subprocess.check_output([ "pyenv", "root" ], text=True).strip()
         except subprocess.CalledProcessError as e:
-            raise RuntimeError(f"Failed to resolve pyenv root: {e}") from e
+            raise RuntimeError(f"Failed to resolve pyenv root: {e}")
 
         python_path = Path(pyenv_root) / "versions" / version / "bin" / "python"
         if not python_path.exists():
-            raise RuntimeError(
-                f"pyenv reports {version} as installed but {python_path} does not exist."
-            )
+            raise RuntimeError(f"pyenv reports {version} as installed but {python_path} does not exist.")
         return python_path
 
     def _install_dependencies(self) -> None:

{model_compose-0.4.83 → model_compose-0.4.85}/src/mindor/dsl/schema/action/impl/model/tasks/text_to_speech/impl/custom/impl/__init__.py

@@ -3,3 +3,4 @@ from .kokoro import *
 from .chatterbox import *
 from .luxtts import *
 from .tada import *
+from .cosyvoice import *

model_compose-0.4.85/src/mindor/dsl/schema/action/impl/model/tasks/text_to_speech/impl/custom/impl/cosyvoice.py

@@ -0,0 +1,32 @@
+from typing import Union, Literal, Optional, Annotated
+from pydantic import Field
+from ...common import CommonTextToSpeechModelActionConfig, TextToSpeechActionMethod
+
+class CosyvoiceTextToSpeechModelGenerateActionConfig(CommonTextToSpeechModelActionConfig):
+    method: Literal[TextToSpeechActionMethod.GENERATE]
+    voice: str = Field(..., description="Preset speaker id. On CosyVoice1-SFT models this is a built-in spk_id (e.g. '中文女'); on CosyVoice2/3 it must be a zero-shot speaker previously registered via add_zero_shot_spk / save_spkinfo.")
+    speed: Union[float, str] = Field(default=1.0, description="Speech speed multiplier (1.0 = natural).")
+    text_frontend: Union[bool, str] = Field(default=True, description="Run CosyVoice's text normalization frontend.")
+
+class CosyvoiceTextToSpeechModelCloneActionConfig(CommonTextToSpeechModelActionConfig):
+    method: Literal[TextToSpeechActionMethod.CLONE]
+    reference_audio: str = Field(..., description="Path or URL to the reference audio for zero-shot voice cloning.")
+    reference_text: Optional[str] = Field(default=None, description="Transcription of the reference audio. If omitted, CosyVoice's cross_lingual inference is used instead (works without a transcript).")
+    speed: Union[float, str] = Field(default=1.0, description="Speech speed multiplier (1.0 = natural).")
+    text_frontend: Union[bool, str] = Field(default=True, description="Run CosyVoice's text normalization frontend.")
+
+class CosyvoiceTextToSpeechModelDesignActionConfig(CommonTextToSpeechModelActionConfig):
+    method: Literal[TextToSpeechActionMethod.DESIGN]
+    instructions: str = Field(..., description="Natural-language instruction controlling style, dialect, emotion, etc. (e.g. '用四川话说这句话'). Passed as instruct_text to CosyVoice2/3 inference_instruct2.")
+    reference_audio: str = Field(..., description="Path or URL to the reference audio. CosyVoice2/3 instruct2 requires a prompt wav to condition the target voice.")
+    speed: Union[float, str] = Field(default=1.0, description="Speech speed multiplier (1.0 = natural).")
+    text_frontend: Union[bool, str] = Field(default=True, description="Run CosyVoice's text normalization frontend.")
+
+CosyvoiceTextToSpeechModelActionConfig = Annotated[
+    Union[
+        CosyvoiceTextToSpeechModelGenerateActionConfig,
+        CosyvoiceTextToSpeechModelCloneActionConfig,
+        CosyvoiceTextToSpeechModelDesignActionConfig,
+    ],
+    Field(discriminator="method")
+]

{model_compose-0.4.83 → model_compose-0.4.85}/src/mindor/dsl/schema/component/impl/model/tasks/text_to_speech/impl/custom/custom.py

@@ -5,6 +5,7 @@ from .impl.kokoro import KokoroTextToSpeechModelComponentConfig
 from .impl.chatterbox import ChatterboxTextToSpeechModelComponentConfig
 from .impl.luxtts import LuxttsTextToSpeechModelComponentConfig
 from .impl.tada import TadaTextToSpeechModelComponentConfig
+from .impl.cosyvoice import CosyvoiceTextToSpeechModelComponentConfig
 
 CustomTextToSpeechModelComponentConfig = Annotated[
     Union[
@@ -13,6 +14,7 @@ CustomTextToSpeechModelComponentConfig = Annotated[
         ChatterboxTextToSpeechModelComponentConfig,
         LuxttsTextToSpeechModelComponentConfig,
         TadaTextToSpeechModelComponentConfig,
+        CosyvoiceTextToSpeechModelComponentConfig,
     ],
     Field(discriminator="family")
 ]

{model_compose-0.4.83 → model_compose-0.4.85}/src/mindor/dsl/schema/component/impl/model/tasks/text_to_speech/impl/custom/impl/common.py

@@ -6,3 +6,4 @@ class TextToSpeechModelFamily(str, Enum):
     CHATTERBOX = "chatterbox"
     LUXTTS     = "luxtts"
     TADA       = "tada"
+    COSYVOICE  = "cosyvoice"

model_compose-0.4.85/src/mindor/dsl/schema/component/impl/model/tasks/text_to_speech/impl/custom/impl/cosyvoice.py

@@ -0,0 +1,15 @@
+from typing import Literal, List
+from pydantic import Field
+from mindor.dsl.schema.action import CosyvoiceTextToSpeechModelActionConfig
+from ...common import CommonTextToSpeechModelComponentConfig
+from .common import TextToSpeechModelFamily
+from .....common import ModelDriver
+
+class CosyvoiceTextToSpeechModelComponentConfig(CommonTextToSpeechModelComponentConfig):
+    driver: Literal[ModelDriver.CUSTOM] = Field(default=ModelDriver.CUSTOM)
+    family: Literal[TextToSpeechModelFamily.COSYVOICE]
+    actions: List[CosyvoiceTextToSpeechModelActionConfig] = Field(default_factory=list)
+    load_jit: bool = Field(default=False, description="Load JIT-compiled modules (CUDA only).")
+    load_trt: bool = Field(default=False, description="Load TensorRT engines (CUDA only).")
+    load_vllm: bool = Field(default=False, description="Load vLLM runtime for the LLM stage (CosyVoice2/3 only, CUDA only).")
+    fp16: bool = Field(default=False, description="Run inference in fp16 (CUDA only).")