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

{model_compose-0.3.4/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.4
+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.4 → model_compose-0.3.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.3.4"
+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.4 → model_compose-0.3.6}/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

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

@@ -5,7 +5,7 @@ from mindor.dsl.schema.action import ModelActionConfig
 from mindor.core.services import AsyncService
 from ...context import ComponentActionContext
 from transformers import PreTrainedModel, PreTrainedTokenizer
-import torch
+import torch, asyncio
 
 class ModelTaskService(AsyncService):
     def __init__(self, id: str, config: ModelComponentConfig, daemon: bool):
@@ -15,10 +15,15 @@ class ModelTaskService(AsyncService):
         self.config: ModelComponentConfig = config
 
     async def run(self, action: ModelActionConfig, context: ComponentActionContext) -> Any:
-        return await self._run(action, context)
+        loop: asyncio.AbstractEventLoop = asyncio.get_running_loop()
+
+        async def _run():
+            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.4 → 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.4 → 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.4 → 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.4 → 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.4 → 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.4 → 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.4 → 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.4 → model_compose-0.3.6}/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.4 → model_compose-0.3.6}/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