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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.0.7
+Version: 0.0.8
 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.7 → model_compose-0.0.8}/pyproject.toml

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

{model_compose-0.0.7 → model_compose-0.0.8}/src/mindor/core/component/engine/__init__.py

@@ -1,4 +1,3 @@
 from .base import *
-from .stream import *
 from .http_server import *
 from .http_client import *

{model_compose-0.0.7 → model_compose-0.0.8}/src/mindor/core/component/engine/base.py

@@ -3,12 +3,10 @@ from abc import ABC, abstractmethod
 
 from mindor.dsl.schema.component import ComponentConfig, ComponentType
 from mindor.dsl.schema.action import ActionConfig
+from mindor.core.services import AsyncService
 from mindor.core.utils.workqueue import WorkQueue
 from .context import ComponentContext
 
-from threading import Thread
-import asyncio
-
 class ActionResolver:
     def __init__(self, actions: Dict[str, ActionConfig]):
         self.actions = actions
@@ -32,52 +30,17 @@ class ActionResolver:
 
         return default_ids[0] if default_ids else "__default__"
 
-class BaseComponent(ABC):
+class BaseComponent(AsyncService):
     def __init__(self, id: str, config: ComponentConfig, env: Dict[str, str], daemon: bool):
+        super().__init__(daemon)
+
         self.id: str = id
         self.config: ComponentConfig = config
         self.env: Dict[str, str] = env
-        self.daemon: bool = daemon
-
-        self.queue: Optional[WorkQueue] = None
-        self.thread: Optional[Thread] = None
-        self.thread_loop: Optional[asyncio.AbstractEventLoop] = None
-        self.daemon_task: Optional[asyncio.Task] = None
-        self.started: bool = False
-
+        
         if self.config.max_concurrent_count > 0:
             self.queue = WorkQueue(self.config.max_concurrent_count, self._run)
 
-    async def start(self, background: bool = False) -> None:
-        if background:
-            def _start_in_thread():
-                self.thread_loop = asyncio.new_event_loop()
-                asyncio.set_event_loop(self.thread_loop)
-                self.thread_loop.run_until_complete(self._start())
-    
-            self.thread = Thread(target=_start_in_thread)
-            self.thread.start()
-        else:
-            await self._start()
-
-    async def stop(self) -> None:
-        if self.thread:
-            future = asyncio.run_coroutine_threadsafe(self._stop(), self.thread_loop)
-            future.result()
-            self.thread_loop.close()
-            self.thread_loop = None
-            self.thread.join()
-            self.thread = None
-        else:
-            await self._stop()
-
-    async def wait_until_stopped(self) -> None:
-        if self.thread:
-            self.thread.join()
-
-        if self.daemon_task:
-            await self.daemon_task
-
     async def run(self, action_id: Union[str, None], call_id: str, input: Dict[str, Any]) -> Dict[str, Any]:
         _, action = ActionResolver(self.config.actions).resolve(action_id)
         context = ComponentContext(call_id, input, self.env)
@@ -91,30 +54,13 @@ class BaseComponent(ABC):
         if self.queue:
             await self.queue.start()
 
-        self.started = True
-
-        if self.daemon:
-            if not self.thread:
-                self.daemon_task = asyncio.create_task(self._serve())
-            else:
-                await self._serve()
+        await super()._start()
 
     async def _stop(self) -> None:
         if self.queue:
             await self.queue.stop()
 
-        if self.daemon:
-            await self._shutdown()
-
-        self.started = False
-
-    @abstractmethod
-    async def _serve(self) -> None:
-        pass
-
-    @abstractmethod
-    async def _shutdown(self) -> None:
-        pass
+        await super()._stop()
 
     @abstractmethod
     async def _run(self, action: ActionConfig, context: ComponentContext) -> Any:

{model_compose-0.0.7 → model_compose-0.0.8}/src/mindor/core/component/engine/http_client.py

@@ -1,12 +1,14 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, AsyncIterator, Any
-from mindor.dsl.schema.component import HttpClientComponentConfig, HttpClientActionConfig
+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, ActionConfig
+from .base import BaseComponent, ComponentType, ComponentEngineMap
 from .context import ComponentContext
 
 from urllib.parse import urlencode
