model-compose 0.4.44__tar.gz → 0.4.45__tar.gz

{model_compose-0.4.44 → model_compose-0.4.45}/PKG-INFO

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

{model_compose-0.4.44 → model_compose-0.4.45}/pyproject.toml

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

{model_compose-0.4.44 → model_compose-0.4.45}/src/mindor/core/component/services/__init__.py

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

{model_compose-0.4.44 → model_compose-0.4.45}/src/mindor/core/component/services/http_client.py

@@ -1,12 +1,12 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
-from collections.abc import AsyncIterator
 from abc import ABC, abstractmethod
 from mindor.dsl.schema.component import HttpClientComponentConfig
 from mindor.dsl.schema.action import ActionConfig, HttpClientActionConfig, HttpClientCompletionType, HttpClientCompletionConfig
 from mindor.dsl.schema.transport.http import HttpStreamFormat
 from mindor.core.listener import HttpCallbackListener
-from mindor.core.utils.http_client import HttpClient, HttpEventStreamResource
+from mindor.core.utils.http_client import HttpClient
 from mindor.core.utils.http_status import is_status_code_matched
+from mindor.core.utils.streaming import StreamResource
 from mindor.core.utils.time import parse_duration
 from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
 from ..context import ComponentActionContext
@@ -18,11 +18,11 @@ class HttpClientCompletion(ABC):
         self.config: HttpClientCompletionConfig = config
 
     @abstractmethod
-    async def run(self, context: ComponentActionContext, client: HttpClient) -> Any:
+    async def run(self, context: ComponentActionContext, client: HttpClient, streaming: bool = False) -> Any:
         pass
 
 class HttpClientPollingCompletion(HttpClientCompletion):
-    async def run(self, context: ComponentActionContext, client: HttpClient) -> Any:
+    async def run(self, context: ComponentActionContext, client: HttpClient, streaming: bool = False) -> Any:
         url_or_path = await self._resolve_url_or_path(context)
         method      = await context.render_variable(self.config.method)
         params      = await context.render_variable(self.config.params)
@@ -36,7 +36,7 @@ class HttpClientPollingCompletion(HttpClientCompletion):
         await asyncio.sleep(interval.total_seconds())
 
         while datetime.now(timezone.utc) < deadline:
-            response, status_code = await client.request(url_or_path, method, params, body, headers, raise_on_error=False)
+            response, status_code = await client.request(url_or_path, method, params, body, headers, raise_on_error=False, streaming=streaming)
             context.register_source("result", response)
 
             status = (await context.render_variable(self.config.status)) if self.config.status else None
@@ -62,7 +62,7 @@ class HttpClientPollingCompletion(HttpClientCompletion):
         return await context.render_variable(self.config.endpoint)
 
 class HttpClientCallbackCompletion(HttpClientCompletion):
-    async def run(self, context: ComponentActionContext, client: HttpClient) -> Any:
+    async def run(self, context: ComponentActionContext, client: HttpClient, streaming: bool = False) -> Any:
         callback_id = await context.render_variable(self.config.wait_for)
         future: asyncio.Future = asyncio.get_running_loop().create_future()
         HttpCallbackListener.register_pending_future(callback_id, future)
@@ -95,26 +95,32 @@ class HttpClientAction:
         body        = await context.render_variable(self.config.body)
         headers     = await context.render_variable(self.config.headers)
 
-        response, result = await client.request(url_or_path, method, params, body, headers), None
+        is_streaming = context.contains_variable_reference("response[]", self.config.output)
+        response, result = await client.request(url_or_path, method, params, body, headers, streaming=is_streaming), None
 
-        if isinstance(response, HttpEventStreamResource) and context.contains_variable_reference("response[]", self.config.output):
-            async def _stream_output_generator(stream: HttpEventStreamResource):
+        if isinstance(response, StreamResource) and is_streaming:
+            async def _stream_output_generator(stream: StreamResource):
                 async for chunk in stream:
-                    context.register_source("response[]", self._convert_stream_chunk(chunk))
-                    yield await context.render_variable(self.config.output, ignore_files=True)
+                    context.register_source("response[]", self._convert_stream_chunk(chunk, self.config.stream_format))
+                    chunk = await context.render_variable(self.config.output, ignore_files=True)
+                    if chunk is not None:
+                        yield chunk
 
             return _stream_output_generator(response)
 
         context.register_source("response", response)
 
         if self.completion:
-            result = await self.completion.run(context, client)
+            is_streaming = context.contains_variable_reference("result[]", self.config.output)
+            result = await self.completion.run(context, client, streaming=is_streaming)
 
-            if isinstance(result, HttpEventStreamResource) and context.contains_variable_reference("result[]", self.config.output):
-                async def _stream_output_generator(stream: HttpEventStreamResource):
+            if isinstance(result, StreamResource) and is_streaming:
+                async def _stream_output_generator(stream: StreamResource):
                     async for chunk in stream:
-                        context.register_source("result[]", self._convert_stream_chunk(chunk))
-                        yield await context.render_variable(self.config.output, ignore_files=True)
+                        context.register_source("result[]", self._convert_stream_chunk(chunk, self.config.stream_format))
+                        chunk = await context.render_variable(self.config.output, ignore_files=True)
+                        if chunk is not None:
+                            yield chunk
 
                 return _stream_output_generator(result)
 
@@ -128,14 +134,14 @@ class HttpClientAction:
 
         return await context.render_variable(self.config.endpoint)
 
-    def _convert_stream_chunk(self, chunk: bytes) -> Any:
-        if self.config.stream_format == HttpStreamFormat.JSON:
+    def _convert_stream_chunk(self, chunk: bytes, format: HttpStreamFormat) -> Any:
+        if format == HttpStreamFormat.JSON:
             try:
                 return json.loads(chunk)
             except:
                 return None
 
-        if self.config.stream_format == HttpStreamFormat.TEXT:
+        if format == HttpStreamFormat.TEXT:
             return chunk.decode("utf-8", errors="replace")
 
         return chunk

{model_compose-0.4.44 → model_compose-0.4.45}/src/mindor/core/component/services/http_server.py

@@ -4,8 +4,9 @@ from mindor.dsl.schema.component import HttpServerComponentConfig
 from mindor.dsl.schema.action import ActionConfig, HttpServerActionConfig, HttpServerCompletionType, HttpServerCompletionConfig
 from mindor.dsl.schema.transport.http import HttpStreamFormat
 from mindor.core.listener import HttpCallbackListener
-from mindor.core.utils.http_client import HttpClient, HttpEventStreamResource
+from mindor.core.utils.http_client import HttpClient
 from mindor.core.utils.http_status import is_status_code_matched
+from mindor.core.utils.streaming import StreamResource
 from mindor.core.utils.time import parse_duration
 from mindor.core.utils.shell import run_command_streaming
 from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
@@ -18,11 +19,11 @@ class HttpServerCompletion(ABC):
         self.config: HttpServerCompletionConfig = config
 
     @abstractmethod
-    async def run(self, context: ComponentActionContext, client: HttpClient) -> Any:
+    async def run(self, context: ComponentActionContext, client: HttpClient, streaming: bool = False) -> Any:
         pass
 
 class HttpServerPollingCompletion(HttpServerCompletion):
-    async def run(self, context: ComponentActionContext, client: HttpClient) -> Any:
+    async def run(self, context: ComponentActionContext, client: HttpClient, streaming: bool = False) -> Any:
         path    = await context.render_variable(self.config.path)
         method  = await context.render_variable(self.config.method)
         params  = await context.render_variable(self.config.params)
@@ -36,7 +37,7 @@ class HttpServerPollingCompletion(HttpServerCompletion):
         await asyncio.sleep(interval.total_seconds())
 
         while datetime.now(timezone.utc) < deadline:
-            response, status_code = await client.request(path or "", method, params, body, headers, raise_on_error=False)
+            response, status_code = await client.request(path or "", method, params, body, headers, raise_on_error=False, streaming=streaming)
             context.register_source("result", response)
 
             status = (await context.render_variable(self.config.status)) if self.config.status else None
@@ -56,7 +57,7 @@ class HttpServerPollingCompletion(HttpServerCompletion):
         raise TimeoutError(f"Polling timed out after {timeout}.")
 
 class HttpServerCallbackCompletion(HttpServerCompletion):
-    async def run(self, context: ComponentActionContext, client: HttpClient) -> Any:
+    async def run(self, context: ComponentActionContext, client: HttpClient, streaming: bool = False) -> Any:
         callback_id = await context.render_variable(self.config.wait_for) if self.config.wait_for else "__callback__"
         future: asyncio.Future = asyncio.get_running_loop().create_future()
         HttpCallbackListener.register_pending_future(callback_id, future)
