model-compose 0.4.37__tar.gz → 0.4.38__tar.gz

{model_compose-0.4.37 → model_compose-0.4.38}/PKG-INFO

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

{model_compose-0.4.37 → model_compose-0.4.38}/pyproject.toml

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

{model_compose-0.4.37 → model_compose-0.4.38}/src/mindor/core/component/base.py

@@ -140,7 +140,10 @@ class ComponentService(AsyncService):
         from mindor.core.runtime.docker import DockerRuntimeManager
         self._docker_manager = DockerRuntimeManager(self.config.runtime, verbose=False)
         if not await self._docker_manager.exists_image():
-            await self._docker_manager.pull_image()
+            if self.config.runtime.build:
+                await self._docker_manager.build_image()
+            else:
+                await self._docker_manager.pull_image()
         if await self._docker_manager.exists_container():
             await self._docker_manager.remove_container(force=True)
         await self._docker_manager.start_container(detach=True)

{model_compose-0.4.37 → model_compose-0.4.38}/src/mindor/core/component/services/__init__.py

@@ -1,5 +1,6 @@
 from .http_server import *
 from .http_client import *
+from .websocket_server import *
 from .mcp_server import *
 from .mcp_client import *
 from .model import *

{model_compose-0.4.37 → model_compose-0.4.38}/src/mindor/core/component/services/key_value_store/drivers/redis.py

@@ -3,10 +3,7 @@ from typing import TYPE_CHECKING
 
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Any
 from mindor.dsl.schema.component import RedisKeyValueStoreComponentConfig
-from mindor.dsl.schema.action import (
-    KeyValueStoreActionConfig, RedisKeyValueStoreActionConfig, KeyValueStoreActionMethod
-)
-from mindor.core.logger import logging
+from mindor.dsl.schema.action import KeyValueStoreActionConfig, RedisKeyValueStoreActionConfig, KeyValueStoreActionMethod
 from ..base import KeyValueStoreService, KeyValueStoreDriver, register_kv_store_service
 from ..base import ComponentActionContext
 import json
@@ -118,7 +115,4 @@ class RedisKeyValueStoreService(KeyValueStoreService):
         scheme = "rediss" if self.config.secure else "redis"
         url = f"{scheme}://{self.config.host}:{self.config.port}/{self.config.database}"
 
-        return Redis.from_url(
-            url,
-            password=self.config.password
-        )
+        return Redis.from_url(url, password=self.config.password)

model_compose-0.4.38/src/mindor/core/component/services/websocket_server.py

