model-compose 0.4.23__tar.gz → 0.4.24__tar.gz

{model_compose-0.4.23/src/model_compose.egg-info → model_compose-0.4.24}/PKG-INFO

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

{model_compose-0.4.23 → model_compose-0.4.24}/pyproject.toml

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

{model_compose-0.4.23 → model_compose-0.4.24}/src/mindor/cli/compose.py

@@ -4,6 +4,7 @@ from pathlib import Path
 import click
 import asyncio
 import json
+import sys
 
 def _load_compose_config(config_files: List[Path], env_files: List[Path], env_data: List[str]):
     from mindor.dsl.loader import load_compose_config
@@ -70,6 +71,7 @@ def up_command(
                 traceback.print_exc()
             else:
                 click.echo(f"❌ {e}", err=True)
+            raise SystemExit(1)
     asyncio.run(_async_command())
 
 @click.command(name="down")
@@ -104,6 +106,7 @@ def down_command(
                 traceback.print_exc()
             else:
                 click.echo(f"❌ {e}", err=True)
+            raise SystemExit(1)
     asyncio.run(_async_command())
 
 @click.command(name="start")
@@ -138,6 +141,7 @@ def start_command(
                 traceback.print_exc()
             else:
                 click.echo(f"❌ {e}", err=True)
+            raise SystemExit(1)
     asyncio.run(_async_command())
 
 @click.command(name="stop")
@@ -172,6 +176,7 @@ def stop_command(
                 traceback.print_exc()
             else:
                 click.echo(f"❌ {e}", err=True)
+            raise SystemExit(1)
     asyncio.run(_async_command())
 
 @click.command(name="run")
@@ -198,6 +203,7 @@ def stop_command(
     required=False,
     help="Path to save the output result as a file."
 )
+@click.option("--auto-resume", is_flag=True, help="Automatically resume interrupts without prompting.")
 @click.option("--verbose", "-v", is_flag=True, help="Enable verbose output.")
 @click.pass_context
 def run_command(
@@ -207,15 +213,29 @@ def run_command(
     env_files: List[Path],
     env_data: List[str],
     output_path: Optional[Path],
+    auto_resume: bool,
     verbose: bool
 ) -> None:
-    from mindor.core.compose import run_workflow
+    from mindor.core.compose.manager import ComposeManager
+    from mindor.core.controller.base import TaskStatus
+    from mindor.cli.interrupt import prompt_for_interrupt
     config_files = ctx.obj.get("config_files", [])
     async def _async_command():
         try:
             config = _load_compose_config(config_files, env_files, env_data)
             input = json.loads(input_json) if input_json else {}
-            state = await run_workflow(config, workflow_id or "__default__", input, output_path, verbose)
+            is_tty = sys.stdin.isatty()
+
+            manager = ComposeManager(config, daemon=False)
+            state = await manager.run_workflow(workflow_id or "__default__", input, output_path, verbose)
+
+            while state.status == TaskStatus.INTERRUPTED:
+                if not auto_resume and not is_tty:
+                    click.echo("❌ Workflow interrupted but no TTY available. Use --auto-resume to skip.", err=True)
+                    raise SystemExit(1)
+                answer = None if auto_resume else prompt_for_interrupt(state)
+                state = await manager.resume_workflow(state.task_id, state.interrupt.job_id, answer)
+
             if isinstance(state.output, (dict, list)) or state.error:
                 click.echo(json.dumps(
                     state.output or state.error,
@@ -225,8 +245,12 @@ def run_command(
             else:
                 if state.output is not None:
                     click.echo(state.output)
+        except click.exceptions.Abort:
+            click.echo("\nInterrupt cancelled by user.", err=True)
+            raise SystemExit(130)
         except json.JSONDecodeError:
             click.echo("❌ Invalid JSON provided for --input", err=True)
+            raise SystemExit(1)
         except Exception as e:
             if verbose:
                 import traceback
@@ -234,13 +258,68 @@ def run_command(
                 traceback.print_exc()
             else:
                 click.echo(f"❌ {e}", err=True)
+            raise SystemExit(1)
     asyncio.run(_async_command())
 
+@click.command(name="validate")
+@click.option(
+    "--env-file", "env_files", multiple=True,
+    type=click.Path(exists=True, dir_okay=False, path_type=Path),
+    required=False,
+    help="Path to a .env file containing environment variables."
+)
+@click.option(
+    "--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 validate_command(
+    ctx: click.Context,
+    env_files: List[Path],
+    env_data: List[str],
+    verbose: bool
+) -> None:
+    """Validate the compose configuration without starting any services."""
+    from mindor.core.compose import validate_compose_config
+    config_files = ctx.obj.get("config_files", [])
+    try:
+        config = _load_compose_config(config_files, env_files, env_data)
+        errors = validate_compose_config(config)
+
+        if errors:
+            click.echo("❌ Configuration has semantic errors:\n", err=True)
+            for error in errors:
+                click.echo(f"  - {error}", err=True)
+            raise SystemExit(1)
+        else:
+            summary_parts = [f"controller: {config.controller.type.value}"]
+            if config.components:
+                summary_parts.append(f"{len(config.components)} component(s)")
+            if config.workflows:
+                summary_parts.append(f"{len(config.workflows)} workflow(s)")
+            if config.listeners:
+                summary_parts.append(f"{len(config.listeners)} listener(s)")
+            if config.gateways:
+                summary_parts.append(f"{len(config.gateways)} gateway(s)")
+            if config.loggers:
+                summary_parts.append(f"{len(config.loggers)} logger(s)")
+            click.echo(f"✅ Configuration is valid ({', '.join(summary_parts)})")
+    except Exception as e:
+        if verbose:
+            import traceback
+            click.echo(f"❌ Error: {e}\n\nTraceback:", err=True)
+            traceback.print_exc()
+        else:
+            click.echo(f"❌ {e}", err=True)
+        raise SystemExit(1)
+
 compose_command.add_command(up_command)
 compose_command.add_command(down_command)
 compose_command.add_command(start_command)
 compose_command.add_command(stop_command)
 compose_command.add_command(run_command)
+compose_command.add_command(validate_command)
 
 if __name__ == "__main__":
     compose_command()

model_compose-0.4.24/src/mindor/cli/interrupt.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any
+import click
+import json
+
+if TYPE_CHECKING:
+    from mindor.core.controller.base import TaskState
+
+def prompt_for_interrupt(state: TaskState) -> Any:
+    interrupt = state.interrupt
+
+    click.echo("", err=True)
+    click.echo(f"--- Interrupted (job: {interrupt.job_id}, phase: {interrupt.phase}) ---", err=True)
+
+    if interrupt.message:
+        click.echo(f"\n{interrupt.message}", err=True)
+
+    if interrupt.metadata:
+        click.echo(json.dumps(interrupt.metadata, indent=2, ensure_ascii=False), err=True)
+
+    click.echo("", err=True)
+    raw = click.prompt("Enter response (JSON or text, empty to continue)", default="", show_default=False)
+
+    if not raw:
+        return None
+
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError:
+        return raw

{model_compose-0.4.23 → model_compose-0.4.24}/src/mindor/core/component/context.py

@@ -1,5 +1,5 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
-from mindor.core.utils.renderers import VariableRenderer, ImageValueRenderer
+from mindor.core.utils.renderers import VariableRenderer, ImageValueRenderer, FileValueRenderer
 from mindor.core.gateway import find_gateway_by_port
 from PIL import Image as PILImage
 
@@ -20,6 +20,9 @@ class ComponentActionContext:
     async def render_image(self, value: Any) -> Optional[PILImage.Image]:
         return await ImageValueRenderer().render(await self.render_variable(value))
 
+    async def render_file(self, value: Any) -> Optional[str]:
+        return await FileValueRenderer().render(await self.render_variable(value))
+
     def contains_variable_reference(self, key: str, value: Any) -> bool:
         return self.renderer.contains_reference(key, value)
 

{model_compose-0.4.23 → model_compose-0.4.24}/src/mindor/core/component/services/__init__.py

@@ -10,3 +10,4 @@ from .shell import *
 from .text_splitter import *
 from .image_processor import *
 from .web_scraper import *
+from .agent import *

model_compose-0.4.24/src/mindor/core/component/services/agent.py

@@ -0,0 +1,194 @@
+from typing import Optional, Dict, List, Any
+from mindor.dsl.schema.component import AgentComponentConfig
+from mindor.dsl.schema.action import ActionConfig, AgentActionConfig, AgentModelConfig
+from mindor.core.component import ComponentService, ComponentGlobalConfigs, ComponentResolver, create_component
+from mindor.core.workflow import Workflow, WorkflowResolver, create_workflow
+from mindor.core.workflow.tool import WorkflowToolGenerator, WorkflowTool
+from mindor.core.workflow.schema import create_workflow_schemas
+from ..base import ComponentType, register_component
+from ..context import ComponentActionContext
+import asyncio, ulid, json
+
+_JSON_SCHEMA_TYPE_MAP = { "int": "integer", "float": "number", "bool": "boolean", "list[dict]": "array" }
+
+class AgentAction:
+    def __init__(self, action: AgentActionConfig, config: AgentComponentConfig, global_configs: ComponentGlobalConfigs, tools: Dict[str, WorkflowTool], function_schemas: List[Dict[str, Any]]):
+        self.action: AgentActionConfig = action
+        self.config: AgentComponentConfig = config
+        self.global_configs: ComponentGlobalConfigs = global_configs
+        self.tools: Dict[str, WorkflowTool] = tools
+        self.function_schemas: List[Dict[str, Any]] = function_schemas
+
+    async def run(self, context: ComponentActionContext) -> Any:
+        messages: List[Dict[str, Any]] = await self._build_initial_messages(context)
+
+        model_config = self.action.model
+        model_component = self._create_component(model_config.component)
+        if not model_component.started:
+            await model_component.start()
+
+        max_iteration_count = self.action.max_iteration_count or self.config.max_iteration_count
+        tools = self.function_schemas if self.function_schemas else None
+        streaming = await context.render_variable(self.action.streaming)
+
+        if streaming:
+            async def _stream_message_generator():
+                for message in messages:
+                    yield message
+
+                for _ in range(max_iteration_count):
+                    model_input = await self._render_model_input(context, model_config.input, messages, tools)
+                    response = await model_component.run(model_config.action, ulid.ulid(), model_input)
+
+                    assistant_message = await self._build_assistant_message(response)
+                    messages.append(assistant_message)
+                    yield assistant_message
+
+                    tool_calls = self._extract_tool_calls(response)
+                    if not tool_calls:
+                        break
+
+                    tool_messages = await asyncio.gather(*[self._execute_tool_call(tc) for tc in tool_calls])
+                    for tool_message in tool_messages:
+                        messages.append(tool_message)
+                        yield tool_message
+
+            return _stream_message_generator()
+
+        for _ in range(max_iteration_count):
+            model_input = await self._render_model_input(context, model_config.input, messages, tools)
+            response = await model_component.run(model_config.action, ulid.ulid(), model_input)
+
+            assistant_message = await self._build_assistant_message(response)
+            messages.append(assistant_message)
+ 
+            tool_calls = self._extract_tool_calls(response)
+            if not tool_calls:
+                break
+
+            tool_messages = await asyncio.gather(*[self._execute_tool_call(tc) for tc in tool_calls])
+            for tool_message in tool_messages:
+                messages.append(tool_message)
+
+        return messages
+
+    async def _execute_tool_call(self, tool_call: Dict[str, Any]) -> Dict[str, Any]:
+        tool_name = tool_call["function"]["name"]
+        tool_arguments = tool_call["function"].get("arguments", {})
+        if isinstance(tool_arguments, str):
+            tool_arguments = json.loads(tool_arguments)
+
+        if tool_name in self.tools:
+            result = await self.tools[tool_name].fn(**tool_arguments)
+            content = json.dumps(result) if isinstance(result, (dict, list)) else str(result)
+        else:
+            content = f"Error: Unknown tool '{tool_name}'"
+
+        return { "role": "tool", "tool_call_id": tool_call.get("id", ""), "content": content }
+
+    def _create_component(self, component_id: str) -> ComponentService:
+        _, config = ComponentResolver(self.global_configs.components).resolve(component_id)
+        return create_component(component_id, config, self.global_configs, daemon=False)
+
+    async def _render_model_input(self, context: ComponentActionContext, input_mapping: Dict[str, Any], messages: List[Dict[str, Any]], tools: Optional[List[Dict[str, Any]]]) -> Dict[str, Any]:
+        context.register_source("messages", messages)
+        if tools:
+            context.register_source("tools", tools)
+
+        return await context.render_variable(input_mapping)
+
+    def _extract_tool_calls(self, response: Any) -> Optional[List[Dict[str, Any]]]:
+        if isinstance(response, dict):
+            return response.get("tool_calls")
+        return None
+
+    def _extract_content(self, response: Any) -> Any:
+        if isinstance(response, dict):
+            return response.get("content", response)
+        return response
+
+    async def _build_initial_messages(self, context: ComponentActionContext) -> List[Dict[str, Any]]:
+        messages: List[Dict[str, Any]] = []
+
+        if self.action.system_prompt:
+            system = await context.render_variable(self.action.system_prompt)
+            messages.append({ "role": "system", "content": system if isinstance(system, str) else json.dumps(system) })
+
+        user_input = self.action.user_prompt
+        user = (await context.render_variable(user_input)) if user_input else context.input
+        messages.append({ "role": "user", "content": user if isinstance(user, str) else json.dumps(user) })
+
+        return messages
+
+    async def _build_assistant_message(self, response: Any) -> Dict[str, Any]:
+        if isinstance(response, dict):
+            message: Dict[str, Any] = {"role": "assistant"}
+            if "content" in response:
+                message["content"] = response["content"]
+            if "tool_calls" in response:
+                message["tool_calls"] = response["tool_calls"]
+            return message
+        return { "role": "assistant", "content": str(response) }
+
+async def _build_function_schema(name: str, tool: WorkflowTool) -> Dict[str, Any]:
+    properties: Dict[str, Any] = {}
+    required: List[str] = []
+
+    for param in tool.parameters:
+        prop: Dict[str, Any] = { "type": _JSON_SCHEMA_TYPE_MAP.get(param.type, "string") }
+        if param.description:
+            prop["description"] = param.description
+        if param.default is not None:
+            prop["default"] = param.default
+        if param.required:
+            required.append(param.name)
+        properties[param.name] = prop
+
+    schema: Dict[str, Any] = {
+        "type": "function",
+        "function": {
+            "name": name,
+            "parameters": {"type": "object", "properties": properties}
+        }
+    }
+
+    if tool.description:
+        schema["function"]["description"] = tool.description
+    if required:
+        schema["function"]["parameters"]["required"] = required
+
+    return schema
+
+@register_component(ComponentType.AGENT)
+class AgentComponent(ComponentService):
+    def __init__(self, id: str, config: AgentComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
+        super().__init__(id, config, global_configs, daemon)
+
+        self.tools: Optional[Dict[str, WorkflowTool]] = None
+        self.function_schemas: Optional[List[Dict[str, Any]]] = None
+
+    async def _start(self) -> None:
+        self.tools = await self._generate_tools()
+        self.function_schemas = await asyncio.gather(*[ _build_function_schema(name, tool) for name, tool in self.tools.items() ])
+        await super()._start()
+
+    async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
+        return await AgentAction(action, self.config, self.global_configs, self.tools, self.function_schemas).run(context)
+
+    async def _generate_tools(self) -> Dict[str, WorkflowTool]:
+        workflow_schemas = create_workflow_schemas(self.global_configs.workflows, self.global_configs.components)
+        tools: Dict[str, WorkflowTool] = {}
+
+        for workflow_id in self.config.tools:
+            if workflow_id not in workflow_schemas:
+                raise ValueError(f"Workflow not found for tool: {workflow_id}")
+
+            workflow = workflow_schemas[workflow_id]
+            tool = WorkflowToolGenerator().generate(workflow_id, workflow, self._run_workflow)
+            tools[workflow.name or workflow_id] = tool
+
+        return tools
+
+    async def _run_workflow(self, workflow_id: str, input: Any) -> Any:
+        workflow = create_workflow(*WorkflowResolver(self.global_configs.workflows).resolve(workflow_id), self.global_configs)
+        return await workflow.run(ulid.ulid(), input)

{model_compose-0.4.23 → model_compose-0.4.24}/src/mindor/core/component/services/http_client.py

@@ -97,12 +97,12 @@ class HttpClientAction:
         response, result = await client.request(url_or_path, method, params, body, headers), None
 
         if isinstance(response, HttpEventStreamResource) and context.contains_variable_reference("response[]", self.config.output):
-            async def _stream_generator(stream: HttpEventStreamResource):
+            async def _stream_output_generator(stream: HttpEventStreamResource):
                 async for chunk in stream:
                     context.register_source("response[]", self._convert_stream_chunk(chunk))
                     yield await context.render_variable(self.config.output, ignore_files=True)
 
-            return _stream_generator(response)
+            return _stream_output_generator(response)
 
         context.register_source("response", response)
 
@@ -110,12 +110,12 @@ class HttpClientAction:
             result = await self.completion.run(context, client)
 
             if isinstance(result, HttpEventStreamResource) and context.contains_variable_reference("result[]", self.config.output):
-                async def _stream_generator(stream: HttpEventStreamResource):
+                async def _stream_output_generator(stream: HttpEventStreamResource):
                     async for chunk in stream:
                         context.register_source("result[]", self._convert_stream_chunk(chunk))
                         yield await context.render_variable(self.config.output, ignore_files=True)
 
-                return _stream_generator(result)
+                return _stream_output_generator(result)
 
             context.register_source("result", result)
 

{model_compose-0.4.23 → model_compose-0.4.24}/src/mindor/core/component/services/http_server.py

@@ -92,12 +92,12 @@ class HttpServerAction:
         response, result = await client.request(path or "", method, params, body, headers), None
 
         if isinstance(response, HttpEventStreamResource) and context.contains_variable_reference("response[]", self.config.output):
-            async def _stream_generator(stream: HttpEventStreamResource):
+            async def _stream_output_generator(stream: HttpEventStreamResource):
                 async for chunk in stream:
                     context.register_source("response[]", self._convert_stream_chunk(chunk))
                     yield await context.render_variable(self.config.output, ignore_files=True)
 
-            return _stream_generator(response)
+            return _stream_output_generator(response)
 
         context.register_source("response", response)
 
@@ -105,12 +105,12 @@ class HttpServerAction:
             result = await self.completion.run(context, client)
 
             if isinstance(result, HttpEventStreamResource) and context.contains_variable_reference("result[]", self.config.output):
-                async def _stream_generator(stream: HttpEventStreamResource):
+                async def _stream_output_generator(stream: HttpEventStreamResource):
                     async for chunk in stream:
                         context.register_source("result[]", self._convert_stream_chunk(chunk))
                         yield await context.render_variable(self.config.output, ignore_files=True)
 
-                return _stream_generator(result)
+                return _stream_output_generator(result)
 
             context.register_source("result", result)
 

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

@@ -5,3 +5,4 @@ from .text_embedding import *
 from .image_to_text import *
 from .image_upscale import *
 from .face_embedding import *
+from .text_to_speech import *

{model_compose-0.4.23 → model_compose-0.4.24}/src/mindor/core/component/services/model/tasks/image_upscale/common.py

@@ -51,7 +51,7 @@ class ImageUpscaleTaskAction:
         
         raise ValueError(f"Unsupported color format: {color_format}")
 
-    def _downsample_image(self, image: PILImage.Image, method: Literal["lanczos", "bicubic"], scale: int = 4) -> PILImage.Image:
+    def _downsample_image(self, image: PILImage.Image, method: Literal[ "lanczos", "bicubic" ], scale: int = 4) -> PILImage.Image:
         downsample_size = (max(1, image.size[0] // scale), max(1, image.size[1] // scale))
         
         if method not in _resample_map:

{model_compose-0.4.23 → model_compose-0.4.24}/src/mindor/core/component/services/model/tasks/image_upscale/custom.py

@@ -1,24 +1,24 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, TypeAlias, Any
-from mindor.dsl.schema.component import ModelComponentConfig, ImageUpscaleModelArchitecture
+from mindor.dsl.schema.component import ModelComponentConfig, ImageUpscaleModelFamily
 from ...base import ModelTaskType, ModelDriver, register_model_task_service
 
 @register_model_task_service(ModelTaskType.IMAGE_UPSCALE, ModelDriver.CUSTOM)
 class CustomImageUpscaleTaskService:
     def __new__(cls, id: str, config: ModelComponentConfig, daemon: bool):
-        if config.architecture == ImageUpscaleModelArchitecture.ESRGAN:
+        if config.family == ImageUpscaleModelFamily.ESRGAN:
             from .esrgan import EsrganImageUpscaleTaskService
             return EsrganImageUpscaleTaskService(id, config, daemon)
 
-        if config.architecture == ImageUpscaleModelArchitecture.REAL_ESRGAN:
+        if config.family == ImageUpscaleModelFamily.REAL_ESRGAN:
             from .real_esrgan import RealEsrganImageUpscaleTaskService
             return RealEsrganImageUpscaleTaskService(id, config, daemon)
 
-        if config.architecture == ImageUpscaleModelArchitecture.LDSR:
+        if config.family == ImageUpscaleModelFamily.LDSR:
             from .ldsr import LdsrImageUpscaleTaskService
             return LdsrImageUpscaleTaskService(id, config, daemon)
 
-        if config.architecture == ImageUpscaleModelArchitecture.SWINIR:
+        if config.family == ImageUpscaleModelFamily.SWINIR:
             from .swinir import SwinIRImageUpscaleTaskService
             return SwinIRImageUpscaleTaskService(id, config, daemon)
 
-        raise ValueError(f"Unknown architecture: {config.architecture}")
+        raise ValueError(f"Unknown family: {config.family}")

model_compose-0.4.24/src/mindor/core/component/services/model/tasks/text_to_speech/__init__.py

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

model_compose-0.4.24/src/mindor/core/component/services/model/tasks/text_to_speech/common.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, TypeAlias, Any
+from abc import ABC, abstractmethod
+from mindor.dsl.schema.action import TextToSpeechModelActionConfig
+from mindor.core.logger import logging
+from ...base import ModelTaskService, ComponentActionContext
+
+if TYPE_CHECKING:
+    import torch
+
+class TextToSpeechTaskAction:
+    def __init__(self, config: TextToSpeechModelActionConfig, device: Optional[torch.device]):
+        self.config: TextToSpeechModelActionConfig = config
+        self.device: Optional[torch.device] = device
+
+    async def run(self, context: ComponentActionContext) -> Any:
+        text = await self._prepare_input(context)
+        is_single_input = not isinstance(text, list)
+        texts: List[str] = [ text ] if is_single_input else text
+        results = []
+
+        for t in texts:
+            audio_bytes = await self._generate(t, context)
+            results.append(audio_bytes)
+
+        return results[0] if is_single_input else results
+
+    async def _prepare_input(self, context: ComponentActionContext) -> Union[str, List[str]]:
+        return await context.render_variable(self.config.text)
+
+    @abstractmethod
+    async def _generate(self, text: str, context: ComponentActionContext) -> bytes:
+        pass
+
+class TextToSpeechTaskService(ModelTaskService):
+    pass

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

@@ -0,0 +1,12 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, TypeAlias, Any
+from mindor.dsl.schema.component import ModelComponentConfig, TextToSpeechModelFamily
+from ...base import ModelTaskType, ModelDriver, register_model_task_service
+
+@register_model_task_service(ModelTaskType.TEXT_TO_SPEECH, ModelDriver.CUSTOM)
+class CustomTextToSpeechTaskService:
+    def __new__(cls, id: str, config: ModelComponentConfig, daemon: bool):
+        if config.family == TextToSpeechModelFamily.QWEN:
+            from .qwen import QwenTextToSpeechTaskService
+            return QwenTextToSpeechTaskService(id, config, daemon)
+
+        raise ValueError(f"Unknown family: {config.family}")