model-compose 0.0.8__tar.gz → 0.0.9__tar.gz

{model_compose-0.0.8/src/model_compose.egg-info → model_compose-0.0.9}/PKG-INFO

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

{model_compose-0.0.8 → model_compose-0.0.9}/pyproject.toml

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

model_compose-0.0.9/src/mindor/core/component/engine/http_client.py

@@ -0,0 +1,120 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, AsyncIterator, Any
+from mindor.dsl.schema.component import HttpClientComponentConfig
+from mindor.dsl.schema.action import ActionConfig, HttpClientActionConfig, HttpClientCompletionConfig
+from mindor.core.listener import HttpCallbackListener
+from mindor.core.utils.http_client import HttpClient
+from mindor.core.utils.time import parse_duration
+from .base import BaseComponent, ComponentType, ComponentEngineMap
+from .context import ComponentContext
+from datetime import datetime, timezone
+import asyncio
+
+class HttpClientPollingCompletion:
+    def __init__(self, base_url: Optional[str], config: HttpClientCompletionConfig):
+        self.base_url: Optional[str] = base_url
+        self.config: HttpClientCompletionConfig = config
+        self.client: HttpClient = HttpClient()
+
+    async def run(self, context: ComponentContext) -> Any:
+        url     = self._resolve_request_url(context)
+        method  = context.render_template(self.config.method)
+        params  = context.render_template(self.config.params)
+        body    = context.render_template(self.config.body)
+        headers = context.render_template(self.config.headers)
+
+        interval = parse_duration(self.config.interval) if self.config.interval else 5.0
+        timeout  = parse_duration(self.config.timeout) if self.config.timeout else 300
+        deadline = datetime.now(timezone.utc) + timeout
+
+        await asyncio.sleep(interval.total_seconds())
+
+        while datetime.now(timezone.utc) < deadline:
+            response = await self.client.request(url, method, params, body, headers)
+
+            context.register_source("response", response)
+            status = context.render_template(self.config.status) if self.config.status else response["status"]
+
+            success_when = context.render_template(self.config.success_when) if self.config.success_when else "completed"
+            if success_when and status == success_when:
+                return response
+
+            fail_when = context.render_template(self.config.fail_when) if self.config.fail_when else "failed"
+            if fail_when and status == fail_when:
+                raise RuntimeError(f"Polling failed: status='{status}'.")
+
+            await asyncio.sleep(interval.total_seconds())
+
+        raise TimeoutError(f"Polling timed out after {timeout}")
+
+    def _resolve_request_url(self, context: ComponentContext) -> str:
+        if self.base_url and self.config.path:
+            return context.render_template(self.base_url) + context.render_template(self.config.path)
+
+        return context.render_template(self.config.endpoint)
+
+class HttpClientCallbackCompletion:
+    def __init__(self, config: HttpClientCompletionConfig):
+        self.config: HttpClientCompletionConfig = config
+
+    async def run(self, context: ComponentContext) -> Any:
+        callback_id = context.render_template(self.config.wait_for)
+        future: asyncio.Future = asyncio.get_event_loop().create_future()
+        HttpCallbackListener.register_pending_future(callback_id, future)
+
+        return await future
+
+class HttpClientAction:
+    def __init__(self, base_url: Optional[str], config: HttpClientActionConfig):
+        self.base_url: Optional[str] = base_url
+        self.config: HttpClientActionConfig = config
+        self.client: HttpClient = HttpClient()
+
+    async def run(self, context: ComponentContext) -> Any:
+        url     = self._resolve_request_url(context)
+        method  = context.render_template(self.config.method)
+        params  = context.render_template(self.config.params)
+        body    = context.render_template(self.config.body)
+        headers = context.render_template(self.config.headers)
+
+        response = await self.client.request(url, method, params, body, headers)
+
+        if response:
+            context.register_source("response", response)
+
+        if self.config.completion:
+            result = await self._handle_completion(self.config.completion, context)
+
+            if result:
+                context.register_source("result", result)
+
+        return context.render_template(self.config.output) if self.config.output else (result or response)
+
+    def _resolve_request_url(self, context: ComponentContext) -> str:
+        if self.base_url and self.config.path:
+            return context.render_template(self.base_url) + context.render_template(self.config.path)
+
+        return context.render_template(self.config.endpoint)
+
+    async def _handle_completion(self, completion: HttpClientCompletionConfig, context: ComponentContext) -> Any:
+        if completion.type == "polling":
+            return await HttpClientPollingCompletion(self.base_url, completion).run(context)
+        
+        if completion.type == "callback":
+            return await HttpClientCallbackCompletion(completion).run(context)
+
+        return None
+
+class HttpClientComponent(BaseComponent):
+    def __init__(self, id: str, config: HttpClientComponentConfig, env: Dict[str, str], daemon: bool):
+        super().__init__(id, config, env, daemon)
+
+    async def _serve(self) -> None:
+        pass
+
+    async def _shutdown(self) -> None:
+        pass
+
+    async def _run(self, action: ActionConfig, context: ComponentContext) -> Any:
+        return await HttpClientAction(self.config.base_url, action).run(context)
+
+ComponentEngineMap[ComponentType.HTTP_CLIENT] = HttpClientComponent