@@ -0,0 +1,203 @@
+from typing import Any, Optional, Dict, Tuple
+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
+from mindor.core.utils.shell import run_command_streaming
+from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
+from ..context import ComponentActionContext
+import asyncio, json
+
+class WebSocketConnector:
+    def __init__(self, client: WebSocketClient, params: Optional[Dict[str, Any]] = None):
+        self._client: WebSocketClient = client
+        self._params: Optional[Dict[str, Any]] = params
+        self._connection: Optional[WebSocketConnection] = None
+
+    async def connect(
+        self,
+        path: Optional[str] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        receive_timeout: Optional[float] = None
+    ) -> Tuple[WebSocketConnection, bool]:
+        if path or params or headers:  # new owned connection per request
+            connection = await self._client.connect(
+                path=path,
+                params={ **(self._params or {}), **(params or {}) } or None,
+                headers=headers,
+                receive_timeout=receive_timeout
+            )
+            return connection, True
+        if not self._connection or not self._connection.is_connected():
+            self._connection = await self._client.connect()
+        return self._connection, False
+
+    async def close(self) -> None:
+        if self._connection:
+            await self._connection.close()
+            self._connection = None
+
+class WebSocketServerAction:
+    def __init__(self, config: WebSocketServerActionConfig):
+        self.config: WebSocketServerActionConfig = config
+
+    async def run(self, context: ComponentActionContext, client: WebSocketConnector) -> Any:
+        path    = await context.render_variable(self.config.path)
+        params  = await context.render_variable(self.config.params)
+        headers = await context.render_variable(self.config.headers)
+        message = await context.render_variable(self.config.message)
+
+        format  = await context.render_variable(self.config.receive.format)
+        collect = await context.render_variable(self.config.receive.collect)
+        timeout = await context.render_variable(self.config.receive.timeout)
+
+        connection, owned = await client.connect(
+            path=path,
+            params=params or None,
+            headers=headers or None,
+            receive_timeout=timeout
+        )
+
+        try:
+            if message:
+                await self._send(connection, message)
+
+            if context.contains_variable_reference("response[]", self.config.output):
+                return self._receive_stream(connection, format, context)
+
+            response = await self._receive(connection, format, collect)
+        except:
+            if owned:
+                await connection.close()
+            raise
+
+        if owned:
+            await connection.close()
+
+        if format == WebSocketReceiveFormat.BINARY and isinstance(response, (bytes, bytearray)):
+            response = BytesStreamResource(bytes(response), "application/octet-stream")
+
+        context.register_source("response", response)
+        return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else response
+
+    async def _send(self, connection: WebSocketConnection, message: Any) -> None:
+        if isinstance(message, (dict, list)):
+            await connection.send_message(message)
+        elif isinstance(message, bytes):
+            await connection.send_bytes(message)
+        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()
+            async for frame in connection.receive_frames():
+                if isinstance(frame, bytes):
+                    buffer.extend(frame)
+            return bytes(buffer)
+        items = []
+        async for frame in connection.receive_frames():
+            if isinstance(frame, str):
+                if format == WebSocketReceiveFormat.JSON:
+                    try:
+                        items.append(json.loads(frame))
+                    except json.JSONDecodeError:
+                        pass
+                else:
+                    items.append(frame)
+        return items
+
+    async def _receive_single(self, connection: WebSocketConnection, format: WebSocketReceiveFormat) -> Any:
+        async for frame in connection.receive_frames():
+            frame = self._decode_frame(frame, format)
+            if frame is not None:
+                return frame
+        return None
+
+    async def _receive_stream(self, connection: WebSocketConnection, format: WebSocketReceiveFormat, context: ComponentActionContext):
+        async for frame in connection.receive_frames():
+            frame = self._decode_frame(frame, format)
+            if frame is not None:
+                context.register_source("response[]", frame)
+                yield await context.render_variable(self.config.output, ignore_files=True)
+
+    def _decode_frame(self, frame: Any, format: WebSocketReceiveFormat) -> Any:
+        if format == WebSocketReceiveFormat.BINARY and isinstance(frame, bytes):
+            return frame
+        if format == WebSocketReceiveFormat.JSON and isinstance(frame, str):
+            try:
+                return json.loads(frame)
+            except json.JSONDecodeError:
+                return None
+        if format == WebSocketReceiveFormat.TEXT and isinstance(frame, str):
+            return frame
+        return None
+
+@register_component(ComponentType.WEBSOCKET_SERVER)
+class WebSocketServerComponent(ComponentService):
+    def __init__(
+        self,
+        id: str,
+        config: WebSocketServerComponentConfig,
+        global_configs: ComponentGlobalConfigs,
+        daemon: bool
+    ):
+        super().__init__(id, config, global_configs, daemon)
+
+        self.client: Optional[WebSocketConnector] = None
+
+    async def _setup(self) -> None:
+        if self.config.manage.scripts.install:
+            for command in self.config.manage.scripts.install:
+                await run_command_streaming(command, self.config.manage.working_dir, self.config.manage.env)
+
+        if self.config.manage.scripts.build:
+            for command in self.config.manage.scripts.build:
+                await run_command_streaming(command, self.config.manage.working_dir, self.config.manage.env)
+
+    async def _teardown(self):
+        if self.config.manage.scripts.clean:
+            for command in self.config.manage.scripts.clean:
+                await run_command_streaming(command, self.config.manage.working_dir, self.config.manage.env)
+
+    async def _start(self) -> None:
+        base_url = f"ws://localhost:{self.config.port}" + (self.config.base_path or "")
+        self.client = WebSocketConnector(
+            WebSocketClient(
+                base_url=base_url,
+                ping_interval=self.config.ping_interval,
+                ping_timeout=self.config.ping_timeout,
+                additional_headers=self.config.headers or None
+            ),
+            params=self.config.params or None
+        )
+        await super()._start()
+
+    async def _stop(self) -> None:
+        await super()._stop()
+        if self.client:
+            await self.client.close()
+            self.client = None
+
+    async def _serve(self) -> None:
+        if self.config.manage.scripts.start:
+            await run_command_streaming(self.config.manage.scripts.start, self.config.manage.working_dir, self.config.manage.env)
+
+    async def _is_ready(self) -> bool:
+        try:
+            _, writer = await asyncio.open_connection("localhost", self.config.port)
+            writer.close()
+            await writer.wait_closed()
+            return True
+        except (ConnectionRefusedError, OSError):
+            return False
+
+    async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
+        return await WebSocketServerAction(action).run(context, self.client)

