model-compose 0.1.8__tar.gz → 0.1.9__tar.gz

{model_compose-0.1.8/src/model_compose.egg-info → model_compose-0.1.9}/PKG-INFO

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

{model_compose-0.1.8 → model_compose-0.1.9}/pyproject.toml

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

{model_compose-0.1.8 → model_compose-0.1.9}/src/mindor/core/component/engine/http_client.py

@@ -1,19 +1,30 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, AsyncIterator, Any
+from abc import ABC, abstractmethod
 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.http_status import is_status_code_matched
 from mindor.core.utils.time import parse_duration
 from .base import ComponentEngine, ComponentType, ComponentEngineMap
 from .context import ComponentContext
 from datetime import datetime, timezone
 import asyncio
 
-class HttpClientPollingCompletion:
-    def __init__(self, base_url: Optional[str], headers: Optional[Dict[str, str]], config: HttpClientCompletionConfig):
+class HttpClientCompletion(ABC):
+    @abstractmethod
+    async def run(self, context: ComponentContext) -> Any:
+        pass
+
+    @abstractmethod
+    async def close(self) -> None:
+        pass
+
+class HttpClientPollingCompletion(HttpClientCompletion):
+    def __init__(self, config: HttpClientCompletionConfig, base_url: Optional[str], headers: Optional[Dict[str, str]]):
+        self.config: HttpClientCompletionConfig = config
         self.base_url: Optional[str] = base_url
         self.headers: Optional[Dict[str, str]] = headers
-        self.config: HttpClientCompletionConfig = config
         self.client: HttpClient = HttpClient()
 
     async def run(self, context: ComponentContext) -> Any:
@@ -30,33 +41,38 @@ class HttpClientPollingCompletion:
         await asyncio.sleep(interval.total_seconds())
 
         while datetime.now(timezone.utc) < deadline:
-            response = await self.client.request(url, method, params, body, headers)
+            response, status_code = await self.client.request(url, method, params, body, headers, raise_on_error=False)
             context.register_source("result", response)
 
-            status = (await context.render_template(self.config.status)) if self.config.status else response["status"]
-
-            if not status:
+            status = (await context.render_template(self.config.status)) if self.config.status else None
+            if self.config.status and not status:
                 raise RuntimeError(f"Polling failed: no status found in response.")
 
-            for success_when in self.config.success_when if self.config.success_when else [ "completed" ]:
-                if status == await context.render_template(success_when):
+            if status:
+                if status in self.config.success_when or []:
                     return response
-
-            for fail_when in self.config.fail_when if self.config.fail_when else [ "failed" ]:
-                if status == await context.render_template(fail_when):
+                if status in self.config.fail_when or []:
                     raise RuntimeError(f"Polling failed: status '{status}' matched a failure condition.")
+            else: # use status code
+                if is_status_code_matched(status_code, self.config.success_when or []):
+                    return response
+                if is_status_code_matched(status_code, self.config.fail_when or []):
+                    raise RuntimeError(f"Polling failed: status code '{status_code}' matched a failure condition.")
 
             await asyncio.sleep(interval.total_seconds())
 
         raise TimeoutError(f"Polling timed out after {timeout}.")
 
+    async def close(self) -> None:
+        await self.client.close()
+
     async def _resolve_request_url(self, context: ComponentContext) -> str:
         if self.base_url and self.config.path:
             return await context.render_template(self.base_url) + await context.render_template(self.config.path)
 
         return await context.render_template(self.config.endpoint)
 
-class HttpClientCallbackCompletion:
+class HttpClientCallbackCompletion(HttpClientCompletion):
     def __init__(self, config: HttpClientCompletionConfig):
         self.config: HttpClientCompletionConfig = config
 
@@ -66,56 +82,71 @@ class HttpClientCallbackCompletion:
         HttpCallbackListener.register_pending_future(callback_id, future)
 
         return await future
+    
+    async def close(self) -> None:
+        pass
 
 class HttpClientAction:
-    def __init__(self, base_url: Optional[str], headers: Optional[Dict[str, str]], config: HttpClientActionConfig):
+    def __init__(self, config: HttpClientActionConfig, base_url: Optional[str], headers: Optional[Dict[str, str]]):
+        self.config: HttpClientActionConfig = config
         self.base_url: Optional[str] = base_url
         self.headers: Optional[Dict[str, str]] = headers
-        self.config: HttpClientActionConfig = config
-        self.client: HttpClient = HttpClient()
+        self.completion: HttpClientCompletion = None
 
-    async def run(self, context: ComponentContext) -> Any:
+        if self.config.completion:
+            self._configure_completion()
+
+    def _configure_completion(self) -> None:
+        if self.config.completion.type == "polling":
+            self.completion = HttpClientPollingCompletion(self.config.completion, self.base_url, self.headers)
+            return
+        
+        if self.config.completion.type == "callback":
+            self.completion = HttpClientCallbackCompletion(self.config.completion)
+            return
+        
+        raise ValueError(f"Unsupported http completion type: {self.config.completion.type}")
+
+    async def run(self, context: ComponentContext, client: HttpClient) -> Any:
         url     = await self._resolve_request_url(context)
         method  = await context.render_template(self.config.method)
         params  = await context.render_template(self.config.params)
         body    = await context.render_template(self.config.body)
         headers = await context.render_template({ **self.headers, **self.config.headers })
 
-        response, result = await self.client.request(url, method, params, body, headers), None
+        response, result = await client.request(url, method, params, body, headers), None
         context.register_source("response", response)
 
-        if self.config.completion:
-            result = await self._handle_completion(self.config.completion, context)
+        if self.completion:
+            result = await self.completion.run(context)
             context.register_source("result", result)
 
         return (await context.render_template(self.config.output, ignore_files=True)) if self.config.output else (result or response)
 
+    async def close(self) -> None:
+        if self.completion:
+            await self.completion.close()
+
     async def _resolve_request_url(self, context: ComponentContext) -> str:
         if self.base_url and self.config.path:
             return await context.render_template(self.base_url) + await context.render_template(self.config.path)
 
         return await 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, self.headers, completion).run(context)
-        
-        if completion.type == "callback":
-            return await HttpClientCallbackCompletion(completion).run(context)
-
-        return None
-
 class HttpClientComponent(ComponentEngine):
     def __init__(self, id: str, config: HttpClientComponentConfig, env: Dict[str, str], daemon: bool):
         super().__init__(id, config, env, daemon)
 
+        self.client: HttpClient = None
+
     async def _serve(self) -> None:
-        pass
+        self.client = HttpClient()
 
     async def _shutdown(self) -> None:
-        pass
+        await self.client.close()
+        self.client = None
 
     async def _run(self, action: ActionConfig, context: ComponentContext) -> Any:
-        return await HttpClientAction(self.config.base_url, self.config.headers, action).run(context)
+        return await HttpClientAction(action, self.config.base_url, self.config.headers).run(context, self.client)
 
 ComponentEngineMap[ComponentType.HTTP_CLIENT] = HttpClientComponent

{model_compose-0.1.8 → model_compose-0.1.9}/src/mindor/core/controller/engine/http_server.py

@@ -59,7 +59,7 @@ class HttpServerController(ControllerEngine):
         self._configure_routes()
         self.app.include_router(self.router, prefix=self.config.base_path)
 
-    def _configure_server(self):
+    def _configure_server(self) -> None:
         self.app.add_middleware(
             CORSMiddleware, 
             allow_origins=[self.config.origins], 
@@ -68,7 +68,7 @@ class HttpServerController(ControllerEngine):
             allow_headers=["*"],
         )
 
-    def _configure_routes(self):
+    def _configure_routes(self) -> None:
         @self.router.post("/workflows")
         async def run_workflow(
             request: Request
@@ -107,6 +107,7 @@ class HttpServerController(ControllerEngine):
             log_level="info"
         ))
         await self.server.serve()