model_compose-0.0.9/src/mindor/core/gateway/__init__.py

@@ -0,0 +1,2 @@
+from .gateway import *
+from .engine import HttpTunnelGateway

model_compose-0.0.9/src/mindor/core/gateway/engine/__init__.py

@@ -0,0 +1,2 @@
+from .base import *
+from .http_tunnel import *

model_compose-0.0.9/src/mindor/core/gateway/engine/base.py

@@ -0,0 +1,12 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.gateway import GatewayConfig, GatewayType
+from mindor.core.services import AsyncService
+
+class BaseGateway(AsyncService):
+    def __init__(self, config: GatewayConfig, env: Dict[str, str], daemon: bool):
+        super().__init__(daemon)
+
+        self.config: GatewayConfig = config
+        self.env: Dict[str, str] = env
+
+GatewayEngineMap: Dict[GatewayType, Type[BaseGateway]] = {}

model_compose-0.0.9/src/mindor/core/gateway/engine/http_tunnel.py

@@ -0,0 +1,9 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Iterator, Any
+from mindor.dsl.schema.gateway import HttpTunnelGatewayConfig
+from .base import BaseGateway, GatewayType, GatewayEngineMap
+
+class HttpTunnelGateway(BaseGateway):
+    def __init__(self, config: HttpTunnelGatewayConfig, env: Dict[str, str], daemon: bool):
+        super().__init__(config, env, daemon)
+        
+GatewayEngineMap[GatewayType.HTTP_TUNNEL] = HttpTunnelGateway

model_compose-0.0.9/src/mindor/core/gateway/gateway.py

@@ -0,0 +1,9 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.gateway import GatewayConfig
+from .engine import BaseGateway, GatewayEngineMap
+
+def create_gateway(config: GatewayConfig, env: Dict[str, str], daemon: bool) -> BaseGateway:
+    try:
+        return GatewayEngineMap[config.type](config, env, daemon)
+    except KeyError:
+        raise ValueError(f"Unsupported gateway type: {config.type}")

{model_compose-0.0.8 → model_compose-0.0.9}/src/mindor/core/listener/engine/http_callback.py

@@ -14,11 +14,11 @@ _pending_futures: Dict[str, asyncio.Future] = {}
 _pending_futures_lock: Lock = Lock()
 
 class HttpCallbackContext:
-    def __init__(self, body: Optional[Any], query: Optional[Dict[str, str]], bulk: bool, item_at: Optional[str]):
+    def __init__(self, body: Optional[Any], query: Optional[Dict[str, str]], bulk: bool, item: Optional[str]):
         self.body: Optional[Any] = body
         self.query: Optional[Dict[str, str]] = query
         self.bulk: bool = bulk
-        self.item_at: Optional[str] = item_at
+        self.item: Optional[str] = item
         self.renderer: TemplateRenderer = TemplateRenderer(self._resolve_source)
 
     def items(self) -> Iterator["HttpCallbackContext"]:
@@ -29,11 +29,11 @@ class HttpCallbackContext:
         return self.renderer.render(template)
 
     def _items(self) -> List[Any]:
-        item = self.renderer.render(self.item_at) if self.item_at else self.body
+        item = self.renderer.render(self.item) if self.item else self.body
 
         if self.bulk:
             if not isinstance(item, list):
-               raise ValueError("Expected a list because 'bulk' is True, but got a non-list.")
+               raise ValueError("Expected a list because 'bulk' is true, but got a non-list.")
             return item
 
         return [ item ]
