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

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

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

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

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

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

@@ -5,7 +5,6 @@ from mindor.dsl.schema.action import ModelActionConfig
 from mindor.core.services import AsyncService
 from ...context import ComponentActionContext
 from transformers import PreTrainedModel, PreTrainedTokenizer
-from threading import Thread
 import torch, asyncio
 
 class ModelTaskService(AsyncService):
@@ -16,13 +15,15 @@ class ModelTaskService(AsyncService):
         self.config: ModelComponentConfig = config
 
     async def run(self, action: ModelActionConfig, context: ComponentActionContext) -> Any:
+        loop: asyncio.AbstractEventLoop = asyncio.get_running_loop()
+
         async def _run():
-            return await self._run(action, context)
+            return await self._run(action, context, loop)
 
         return await self.run_in_thread(_run)
 
     @abstractmethod
-    async def _run(self, action: ModelActionConfig, context: ComponentActionContext) -> Any:
+    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:

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

@@ -1,12 +1,14 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.component import ModelComponentConfig
 from mindor.dsl.schema.action import ModelActionConfig, SummarizationModelActionConfig
+from mindor.core.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
+from transformers import AutoModelForSeq2SeqLM, AutoTokenizer, PreTrainedModel, PreTrainedTokenizer, GenerationMixin, TextIteratorStreamer
+from threading import Thread
 from torch import Tensor
-import torch
+import torch, asyncio
 
 class SummarizationTaskAction:
     def __init__(self, config: SummarizationModelActionConfig, model: Union[PreTrainedModel, GenerationMixin], tokenizer: PreTrainedTokenizer, device: torch.device):
@@ -15,46 +17,71 @@ class SummarizationTaskAction:
         self.tokenizer: PreTrainedTokenizer = tokenizer
         self.device: torch.device = device
 
-    async def run(self, context: ComponentActionContext) -> Any:
+    async def run(self, context: ComponentActionContext, loop: asyncio.AbstractEventLoop) -> Any:
         text: Union[str, List[str]] = await context.render_variable(self.config.text)
 
         max_input_length  = await context.render_variable(self.config.params.max_input_length)
         max_output_length = await context.render_variable(self.config.params.max_output_length)
         min_output_length = await context.render_variable(self.config.params.min_output_length)
         num_beams         = await context.render_variable(self.config.params.num_beams)
-        length_penalty    = await context.render_variable(self.config.params.length_penalty)
-        early_stopping    = await context.render_variable(self.config.params.early_stopping)
+        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)
+        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
         batch_size        = await context.render_variable(self.config.params.batch_size)
+        stream            = await context.render_variable(self.config.stream)
 
         texts: List[str] = [ text ] if isinstance(text, str) else text
         results = []
 
+        if stream and (batch_size != 1 or len(texts) != 1):
+            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
         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)
             inputs = { k: v.to(self.device) for k, v in inputs.items() }
 