+        self.server = None
  
     async def _shutdown(self) -> None:
         if self.server:

{model_compose-0.1.8 → model_compose-0.1.9}/src/mindor/core/controller/engine/mcp_server.py

@@ -150,6 +150,7 @@ class McpServerController(ControllerEngine):
             log_level="info"
         ))
         await self.server.serve()
+        self.server = None
 
     async def _shutdown(self) -> None:
         if self.server:

{model_compose-0.1.8 → model_compose-0.1.9}/src/mindor/core/controller/runner/http_client.py

@@ -32,6 +32,9 @@ class HttpControllerClient(ControllerClient):
 
         return await self.client.request(url, method, None, body, headers)
 
+    async def close(self) -> None:
+        await self.client.close()
+
     def _flatten_for_multipart(self, body: Dict[str, Any], key: str = "") -> List[Tuple[str, Any]]:
         flattened = []
 

{model_compose-0.1.8 → model_compose-0.1.9}/src/mindor/core/controller/runner/mcp_client.py

@@ -7,7 +7,8 @@ class McpControllerClient(ControllerClient):
     def __init__(self, config: ControllerConfig):
         super().__init__(config)
 
-        self.client: McpClient = McpClient()
-
     async def run_workflow(self, workflow_id: Optional[str], input: Any) -> Any:
         pass
+
+    async def close(self) -> None:
+        pass

{model_compose-0.1.8 → model_compose-0.1.9}/src/mindor/core/controller/runner/runner.py

@@ -13,6 +13,10 @@ class ControllerClient(ABC):
     async def run_workflow(self, workflow_id: Optional[str], input: Any) -> Any:
         pass
 
+    @abstractmethod
+    async def close(self) -> None:
+        pass
+
 class ControllerRunner:
     def __init__(self, config: ControllerConfig):
         self.config: ControllerConfig = config
@@ -24,10 +28,15 @@ class ControllerRunner:
         if self.config.type == "http-server":
             self.client = HttpControllerClient(self.config)
             return
-        
+
         if self.config.type == "mcp-server":
             self.client = McpControllerClient(self.config)
             return
+
+        raise ValueError(f"Unsupported controller type: {self.config.type}")
     
     async def run_workflow(self, workflow_id: Optional[str], input: Any) -> Any:
         return await self.client.run_workflow(workflow_id, input)
+
+    async def close(self) -> None:
+        await self.client.close()

{model_compose-0.1.8 → model_compose-0.1.9}/src/mindor/core/controller/webui/gradio.py

@@ -184,7 +184,7 @@ class GradioWebUIBuilder:
             return await load_image_from_stream(Base64StreamResource(value), subtype)
 
         if format == "url" and isinstance(value, str):
-            return await load_image_from_stream(await HttpClient().request(value), subtype)
+            return await load_image_from_stream(await HttpClient.request_once(value), subtype)
 
         if isinstance(value, StreamResource):
             return await load_image_from_stream(value, subtype)
@@ -196,7 +196,7 @@ class GradioWebUIBuilder:
             return await save_stream_to_temporary_file(Base64StreamResource(value), subtype)
 
         if format == "url" and isinstance(value, str):
-            return await save_stream_to_temporary_file(await HttpClient().request(value), subtype)
+            return await save_stream_to_temporary_file(await HttpClient.request_once(value), subtype)
 
         if isinstance(value, StreamResource):
             return await save_stream_to_temporary_file(value, subtype)

{model_compose-0.1.8 → model_compose-0.1.9}/src/mindor/core/controller/webui/webui.py

@@ -30,7 +30,7 @@ class ControllerWebUI(AsyncService):
         self.env: Dict[str, str] = env
         self.server: Optional[uvicorn.Server] = None
         self.app: FastAPI = FastAPI(openapi_url=None, docs_url=None, redoc_url=None)
-        self.runner: ControllerRunner = ControllerRunner(controller)
+        self.runner: ControllerRunner = None
 
         self._configure_driver()
 
