model-compose 0.1.0__tar.gz → 0.1.2__tar.gz

{model_compose-0.1.0 → model_compose-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.1.0
+Version: 0.1.2
 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
@@ -21,41 +21,28 @@ Requires-Dist: gradio
 Requires-Dist: Pillow
 Dynamic: license-file
 
-# model-compose: Declarative AI Model and Workflow Orchestrator (_part of the Mindor project_)
+# model-compose: Declarative AI Model and Workflow Orchestrator
 
 [![Python Version](https://img.shields.io/badge/python-3.9+-blue.svg)](https://python.org)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](http://makeapullrequest.com)
 
+![Screenshots](docs/images/screenshots.png)
+
 **model-compose** is an open-source, declarative workflow orchestrator inspired by `docker-compose`. It lets you define and run AI model pipelines using simple YAML files — no custom code required. Effortlessly connect external AI services or run local AI models, all within powerful, composable workflows.
 
 ---
 
 ## ✨ Features
 
-#### 🔧 Declarative by Design
-Define complete AI workflows using simple YAML files — no complex scripting required.
-
-#### 🔗 Compose Anything
-Combine multiple AI models, APIs, and tools into a single, unified pipeline.
-
-#### 🧠 Built for Orchestration
-Orchestrate multi-step model interactions with ease. Turn individual API calls into maintainable, end-to-end systems using **model-compose**.
-
-#### 🛠️ Multi-Workflow Support
-Define multiple named workflows in one project. Run them by name or set a default for quick execution.
-
-#### 🧩 Modular Components
-Break down logic into reusable components and jobs. Easily plug, swap, and extend them across workflows.
-
-#### ⚙️ Flexible I/O Routing
-Connect inputs and outputs between jobs using clean, scoped variables - no glue code needed.
-
-#### 🧪 Run Locally, Serve Remotely
-Execute workflows from the CLI or expose them as HTTP or MCP endpoints with an optional Web UI.
-
-#### 📦 Works with Environment Variables
-Easily inject secrets and configuration via `.env` files or environment variables to keep your YAML clean and secure.
+- **Declarative by Design:** Define complete AI workflows using simple YAML files—no complex scripting required.
+- **Compose Anything:** Combine multiple AI models, APIs, and tools into a single, unified pipeline.
+- **Built for Orchestration:**  Orchestrate multi-step model interactions with ease. Transform individual API calls into maintainable, end-to-end systems.
+- **Multi-Workflow Support:** Define multiple named workflows in one project. Run them by name or set a default for quick execution.
+- **Modular Components:** Break down logic into reusable components and jobs. Easily plug, swap, and extend them across workflows.
+- **Flexible I/O Routing:** Connect inputs and outputs between jobs using clean, scoped variables—no glue code needed.
+- **Run Locally, Serve Remotely:** Execute workflows from the CLI or expose them as HTTP or MCP endpoints with an optional Web UI.
+- **Environment Variable Support:** Easily inject secrets and configuration via `.env` files or environment variables to keep your YAML clean and secure.
 
 ---
 
@@ -214,14 +201,14 @@ listener:
   port: 8090
   base_path: /callbacks
   callbacks:
-    - path: /chatgpt
+    - 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/chatgpt` to receive asynchronous responses from a remote ChatGPT-compatible service. It extracts the incoming data from the request body, identifies the task using `task_id`, and stores the final message content from the first choice in the response.
+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
 
@@ -234,7 +221,12 @@ gateway:
 
 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 samples directory in the source code.
+> 📁 For more example model-compose.yml configurations, check the [examples directory](examples) in the source code.
+
+---
+## 🏗 Architecture
+
+![Archtecture Diagram](docs/images/architecture-diagram.png)
 
 ---
 

{model_compose-0.1.0 → model_compose-0.1.2}/README.md

@@ -1,38 +1,25 @@
-# model-compose: Declarative AI Model and Workflow Orchestrator (_part of the Mindor project_)
+# model-compose: Declarative AI Model and Workflow Orchestrator
 
 [![Python Version](https://img.shields.io/badge/python-3.9+-blue.svg)](https://python.org)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](http://makeapullrequest.com)
 
+![Screenshots](docs/images/screenshots.png)
+
 **model-compose** is an open-source, declarative workflow orchestrator inspired by `docker-compose`. It lets you define and run AI model pipelines using simple YAML files — no custom code required. Effortlessly connect external AI services or run local AI models, all within powerful, composable workflows.
 
 ---
 
 ## ✨ Features
 
-#### 🔧 Declarative by Design
-Define complete AI workflows using simple YAML files — no complex scripting required.
-
-#### 🔗 Compose Anything
-Combine multiple AI models, APIs, and tools into a single, unified pipeline.
-
-#### 🧠 Built for Orchestration
-Orchestrate multi-step model interactions with ease. Turn individual API calls into maintainable, end-to-end systems using **model-compose**.
-
-#### 🛠️ Multi-Workflow Support
-Define multiple named workflows in one project. Run them by name or set a default for quick execution.
-
-#### 🧩 Modular Components
-Break down logic into reusable components and jobs. Easily plug, swap, and extend them across workflows.
-
-#### ⚙️ Flexible I/O Routing
-Connect inputs and outputs between jobs using clean, scoped variables - no glue code needed.
-
-#### 🧪 Run Locally, Serve Remotely
-Execute workflows from the CLI or expose them as HTTP or MCP endpoints with an optional Web UI.
-
-#### 📦 Works with Environment Variables
-Easily inject secrets and configuration via `.env` files or environment variables to keep your YAML clean and secure.
+- **Declarative by Design:** Define complete AI workflows using simple YAML files—no complex scripting required.
+- **Compose Anything:** Combine multiple AI models, APIs, and tools into a single, unified pipeline.
+- **Built for Orchestration:**  Orchestrate multi-step model interactions with ease. Transform individual API calls into maintainable, end-to-end systems.
+- **Multi-Workflow Support:** Define multiple named workflows in one project. Run them by name or set a default for quick execution.
+- **Modular Components:** Break down logic into reusable components and jobs. Easily plug, swap, and extend them across workflows.
+- **Flexible I/O Routing:** Connect inputs and outputs between jobs using clean, scoped variables—no glue code needed.
+- **Run Locally, Serve Remotely:** Execute workflows from the CLI or expose them as HTTP or MCP endpoints with an optional Web UI.
+- **Environment Variable Support:** Easily inject secrets and configuration via `.env` files or environment variables to keep your YAML clean and secure.
 
 ---
 
@@ -191,14 +178,14 @@ listener:
   port: 8090
   base_path: /callbacks
   callbacks:
-    - path: /chatgpt
+    - 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/chatgpt` to receive asynchronous responses from a remote ChatGPT-compatible service. It extracts the incoming data from the request body, identifies the task using `task_id`, and stores the final message content from the first choice in the response.
+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
 
@@ -211,7 +198,12 @@ gateway:
 
 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 samples directory in the source code.
+> 📁 For more example model-compose.yml configurations, check the [examples directory](examples) in the source code.
+
+---
+## 🏗 Architecture
+
+![Archtecture Diagram](docs/images/architecture-diagram.png)
 
 ---
 

{model_compose-0.1.0 → model_compose-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.1.0"
+version = "0.1.2"
 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.0 → model_compose-0.1.2}/src/mindor/core/component/engine/http_client.py

@@ -10,8 +10,9 @@ from datetime import datetime, timezone
 import asyncio
 
 class HttpClientPollingCompletion:
-    def __init__(self, base_url: Optional[str], config: HttpClientCompletionConfig):
+    def __init__(self, base_url: Optional[str], headers: Optional[Dict[str, str]], config: HttpClientCompletionConfig):
         self.base_url: Optional[str] = base_url
+        self.headers: Optional[Dict[str, str]] = headers
         self.config: HttpClientCompletionConfig = config
         self.client: HttpClient = HttpClient()
 
@@ -20,7 +21,7 @@ class HttpClientPollingCompletion:
         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.config.headers)
+        headers = await context.render_template({ **self.headers, **self.config.headers })
 
         interval = parse_duration(self.config.interval) if self.config.interval else 5.0
         timeout  = parse_duration(self.config.timeout) if self.config.timeout else 300
@@ -30,8 +31,8 @@ class HttpClientPollingCompletion:
 
         while datetime.now(timezone.utc) < deadline:
             response = await self.client.request(url, method, params, body, headers)
-
             context.register_source("result", response)
+
             status = (await context.render_template(self.config.status)) if self.config.status else response["status"]
 
             if not status:
@@ -67,8 +68,9 @@ class HttpClientCallbackCompletion:
         return await future
 
 class HttpClientAction:
-    def __init__(self, base_url: Optional[str], config: HttpClientActionConfig):
+    def __init__(self, base_url: Optional[str], headers: Optional[Dict[str, str]], config: HttpClientActionConfig):
         self.base_url: Optional[str] = base_url
+        self.headers: Optional[Dict[str, str]] = headers
         self.config: HttpClientActionConfig = config
         self.client: HttpClient = HttpClient()
 
@@ -77,18 +79,14 @@ class HttpClientAction:
         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.config.headers)
+        headers = await context.render_template({ **self.headers, **self.config.headers })
 
         response, result = await self.client.request(url, method, params, body, headers), None
-
-        if response:
-            context.register_source("response", response)
+        context.register_source("response", response)
 
         if self.config.completion:
             result = await self._handle_completion(self.config.completion, context)
-
-            if result:
-                context.register_source("result", result)
+            context.register_source("result", result)
 
         return (await context.render_template(self.config.output)) if self.config.output else (result or response)
 
@@ -100,7 +98,7 @@ class HttpClientAction:
 
     async def _handle_completion(self, completion: HttpClientCompletionConfig, context: ComponentContext) -> Any:
         if completion.type == "polling":
-            return await HttpClientPollingCompletion(self.base_url, completion).run(context)
+            return await HttpClientPollingCompletion(self.base_url, self.headers, completion).run(context)
         
         if completion.type == "callback":
             return await HttpClientCallbackCompletion(completion).run(context)
@@ -118,6 +116,6 @@ class HttpClientComponent(ComponentEngine):
         pass
 
     async def _run(self, action: ActionConfig, context: ComponentContext) -> Any:
-        return await HttpClientAction(self.config.base_url, action).run(context)
+        return await HttpClientAction(self.config.base_url, self.config.headers, action).run(context)
 
 ComponentEngineMap[ComponentType.HTTP_CLIENT] = HttpClientComponent

{model_compose-0.1.0 → model_compose-0.1.2}/src/mindor/core/controller/engine/http_server.py

@@ -109,7 +109,8 @@ class HttpServerController(ControllerEngine):
         await self.server.serve()
  
     async def _shutdown(self) -> None:
-        self.server.should_exit = True
+        if self.server:
+            self.server.should_exit = True
 
     async def _parse_workflow_body(self, request: Request) -> WorkflowTaskRequestBody:
         content_type, _ = parse_options_header(request.headers, "Content-Type")

{model_compose-0.1.0 → model_compose-0.1.2}/src/mindor/core/controller/webui/gradio.py

@@ -1,23 +1,29 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Awaitable, Any
-from mindor.dsl.schema.workflow import WorkflowVariableConfig
+from mindor.dsl.schema.workflow import WorkflowVariableConfig, WorkflowVariableGroupConfig
 from mindor.core.utils.http_client import HttpStreamResource
 from mindor.core.utils.image import load_image_from_stream
 from mindor.core.utils.streaming import Base64StreamResource, save_stream_to_temporary_file
 from .schema import WorkflowSchema
 import gradio as gr
+import json
+
+class ComponentGroup:
+    def __init__(self, group: gr.Component, components: List[gr.Component]):
+        self.group: gr.Component = group
+        self.components: List[gr.Component] = components
 
 class GradioWebUIBuilder:
     def build(self, schema: Dict[str, WorkflowSchema], runner: Callable[[Optional[str], Any], Awaitable[Any]]) -> gr.Blocks:
         with gr.Blocks() as blocks:
             for workflow_id, workflow in schema.items():
-                async def run_workflow(input: Any, workflow_id=workflow_id) -> Any:
+                async def _run_workflow(input: Any, workflow_id=workflow_id) -> Any:
                     return await runner(workflow_id, input)
 
                 if len(schema) > 1:
                     with gr.Tab(label=workflow.name or workflow_id):
-                        self._build_workflow_section(workflow, run_workflow)
+                        self._build_workflow_section(workflow, _run_workflow)
                 else:
-                    self._build_workflow_section(workflow, run_workflow)
+                    self._build_workflow_section(workflow, _run_workflow)
 
         return blocks
 
@@ -38,24 +44,16 @@ class GradioWebUIBuilder:
             if not output_components:
                 output_components = gr.Textbox(label="", lines=8, interactive=False, show_copy_button=True)
 
-            async def run_workflow(*args):
-                input = { variable.name: value for variable, value in zip(workflow.input, args) }
+            async def _run_workflow(*args):
+                input = { variable.name: value if value != "" else None for variable, value in zip(workflow.input, args) }
                 output = await runner(input)
-
-                if workflow.output:
-                    if isinstance(output, dict):
-                        output = [ await self._convert_type(output[variable.name], variable.type, variable.subtype, variable.format) for variable in workflow.output ]
-                        output = output[0] if len(output) == 1 else output
-                    else:
-                        variable = workflow.output[0]
-                        output = await self._convert_type(output, variable.type, variable.subtype, variable.format)
-
-                return output
+                output = await self._flatten_output(output, workflow.output)
+                return output[0] if len(output) == 1 else output
 
             run_button.click(
-                fn=run_workflow,
+                fn=_run_workflow,
                 inputs=input_components,
-                outputs=output_components
+                outputs=self._flatten_output_components(output_components)
             )
 
         return section
@@ -85,7 +83,16 @@ class GradioWebUIBuilder:
         
         return gr.Textbox(label=label, value=default, info=f"Unsupported type: {variable.type}")
 
-    def _build_output_component(self, variable: WorkflowVariableConfig) -> gr.Component:
+    def _build_output_component(self, variable: Union[WorkflowVariableConfig, WorkflowVariableGroupConfig]) -> Union[gr.Component, List[ComponentGroup]]:
+        if isinstance(variable, WorkflowVariableGroupConfig):
+            groups: List[ComponentGroup] = []
+            for index in range(variable.repeat_count if variable.repeat_count != 0 else 100):
+                visible = True if variable.repeat_count != 0 or index == 0 else False
+                with gr.Column(visible=visible) as group:
+                    components = [ self._build_output_component(v) for v in variable.variables ]
+                groups.append(ComponentGroup(group, components))
+            return groups
+
         label = variable.name or ""
         info = variable.description or ""
 
@@ -100,7 +107,34 @@ class GradioWebUIBuilder:
     
         return gr.Textbox(label=label, info=f"Unsupported type: {variable.type}")
 
+    def _flatten_output_components(self, components: List[Union[gr.Component, List[ComponentGroup]]]) -> List[gr.Component]:
+        flattened = []
+        for item in components:
+            if isinstance(item, list):
+                for group in item:
+                    flattened.extend(group.components)
+            else:
+                flattened.append(item)
+        return flattened
+    
+    async def _flatten_output(self, output: Any, variables: List[Union[WorkflowVariableConfig, WorkflowVariableGroupConfig]]) -> Any:
+        flattened = []
+        for variable in variables:
+            if isinstance(variable, WorkflowVariableGroupConfig):
+                group = output[variable.name] if variable.name else output
+                for value in group:
+                    flattened.extend(await self._flatten_output(value, variable.variables))
+            else:
+                value = output[variable.name] if variable.name else output
+                flattened.append(await self._convert_type(value, variable.type, variable.subtype, variable.format))
+        return flattened
+
     async def _convert_type(self, value: Any, type: Optional[str], subtype: Optional[str], format: Optional[str]) -> Any:
+        if type == "string":
+            if isinstance(value, (dict, list)):
+                return json.dumps(value)
+            return str(value)
+        
         if type == "image":
             if format == "base64" and isinstance(value, str):
                 return await load_image_from_stream(Base64StreamResource(value), subtype)

model_compose-0.1.2/src/mindor/core/controller/webui/schema.py

@@ -0,0 +1,198 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel
+from mindor.dsl.schema.workflow import WorkflowConfig, WorkflowVariableConfig, WorkflowVariableGroupConfig
+from mindor.dsl.schema.component import ComponentConfig
+import re, json
+
+class WorkflowVariable:
+    def __init__(self, name: Optional[str], type: str, subtype: Optional[str], format: Optional[str], default: Optional[Any]):
+        self.name: Optional[str] = name
+        self.type: str = type
+        self.subtype: Optional[str] = subtype
+        self.format: Optional[str] = format
+        self.default: Optional[Any] = default
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "name": self.name,
+            "type": self.type,
+            "subtype": self.subtype,
+            "format": self.format,
+            "default": self.default
+        }
+
+    def __eq__(self, other):
+        if not isinstance(other, WorkflowVariable):
+            return False
+        if self.name is None or other.name is None:
+            return False
+        return self.name == other.name
+
+    def __hash__(self):
+        return hash(self.name) if self.name is not None else id(self)
+    
+class WorkflowVariableGroup:
+    def __init__(self, name: Optional[str], variables: List[WorkflowVariable], repeat_count: int):
+        self.name: Optional[str] = name
+        self.variables: List[WorkflowVariable] = variables
+        self.repeat_count: int = repeat_count
+
+class WorkflowVariableResolver:
+    def __init__(self):
+        self.patterns: Dict[str, re.Pattern] = {
+            "variable": re.compile(
+                r"""\$\{                                                             # ${ 
+                    ([a-zA-Z_][^.\s]*)                                               # key: input, env, etc.
+                    (?:\.([^\s\|\}]+))?                                              # path: key, key.path[0], etc.
+                    (?:\s*as\s*([^\s\|\}/;]+)(?:/([^\s\|\};]+))?(?:;([^\s\|\}]+))?)? # type/subtype;format
+                    (?:\s*\|\s*([^\}]+))?                                            # default value after `|`
+                \}""",                                                               # }
+                re.VERBOSE,
+            ),
+            "keypath": re.compile(r"[-_\w]+|\[\d+\]"),
+        }
+
+    def _enumerate_input_variables(self, value: Any, wanted_key: str) -> List[WorkflowVariable]:
+        if isinstance(value, str):
+            variables: List[WorkflowVariable] = []
+
+            for match in self.patterns["variable"].finditer(value):
+                key, path, type, subtype, format, default = match.group(1, 2, 3, 4, 5, 6)
+
+                if type and default:
+                    default = self._parse_as_type(default, type)
+
+                if key == wanted_key:
+                    variables.append(WorkflowVariable(path, type or "string", subtype, format, default))
+
+            return variables
+
+        if isinstance(value, BaseModel):
+            return self._enumerate_input_variables(value.model_dump(exclude_none=True), wanted_key)
+        
+        if isinstance(value, dict):
+            return sum([ self._enumerate_input_variables(v, wanted_key) for v in value.values() ], [])
+
+        if isinstance(value, list):
+            return sum([ self._enumerate_input_variables(v, wanted_key) for v in value ], [])
+        
+        return []
+
+    def _enumerate_output_variables(self, name: Optional[str], value: Any) -> List[WorkflowVariable]:
+        variables: List[WorkflowVariable] = []
+        
+        if isinstance(value, str):
+            for match in self.patterns["variable"].finditer(value):
+                key, path, type, subtype, format, default = match.group(1, 2, 3, 4, 5, 6)
+
+                if type and default:
+                    default = self._parse_as_type(default, type)
+
+                variables.append(WorkflowVariable(name, type or "string", subtype, format, default))
+            
+            return variables
+        
+        if isinstance(value, BaseModel):
+            return self._enumerate_output_variables(name, value.model_dump(exclude_none=True))
+        
+        if isinstance(value, dict):
+            return sum([ self._enumerate_output_variables(f"{name}.{k}" if name else f"{k}", v) for k, v in value.items() ], [])
+
+        if isinstance(value, list):
+            return sum([ self._enumerate_output_variables(f"{name}[{i}]" if name else f"[{i}]", v) for i, v in enumerate(value) ], [])
+        
+        return []
+
+    def _to_variable_config_list(self, variables: List[Union[WorkflowVariable, WorkflowVariableGroup]]) -> List[Union[WorkflowVariableConfig, WorkflowVariableGroupConfig]]:
+        configs: List[Union[WorkflowVariableConfig, WorkflowVariableGroupConfig]] = []
+        seen_single: Set[WorkflowVariable] = set()
+
+        for item in variables:
+            if isinstance(item, WorkflowVariableGroup):
+                group: List[WorkflowVariableConfig] = []
+                seen_in_group: Set[WorkflowVariable] = set()
+                for v in item.variables:
+                    if v not in seen_in_group:
+                        seen_in_group.add(v)
+                        group.append(WorkflowVariableConfig(**v.to_dict()))
+                configs.append(WorkflowVariableGroupConfig(name=item.name, variables=group, repeat_count=item.repeat_count))
+            else:
+                if item not in seen_single:
+                    seen_single.add(item)
+                    configs.append(WorkflowVariableConfig(**item.to_dict()))
+
+        return configs
+
+    def _parse_as_type(self, value: Any, type: str) -> Any:
+        if type == "number":
+            return float(value)
+
+        if type == "integer":
+            return int(value)
+        
+        if type == "boolean":
+            return str(value).lower() in [ "true", "1" ]
+        
+        if type == "json":
+            return json.loads(value)
+ 
+        return value
+
+class WorkflowInputResolver(WorkflowVariableResolver):
+    def resolve(self, workflow: WorkflowConfig, components: Dict[str, ComponentConfig]) -> List[WorkflowVariableConfig]:
+        variables: List[WorkflowVariable] = []
+
+        for job in workflow.jobs.values():
+            if not job.input or job.input == "${input}":
+                action_id = job.action or "__default__"
+                if isinstance(job.component, str):
+                    component: Optional[ComponentConfig] = components[job.component] if job.component in components else None
+                    if component:
+                        variables.extend(self._enumerate_input_variables(component.actions[action_id], "input"))
+                else:
+                    variables.extend(self._enumerate_input_variables(job.component.actions[action_id], "input"))
+            else:
+                variables.extend(self._enumerate_input_variables(job.input, "input"))
+
+            for value in [ job.repeat_count ]:
+                variables.extend(self._enumerate_input_variables(value, "input"))
+
+        return self._to_variable_config_list(variables)
+
+class WorkflowOutputResolver(WorkflowVariableResolver):
+    def resolve(self, workflow: WorkflowConfig, components: Dict[str, ComponentConfig]) -> List[Union[WorkflowVariableConfig, WorkflowVariableGroupConfig]]:
+        variables: List[Union[WorkflowVariable, WorkflowVariableGroup]] = []
+
+        for job_id, job in workflow.jobs.items():
+            if not self._is_terminal_job(workflow, job_id):
+                continue
+
+            job_variables: List[WorkflowVariable] = variables
+            repeat_count: int = job.repeat_count if isinstance(job.repeat_count, int) else 0
+
+            if repeat_count != 1:
+                variables.append(WorkflowVariableGroup(None, job_variables := [], repeat_count))
+
+            if not job.output or job.output == "${output}":
+                action_id = job.action or "__default__"
+                if isinstance(job.component, str):
+                    component: Optional[ComponentConfig] = components[job.component] if job.component in components else None
+                    if component:
+                        job_variables.extend(self._enumerate_output_variables(None, component.actions[action_id].output))
+                else:
+                    job_variables.extend(self._enumerate_output_variables(None, job.component.actions[action_id].output))
+            else:
+                job_variables.extend(self._enumerate_output_variables(None, job.output))
+
+        return self._to_variable_config_list(variables)
+
+    def _is_terminal_job(self, workflow: WorkflowConfig, job_id: str) -> bool:
+        return all(job_id not in job.depends_on for other_id, job in workflow.jobs.items() if other_id != job_id)
+
+class WorkflowSchema:
+    def __init__(self, name: str, title: str, description: Optional[str], input: List[WorkflowVariableConfig], output: List[Union[WorkflowVariableConfig, WorkflowVariableGroupConfig]]):
+        self.name: str = name
+        self.title: str = title
+        self.description: Optional[str] = description
+        self.input: List[WorkflowVariableConfig] = input
+        self.output: List[Union[WorkflowVariableConfig, WorkflowVariableGroupConfig]] = output

