model-compose 0.3.3__tar.gz → 0.3.5__tar.gz

{model_compose-0.3.3/src/model_compose.egg-info → model_compose-0.3.5}/PKG-INFO

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

{model_compose-0.3.3 → model_compose-0.3.5}/pyproject.toml

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

{model_compose-0.3.3 → model_compose-0.3.5}/src/mindor/cli/compose.py

@@ -15,7 +15,7 @@ from mindor.core.compose import *
 )
 @click.pass_context
 def compose_command(ctx: click.Context, config_files: List[Path]) -> None:
-    """model-compose (from Mindor)"""
+    """model-compose"""
     ctx.ensure_object(dict)
     ctx.obj["config_files"] = list(config_files)
 
@@ -138,7 +138,7 @@ def stop_command(
     asyncio.run(_async_command())
 
 @click.command(name="run")
-@click.argument("workflow", required=False)
+@click.argument("workflow_id", required=False)
 @click.option(
     "--input", "-i", "input_json",
     type=str,
@@ -155,14 +155,21 @@ def stop_command(
     "--env", "-e", "env_data", multiple=True,
     help="Environment variable in the form KEY=VALUE. Repeatable."
 )
+@click.option(
+    "--output", "-o", "output_path",
+    type=click.Path(dir_okay=False, writable=True, path_type=Path),
+    required=False,
+    help="Path to save the output result as a file."
+)
 @click.option("--verbose", "-v", is_flag=True, help="Enable verbose output.")
 @click.pass_context
 def run_command(
     ctx: click.Context,
-    workflow: Optional[str],
+    workflow_id: Optional[str],
     input_json: Optional[str],
     env_files: List[Path],
     env_data: List[str],
+    output_path: Optional[Path],
     verbose: bool
 ) -> None:
     config_files = ctx.obj.get("config_files", [])
@@ -171,12 +178,16 @@ def run_command(
             env = load_env_files(".", env_files or [])
             config = load_compose_config(".", config_files, env)
             input = json.loads(input_json) if input_json else {}
-            state = await run_workflow(config, workflow, input, verbose)
-            click.echo(json.dumps(
-                state.error if state.error else state.output, 
-                indent=2, 
-                ensure_ascii=False
-            ))
+            state = await run_workflow(config, workflow_id, input, output_path, verbose)
+            if isinstance(state.output, (dict, list)) or state.error:
+                click.echo(json.dumps(
+                    state.output or state.error,
+                    indent=2,
+                    ensure_ascii=False
+                ))
+            else:
+                if state.output is not None:
+                    click.echo(state.output)
         except json.JSONDecodeError:
             click.echo("❌ Invalid JSON provided for --input", err=True)
         except Exception as e:

{model_compose-0.3.3 → model_compose-0.3.5}/src/mindor/core/component/base.py

@@ -78,6 +78,12 @@ class ComponentService(AsyncService):
 
         await super()._stop()
 
+    async def _serve(self) -> None:
+        pass
+
+    async def _shutdown(self) -> None:
+        pass
+
     @abstractmethod
     async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
         pass

{model_compose-0.3.3 → model_compose-0.3.5}/src/mindor/core/component/services/__init__.py

@@ -5,3 +5,4 @@ from .mcp_client import *
 from .model import *
 from .workflow import *
 from .shell import *
+from .text_splitter import *

{model_compose-0.3.3 → model_compose-0.3.5}/src/mindor/core/component/services/http_client.py

@@ -62,7 +62,7 @@ class HttpClientPollingCompletion(HttpClientCompletion):
 class HttpClientCallbackCompletion(HttpClientCompletion):
     async def run(self, context: ComponentActionContext, client: HttpClient) -> Any:
         callback_id = await context.render_variable(self.config.wait_for)
-        future: asyncio.Future = asyncio.get_event_loop().create_future()
+        future: asyncio.Future = asyncio.get_running_loop().create_future()
         HttpCallbackListener.register_pending_future(callback_id, future)
 
         return await future
@@ -113,12 +113,14 @@ class HttpClientComponent(ComponentService):
     def __init__(self, id: str, config: HttpClientComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
         super().__init__(id, config, global_configs, daemon)
 
-        self.client: HttpClient = None
+        self.client: Optional[HttpClient] = None
 
-    async def _serve(self) -> None:
+    async def _start(self) -> None:
         self.client = HttpClient(self.config.base_url, self.config.headers)
+        await super()._start()
 
-    async def _shutdown(self) -> None:
+    async def _stop(self) -> None:
+        await super()._stop()
         await self.client.close()
         self.client = None
 

{model_compose-0.3.3 → model_compose-0.3.5}/src/mindor/core/component/services/mcp_client.py

@@ -32,10 +32,14 @@ class McpClientComponent(ComponentService):
     def __init__(self, id: str, config: McpClientComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
         super().__init__(id, config, global_configs, daemon)
 
-    async def _serve(self) -> None:
+        self.client: Optional[McpClient] = None 
+
+    async def _start(self) -> None:
         self.client = McpClient(self.config.url, self.config.headers)
+        await super()._start()
 
-    async def _shutdown(self) -> None:
+    async def _stop(self) -> None:
+        await super()._stop()
         await self.client.close()
         self.client = None
 

{model_compose-0.3.3 → model_compose-0.3.5}/src/mindor/core/component/services/model/base.py

@@ -5,7 +5,8 @@ from mindor.dsl.schema.action import ModelActionConfig
 from mindor.core.services import AsyncService
 from ...context import ComponentActionContext
 from transformers import PreTrainedModel, PreTrainedTokenizer
-import torch
+from threading import Thread
+import torch, asyncio
 
 class ModelTaskService(AsyncService):
     def __init__(self, id: str, config: ModelComponentConfig, daemon: bool):
@@ -15,7 +16,10 @@ class ModelTaskService(AsyncService):
         self.config: ModelComponentConfig = config
 
     async def run(self, action: ModelActionConfig, context: ComponentActionContext) -> Any:
-        return await self._run(action, context)
+        async def _run():
+            return await self._run(action, context)
+
+        return await self.run_in_thread(_run)
 
     @abstractmethod
     async def _run(self, action: ModelActionConfig, context: ComponentActionContext) -> Any:

{model_compose-0.3.3 → model_compose-0.3.5}/src/mindor/core/component/services/shell.py

@@ -69,11 +69,5 @@ class ShellComponent(ComponentService):
     def __init__(self, id: str, config: ShellComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
         super().__init__(id, config, global_configs, daemon)
 
-    async def _serve(self) -> None:
-        pass
-
-    async def _shutdown(self) -> None:
-        pass
-
     async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
         return await ShellAction(action, self.config.base_dir, self.config.env).run(context)

model_compose-0.3.5/src/mindor/core/component/services/text_splitter.py

@@ -0,0 +1,82 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.component import TextSplitterComponentConfig
+from mindor.dsl.schema.action import ActionConfig, TextSplitterActionConfig
+from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
+from ..context import ComponentActionContext
+
+class TextSplitterAction:
+    def __init__(self, config: TextSplitterActionConfig):
+        self.config: TextSplitterActionConfig = config
+
+    async def run(self, context: ComponentActionContext) -> Any:
+        text           = await context.render_variable(self.config.text)
+        separators     = await context.render_variable(self.config.separators)
+        chunk_size     = await context.render_variable(self.config.chunk_size)
+        chunk_overlap  = await context.render_variable(self.config.chunk_overlap)
+        maximize_chunk = await context.render_variable(self.config.maximize_chunk)
+        stream         = await context.render_variable(self.config.stream)
+
+        chunks = self._recursive_split(text, separators or [ "\n\n", "\n", " ", "" ], chunk_size, maximize_chunk)
+
+        if chunk_overlap > 0 and len(chunks) > 1:
+            return self._overlap_chunks(chunks, chunk_overlap)
+
+        return chunks
+
+    def _recursive_split(self, text: str, separators: List[str], chunk_size: int, maximize_chunk: bool) -> List[str]:
+        if len(text) <= chunk_size:
+            return [ text ]
+
+        separator = separators[0] if separators else ""
+        if separator == "":
+            return self._character_split(text, chunk_size)
+
+        chunks, current = [], ""
+        for part in text.split(separator):
+            candidate = current + separator + part if current else part
+
+            if len(candidate) > chunk_size:
+                if current:
+                    chunks.append(current)
+                    current = part
+                else:
+                    if len(separators) > 1:
+                        sub_chunks = self._recursive_split(part, separators[1:], chunk_size, maximize_chunk)
+                    else:
+                        sub_chunks = self._character_split(part, chunk_size)
+                    chunks.extend(sub_chunks)
+                    current = ""
+            else:
+                if maximize_chunk:
+                    current = candidate
+                else:
+                    if current:
+                        chunks.append(current)
+                    current = part
+
+        if current:
+            chunks.append(current)
+
+        return chunks
+
+    def _character_split(self, text: str, chunk_size: int) -> List[str]:
+        return [ text[i:i + chunk_size] for i in range(0, len(text), chunk_size) ]
+    
+    def _overlap_chunks(self, chunks: List[str], chunk_overlap: int) -> List[str]:
+        overlapped = [ chunks[0] ]
+
+        for i in range(1, len(chunks)):
+            prev = chunks[i - 1]
+            current = chunks[i]
+            overlap = prev[-chunk_overlap:] if len(prev) >= chunk_overlap else prev
+            overlapped.append(overlap + current)
+
+        return overlapped
+
+@register_component(ComponentType.TEXT_SPLITTER)
+class TextSplitterComponent(ComponentService):
+    def __init__(self, id: str, config: TextSplitterComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
+        super().__init__(id, config, global_configs, daemon)
+
+    async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
+        return await TextSplitterAction(action).run(context)

{model_compose-0.3.3 → model_compose-0.3.5}/src/mindor/core/component/services/workflow.py

@@ -5,7 +5,6 @@ from mindor.dsl.schema.workflow import WorkflowConfig
 from mindor.core.workflow import Workflow, WorkflowResolver, create_workflow
 from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
 from ..context import ComponentActionContext
-import asyncio, os
 
 class WorkflowAction:
     def __init__(self, config: WorkflowActionConfig, global_configs: ComponentGlobalConfigs):
@@ -30,11 +29,5 @@ class WorkflowComponent(ComponentService):
     def __init__(self, id: str, config: WorkflowComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
         super().__init__(id, config, global_configs, daemon)
 
-    async def _serve(self) -> None:
-        pass
-
-    async def _shutdown(self) -> None:
-        pass
-
     async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
         return await WorkflowAction(action, self.global_configs).run(context)

{model_compose-0.3.3 → model_compose-0.3.5}/src/mindor/core/compose/compose.py

@@ -14,5 +14,5 @@ async def start_services(config: ComposeConfig, verbose: bool):
 async def stop_services(config: ComposeConfig, verbose: bool):
     await ComposeManager(config, daemon=False).stop_services(verbose)
 
-async def run_workflow(config: ComposeConfig, workflow_id: Optional[str], input: Dict[str, Any], verbose: bool) -> TaskState:
-    return await ComposeManager(config, daemon=False).run_workflow(workflow_id, input, verbose)
+async def run_workflow(config: ComposeConfig, workflow_id: Optional[str], input: Dict[str, Any], output_path: Optional[str], verbose: bool) -> TaskState:
+    return await ComposeManager(config, daemon=False).run_workflow(workflow_id, input, output_path, verbose)

{model_compose-0.3.3 → model_compose-0.3.5}/src/mindor/core/compose/manager.py

@@ -1,6 +1,6 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.compose import ComposeConfig
-from mindor.core.controller import ControllerService, TaskState, create_controller
+from mindor.core.controller import ControllerService, TaskState, TaskStatus, create_controller
 
 class ComposeManager:
     def __init__(self, config: ComposeConfig, daemon: bool):
@@ -27,8 +27,17 @@ class ComposeManager:
     async def stop_services(self, verbose: bool):
         await self.controller.stop()
 
-    async def run_workflow(self, workflow_id: Optional[str], input: Dict[str, Any], verbose: bool) -> TaskState:
+    async def run_workflow(self, workflow_id: Optional[str], input: Dict[str, Any], output_path: Optional[str], verbose: bool) -> TaskState:
         if not self.controller.started:
             await self.controller.start()
 
-        return await self.controller.run_workflow(workflow_id, input)
+        state = await self.controller.run_workflow(workflow_id, input)
+
+        if output_path and state.status == TaskStatus.COMPLETED:
+            await self._save_output(state.output, output_path)
+            state.output = None
+
+        return state
+
+    async def _save_output(self, output: Any, path: str) -> None:
+        pass

{model_compose-0.3.3 → model_compose-0.3.5}/src/mindor/core/controller/controller.py

@@ -5,7 +5,7 @@ from mindor.dsl.schema.listener import ListenerConfig
 from mindor.dsl.schema.gateway import GatewayConfig
 from mindor.dsl.schema.workflow import WorkflowConfig
 from mindor.dsl.schema.logger import LoggerConfig
-from .base import ControllerService, ControllerRegistry
+from .base import ControllerService, ControllerRegistry, TaskStatus
 
 def create_controller(
     config: ControllerConfig,

{model_compose-0.3.3 → model_compose-0.3.5}/src/mindor/core/controller/webui/gradio.py

@@ -211,7 +211,10 @@ class GradioWebUIBuilder:
         if isinstance(value, (dict, list)):
             return json.dumps(value)
 
-        return str(value) if value is not None else None
+        if value is not None:
+            return str(value)
+        
+        return None
 
     async def _resolve_json_field_from_value(self, value: Any, subtype: Optional[str], format: Optional[WorkflowVariableFormat]) -> Optional[Any]:
         try:

{model_compose-0.3.3 → model_compose-0.3.5}/src/mindor/core/runtime/docker/docker.py

@@ -246,7 +246,7 @@ class DockerRuntimeManager:
                 for line in container.logs(stream=True, follow=True, since=int(time.time())):
                     sys.stdout.buffer.write(line)
                     sys.stdout.flush()
-            loop = asyncio.get_event_loop()
+            loop = asyncio.get_running_loop()
             await loop.run_in_executor(None, _stream_logs_sync, container)
         except Exception as e:
             logging.error("Error while streaming logs from container '%s': %s", container.name, e)

{model_compose-0.3.3 → model_compose-0.3.5}/src/mindor/core/services/async_service.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Optional, Callable, Awaitable, Any
 from abc import ABC, abstractmethod
 from threading import Thread
 import asyncio
@@ -42,6 +42,28 @@ class AsyncService(ABC):
         if self.daemon_task:
             await self.daemon_task
 
+    def run_in_thread(self, runner: Callable[[], Awaitable[Any]]) -> asyncio.Future:
+        loop = asyncio.get_running_loop()
+        future: asyncio.Future = loop.create_future()
+
+        def _start_in_thread():
+            thread_loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(thread_loop)
+
+            async def _run_and_set_result():
+                try:
+                    result = await runner()
+                    loop.call_soon_threadsafe(future.set_result, result)
+                except Exception as e:
+                    loop.call_soon_threadsafe(future.set_exception, e)
+
+            thread_loop.run_until_complete(_run_and_set_result())
+
+        thread = Thread(target=_start_in_thread)
+        thread.start()
+
+        return future
+
     async def _start(self) -> None:
         self.started = True
 

{model_compose-0.3.3 → model_compose-0.3.5}/src/mindor/dsl/schema/action/action.py

@@ -9,5 +9,6 @@ ActionConfig = Union[
     McpClientActionConfig,
     ModelActionConfig,
     WorkflowActionConfig,
-    ShellActionConfig
+    ShellActionConfig,
+    TextSplitterActionConfig
 ]

{model_compose-0.3.3 → model_compose-0.3.5}/src/mindor/dsl/schema/action/impl/__init__.py

@@ -6,3 +6,4 @@ from .mcp_client import *
 from .model import *
 from .workflow import *
 from .shell import *
+from .text_splitter import *

{model_compose-0.3.3 → model_compose-0.3.5}/src/mindor/dsl/schema/action/impl/http_server.py

@@ -5,4 +5,4 @@ from .common import CommonActionConfig
 
 class HttpServerActionConfig(CommonActionConfig):
     path: Optional[str] = Field(default=None)
-    method: Literal["GET", "POST", "PUT", "DELETE", "PATCH"] = Field(default="POST")
+    method: Literal[ "GET", "POST", "PUT", "DELETE", "PATCH" ] = Field(default="POST")

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

@@ -0,0 +1,18 @@
+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(..., description="Mode for model task execution.")
+
+class CommonModelInferenceActionConfig(CommonModelActionConfig):
+    mode: ModelTaskMode = Literal[ModelTaskMode.INFERENCE]
+    stream: bool = Field(default=False, description="Whether to enable streaming responses for inference.")
+
+class CommonModelTrainingActionConfig(CommonModelActionConfig):
+    mode: ModelTaskMode = Literal[ModelTaskMode.TRAINING]

{model_compose-0.3.3 → model_compose-0.3.5}/src/mindor/dsl/schema/action/impl/model/impl/summarization.py

@@ -1,7 +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 CommonModelActionConfig
+from .common import CommonModelInferenceActionConfig
 
 class SummarizationParamsConfig(BaseModel):
     max_input_length: Union[int, str] = Field(default=1024, description="Maximum number of tokens per input text.")
@@ -13,6 +13,6 @@ class SummarizationParamsConfig(BaseModel):
     do_sample: bool = Field(default=True, description="Whether to use sampling.")
     batch_size: Union[int, str] = Field(default=32, description="Number of input texts to process in a single batch.")
 
-class SummarizationModelActionConfig(CommonModelActionConfig):
+class SummarizationModelActionConfig(CommonModelInferenceActionConfig):
     text: Union[str, List[str]] = Field(..., description="Input text to summarize.")
     params: SummarizationParamsConfig = Field(default_factory=SummarizationParamsConfig, description="Summarization configuration parameters.")

{model_compose-0.3.3 → model_compose-0.3.5}/src/mindor/dsl/schema/action/impl/model/impl/text_classification.py

@@ -1,12 +1,12 @@
 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
+from .common import CommonModelInferenceActionConfig
 
 class TextClassificationParamsConfig(BaseModel):
     return_probabilities: Union[bool, str] = Field(default=False, description="Whether to return class probabilities for each prediction.")
     batch_size: Union[int, str] = Field(default=32, description="Number of input texts to process in a single batch.")
 
-class TextClassificationModelActionConfig(CommonModelActionConfig):
+class TextClassificationModelActionConfig(CommonModelInferenceActionConfig):
     text: Union[str, List[str]] = Field(..., description="Input text to classify.")
     params: TextClassificationParamsConfig = Field(default_factory=TextClassificationParamsConfig, description="Text classification configuration parameters.")

{model_compose-0.3.3 → model_compose-0.3.5}/src/mindor/dsl/schema/action/impl/model/impl/text_embedding.py

@@ -1,7 +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 CommonModelActionConfig
+from .common import CommonModelInferenceActionConfig
 
 class TextEmbeddingParamsConfig(BaseModel):
     max_input_length: Union[int, str] = Field(default=512, description="Maximum number of tokens per input text.")
@@ -9,6 +9,6 @@ class TextEmbeddingParamsConfig(BaseModel):
     normalize: Union[bool, str] = Field(default=True, description="Whether to apply L2 normalization to the output embeddings.")
     batch_size: Union[int, str] = Field(default=32, description="Number of input texts to process in a single batch.")
 
-class TextEmbeddingModelActionConfig(CommonModelActionConfig):
+class TextEmbeddingModelActionConfig(CommonModelInferenceActionConfig):
     text: Union[str, List[str]] = Field(..., description="Input text to be embedded.")
     params: TextEmbeddingParamsConfig = Field(default_factory=TextEmbeddingParamsConfig, description="Configuration parameters for embedding generation.")

{model_compose-0.3.3 → model_compose-0.3.5}/src/mindor/dsl/schema/action/impl/model/impl/text_generation.py

@@ -1,7 +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 CommonModelActionConfig
+from .common import CommonModelInferenceActionConfig
 
 class TextGenerationParamsConfig(BaseModel):
     max_output_length: Union[int, str] = Field(default=1024, description="The maximum number of tokens to generate.")
@@ -11,6 +11,6 @@ class TextGenerationParamsConfig(BaseModel):
     top_p: Union[int, str] = Field(default=0.9, description="Top-p (nucleus) sampling; restricts sampling to tokens with cumulative probability >= top_p.")
     batch_size: Union[int, str] = Field(default=32, description="Number of input texts to process in a single batch.")
 
-class TextGenerationModelActionConfig(CommonModelActionConfig):
+class TextGenerationModelActionConfig(CommonModelInferenceActionConfig):
     prompt: Union[str, List[str]] = Field(..., description="Input prompt to generate text from.")
     params: TextGenerationParamsConfig = Field(default_factory=TextGenerationParamsConfig, description="Text generation configuration parameters.")

{model_compose-0.3.3 → model_compose-0.3.5}/src/mindor/dsl/schema/action/impl/model/impl/translation.py

@@ -1,7 +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 CommonModelActionConfig
+from .common import CommonModelInferenceActionConfig
 
 class TranslationParamsConfig(BaseModel):
     max_input_length: Union[int, str] = Field(default=1024, description="Maximum number of tokens per input text.")
@@ -11,6 +11,6 @@ class TranslationParamsConfig(BaseModel):
     length_penalty: Union[float, str] = Field(default=1.0, description="Length penalty applied during beam search.")
     batch_size: Union[int, str] = Field(default=32, description="Number of input texts to process in a single batch.")
 
-class TranslationModelActionConfig(CommonModelActionConfig):
+class TranslationModelActionConfig(CommonModelInferenceActionConfig):
     text: Union[str, List[str]] = Field(..., description="Input text to translate.")
     params: TranslationParamsConfig = Field(default_factory=TranslationParamsConfig, description="Translation configuration parameters.")

model_compose-0.3.5/src/mindor/dsl/schema/action/impl/text_splitter.py

@@ -0,0 +1,12 @@
+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 CommonActionConfig
+
+class TextSplitterActionConfig(CommonActionConfig):
+    text: str = Field(..., description="Input text to be split.")
+    separators: Optional[List[str]] = Field(default=None, description="Separators used for splitting.")
+    chunk_size: Union[int, str] = Field(default=1000, description="Maximum number of characters per chunk.")
+    chunk_overlap: Union[int, str] = Field(default=200, description="Number of overlapping characters between chunks.")
+    maximize_chunk: Union[bool, str] = Field(default=True, description="Whether to combine parts to fill each chunk as close to the maximum size as possible.")
+    stream: Union[bool, str] = Field(default=False, description="Whether to stream the output chunks one by one instead of returning the full list.")

{model_compose-0.3.3 → model_compose-0.3.5}/src/mindor/dsl/schema/component/component.py

@@ -10,7 +10,8 @@ ComponentConfig = Annotated[
         McpClientComponentConfig,
         ModelComponentConfig,
         WorkflowComponentConfig,
-        ShellComponentConfig
+        ShellComponentConfig,
+        TextSplitterComponentConfig
     ],
     Field(discriminator="type")
 ]

{model_compose-0.3.3 → model_compose-0.3.5}/src/mindor/dsl/schema/component/impl/__init__.py

@@ -6,3 +6,4 @@ from .mcp_client import *
 from .model import *
 from .workflow import *
 from .shell import *
+from .text_splitter import *

model_compose-0.3.5/src/mindor/dsl/schema/component/impl/text_splitter.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 mindor.dsl.schema.action import TextSplitterActionConfig
+from .common import ComponentType, CommonComponentConfig
+
+class TextSplitterComponentConfig(CommonComponentConfig):
+    type: Literal[ComponentType.TEXT_SPLITTER]
+    actions: Optional[Dict[str, TextSplitterActionConfig]] = Field(default_factory=dict, description="Text split actions mapped by an identifier.")
+
+    @model_validator(mode="before")
+    def inflate_single_action(cls, values: Dict[str, Any]):
+        if "actions" not in values:
+            action_keys = set(TextSplitterActionConfig.model_fields.keys())
+            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.3.5/src/mindor/dsl/schema/component/impl/types.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+class ComponentType(str, Enum):
+    HTTP_SERVER   = "http-server"
+    HTTP_CLIENT   = "http-client"
+    MCP_SERVER    = "mcp-server"
+    MCP_CLIENT    = "mcp-client"
+    MODEL         = "model"
+    WORKFLOW      = "workflow"
+    SHELL         = "shell"
+    TEXT_SPLITTER = "text-splitter"

{model_compose-0.3.3 → model_compose-0.3.5}/src/mindor/dsl/schema/runtime/impl/docker.py

@@ -17,11 +17,11 @@ class DockerBuildConfig(BaseModel):
 class DockerPortConfig(BaseModel):
     target: int = Field(..., description="Port exposed by the container.")
     published: Optional[int] = Field(default=None, description="Host port to publish.")
-    protocol: Optional[Literal["tcp", "udp"]] = Field(default="tcp", description="Protocol.")
-    mode: Optional[Literal["host", "ingress"]] = Field(default=None, description="Publishing mode.")
+    protocol: Optional[Literal[ "tcp", "udp" ]] = Field(default="tcp", description="Protocol.")
+    mode: Optional[Literal[ "host", "ingress" ]] = Field(default=None, description="Publishing mode.")
 
 class DockerVolumeConfig(BaseModel):
-    type: Optional[Literal["bind", "volume", "tmpfs"]] = Field(default=None, description="Volume type.")
+    type: Optional[Literal[ "bind", "volume", "tmpfs" ]] = Field(default=None, description="Volume type.")
     target: str = Field(..., description="Target path inside the container.")
     source: Optional[str] = Field(default=None, description="Source path or volume name on the host.")
     read_only: Optional[bool] = Field(default=None, description="Mount as read-only.")
@@ -63,7 +63,7 @@ class DockerRuntimeConfig(CommonRuntimeConfig):
     cpus: Optional[Union[str, float]] = Field(default=None, description="CPU quota.")
     cpu_shares: Optional[int] = Field(default=None, description="Relative CPU weight.")
     # Restart policy and health checks
-    restart: Literal["no", "always", "on-failure", "unless-stopped"] = Field(default="no", description="Restart policy.")
+    restart: Literal[ "no", "always", "on-failure", "unless-stopped" ] = Field(default="no", description="Restart policy.")
     healthcheck: Optional[DockerHealthCheck] = Field(default=None, description="Health check configuration.")
     # Miscellaneous
     labels: Optional[Dict[str, str]] = Field(default=None, description="Container labels.")

{model_compose-0.3.3 → model_compose-0.3.5/src/model_compose.egg-info}/PKG-INFO

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