model-compose 0.2.8__tar.gz → 0.2.10__tar.gz

{model_compose-0.2.8/src/model_compose.egg-info → model_compose-0.2.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.2.8
+Version: 0.2.10
 Summary: model-compose: Declarative AI Model and Workflow Orchestrator
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT
@@ -20,6 +20,8 @@ Requires-Dist: pyngrok
 Requires-Dist: ulid
 Requires-Dist: gradio
 Requires-Dist: Pillow
+Requires-Dist: transformers
+Requires-Dist: torch
 Dynamic: license-file
 
 # model-compose: Declarative AI Model and Workflow Orchestrator

{model_compose-0.2.8 → model_compose-0.2.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.2.8"
+version = "0.2.10"
 description = "model-compose: Declarative AI Model and Workflow Orchestrator"
 authors = [
     { name = "Hanyeol Cho", email = "hanyeol.cho@gmail.com" }
@@ -20,7 +20,9 @@ dependencies = [
     "pyngrok", 
     "ulid", 
     "gradio",
-    "Pillow"
+    "Pillow",
+    "transformers",
+    "torch"
 ]
 
 [project.scripts]

{model_compose-0.2.8 → model_compose-0.2.10}/src/mindor/core/component/services/__init__.py

@@ -2,5 +2,6 @@ from .http_server import *
 from .http_client import *
 from .mcp_server import *
 from .mcp_client import *
+from .model import *
 from .workflow import *
 from .shell import *

{model_compose-0.2.8 → model_compose-0.2.10}/src/mindor/core/component/services/http_server.py

@@ -4,6 +4,13 @@ from mindor.dsl.schema.action import ActionConfig, HttpServerActionConfig
 from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
 from ..context import ComponentActionContext
 
+class HttpServerAction:
+    def __init__(self, config: HttpServerActionConfig):
+        self.config: HttpServerActionConfig = config
+
+    async def run(self, context: ComponentActionContext) -> Any:
+        pass
+
 @register_component(ComponentType.HTTP_SERVER)
 class HttpServerComponent(ComponentService):
     def __init__(self, id: str, config: HttpServerComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
@@ -16,4 +23,4 @@ class HttpServerComponent(ComponentService):
         pass
 
     async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
-        return {}
+        return await HttpServerAction(action).run(context)

{model_compose-0.2.8 → model_compose-0.2.10}/src/mindor/core/component/services/mcp_client.py

@@ -5,7 +5,7 @@ from mindor.core.utils.mcp_client import McpClient, ContentBlock, TextContent, I
 from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
 from ..context import ComponentActionContext
 
-class McpClientAction():
+class McpClientAction:
     def __init__(self, config: McpClientActionConfig):
         self.config: McpClientActionConfig = config
 

{model_compose-0.2.8 → model_compose-0.2.10}/src/mindor/core/component/services/mcp_server.py

@@ -4,6 +4,13 @@ from mindor.dsl.schema.action import ActionConfig, McpServerActionConfig
 from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
 from ..context import ComponentActionContext
 
+class McpServerAction:
+    def __init__(self, config: McpServerActionConfig):
+        self.config: McpServerActionConfig = config
+
+    async def run(self, context: ComponentActionContext) -> Any:
+        pass
+
 @register_component(ComponentType.MCP_SERVER)
 class McpServerComponent(ComponentService):
     def __init__(self, id: str, config: McpServerComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
@@ -16,4 +23,5 @@ class McpServerComponent(ComponentService):
         pass
 
     async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
-        return {}
+        return await McpServerAction(action).run(context)
+

model_compose-0.2.10/src/mindor/core/component/services/model/__init__.py

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

model_compose-0.2.10/src/mindor/core/component/services/model/base.py

@@ -0,0 +1,28 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Any
+from abc import ABC, abstractmethod
+from mindor.dsl.schema.component import ModelComponentConfig, ModelTaskType
+from mindor.dsl.schema.action import ModelActionConfig
+from mindor.core.services import AsyncService
+from ...context import ComponentActionContext
+
+class ModelTaskService(AsyncService):
+    def __init__(self, id: str, config: ModelComponentConfig, daemon: bool):
+        super().__init__(daemon)
+
+        self.id: str = id
+        self.config: ModelComponentConfig = config
+
+    async def run(self, action: ModelActionConfig, context: ComponentActionContext) -> Any:
+        return await self._run(action, context)
+
+    @abstractmethod
+    async def _run(self, action: ModelActionConfig, context: ComponentActionContext) -> Any:
+        pass
+
+def register_model_task_service(type: ModelTaskType):
+    def decorator(cls: Type[ModelTaskService]) -> Type[ModelTaskService]:
+        ModelTaskServiceRegistry[type] = cls
+        return cls
+    return decorator
+
+ModelTaskServiceRegistry: Dict[ModelTaskType, Type[ModelTaskService]] = {}

model_compose-0.2.10/src/mindor/core/component/services/model/model.py

@@ -0,0 +1,37 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, AsyncIterator, Any
+from mindor.dsl.schema.component import ModelComponentConfig, ModelTaskType
+from mindor.dsl.schema.action import ActionConfig, ModelActionConfig
+from ...base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
+from ...context import ComponentActionContext
+from .base import ModelTaskService, ModelTaskServiceRegistry
+
+class ModelAction:
+    def __init__(self, config: ModelActionConfig):
+        self.config: ModelActionConfig = config
+
+    async def run(self, context: ComponentActionContext, task_service: ModelTaskService) -> Any:
+        return await task_service.run(self.config, context)
+
+@register_component(ComponentType.MODEL)
+class ModelComponent(ComponentService):
+    def __init__(self, id: str, config: ModelComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
+        super().__init__(id, config, global_configs, daemon)
+
+        self.task_service = self._create_task_service(self.config.task)
+
+    def _create_task_service(self, type: ModelTaskType) -> ModelTaskService:
+        try:
+            if not ModelTaskServiceRegistry:
+                from . import tasks
+            return ModelTaskServiceRegistry[type](self.id, self.config, self.daemon)
+        except KeyError:
+            raise ValueError(f"Unsupported component type: {type}")
+
+    async def _serve(self) -> None:
+        await self.task_service.start()
+
+    async def _shutdown(self) -> None:
+        await self.task_service.stop()
+
+    async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
+        return await ModelAction(action).run(context, self.task_service)

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

@@ -0,0 +1,2 @@
+from .text_generation import *
+from .text_embedding import *

model_compose-0.2.10/src/mindor/core/component/services/model/tasks/text_embedding.py

@@ -0,0 +1,83 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.component import ModelComponentConfig
+from mindor.dsl.schema.action import ModelActionConfig, TextEmbeddingModelActionConfig
+from ..base import ModelTaskService, ModelTaskType, register_model_task_service
+from ..base import ComponentActionContext
+from transformers import AutoModel, AutoTokenizer, PreTrainedModel, PreTrainedTokenizer
+from transformers.modeling_outputs import BaseModelOutput
+from torch import Tensor
+import torch
+
+class TextEmbeddingTaskAction:
+    def __init__(self, config: TextEmbeddingModelActionConfig, model: PreTrainedModel, tokenizer: PreTrainedTokenizer):
+        self.config: TextEmbeddingModelActionConfig = config
+        self.model: PreTrainedModel = model
+        self.tokenizer: PreTrainedTokenizer = tokenizer
+
+    async def run(self, context: ComponentActionContext) -> Any:
+        text = await context.render_variable(self.config.text)
+
+        # Model parameters
+        max_length = await context.render_variable(self.config.params.max_length)
+        pooling    = await context.render_variable(self.config.params.pooling)
+        normalize  = await context.render_variable(self.config.params.normalize)
+
+        # Tokenizing
+        inputs = self.tokenizer(text, return_tensors="pt", padding=True, truncation=True, max_length=max_length).to(self.model.device)
+        attention_mask: Tensor = inputs.get("attention_mask", None)
+
+        # Forward pass through the model
+        with torch.no_grad():
+            outputs: BaseModelOutput = self.model(**inputs)
+            last_hidden_state = outputs.last_hidden_state  # (batch_size, seq_len, hidden_size)
+
+        # Apply pooling strategy (mean, cls, max)
+        embedding = self._pool_hidden_state(last_hidden_state, attention_mask, pooling)
+
+        if normalize:
+            embedding = torch.nn.functional.normalize(embedding, p=2, dim=1)
+
+        result = embedding.squeeze().tolist()
+        context.register_source("result", result)
+
+        return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result
+
+    def _pool_hidden_state(self, last_hidden_state: Tensor, attention_mask: Optional[Tensor], pooling: str) -> Tensor:
+        if pooling == "mean":
+            if attention_mask is not None:
+                mask = attention_mask.unsqueeze(-1).expand(last_hidden_state.size())
+                summed = torch.sum(last_hidden_state * mask, dim=1)
+                count = torch.clamp(mask.sum(dim=1), min=1e-9)
+                return summed / count
+            else:
+                return torch.mean(last_hidden_state, dim=1)
+
+        if pooling == "cls":
+            return last_hidden_state[:, 0]
+
+        if pooling == "max":
+            if attention_mask is not None:
+                mask = attention_mask.unsqueeze(-1).expand(last_hidden_state.size())
+                last_hidden_state = last_hidden_state.masked_fill(mask == 0, -1e9)
+            return torch.max(last_hidden_state, dim=1).values
+
+        raise ValueError(f"Unsupported pooling type: {pooling}")
+
+@register_model_task_service(ModelTaskType.TEXT_EMBEDDING)
+class TextEmbeddingTaskService(ModelTaskService):
+    def __init__(self, id: str, config: ModelComponentConfig, daemon: bool):
+        super().__init__(id, config, daemon)
+
+        self.model: Optional[PreTrainedModel] = None
+        self.tokenizer: Optional[PreTrainedTokenizer] = None
+
+    async def _serve(self) -> None:
+        self.model = AutoModel.from_pretrained(self.config.model).to(torch.device(self.config.device))
+        self.tokenizer = AutoTokenizer.from_pretrained(self.config.model)
+
+    async def _shutdown(self) -> None:
+        self.model = None
+        self.tokenizer = None
+
+    async def _run(self, action: ModelActionConfig, context: ComponentActionContext) -> Any:
+        return await TextEmbeddingTaskAction(action, self.model, self.tokenizer).run(context)

model_compose-0.2.10/src/mindor/core/component/services/model/tasks/text_generation.py

@@ -0,0 +1,63 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.component import ModelComponentConfig
+from mindor.dsl.schema.action import ModelActionConfig, TextGenerationModelActionConfig
+from ..base import ModelTaskService, ModelTaskType, register_model_task_service
+from ..base import ComponentActionContext
+from transformers import AutoModelForCausalLM, AutoTokenizer, PreTrainedModel, PreTrainedTokenizer, GenerationMixin
+import torch
+
+class TextGenerationTaskAction:
+    def __init__(self, config: TextGenerationModelActionConfig, model: Union[PreTrainedModel, GenerationMixin], tokenizer: PreTrainedTokenizer):
+        self.config: TextGenerationModelActionConfig = config
+        self.model: Union[PreTrainedModel, GenerationMixin] = model
+        self.tokenizer: PreTrainedTokenizer = tokenizer
+
+    async def run(self, context: ComponentActionContext) -> Any:
+        prompt: str = await context.render_variable(self.config.prompt)
+
+        # Model parameters
+        max_length           = await context.render_variable(self.config.params.max_length)
+        num_return_sequences = await context.render_variable(self.config.params.num_return_sequences)
+        temperature          = await context.render_variable(self.config.params.temperature)
+        top_k                = await context.render_variable(self.config.params.top_k)
+        top_p                = await context.render_variable(self.config.params.top_p)
+
+        # Tokenizing
+        inputs = self.tokenizer(prompt, return_tensors="pt").to(self.model.device)
+
+        # Text generation
+        with torch.no_grad():
+            outputs = self.model.generate(
+                **inputs,
+                max_length=max_length,
+                num_return_sequences=num_return_sequences,
+                temperature=temperature,
+                top_k=top_k,
+                top_p=top_p,
+                do_sample=True
+            )
+
+        # Decoding output
+        result = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)
+        context.register_source("result", result)
+
+        return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result
+
+@register_model_task_service(ModelTaskType.TEXT_GENERATION)
+class TextGenerationTaskService(ModelTaskService):
+    def __init__(self, id: str, config: ModelComponentConfig, daemon: bool):
+        super().__init__(id, config, daemon)
+
+        self.model: Optional[Union[PreTrainedModel, GenerationMixin]] = None
+        self.tokenizer: Optional[PreTrainedTokenizer] = None
+
+    async def _serve(self) -> None:
+        self.model = AutoModelForCausalLM.from_pretrained(self.config.model).to(torch.device(self.config.device))
+        self.tokenizer = AutoTokenizer.from_pretrained(self.config.model)
+
+    async def _shutdown(self) -> None:
+        self.model = None
+        self.tokenizer = None
+
+    async def _run(self, action: ModelActionConfig, context: ComponentActionContext) -> Any:
+        return await TextGenerationTaskAction(action, self.model, self.tokenizer).run(context)

{model_compose-0.2.8 → model_compose-0.2.10}/src/mindor/core/controller/webui/gradio.py

@@ -49,7 +49,8 @@ class GradioWebUIBuilder:
             async def _run_workflow(*args):
                 input = await self._build_input_value(args, workflow.input)
                 output = await runner(input)
-                output = await self._flatten_output_value(output, workflow.output)
+                if workflow.output:
+                    output = await self._flatten_output_value(output, workflow.output)
                 return output[0] if len(output) == 1 else output
 
             run_button.click(

{model_compose-0.2.8 → model_compose-0.2.10}/src/mindor/core/controller/webui/webui.py

@@ -6,9 +6,8 @@ from mindor.core.controller.runner import ControllerRunner
 from mindor.core.workflow.schema import create_workflow_schema
 from mindor.core.services import AsyncService
 from .gradio import GradioWebUIBuilder
-
-from fastapi import FastAPI
 from gradio import mount_gradio_app
+from fastapi import FastAPI
 import uvicorn, gradio
 
 class ControllerWebUI(AsyncService):

{model_compose-0.2.8 → model_compose-0.2.10}/src/mindor/core/logger/services/console.py

@@ -1,6 +1,7 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Iterator, Any
 from mindor.dsl.schema.logger import ConsoleLoggerConfig
 from ..base import LoggerService, LoggerType, LoggingLevel, register_logger
+from uvicorn.logging import ColourizedFormatter
 import logging
 
 _level_map = {
@@ -17,7 +18,7 @@ class ConsoleLogger(LoggerService):
         super().__init__(id, config, daemon)
 
         self.logger: logging.Logger = logging.getLogger(id)
-        self.formatter: logging.Formatter = logging.Formatter("%(levelname)s: %(message)s")
+        self.formatter: logging.Formatter = ColourizedFormatter("%(levelprefix)s %(message)s")
         self.handler: logging.StreamHandler = None
 
         self._configure_logger()

{model_compose-0.2.8 → model_compose-0.2.10}/src/mindor/core/utils/time.py

@@ -2,6 +2,16 @@ from typing import Union, Optional
 from datetime import timedelta, datetime
 import zoneinfo
 
+class TimeTracker:
+    def __init__(self):
+        self._start = datetime.now()
+
+    def elapsed(self) -> float:
+        return (datetime.now() - self._start).total_seconds()
+
+    def reset(self) -> None:
+        self._start = datetime.now()
+
 def parse_duration(value: Union[str, float, int]) -> timedelta:
     if isinstance(value, (float, int)):
         return timedelta(seconds=value)

{model_compose-0.2.8 → model_compose-0.2.10}/src/mindor/core/workflow/job/impl/action.py

@@ -2,6 +2,7 @@ from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annot
 from mindor.dsl.schema.job import ActionJobConfig, JobType
 from mindor.dsl.schema.component import ComponentConfig
 from mindor.core.component import ComponentService, ComponentGlobalConfigs, ComponentResolver, create_component
+from mindor.core.utils.time import TimeTracker
 from mindor.core.logger import logging
 from ..base import Job, JobType, WorkflowContext, register_job
 from datetime import datetime
@@ -24,14 +25,13 @@ class ActionJob(Job):
         async def _run_once():
             run_id: str = ulid.ulid()
 
-            started_at = datetime.now()
+            job_time_tracker = TimeTracker()
             logging.debug("[task-%s] Action 'run-%s' started for job '%s'", context.task_id, run_id, self.id)
 
             output = await component.run(await context.render_variable(self.config.action), run_id, input)
             context.register_source("output", output)
 
-            elapsed = (datetime.now() - started_at).total_seconds()
-            logging.debug("[task-%s] Action 'run-%s' completed in %.2f seconds.", context.task_id, run_id, elapsed)
+            logging.debug("[task-%s] Action 'run-%s' completed in %.2f seconds.", context.task_id, run_id, job_time_tracker.elapsed())
 
             output = (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else output
             outputs.append(output)

{model_compose-0.2.8 → model_compose-0.2.10}/src/mindor/core/workflow/job/impl/delay.py

@@ -1,7 +1,7 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Any
 from mindor.dsl.schema.job import DelayJobConfig, DelayJobMode
 from mindor.dsl.schema.component import ComponentConfig
-from mindor.core.utils.time import parse_duration, parse_datetime
+from mindor.core.utils.time import parse_duration, parse_datetime, TimeTracker
 from mindor.core.logger import logging
 from ..base import Job, JobType, WorkflowContext, register_job
 from datetime import datetime, timedelta
@@ -25,14 +25,13 @@ class DelayJob(Job):
         duration = parse_duration((await context.render_variable(self.config.duration)) or 0.0)
         duration = duration.total_seconds()
         
-        started_at = datetime.now()
+        job_time_tracker = TimeTracker()
         logging.debug("[task-%s] Delay started for time interval: %d seconds.", context.task_id, int(duration))
 
         if duration > 0.0:
             await asyncio.sleep(duration)
 
-        elapsed = (datetime.now() - started_at).total_seconds()
-        logging.debug("[task-%s] Delay completed in %.2f seconds.", context.task_id, elapsed)
+        logging.debug("[task-%s] Delay completed in %.2f seconds.", context.task_id, job_time_tracker.elapsed())
 
         return None
 
@@ -43,13 +42,12 @@ class DelayJob(Job):
         now = datetime.now(tz=time.tzinfo)
         duration = max((time - now).total_seconds(), 0.0)
 
-        started_at = datetime.now()
+        job_time_tracker = TimeTracker()
         logging.debug("[task-%s] Delay started, waiting until %s", context.task_id, time)
 
         if duration > 0.0:
             await asyncio.sleep(duration)
 
-        elapsed = (datetime.now() - started_at).total_seconds()
-        logging.debug("[task-%s] Delay completed in %.2f seconds.", context.task_id, elapsed)
+        logging.debug("[task-%s] Delay completed in %.2f seconds.", context.task_id, job_time_tracker.elapsed())
 
         return None

{model_compose-0.2.8 → model_compose-0.2.10}/src/mindor/core/workflow/workflow.py

@@ -2,6 +2,7 @@ from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annot
 from mindor.dsl.schema.workflow import WorkflowConfig, JobConfig
 from mindor.dsl.schema.component import ComponentConfig
 from mindor.core.component import ComponentGlobalConfigs
+from mindor.core.utils.time import TimeTracker
 from mindor.core.logger import logging
 from .context import WorkflowContext
 from .job import Job, create_job
@@ -86,9 +87,10 @@ class WorkflowRunner:
         running_job_ids: Set[str] = set()
         completed_job_ids: Set[str] = set()
         scheduled_job_tasks: Dict[str, asyncio.Task] = {}
+        job_time_trackers: Dict[str, TimeTracker] = {}
         output: Any = None
 
-        started_at = datetime.now()
+        workflow_time_tracker = TimeTracker()
         logging.info("[task-%s] Workflow '%s' started.", context.task_id, self.id)
 
         while pending_jobs:
@@ -96,10 +98,12 @@ class WorkflowRunner:
 
             for job in runnable_jobs:
                 if job.id not in scheduled_job_tasks:
-                    logging.debug("[task-%s] Scheduling job: '%s'", context.task_id, job.id)
                     scheduled_job_tasks[job.id] = asyncio.create_task(job.run(context))
                     running_job_ids.add(job.id)
 
+                    job_time_trackers[job.id] = TimeTracker()
+                    logging.info("[task-%s] Job '%s' started.", context.task_id, job.id)
+
             if not scheduled_job_tasks:
                 raise RuntimeError("No runnable jobs but pending jobs remain.")
 
@@ -111,7 +115,7 @@ class WorkflowRunner:
                 completed_job_output = await completed_job_task
                 context.complete_job(completed_job_id, completed_job_output)
 
-                logging.info("[task-%s] Job '%s' completed.", context.task_id, completed_job_id)
+                logging.info("[task-%s] Job '%s' completed in %.2f seconds.", context.task_id, completed_job_id, job_time_trackers[completed_job_id].elapsed())
 
                 if self._is_terminal_job(completed_job_id):
                     if isinstance(output, dict) and isinstance(completed_job_output, dict):
@@ -124,8 +128,7 @@ class WorkflowRunner:
                 del pending_jobs[completed_job_id]
                 del scheduled_job_tasks[completed_job_id]
 
-        elapsed = (datetime.now() - started_at).total_seconds()
-        logging.info("[task-%s] Workflow '%s' completed in %.2f seconds.", context.task_id, self.id, elapsed)
+        logging.info("[task-%s] Workflow '%s' completed in %.2f seconds.", context.task_id, self.id, workflow_time_tracker.elapsed())
 
         return output
 

model_compose-0.2.10/src/mindor/dsl/schema/action/action.py

@@ -0,0 +1,13 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from .impl import *
+
+ActionConfig = Union[ 
+    HttpServerActionConfig,
+    HttpClientActionConfig,
+    McpServerActionConfig,
+    McpClientActionConfig,
+    ModelActionConfig,
+    WorkflowActionConfig,
+    ShellActionConfig
+]

{model_compose-0.2.8 → model_compose-0.2.10}/src/mindor/dsl/schema/action/impl/__init__.py

@@ -3,5 +3,6 @@ from .http_server import *
 from .http_client import *
 from .mcp_server import *
 from .mcp_client import *
+from .model import *
 from .workflow import *
 from .shell import *

{model_compose-0.2.8 → model_compose-0.2.10}/src/mindor/dsl/schema/action/impl/mcp_server.py

@@ -4,5 +4,4 @@ from pydantic import model_validator
 from .common import CommonActionConfig
 
 class McpServerActionConfig(CommonActionConfig):
-    def __init__(self):
-        super().__init__()
+    pass

model_compose-0.2.10/src/mindor/dsl/schema/action/impl/model/__init__.py

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

model_compose-0.2.10/src/mindor/dsl/schema/action/impl/model/impl/__init__.py

@@ -0,0 +1,3 @@
+from .common import *
+from .text_generation import *
+from .text_embedding import *

model_compose-0.2.10/src/mindor/dsl/schema/action/impl/model/impl/common.py

@@ -0,0 +1,11 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from enum import Enum
+from pydantic import BaseModel, Field
+from ...common import CommonActionConfig
+
+class ModelTaskMode(str, Enum):
+    INFERENCE = "inference"
+    TRAINING  = "training"
+
+class CommonModelActionConfig(CommonActionConfig):
+    mode: ModelTaskMode = Field(default=ModelTaskMode.INFERENCE, description="")

model_compose-0.2.10/src/mindor/dsl/schema/action/impl/model/impl/text_embedding.py

@@ -0,0 +1,14 @@
+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 CommonModelActionConfig
+
+class TextEmbeddingParamsConfig(BaseModel):
+    pooling: Literal[ "mean", "cls", "max" ] = Field(default="mean", description="Pooling strategy used to aggregate token embeddings.")
+    normalize: bool = Field(default=True, description="Whether to apply L2 normalization to the output embeddings.")
+    batch_size: int = Field(default=1, description="Number of input texts to process in a single batch.")
+    max_length: int = Field(default=512, description="Maximum number of tokens per input text.")
+
+class TextEmbeddingModelActionConfig(CommonModelActionConfig):
+    text: str = Field(..., description="Input text to be embedded.")
+    params: TextEmbeddingParamsConfig = Field(default_factory=TextEmbeddingParamsConfig, description="Configuration parameters for embedding generation.")

model_compose-0.2.10/src/mindor/dsl/schema/action/impl/model/impl/text_generation.py

@@ -0,0 +1,15 @@
+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 CommonModelActionConfig
+
+class TextGenerationParamsConfig(BaseModel):
+    max_length: int = Field(default=128, description="")
+    num_return_sequences: int = Field(default=1, description="")
+    temperature: float = Field(default=1.0, description="")
+    top_k: int = Field(default=50, description="")
+    top_p: float = Field(default=1.0, description="")
+
+class TextGenerationModelActionConfig(CommonModelActionConfig):
+    prompt: str = Field(..., description="")
+    params: TextGenerationParamsConfig = Field(default_factory=TextGenerationParamsConfig, description="Text generation configuration parameters.")

model_compose-0.2.10/src/mindor/dsl/schema/action/impl/model/model.py

@@ -0,0 +1,8 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from .impl import *
+
+ModelActionConfig = Union[
+    TextGenerationModelActionConfig,
+    TextEmbeddingModelActionConfig,
+]

{model_compose-0.2.8 → model_compose-0.2.10}/src/mindor/dsl/schema/component/component.py

@@ -8,6 +8,7 @@ ComponentConfig = Annotated[
         HttpClientComponentConfig,
         McpServerComponentConfig,
         McpClientComponentConfig,
+        ModelComponentConfig,
         WorkflowComponentConfig,
         ShellComponentConfig
     ],

{model_compose-0.2.8 → model_compose-0.2.10}/src/mindor/dsl/schema/component/impl/__init__.py

@@ -3,5 +3,6 @@ from .http_server import *
 from .http_client import *
 from .mcp_server import *
 from .mcp_client import *
+from .model import *
 from .workflow import *
 from .shell import *

model_compose-0.2.10/src/mindor/dsl/schema/component/impl/model/__init__.py

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

model_compose-0.2.10/src/mindor/dsl/schema/component/impl/model/impl/__init__.py

@@ -0,0 +1,3 @@
+from .common import *
+from .text_generation import *
+from .text_embedding import *

model_compose-0.2.10/src/mindor/dsl/schema/component/impl/model/impl/common.py

@@ -0,0 +1,23 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+from mindor.dsl.schema.action import ModelActionConfig
+from mindor.dsl.utils.annotation import get_model_union_keys
+from ...common import CommonComponentConfig, ComponentType
+from .types import ModelTaskType
+
+class CommonModelComponentConfig(CommonComponentConfig):
+    type: Literal[ComponentType.MODEL]
+    task: ModelTaskType = Field(..., description="")
+    model: str = Field(..., description="")
+    device: str = Field(default="cpu", description="Computation device to use.")
+    cache_dir: Optional[str] = Field(default=None, description="")
+    actions: Dict[str, ModelActionConfig] = Field(default_factory=dict)
+
+    @model_validator(mode="before")
+    def inflate_single_action(cls, values: Dict[str, Any]):
+        if "actions" not in values:
+            action_keys = set(get_model_union_keys(ModelActionConfig))
+            if any(k in values for k in action_keys):
+                values["actions"] = { "__default__": { k: values.pop(k) for k in action_keys if k in values } }
+        return values