model-compose 0.3.14__tar.gz → 0.3.15__tar.gz

{model_compose-0.3.14 → model_compose-0.3.15}/PKG-INFO

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

{model_compose-0.3.14 → model_compose-0.3.15}/pyproject.toml

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

{model_compose-0.3.14 → model_compose-0.3.15}/src/mindor/core/component/base.py

@@ -64,6 +64,10 @@ class ComponentService(AsyncService):
     async def teardown(self) -> None:
         await self._teardown()
 
+    async def start(self, background: bool = False) -> None:
+        await super().start(background)
+        await self.wait_until_ready()
+
     async def run(self, action_id: Union[str, None], run_id: str, input: Dict[str, Any]) -> Dict[str, Any]:
         _, action = ActionResolver(self.config.actions).resolve(action_id)
         context = ComponentActionContext(run_id, input)
@@ -97,6 +101,9 @@ class ComponentService(AsyncService):
     async def _shutdown(self) -> None:
         pass
 
+    async def _is_ready(self) -> bool:
+        return True
+
     @abstractmethod
     async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
         pass

{model_compose-0.3.14 → model_compose-0.3.15}/src/mindor/core/component/services/http_server.py

@@ -161,10 +161,19 @@ class HttpServerComponent(ComponentService):
 
     async def _serve(self) -> None:
         if self.config.manage.scripts.start:
-            await run_command_streaming(self.config.manage.scripts.start, self.config.manage.working_dir, self.config.manage.env, block=False)
+            await run_command_streaming(self.config.manage.scripts.start, self.config.manage.working_dir, self.config.manage.env)
 
     async def _shutdown(self) -> None:
         pass
 
+    async def _is_ready(self) -> bool:
+        try:
+            _, writer = await asyncio.open_connection("localhost", self.config.port)
+            writer.close()
+            await writer.wait_closed()
+            return True
+        except (ConnectionRefusedError, OSError):
+            return False
+
     async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
         return await HttpServerAction(action).run(context, self.client)

{model_compose-0.3.14 → model_compose-0.3.15}/src/mindor/core/component/services/model/base.py

@@ -1,6 +1,6 @@
 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, DeviceMode
+from mindor.dsl.schema.component import ModelComponentConfig, ModelTaskType, ModelSourceConfig, DeviceMode
 from mindor.dsl.schema.action import ModelActionConfig
 from mindor.core.services import AsyncService
 from ...context import ComponentActionContext
@@ -26,7 +26,7 @@ class ModelTaskService(AsyncService):
     async def _run(self, action: ModelActionConfig, context: ComponentActionContext, loop: asyncio.AbstractEventLoop) -> Any:
         pass
 
-    def _load_pretrained_model(self, extra_params: Optional[Dict[str, Any]] = None) -> PreTrainedModel:
+    def _load_pretrained_model(self, extra_params: Optional[Dict[str, Any]] = None) -> Union[PreTrainedModel, torch.nn.Module]:
         params = self._get_common_model_params()
 
         if extra_params:
@@ -42,6 +42,10 @@ class ModelTaskService(AsyncService):
     def _get_common_model_params(self) -> Dict[str, Any]:
         params: Dict[str, Any] = {}
 
+        if isinstance(self.config.model, ModelSourceConfig):
+            if self.config.model.revision:
+                params["revision"] = self.config.model.revision
+
         if self.config.device_mode != DeviceMode.SINGLE:
             params["device_map"] = self.config.device_mode.value
     
@@ -51,9 +55,6 @@ class ModelTaskService(AsyncService):
         if self.config.low_cpu_mem_usage:
             params["low_cpu_mem_usage"] = True
 
-        if self.config.revision:
-            params["revision"] = self.config.revision
-
         if self.config.cache_dir:
             params["cache_dir"] = self.config.cache_dir
 
@@ -75,12 +76,13 @@ class ModelTaskService(AsyncService):
 
     def _get_common_tokenizer_params(self) -> Dict[str, Any]:
         params: Dict[str, Any] = {}
+
+        if isinstance(self.config.model, ModelSourceConfig):
+            if self.config.model.revision:
+                params["revision"] = self.config.model.revision
     
         if not self.config.fast_tokenizer:
             params["use_fast"] = False