-import aiohttp, json
+import asyncio, aiohttp, json
 
 class HttpStreamResource(StreamResource):
     def __init__(self, session: aiohttp.ClientSession, stream: aiohttp.StreamReader, content_type: Optional[str], filename: Optional[str]):
@@ -35,6 +37,7 @@ 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)
@@ -48,7 +51,10 @@ class HttpClientAction:
         if response:
             context.register_source("response", response)
 
-        return context.render_template(self.config.output) if self.config.output else 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()
@@ -107,6 +113,18 @@ class HttpClientAction:
 
         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)

{model_compose-0.0.7 → model_compose-0.0.8}/src/mindor/core/compose/manager.py

@@ -5,7 +5,7 @@ from mindor.core.controller import BaseController, TaskState, create_controller
 class ComposeManager:
     def __init__(self, config: ComposeConfig, env: Dict[str, str], daemon: bool = True):
         self.config: ComposeConfig = config
-        self.controller: BaseController = create_controller(self.config.controller, self.config.components, self.config.workflows, env, daemon)
+        self.controller: BaseController = create_controller(self.config.controller, self.config.components, self.config.listeners, self.config.workflows, env, daemon)
 
     async def launch_services(self, detach: bool, background: bool = False):
         await self.controller.start(background=background)

{model_compose-0.0.7 → model_compose-0.0.8}/src/mindor/core/controller/controller.py

@@ -1,11 +1,12 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.controller import ControllerConfig
 from mindor.dsl.schema.component import ComponentConfig
+from mindor.dsl.schema.listener import ListenerConfig
 from mindor.dsl.schema.workflow import WorkflowConfig
 from .engine import BaseController, ControllerEngineMap
 
-def create_controller(config: ControllerConfig, components: Dict[str, ComponentConfig], workflows: Dict[str, WorkflowConfig], env: Dict[str, str], daemon: bool) -> BaseController:
+def create_controller(config: ControllerConfig, components: Dict[str, ComponentConfig], listeners: List[ListenerConfig], workflows: Dict[str, WorkflowConfig], env: Dict[str, str], daemon: bool) -> BaseController:
     try:
-        return ControllerEngineMap[config.type](config, components, workflows, env, daemon)
+        return ControllerEngineMap[config.type](config, components, listeners, workflows, env, daemon)
     except KeyError:
         raise ValueError(f"Unsupported controller type: {config.type}")

{model_compose-0.0.7 → model_compose-0.0.8}/src/mindor/core/controller/engine/base.py

@@ -1,16 +1,18 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
-from abc import ABC, abstractmethod
 from dataclasses import dataclass
 
 from mindor.dsl.schema.controller import ControllerConfig, ControllerType
 from mindor.dsl.schema.component import ComponentConfig
+from mindor.dsl.schema.listener import ListenerConfig
 from mindor.dsl.schema.workflow import WorkflowConfig
+from mindor.core.services import AsyncService
 from mindor.core.component import BaseComponent, create_component
+from mindor.core.listener import BaseListener, create_listener
 from mindor.core.workflow import Workflow, WorkflowResolver, create_workflow
 from mindor.core.utils.workqueue import WorkQueue
 from mindor.core.utils.expiring import ExpiringDict
 
-from threading import Thread, Lock
+from threading import Lock
 import asyncio, ulid
 
 @dataclass
@@ -20,54 +22,22 @@ class TaskState:
     output: Optional[Any] = None
     error: Optional[Any] = None
 
-class BaseController(ABC):
-    def __init__(self, config: ControllerConfig, components: Dict[str, ComponentConfig], workflows: Dict[str, WorkflowConfig], env: Dict[str, str], daemon: bool):
+class BaseController(AsyncService):
+    def __init__(self, config: ControllerConfig, components: Dict[str, ComponentConfig], listeners: List[ListenerConfig], workflows: Dict[str, WorkflowConfig], env: Dict[str, str], daemon: bool):
+        super().__init__(daemon)
+
         self.config: ControllerConfig = config
         self.components: Dict[str, ComponentConfig] = components
+        self.listeners: List[ListenerConfig] = listeners
         self.workflows: Dict[str, WorkflowConfig] = workflows
         self.env: Dict[str, str] = env
-        self.daemon: bool = daemon
         self.queue: Optional[WorkQueue] = None