{model_compose-0.4.37 → model_compose-0.4.38}/src/mindor/core/controller/webui/gradio/builder.py

@@ -12,6 +12,7 @@ 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.resolvers import FieldResolver
 from PIL import Image as PILImage
+from collections.abc import AsyncIterator
 import gradio as gr
 import json, re
 
@@ -106,16 +107,20 @@ class GradioWebUIBuilder:
                 # Clear interrupt panel for normal results
                 clear_interrupt = self._clear_interrupt_updates()
 
-                if len(workflow.output) == 1 and self._is_streaming_variable(workflow.output[0]):
-                    buffer = "" if workflow.output[0].type == WorkflowVariableType.TEXT else []
-                    async for chunk in output:
-                        chunk = await self._flatten_output_value(chunk, [ workflow.output[0]])
-                        if workflow.output[0].type == WorkflowVariableType.TEXT:
-                            buffer += chunk[0] or ""
-                        else:
-                            buffer.append(chunk[0])
-                        yield [ _run_button_running(), *clear_interrupt, buffer ]
-                    yield [ _run_button_ready(), *clear_interrupt, buffer ]
+                if isinstance(output, AsyncIterator) and len(workflow.output) == 1 and isinstance(workflow.output[0], WorkflowVariableConfig):
+                    if self._is_streaming_variable(workflow.output[0]):
+                        buffer = "" if workflow.output[0].type == WorkflowVariableType.TEXT else []
+                        async for chunk in output:
+                            chunk = await self._flatten_output_value(chunk, [ workflow.output[0]])
+                            if workflow.output[0].type == WorkflowVariableType.TEXT:
+                                buffer += chunk[0] or ""
+                            else:
+                                buffer.append(chunk[0])
+                            yield [ _run_button_running(), *clear_interrupt, buffer ]
+                        yield [ _run_button_ready(), *clear_interrupt, buffer ]
+                    else:
+                        result = await self._collect_stream_to_file(output, workflow.output[0])
+                        yield [ _run_button_ready(), *clear_interrupt, result ]
                 else:
                     if workflow.output:
                         output = await self._flatten_output_value(output, workflow.output)
@@ -181,10 +186,8 @@ class GradioWebUIBuilder:
 
         return section
 
-    def _is_streaming_variable(self, variable: Union[WorkflowVariableConfig, WorkflowVariableGroupConfig]) -> bool:
-        if isinstance(variable, WorkflowVariableConfig):
-            return variable.format in [ WorkflowVariableFormat.SSE_JSON, WorkflowVariableFormat.SSE_TEXT ]
-        return False
+    def _is_streaming_variable(self, variable: WorkflowVariableConfig) -> bool:
+        return variable.format in [ WorkflowVariableFormat.SSE_JSON, WorkflowVariableFormat.SSE_TEXT ]
 
     def _build_input_component(self, variable: WorkflowVariableConfig) -> gr.Component:
         label = (variable.name or "") + (" *" if variable.required else "") + (f" (default: {variable.default})" if variable.default is not None else "")
@@ -463,3 +466,14 @@ class GradioWebUIBuilder:
             return await save_stream_to_temporary_file(BytesStreamResource(value), subtype)
 
         return None
+
+    async def _collect_stream_to_file(self, stream, variable: WorkflowVariableConfig) -> Optional[str]:
+        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)

{model_compose-0.4.37 → model_compose-0.4.38}/src/mindor/core/utils/cdp_client.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from typing import Optional, Dict, List, Any, Callable
-from .websocket_client import WebSocketClient
+from .websocket_client import WebSocketClient, WebSocketConnection
 import aiohttp, asyncio, itertools
 
 class CdpClient:
@@ -19,15 +19,14 @@ class CdpClient:
     def __init__(self, ws_url: str, timeout: float = 30.0):
         self.ws_url: str = ws_url
         self.timeout: float = timeout
-        self._ws: Optional[WebSocketClient] = None
+        self._websocket: Optional[WebSocketConnection] = None
         self._id_counter = itertools.count(1)
         self._pending: Dict[int, asyncio.Future] = {}
         self._event_listeners: Dict[str, List[Callable]] = {}
         self._reader_task: Optional[asyncio.Task] = None
 
     async def connect(self) -> None:
-        self._ws = WebSocketClient(self.ws_url)
-        await self._ws.connect()
+        self._websocket = await WebSocketClient(self.ws_url).connect()
         self._reader_task = asyncio.create_task(self._reader_loop())
 
     async def close(self) -> None:
@@ -38,9 +37,9 @@ class CdpClient:
             except asyncio.CancelledError:
                 pass
             self._reader_task = None
-        if self._ws:
-            await self._ws.close()
-            self._ws = None
+        if self._websocket:
+            await self._websocket.close()
+            self._websocket = None
 
     async def send_command(self, method: str, params: Optional[Dict] = None) -> Dict[str, Any]:
         cmd_id = next(self._id_counter)
@@ -49,7 +48,7 @@ class CdpClient:
         self._pending[cmd_id] = future
 
         message = { "id": cmd_id, "method": method, "params": params or {} }
-        await self._ws.send_message(message)
+        await self._websocket.send_message(message)
 
         try:
             return await asyncio.wait_for(future, timeout=self.timeout)
@@ -68,7 +67,7 @@ class CdpClient:
     async def _reader_loop(self) -> None:
         try:
             while True:
-                message = await self._ws.receive_message()
+                message = await self._websocket.receive_message()
                 if "id" in message:
                     future = self._pending.pop(message["id"], None)
                     if future and not future.done():
@@ -105,6 +104,7 @@ class CdpClient:
                 targets = await response.json(content_type=None)
 
         page_targets = [ t for t in targets if t.get("type") == "page" ]
+
         if not page_targets:
             raise ConnectionError(f"No 'page' target found at {host}:{port}.")
         if target_index >= len(page_targets):
@@ -116,4 +116,5 @@ class CdpClient:
         ws_url = page_targets[target_index]["webSocketDebuggerUrl"]
         instance = cls(ws_url, timeout=timeout)
         await instance.connect()
+
         return instance

model_compose-0.4.38/src/mindor/core/utils/websocket_client.py

@@ -0,0 +1,95 @@
+from typing import Optional, Union, Dict, Any
+from collections.abc import AsyncIterator
+from websockets.asyncio.client import ClientConnection
+from urllib.parse import urlencode
+import websockets, asyncio, json
+
+class WebSocketConnection:
+    def __init__(self, websocket: ClientConnection, receive_timeout: Optional[float] = None):
+        self.websocket: ClientConnection = websocket
+        self.receive_timeout: Optional[float] = receive_timeout
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+
+    async def close(self) -> None:
+        if self.websocket:
+            await self.websocket.close()
+            self.websocket = None
+
+    async def send_message(self, message: Any) -> None:
+        await self.websocket.send(json.dumps(message))
+
+    async def send_bytes(self, data: bytes) -> None:
+        await self.websocket.send(data)
+
+    async def receive_message(self) -> Dict[str, Any]:
+        if self.receive_timeout:
+            message = await asyncio.wait_for(
+                self.websocket.recv(),
+                timeout=self.receive_timeout
+            )
+        else:
+            message = await self.websocket.recv()
+
+        return json.loads(message)
+
+    async def receive_frame(self) -> Union[str, bytes]:
+        if self.receive_timeout:
+            return await asyncio.wait_for(
+                self.websocket.recv(),
+                timeout=self.receive_timeout
+            )
+        return await self.websocket.recv()
+
+    async def receive_frames(self) -> AsyncIterator[Union[str, bytes]]:
+        try:
+            while True:
+                yield await self.receive_frame()
+        except (websockets.ConnectionClosed, websockets.ConnectionClosedOK):
+            return
+        except asyncio.TimeoutError:
+            return
+
+    def is_connected(self) -> bool:
+        return bool(self.websocket)
+
+class WebSocketClient:
+    def __init__(
+        self,
+        base_url: str,
+        ping_interval: Optional[float] = None,
+        ping_timeout: Optional[float] = None,
+        additional_headers: Optional[Dict[str, str]] = None
+    ):
+        self.base_url: str = base_url
+        self.ping_interval: Optional[float] = ping_interval
+        self.ping_timeout: Optional[float] = ping_timeout
+        self.additional_headers: Optional[Dict[str, str]] = additional_headers
+
+    async def connect(
+        self,
+        path: Optional[str] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        receive_timeout: Optional[float] = None
+    ) -> WebSocketConnection:
+        url = self.base_url
+        if path:
+            url += path if path.startswith("/") else f"/{path}"
+        if params:
+            filtered = { k: v for k, v in params.items() if v is not None }
+            if filtered:
+                url += "?" + urlencode(filtered)
+
+        ws = await websockets.connect(
+            url,
+            ping_interval=self.ping_interval,
+            ping_timeout=self.ping_timeout,
+            additional_headers={ **(self.additional_headers or {}), **(headers or {}) } or None
+        )
+
+        return WebSocketConnection(ws, receive_timeout)