-    
-        if self.config.revision:
-            params["revision"] = self.config.revision
 
         if self.config.cache_dir:
             params["cache_dir"] = self.config.cache_dir
@@ -104,9 +106,10 @@ class ModelTaskService(AsyncService):
     def _get_common_processor_params(self) -> Dict[str, Any]:
         params: Dict[str, Any] = {}
 
-        if self.config.revision:
-            params["revision"] = self.config.revision
-
+        if isinstance(self.config.model, ModelSourceConfig):
+            if self.config.model.revision:
+                params["revision"] = self.config.model.revision
+ 
         if self.config.cache_dir:
             params["cache_dir"] = self.config.cache_dir
 

model_compose-0.3.15/src/mindor/core/component/services/model/loader.py

@@ -0,0 +1,25 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, AsyncIterator, Any
+from transformers import PreTrainedModel
+import torch
+    
+async def load_model(
+    provider: str,
+    model_id: str,
+    revision: Optional[str],
+    filename: Optional[str],
+    model_class: Type[PreTrainedModel],
+    *,
+    cache_dir: Optional[str] = None,
+    local_files_only: bool = False
+) -> Union[PreTrainedModel, torch.nn.Module]:
+    if provider in [ "huggingface.co", "huggingface.com", "huggingface" ]:
+        pass
+
+async def load_model_from_uri(
+    uri: str,
+    model_class: Type[PreTrainedModel],
+    *,
+    cache_dir: Optional[str] = None,
+    local_files_only: bool = False
+) -> Union[PreTrainedModel, torch.nn.Module]:
+    pass

{model_compose-0.3.14 → model_compose-0.3.15}/src/mindor/core/component/services/model/tasks/image_to_text.py

@@ -5,7 +5,7 @@ from mindor.core.utils.streamer import AsyncStreamer
 from mindor.core.logger import logging
 from ..base import ModelTaskService, ModelTaskType, register_model_task_service
 from ..base import ComponentActionContext
-from transformers import PreTrainedModel, PreTrainedTokenizer, ProcessorMixin, GenerationMixin, TextIteratorStreamer
+from transformers import PreTrainedModel, PreTrainedTokenizer, ProcessorMixin, GenerationMixin, TextIteratorStreamer, StopStringCriteria
 from PIL import Image as PILImage
 from threading import Thread
 from torch import Tensor
@@ -25,8 +25,20 @@ class ImageToTextTaskAction:
         image: Union[PILImage.Image, List[PILImage.Image]] = await context.render_image(self.config.image)
         prompt: Optional[Union[str, List[str]]] = await context.render_variable(self.config.prompt)
 
-        batch_size = await context.render_variable(self.config.params.batch_size)
-        stream     = await context.render_variable(self.config.stream)
+        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_return_sequences = await context.render_variable(self.config.params.num_return_sequences)
+        do_sample            = await context.render_variable(self.config.params.do_sample)
+        temperature          = await context.render_variable(self.config.params.temperature) if do_sample else None
+        top_k                = await context.render_variable(self.config.params.top_k) if do_sample else None
+        top_p                = await context.render_variable(self.config.params.top_p) if do_sample else None
+        num_beams            = await context.render_variable(self.config.params.num_beams)
+        length_penalty       = await context.render_variable(self.config.params.length_penalty) if num_beams > 1 else None
+        early_stopping       = await context.render_variable(self.config.params.early_stopping) if num_beams > 1 else False
+        stop_sequences       = await context.render_variable(self.config.params.stop_sequences)
+        batch_size           = await context.render_variable(self.config.params.batch_size)
+        stream               = await context.render_variable(self.config.stream)
 
         is_single_input: bool = bool(not isinstance(images, list))
         images: List[PILImage.Image] = [ image ] if is_single_input else image
@@ -37,17 +49,31 @@ class ImageToTextTaskAction:
             raise ValueError("Streaming mode only supports a single input image with batch size of 1.")
 
         streamer = TextIteratorStreamer(self.processor.tokenizer, skip_prompt=True, skip_special_tokens=True) if stream else None