-        self.thread: Optional[Thread] = None
-        self.thread_loop: Optional[asyncio.AbstractEventLoop] = None
-        self.daemon_task: Optional[asyncio.Task] = None
         self.task_states: ExpiringDict[TaskState] = ExpiringDict()
         self.task_states_lock: Lock = Lock()
-        self.started: bool = False
-
+        
         if self.config.max_concurrent_count > 0:
             self.queue = WorkQueue(self.config.max_concurrent_count, self._run_workflow)
 
-    async def start(self, background: bool = False) -> None:
-        if background:
-            def _start_in_thread():
-                self.thread_loop = asyncio.new_event_loop()
-                asyncio.set_event_loop(self.thread_loop)
-                self.thread_loop.run_until_complete(self._start())
-
-            self.thread = Thread(target=_start_in_thread)
-            self.thread.start()
-        else:
-            await self._start()
-
-    async def stop(self) -> None:
-        if self.thread:
-            future = asyncio.run_coroutine_threadsafe(self._stop(), self.thread_loop)
-            future.result()
-            self.thread_loop.close()
-            self.thread_loop = None
-            self.thread.join()
-            self.thread = None
-        else:
-            await self._stop()
-
-    async def wait_until_stopped(self) -> None:
-        if self.thread:
-            self.thread.join()
-
-        if self.daemon_task:
-            await self.daemon_task
-
     async def run_workflow(self, workflow_id: Optional[str], input: Dict[str, Any], wait_for_completion: bool = True) -> TaskState:
         task_id = ulid.ulid()
         state = TaskState(task_id=task_id, status="pending")
@@ -92,25 +62,21 @@ class BaseController(ABC):
         if self.queue:
             await self.queue.start()
 
-        self.started = True
-
         if self.daemon:
             await self._start_components()
-    
-            if not self.thread:
-                self.daemon_task = asyncio.create_task(self._serve())
-            else:
-                await self._serve()
+            await self._start_listeners()
+
+        await super()._start()
 
     async def _stop(self) -> None:
         if self.queue:
             await self.queue.stop()
 
         if self.daemon:
+            await self._stop_listeners()
             await self._stop_components()
-            await self._shutdown()
 
-        self.started = False
+        await super()._stop()
 
     async def _start_components(self) -> None:
         await asyncio.gather(*[ component.start() for component in self._create_components() ])
@@ -118,6 +84,12 @@ class BaseController(ABC):
     async def _stop_components(self) -> None:
         await asyncio.gather(*[ component.stop() for component in self._create_components() ])
 
+    async def _start_listeners(self) -> None:
+        await asyncio.gather(*[ listener.start() for listener in self._create_listeners() ])
+
+    async def _stop_listeners(self) -> None:
+        await asyncio.gather(*[ listener.stop() for listener in self._create_listeners() ])
+
     async def _run_workflow(self, task_id: str, workflow_id: Optional[str], input: Dict[str, Any]) -> TaskState:
         state = TaskState(task_id=task_id, status="processing")
         with self.task_states_lock:
@@ -138,15 +110,10 @@ class BaseController(ABC):
     def _create_components(self) -> List[BaseComponent]:
         return [ create_component(component_id, config, self.env, self.daemon) for component_id, config in self.components.items() ]
     
+    def _create_listeners(self) -> List[BaseListener]:
+        return [ create_listener(config, self.env, self.daemon) for config in self.listeners ]
+    
     def _create_workflow(self, workflow_id: Optional[str]) -> Workflow:
         return create_workflow(*WorkflowResolver(self.workflows).resolve(workflow_id), self.components, self.env)
 
-    @abstractmethod
-    async def _serve(self) -> None:
-        pass
-
-    @abstractmethod
-    async def _shutdown(self) -> None:
-        pass
-
 ControllerEngineMap: Dict[ControllerType, Type[BaseController]] = {}

{model_compose-0.0.7 → model_compose-0.0.8}/src/mindor/core/controller/engine/http_server.py

@@ -3,6 +3,7 @@ from typing_extensions import Self
 from pydantic import BaseModel
 
 from mindor.dsl.schema.controller import HttpServerControllerConfig
+from mindor.dsl.schema.listener import ListenerConfig
 from mindor.dsl.schema.component import ComponentConfig
 from mindor.dsl.schema.workflow import WorkflowConfig
 from mindor.core.utils.resources import StreamResource 