@@ -44,6 +44,7 @@ class ControllerWebUI(AsyncService):
             return
 
     async def _serve(self) -> None:
+        self.runner = ControllerRunner(self.controller)
         self.server = uvicorn.Server(uvicorn.Config(
             self.app,
             host=self.config.host,
@@ -51,10 +52,15 @@ class ControllerWebUI(AsyncService):
             log_level="info"
         ))
         await self.server.serve()
+        await self.runner.close()
+        self.server = None
+        self.runner = None
     
     async def _shutdown(self) -> None:
         if self.server:
             self.server.should_exit = True
-    
+
     async def _run_workflow(self, workflow_id: Optional[str], input: Any) -> Any:
-        return await self.runner.run_workflow(workflow_id, input)
+        if self.runner:
+            return await self.runner.run_workflow(workflow_id, input)
+        return None

{model_compose-0.1.8 → model_compose-0.1.9}/src/mindor/core/listener/engine/http_callback.py

@@ -22,7 +22,7 @@ class HttpCallbackContext:
         self.renderer: TemplateRenderer = TemplateRenderer(self._resolve_source)
 
     async def items(self) -> AsyncIterator["HttpCallbackContext"]:
-        async for item in self._items():
+        for item in await self._items():
             yield HttpCallbackContext(item, self.query, False, None)
 
     async def render_template(self, template: str, ignore_files: bool = True) -> Any:
@@ -56,7 +56,7 @@ class HttpCallbackListener(ListenerEngine):
         self._configure_routes()
         self.app.include_router(self.router, prefix=self.config.base_path)
 
-    def _configure_routes(self):
+    def _configure_routes(self) -> None:
         for callback in self.config.callbacks:
             self.router.add_api_route(
                 path=callback.path,
@@ -69,8 +69,8 @@ class HttpCallbackListener(ListenerEngine):
         async def _handler(request: Request) -> Response:
             content_type, _ = parse_options_header(request.headers, "Content-Type")
             body, query = await parse_request_body(request, content_type), request.query_params
-            context: HttpCallbackContext = HttpCallbackContext(body, query, callback.bulk, callback.item)
-            succeeded: bool = await self._is_callback_succeeded(callback, context)
+            context = HttpCallbackContext(body, query, callback.bulk, callback.item)
+            succeeded = await self._is_callback_succeeded(callback, context)
 
             async for item in context.items():
                 callback_id = await item.render_template(callback.identify_by)
@@ -91,13 +91,12 @@ class HttpCallbackListener(ListenerEngine):
         status = (await context.render_template(callback.status)) if callback.status else None
 
         if status:
-            if callback.success_when and status == await context.render_template(callback.success_when):
+            if status in callback.success_when or []:
                 return True
-
-            if callback.fail_when and status == await context.render_template(callback.fail_when):
+            if status in callback.fail_when or []:
                 return False
 
-        return True       
+        return True
 
     async def _serve(self) -> None:
         self.server = uvicorn.Server(uvicorn.Config(
@@ -107,6 +106,7 @@ class HttpCallbackListener(ListenerEngine):
             log_level="info"
         ))
         await self.server.serve()
+        self.server = None
  
     async def _shutdown(self) -> None:
         if self.server:

{model_compose-0.1.8 → model_compose-0.1.9}/src/mindor/core/utils/http_client.py

@@ -1,4 +1,4 @@
-from typing import Optional, Dict, Tuple, AsyncIterator, Any
+from typing import Union, Optional, Dict, Tuple, AsyncIterator, Any
 from .http_request import build_request_body, parse_options_header
 from .streaming import StreamResource
 from requests.structures import CaseInsensitiveDict
@@ -7,20 +7,19 @@ import aiohttp
 class HttpStreamResource(StreamResource):
     def __init__(
         self, 
-        session: aiohttp.ClientSession, 
-        stream: aiohttp.StreamReader, 
+        response: aiohttp.ClientResponse,
         content_type: Optional[str] = None, 
         filename: Optional[str] = None
     ):
         super().__init__(content_type, filename)
 
-        self.session: aiohttp.ClientSession = session
-        self.stream: aiohttp.StreamReader = stream
+        self.response: aiohttp.ClientResponse = response
+        self.stream: aiohttp.StreamReader = response.content
 
-    async def close(self):
-        await self.session.close()
-        self.session = None
-        self.stream  = None
+    async def close(self) -> None:
+        self.response.close()
+        self.response = None
+        self.stream = None
 
     async def _iterate_stream(self) -> AsyncIterator[bytes]:
         _, buffer_size = self.stream.get_read_buffer_limits()
@@ -33,34 +32,62 @@ class HttpStreamResource(StreamResource):
             yield chunk
 
 class HttpClient:
+    def __init__(self, base_url: Optional[str] = None, headers: Optional[Dict[str, str]] = None):
+        self.base_url: Optional[str] = base_url
+        self.headers: Optional[Dict[str, str]] = headers
+        self.session = aiohttp.ClientSession(self.base_url, headers=self.headers)
+
+    async def __aenter__(self):
+        if self.session is not None:
+            self.session = aiohttp.ClientSession(self.base_url, headers=self.headers)
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+
     async def request(
         self,
-        url: str,
+        url_or_path: str,
         method: Optional[str] = "GET",
         params: Optional[Dict[str, Any]] = None,
         body: Optional[Any] = None,
-        headers: Optional[Dict[str, str]] = None
-    ) -> Any:
-        session = aiohttp.ClientSession()
+        headers: Optional[Dict[str, str]] = None,
+        raise_on_error: bool = True
+    ) -> Union[Any, Tuple[Any, int]]:
+        response: aiohttp.ClientResponse = None
         try:
-            response = await self._request_with_session(session, url, method, params, body, headers)
-            content, _ = await self._parse_response_content(session, response)
+            response = await self._request_with_session(self.session, url_or_path, method, params, body, headers)
+            content, _ = await self._parse_response_content(response)
 
-            if response.status >= 400:
+            if raise_on_error and response.status >= 400:
                 raise ValueError(f"Request failed with status {response.status}: {content}")
 
             if not isinstance(content, HttpStreamResource):
-                await session.close()
+                response.close()
 
-            return content
+            return content if raise_on_error else (content, response.status)
         except:
-            await session.close()
+            if response:
+                response.close()
             raise
 
+    async def close(self) -> None:
+        if self.session:
+            await self.session.close()
+            self.session = None
+
+    @classmethod
+    async def request_once(cls, *args, **kwargs):
+        instance = cls()
+        try:
+            return await instance.request(*args, **kwargs)
+        finally:
+            await instance.close()
+    
     async def _request_with_session(
         self,
         session: aiohttp.ClientSession,
-        url: str,
+        url_or_path: str,
         method: str,
         params: Optional[Dict[str, Any]],
         body: Optional[Any],
@@ -72,7 +99,7 @@ class HttpClient:
             headers = CaseInsensitiveDict(headers)
             headers.pop("Content-Type", None)
 
-        return await session.request(method, url, params=params, data=data, headers=headers)
+        return await session.request(method, url_or_path, params=params, data=data, headers=headers)
 
     def _build_request_body(self, body: Optional[Any], headers: Optional[Dict[str, str]]) -> Tuple[Any, str]:
         content_type, _ = parse_options_header(headers, "Content-Type")
@@ -82,7 +109,7 @@ class HttpClient:
 
         return (body, content_type)
 
-    async def _parse_response_content(self, session: aiohttp.ClientSession, response: aiohttp.ClientResponse) -> Tuple[Any, str]:
+    async def _parse_response_content(self, response: aiohttp.ClientResponse) -> Tuple[Any, str]:
         content_type, _ = parse_options_header(response.headers, "Content-Type")
 
         if content_type == "application/json":
@@ -94,4 +121,4 @@ class HttpClient:
         _, disposition = parse_options_header(response.headers, "Content-Disposition")
         filename = disposition.get("filename")
 
-        return (HttpStreamResource(session, response.content, content_type, filename), content_type)
+        return (HttpStreamResource(response, content_type, filename), content_type)

model_compose-0.1.9/src/mindor/core/utils/http_status.py

@@ -0,0 +1,20 @@
+from typing import Union, List
+
+def is_status_code_matched(status_code: int, conditions: List[Union[int, str]]) -> bool:
+    for condition in conditions:
+        if isinstance(condition, int) or (isinstance(condition, str) and condition.isdigit()):
+            if status_code == int(condition):
+                return True
+            continue
+
+        if isinstance(condition, str) and condition.endswith("x"):
+            try:
+                prefix = int(condition.rstrip("x"))
+                factor = 10 ** (len(condition) - len(str(prefix)))
+                if prefix * factor <= status_code < (prefix + 1) * factor:
+                    return True
+            except ValueError:
+                pass
+            continue
+
+    return False

model_compose-0.1.9/src/mindor/core/utils/mcp_client.py

@@ -0,0 +1,122 @@
+from typing import Optional, Dict, Tuple, AsyncIterator, Any
+from mcp.client.streamable_http import streamablehttp_client
+from mcp import ClientSession
+
+class McpClient:
+    def __init__(self, url: str, headers: Optional[Dict[str, str]] = None):
+        self.url: str = url
+        self.headers: Optional[Dict[str, str]] = headers
+        self.session: Optional[ClientSession] = ClientSession(streamablehttp_client(self.url, headers=self.headers))
+        self._initialized = False
+
+    async def __aenter__(self):
+        if self.session is None:
+            self.session = ClientSession(streamablehttp_client(self.url, headers=self.headers))
+        await self._ensure_initialized()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+
+    async def call_tool(self, name: str, arguments: Optional[Dict[str, Any]] = None, raise_on_error: bool = True) -> Any:
+        """
+        Call a specific tool on the MCP server
+        
+        Args:
+            name: The name of the tool to call
+            arguments: Arguments to pass to the tool
+            raise_on_error: Whether to raise exceptions on error responses
+            
+        Returns:
+            The tool execution result
+        """
+        await self._ensure_initialized()
+        try:
+            return await self.session.call_tool(name, arguments)
+        except:
+            pass
+
+    async def list_tools(self) -> Any:
+        """List all available tools from the MCP server"""
+        await self._ensure_initialized()
+        try:
+            return await self.session.list_tools()
+        except:
+            pass
+
+    async def read_resource(self, uri: str, raise_on_error: bool = True) -> Any:
+        """
+        Read a specific resource from the MCP server
+        
+        Args:
+            uri: The URI of the resource to read
+            raise_on_error: Whether to raise exceptions on error responses
+            
+        Returns:
+            The resource content
+        """
+        await self._ensure_initialized()
+        try:
+            return await self.session.read_resource(uri)
+        except:
+            pass
+
+    async def list_resources(self) -> Any:
+        """List all available resources from the MCP server"""
+        return await self.session.list_resources()
+
+    async def get_prompt(self, name: str, arguments: Optional[Dict[str, Any]] = None, raise_on_error: bool = True) -> Any:
+        """
+        Get a specific prompt from the MCP server
+        
+        Args:
+            name: The name of the prompt to get
+            arguments: Arguments to pass to the prompt
+            raise_on_error: Whether to raise exceptions on error responses
+            
+        Returns:
+            The prompt content
+        """
+        await self._ensure_initialized()
+        try:
+            return await self.session.get_prompt(name, arguments)
+        except:
+            pass
+
+    async def list_prompts(self) -> Any:
+        """List all available prompts from the MCP server"""
+        await self._ensure_initialized()
+        try:
+            return await self.session.list_prompts()
+        except:
+            pass
+
+    async def ping(self) -> bool:
+        """
+        Ping the MCP server to check connectivity
+        
+        Returns:
+            True if the server is reachable, False otherwise
+        """
+        await self._ensure_initialized()
+        try:
+            await self.session.send_ping()
+            return True
+        except:
+            return False
+
+    async def close(self) -> None:
+        """Close the MCP client session"""
+        await self._close()
+
+    async def _ensure_initialized(self):
+        if not self._initialized:
+            await self.session.__aenter__()
+            await self.session.initialize()
+            self._initialized = True
+
+    async def _close(self) -> None:
+        if self.session:
+            await self.session.__aexit__(None, None, None)
+            self.session = None
+            self._initialized = False

{model_compose-0.1.8 → model_compose-0.1.9}/src/mindor/core/utils/streaming.py

@@ -19,7 +19,7 @@ class StreamResource(ABC):
         return self._iterate_stream()
 
     @abstractmethod
-    async def close(self):
+    async def close(self) -> None:
         pass
 
     @abstractmethod
@@ -37,7 +37,7 @@ class Base64StreamResource(StreamResource):
         self.stream = io.BytesIO(base64.b64decode(self.encoded))
         return self
 
-    async def close(self):
+    async def close(self) -> None:
         self.stream.close()
         self.stream = None
         

{model_compose-0.1.8 → model_compose-0.1.9}/src/mindor/core/utils/template.py

@@ -128,7 +128,7 @@ class TemplateRenderer:
             return await save_stream_to_temporary_file(Base64StreamResource(value), subtype)
 
         if format == "url" and isinstance(value, str):
-            return await save_stream_to_temporary_file(await HttpClient().request(value), subtype)
+            return await save_stream_to_temporary_file(await HttpClient.request_once(value), subtype)
 
         if isinstance(value, StreamResource):
             return await save_stream_to_temporary_file(value, subtype)

{model_compose-0.1.8 → model_compose-0.1.9}/src/mindor/dsl/schema/action/impl/http_client.py

@@ -15,8 +15,8 @@ class PollingCompletionConfig(CommonCompletionConfig):
     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[List[str]] = None
-    fail_when: Optional[List[str]] = None
+    success_when: Optional[List[Union[int, str]]] = None
+    fail_when: Optional[List[Union[int, str]]] = None
     interval: Optional[str] = None
     timeout: Optional[str] = None
 
@@ -28,8 +28,8 @@ class PollingCompletionConfig(CommonCompletionConfig):
 
     @model_validator(mode="before")
     def normalize_status_fields(cls, values: Dict[str, Any]):
-        for key in ("success_when", "fail_when"):
-            if isinstance(values.get(key), str):
+        for key in [ "success_when", "fail_when" ]:
+            if isinstance(values.get(key), (int, str)):
                 values[key] = [ values[key] ]
         return values
 

{model_compose-0.1.8 → model_compose-0.1.9}/src/mindor/dsl/schema/component/impl/http_client.py

@@ -9,7 +9,7 @@ class HttpClientComponentConfig(CommonComponentConfig):
     base_url: Optional[str] = None
     headers: Optional[Dict[str, Any]] = Field(default_factory=dict)
     actions: Optional[Dict[str, HttpClientActionConfig]] = Field(default_factory=dict)
-    
+
     @model_validator(mode="before")
     def inflate_single_action(cls, values: Dict[str, Any]):
         if "actions" not in values:

{model_compose-0.1.8 → model_compose-0.1.9/src/model_compose.egg-info}/PKG-INFO

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

{model_compose-0.1.8 → model_compose-0.1.9}/src/model_compose.egg-info/SOURCES.txt

@@ -51,6 +51,7 @@ src/mindor/core/utils/__init__.py
 src/mindor/core/utils/expiring.py
 src/mindor/core/utils/http_client.py
 src/mindor/core/utils/http_request.py
+src/mindor/core/utils/http_status.py
 src/mindor/core/utils/image.py
 src/mindor/core/utils/mcp_client.py
 src/mindor/core/utils/ssh_client.py

model_compose-0.1.8/src/mindor/core/utils/mcp_client.py

@@ -1,4 +0,0 @@
-from typing import Optional, Dict, Tuple, AsyncIterator, Any
-
-class McpClient:
-    pass