+        stopping_criteria = [ StopStringCriteria(self.processor.tokenizer, stop_sequences) ] if stop_sequences else None
         for index in range(0, len(images), batch_size):
             batch_images = images[index:index + batch_size]
             batch_prompts = prompts[index:index + batch_size] if prompts else None
             
-            inputs: Tensor = self.processor(images=batch_images, text=batch_prompts, return_tensors="pt")
+            inputs: Tensor = self.processor(images=batch_images, text=batch_prompts, max_length=max_input_length, return_tensors="pt")
             inputs = inputs.to(self.device)
 
             def _generate():
                 with torch.inference_mode():
                     outputs = self.model.generate(
                         **inputs,
+                        max_new_tokens=max_output_length,
+                        min_length=min_output_length,
+                        num_return_sequences=num_return_sequences,
+                        do_sample=do_sample,
+                        temperature=temperature,
+                        top_k=top_k,
+                        top_p=top_p,
+                        num_beams=num_beams,
+                        length_penalty=length_penalty,
+                        early_stopping=early_stopping,
+                        pad_token_id=getattr(self.processor.tokenizer, "pad_token_id", None),
+                        eos_token_id=getattr(self.processor.tokenizer, "eos_token_id", None),
+                        stopping_criteria=stopping_criteria,
                         streamer=streamer
                     )
 

{model_compose-0.3.14 → model_compose-0.3.15}/src/mindor/core/component/services/model/tasks/summarization.py

@@ -5,7 +5,7 @@ from mindor.core.utils.streamer import AsyncStreamer
 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, TextIteratorStreamer
+from transformers import AutoModelForSeq2SeqLM, AutoTokenizer, PreTrainedModel, PreTrainedTokenizer, GenerationMixin, TextIteratorStreamer, StopStringCriteria
 from threading import Thread
 from torch import Tensor
 import torch, asyncio
@@ -23,12 +23,14 @@ class SummarizationTaskAction:
         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) if num_beams > 1 else None
-        early_stopping    = await context.render_variable(self.config.params.early_stopping) if num_beams > 1 else False
         do_sample         = await context.render_variable(self.config.params.do_sample)
+        temperature       = await context.render_variable(self.config.params.temperature) if do_sample else None
         top_k             = await context.render_variable(self.config.params.top_k) if do_sample else None
         top_p             = await context.render_variable(self.config.params.top_p) if do_sample else None
+        num_beams         = await context.render_variable(self.config.params.num_beams)
+        length_penalty    = await context.render_variable(self.config.params.length_penalty) if num_beams > 1 else None
+        early_stopping    = await context.render_variable(self.config.params.early_stopping) if num_beams > 1 else False
+        stop_sequences    = await context.render_variable(self.config.params.stop_sequences)
         batch_size        = await context.render_variable(self.config.params.batch_size)
         stream            = await context.render_variable(self.config.stream)
 
@@ -40,6 +42,7 @@ class SummarizationTaskAction:
             raise ValueError("Streaming mode only supports a single input text with batch size of 1.")
 
         streamer = TextIteratorStreamer(self.tokenizer, skip_prompt=True, skip_special_tokens=True) if stream else None
+        stopping_criteria = [ StopStringCriteria(self.tokenizer, stop_sequences) ] if stop_sequences else None
         for index in range(0, len(texts), batch_size):
             batch_texts = texts[index:index + batch_size]
             inputs: Dict[str, Tensor] = self.tokenizer(batch_texts, return_tensors="pt", max_length=max_input_length, padding=True, truncation=True)
@@ -49,16 +52,18 @@ class SummarizationTaskAction:
                 with torch.inference_mode():
                     outputs = self.model.generate(
                         **inputs,
-                        max_length=max_output_length,
+                        max_new_tokens=max_output_length,
                         min_length=min_output_length,
-                        num_beams=num_beams,
-                        length_penalty=length_penalty,
-                        early_stopping=early_stopping,
                         do_sample=do_sample,
+                        temperature=temperature,
                         top_k=top_k,
                         top_p=top_p,
+                        num_beams=num_beams,
+                        length_penalty=length_penalty,
+                        early_stopping=early_stopping,
                         pad_token_id=getattr(self.tokenizer, "pad_token_id", None),
                         eos_token_id=getattr(self.tokenizer, "eos_token_id", None),
+                        stopping_criteria=stopping_criteria,
                         streamer=streamer
                     )
 