@@ -35,8 +36,8 @@ class TaskResult(BaseModel):
         )
 
 class HttpServerController(BaseController):
-    def __init__(self, config: HttpServerControllerConfig, components: Dict[str, ComponentConfig], workflows: Dict[str, WorkflowConfig], env: Dict[str, str], daemon: bool):
-        super().__init__(config, components, workflows, env, daemon)
+    def __init__(self, config: HttpServerControllerConfig, components: Dict[str, ComponentConfig], listeners: List[ListenerConfig], workflows: Dict[str, WorkflowConfig], env: Dict[str, str], daemon: bool):
+        super().__init__(config, components, listeners, workflows, env, daemon)
         
         self.server: Optional[uvicorn.Server] = None
         self.app: FastAPI = FastAPI()

{model_compose-0.0.7 → model_compose-0.0.8}/src/mindor/core/controller/engine/mcp_server.py

@@ -1,12 +1,13 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.controller import McpServerControllerConfig
+from mindor.dsl.schema.listener import ListenerConfig
 from mindor.dsl.schema.component import ComponentConfig
 from mindor.dsl.schema.workflow import WorkflowConfig
 from .base import BaseController, ControllerType, ControllerEngineMap
 
 class McpServerController(BaseController):
-    def __init__(self, config: McpServerControllerConfig, components: Dict[str, ComponentConfig], workflows: Dict[str, WorkflowConfig], env: Dict[str, str], daemon: bool):
-        super().__init__(config, components, workflows, env, daemon)
+    def __init__(self, config: McpServerControllerConfig, components: Dict[str, ComponentConfig], listeners: List[ListenerConfig], workflows: Dict[str, WorkflowConfig], env: Dict[str, str], daemon: bool):
+        super().__init__(config, components, listeners, workflows, env, daemon)
 
     async def _serve(self) -> None:
         pass

model_compose-0.0.8/src/mindor/core/listener/__init__.py

@@ -0,0 +1,2 @@
+from .listener import *
+from .engine import HttpCallbackListener

model_compose-0.0.8/src/mindor/core/listener/engine/base.py

@@ -0,0 +1,29 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.listener import ListenerConfig, ListenerType
+from mindor.core.services import AsyncService
+from mindor.core.utils.workqueue import WorkQueue
+
+class BaseListener(AsyncService):
+    def __init__(self, config: ListenerConfig, env: Dict[str, str], daemon: bool):
+        super().__init__(daemon)
+
+        self.config: ListenerConfig = config
+        self.env: Dict[str, str] = env
+        self.queue: Optional[WorkQueue] = None
+
+        # if self.config.max_concurrent_count > 0:
+        #     self.queue = WorkQueue(self.config.max_concurrent_count, self._run_workflow)
+
+    async def _start(self) -> None:
+        if self.queue:
+            await self.queue.start()
+
+        await super()._start()
+
+    async def _stop(self) -> None:
+        if self.queue:
+            await self.queue.stop()
+
+        await super()._stop()
+
+ListenerEngineMap: Dict[ListenerType, Type[BaseListener]] = {}

model_compose-0.0.8/src/mindor/core/listener/engine/http_callback.py