-            with torch.no_grad():
-                outputs = self.model.generate(
-                    **inputs,
-                    max_length=max_output_length,
-                    min_length=min_output_length,
-                    num_beams=num_beams,
-                    length_penalty=length_penalty,
-                    early_stopping=early_stopping,
-                    do_sample=do_sample,
-                    pad_token_id=getattr(self.tokenizer, "pad_token_id", None),
-                    eos_token_id=getattr(self.tokenizer, "eos_token_id", None)
-                )
-
-            outputs = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)
-            results.extend(outputs)
-        
-        result = results if len(results) > 1 else results[0]
-        context.register_source("result", result)
-
-        return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result
+            def _generate():
+                with torch.no_grad():
+                    outputs = self.model.generate(
+                        **inputs,
+                        max_length=max_output_length,
+                        min_length=min_output_length,
+                        num_beams=num_beams,
+                        length_penalty=length_penalty,
+                        early_stopping=early_stopping,
+                        do_sample=do_sample,
+                        top_k=top_k,
+                        top_p=top_p,
+                        pad_token_id=getattr(self.tokenizer, "pad_token_id", None),
+                        eos_token_id=getattr(self.tokenizer, "eos_token_id", None),
+                        streamer=streamer
+                    )
+
+                outputs = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)
+                results.extend(outputs)
+
+            if stream:
+                thread = Thread(target=_generate)
+                thread.start()
+            else:
+                _generate()
+
+        if stream:        
+            async def _stream_generator():
+                async for result in AsyncStreamer(streamer, loop):
+                    context.register_source("result", result)
+                    yield (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result
+
+            return _stream_generator()
+        else:
+            result = results if len(results) > 1 else results[0]
+            context.register_source("result", result)
+
+            return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result
 
 @register_model_task_service(ModelTaskType.SUMMARIZATION)
 class SummarizationTaskService(ModelTaskService):
@@ -80,8 +107,8 @@ class SummarizationTaskService(ModelTaskService):
         self.tokenizer = None
         self.device = None
 
-    async def _run(self, action: ModelActionConfig, context: ComponentActionContext) -> Any:
-        return await SummarizationTaskAction(action, self.model, self.tokenizer, self.device).run(context)
+    async def _run(self, action: ModelActionConfig, context: ComponentActionContext, loop: asyncio.AbstractEventLoop) -> Any:
+        return await SummarizationTaskAction(action, self.model, self.tokenizer, self.device).run(context, loop)
 
     def _get_model_class(self) -> Type[PreTrainedModel]:
         return AutoModelForSeq2SeqLM

{model_compose-0.3.5 → model_compose-0.3.6}/src/mindor/core/component/services/model/tasks/text_classification.py

@@ -8,7 +8,7 @@ from transformers import AutoModelForSequenceClassification, AutoTokenizer, PreT
 from transformers.modeling_outputs import SequenceClassifierOutput
 import torch.nn.functional as F
 from torch import Tensor
-import torch
+import torch, asyncio
 
 class TextClassificationTaskAction:
     def __init__(self, config: TextClassificationModelActionConfig, model: PreTrainedModel, tokenizer: PreTrainedTokenizer, device: torch.device):
@@ -80,7 +80,7 @@ class TextClassificationTaskService(ModelTaskService):
         self.tokenizer = None
         self.device = None
 
-    async def _run(self, action: ModelActionConfig, context: ComponentActionContext) -> Any:
+    async def _run(self, action: ModelActionConfig, context: ComponentActionContext, loop: asyncio.AbstractEventLoop) -> Any:
         return await TextClassificationTaskAction(action, self.model, self.tokenizer, self.device).run(context, self.config.labels)
 
     def _get_model_class(self) -> Type[PreTrainedModel]:

{model_compose-0.3.5 → model_compose-0.3.6}/src/mindor/core/component/services/model/tasks/text_embedding.py

@@ -7,7 +7,7 @@ from ..base import ComponentActionContext
 from transformers import AutoModel, AutoTokenizer, PreTrainedModel, PreTrainedTokenizer
 from transformers.modeling_outputs import BaseModelOutput
 from torch import Tensor
-import torch
+import torch, asyncio
 
 class TextEmbeddingTaskAction:
     def __init__(self, config: TextEmbeddingModelActionConfig, model: PreTrainedModel, tokenizer: PreTrainedTokenizer, device: torch.device):
@@ -94,7 +94,7 @@ class TextEmbeddingTaskService(ModelTaskService):
         self.tokenizer = None
         self.device = None
 
-    async def _run(self, action: ModelActionConfig, context: ComponentActionContext) -> Any:
+    async def _run(self, action: ModelActionConfig, context: ComponentActionContext, loop: asyncio.AbstractEventLoop) -> Any:
         return await TextEmbeddingTaskAction(action, self.model, self.tokenizer, self.device).run(context)
 
     def _get_model_class(self) -> Type[PreTrainedModel]:

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

@@ -1,12 +1,14 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.component import ModelComponentConfig
 from mindor.dsl.schema.action import ModelActionConfig, TextGenerationModelActionConfig
+from mindor.core.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
+from transformers import AutoModelForCausalLM, AutoTokenizer, PreTrainedModel, PreTrainedTokenizer, GenerationMixin, TextIteratorStreamer
+from threading import Thread
 from torch import Tensor
-import torch
+import torch, asyncio
 
 class TextGenerationTaskAction:
     def __init__(self, config: TextGenerationModelActionConfig, model: Union[PreTrainedModel, GenerationMixin], tokenizer: PreTrainedTokenizer, device: torch.device):
@@ -15,7 +17,7 @@ class TextGenerationTaskAction:
         self.tokenizer: PreTrainedTokenizer = tokenizer
         self.device: torch.device = device
 
-    async def run(self, context: ComponentActionContext) -> Any:
+    async def run(self, context: ComponentActionContext, loop: asyncio.AbstractEventLoop) -> Any:
         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)