{model_compose-0.3.14 → model_compose-0.3.15}/src/mindor/core/component/services/model/tasks/text_generation.py

@@ -5,7 +5,7 @@ from mindor.core.utils.streamer import AsyncStreamer
 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, TextIteratorStreamer
+from transformers import AutoModelForCausalLM, AutoTokenizer, PreTrainedModel, PreTrainedTokenizer, GenerationMixin, TextIteratorStreamer, StopStringCriteria
 from threading import Thread
 from torch import Tensor
 import torch, asyncio
@@ -21,10 +21,16 @@ class TextGenerationTaskAction:
         prompt: Union[str, List[str]] = await context.render_variable(self.config.prompt)
 
         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_return_sequences = await context.render_variable(self.config.params.num_return_sequences)
+        do_sample            = await context.render_variable(self.config.params.do_sample)
         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)
+        num_beams            = await context.render_variable(self.config.params.num_beams)
+        length_penalty       = await context.render_variable(self.config.params.length_penalty) if num_beams > 1 else None
+        early_stopping       = await context.render_variable(self.config.params.early_stopping) if num_beams > 1 else False
+        stop_sequences       = await context.render_variable(self.config.params.stop_sequences)
         batch_size           = await context.render_variable(self.config.params.batch_size)
         stream               = await context.render_variable(self.config.stream)
 
@@ -36,6 +42,7 @@ class TextGenerationTaskAction:
             raise ValueError("Streaming mode only supports a single input prompt with batch size of 1.")
 
         streamer = TextIteratorStreamer(self.tokenizer, skip_prompt=True, skip_special_tokens=True) if stream else None
+        stopping_criteria = [ StopStringCriteria(self.tokenizer, stop_sequences) ] if stop_sequences else None
         for index in range(0, len(prompts), batch_size):
             batch_prompts = prompts[index:index + batch_size]
             inputs: Dict[str, Tensor] = self.tokenizer(batch_prompts, return_tensors="pt", padding=True, truncation=True)
@@ -46,11 +53,18 @@ class TextGenerationTaskAction:
                     outputs = self.model.generate(
                         **inputs,
                         max_new_tokens=max_output_length,
+                        min_length=min_output_length,
                         num_return_sequences=num_return_sequences,
+                        do_sample=do_sample,
                         temperature=temperature,
-                        do_sample=True,
                         top_k=top_k,
                         top_p=top_p,
+                        num_beams=num_beams,
+                        length_penalty=length_penalty,
+                        early_stopping=early_stopping,
+                        pad_token_id=getattr(self.tokenizer, "pad_token_id", None),
+                        eos_token_id=getattr(self.tokenizer, "eos_token_id", None),
+                        stopping_criteria=stopping_criteria,
                         streamer=streamer
                     )
 

{model_compose-0.3.14 → model_compose-0.3.15}/src/mindor/core/component/services/model/tasks/translation.py

@@ -5,7 +5,7 @@ from mindor.core.utils.streamer import AsyncStreamer
 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, TextIteratorStreamer
+from transformers import AutoModelForSeq2SeqLM, AutoTokenizer, PreTrainedModel, PreTrainedTokenizer, GenerationMixin, TextIteratorStreamer, StopStringCriteria
 from threading import Thread
 from torch import Tensor
 import torch, asyncio
@@ -23,12 +23,14 @@ class TranslationTaskAction:
         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) if num_beams > 1 else None
-        early_stopping    = await context.render_variable(self.config.params.early_stopping) if num_beams > 1 else False
         do_sample         = await context.render_variable(self.config.params.do_sample)
+        temperature       = await context.render_variable(self.config.params.temperature) if do_sample else None
         top_k             = await context.render_variable(self.config.params.top_k) if do_sample else None
         top_p             = await context.render_variable(self.config.params.top_p) if do_sample else None