@@ -0,0 +1,121 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Iterator, Any
+
+from mindor.dsl.schema.listener import HttpCallbackListenerConfig, HttpCallbackConfig
+from mindor.core.utils.http_headers import parse_options_header, get_header_value
+from mindor.core.utils.template import TemplateRenderer
+from .base import BaseListener, ListenerType, ListenerEngineMap
+
+from fastapi import FastAPI, APIRouter, Body, HTTPException, Request
+from fastapi.responses import Response, JSONResponse
+from threading import Lock
+import asyncio, uvicorn
+
+_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]):
+        self.body: Optional[Any] = body
+        self.query: Optional[Dict[str, str]] = query
+        self.bulk: bool = bulk
+        self.item_at: Optional[str] = item_at
+        self.renderer: TemplateRenderer = TemplateRenderer(self._resolve_source)
+
+    def items(self) -> Iterator["HttpCallbackContext"]:
+        for item in self._items():
+            yield HttpCallbackContext(item, self.query, False, None)
+
+    def render_template(self, template: str) -> Any:
+        return self.renderer.render(template)
+
+    def _items(self) -> List[Any]:
+        item = self.renderer.render(self.item_at) if self.item_at 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.")
+            return item
+
+        return [ item ]
+
+    def _resolve_source(self, key: str) -> Any:
+        if key == "body" or key == "item":
+            return self.body
+        if key == "query":
+            return self.query
+        raise KeyError(f"Unknown source: {key}")
+
+class HttpCallbackListener(BaseListener):
+    def __init__(self, config: HttpCallbackListenerConfig, env: Dict[str, str], daemon: bool):
+        super().__init__(config, env, daemon)
+        
+        self.server: Optional[uvicorn.Server] = None
+        self.app: FastAPI = FastAPI()
+        self.router: APIRouter = APIRouter()
+
+        self._configure_routes()
+        self.app.include_router(self.router, prefix=self.config.base_path)
+
+    def _configure_routes(self):
+        for callback in self.config.callbacks:
+            self.router.add_api_route(
+                path=callback.path,
+                endpoint=self._make_callback_handler(callback),
+                methods=[callback.method],
+                name=f"callback_{callback.path.strip('/').replace('/', '_')}",
+            )
+
+    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)
+
+            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
+
+                if future:
+                    future.set_result(item.render_template(callback.result) if callback.result else item.body)
+                    self._remove_pending_future(action_id)
+
+            return Response()
+
+        return handler
+
+    async def _parse_request_content(self, request: Request) -> Any:
+        content_type, _ = parse_options_header(request.headers.get("Content-Type", ""))
+
+        if content_type == "application/json":
+            return await request.json()
+
+        if content_type.startswith("text/"):
+            return str(await request.body())
+
+        return await request.body()
+
+    async def _serve(self) -> None:
+        self.server = uvicorn.Server(uvicorn.Config(
+            self.app, 
+            host=self.config.host, 
+            port=self.config.port, 
+            log_level="info"
+        ))
+        await self.server.serve()
+ 
+    async def _shutdown(self) -> None:
+        self.server.should_exit = True
+
+    def _get_pending_future(self, id: str) -> Optional[asyncio.Future]:
+        with _pending_futures_lock:
+            return _pending_futures.get(id)
+
+    def _remove_pending_future(self, id: str) -> None:
+        with _pending_futures_lock:
+            _pending_futures.pop(id, None)
+
+    @classmethod
+    def register_pending_future(cls, id: str, future: asyncio.Future) -> None:
+        with _pending_futures_lock:
+            _pending_futures[id] = future
+
+ListenerEngineMap[ListenerType.HTTP_CALLBACK] = HttpCallbackListener

{model_compose-0.0.7 → model_compose-0.0.8}/src/mindor/core/listener/listener.py

@@ -2,8 +2,8 @@ from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annot
 from mindor.dsl.schema.listener import ListenerConfig
 from .engine import BaseListener, ListenerEngineMap
 
-def create_listener(config: ControllerConfig, env: Dict[str, str]) -> BaseListener:
+def create_listener(config: ListenerConfig, env: Dict[str, str], daemon: bool) -> BaseListener:
     try:
-        return ListenerEngineMap[config.type](config, env)
+        return ListenerEngineMap[config.type](config, env, daemon)
     except KeyError:
         raise ValueError(f"Unsupported listener type: {config.type}")

model_compose-0.0.8/src/mindor/core/services/__init__.py

@@ -0,0 +1,2 @@
+from .async_service import *
+

model_compose-0.0.8/src/mindor/core/services/async_service.py

