model-compose 0.2.9__tar.gz → 0.2.11__tar.gz

{model_compose-0.2.9/src/model_compose.egg-info → model_compose-0.2.11}/PKG-INFO

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

{model_compose-0.2.9 → model_compose-0.2.11}/pyproject.toml

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

{model_compose-0.2.9 → model_compose-0.2.11}/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.9 → model_compose-0.2.11}/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.9 → model_compose-0.2.11}/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.9 → model_compose-0.2.11}/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.11/src/mindor/core/component/services/model/__init__.py

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

model_compose-0.2.11/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.11/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.11/src/mindor/core/component/services/model/tasks/__init__.py

@@ -0,0 +1,4 @@
+from .text_generation import *
+from .summarization import *
+from .translation import *
+from .text_embedding import *

model_compose-0.2.11/src/mindor/core/component/services/model/tasks/summarization.py

@@ -0,0 +1,75 @@
+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, SummarizationModelActionConfig
+from mindor.core.logger import logging
+from ..base import ModelTaskService, ModelTaskType, register_model_task_service
+from ..base import ComponentActionContext
+from transformers import AutoModelForSeq2SeqLM, AutoTokenizer, PreTrainedModel, PreTrainedTokenizer, GenerationMixin
+import torch
+
+class SummarizationTaskAction:
+    def __init__(self, config: SummarizationModelActionConfig, model: Union[PreTrainedModel, GenerationMixin], tokenizer: PreTrainedTokenizer):
+        self.config: SummarizationModelActionConfig = config
+        self.model: Union[PreTrainedModel, GenerationMixin] = model
+        self.tokenizer: PreTrainedTokenizer = tokenizer
+
+    async def run(self, context: ComponentActionContext) -> Any:
+        text: Union[str, List[str]] = await context.render_variable(self.config.text)
+
+        # Model parameters
+        max_input_length  = await context.render_variable(self.config.params.max_input_length)
+        max_output_length = await context.render_variable(self.config.params.max_output_length)
+        min_output_length = await context.render_variable(self.config.params.min_output_length)
+        num_beams         = await context.render_variable(self.config.params.num_beams)
+        length_penalty    = await context.render_variable(self.config.params.length_penalty)
+        early_stopping    = await context.render_variable(self.config.params.early_stopping)
+        do_sample         = await context.render_variable(self.config.params.do_sample)
+
+        # Tokenizing
+        inputs = self.tokenizer(text, return_tensors="pt", max_length=max_input_length, padding=True, truncation=True).to(self.model.device)
+
+        # Text Summarization
+        with torch.no_grad():
+            outputs = self.model.generate(
+                **inputs,
+                max_length=max_output_length,
+                min_length=min_output_length,
+                num_beams=num_beams,
+                length_penalty=length_penalty,
+                early_stopping=early_stopping,
+                do_sample=do_sample,
+                pad_token_id=getattr(self.tokenizer, "pad_token_id", None),
+                eos_token_id=getattr(self.tokenizer, "eos_token_id", None)
+            )
+
+        # Decoding output
+        outputs = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)
+        
+        result = outputs if isinstance(text, list) else outputs[0] 
+        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.SUMMARIZATION)
+class SummarizationTaskService(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:
+        try:
+            self.model = AutoModelForSeq2SeqLM.from_pretrained(self.config.model).to(torch.device(self.config.device))
+            self.tokenizer = AutoTokenizer.from_pretrained(self.config.model, use_fast=self.config.fast_tokenizer)
+            logging.info(f"Model and tokenizer loaded successfully on device '{self.config.device}': {self.config.model}")
+        except Exception as e:
+            logging.error(f"Failed to load model '{self.config.model}': {e}")
+            raise
+
+    async def _shutdown(self) -> None:
+        self.model = None
+        self.tokenizer = None
+
+    async def _run(self, action: ModelActionConfig, context: ComponentActionContext) -> Any:
+        return await SummarizationTaskAction(action, self.model, self.tokenizer).run(context)

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

@@ -0,0 +1,89 @@
+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 mindor.core.logger import logging
+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_input_length = await context.render_variable(self.config.params.max_input_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", max_length=max_input_length, padding=True, truncation=True).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:
+        try:
+            self.model = AutoModel.from_pretrained(self.config.model).to(torch.device(self.config.device))
+            self.tokenizer = AutoTokenizer.from_pretrained(self.config.model, use_fast=self.config.fast_tokenizer)
+            logging.info(f"Model and tokenizer loaded successfully on device '{self.config.device}': {self.config.model}")
+        except Exception as e:
+            logging.error(f"Failed to load model '{self.config.model}': {e}")
+            raise
+
+    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.11/src/mindor/core/component/services/model/tasks/text_generation.py

@@ -0,0 +1,71 @@
+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 mindor.core.logger import logging
+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: Union[str, List[str]] = await context.render_variable(self.config.prompt)
+
+        # Model parameters
+        max_output_length    = await context.render_variable(self.config.params.max_output_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_output_length,
+                num_return_sequences=num_return_sequences,
+                temperature=temperature,
+                top_k=top_k,
+                top_p=top_p,
+                do_sample=True
+            )
+
+        # Decoding output
+        outputs = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)
+        
+        result = outputs if isinstance(prompt, list) else outputs[0] 
+        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:
+        try:
+            self.model = AutoModelForCausalLM.from_pretrained(self.config.model).to(torch.device(self.config.device))
+            self.tokenizer = AutoTokenizer.from_pretrained(self.config.model, use_fast=self.config.fast_tokenizer)
+            logging.info(f"Model and tokenizer loaded successfully on device '{self.config.device}': {self.config.model}")
+        except Exception as e:
+            logging.error(f"Failed to load model '{self.config.model}': {e}")
+            raise
+
+    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.11/src/mindor/core/component/services/model/tasks/translation.py

@@ -0,0 +1,72 @@
+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, TranslationModelActionConfig
+from mindor.core.logger import logging
+from ..base import ModelTaskService, ModelTaskType, register_model_task_service
+from ..base import ComponentActionContext
+from transformers import AutoModelForSeq2SeqLM, AutoTokenizer, PreTrainedModel, PreTrainedTokenizer, GenerationMixin
+import torch
+
+class TranslationTaskAction:
+    def __init__(self, config: TranslationModelActionConfig, model: Union[PreTrainedModel, GenerationMixin], tokenizer: PreTrainedTokenizer):
+        self.config: TranslationModelActionConfig = config
+        self.model: Union[PreTrainedModel, GenerationMixin] = model
+        self.tokenizer: PreTrainedTokenizer = tokenizer
+
+    async def run(self, context: ComponentActionContext) -> Any:
+        text: Union[str, List[str]] = await context.render_variable(self.config.text)
+
+        # Model parameters
+        max_input_length  = await context.render_variable(self.config.params.max_input_length)
+        max_output_length = await context.render_variable(self.config.params.max_output_length)
+        min_output_length = await context.render_variable(self.config.params.min_output_length)
+        num_beams         = await context.render_variable(self.config.params.num_beams)
+        length_penalty    = await context.render_variable(self.config.params.length_penalty)
+
+        # Tokenizing
+        inputs = self.tokenizer(text, return_tensors="pt", max_length=max_input_length, padding=True, truncation=True).to(self.model.device)
+
+        # Text Translation
+        with torch.no_grad():
+            outputs = self.model.generate(
+                **inputs,
+                max_length=max_output_length,
+                min_length=min_output_length,
+                num_beams=num_beams,
+                length_penalty=length_penalty,
+                do_sample=False,
+                pad_token_id=getattr(self.tokenizer, "pad_token_id", None),
+                eos_token_id=getattr(self.tokenizer, "eos_token_id", None)
+            )
+
+        # Decoding output
+        outputs = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)
+        
+        result = outputs if isinstance(text, list) else outputs[0] 
+        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.TRANSLATION)
+class TranslationTaskService(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:
+        try:
+            self.model = AutoModelForSeq2SeqLM.from_pretrained(self.config.model).to(torch.device(self.config.device))
+            self.tokenizer = AutoTokenizer.from_pretrained(self.config.model, use_fast=self.config.fast_tokenizer)
+            logging.info(f"Model and tokenizer loaded successfully on device '{self.config.device}': {self.config.model}")
+        except Exception as e:
+            logging.error(f"Failed to load model '{self.config.model}': {e}")
+            raise
+
+    async def _shutdown(self) -> None:
+        self.model = None
+        self.tokenizer = None
+
+    async def _run(self, action: ModelActionConfig, context: ComponentActionContext) -> Any:
+        return await TranslationTaskAction(action, self.model, self.tokenizer).run(context)

{model_compose-0.2.9 → model_compose-0.2.11}/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.9 → model_compose-0.2.11}/src/mindor/core/workflow/workflow.py

