model-compose 0.4.9__tar.gz → 0.4.10__tar.gz

{model_compose-0.4.9/src/model_compose.egg-info → model_compose-0.4.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.4.9
+Version: 0.4.10
 Summary: model-compose: Declarative AI Model and Workflow Orchestrator
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT
@@ -65,6 +65,26 @@ pip install -e .
 
 ---
 
+## 📚 Documentation
+
+**📖 [Complete User Guide](docs/user-guide/00-table-of-contents.md)**
+
+Need help getting started or want to explore advanced features? Check out our comprehensive user guide:
+
+- **🌍 English**: [User Guide](docs/user-guide/00-table-of-contents.md)
+- **🇰🇷 한국어**: [사용자 가이드](docs/user-guide/ko/00-table-of-contents.md)
+
+The guide covers everything from basic concepts to advanced workflows, including:
+- Getting started with model-compose
+- Component and workflow configuration
+- Local AI models and training
+- Streaming mode and variable binding
+- System integration with listeners and gateways
+- Deployment strategies
+- Practical examples and troubleshooting
+
+---
+
 ## 🚀 How to Run
 
 **model-compose** provides a CLI interface to launch and manage your AI workflows — inspired by `docker-compose`.
@@ -194,35 +214,7 @@ This minimal example defines a simple workflow that calls the OpenAI ChatGPT API
 
 You can easily expand this example by adding more components (e.g., text-to-speech, image generation) and connecting them through additional jobs.
 
-#### 📡 Listener Example
-
-```
-listener:
-  type: http-callback
-  port: 8090
-  base_path: /callbacks
-  callbacks:
-    - path: /chat-ai
-      method: POST
-      item: ${body.data}
-      identify_by: ${item.task_id}
-      result: ${item.choices[0].message.content}
-```
-
-This listener sets up an HTTP callback endpoint at `http://localhost:8090/callbacks/chat-ai` to handle asynchronous responses from an external service that behaves like ChatGPT but supports delayed or push-based results. This is useful when integrating with services that notify results via webhook-style callbacks.
-
-#### 🌐 Gateway Example
-
-```
-gateway:
-  type: http-tunnel
-  driver: ngrok
-  port: 8090
-```
-
-This gateway configuration exposes the local listener defined above to the public internet using an HTTP tunnel powered by ngrok. It forwards incoming traffic from a secure, public URL (e.g., `https://abc123.ngrok.io`) directly to your local callback endpoint at `http://localhost:8090`. This is essential when integrating with third-party services that need to push data back to your workflow via webhooks or asynchronous callbacks.
-
-> 📁 For more example model-compose.yml configurations, check the [examples directory](examples) in the source code.
+> 📁 For more example configurations including listeners, gateways, and advanced workflows, check the [examples directory](examples) or refer to the [User Guide](docs/user-guide/00-table-of-contents.md).
 
 ---
 ## 🖥 Web UI

{model_compose-0.4.9 → model_compose-0.4.10}/README.md

@@ -41,6 +41,26 @@ pip install -e .
 
 ---
 
+## 📚 Documentation
+
+**📖 [Complete User Guide](docs/user-guide/00-table-of-contents.md)**
+
+Need help getting started or want to explore advanced features? Check out our comprehensive user guide:
+
+- **🌍 English**: [User Guide](docs/user-guide/00-table-of-contents.md)
+- **🇰🇷 한국어**: [사용자 가이드](docs/user-guide/ko/00-table-of-contents.md)
+
+The guide covers everything from basic concepts to advanced workflows, including:
+- Getting started with model-compose
+- Component and workflow configuration
+- Local AI models and training
+- Streaming mode and variable binding
+- System integration with listeners and gateways
+- Deployment strategies
+- Practical examples and troubleshooting
+
+---
+
 ## 🚀 How to Run
 
 **model-compose** provides a CLI interface to launch and manage your AI workflows — inspired by `docker-compose`.
@@ -170,35 +190,7 @@ This minimal example defines a simple workflow that calls the OpenAI ChatGPT API
 
 You can easily expand this example by adding more components (e.g., text-to-speech, image generation) and connecting them through additional jobs.
 
-#### 📡 Listener Example
-
-```
-listener:
-  type: http-callback
-  port: 8090
-  base_path: /callbacks
-  callbacks:
-    - path: /chat-ai
-      method: POST
-      item: ${body.data}
-      identify_by: ${item.task_id}
-      result: ${item.choices[0].message.content}
-```
-
-This listener sets up an HTTP callback endpoint at `http://localhost:8090/callbacks/chat-ai` to handle asynchronous responses from an external service that behaves like ChatGPT but supports delayed or push-based results. This is useful when integrating with services that notify results via webhook-style callbacks.
-
-#### 🌐 Gateway Example
-
-```
-gateway:
-  type: http-tunnel
-  driver: ngrok
-  port: 8090
-```
-
-This gateway configuration exposes the local listener defined above to the public internet using an HTTP tunnel powered by ngrok. It forwards incoming traffic from a secure, public URL (e.g., `https://abc123.ngrok.io`) directly to your local callback endpoint at `http://localhost:8090`. This is essential when integrating with third-party services that need to push data back to your workflow via webhooks or asynchronous callbacks.
-
-> 📁 For more example model-compose.yml configurations, check the [examples directory](examples) in the source code.
+> 📁 For more example configurations including listeners, gateways, and advanced workflows, check the [examples directory](examples) or refer to the [User Guide](docs/user-guide/00-table-of-contents.md).
 
 ---
 ## 🖥 Web UI

{model_compose-0.4.9 → model_compose-0.4.10}/pyproject.toml

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

{model_compose-0.4.9 → model_compose-0.4.10}/src/mindor/cli/compose.py

@@ -1,11 +1,18 @@
-import click
-import json
+from typing import Optional, List
+import importlib.metadata
 from pathlib import Path
+import click
 import asyncio
+import json
 
-from mindor.dsl.loader import load_compose_config
-from mindor.core.runtime.env import load_env_files, merge_env_data
-from mindor.core.compose import *
+def _load_compose_config(config_files: List[Path], env_files: List[Path], env_data: List[str]):
+    from mindor.dsl.loader import load_compose_config
+    from mindor.core.runtime.env import load_env_files, merge_env_data
+
+    env = load_env_files(".", env_files or [])
+    env = merge_env_data(env, env_data)
+
+    return load_compose_config(".", config_files, env)
 
 @click.group()
 @click.option(
@@ -13,6 +20,10 @@ from mindor.core.compose import *
     type=click.Path(exists=True, dir_okay=False, path_type=Path),
     help="Compose configuration files."
 )
+@click.version_option(
+    version=importlib.metadata.version("model-compose"),
+    message="%(prog)s %(version)s"
+)
 @click.pass_context
 def compose_command(ctx: click.Context, config_files: List[Path]) -> None:
     """model-compose"""
@@ -34,18 +45,17 @@ def compose_command(ctx: click.Context, config_files: List[Path]) -> None:
 @click.option("--verbose", "-v", is_flag=True, help="Enable verbose output.")
 @click.pass_context
 def up_command(
-    ctx: click.Context, 
+    ctx: click.Context,
     detach: bool,
     env_files: List[Path],
     env_data: List[str],
     verbose: bool
 ) -> None:
+    from mindor.core.compose import launch_services
     config_files = ctx.obj.get("config_files", [])
     async def _async_command():
         try:
-            env = load_env_files(".", env_files or [])
-            env = merge_env_data(env, env_data)
-            config = load_compose_config(".", config_files, env)
+            config = _load_compose_config(config_files, env_files, env_data)
             await launch_services(config, detach, verbose)
         except Exception as e:
             click.echo(f"❌ {e}", err=True)
@@ -70,12 +80,11 @@ def down_command(
     env_data: List[str],
     verbose: bool
 ) -> None:
+    from mindor.core.compose import terminate_services
     config_files = ctx.obj.get("config_files", [])
     async def _async_command():
         try:
-            env = load_env_files(".", env_files or [])
-            env = merge_env_data(env, env_data)
-            config = load_compose_config(".", config_files, env)
+            config = _load_compose_config(config_files, env_files, env_data)
             await terminate_services(config, verbose)
         except Exception as e:
             click.echo(f"❌ {e}", err=True)
@@ -100,12 +109,11 @@ def start_command(
     env_data: List[str],
     verbose: bool
 ) -> None:
+    from mindor.core.compose import start_services
     config_files = ctx.obj.get("config_files", [])
     async def _async_command():
         try:
-            env = load_env_files(".", env_files or [])
-            env = merge_env_data(env, env_data)
-            config = load_compose_config(".", config_files, env)
+            config = _load_compose_config(config_files, env_files, env_data)
             await start_services(config, verbose)
         except Exception as e:
             click.echo(f"❌ {e}", err=True)
@@ -130,12 +138,11 @@ def stop_command(
     env_data: List[str],
     verbose: bool
 ) -> None:
+    from mindor.core.compose import stop_services
     config_files = ctx.obj.get("config_files", [])
     async def _async_command():
         try:
-            env = load_env_files(".", env_files or [])
-            env = merge_env_data(env, env_data)
-            config = load_compose_config(".", config_files, env)
+            config = _load_compose_config(config_files, env_files, env_data)
             await stop_services(config, verbose)
         except Exception as e:
             click.echo(f"❌ {e}", err=True)
@@ -176,12 +183,11 @@ def run_command(
     output_path: Optional[Path],
     verbose: bool
 ) -> None:
+    from mindor.core.compose import run_workflow
     config_files = ctx.obj.get("config_files", [])
     async def _async_command():
         try:
-            env = load_env_files(".", env_files or [])
-            env = merge_env_data(env, env_data)
-            config = load_compose_config(".", config_files, env)
+            config = _load_compose_config(config_files, env_files, env_data)
             input = json.loads(input_json) if input_json else {}
             state = await run_workflow(config, workflow_id or "__default__", input, output_path, verbose)
             if isinstance(state.output, (dict, list)) or state.error:

{model_compose-0.4.9 → model_compose-0.4.10}/src/mindor/core/controller/base.py

@@ -23,7 +23,7 @@ from .runtime.native import NativeRuntimeLauncher
 from .runtime.docker import DockerRuntimeLauncher
 from threading import Lock
 from pathlib import Path
-import asyncio, ulid, os
+import asyncio, ulid, os, threading
 
 class TaskStatus(str, Enum):
     PENDING    = "pending"
@@ -39,6 +39,19 @@ class TaskState:
     error: Optional[Any] = None
 
 class ControllerService(AsyncService):
+    _shared_instance: Optional["ControllerService"] = None
+    _shared_instance_lock = threading.Lock()
+    
+    def __new__(cls, *args, **kwargs):
+        with cls._shared_instance_lock:
+            if cls._shared_instance is None:
+                cls._shared_instance = super().__new__(cls, args, kwargs)
+        return cls._shared_instance
+
+    @classmethod
+    def get_shared_instance(cls) -> Optional["ControllerService"]:
+        return cls._shared_instance
+
     def __init__(
         self,
         config: ControllerConfig,

{model_compose-0.4.9 → model_compose-0.4.10}/src/mindor/core/controller/services/http_server.py

@@ -42,6 +42,10 @@ class TaskResult(BaseModel):
             error=instance.error
         )
 
+    @classmethod
+    def to_dict(cls, instance: TaskState) -> Dict[str, Any]:
+        return cls.from_instance(instance).model_dump(exclude_none=True)
+
 class WorkflowVariableResult(BaseModel):
     name: Optional[str]
     type: str
@@ -83,6 +87,10 @@ class WorkflowSimpleResult(BaseModel):
             default=instance.default or None
         )
 