@@ -0,0 +1,66 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Any
+from abc import ABC, abstractmethod
+from threading import Thread
+import asyncio
+
+class AsyncService(ABC):
+    def __init__(self, daemon: bool):
+        self.daemon: bool = daemon
+        self.started: bool = False
+
+        self.thread: Optional[Thread] = None
+        self.thread_loop: Optional[asyncio.AbstractEventLoop] = None
+        self.daemon_task: Optional[asyncio.Task] = None
+
+    async def start(self, background: bool = False) -> None:
+        if background:
+            def _start_in_thread():
+                self.thread_loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(self.thread_loop)
+                self.thread_loop.run_until_complete(self._start())
+    
+            self.thread = Thread(target=_start_in_thread)
+            self.thread.start()
+        else:
+            await self._start()
+
+    async def stop(self) -> None:
+        if self.thread:
+            future = asyncio.run_coroutine_threadsafe(self._stop(), self.thread_loop)
+            future.result()
+            self.thread_loop.close()
+            self.thread_loop = None
+            self.thread.join()
+            self.thread = None
+        else:
+            await self._stop()
+
+    async def wait_until_stopped(self) -> None:
+        if self.thread:
+            self.thread.join()
+
+        if self.daemon_task:
+            await self.daemon_task
+
+    async def _start(self) -> None:
+        self.started = True
+
+        if self.daemon:
+            if not self.thread:
+                self.daemon_task = asyncio.create_task(self._serve())
+            else:
+                await self._serve()
+
+    async def _stop(self) -> None:
+        if self.daemon:
+            await self._shutdown()
+
+        self.started = False
+
+    @abstractmethod
+    async def _serve(self) -> None:
+        pass
+
+    @abstractmethod
+    async def _shutdown(self) -> None:
+        pass

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

@@ -1,4 +1,4 @@
-from typing import Callable, Dict, List, Any
+from typing import Callable, Dict, List, Optional, Any
 import re
 
 class TemplateRenderer:
@@ -8,7 +8,7 @@ class TemplateRenderer:
             "placeholder": re.compile(
                 r"""\$\{                   # ${ 
                     ([a-zA-Z_][\w\-]*)     # key: input, env, etc.
-                    \.([^\|\}]+)           # path: key, key.path[0], etc.
+                    (?:\.([^\|\}]+))?      # path: key, key.path[0], etc.
                     (?:\s*\|\s*([^\}]+))?  # default value after `|`
                 \}""",                     # }
                 re.VERBOSE,
@@ -28,19 +28,22 @@ class TemplateRenderer:
             return [ self._render_element(item) for item in element ]
         return element
 
-    def _render_text(self, text: str) -> str:
-        def replace(match: re.Match) -> str:
-            key, path, default = match.group(1), match.group(2), match.group(3)
+    def _render_text(self, text: str) -> Any:
+        match = self.patterns["placeholder"].search(text)
+        if match:
+            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)
-                return str(value if value is not None else (default or ""))
+                if text != placeholder:
+                    return text.replace(placeholder, value)
+                return value
             except Exception:
                 return default or ""
-        return self.patterns["placeholder"].sub(replace, text)
+        return text
 
-    def _resolve_by_path(self, source: Any, path: str) -> Any:
-        parts: List[str] = self.patterns["keypath"].findall(path)
+    def _resolve_by_path(self, source: Any, path: Optional[str]) -> Any:
+        parts: List[str] = self.patterns["keypath"].findall(path) if path else []
         current = source
         for part in parts:
             if isinstance(current, dict) and not part.startswith("["):

{model_compose-0.0.7 → model_compose-0.0.8}/src/mindor/core/workflow/workflow.py

@@ -85,7 +85,7 @@ class WorkflowRunner:
         running_job_ids: Set[str] = set()
         completed_job_ids: Set[str] = set()
         scheduled_job_tasks: Dict[str, asyncio.Task] = {}
-        output: Any = {}
+        output: Any = None
 
         while pending_jobs:
             runnable_jobs = [ job for job in pending_jobs.values() if self._can_run_job(job, running_job_ids, completed_job_ids) ]
@@ -107,8 +107,10 @@ class WorkflowRunner:
                 context.complete_job(completed_job_id, completed_job_output)
 
                 if self._is_terminal_job(completed_job_id):
-                    output = completed_job_output
-                    # output.update(completed_job_output)
+                    if isinstance(output, dict) and isinstance(completed_job_output, dict):
+                        output.update(completed_job_output)
+                    else:
+                        output = completed_job_output
 
                 running_job_ids.remove(completed_job_id)
                 completed_job_ids.add(completed_job_id)
@@ -136,10 +138,10 @@ class Workflow:
 
         output = await runner.run(context)
 
-        if not self.config.output:
-            return output
+        if output:
+            context.register_source("output", output)
         
-        return context.render_template(self.config.output)
+        return context.render_template(self.config.output) if self.config.output else output
 
     def validate(self) -> None:
         JobGraphValidator(self.config.jobs).validate()