@@ -24,33 +26,54 @@ class TextGenerationTaskAction:
         top_k                = await context.render_variable(self.config.params.top_k)
         top_p                = await context.render_variable(self.config.params.top_p)
         batch_size           = await context.render_variable(self.config.params.batch_size)
+        stream               = await context.render_variable(self.config.stream)
 
         prompts: List[str] = [ prompt ] if isinstance(prompt, str) else prompt
         results = []
 
+        if stream and (batch_size != 1 or len(prompts) != 1):
+            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
         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)
             inputs = { k: v.to(self.device) for k, v in inputs.items() }
 
-            with torch.no_grad():
-                outputs = self.model.generate(
-                    **inputs,
-                    max_new_tokens=max_output_length,
-                    num_return_sequences=num_return_sequences,
-                    temperature=temperature,
-                    top_k=top_k,
-                    top_p=top_p,
-                    do_sample=True
-                )
-
-            outputs = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)
-            results.extend(outputs)
-
-        result = results if len(results) > 1 else results[0] 
-        context.register_source("result", result)
-
-        return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result
+            def _generate():
+                with torch.no_grad():
+                    outputs = self.model.generate(
+                        **inputs,
+                        max_new_tokens=max_output_length,
+                        num_return_sequences=num_return_sequences,
+                        temperature=temperature,
+                        do_sample=True,
+                        top_k=top_k,
+                        top_p=top_p,
+                        streamer=streamer
+                    )
+
+                outputs = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)
+                results.extend(outputs)
+
+            if stream:
+                thread = Thread(target=_generate)
+                thread.start()
+            else:
+                _generate()
+
+        if stream:        
+            async def _stream_generator():
+                async for result in AsyncStreamer(streamer, loop):
+                    context.register_source("result", result)
+                    yield (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result
+
+            return _stream_generator()
+        else:
+            result = results if len(results) > 1 else results[0] 
+            context.register_source("result", result)
+
+            return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result
 
 @register_model_task_service(ModelTaskType.TEXT_GENERATION)
 class TextGenerationTaskService(ModelTaskService):
@@ -76,8 +99,8 @@ class TextGenerationTaskService(ModelTaskService):
         self.tokenizer = None
         self.device = None
 
-    async def _run(self, action: ModelActionConfig, context: ComponentActionContext) -> Any:
-        return await TextGenerationTaskAction(action, self.model, self.tokenizer, self.device).run(context)
+    async def _run(self, action: ModelActionConfig, context: ComponentActionContext, loop: asyncio.AbstractEventLoop) -> Any:
+        return await TextGenerationTaskAction(action, self.model, self.tokenizer, self.device).run(context, loop)
 
     def _get_model_class(self) -> Type[PreTrainedModel]:
         return AutoModelForCausalLM

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

@@ -1,12 +1,14 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.component import ModelComponentConfig
 from mindor.dsl.schema.action import ModelActionConfig, TranslationModelActionConfig
+from mindor.core.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
+from transformers import AutoModelForSeq2SeqLM, AutoTokenizer, PreTrainedModel, PreTrainedTokenizer, GenerationMixin, TextIteratorStreamer
+from threading import Thread
 from torch import Tensor
-import torch
+import torch, asyncio
 
 class TranslationTaskAction:
     def __init__(self, config: TranslationModelActionConfig, model: Union[PreTrainedModel, GenerationMixin], tokenizer: PreTrainedTokenizer, device: torch.device):
@@ -15,43 +17,71 @@ class TranslationTaskAction:
         self.tokenizer: PreTrainedTokenizer = tokenizer
         self.device: torch.device = device
 
-    async def run(self, context: ComponentActionContext) -> Any:
+    async def run(self, context: ComponentActionContext, loop: asyncio.AbstractEventLoop) -> Any:
         text: Union[str, List[str]] = await context.render_variable(self.config.text)
 
         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)
