model-compose 0.4.42__tar.gz → 0.4.43__tar.gz

{model_compose-0.4.42 → model_compose-0.4.43}/PKG-INFO

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

{model_compose-0.4.42 → model_compose-0.4.43}/pyproject.toml

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

{model_compose-0.4.42 → model_compose-0.4.43}/src/mindor/core/component/services/__init__.py

@@ -16,4 +16,5 @@ from .agent import *
 from .video_converter import *
 from .video_scene_detector import *
 from .audio_extractor import *
+from .audio_converter import *
 from .key_value_store import *

model_compose-0.4.43/src/mindor/core/component/services/audio_converter/__init__.py

@@ -0,0 +1 @@
+from .audio_converter import *

model_compose-0.4.43/src/mindor/core/component/services/audio_converter/audio_converter.py

@@ -0,0 +1,45 @@
+from typing import Optional, List, Any
+from mindor.dsl.schema.component import AudioConverterComponentConfig, AudioConverterDriver
+from mindor.dsl.schema.action import ActionConfig, AudioConverterActionConfig
+from ...base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
+from ...context import ComponentActionContext
+from .base import AudioConverterService, AudioConverterServiceRegistry
+
+class AudioConverterAction:
+    def __init__(self, config: AudioConverterActionConfig):
+        self.config: AudioConverterActionConfig = config
+
+    async def run(self, context: ComponentActionContext, service: AudioConverterService) -> Any:
+        return await service.run(self.config, context)
+
+@register_component(ComponentType.AUDIO_CONVERTER)
+class AudioConverterComponent(ComponentService):
+    def __init__(
+        self,
+        id: str,
+        config: AudioConverterComponentConfig,
+        global_configs: ComponentGlobalConfigs,
+        daemon: bool
+    ):
+        super().__init__(id, config, global_configs, daemon)
+        self.service: AudioConverterService = self._create_service(self.config.driver)
+
+    def _create_service(self, driver: AudioConverterDriver) -> AudioConverterService:
+        try:
+            if not AudioConverterServiceRegistry:
+                from . import drivers
+            return AudioConverterServiceRegistry[driver](self.id, self.config, self.daemon)
+        except KeyError:
+            raise ValueError(f"Unsupported audio converter driver: {driver}")
+
+    def _get_setup_requirements(self) -> Optional[List[str]]:
+        return self.service.get_setup_requirements()
+
+    async def _serve(self) -> None:
+        await self.service.start()
+
+    async def _shutdown(self) -> None:
+        await self.service.stop()
+
+    async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
+        return await AudioConverterAction(action).run(context, self.service)

model_compose-0.4.43/src/mindor/core/component/services/audio_converter/base.py

@@ -0,0 +1,30 @@
+from typing import Type, Optional, Dict, List, Any
+from abc import abstractmethod
+from mindor.dsl.schema.component import AudioConverterComponentConfig, AudioConverterDriver
+from mindor.dsl.schema.action import AudioConverterActionConfig
+from mindor.core.foundation import AsyncService
+from ...context import ComponentActionContext
+
+class AudioConverterService(AsyncService):
+    def __init__(self, id: str, config: AudioConverterComponentConfig, daemon: bool):
+        super().__init__(daemon)
+        self.id: str = id
+        self.config: AudioConverterComponentConfig = config
+
+    def get_setup_requirements(self) -> Optional[List[str]]:
+        return None
+
+    async def run(self, action: AudioConverterActionConfig, context: ComponentActionContext) -> Any:
+        return await self._run(action, context)
+
+    @abstractmethod
+    async def _run(self, action: AudioConverterActionConfig, context: ComponentActionContext) -> Any:
+        pass
+
+def register_audio_converter_service(driver: AudioConverterDriver):
+    def decorator(cls: Type[AudioConverterService]) -> Type[AudioConverterService]:
+        AudioConverterServiceRegistry[driver] = cls
+        return cls
+    return decorator
+
+AudioConverterServiceRegistry: Dict[AudioConverterDriver, Type[AudioConverterService]] = {}