@@ -6,7 +6,6 @@ from mindor.core.utils.time import TimeTracker
 from mindor.core.logger import logging
 from .context import WorkflowContext
 from .job import Job, create_job
-from datetime import datetime
 import asyncio
 
 class JobGraphValidator:

model_compose-0.2.11/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.9 → model_compose-0.2.11}/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.9 → model_compose-0.2.11}/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.11/src/mindor/dsl/schema/action/impl/model/__init__.py

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

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

@@ -0,0 +1,5 @@
+from .common import *
+from .text_generation import *
+from .summarization import *
+from .translation import *
+from .text_embedding import *

model_compose-0.2.11/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.11/src/mindor/dsl/schema/action/impl/model/impl/summarization.py

@@ -0,0 +1,17 @@
+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 SummarizationParamsConfig(BaseModel):
+    max_input_length: int = Field(default=1024, description="Maximum number of tokens per input text.")
+    max_output_length: int = Field(default=256, description="The maximum number of tokens to generate.")
+    min_output_length: int = Field(default=30, description="The minimum number of tokens to generate.")
+    num_beams: int = Field(default=4, description="")
+    length_penalty: float = Field(default=2.0, description="")
+    early_stopping: bool = Field(default=True, description="")
+    do_sample: bool = Field(default=True, description="Whether to use sampling.")
+
+class SummarizationModelActionConfig(CommonModelActionConfig):
+    text: str = Field(..., description="")
+    params: SummarizationParamsConfig = Field(default_factory=SummarizationParamsConfig, description="Summarization configuration parameters.")