+        num_beams         = await context.render_variable(self.config.params.num_beams)
+        length_penalty    = await context.render_variable(self.config.params.length_penalty) if num_beams > 1 else None
+        early_stopping    = await context.render_variable(self.config.params.early_stopping) if num_beams > 1 else False
+        stop_sequences    = await context.render_variable(self.config.params.stop_sequences)
         batch_size        = await context.render_variable(self.config.params.batch_size)
         stream            = await context.render_variable(self.config.stream)
 
@@ -40,6 +42,7 @@ class TranslationTaskAction:
             raise ValueError("Streaming mode only supports a single input text with batch size of 1.")
 
         streamer = TextIteratorStreamer(self.tokenizer, skip_prompt=True, skip_special_tokens=True) if stream else None
+        stopping_criteria = [ StopStringCriteria(self.tokenizer, stop_sequences) ] if stop_sequences else None
         for index in range(0, len(texts), batch_size):
             batch_texts = texts[index:index + batch_size]
             inputs: Dict[str, Tensor] = self.tokenizer(batch_texts, return_tensors="pt", max_length=max_input_length, padding=True, truncation=True)
@@ -49,16 +52,18 @@ class TranslationTaskAction:
                 with torch.inference_mode():
                     outputs = self.model.generate(
                         **inputs,
-                        max_length=max_output_length,
+                        max_new_tokens=max_output_length,
                         min_length=min_output_length,
-                        num_beams=num_beams,
-                        length_penalty=length_penalty,
-                        early_stopping=early_stopping,
                         do_sample=do_sample,
+                        temperature=temperature,
                         top_k=top_k,
                         top_p=top_p,
+                        num_beams=num_beams,
+                        length_penalty=length_penalty,
+                        early_stopping=early_stopping,
                         pad_token_id=getattr(self.tokenizer, "pad_token_id", None),
                         eos_token_id=getattr(self.tokenizer, "eos_token_id", None),
+                        stopping_criteria=stopping_criteria,
                         streamer=streamer
                     )
 

{model_compose-0.3.14 → model_compose-0.3.15}/src/mindor/core/services/async_service.py

@@ -1,7 +1,7 @@
 from typing import Optional, Callable, Awaitable, Any
 from abc import ABC, abstractmethod
 from threading import Thread
-import asyncio
+import asyncio, time
 
 class AsyncService(ABC):
     def __init__(self, daemon: bool):
@@ -35,6 +35,16 @@ class AsyncService(ABC):
         else:
             await self._stop()
 
+    async def wait_until_ready(self, timeout: int = 0) -> None:
+        start_time = time.monotonic()
+
+        while timeout <= 0 or time.monotonic() - start_time < timeout:
+            if await self._is_ready():
+                return
+            await asyncio.sleep(0.5)
+
+        raise TimeoutError(f"Service did not become ready within {timeout} seconds.")
+
     async def wait_until_stopped(self) -> None:
         if self.thread:
             self.thread.join()
@@ -81,6 +91,9 @@ class AsyncService(ABC):
 
         self.started = False
 
+    async def _is_ready(self) -> bool:
+        return True
+
     async def _on_stop(self) -> None:
         pass
 

{model_compose-0.3.14 → model_compose-0.3.15}/src/mindor/core/utils/shell.py