@@ -67,16 +67,16 @@ class HttpCallbackListener(BaseListener):
 
     def _make_callback_handler(self, callback: HttpCallbackConfig) -> Callable:
         async def handler(request: Request) -> Response:
-            body, query  = await self._parse_request_content(request), request.query_params
-            context = HttpCallbackContext(body, query, callback.bulk, callback.item_at)
+            body, query = await self._parse_request_content(request), request.query_params
+            context = HttpCallbackContext(body, query, callback.bulk, callback.item)
 
             for item in context.items():
-                action_id = item.render_template(callback.identify_by)
-                future: asyncio.Future = self._get_pending_future(action_id) if isinstance(action_id, str) else None
+                callback_id = item.render_template(callback.identify_by)
+                future: asyncio.Future = self._get_pending_future(callback_id)
 
                 if future:
                     future.set_result(item.render_template(callback.result) if callback.result else item.body)
-                    self._remove_pending_future(action_id)
+                    self._remove_pending_future(callback_id)
 
             return Response()
 

{model_compose-0.0.8 → model_compose-0.0.9}/src/mindor/core/services/async_service.py

@@ -1,4 +1,4 @@
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Any
+from typing import Optional
 from abc import ABC, abstractmethod
 from threading import Thread
 import asyncio

model_compose-0.0.9/src/mindor/core/utils/http_client.py

@@ -0,0 +1,79 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, AsyncIterator, Any
+from .http_headers import parse_options_header, get_header_value
+from .resources import StreamResource
+
+from urllib.parse import urlencode
+import aiohttp, json
+
+class HttpStreamResource(StreamResource):
+    def __init__(self, session: aiohttp.ClientSession, stream: aiohttp.StreamReader, content_type: Optional[str], filename: Optional[str]):
+        super().__init__(content_type, filename)
+
+        self.session: aiohttp.ClientSession = session
+        self.stream: aiohttp.StreamReader = stream
+
+    def get_stream(self):
+        return self.stream
+    
+    async def close(self):
+        await self.session.close()
+
+    async def _iterate_stream(self) -> AsyncIterator[bytes]:
+        _, buffer_size = self.stream.get_read_buffer_limits()
+        chunk_size = buffer_size or 65536
+
+        while not self.stream.at_eof():
+            chunk = await self.stream.read(chunk_size)
+            if not chunk:
+                break
+            yield chunk
+
+class HttpClient:
+    async def request(self, url: str, method: str, params: Optional[Dict[str, Any]], body: Optional[Any], headers: Optional[Dict[str, str]]) -> Any:
+        session = aiohttp.ClientSession()
+        try:
+            response = await session.request(                
+                method,
+                url,
+                params=params,
+                data=self._serialize_request_body(body, headers) if body is not None else None, 
+                headers=headers
+            )
+
+            if response.status >= 400:
+                raise ValueError(f"Request failed with status {response.status}")
+
+            content = await self._parse_response_content(session, response)
+
+            if not isinstance(content, HttpStreamResource):
+                await session.close()
+
+            return content
+        except:
+            await session.close()
+            raise
+
+    def _serialize_request_body(self, body: Any, headers: Optional[Dict[str, str]]) -> Any:
+        content_type, _ = parse_options_header(get_header_value(headers, "Content-Type", ""))
+
+        if content_type == "application/x-www-form-urlencoded":
+            return urlencode(body)
+
+        if isinstance(body, (str, bytes)):
+            return body
+
+        return json.dumps(body)
+    
+    async def _parse_response_content(self, session: aiohttp.ClientSession, response: aiohttp.ClientResponse) -> Any:
+        content_type, _ = parse_options_header(response.headers.get("Content-Type", ""))
+
+        if content_type == "application/json":
+            return await response.json()
+
+        if content_type.startswith("text/"):
+            return await response.text()
+
+        _, disposition = parse_options_header(response.headers.get("Content-Disposition", ""))
+        filename = disposition.get("filename")
+
+        return HttpStreamResource(session, response.content, content_type, filename)

{model_compose-0.0.8 → model_compose-0.0.9}/src/mindor/core/utils/template.py

@@ -22,24 +22,33 @@ class TemplateRenderer:
     def _render_element(self, element: Any) -> Any:
         if isinstance(element, str):
             return self._render_text(element)