+        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)
+        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
         batch_size        = await context.render_variable(self.config.params.batch_size)
+        stream            = await context.render_variable(self.config.stream)
 
         texts: List[str] = [ text ] if isinstance(text, str) else text
         results = []
 
+        if stream and (batch_size != 1 or len(texts) != 1):
+            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
         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)
             inputs = { k: v.to(self.device) for k, v in inputs.items() }
             
-            with torch.no_grad():
-                outputs = self.model.generate(
-                    **inputs,
-                    max_length=max_output_length,
-                    min_length=min_output_length,
-                    num_beams=num_beams,
-                    length_penalty=length_penalty,
-                    do_sample=False,
-                    pad_token_id=getattr(self.tokenizer, "pad_token_id", None),
-                    eos_token_id=getattr(self.tokenizer, "eos_token_id", None)
-                )
-
-            outputs = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)
-            results.extend(outputs)
-        
-        result = results if len(results) > 1 else results[0]
-        context.register_source("result", result)
-
-        return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result
+            def _generate():
+                with torch.no_grad():
+                    outputs = self.model.generate(
+                        **inputs,
+                        max_length=max_output_length,
+                        min_length=min_output_length,
+                        num_beams=num_beams,
+                        length_penalty=length_penalty,
+                        early_stopping=early_stopping,
+                        do_sample=do_sample,
+                        top_k=top_k,
+                        top_p=top_p,
+                        pad_token_id=getattr(self.tokenizer, "pad_token_id", None),
+                        eos_token_id=getattr(self.tokenizer, "eos_token_id", None),
+                        streamer=streamer
+                    )
+
+                outputs = self.tokenizer.batch_decode(outputs, skip_special_tokens=True)
+                results.extend(outputs)
+
+            if stream:
+                thread = Thread(target=_generate)
+                thread.start()
+            else:
+                _generate()
+
+        if stream:        
+            async def _stream_generator():
+                async for result in AsyncStreamer(streamer, loop):
+                    context.register_source("result", result)
+                    yield (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result
+
+            return _stream_generator()
+        else:
+            result = results if len(results) > 1 else results[0]
+            context.register_source("result", result)
+
+            return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result
 
 @register_model_task_service(ModelTaskType.TRANSLATION)
 class TranslationTaskService(ModelTaskService):
@@ -77,8 +107,8 @@ class TranslationTaskService(ModelTaskService):
         self.tokenizer = None
         self.device = None
 
-    async def _run(self, action: ModelActionConfig, context: ComponentActionContext) -> Any:
-        return await TranslationTaskAction(action, self.model, self.tokenizer, self.device).run(context)
+    async def _run(self, action: ModelActionConfig, context: ComponentActionContext, loop: asyncio.AbstractEventLoop) -> Any:
+        return await TranslationTaskAction(action, self.model, self.tokenizer, self.device).run(context, loop)
 
     def _get_model_class(self) -> Type[PreTrainedModel]:
         return AutoModelForSeq2SeqLM

{model_compose-0.3.5 → model_compose-0.3.6}/src/mindor/core/controller/services/http_server.py

@@ -1,4 +1,5 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, AsyncIterator, Any
+from types import AsyncGeneratorType
 from typing_extensions import Self
 from pydantic import BaseModel
 from mindor.dsl.schema.controller import HttpServerControllerConfig
@@ -15,7 +16,7 @@ from fastapi import FastAPI, APIRouter, Request, Body, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import Response, JSONResponse, StreamingResponse
 from starlette.background import BackgroundTask
-import uvicorn
+import uvicorn, json
 
 class WorkflowTaskRequestBody(BaseModel):
     workflow_id: Optional[str] = None
@@ -80,6 +81,9 @@ class HttpServerController(ControllerService):
             if body.output_only and not body.wait_for_completion:
                 raise HTTPException(status_code=400, detail="output_only requires wait_for_completion=true.")
             
+            if not body.output_only and isinstance(state.output, (StreamResource, AsyncGeneratorType)):
+                raise HTTPException(status_code=400, detail="Streaming output is only allowed when output_only=true.")
+
             if body.output_only:
                 return self._render_task_output(state)
             
@@ -95,6 +99,9 @@ class HttpServerController(ControllerService):
             if not state:
                 raise HTTPException(status_code=404, detail="Task not found.")
             
+            if not output_only and isinstance(state.output, (StreamResource, AsyncGeneratorType)):
+                raise HTTPException(status_code=400, detail="Streaming output is only allowed when output_only=true.")
+
             if output_only:
                 return self._render_task_output(state)
 
@@ -138,13 +145,44 @@ class HttpServerController(ControllerService):
         if state.status == TaskStatus.FAILED:
             raise HTTPException(status_code=500, detail=str(state.error))
 
+        if isinstance(state.output, AsyncGeneratorType):
+            return self._render_async_generator(state.output)
+        
         if isinstance(state.output, HttpEventStreamResource):
             return self._render_event_stream_resource(state.output)
 
         if isinstance(state.output, StreamResource):
             return self._render_stream_resource(state.output)
-        
+
         return JSONResponse(content=state.output)
+    
+    def _render_async_generator(self, generator: AsyncGeneratorType) -> Response:
+        async def _event_generator() -> AsyncIterator[bytes]:
+            async for chunk in generator:
+                if not isinstance(chunk, str):
+                    chunk = json.dumps()
+                yield b"data: " + chunk.encode("utf-8") + b"\n\n"
+
+        return StreamingResponse(
+            _event_generator(),
+            media_type="text/event-stream",
+            headers={ "Cache-Control": "no-cache" }
+        )
+
+    def _render_event_stream_resource(self, resource: HttpEventStreamResource) -> Response:
+        async def _event_generator() -> AsyncIterator[bytes]:
+            async for chunk in resource:
+                yield b"data: " + chunk + b"\n\n"
+
+        async def _close_stream():
+            await resource.close()
+
+        return StreamingResponse(
+            _event_generator(),
+            media_type="text/event-stream",
+            headers={ "Cache-Control": "no-cache" },
+            background=BackgroundTask(_close_stream)
+        )
 
     def _render_stream_resource(self, resource: StreamResource) -> Response:
         async def _close_stream():
@@ -156,7 +194,7 @@ class HttpServerController(ControllerService):
             headers=self._build_stream_resource_headers(resource), 
             background=BackgroundTask(_close_stream)
         )