model_compose-0.4.43/src/mindor/core/component/services/audio_converter/drivers/common.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from typing import Optional, Any
+from mindor.dsl.schema.action import AudioConverterActionConfig, AudioSourceConfig
+from ..base import ComponentActionContext
+
+class AudioSource:
+    def __init__(self, path: Optional[str], data: Any, format: Optional[str], sample_rate: Optional[int], channels: Optional[int]):
+        self.path        = path
+        self.data        = data
+        self.format      = format
+        self.sample_rate = sample_rate
+        self.channels    = channels
+
+class AudioConverterAction:
+    def __init__(self, config: AudioConverterActionConfig):
+        self.config: AudioConverterActionConfig = config
+
+    async def _render_source(self, context: ComponentActionContext) -> AudioSource:
+        source = self.config.source
+        if isinstance(source, AudioSourceConfig):
+            path        = await context.render_variable(source.path) if source.path else None
+            data        = await context.render_variable(source.data) if source.data else None
+            format      = await context.render_variable(source.format) if source.format else None
+            sample_rate = await context.render_variable(source.sample_rate) if isinstance(source.sample_rate, str) else source.sample_rate
+            channels    = await context.render_variable(source.channels) if isinstance(source.channels, str) else source.channels
+        else:
+            path        = await context.render_variable(source)
+            data        = None
+            format      = None
+            sample_rate = None
+            channels    = None
+        return AudioSource(path, data, format, sample_rate, channels)