+        
         if isinstance(element, dict):
             return { key: self._render_element(value) for key, value in element.items() }
+        
         if isinstance(element, list):
             return [ self._render_element(item) for item in element ]
+        
         return element
 
     def _render_text(self, text: str) -> Any:
-        match = self.patterns["placeholder"].search(text)
-        if match:
+        while True:
+            match = self.patterns["placeholder"].search(text)
+            
+            if not match:
+                break
+
             key, path, default, placeholder = match.group(1), match.group(2), match.group(3), match.group(0)
             try:
-                source = self.source_resolver(key)
-                value = self._resolve_by_path(source, path)
-                if text != placeholder:
-                    return text.replace(placeholder, value)
-                return value
+                value = self._resolve_by_path(self.source_resolver(key), path)
             except Exception:
-                return default or ""
+                value = default or ""
+
+            if placeholder == text:
+                return value
+
+            text = text.replace(placeholder, str(value))
+
         return text
 
     def _resolve_by_path(self, source: Any, path: Optional[str]) -> Any:

model_compose-0.0.9/src/mindor/core/utils/time.py

@@ -0,0 +1,13 @@
+from datetime import timedelta
+
+def parse_duration(string: str) -> timedelta:
+    if string.endswith("s"):
+        return timedelta(seconds=int(string[:-1]))
+    
+    if string.endswith("m"):
+            return timedelta(minutes=int(string[:-1]))
+    
+    if string.endswith("h"):
+        return timedelta(hours=int(string[:-1]))
+    
+    raise ValueError(f"Unsupported duration format: {string}")

{model_compose-0.0.8 → model_compose-0.0.9}/src/mindor/dsl/schema/action/impl/http_client.py

@@ -4,11 +4,7 @@ from pydantic import model_validator
 from .common import CommonActionConfig
 
 class CommonCompletionConfig(BaseModel):
-    type: Literal[ "callback", "polling" ]
-
-class CallbackCompletionConfig(CommonCompletionConfig):
-    type: Literal["callback"]
-    wait_for: str
+    type: Literal[ "polling", "callback" ]
 
 class PollingCompletionConfig(CommonCompletionConfig):
     type: Literal["polling"]
@@ -18,6 +14,9 @@ class PollingCompletionConfig(CommonCompletionConfig):
     headers: Optional[Dict[str, str]] = Field(default_factory=dict)
     body: Optional[Dict[str, Any]] = Field(default_factory=dict)
     params: Optional[Dict[str, str]] = Field(default_factory=dict)
+    status: Optional[str] = None
+    success_when: Optional[str] = None
+    fail_when: Optional[str] = None
     interval: Optional[str] = None
     timeout: Optional[str] = None
 
@@ -27,10 +26,14 @@ class PollingCompletionConfig(CommonCompletionConfig):
             raise ValueError("Either 'endpoint' or 'path' must be set, but not both.")
         return values
 