@@ -89,26 +90,32 @@ class HttpServerAction:
         body    = await context.render_variable(self.config.body)
         headers = await context.render_variable(self.config.headers)
 
-        response, result = await client.request(path or "", method, params, body, headers), None
+        is_streaming = context.contains_variable_reference("response[]", self.config.output)
+        response, result = await client.request(path or "", method, params, body, headers, streaming=is_streaming), None
 
-        if isinstance(response, HttpEventStreamResource) and context.contains_variable_reference("response[]", self.config.output):
-            async def _stream_output_generator(stream: HttpEventStreamResource):
+        if isinstance(response, StreamResource) and is_streaming:
+            async def _stream_output_generator(stream: StreamResource):
                 async for chunk in stream:
-                    context.register_source("response[]", self._convert_stream_chunk(chunk))
-                    yield await context.render_variable(self.config.output, ignore_files=True)
+                    context.register_source("response[]", self._convert_stream_chunk(chunk, self.config.stream_format))
+                    chunk = await context.render_variable(self.config.output, ignore_files=True)
+                    if chunk is not None:
+                        yield chunk
 
             return _stream_output_generator(response)
 
         context.register_source("response", response)
 
         if self.completion:
-            result = await self.completion.run(context, client)
+            is_streaming = context.contains_variable_reference("result[]", self.config.output)
+            result = await self.completion.run(context, client, streaming=is_streaming)
 
-            if isinstance(result, HttpEventStreamResource) and context.contains_variable_reference("result[]", self.config.output):
-                async def _stream_output_generator(stream: HttpEventStreamResource):
+            if isinstance(result, StreamResource) and is_streaming:
+                async def _stream_output_generator(stream: StreamResource):
                     async for chunk in stream:
-                        context.register_source("result[]", self._convert_stream_chunk(chunk))
-                        yield await context.render_variable(self.config.output, ignore_files=True)
+                        context.register_source("result[]", self._convert_stream_chunk(chunk, self.config.stream_format))
+                        chunk = await context.render_variable(self.config.output, ignore_files=True)
+                        if chunk is not None:
+                            yield chunk
 
                 return _stream_output_generator(result)
 
@@ -116,14 +123,14 @@ class HttpServerAction:
 
         return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else (result or response)
 
-    def _convert_stream_chunk(self, chunk: bytes) -> Any:
-        if self.config.stream_format == HttpStreamFormat.JSON:
+    def _convert_stream_chunk(self, chunk: bytes, format: HttpStreamFormat) -> Any:
+        if format == HttpStreamFormat.JSON:
             try:
                 return json.loads(chunk)
             except:
                 return None
 
-        if self.config.stream_format == HttpStreamFormat.TEXT:
+        if format == HttpStreamFormat.TEXT:
             return chunk.decode("utf-8", errors="replace")
 
         return chunk

{model_compose-0.4.44 → model_compose-0.4.45}/src/mindor/core/component/services/model/tasks/text_generation/llamacpp.py

@@ -3,7 +3,6 @@ from typing import TYPE_CHECKING
 
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.action import ModelActionConfig, TextGenerationModelActionConfig
-from mindor.core.utils.streamer import AsyncStreamer
 from ...base import ModelTaskType, ModelDriver, register_model_task_service
 from ...base import LlamaCppModelTaskService, ComponentActionContext
 import asyncio

{model_compose-0.4.44 → model_compose-0.4.45}/src/mindor/core/component/services/vector_store/drivers/chroma.py

@@ -3,8 +3,8 @@ 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 VectorStoreComponentConfig
-from mindor.dsl.schema.action import VectorStoreActionConfig, ChromaVectorStoreActionConfig, VectorStoreActionMethod, VectorStoreFilterCondition, VectorStoreFilterOperator
-from mindor.core.utils.streamer import AsyncStreamer
+from mindor.dsl.schema.action import VectorStoreActionConfig, ChromaVectorStoreActionConfig
+from mindor.dsl.schema.action import VectorStoreActionMethod, VectorStoreFilterCondition, VectorStoreFilterOperator
 from mindor.core.utils.time import parse_duration
 from mindor.core.logger import logging
 from ..base import VectorStoreService, VectorStoreDriver, register_vector_store_service

{model_compose-0.4.44 → model_compose-0.4.45}/src/mindor/core/component/services/vector_store/drivers/milvus.py