-    
+
     def _build_stream_resource_headers(self, resource: StreamResource) -> Dict[str, str]:
         headers: Dict[str, str] = { "Cache-Control": "no-cache" }
 
@@ -165,18 +203,3 @@ class HttpServerController(ControllerService):
             headers["Content-Disposition"] = f'attachment; filename="{filename}"'
 
         return headers
-
-    def _render_event_stream_resource(self, resource: HttpEventStreamResource) -> Response:
-        async def _event_generator() -> AsyncIterator[bytes]:
-            async for chunk in resource:
-                yield b"data: " + chunk + b"\n\n"
-
-        async def _close_stream():
-            await resource.close()
-
-        return StreamingResponse(
-            _event_generator(),
-            media_type="text/event-stream",
-            headers={ "Cache-Control": "no-cache" },
-            background=BackgroundTask(_close_stream)
-        )

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

@@ -194,7 +194,7 @@ class GradioWebUIBuilder:
 
     async def _convert_output_value(self, value: Any, type: WorkflowVariableType, subtype: Optional[str], format: Optional[WorkflowVariableFormat], internal: bool) -> Any:
         if format == WorkflowVariableFormat.SSE_JSON:
-            return await self._resolve_json_field_from_value(value, subtype, format)
+            return await self._resolve_json_field_from_bytes(value, subtype, format)
 
         if type in [ WorkflowVariableType.STRING, WorkflowVariableType.TEXT ]:
             return await self._convert_value_to_string(value, subtype, format)