{model_compose-0.1.0 → model_compose-0.1.2}/src/mindor/core/controller/webui/webui.py

@@ -54,7 +54,8 @@ class ControllerWebUI(AsyncService):
         await self.server.serve()
     
     async def _shutdown(self) -> None:
-        self.server.should_exit = True
+        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)

{model_compose-0.1.0 → model_compose-0.1.2}/src/mindor/core/listener/engine/http_callback.py

@@ -66,7 +66,7 @@ class HttpCallbackListener(ListenerEngine):
             )
 
     def _make_callback_handler(self, callback: HttpCallbackConfig) -> Callable:
-        async def handler(request: Request) -> Response:
+        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)
@@ -85,7 +85,7 @@ class HttpCallbackListener(ListenerEngine):
 
             return Response()
 
-        return handler
+        return _handler
 
     async def _is_callback_succeeded(self, callback: HttpCallbackConfig, context: HttpCallbackContext) -> bool:
         status = (await context.render_template(callback.status)) if callback.status else None
@@ -109,7 +109,8 @@ class HttpCallbackListener(ListenerEngine):
         await self.server.serve()
  
     async def _shutdown(self) -> None:
-        self.server.should_exit = True
+        if self.server:
+            self.server.should_exit = True
 
     def _get_pending_future(self, id: str) -> Optional[asyncio.Future]:
         with _pending_futures_lock:

{model_compose-0.1.0 → model_compose-0.1.2}/src/mindor/core/utils/http_client.py

@@ -39,11 +39,11 @@ class HttpClient:
                 headers=headers
             )
 
-            if response.status >= 400:
-                raise ValueError(f"Request failed with status {response.status}")
-
             content = await self._parse_response_content(session, response)
 
+            if response.status >= 400:
+                raise ValueError(f"Request failed with status {response.status}: {content}")
+
             if not isinstance(content, HttpStreamResource):
                 await session.close()