@@ -3,8 +3,8 @@ from typing import TYPE_CHECKING
 
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.component import VectorStoreComponentConfig
-from mindor.dsl.schema.action import VectorStoreActionConfig, MilvusVectorStoreActionConfig, VectorStoreActionMethod, VectorStoreFilterCondition, VectorStoreFilterOperator
-from mindor.core.utils.streamer import AsyncStreamer
+from mindor.dsl.schema.action import VectorStoreActionConfig, MilvusVectorStoreActionConfig
+from mindor.dsl.schema.action import VectorStoreActionMethod, VectorStoreFilterCondition, VectorStoreFilterOperator
 from mindor.core.utils.time import parse_duration
 from mindor.core.logger import logging
 from ..base import VectorStoreService, VectorStoreDriver, register_vector_store_service

model_compose-0.4.45/src/mindor/core/component/services/websocket_client.py

@@ -0,0 +1,147 @@
+from typing import Any, Optional
+from mindor.dsl.schema.component import WebSocketClientComponentConfig
+from mindor.dsl.schema.action import ActionConfig, WebSocketClientActionConfig
+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.time import parse_duration
+from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
+from ..context import ComponentActionContext
+import json
+
+class WebSocketClientAction:
+    def __init__(self, config: WebSocketClientActionConfig):
+        self.config: WebSocketClientActionConfig = config
+
+    async def run(self, context: ComponentActionContext, client: WebSocketClient) -> 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_str = await context.render_variable(self.config.receive.timeout)
+        timeout = parse_duration(timeout_str).total_seconds() if timeout_str else None
+
+        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):
+                stream = self._receive_stream(connection, format, context, owned)
+
+                return stream
+
+            if collect:
+                response = await self._receive_collect(connection, format)
+            else:
+                response = await self._receive_single(connection, format)
+        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_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, owned: bool = False):
+        try:
+            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)
+        finally:
+            if owned:
+                await connection.close()
+
+    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_CLIENT)
+class WebSocketClientComponent(ComponentService):
+    def __init__(
+        self,
+        id: str,
+        config: WebSocketClientComponentConfig,
+        global_configs: ComponentGlobalConfigs,
+        daemon: bool
+    ):
+        super().__init__(id, config, global_configs, daemon)
+        self.client: Optional[WebSocketClient] = None
+
+    async def _start(self) -> None:
+        self.client = WebSocketClient(
+            base_url=self.config.base_url,
+            ping_interval=parse_duration(self.config.ping_interval).total_seconds() if self.config.ping_interval else None,
+            ping_timeout=parse_duration(self.config.ping_timeout).total_seconds() if self.config.ping_timeout else None,
+            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 _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
+        return await WebSocketClientAction(action).run(context, self.client)

{model_compose-0.4.44 → model_compose-0.4.45}/src/mindor/core/component/services/websocket_server.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional, Dict, Tuple
+from typing import Any, Optional
 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
@@ -10,41 +10,11 @@ from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, regi
 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:
+    async def run(self, context: ComponentActionContext, client: WebSocketClient) -> 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)
@@ -67,7 +37,9 @@ class WebSocketServerAction:
                 await self._send(connection, message)
 
             if context.contains_variable_reference("response[]", self.config.output):
-                return self._receive_stream(connection, format, context, owned)
+                stream = self._receive_stream(connection, format, context, owned)
+
+                return stream
 
             if collect:
                 response = await self._receive_collect(connection, format)
@@ -155,7 +127,7 @@ class WebSocketServerComponent(ComponentService):
     ):
         super().__init__(id, config, global_configs, daemon)
 
-        self.client: Optional[WebSocketConnector] = None
+        self.client: Optional[WebSocketClient] = None
 
     async def _setup(self) -> None:
         if self.config.manage.scripts.install:
@@ -173,13 +145,11 @@ class WebSocketServerComponent(ComponentService):
 
     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=parse_duration(self.config.ping_interval).total_seconds() if self.config.ping_interval else None,
-                ping_timeout=parse_duration(self.config.ping_timeout).total_seconds() if self.config.ping_timeout else None,
-                additional_headers=self.config.headers or None
-            ),
+        self.client = WebSocketClient(
+            base_url=base_url,
+            ping_interval=parse_duration(self.config.ping_interval).total_seconds() if self.config.ping_interval else None,
+            ping_timeout=parse_duration(self.config.ping_timeout).total_seconds() if self.config.ping_timeout else None,
+            additional_headers=self.config.headers or None,
             params=self.config.params or None
         )
         await super()._start()