{model_compose-0.0.7 → model_compose-0.0.8}/src/mindor/dsl/schema/action/impl/common.py

@@ -2,5 +2,5 @@ from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annot
 from pydantic import BaseModel, Field
 
 class CommonActionConfig(BaseModel):
-    output: Optional[Dict[str, Any]] = Field(default_factory=dict)
+    output: Optional[Any] = None
     default: bool = False

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

@@ -22,7 +22,7 @@ class PollingCompletionConfig(CommonCompletionConfig):
     timeout: Optional[str] = None
 
     @model_validator(mode="before")
-    def validate_endpoint_or_path(cls, values):
+    def validate_endpoint_or_path(cls, values: Dict[str, Any]):
         if bool(values.get("endpoint")) == bool(values.get("path")):
             raise ValueError("Either 'endpoint' or 'path' must be set, but not both.")
         return values
@@ -46,7 +46,7 @@ class HttpClientActionConfig(CommonActionConfig):
     completion: Optional[HttpClientCompletionConfig] = None
 
     @model_validator(mode="before")
-    def validate_endpoint_or_path(cls, values):
+    def validate_endpoint_or_path(cls, values: Dict[str, Any]):
         if bool(values.get("endpoint")) == bool(values.get("path")):
             raise ValueError("Either 'endpoint' or 'path' must be set, but not both.")
         return values

{model_compose-0.0.7 → model_compose-0.0.8}/src/mindor/dsl/schema/component/impl/http_client.py

@@ -11,7 +11,7 @@ class HttpClientComponentConfig(CommonComponentConfig):
     actions: Optional[Dict[str, HttpClientActionConfig]] = Field(default_factory=dict)
     
     @model_validator(mode="before")
-    def inflate_single_action(cls, values):
+    def inflate_single_action(cls, values: Dict[str, Any]):
         if "actions" not in values:
             action_keys = set(HttpClientActionConfig.model_fields.keys())
             if any(k in values for k in action_keys):

{model_compose-0.0.7 → model_compose-0.0.8}/src/mindor/dsl/schema/compose.py

@@ -4,23 +4,33 @@ from pydantic import model_validator
 
 from .controller import ControllerConfig
 from .component import ComponentConfig
+from .listener import ListenerConfig
 from .workflow import WorkflowConfig
 
 class ComposeConfig(BaseModel):
     controller: ControllerConfig
     components: Dict[str, ComponentConfig] = Field(default_factory=dict)
+    listeners: List[ListenerConfig] = Field(default_factory=list)
     workflows: Dict[str, WorkflowConfig] = Field(default_factory=dict)
 
     @model_validator(mode="before")
-    def inflate_single_component(cls, values):
+    def inflate_single_component(cls, values: Dict[str, Any]):
         if "components" not in values:
             component_values = values.pop("component", None)
             if component_values:
                 values["components"] = { "__default__": component_values }
         return values
+    
+    @model_validator(mode="before")
+    def inflate_single_listener(cls, values: Dict[str, Any]):
+        if "listeners" not in values:
+            listener_values = values.pop("listener", None)
+            if listener_values:
+                values["listeners"] = [ listener_values ]
+        return values
 
     @model_validator(mode="before")
-    def inflate_single_workflow(cls, values):
+    def inflate_single_workflow(cls, values: Dict[str, Any]):
         if "workflows" not in values:
             workflow_values = values.pop("workflow", None)
             if workflow_values: 

{model_compose-0.0.7 → model_compose-0.0.8}/src/mindor/dsl/schema/listener/impl/common.py

@@ -5,3 +5,4 @@ from .types import ListenerType
 class CommonListenerConfig(BaseModel):
     type: ListenerType
     runtime: Literal[ "docker", "native" ] = "native"
+    max_concurrent_count: int = 0

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

@@ -5,9 +5,11 @@ from .common import ListenerType, CommonListenerConfig
 
 class HttpCallbackConfig(BaseModel):
     path: str
-    method: Literal[ "GET", "POST", "PUT", "DELETE", "PATCH" ] = "GET"
+    method: Literal[ "GET", "POST", "PUT", "DELETE", "PATCH" ] = "POST"
     bulk: bool = False
+    item_at: Optional[str] = None
     identify_by: str