@@ -210,13 +210,16 @@ class GradioWebUIBuilder:
     async def _convert_value_to_string(self, value: Any, subtype: Optional[str], format: Optional[WorkflowVariableFormat]) -> Optional[str]:
         if isinstance(value, (dict, list)):
             return json.dumps(value)
+        
+        if isinstance(value, bytes):
+            return value.decode("utf-8", errors="replace")
 
         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]:
+        return None
+    
+    async def _resolve_json_field_from_bytes(self, value: Any, subtype: Optional[str], format: Optional[WorkflowVariableFormat]) -> Optional[Any]:
         try:
             return self.field_resolver.resolve(json.loads(value), subtype)
         except Exception:

model_compose-0.3.6/src/mindor/core/utils/streamer.py

@@ -0,0 +1,29 @@
+from types import GeneratorType
+from threading import Thread
+import asyncio
+
+class AsyncStreamer:
+    def __init__(self, generator: GeneratorType, loop: asyncio.AbstractEventLoop):
+        self.generator = generator
+        self.loop = loop
+        self._queue = asyncio.Queue()
+        self._end_of_stream = object()
+
+        self._start_stream_watcher()
+
+    def _start_stream_watcher(self):
+        def _run():
+            for chunk in self.generator:
+                asyncio.run_coroutine_threadsafe(self._queue.put(chunk), self.loop)
+            asyncio.run_coroutine_threadsafe(self._queue.put(self._end_of_stream), self.loop)
+
+        Thread(target=_run, daemon=True).start()
+
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self):
+        chunk = await self._queue.get()
+        if chunk is self._end_of_stream:
+            raise StopAsyncIteration
+        return chunk

{model_compose-0.3.5 → model_compose-0.3.6}/src/mindor/core/workflow/workflow.py

@@ -1,4 +1,5 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Any
+from types import GeneratorType
 from mindor.dsl.schema.workflow import WorkflowConfig, JobConfig
 from mindor.dsl.schema.component import ComponentConfig
 from mindor.core.component import ComponentGlobalConfigs
@@ -142,7 +143,8 @@ class WorkflowRunner:
                 del pending_jobs[completed_job_id]
                 del scheduled_job_tasks[completed_job_id]
 
-        logging.info("[task-%s] Workflow '%s' completed in %.2f seconds.", context.task_id, self.id, workflow_time_tracker.elapsed())
+        if not isinstance(output, GeneratorType):
+            logging.info("[task-%s] Workflow '%s' completed in %.2f seconds.", context.task_id, self.id, workflow_time_tracker.elapsed())
 
         return output
 

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

@@ -11,8 +11,8 @@ class CommonModelActionConfig(CommonActionConfig):
     mode: ModelTaskMode = Field(..., description="Mode for model task execution.")
 
 class CommonModelInferenceActionConfig(CommonModelActionConfig):
-    mode: ModelTaskMode = Literal[ModelTaskMode.INFERENCE]
+    mode: ModelTaskMode = Field(default=ModelTaskMode.INFERENCE)
     stream: bool = Field(default=False, description="Whether to enable streaming responses for inference.")
 
 class CommonModelTrainingActionConfig(CommonModelActionConfig):
-    mode: ModelTaskMode = Literal[ModelTaskMode.TRAINING]
+    mode: ModelTaskMode = Field(default=ModelTaskMode.TRAINING)

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

@@ -10,7 +10,9 @@ class SummarizationParamsConfig(BaseModel):
     num_beams: Union[int, str] = Field(default=4, description="Number of beams to use for beam search.")
     length_penalty: Union[float, str] = Field(default=2.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.")
-    do_sample: bool = Field(default=True, description="Whether to use sampling.")
+    do_sample: bool = Field(default=True, description="Whether to use sampling to generate diverse summaries.")
+    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=1.0, 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 SummarizationModelActionConfig(CommonModelInferenceActionConfig):