{model_compose-0.4.37 → model_compose-0.4.38}/src/mindor/dsl/schema/action/action.py

@@ -5,6 +5,7 @@ from .impl import *
 ActionConfig = Union[ 
     HttpServerActionConfig,
     HttpClientActionConfig,
+    WebSocketServerActionConfig,
     McpServerActionConfig,
     McpClientActionConfig,
     ModelActionConfig,

{model_compose-0.4.37 → model_compose-0.4.38}/src/mindor/dsl/schema/action/impl/__init__.py

@@ -1,6 +1,7 @@
 from .common import *
 from .http_server import *
 from .http_client import *
+from .websocket_server import *
 from .mcp_server import *
 from .mcp_client import *
 from .model import *

model_compose-0.4.38/src/mindor/dsl/schema/action/impl/websocket_server.py

@@ -0,0 +1,21 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from enum import Enum
+from pydantic import BaseModel, Field
+from .common import CommonActionConfig
+
+class WebSocketReceiveFormat(str, Enum):
+    JSON   = "json"
+    TEXT   = "text"
+    BINARY = "binary"
+
+class WebSocketReceiveConfig(BaseModel):
+    format: WebSocketReceiveFormat = Field(default=WebSocketReceiveFormat.JSON, description="Expected format of received WebSocket frames.")
+    collect: bool = Field(default=False, description="When true, collect all received frames into a single response. For binary, concatenates bytes. For JSON/text, collects into a list.")
+    timeout: Optional[float] = Field(default=None, description="Receive timeout in seconds per frame.")
+
+class WebSocketServerActionConfig(CommonActionConfig):
+    path: Optional[str] = Field(default=None, description="WebSocket endpoint path. Overrides the component-level base_path.")
+    params: Dict[str, Any] = Field(default_factory=dict, description="Query parameters to include in the WebSocket URL.")
+    headers: Dict[str, str] = Field(default_factory=dict, description="Additional headers for the WebSocket handshake.")
+    message: Optional[Any] = Field(default=None, description="Message to send after connecting. Dict/List will be JSON-encoded, bytes sent as binary, str sent as text.")
+    receive: WebSocketReceiveConfig = Field(default_factory=WebSocketReceiveConfig, description="Configuration for receiving WebSocket messages.")

{model_compose-0.4.37 → model_compose-0.4.38}/src/mindor/dsl/schema/component/component.py

@@ -6,6 +6,7 @@ ComponentConfig = Annotated[
     Union[
         HttpServerComponentConfig,
         HttpClientComponentConfig,
+        WebSocketServerComponentConfig,
         McpServerComponentConfig,
         McpClientComponentConfig,
         ModelComponentConfig,

{model_compose-0.4.37 → model_compose-0.4.38}/src/mindor/dsl/schema/component/impl/__init__.py

@@ -1,6 +1,7 @@
 from .common import *
 from .http_server import *
 from .http_client import *
+from .websocket_server import *
 from .mcp_server import *
 from .mcp_client import *
 from .model import *

{model_compose-0.4.37 → model_compose-0.4.38}/src/mindor/dsl/schema/component/impl/types.py

@@ -3,6 +3,7 @@ from enum import Enum
 class ComponentType(str, Enum):
     HTTP_SERVER          = "http-server"
     HTTP_CLIENT          = "http-client"
+    WEBSOCKET_SERVER     = "websocket-server"
     MCP_SERVER           = "mcp-server"
     MCP_CLIENT           = "mcp-client"
     MODEL                = "model"

model_compose-0.4.38/src/mindor/dsl/schema/component/impl/websocket_server.py

@@ -0,0 +1,53 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+from mindor.dsl.schema.action import WebSocketServerActionConfig
+from .common import ComponentType, CommonComponentConfig
+
+class WebSocketServerManageScripts(BaseModel):
+    install: Optional[List[List[str]]] = Field(default=None, description="One or more scripts to install dependencies.")
+    build: Optional[List[List[str]]] = Field(default=None, description="One or more scripts to build the server.")
+    clean: Optional[List[List[str]]] = Field(default=None, description="One or more scripts to clean the server environment.")
+    start: Optional[List[str]] = Field(default=None, description="Script to start the server.")
+
+    @model_validator(mode="before")
+    def normalize_scripts(cls, values):
+        for key in [ "install", "build", "clean" ]:
+            script = values.get(key)
+            if script and isinstance(script, list) and all(isinstance(token, str) for token in script):
+                values[key] = [ script ]
+        return values
+
+class WebSocketServerManageConfig(BaseModel):
+    scripts: WebSocketServerManageScripts = Field(..., description="Shell scripts used to install, build, clean, and start the server.")
+    working_dir: Optional[str] = Field(default=None, description="Working directory for the scripts.")
+    env: Dict[str, str] = Field(default_factory=dict, description="Environment variables to set when executing the scripts.")
+
+    @model_validator(mode="before")
+    def inflate_single_script(cls, values: Dict[str, Any]):
+        if "scripts" not in values:
+            values["scripts"] = { key: values.pop(key) for key in WebSocketServerManageScripts.model_fields.keys() if key in values }
+        return values
+
+class WebSocketServerComponentConfig(CommonComponentConfig):
+    type: Literal[ComponentType.WEBSOCKET_SERVER]
+    manage: WebSocketServerManageConfig = Field(default_factory=WebSocketServerManageConfig, description="Configuration used to manage the WebSocket server lifecycle.")
+    port: int = Field(default=3000, ge=1, le=65535, description="Port on which the WebSocket server will listen for incoming connections.")
+    base_path: Optional[str] = Field(default=None, description="Base path to prefix all WebSocket routes exposed by this component.")
+    params: Dict[str, Any] = Field(default_factory=dict, description="Default query parameters to include in all WebSocket connection URLs.")
+    headers: Dict[str, str] = Field(default_factory=dict, description="Headers to be included in all outgoing WebSocket handshake requests.")
+    ping_interval: Optional[float] = Field(default=None, description="WebSocket ping interval in seconds.")
+    ping_timeout: Optional[float] = Field(default=None, description="WebSocket ping timeout in seconds.")
+    actions: List[WebSocketServerActionConfig] = Field(default_factory=list)
+
+    @model_validator(mode="before")
+    def migrate_path_to_base_path(cls, values: Dict[str, Any]):
+        if "path" in values and "base_path" not in values:
+            values["base_path"] = values.pop("path")
+        return values
+
+    @model_validator(mode="before")
+    def inflate_single_script(cls, values: Dict[str, Any]):
+        if "manage" not in values:
+            values["manage"] = { key: values.pop(key) for key in WebSocketServerManageScripts.model_fields.keys() if key in values }
+        return values

{model_compose-0.4.37 → model_compose-0.4.38}/src/model_compose.egg-info/PKG-INFO

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

{model_compose-0.4.37 → model_compose-0.4.38}/src/model_compose.egg-info/SOURCES.txt

@@ -25,6 +25,7 @@ src/mindor/core/component/services/shell.py
 src/mindor/core/component/services/text_splitter.py
 src/mindor/core/component/services/web_browser.py
 src/mindor/core/component/services/web_scraper.py
+src/mindor/core/component/services/websocket_server.py
 src/mindor/core/component/services/workflow.py
 src/mindor/core/component/services/audio_extractor/__init__.py
 src/mindor/core/component/services/audio_extractor/audio_extractor.py
@@ -254,6 +255,7 @@ src/mindor/dsl/schema/action/impl/video_converter.py
 src/mindor/dsl/schema/action/impl/video_scene_detector.py
 src/mindor/dsl/schema/action/impl/web_browser.py
 src/mindor/dsl/schema/action/impl/web_scraper.py
+src/mindor/dsl/schema/action/impl/websocket_server.py
 src/mindor/dsl/schema/action/impl/workflow.py
 src/mindor/dsl/schema/action/impl/datasets/__init__.py
 src/mindor/dsl/schema/action/impl/datasets/common.py
@@ -336,6 +338,7 @@ src/mindor/dsl/schema/component/impl/video_converter.py
 src/mindor/dsl/schema/component/impl/video_scene_detector.py
 src/mindor/dsl/schema/component/impl/web_browser.py
 src/mindor/dsl/schema/component/impl/web_scraper.py
+src/mindor/dsl/schema/component/impl/websocket_server.py
 src/mindor/dsl/schema/component/impl/workflow.py
 src/mindor/dsl/schema/component/impl/datasets/__init__.py
 src/mindor/dsl/schema/component/impl/datasets/datasets.py