+    result: Optional[Any] = None
 
 class HttpCallbackListenerConfig(CommonListenerConfig):
     type: Literal[ListenerType.HTTP_CALLBACK]
@@ -17,7 +19,7 @@ class HttpCallbackListenerConfig(CommonListenerConfig):
     callbacks: Optional[List[HttpCallbackConfig]] = Field(default_factory=list)
 
     @model_validator(mode="before")
-    def inflate_single_callback(cls, values):
+    def inflate_single_callback(cls, values: Dict[str, Any]):
         if "callbacks" not in values:
             callback_keys = set(HttpCallbackConfig.model_fields.keys())
             if any(k in values for k in callback_keys):

{model_compose-0.0.7 → model_compose-0.0.8}/src/mindor/dsl/schema/workflow.py

@@ -6,18 +6,18 @@ from .component import ComponentConfig
 class JobConfig(BaseModel):
     component: Optional[Union[ str, ComponentConfig ]] = "__default__"
     action: Optional[str] = "__default__"
-    input: Optional[Dict[str, Any]] = Field(default_factory=dict)
-    output: Optional[Dict[str, Any]] = Field(default_factory=dict)
+    input: Optional[Any] = None
+    output: Optional[Any] = None
     depends_on: Optional[List[str]] = Field(default_factory=list)
 
 class WorkflowConfig(BaseModel):
     description: Optional[str] = None
     jobs: Optional[Dict[str, JobConfig]] = Field(default_factory=dict)
-    output: Optional[Dict[str, Any]] = Field(default_factory=dict)
+    output: Optional[Any] = None
     default: bool = False
 
     @model_validator(mode="before")
-    def inflate_single_job(cls, values):
+    def inflate_single_job(cls, values: Dict[str, Any]):
         if "jobs" not in values:
             job_keys = set(JobConfig.model_fields.keys())
             if any(k in values for k in job_keys):

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.0.7
+Version: 0.0.8
 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.7 → model_compose-0.0.8}/src/model_compose.egg-info/SOURCES.txt

@@ -28,6 +28,8 @@ src/mindor/core/listener/engine/base.py
 src/mindor/core/listener/engine/http_callback.py
 src/mindor/core/runtime/__init__.py
 src/mindor/core/runtime/env.py
+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_headers.py

model_compose-0.0.7/src/mindor/core/listener/engine/base.py

@@ -1,13 +0,0 @@
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-
-from mindor.dsl.schema.listener import ListenerConfig, ListenerType
-from mindor.core.listener import BaseListener, create_listener
-
-class BaseListener(ABC):
-    def __init__(self, config: ListenerConfig, env: Dict[str, str]):
-        self.config: ListenerConfig = config
-        self.env: Dict[str, str] = env
-
-ListenerEngineMap: Dict[ListenerType, Type[BaseListener]] = {}

model_compose-0.0.7/src/mindor/core/listener/engine/http_callback.py

@@ -1,37 +0,0 @@
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
-from typing_extensions import Self
-from pydantic import BaseModel
-
-from mindor.dsl.schema.listener import HttpCallbackListenerConfig
-from .base import BaseListener, ListenerType, ListenerEngineMap
-
-from fastapi import FastAPI, APIRouter, Body, HTTPException
-import uvicorn
-
-class HttpCallbackListener(BaseListener):
-    def __init__(self, config: HttpCallbackListenerConfig, env: Dict[str, str]):
-        super().__init__(config, env)
-        
-        self.server: Optional[uvicorn.Server] = None
-        self.app: FastAPI = FastAPI()
-        self.router: APIRouter = APIRouter()
-
-        self._configure_routes()
-        self.app.include_router(self.router, prefix=self.config.base_path)
-
-    def _configure_routes(self):
-        pass
-
-    async def _serve(self) -> None:
-        self.server = uvicorn.Server(uvicorn.Config(
-            self.app, 
-            host=self.config.host, 
-            port=self.config.port, 
-            log_level="info"
-        ))
-        await self.server.serve()
- 
-    async def _shutdown(self) -> None:
-        self.server.should_exit = True
-
-ListenerEngineMap[ListenerType.HTTP_CALLBACK] = HttpCallbackListener

model_compose-0.0.7/src/mindor/dsl/schema/listener/__init__.py

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