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

{model_compose-0.2.9/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.9
+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.9 → model_compose-0.2.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.2.9"
+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.9 → 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.9 → 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.9 → 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.9 → 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.9 → 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.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.9 → 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.9 → 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.9 → 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.9 → 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

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

@@ -0,0 +1,7 @@
+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 CommonModelComponentConfig, ModelTaskType
+
+class TextEmbeddingModelComponentConfig(CommonModelComponentConfig):
+    task: Literal[ModelTaskType.TEXT_EMBEDDING]

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

@@ -0,0 +1,7 @@
+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 CommonModelComponentConfig, ModelTaskType
+
+class TextGenerationModelComponentConfig(CommonModelComponentConfig):
+    task: Literal[ModelTaskType.TEXT_GENERATION]

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

@@ -0,0 +1,5 @@
+from enum import Enum
+
+class ModelTaskType(str, Enum):
+    TEXT_GENERATION = "text-generation"
+    TEXT_EMBEDDING  = "text-embedding"

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

@@ -0,0 +1,11 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from .impl import *
+
+ModelComponentConfig = Annotated[
+    Union[ 
+        TextGenerationModelComponentConfig, 
+        TextEmbeddingModelComponentConfig,
+    ],
+    Field(discriminator="task")
+]

{model_compose-0.2.9 → model_compose-0.2.10}/src/mindor/dsl/schema/component/impl/types.py

@@ -5,5 +5,6 @@ class ComponentType(str, Enum):
     HTTP_CLIENT = "http-client"
     MCP_SERVER  = "mcp-server"
     MCP_CLIENT  = "mcp-client"
+    MODEL       = "model"
     WORKFLOW    = "workflow"
     SHELL       = "shell"

{model_compose-0.2.9 → model_compose-0.2.10}/src/mindor/dsl/schema/workflow.py

@@ -2,8 +2,8 @@ from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annot
 from enum import Enum
 from pydantic import BaseModel, Field
 from pydantic import model_validator, field_validator
+from mindor.dsl.utils.annotation import get_model_union_keys
 from .job import JobConfig, JobType
-from .utils.annotation import get_model_union_keys
 
 class WorkflowVariableType(str, Enum):
     # Primitive data types

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.2.9
+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.9 → model_compose-0.2.10}/src/model_compose.egg-info/SOURCES.txt

@@ -16,6 +16,12 @@ src/mindor/core/component/services/mcp_client.py
 src/mindor/core/component/services/mcp_server.py
 src/mindor/core/component/services/shell.py
 src/mindor/core/component/services/workflow.py
+src/mindor/core/component/services/model/__init__.py
+src/mindor/core/component/services/model/base.py
+src/mindor/core/component/services/model/model.py
+src/mindor/core/component/services/model/tasks/__init__.py
+src/mindor/core/component/services/model/tasks/text_embedding.py
+src/mindor/core/component/services/model/tasks/text_generation.py
 src/mindor/core/compose/__init__.py
 src/mindor/core/compose/compose.py
 src/mindor/core/compose/manager.py
@@ -92,6 +98,12 @@ src/mindor/dsl/schema/action/impl/mcp_client.py
 src/mindor/dsl/schema/action/impl/mcp_server.py
 src/mindor/dsl/schema/action/impl/shell.py
 src/mindor/dsl/schema/action/impl/workflow.py
+src/mindor/dsl/schema/action/impl/model/__init__.py
+src/mindor/dsl/schema/action/impl/model/model.py
+src/mindor/dsl/schema/action/impl/model/impl/__init__.py
+src/mindor/dsl/schema/action/impl/model/impl/common.py
+src/mindor/dsl/schema/action/impl/model/impl/text_embedding.py
+src/mindor/dsl/schema/action/impl/model/impl/text_generation.py
 src/mindor/dsl/schema/component/__init__.py
 src/mindor/dsl/schema/component/component.py
 src/mindor/dsl/schema/component/impl/__init__.py
@@ -103,6 +115,13 @@ src/mindor/dsl/schema/component/impl/mcp_server.py
 src/mindor/dsl/schema/component/impl/shell.py
 src/mindor/dsl/schema/component/impl/types.py
 src/mindor/dsl/schema/component/impl/workflow.py
+src/mindor/dsl/schema/component/impl/model/__init__.py
+src/mindor/dsl/schema/component/impl/model/model.py
+src/mindor/dsl/schema/component/impl/model/impl/__init__.py
+src/mindor/dsl/schema/component/impl/model/impl/common.py
+src/mindor/dsl/schema/component/impl/model/impl/text_embedding.py
+src/mindor/dsl/schema/component/impl/model/impl/text_generation.py
+src/mindor/dsl/schema/component/impl/model/impl/types.py
 src/mindor/dsl/schema/controller/__init__.py
 src/mindor/dsl/schema/controller/controller.py
 src/mindor/dsl/schema/controller/impl/__init__.py
@@ -144,8 +163,8 @@ src/mindor/dsl/schema/runtime/impl/__init__.py
 src/mindor/dsl/schema/runtime/impl/common.py
 src/mindor/dsl/schema/runtime/impl/docker.py
 src/mindor/dsl/schema/runtime/impl/types.py
-src/mindor/dsl/schema/utils/__init__.py
-src/mindor/dsl/schema/utils/annotation.py
+src/mindor/dsl/utils/__init__.py
+src/mindor/dsl/utils/annotation.py
 src/model_compose.egg-info/PKG-INFO
 src/model_compose.egg-info/SOURCES.txt
 src/model_compose.egg-info/dependency_links.txt

{model_compose-0.2.9 → model_compose-0.2.10}/src/model_compose.egg-info/requires.txt

@@ -11,3 +11,5 @@ pyngrok
 ulid
 gradio
 Pillow
+transformers
+torch

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

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