@@ -5,8 +5,7 @@ import asyncio, os
 async def run_command_streaming(
     command: List[str],
     working_dir: Optional[str] = None,
-    env: Dict[str, str] = None,
-    block: bool = True
+    env: Dict[str, str] = None
 ) -> None:
     process = await asyncio.create_subprocess_exec(
         *command,
@@ -23,18 +22,11 @@ async def run_command_streaming(
                 break
             print(line.decode().rstrip())
 
-    if block:
-        stdout_task = asyncio.create_task(_stream_output(process.stdout))
-        stderr_task = asyncio.create_task(_stream_output(process.stderr))
-        await process.wait()
-        await stdout_task
-        await stderr_task
-    else:
-        await asyncio.gather(
-            _stream_output(process.stdout),
-            _stream_output(process.stderr),
-            process.wait()
-        )
+    await asyncio.gather(
+        _stream_output(process.stdout),
+        _stream_output(process.stderr),
+        process.wait()
+    )
 
 async def run_command(
     command: List[str],

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

@@ -0,0 +1,7 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+
+class CommonActionConfig(BaseModel):
+    id: str = Field(default="__default__", description="ID of action.")
+    output: Optional[Any] = Field(default=None, description="Output mapping to transform and extract specific values from the action result.")
+    default: bool = Field(default=False, description="Whether this action should be used as the default.")

{model_compose-0.3.14 → model_compose-0.3.15}/src/mindor/dsl/schema/action/impl/http_client.py

@@ -15,17 +15,17 @@ class HttpClientCommonCompletionConfig(BaseModel):
 
 class HttpClientPollingCompletionConfig(HttpClientCommonCompletionConfig):
     type: Literal[HttpClientCompletionType.POLLING]
-    endpoint: Optional[str] = Field(default=None, description="")
-    path: Optional[str] = Field(default=None, description="")
-    method: Literal[ "GET", "POST", "PUT", "DELETE", "PATCH" ] = Field(default="GET", description="")
-    headers: Dict[str, str] = Field(default_factory=dict, description="")
-    body: Dict[str, Any] = Field(default_factory=dict, description="")
-    params: Dict[str, str] = Field(default_factory=dict, description="")
-    status: Optional[str] = Field(default=None, description="")
-    success_when: Optional[List[Union[int, str]]] = Field(default=None, description="")
-    fail_when: Optional[List[Union[int, str]]] = Field(default=None, description="")
-    interval: Optional[str] = Field(default=None, description="")
-    timeout: Optional[str] = Field(default=None, description="")
+    endpoint: Optional[str] = Field(default=None, description="URL endpoint for polling requests.")
+    path: Optional[str] = Field(default=None, description="URL path to append to base_url for polling.")
+    method: Literal[ "GET", "POST", "PUT", "DELETE", "PATCH" ] = Field(default="GET", description="HTTP method for polling requests.")
+    headers: Dict[str, str] = Field(default_factory=dict, description="HTTP headers to include in polling requests.")
+    body: Dict[str, Any] = Field(default_factory=dict, description="Request body data for polling requests.")
+    params: Dict[str, str] = Field(default_factory=dict, description="URL query parameters for polling requests.")
+    status: Optional[str] = Field(default=None, description="Field path to check for completion status in polling response.")
+    success_when: Optional[List[Union[int, str]]] = Field(default=None, description="Status codes or values that indicate successful completion.")
+    fail_when: Optional[List[Union[int, str]]] = Field(default=None, description="Status codes or values that indicate failed completion.")
+    interval: Optional[str] = Field(default=None, description="Time interval between polling attempts.")
+    timeout: Optional[str] = Field(default=None, description="Maximum time to wait for completion before giving up.")
 
     @model_validator(mode="before")
     def validate_endpoint_or_path(cls, values: Dict[str, Any]):
@@ -42,7 +42,7 @@ class HttpClientPollingCompletionConfig(HttpClientCommonCompletionConfig):
 
 class HttpClientCallbackCompletionConfig(HttpClientCommonCompletionConfig):
     type: Literal[HttpClientCompletionType.CALLBACK]
-    wait_for: Optional[str] = Field(default=None, description="")
+    wait_for: Optional[str] = Field(default=None, description="Callback identifier to wait for in asynchronous completion mode")
 
 HttpClientCompletionConfig = Annotated[ 
     Union[
@@ -53,14 +53,14 @@ HttpClientCompletionConfig = Annotated[
 ]
 
 class HttpClientActionConfig(CommonActionConfig):
-    endpoint: Optional[str] = Field(default=None, description="")
-    path: Optional[str] = Field(default=None, description="")
-    method: Literal[ "GET", "POST", "PUT", "DELETE", "PATCH" ] = Field(default="POST", description="")
-    headers: Dict[str, str] = Field(default_factory=dict, description="")
-    body: Dict[str, Any] = Field(default_factory=dict, description="")
-    params: Dict[str, str] = Field(default_factory=dict, description="")
+    endpoint: Optional[str] = Field(default=None, description="Full URL endpoint for the HTTP request (mutually exclusive with path)")
+    path: Optional[str] = Field(default=None, description="URL path to append to base_url (mutually exclusive with endpoint)")
+    method: Literal[ "GET", "POST", "PUT", "DELETE", "PATCH" ] = Field(default="POST", description="HTTP method to use for the request")
+    headers: Dict[str, str] = Field(default_factory=dict, description="HTTP headers to include in the request")
+    body: Dict[str, Any] = Field(default_factory=dict, description="Request body data to send with the HTTP request")
+    params: Dict[str, str] = Field(default_factory=dict, description="URL query parameters to append to the request")
     stream_format: Optional[HttpStreamFormat] = Field(default=None, description="Format of stream payload.")
-    completion: Optional[HttpClientCompletionConfig] = Field(default=None, description="")
+    completion: Optional[HttpClientCompletionConfig] = Field(default=None, description="Configuration for handling asynchronous request completion via polling or callbacks")
 
     @model_validator(mode="before")
     def validate_endpoint_or_path(cls, values: Dict[str, Any]):

{model_compose-0.3.14 → model_compose-0.3.15}/src/mindor/dsl/schema/action/impl/http_server.py

@@ -15,16 +15,16 @@ class HttpServerCommonCompletionConfig(BaseModel):
 
 class HttpServerPollingCompletionConfig(HttpServerCommonCompletionConfig):
     type: Literal[HttpServerCompletionType.POLLING]
-    path: Optional[str] = Field(default=None, description="")
-    method: Literal[ "GET", "POST", "PUT", "DELETE", "PATCH" ] = Field(default="GET", description="")
-    headers: Dict[str, str] = Field(default_factory=dict, description="")
-    body: Dict[str, Any] = Field(default_factory=dict, description="")
-    params: Dict[str, str] = Field(default_factory=dict, description="")
-    status: Optional[str] = Field(default=None, description="")
-    success_when: Optional[List[Union[int, str]]] = Field(default=None, description="")
-    fail_when: Optional[List[Union[int, str]]] = Field(default=None, description="")
-    interval: Optional[str] = Field(default=None, description="")
-    timeout: Optional[str] = Field(default=None, description="")
+    path: Optional[str] = Field(default=None, description="URL path for the polling endpoint to check completion status.")
+    method: Literal[ "GET", "POST", "PUT", "DELETE", "PATCH" ] = Field(default="GET", description="HTTP method for polling completion status.")
+    headers: Dict[str, str] = Field(default_factory=dict, description="HTTP headers to include in polling requests.")
+    body: Dict[str, Any] = Field(default_factory=dict, description="Request body data for polling requests.")
+    params: Dict[str, str] = Field(default_factory=dict, description="URL query parameters for polling requests.")
+    status: Optional[str] = Field(default=None, description="Field path to check for completion status in polling response.")
+    success_when: Optional[List[Union[int, str]]] = Field(default=None, description="Status codes or values that indicate successful completion.")
+    fail_when: Optional[List[Union[int, str]]] = Field(default=None, description="Status codes or values that indicate failed completion.")
+    interval: Optional[str] = Field(default=None, description="Time interval between polling attempts.")
+    timeout: Optional[str] = Field(default=None, description="Maximum time to wait for completion before giving up.")
 
     @model_validator(mode="before")
     def normalize_status_fields(cls, values: Dict[str, Any]):
@@ -35,7 +35,7 @@ class HttpServerPollingCompletionConfig(HttpServerCommonCompletionConfig):
 
 class HttpServerCallbackCompletionConfig(HttpServerCommonCompletionConfig):
     type: Literal[HttpServerCompletionType.CALLBACK]
-    wait_for: Optional[str] = Field(default=None, description="")
+    wait_for: Optional[str] = Field(default=None, description="Callback identifier to wait for in asynchronous completion mode.")
 
 HttpServerCompletionConfig = Annotated[ 
     Union[
@@ -46,10 +46,10 @@ HttpServerCompletionConfig = Annotated[
 ]
 
 class HttpServerActionConfig(CommonActionConfig):
-    path: Optional[str] = Field(default=None)
-    method: Literal[ "GET", "POST", "PUT", "DELETE", "PATCH" ] = Field(default="POST", description="")
-    headers: Dict[str, str] = Field(default_factory=dict, description="")
-    body: Dict[str, Any] = Field(default_factory=dict, description="")
-    params: Dict[str, str] = Field(default_factory=dict, description="")
+    path: Optional[str] = Field(default=None, description="URL path for this HTTP server endpoint.")
+    method: Literal[ "GET", "POST", "PUT", "DELETE", "PATCH" ] = Field(default="POST", description="HTTP method this endpoint will accept.")
+    headers: Dict[str, str] = Field(default_factory=dict, description="HTTP headers to include in responses from this endpoint.")
+    body: Dict[str, Any] = Field(default_factory=dict, description="Default response body template for this endpoint.")
+    params: Dict[str, str] = Field(default_factory=dict, description="Expected URL query parameters for this endpoint.")
     stream_format: Optional[HttpStreamFormat] = Field(default=None, description="Format of stream payload.")
-    completion: Optional[HttpServerCompletionConfig] = Field(default=None, description="")
+    completion: Optional[HttpServerCompletionConfig] = Field(default=None, description="Configuration for handling asynchronous request completion via polling or callbacks.")

{model_compose-0.3.14/src/mindor/dsl/schema/component → model_compose-0.3.15/src/mindor/dsl/schema/action}/impl/model/impl/__init__.py

@@ -1,5 +1,6 @@
 from .common import *
 from .text_generation import *
+from .chat_completion import *
 from .summarization import *
 from .translation import *
 from .text_classification import *

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

@@ -0,0 +1,41 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, TypeAlias, Any
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+from .common import CommonModelInferenceActionConfig
+
+class ChatMessage(BaseModel):
+    role: str = Field(..., description="Role of the message sender.")
+    content: str = Field(..., description="Text content of the chat message.")
+
+class ToolCall(BaseModel):
+    role: str = Field(default="assistant", description="Role for tool calls.")
+    name: str = Field(..., description="Tool name.")
+    call_id: str = Field(..., description="Tool call identifier.")
+    arguments: Dict[str, Any] = Field(default_factory=dict, description="Arguments passed to the tool function.")
+
+class ToolResult(BaseModel):
+    role: str = Field(default="tool", description="Role for tool responses.")
+    call_id: str = Field(..., description="Tool call identifier.")
+    name: Optional[str] = Field(default=None, description="Tool name.")
+    content: Optional[Any] = Field(default=None, description="Tool execution result.")
+    error: Optional[str] = Field(default=None, description="Error message if tool execution failed.")
+
+InputMessage: TypeAlias = Union[ToolResult, ToolCall, ChatMessage]
+
+class ChatCompletionParamsConfig(BaseModel):
+    max_output_length: Union[int, str] = Field(default=1024, description="Maximum number of tokens to generate.")
+    min_output_length: Union[int, str] = Field(default=1, description="Minimum number of tokens to generate.")
+    num_return_sequences: Union[int, str] = Field(default=1, description="Number of generated sequences to return.")
+    do_sample: bool = Field(default=True, description="Whether to use sampling to generate diverse texts.")
+    temperature: Union[float, str] = Field(default=1.0, description="Sampling temperature; higher values produce more random results.")
+    top_k: Union[int, str] = Field(default=50, description="Top-K sampling; restricts sampling to the top K tokens.")
+    top_p: Union[float, str] = Field(default=0.9, description="Top-p (nucleus) sampling; restricts sampling to tokens with cumulative probability >= top_p.")
+    num_beams: Union[int, str] = Field(default=1, description="Number of beams to use for beam search.")
+    length_penalty: Union[float, str] = Field(default=1.0, description="Length penalty applied during beam search.")
+    early_stopping: bool = Field(default=True, description="Whether to stop the beam search when all beams finish generating.")
+    stop_sequences: Union[List[str], str] = Field(default=None, description="List of stop sequences.")
+    batch_size: Union[int, str] = Field(default=1, description="Number of input texts to process in a single batch.")
+
+class ChatCompletionModelActionConfig(CommonModelInferenceActionConfig):
+    messages: Union[InputMessage, List[InputMessage]] = Field(..., description="Input messages to generate text from.")
+    params: ChatCompletionParamsConfig = Field(default_factory=ChatCompletionParamsConfig, description="Chat completion configuration parameters.")