model_compose-0.2.11/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):
+    max_input_length: int = Field(default=512, description="Maximum number of tokens per input text.")
+    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.")
+
+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.11/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_output_length: int = Field(default=1024, description="The maximum number of tokens to generate.")
+    num_return_sequences: int = Field(default=1, description="The number of generated sequences to return.")
+    temperature: float = Field(default=1.0, description="Sampling temperature; higher values produce more random results.")
+    top_k: int = Field(default=50, description="Top-K sampling; restricts sampling to the top K tokens.")
+    top_p: float = Field(default=1.0, description="Top-p (nucleus) sampling; restricts sampling to tokens with cumulative probability >= top_p.")
+
+class TextGenerationModelActionConfig(CommonModelActionConfig):
+    prompt: str = Field(..., description="")
+    params: TextGenerationParamsConfig = Field(default_factory=TextGenerationParamsConfig, description="Text generation configuration parameters.")

model_compose-0.2.11/src/mindor/dsl/schema/action/impl/model/impl/translation.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 TranslationParamsConfig(BaseModel):
+    max_input_length: int = Field(default=1024, description="Maximum number of tokens per input text.")
+    max_output_length: int = Field(default=256, description="The maximum number of tokens to generate.")
+    min_output_length: int = Field(default=10, description="The minimum number of tokens to generate.")
+    num_beams: int = Field(default=4, description="")
+    length_penalty: float = Field(default=1.0, description="")
+
+class TranslationModelActionConfig(CommonModelActionConfig):
+    text: str = Field(..., description="")
+    params: TranslationParamsConfig = Field(default_factory=TranslationParamsConfig, description="Translation configuration parameters.")

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

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

{model_compose-0.2.9 → model_compose-0.2.11}/src/mindor/dsl/schema/component/component.py

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