+    @classmethod
+    def to_dict(cls, instance: WorkflowSchema) -> Dict[str, Any]:
+        return cls.from_instance(instance).model_dump(exclude_none=True)
+
 class WorkflowSchemaResult(BaseModel):
     workflow_id: str
     title: Optional[str] = None
@@ -102,6 +110,10 @@ class WorkflowSchemaResult(BaseModel):
             default=instance.default or None
         )
 
+    @classmethod
+    def to_dict(cls, instance: WorkflowSchema) -> Dict[str, Any]:
+        return cls.from_instance(instance).model_dump(exclude_none=True)
+
     @classmethod
     def _to_variable_result(cls, variable: Union[WorkflowVariableConfig, WorkflowVariableGroupConfig]) -> Union[WorkflowVariableResult, WorkflowVariableGroupResult]:
         if isinstance(variable, WorkflowVariableGroupConfig):
@@ -176,6 +188,10 @@ class HttpServerController(ControllerService):
             
             return self._render_task_response(state, output_only)
 
+        @self.router.get("/health")
+        async def health_check():
+            return JSONResponse(content={ "status": "ok" })
+
     async def _serve(self) -> None:
         self.server = uvicorn.Server(uvicorn.Config(
             self.app,
@@ -231,7 +247,7 @@ class HttpServerController(ControllerService):
         return self._render_task_state(state)
 
     def _render_task_state(self, state: TaskState) -> Response:
-        return JSONResponse(content=TaskResult.from_instance(state).model_dump(exclude_none=True))
+        return JSONResponse(content=TaskResult.to_dict(state))
 
     def _render_task_output(self, state: TaskState) -> Response:
         if state.status in [ TaskStatus.PENDING, TaskStatus.PROCESSING ]:
@@ -279,13 +295,13 @@ class HttpServerController(ControllerService):
 
     def _render_workflow_list(self, workflows: Dict[str, WorkflowSchema]) -> Response:
         return JSONResponse(content=[
-            WorkflowSimpleResult.from_instance(workflow).model_dump(exclude_none=True) for workflow in workflows.values()
+            WorkflowSimpleResult.to_dict(workflow) for workflow in workflows.values()
         ])
 
     def _render_workflow_schemas(self, workflows: Dict[str, WorkflowSchema]) -> Response:
         return JSONResponse(content=[
-            WorkflowSchemaResult.from_instance(workflow).model_dump(exclude_none=True) for workflow in workflows.values()
+            WorkflowSchemaResult.to_dict(workflow) for workflow in workflows.values()
         ])
 
     def _render_workflow_schema(self, workflow: WorkflowSchema) -> Response:
-        return JSONResponse(content=WorkflowSchemaResult.from_instance(workflow).model_dump(exclude_none=True))
+        return JSONResponse(content=WorkflowSchemaResult.to_dict(workflow))

{model_compose-0.4.9 → model_compose-0.4.10}/src/mindor/core/listener/services/__init__.py

@@ -1 +1,2 @@
 from .http_callback import *
+from .http_trigger import *

{model_compose-0.4.9 → model_compose-0.4.10}/src/mindor/core/listener/services/http_callback.py

@@ -1,18 +1,13 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, AsyncIterator, Any
-
 from mindor.dsl.schema.listener import HttpCallbackListenerConfig, HttpCallbackConfig
 from mindor.core.utils.http_request import parse_request_body, parse_options_header
 from mindor.core.utils.renderers import VariableRenderer
 from ..base import ListenerService, ListenerType, register_listener
-
 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: Optional[str]):
         self.body: Optional[Any] = body
@@ -49,6 +44,9 @@ class HttpCallbackContext:
 
 @register_listener(ListenerType.HTTP_CALLBACK)
 class HttpCallbackListener(ListenerService):
+    _pending_futures: Dict[str, asyncio.Future] = {}
+    _pending_futures_lock: Lock = Lock()
+
     def __init__(self, id: str, config: HttpCallbackListenerConfig, daemon: bool):
         super().__init__(id, config, daemon)
         
@@ -86,7 +84,7 @@ class HttpCallbackListener(ListenerService):
                         future.set_exception(RuntimeError(f"Task failed for '{callback_id}'"))
                     self._remove_pending_future(callback_id)
 
-            return Response()
+            return Response(status_code=200)
 
         return _handler
 
@@ -118,14 +116,14 @@ class HttpCallbackListener(ListenerService):
             self.server.should_exit = True
 
     def _get_pending_future(self, id: str) -> Optional[asyncio.Future]:
-        with _pending_futures_lock:
-            return _pending_futures.get(id)
+        with self._pending_futures_lock:
+            return self._pending_futures.get(id)
 
     def _remove_pending_future(self, id: str) -> None:
-        with _pending_futures_lock:
-            _pending_futures.pop(id, None)
+        with self._pending_futures_lock:
+            self._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
+        with cls._pending_futures_lock:
+            cls._pending_futures[id] = future

model_compose-0.4.10/src/mindor/core/listener/services/http_trigger.py

@@ -0,0 +1,129 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, AsyncIterator, Self, Any
+from pydantic import BaseModel
+from mindor.dsl.schema.listener import HttpTriggerListenerConfig, HttpTriggerConfig
+from mindor.core.controller import ControllerService, TaskState
+from mindor.core.utils.http_request import parse_request_body, parse_options_header
+from mindor.core.utils.renderers import VariableRenderer
+from ..base import ListenerService, ListenerType, register_listener
+from fastapi import FastAPI, APIRouter, Body, HTTPException, Request
+from fastapi.responses import Response, JSONResponse
+import asyncio, uvicorn
+
+class TaskResult(BaseModel):
+    task_id: str
+    status: Literal[ "pending", "processing", "completed", "failed" ]
+    output: Optional[Any] = None
+    error: Optional[Any] = None
+
+    @classmethod
+    def from_instance(cls, instance: TaskState) -> Self:
+        return cls(
+            task_id=instance.task_id,
+            status=instance.status,
+            output=instance.output,
+            error=instance.error
+        )
+
+    @classmethod
+    def to_dict(cls, instance: TaskState) -> Dict[str, Any]:
+        return cls.from_instance(instance).model_dump(exclude_none=True)
+
+class HttpTriggerContext:
+    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: Optional[str] = item
+        self.renderer: VariableRenderer = VariableRenderer(self._resolve_source)
+
+    async def items(self) -> AsyncIterator["HttpTriggerContext"]:
+        for item in await self._items():
+            yield HttpTriggerContext(item, self.query, False, None)
+
+    async def render_variable(self, template: str, ignore_files: bool = True) -> Any:
+        return await self.renderer.render(template, ignore_files)
+
+    async def _items(self) -> List[Any]:
+        item = await 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")
+            return item
+
+        return [ item ]
+
+    async def _resolve_source(self, key: str, index: Optional[int]) -> Any:
+        if key == "body" or key == "item":
+            return self.body
+
+        if key == "query":
+            return self.query
+
+        raise KeyError(f"Unknown source: {key}")
+
+@register_listener(ListenerType.HTTP_TRIGGER)
+class HttpTriggerListener(ListenerService):
+    def __init__(self, id: str, config: HttpTriggerListenerConfig, daemon: bool):
+        super().__init__(id, config, daemon)
+
+        self.server: Optional[uvicorn.Server] = None
+        self.app: FastAPI = FastAPI(openapi_url=None, docs_url=None, redoc_url=None)
+        self.router: APIRouter = APIRouter()
+
+        self._configure_routes()
+        self.app.include_router(self.router, prefix=self.config.base_path or "")
+
+    def _configure_routes(self) -> None:
+        for trigger in self.config.triggers:
+            self.router.add_api_route(
+                path=trigger.path,
+                endpoint=self._make_trigger_handler(trigger),
+                methods=[trigger.method],
+                name=f"trigger_{trigger.path.strip('/').replace('/', '_')}",
+            )
+
+    def _make_trigger_handler(self, trigger: HttpTriggerConfig) -> Callable:
+        async def _handler(request: Request) -> Response:
+            controller = ControllerService.get_shared_instance()
+            content_type, _ = parse_options_header(request.headers, "Content-Type")
+            body, query = await parse_request_body(request, content_type), request.query_params
+            context = HttpTriggerContext(body, query, trigger.bulk, trigger.item)
+            states: List[TaskState] = []
+
+            async for item in context.items():
+                workflow_id = await item.render_variable(trigger.workflow)
+                input       = await item.render_variable(trigger.input)
+
+                try:
+                    state = await controller.run_workflow(workflow_id, input, wait_for_completion=False)
+                except Exception as e:
+                    raise HTTPException(status_code=500, detail=f"Failed to trigger workflow: {str(e)}")
+
+                states.append(state)
+
+            return self._render_task_states(states, trigger.bulk)
+
+        return _handler
+
+    def _render_task_states(self, states: List[TaskState], bulk: bool) -> Response:
+        if bulk:
+            return JSONResponse(content=[ TaskResult.to_dict(state) for state in states ])
+        else:
+            return JSONResponse(content=TaskResult.to_dict(states[0]))
+
+    async def _serve(self) -> None:
+        self.server = uvicorn.Server(uvicorn.Config(
+            self.app,
+            host=self.config.host,
+            port=self.config.port,
+            log_level="info"
+        ))
+        try:
+            await self.server.serve()
+        finally:
+            self.server = None
+
+    async def _shutdown(self) -> None:
+        if self.server:
+            self.server.should_exit = True

{model_compose-0.4.9 → model_compose-0.4.10}/src/mindor/dsl/schema/action/impl/datasets/providers/common.py

@@ -11,8 +11,8 @@ class CommonDatasetsLoadActionConfig(CommonDatasetsActionConfig):
     method: Literal[DatasetsActionMethod.LOAD]
     provider: DatasetsProvider = Field(..., description="Datasets provider configuration.")
     split: Optional[str] = Field(default=None, description="Dataset split to load (e.g., 'train', 'test', 'validation').")
-    streaming: bool = Field(default=False, description="Enable streaming mode for large datasets.")
-    keep_in_memory: bool = Field(default=False, description="Keep dataset in memory.")
+    streaming: Union[bool, str] = Field(default=False, description="Enable streaming mode for large datasets.")
+    keep_in_memory: Union[bool, str] = Field(default=False, description="Keep dataset in memory.")
     cache_dir: Optional[str] = Field(default=None, description="Directory to cache downloaded files.")
     save_infos: Union[bool, str] = Field(default=False, description="Save dataset info to cache.")
     fraction: Optional[Union[float, str]] = Field(default=None, description="Fraction of dataset to load.")

{model_compose-0.4.9 → model_compose-0.4.10}/src/mindor/dsl/schema/action/impl/model/impl/common.py

@@ -4,4 +4,4 @@ from pydantic import BaseModel, Field
 from ...common import CommonActionConfig
 
 class CommonModelActionConfig(CommonActionConfig):
-    streaming: Optional[bool] = Field(default=None, description="Whether to enable streaming responses for inference.")
+    streaming: Union[bool, str] = Field(default=None, description="Whether to enable streaming responses for inference.")

{model_compose-0.4.9 → model_compose-0.4.10}/src/mindor/dsl/schema/controller/impl/common.py

@@ -9,7 +9,7 @@ class CommonControllerConfig(BaseModel):
     name: Optional[str] = Field(default=None, description="Name used to identify this controller.")
     type: ControllerType = Field(..., description="Type of controller to run.")
     runtime: RuntimeConfig = Field(..., description="Runtime environment settings.")
-    max_concurrent_count: int = Field(default=1, description="Maximum number of tasks that can be executed concurrently.")
+    max_concurrent_count: int = Field(default=0, description="Maximum number of tasks that can be executed concurrently.")
     threaded: bool = Field(default=False, description="Whether to run tasks in separate threads.")
     webui: Optional[ControllerWebUIConfig] = Field(default=None, description="Configuration for the controller's Web UI interface.")
 

{model_compose-0.4.9 → model_compose-0.4.10}/src/mindor/dsl/schema/listener/impl/__init__.py

@@ -1,2 +1,3 @@
 from .common import *
 from .http_callback import *
+from .http_trigger import *

{model_compose-0.4.9 → model_compose-0.4.10}/src/mindor/dsl/schema/listener/impl/http_callback.py

@@ -4,7 +4,7 @@ from pydantic import model_validator
 from .common import ListenerType, CommonListenerConfig
 
 class HttpCallbackConfig(BaseModel):
-    path: str
+    path: str = Field(..., description="URL path for this callback endpoint.")
     method: Literal[ "GET", "POST", "PUT", "DELETE", "PATCH" ] = Field(default="POST", description="HTTP method this callback endpoint will accept.")
     bulk: Union[bool, str] = Field(default=False, description="Whether this callback handles multiple items in a single request.")
     item: Optional[str] = Field(default=None, description="Field path to extract individual items from the callback payload.")

model_compose-0.4.10/src/mindor/dsl/schema/listener/impl/http_trigger.py

@@ -0,0 +1,27 @@
+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 ListenerType, CommonListenerConfig
+
+class HttpTriggerConfig(BaseModel):
+    path: str = Field(..., description="URL path for this trigger endpoint.")
+    method: Literal["GET", "POST", "PUT", "DELETE", "PATCH"] = Field(default="POST", description="HTTP method this trigger endpoint will accept.")
+    bulk: Union[bool, str] = Field(default=False, description="Whether this trigger handles multiple items in a single request.")
+    item: Optional[str] = Field(default=None, description="Field path to extract individual items from the trigger payload.")
+    workflow: str = Field(..., description="Workflow ID to execute when this endpoint is triggered.")
+    input: Optional[Dict[str, str]] = Field(default=None, description="Workflow input parameters.")
+
+class HttpTriggerListenerConfig(CommonListenerConfig):
+    type: Literal[ListenerType.HTTP_TRIGGER]
+    host: str = Field(default="0.0.0.0", description="Host address to bind the HTTP server to.")
+    port: int = Field(default=8091, ge=1, le=65535, description="Port number on which the HTTP server will listen.")
+    base_path: Optional[str] = Field(default=None, description="Base path prefix for all trigger endpoints.")
+    triggers: List[HttpTriggerConfig] = Field(default_factory=list, description="List of trigger endpoint configurations.")
+
+    @model_validator(mode="before")
+    def inflate_single_trigger(cls, values: Dict[str, Any]):
+        if "triggers" not in values:
+            trigger_keys = set(HttpTriggerConfig.model_fields.keys()) - set(CommonListenerConfig.model_fields.keys())
+            if any(k in values for k in trigger_keys):
+                values["triggers"] = [ { k: values.pop(k) for k in trigger_keys if k in values } ]
+        return values

{model_compose-0.4.9 → model_compose-0.4.10}/src/mindor/dsl/schema/listener/impl/types.py

@@ -2,3 +2,4 @@ from enum import Enum
 
 class ListenerType(str, Enum):
     HTTP_CALLBACK = "http-callback"
+    HTTP_TRIGGER  = "http-trigger"

{model_compose-0.4.9 → model_compose-0.4.10}/src/mindor/dsl/schema/listener/listener.py

@@ -4,7 +4,8 @@ from .impl import *
 
 ListenerConfig = Annotated[
     Union[ 
-        HttpCallbackListenerConfig
+        HttpCallbackListenerConfig,
+        HttpTriggerListenerConfig
     ],
     Field(discriminator="type")
 ]