+class CallbackCompletionConfig(CommonCompletionConfig):
+    type: Literal["callback"]
+    wait_for: str
+
 HttpClientCompletionConfig = Annotated[ 
-    Union[ 
-        CallbackCompletionConfig,
-        PollingCompletionConfig
+    Union[
+        PollingCompletionConfig,
+        CallbackCompletionConfig
     ],
     Field(discriminator="type")
 ]

model_compose-0.0.9/src/mindor/dsl/schema/gateway/__init__.py

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

model_compose-0.0.9/src/mindor/dsl/schema/gateway/gateway.py

@@ -0,0 +1,10 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from .impl import *
+
+GatewayConfig = Annotated[
+    Union[ 
+        HttpTunnelGatewayConfig
+    ],
+    Field(discriminator="type")
+]

model_compose-0.0.9/src/mindor/dsl/schema/gateway/impl/__init__.py

@@ -0,0 +1,2 @@
+from .common import *
+from .http_tunnel import *

model_compose-0.0.9/src/mindor/dsl/schema/gateway/impl/common.py

@@ -0,0 +1,7 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from .types import GatewayType
+
+class CommonGatewayConfig(BaseModel):
+    type: GatewayType
+    runtime: Literal[ "docker", "native" ] = "native"

model_compose-0.0.9/src/mindor/dsl/schema/gateway/impl/http_tunnel.py

@@ -0,0 +1,9 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+from .common import GatewayType, CommonGatewayConfig
+
+class HttpTunnelGatewayConfig(CommonGatewayConfig):
+    type: Literal[GatewayType.HTTP_TUNNEL]
+    driver: Literal[ "ngrok" ]
+    port: Optional[int] = 8090

model_compose-0.0.9/src/mindor/dsl/schema/gateway/impl/types.py

@@ -0,0 +1,4 @@
+from enum import Enum
+
+class GatewayType(str, Enum):
+    HTTP_TUNNEL = "http-tunnel"

{model_compose-0.0.8 → model_compose-0.0.9}/src/mindor/dsl/schema/listener/impl/http_callback.py

@@ -7,7 +7,7 @@ class HttpCallbackConfig(BaseModel):
     path: str
     method: Literal[ "GET", "POST", "PUT", "DELETE", "PATCH" ] = "POST"
     bulk: bool = False
-    item_at: Optional[str] = None
+    item: Optional[str] = None
     identify_by: str
     result: Optional[Any] = None
 

{model_compose-0.0.8 → model_compose-0.0.9/src/model_compose.egg-info}/PKG-INFO

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

{model_compose-0.0.8 → model_compose-0.0.9}/src/model_compose.egg-info/SOURCES.txt

@@ -21,6 +21,11 @@ src/mindor/core/controller/engine/__init__.py
 src/mindor/core/controller/engine/base.py
 src/mindor/core/controller/engine/http_server.py
 src/mindor/core/controller/engine/mcp_server.py
+src/mindor/core/gateway/__init__.py
+src/mindor/core/gateway/gateway.py
+src/mindor/core/gateway/engine/__init__.py
+src/mindor/core/gateway/engine/base.py
+src/mindor/core/gateway/engine/http_tunnel.py
 src/mindor/core/listener/__init__.py
 src/mindor/core/listener/listener.py
 src/mindor/core/listener/engine/__init__.py
@@ -32,9 +37,11 @@ src/mindor/core/services/__init__.py
 src/mindor/core/services/async_service.py
 src/mindor/core/utils/__init__.py
 src/mindor/core/utils/expiring.py
+src/mindor/core/utils/http_client.py
 src/mindor/core/utils/http_headers.py
 src/mindor/core/utils/resources.py
 src/mindor/core/utils/template.py
+src/mindor/core/utils/time.py
 src/mindor/core/utils/workqueue.py
 src/mindor/core/workflow/__init__.py
 src/mindor/core/workflow/context.py
@@ -69,6 +76,12 @@ src/mindor/dsl/schema/controller/impl/common.py
 src/mindor/dsl/schema/controller/impl/http_server.py
 src/mindor/dsl/schema/controller/impl/mcp_server.py
 src/mindor/dsl/schema/controller/impl/types.py
+src/mindor/dsl/schema/gateway/__init__.py
+src/mindor/dsl/schema/gateway/gateway.py
+src/mindor/dsl/schema/gateway/impl/__init__.py
+src/mindor/dsl/schema/gateway/impl/common.py
+src/mindor/dsl/schema/gateway/impl/http_tunnel.py
+src/mindor/dsl/schema/gateway/impl/types.py
 src/mindor/dsl/schema/listener/__init__.py
 src/mindor/dsl/schema/listener/listener.py
 src/mindor/dsl/schema/listener/impl/__init__.py

model_compose-0.0.8/src/mindor/core/component/engine/http_client.py

@@ -1,141 +0,0 @@
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, AsyncIterator, Any
-from mindor.dsl.schema.component import HttpClientComponentConfig
-from mindor.dsl.schema.action import ActionConfig, HttpClientActionConfig, HttpClientCompletionConfig
-from mindor.core.listener import HttpCallbackListener
-from mindor.core.utils.http_headers import parse_options_header, get_header_value
-from mindor.core.utils.resources import StreamResource
-from .base import BaseComponent, ComponentType, ComponentEngineMap
-from .context import ComponentContext
-
-from urllib.parse import urlencode
-import asyncio, aiohttp, json
-
-class HttpStreamResource(StreamResource):
-    def __init__(self, session: aiohttp.ClientSession, stream: aiohttp.StreamReader, content_type: Optional[str], filename: Optional[str]):
-        super().__init__(content_type, filename)
-
-        self.session: aiohttp.ClientSession = session
-        self.stream: aiohttp.StreamReader = stream
-
-    def get_stream(self):
-        return self.stream
-    
-    async def close(self):
-        await self.session.close()
-
-    async def _iterate_stream(self) -> AsyncIterator[bytes]:
-        _, buffer_size = self.stream.get_read_buffer_limits()
-        chunk_size = buffer_size or 65536
-
-        while not self.stream.at_eof():
-            chunk = await self.stream.read(chunk_size)
-            if not chunk:
-                break
-            yield chunk
-
-class HttpClientAction:
-    def __init__(self, base_url: Optional[str], config: HttpClientActionConfig):
-        self.base_url: Optional[str] = base_url
-        self.config: HttpClientActionConfig = config
-        self.future: Optional[asyncio.Future] = None
-
-    async def run(self, context: ComponentContext) -> Any:
-        url     = self._resolve_request_url(context)
-        method  = context.render_template(self.config.method)
-        params  = context.render_template(self.config.params)
-        body    = context.render_template(self.config.body)
-        headers = context.render_template(self.config.headers)
-
-        response = await self._request(url, method, params, body, headers)
-
-        if response:
-            context.register_source("response", response)
-
-        if self.config.completion:
-            result = await self._handle_completion(self.config.completion, context)
-
-        return context.render_template(self.config.output) if self.config.output else (result or response)
-
-    async def _request(self, url: str, method: str, params: Optional[Dict[str, Any]], body: Optional[Any], headers: Optional[Dict[str, str]]) -> Any:
-        session = aiohttp.ClientSession()
-        try:
-            response = await session.request(                
-                method,
-                url,
-                params=params,
-                data=self._serialize_request_body(body, headers) if body is not None else None, 
-                headers=headers
-            )
-
-            if response.status >= 400:
-                raise ValueError(f"Request failed with status {response.status}")
-
-            content = await self._parse_response_content(session, response)
-
-            if isinstance(content, HttpStreamResource):
-                pass
-            else:
-                await session.close()
-
-            return content
-        except:
-            await session.close()
-            raise
-
-    def _resolve_request_url(self, context: ComponentContext) -> str:
-        if self.base_url and self.config.path:
-            return context.render_template(str(self.base_url)) + context.render_template(self.config.path)
-
-        return context.render_template(str(self.config.endpoint))
-    
-    def _serialize_request_body(self, body: Any, headers: Optional[Dict[str, str]]) -> Any:
-        content_type, _ = parse_options_header(get_header_value(headers, "Content-Type", ""))
-
-        if content_type == "application/x-www-form-urlencoded":
-            return urlencode(body)
-
-        if isinstance(body, (str, bytes)):
-            return body
-
-        return json.dumps(body)
-    
-    async def _parse_response_content(self, session: aiohttp.ClientSession, response: aiohttp.ClientResponse) -> Any:
-        content_type, _ = parse_options_header(response.headers.get("Content-Type", ""))
-
-        if content_type == "application/json":
-            return await response.json()
-
-        if content_type.startswith("text/"):
-            return await response.text()
-
-        _, disposition = parse_options_header(response.headers.get("Content-Disposition", ""))
-        filename = disposition.get("filename")
-
-        return HttpStreamResource(session, response.content, content_type, filename)
-
-    async def _handle_completion(self, completion: HttpClientCompletionConfig, context: ComponentContext) -> Any:
-        if completion.type == "callback":
-            future: asyncio.Future = asyncio.get_event_loop().create_future()
-            HttpCallbackListener.register_pending_future(context.render_template(completion.wait_for), future)
-            result = await future
-            if result:
-                context.register_source("result", result)
-            return result
-
-        if completion.type == "polling":
-            return None
-
-class HttpClientComponent(BaseComponent):
-    def __init__(self, id: str, config: HttpClientComponentConfig, env: Dict[str, str], daemon: bool):
-        super().__init__(id, config, env, daemon)
-
-    async def _serve(self) -> None:
-        pass
-
-    async def _shutdown(self) -> None:
-        pass
-
-    async def _run(self, action: ActionConfig, context: ComponentContext) -> Any:
-        return await HttpClientAction(self.config.base_url, action).run(context)
-
-ComponentEngineMap[ComponentType.HTTP_CLIENT] = HttpClientComponent