model_compose-0.4.43/src/mindor/core/component/services/audio_converter/drivers/ffmpeg.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+from typing import Optional, Union, Any
+from mindor.dsl.schema.component import AudioConverterComponentConfig
+from mindor.dsl.schema.action import AudioConverterActionConfig
+from mindor.core.logger import logging
+from ..base import AudioConverterService, AudioConverterDriver, register_audio_converter_service
+from ..base import ComponentActionContext
+from .common import AudioConverterAction, AudioSource
+import asyncio
+import tempfile
+import os
+
+_FORMAT_CODEC_MAP: dict[str, str] = {
+    "mp3":  "libmp3lame",
+    "wav":  "pcm_s16le",
+    "flac": "flac",
+    "aac":  "aac",
+    "m4a":  "aac",
+    "opus": "libopus",
+    "ogg":  "libvorbis",
+}
+
+class FFmpegAudioConverterAction(AudioConverterAction):
+    async def run(self, context: ComponentActionContext) -> Any:
+        source      = await self._render_source(context)
+        format      = await context.render_variable(self.config.format) if self.config.format else "wav"
+        codec       = await context.render_variable(self.config.codec) if self.config.codec else None
+        bitrate     = await context.render_variable(self.config.bitrate) if self.config.bitrate else None
+        sample_rate = await context.render_variable(self.config.sample_rate) if isinstance(self.config.sample_rate, str) else self.config.sample_rate
+        channels    = await context.render_variable(self.config.channels) if isinstance(self.config.channels, str) else self.config.channels
+
+        output_path = await self._convert(source, format, codec, bitrate, sample_rate, channels)
+        result = {
+            "path": output_path,
+            "format": format
+        }
+        context.register_source("result", result)
+
+        return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result
+
+    async def _convert(
+        self,
+        source: AudioSource,
+        format: str,
+        codec: Optional[str],
+        bitrate: Optional[str],
+        sample_rate: Optional[Union[int, str]],
+        channels: Optional[Union[int, str]],
+    ) -> str:
+        output_path = os.path.join(tempfile.gettempdir(), f"audio_converter_{os.getpid()}_{id(self)}.{format}")
+
+        command = [ "ffmpeg", "-hide_banner" ]
+
+        if source.format:
+            command.extend([ "-f", source.format ])
+        if source.sample_rate:
+            command.extend([ "-ar", str(source.sample_rate) ])
+        if source.channels:
+            command.extend([ "-ac", str(source.channels) ])
+
+        is_pipe = source.data is not None
+        command.extend([ "-i", "pipe:0" if is_pipe else source.path ])
+
+        resolved_codec = codec or _FORMAT_CODEC_MAP.get(format)
+        if resolved_codec:
+            command.extend([ "-c:a", resolved_codec ])
+        if bitrate:
+            command.extend([ "-b:a", bitrate ])
+        if sample_rate:
+            command.extend([ "-ar", str(sample_rate) ])
+        if channels:
+            command.extend([ "-ac", str(channels) ])
+
+        command.extend([ "-y", output_path ])
+
+        logging.info(f"Converting '{'pipe:0' if is_pipe else source.path}' to '{format}' format")
+
+        process = await asyncio.create_subprocess_exec(
+            *command,
+            stdin=asyncio.subprocess.PIPE if is_pipe else None,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+
+        raw = bytes(source.data) if isinstance(source.data, (bytes, bytearray)) else None
+        _, stderr = await process.communicate(input=raw)
+
+        if process.returncode != 0:
+            error_output = stderr.decode("utf-8", errors="replace")
+            raise RuntimeError(f"ffmpeg audio conversion failed (exit code {process.returncode}): {error_output}")
+
+        logging.info(f"Audio conversion completed: '{output_path}'")
+
+        return output_path
+
+@register_audio_converter_service(AudioConverterDriver.FFMPEG)
+class FFmpegAudioConverterService(AudioConverterService):
+    def __init__(self, id: str, config: AudioConverterComponentConfig, daemon: bool):
+        super().__init__(id, config, daemon)
+
+    async def _run(self, action: AudioConverterActionConfig, context: ComponentActionContext) -> Any:
+        return await FFmpegAudioConverterAction(action).run(context)

{model_compose-0.4.42 → model_compose-0.4.43}/src/mindor/core/component/services/video_converter/base.py

@@ -1,5 +1,5 @@
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Any
-from abc import ABC, abstractmethod
+from typing import Type, Optional, Dict, List, Any
+from abc import abstractmethod
 from mindor.dsl.schema.component import VideoConverterComponentConfig, VideoConverterDriver
 from mindor.dsl.schema.action import VideoConverterActionConfig
 from mindor.core.foundation import AsyncService

model_compose-0.4.43/src/mindor/core/component/services/video_converter/drivers/__init__.py

@@ -0,0 +1 @@
+from .ffmpeg import *

model_compose-0.4.43/src/mindor/core/component/services/video_converter/drivers/common.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from typing import Optional, Any
+from mindor.dsl.schema.action import VideoConverterActionConfig, VideoSourceConfig
+from ..base import ComponentActionContext
+
+class VideoSource:
+    def __init__(self, path: Optional[str], data: Any, format: Optional[str], resolution: Optional[str], fps: Optional[str], pixel_format: Optional[str]):
+        self.path         = path
+        self.data         = data
+        self.format       = format
+        self.resolution   = resolution
+        self.fps          = fps
+        self.pixel_format = pixel_format
+
+class VideoConverterAction:
+    def __init__(self, config: VideoConverterActionConfig):
+        self.config: VideoConverterActionConfig = config
+
+    async def _render_source(self, context: ComponentActionContext) -> VideoSource:
+        source = self.config.source
+        if isinstance(source, VideoSourceConfig):
+            path         = await context.render_variable(source.path) if source.path else None
+            data         = await context.render_variable(source.data) if source.data else None
+            format       = await context.render_variable(source.format) if source.format else None
+            resolution   = await context.render_variable(source.resolution) if source.resolution else None
+            fps          = await context.render_variable(source.fps) if source.fps else None
+            pixel_format = await context.render_variable(source.pixel_format) if source.pixel_format else None
+        else:
+            path         = await context.render_variable(source)
+            data         = None
+            format       = None
+            resolution   = None
+            fps          = None
+            pixel_format = None
+        return VideoSource(path, data, format, resolution, fps, pixel_format)

{model_compose-0.4.42 → model_compose-0.4.43}/src/mindor/core/component/services/video_converter/drivers/ffmpeg.py

@@ -6,16 +6,14 @@ from mindor.dsl.schema.action import VideoConverterActionConfig
 from mindor.core.logger import logging
 from ..base import VideoConverterService, VideoConverterDriver, register_video_converter_service
 from ..base import ComponentActionContext
+from .common import VideoConverterAction, VideoSource
 import asyncio
 import tempfile
 import os
 
-class FFmpegVideoConverterAction:
-    def __init__(self, config: VideoConverterActionConfig):
-        self.config: VideoConverterActionConfig = config
-
+class FFmpegVideoConverterAction(VideoConverterAction):
     async def run(self, context: ComponentActionContext) -> Any:
-        video       = await context.render_file(self.config.video)
+        source      = await self._render_source(context)
         format      = await context.render_variable(self.config.format) if self.config.format else "mp4"
         codec       = await context.render_variable(self.config.codec) if self.config.codec else None
         audio_codec = await context.render_variable(self.config.audio_codec) if self.config.audio_codec else None
@@ -23,7 +21,7 @@ class FFmpegVideoConverterAction:
         resolution  = await context.render_variable(self.config.resolution) if self.config.resolution else None
         fps         = await context.render_variable(self.config.fps) if self.config.fps else None
 
-        output_path = await self._convert(video, format, codec, audio_codec, bitrate, resolution, fps)
+        output_path = await self._convert(source, format, codec, audio_codec, bitrate, resolution, fps)
         result = {
             "path": output_path,
             "format": format
@@ -34,7 +32,7 @@ class FFmpegVideoConverterAction:
 
     async def _convert(
         self,
-        video: str,
+        source: VideoSource,
         format: str,
         codec: Optional[str],
         audio_codec: Optional[str],
@@ -43,8 +41,20 @@ class FFmpegVideoConverterAction:
         fps: Optional[str]
     ) -> str:
         output_path = os.path.join(tempfile.gettempdir(), f"video_converter_{os.getpid()}_{id(self)}.{format}")
+        is_pipe = source.data is not None
+
+        command = [ "ffmpeg", "-hide_banner" ]
+
+        if source.format:
+            command.extend([ "-f", source.format ])
+        if source.resolution:
+            command.extend([ "-s", source.resolution ])
+        if source.fps:
+            command.extend([ "-r", source.fps ])
+        if source.pixel_format:
+            command.extend([ "-pix_fmt", source.pixel_format ])
 
-        command = [ "ffmpeg", "-hide_banner", "-i", video ]
+        command.extend([ "-i", "pipe:0" if is_pipe else source.path ])
 
         if codec:
             command.extend([ "-c:v", codec ])
@@ -59,15 +69,17 @@ class FFmpegVideoConverterAction:
 
         command.extend([ "-movflags", "+faststart", "-y", output_path ])
 
-        logging.info(f"Converting '{video}' to '{format}' format")
+        logging.info(f"Converting '{'pipe:0' if is_pipe else source.path}' to '{format}' format")
 
         process = await asyncio.create_subprocess_exec(
             *command,
+            stdin=asyncio.subprocess.PIPE if is_pipe else None,
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE
         )
 
-        _, stderr = await process.communicate()
+        raw = bytes(source.data) if isinstance(source.data, (bytes, bytearray)) else None
+        _, stderr = await process.communicate(input=raw)
 
         if process.returncode != 0:
             error_output = stderr.decode("utf-8", errors="replace")

{model_compose-0.4.42 → model_compose-0.4.43}/src/mindor/core/component/services/websocket_server.py

@@ -3,33 +3,13 @@ from mindor.dsl.schema.component import WebSocketServerComponentConfig
 from mindor.dsl.schema.action import ActionConfig, WebSocketServerActionConfig
 from mindor.dsl.schema.action.impl.websocket_server import WebSocketReceiveFormat
 from mindor.core.utils.websocket_client import WebSocketClient, WebSocketConnection
-from mindor.core.utils.streaming import BytesStreamResource, StreamResource
+from mindor.core.utils.streaming import BytesStreamResource
 from mindor.core.utils.shell import run_command_streaming
 from mindor.core.utils.time import parse_duration
 from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
 from ..context import ComponentActionContext
-from collections.abc import AsyncIterator
 import asyncio, json
 
-class WebSocketBinaryStreamResource(StreamResource):
-    def __init__(self, connection: WebSocketConnection, owned: bool):
-        super().__init__("application/octet-stream", None)
-        self._connection = connection
-        self._owned = owned
-
-    async def close(self) -> None:
-        if self._owned and self._connection:
-            await self._connection.close()
-            self._connection = None
-
-    async def _iterate_stream(self) -> AsyncIterator[bytes]:
-        try:
-            async for frame in self._connection.receive_frames():
-                if isinstance(frame, bytes):
-                    yield frame
-        finally:
-            await self.close()
-
 class WebSocketConnector:
     def __init__(self, client: WebSocketClient, params: Optional[Dict[str, Any]] = None):
         self._client: WebSocketClient = client
@@ -87,11 +67,12 @@ class WebSocketServerAction:
                 await self._send(connection, message)
 
             if context.contains_variable_reference("response[]", self.config.output):
-                if format == WebSocketReceiveFormat.BINARY:
-                    return WebSocketBinaryStreamResource(connection, owned)
-                return self._receive_stream(connection, format, context, connection if owned else None)
+                return self._receive_stream(connection, format, context, owned)
 
-            response = await self._receive(connection, format, collect)
+            if collect:
+                response = await self._receive_collect(connection, format)
+            else:
+                response = await self._receive_single(connection, format)
         except:
             if owned:
                 await connection.close()
@@ -114,11 +95,6 @@ class WebSocketServerAction:
         else:
             await connection.websocket.send(str(message))
 
-    async def _receive(self, connection: WebSocketConnection, format: WebSocketReceiveFormat, collect: bool) -> Any:
-        if collect:
-            return await self._receive_collect(connection, format)
-        return await self._receive_single(connection, format)
-
     async def _receive_collect(self, connection: WebSocketConnection, format: WebSocketReceiveFormat) -> Any:
         if format == WebSocketReceiveFormat.BINARY:
             buffer = bytearray()
@@ -145,7 +121,7 @@ class WebSocketServerAction:
                 return frame
         return None
 
-    async def _receive_stream(self, connection: WebSocketConnection, format: WebSocketReceiveFormat, context: ComponentActionContext, owned_connection: Optional[WebSocketConnection] = None):
+    async def _receive_stream(self, connection: WebSocketConnection, format: WebSocketReceiveFormat, context: ComponentActionContext, owned: bool = False):
         try:
             async for frame in connection.receive_frames():
                 frame = self._decode_frame(frame, format)
@@ -153,8 +129,8 @@ class WebSocketServerAction:
                     context.register_source("response[]", frame)
                     yield await context.render_variable(self.config.output, ignore_files=True)
         finally:
-            if owned_connection:
-                await owned_connection.close()
+            if owned:
+                await connection.close()
 
     def _decode_frame(self, frame: Any, format: WebSocketReceiveFormat) -> Any:
         if format == WebSocketReceiveFormat.BINARY and isinstance(frame, bytes):

{model_compose-0.4.42 → model_compose-0.4.43}/src/mindor/core/controller/webui/gradio/builder.py

@@ -5,11 +5,12 @@ from typing import Type, Union, Literal, Optional, Dict, List, Callable, Any
 from mindor.dsl.schema.workflow import WorkflowVariableConfig, WorkflowVariableGroupConfig, WorkflowVariableType, WorkflowVariableFormat
 from mindor.core.workflow.schema import WorkflowSchema
 
-from mindor.core.utils.streaming import StreamResource, Base64StreamResource
-from mindor.core.utils.streaming import save_stream_to_temporary_file, BytesStreamResource
+from mindor.core.utils.streaming import StreamResource, BytesStreamResource, Base64StreamResource
+from mindor.core.utils.streaming import save_stream_to_temporary_file
 from mindor.core.utils.http_request import create_upload_file
 from mindor.core.utils.http_client import create_stream_with_url
 from mindor.core.utils.image import load_image_from_stream
+from mindor.core.utils.audio import pcm_to_wav
 from mindor.core.utils.resolvers import FieldResolver
 from PIL import Image as PILImage
 from collections.abc import AsyncIterator
@@ -232,30 +233,23 @@ class GradioWebUIBuilder:
     async def _build_input_value(self, arguments: List[Any], variables: List[WorkflowVariableConfig]) -> Any:
         if len(variables) == 1 and not variables[0].name:
             value, variable = arguments[0], variables[0]
-            return await self._convert_input_value(value, variable.type, variable.subtype, variable.format, variable.internal)
+            return await self._convert_input_value(value, variable)
 
         input: Dict[str, Any] = {}
         for value, variable in zip(arguments, variables):
-            input[variable.name] = await self._convert_input_value(value, variable.type, variable.subtype, variable.format, variable.internal)
+            input[variable.name] = await self._convert_input_value(value, variable)
         return input
 
-    async def _convert_input_value(
-        self,
-        value: Any,
-        type: WorkflowVariableType,
-        subtype: Optional[str],
-        format: Optional[WorkflowVariableFormat],
-        internal: bool
-    ) -> Any:
-        if type in [ WorkflowVariableType.IMAGE, WorkflowVariableType.AUDIO, WorkflowVariableType.VIDEO, WorkflowVariableType.FILE ] and (not internal or not format):
-            if internal and format and format != "path":
-                value = await self._save_value_to_temporary_file(value, subtype, format)
-            return create_upload_file(value, type.value, subtype) if value is not None else None
+    async def _convert_input_value(self, value: Any, variable: WorkflowVariableConfig) -> Any:
+        if variable.type in [ WorkflowVariableType.IMAGE, WorkflowVariableType.AUDIO, WorkflowVariableType.VIDEO, WorkflowVariableType.FILE ] and (not variable.internal or not variable.format):
+            if variable.internal and variable.format and variable.format != "path":
+                value = await self._save_value_to_temporary_file(value, variable.subtype, variable.attrs, variable.format)
+            return create_upload_file(value, variable.type.value, variable.subtype) if value is not None else None
 
-        if type == WorkflowVariableType.INTEGER:
+        if variable.type == WorkflowVariableType.INTEGER:
             return int(value) if value != "" else None
 
-        if type == WorkflowVariableType.LIST:
+        if variable.type == WorkflowVariableType.LIST:
             return str(value).split(",")
 
         return value if value != "" else None
@@ -371,7 +365,7 @@ class GradioWebUIBuilder:
                     flattened.extend(await self._flatten_output_value(value, variable.variables))
             else:
                 value = self._resolve_variable_output(output, variable)
-                flattened.append(await self._convert_output_value(value, variable.type, variable.subtype, variable.format, variable.internal))
+                flattened.append(await self._convert_output_value(value, variable))
         return flattened
 
     def _resolve_variable_output(
@@ -397,25 +391,18 @@ class GradioWebUIBuilder:
 
         return None if variable.name else output
 
-    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 self._resolve_json_field_from_bytes(value, subtype, format)
+    async def _convert_output_value(self, value: Any, variable: WorkflowVariableConfig) -> Any:
+        if variable.format == WorkflowVariableFormat.SSE_JSON:
+            return self._resolve_json_field_from_bytes(value, variable.subtype, variable.format)
 
-        if type in [ WorkflowVariableType.STRING, WorkflowVariableType.TEXT ]:
-            return self._convert_value_to_string(value, subtype, format)
+        if variable.type in [ WorkflowVariableType.STRING, WorkflowVariableType.TEXT ]:
+            return self._convert_value_to_string(value, variable.subtype, variable.format)
 
-        if type == WorkflowVariableType.IMAGE:
-            return await self._load_image_from_value(value, subtype, format)
+        if variable.type == WorkflowVariableType.IMAGE:
+            return await self._load_image_from_value(value, variable.subtype, variable.format)
 
-        if type in [ WorkflowVariableType.AUDIO, WorkflowVariableType.VIDEO ]:
-            return await self._save_value_to_temporary_file(value, subtype, format)
+        if variable.type in [ WorkflowVariableType.AUDIO, WorkflowVariableType.VIDEO ]:
+            return await self._save_value_to_temporary_file(value, variable.subtype, variable.attrs, variable.format)
 
         return value
 
@@ -449,7 +436,7 @@ class GradioWebUIBuilder:
 
         return None
 
-    async def _save_value_to_temporary_file(self, value: Any, subtype: Optional[str], format: Optional[WorkflowVariableFormat]) -> Optional[str]:
+    async def _save_value_to_temporary_file(self, value: Any, subtype: Optional[str], attrs: Optional[Dict[str, str]], format: Optional[WorkflowVariableFormat]) -> Optional[str]:
         if format == WorkflowVariableFormat.BASE64 and isinstance(value, str):
             return await save_stream_to_temporary_file(Base64StreamResource(value), subtype)
 
@@ -468,12 +455,18 @@ class GradioWebUIBuilder:
         return None
 
     async def _collect_stream_to_file(self, stream, variable: WorkflowVariableConfig) -> Optional[str]:
+        data = await self._collect_stream_to_bytes(stream)
+
+        if variable.type == WorkflowVariableType.AUDIO and variable.subtype == "pcm":
+            return await save_stream_to_temporary_file(BytesStreamResource(pcm_to_wav(data, variable.attrs)), "wav")
+
+        return await save_stream_to_temporary_file(BytesStreamResource(data), variable.subtype)
+
+    async def _collect_stream_to_bytes(self, stream) -> Optional[bytes]:
         buffer = bytearray()
         async for chunk in stream:
             if isinstance(chunk, bytes):
                 buffer.extend(chunk)
             elif isinstance(chunk, (bytearray, memoryview)):
                 buffer.extend(bytes(chunk))
-        if not buffer:
-            return None
-        return await save_stream_to_temporary_file(BytesStreamResource(bytes(buffer)), variable.subtype)
+        return bytes(buffer)

model_compose-0.4.43/src/mindor/core/utils/audio.py

@@ -0,0 +1,12 @@
+from typing import Optional, Dict
+import wave, io
+
+def pcm_to_wav(data: bytes, attrs: Optional[Dict[str, str]] = None) -> bytes:
+    attrs = attrs or {}
+    buffer = io.BytesIO()
+    with wave.open(buffer, "wb") as wav:
+        wav.setnchannels(int(attrs.get("channels", 1)))
+        wav.setsampwidth(int(attrs.get("bit_depth", 16)) // 8)
+        wav.setframerate(int(attrs.get("sample_rate", 44100)))
+        wav.writeframes(data)
+    return buffer.getvalue()