model-compose 0.3.6__tar.gz → 0.3.7__tar.gz

{model_compose-0.3.6/src/model_compose.egg-info → model_compose-0.3.7}/PKG-INFO

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

{model_compose-0.3.6 → model_compose-0.3.7}/pyproject.toml

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

{model_compose-0.3.6 → model_compose-0.3.7}/src/mindor/cli/compose.py

@@ -4,14 +4,14 @@ from pathlib import Path
 import asyncio
 
 from mindor.dsl.loader import load_compose_config
-from mindor.core.runtime.env import load_env_files
+from mindor.core.runtime.env import load_env_files, merge_env_data
 from mindor.core.compose import *
 
 @click.group()
 @click.option(
     "--file", "-f", "config_files", multiple=True,
     type=click.Path(exists=True, dir_okay=False, path_type=Path),
-    help="Compose configuration files"
+    help="Compose configuration files."
 )
 @click.pass_context
 def compose_command(ctx: click.Context, config_files: List[Path]) -> None:
@@ -44,6 +44,7 @@ def up_command(
     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)
             await launch_services(config, detach, verbose)
         except Exception as e:
@@ -73,6 +74,7 @@ def down_command(
     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)
             await terminate_services(config, verbose)
         except Exception as e:
@@ -102,6 +104,7 @@ def start_command(
     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)
             await start_services(config, verbose)
         except Exception as e:
@@ -131,6 +134,7 @@ def stop_command(
     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)
             await stop_services(config, verbose)
         except Exception as e:
@@ -176,6 +180,7 @@ def run_command(
     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)
             input = json.loads(input_json) if input_json else {}
             state = await run_workflow(config, workflow_id, input, output_path, verbose)

{model_compose-0.3.6 → model_compose-0.3.7}/src/mindor/core/component/base.py

@@ -57,6 +57,12 @@ class ComponentService(AsyncService):
         if self.config.max_concurrent_count > 0:
             self.queue = WorkQueue(self.config.max_concurrent_count, self._run)
 
+    async def install(self) -> None:
+        await self._install()
+
+    async def build(self) -> None:
+        await self._build()
+
     async def run(self, action_id: Union[str, None], run_id: str, input: Dict[str, Any]) -> Dict[str, Any]:
         _, action = ActionResolver(self.config.actions).resolve(action_id)
         context = ComponentActionContext(run_id, input)
@@ -66,6 +72,12 @@ class ComponentService(AsyncService):
 
         return await self._run(action, context)
 
+    async def _install(self) -> None:
+        pass
+
+    async def _build(self) -> None:
+        pass
+
     async def _start(self) -> None:
         if self.queue:
             await self.queue.start()

{model_compose-0.3.6 → model_compose-0.3.7}/src/mindor/core/component/context.py

@@ -19,17 +19,23 @@ class ComponentActionContext:
     async def _resolve_source(self, key: str, index: Optional[int]) -> Any:
         if key in self.sources:
             return self.sources[key][index] if index is not None else self.sources[key]
+
         if key == "input":
             return self.input
+
         if key == "context":
             return self.context
+
         if key.startswith("gateway:"):
             return self._resolve_gateway(key)
+
         raise KeyError(f"Unknown source: {key}")
 
     def _resolve_gateway(self, key: str) -> Any:
         _, port = key.split(":")
         gateway = find_gateway_by_port(int(port)) if port else None
+
         if gateway:
             return gateway.get_context()
+
         return None

model_compose-0.3.7/src/mindor/core/component/services/http_server.py

@@ -0,0 +1,133 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Any
+from abc import ABC, abstractmethod
+from mindor.dsl.schema.component import HttpServerComponentConfig
+from mindor.dsl.schema.action import ActionConfig, HttpServerActionConfig, HttpServerCompletionType, HttpServerCompletionConfig
+from mindor.core.listener import HttpCallbackListener
+from mindor.core.utils.http_client import HttpClient
+from mindor.core.utils.http_status import is_status_code_matched
+from mindor.core.utils.time import parse_duration
+from mindor.core.utils.shell import run_command_streaming
+from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
+from ..context import ComponentActionContext
+from datetime import datetime, timezone
+import asyncio, os
+
+class HttpServerCompletion(ABC):
+    def __init__(self, config: HttpServerCompletionConfig):
+        self.config: HttpServerCompletionConfig = config
+
+    @abstractmethod
+    async def run(self, context: ComponentActionContext, client: HttpClient) -> Any:
+        pass
+
+class HttpServerPollingCompletion(HttpServerCompletion):
+    async def run(self, context: ComponentActionContext, client: HttpClient) -> Any:
+        path    = await context.render_variable(self.config.path)
+        method  = await context.render_variable(self.config.method)
+        params  = await context.render_variable(self.config.params)
+        body    = await context.render_variable(self.config.body)
+        headers = await context.render_variable(self.config.headers)
+
+        interval = parse_duration((await context.render_variable(self.config.interval)) or 5.0)
+        timeout  = parse_duration((await context.render_variable(self.config.timeout)) or 300.0)
+        deadline = datetime.now(timezone.utc) + timeout
+
+        await asyncio.sleep(interval.total_seconds())
+
+        while datetime.now(timezone.utc) < deadline:
+            response, status_code = await client.request(path or "", method, params, body, headers, raise_on_error=False)
+            context.register_source("result", response)
+
+            status = (await context.render_variable(self.config.status)) if self.config.status else None
+            if status:
+                if status in (self.config.success_when or []):
+                    return response
+                if status in (self.config.fail_when or []):
+                    raise RuntimeError(f"Polling failed: status '{status}' matched a failure condition.")
+            else: # use status code
+                if is_status_code_matched(status_code, self.config.success_when or []):
+                    return response
+                if is_status_code_matched(status_code, self.config.fail_when or []):
+                    raise RuntimeError(f"Polling failed: status code '{status_code}' matched a failure condition.")
+
+            await asyncio.sleep(interval.total_seconds())
+
+        raise TimeoutError(f"Polling timed out after {timeout}.")
+
+class HttpServerCallbackCompletion(HttpServerCompletion):
+    async def run(self, context: ComponentActionContext, client: HttpClient) -> Any:
+        callback_id = await context.render_variable(self.config.wait_for)
+        future: asyncio.Future = asyncio.get_running_loop().create_future()
+        HttpCallbackListener.register_pending_future(callback_id, future)
+
+        return await future
+
+class HttpServerAction:
+    def __init__(self, config: HttpServerActionConfig):
+        self.config: HttpServerActionConfig = config
+        self.completion: HttpServerCompletion = None
+
+        if self.config.completion:
+            self._configure_completion()
+
+    def _configure_completion(self) -> None:
+        if self.config.completion.type == HttpServerCompletionType.POLLING:
+            self.completion = HttpServerPollingCompletion(self.config.completion)
+            return
+        
+        if self.config.completion.type == HttpServerCompletionType.CALLBACK:
+            self.completion = HttpServerCallbackCompletion(self.config.completion)
+            return
+        
+        raise ValueError(f"Unsupported http completion type: {self.config.completion.type}")
+
+    async def run(self, context: ComponentActionContext, client: HttpClient) -> Any:
+        path    = await context.render_variable(self.config.path)
+        method  = await context.render_variable(self.config.method)
+        params  = await context.render_variable(self.config.params)
+        body    = await context.render_variable(self.config.body)
+        headers = await context.render_variable(self.config.headers)
+
+        response, result = await client.request(path or "", method, params, body, headers), None
+        context.register_source("response", response)
+
+        if self.completion:
+            result = await self.completion.run(context, client)
+            context.register_source("result", result)
+
+        return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else (result or response)
+
+@register_component(ComponentType.HTTP_SERVER)
+class HttpServerComponent(ComponentService):
+    def __init__(self, id: str, config: HttpServerComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
+        super().__init__(id, config, global_configs, daemon)
+
+        self.client: Optional[HttpClient] = None
+
+    async def _install(self) -> None:
+        if self.config.commands.install:
+            await run_command_streaming(self.config.commands.install, self.config.working_dir, self.config.env)
+
+    async def _build(self) -> None:
+        if self.config.commands.build:
+            await run_command_streaming(self.config.commands.build, self.config.working_dir, self.config.env)
+
+    async def _start(self) -> None:
+        base_url = f"http://localhost:{self.config.port}" + (self.config.base_path or "")
+        self.client = HttpClient(base_url, self.config.headers)
+        await super()._start()
+
+    async def _stop(self) -> None:
+        await super()._stop()
+        await self.client.close()
+        self.client = None
+
+    async def _serve(self) -> None:
+        if self.config.commands.start:
+            await run_command_streaming(self.config.commands.start, self.config.working_dir, self.config.env, block=False)
+
+    async def _shutdown(self) -> None:
+        pass
+
+    async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
+        return await HttpServerAction(action).run(context, self.client)

{model_compose-0.3.6 → model_compose-0.3.7}/src/mindor/core/component/services/shell.py

@@ -1,6 +1,7 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.component import ShellComponentConfig
 from mindor.dsl.schema.action import ActionConfig, ShellActionConfig
+from mindor.core.utils.shell import run_command
 from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
 from ..context import ComponentActionContext
 from asyncio.subprocess import Process
@@ -22,24 +23,12 @@ class ShellAction:
         return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result
     
     async def _run_command(self, command: List[str], working_dir: str, env: Dict[str, str], timeout: Optional[float]) -> Dict[str, Any]:
-        process = await asyncio.create_subprocess_exec(
-            *command,
-            cwd=working_dir,
-            env={ **os.environ, **env },
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE
-        )
-
-        try:
-            stdout, stderr = await asyncio.wait_for(process.communicate(), timeout=timeout)
-        except asyncio.TimeoutError:
-            if await self._kill_process(process):
-                raise RuntimeError(f"Command timed out: {' '.join(command)}")
+        stdout, stderr, exit_code = await run_command(command, working_dir, env, timeout)
 
         return { 
             "stdout": stdout.decode().strip(), 
             "stderr": stderr.decode().strip(),
-            "exit_code": process.returncode
+            "exit_code": exit_code
         }
 
     async def _kill_process(self, process: Process) -> bool:
@@ -55,6 +44,7 @@ class ShellAction:
 
     async def _resolve_working_directory(self) -> str:
         working_dir = self.config.working_dir
+
         if working_dir:
             if self.base_dir:
                 working_dir = os.path.abspath(os.path.join(self.base_dir, working_dir))
@@ -62,6 +52,7 @@ class ShellAction:
                 working_dir = os.path.abspath(working_dir)
         else:
             working_dir = self.base_dir or os.getcwd()
+
         return working_dir
 
 @register_component(ComponentType.SHELL)

{model_compose-0.3.6 → model_compose-0.3.7}/src/mindor/core/controller/base.py

@@ -16,6 +16,7 @@ from mindor.core.gateway import GatewayService, create_gateway
 from mindor.core.workflow import Workflow, WorkflowResolver, create_workflow
 from mindor.core.logger import LoggerService, create_logger
 from mindor.core.controller.webui import ControllerWebUI
+from mindor.core.workflow.schema import WorkflowSchema, create_workflow_schemas
 from mindor.core.utils.workqueue import WorkQueue
 from mindor.core.utils.caching import ExpiringDict
 from .runtime.specs import ControllerRuntimeSpecs
@@ -55,12 +56,13 @@ class ControllerService(AsyncService):
         self.listeners: List[ListenerConfig] = listeners
         self.gateways: List[GatewayConfig] = gateways
         self.loggers: List[LoggerConfig] = loggers
-        self.queue: Optional[WorkQueue] = None
+        self.workflow_schemas: Dict[str, WorkflowSchema] = create_workflow_schemas(self.workflows, self.components)
+        self.task_queue: Optional[WorkQueue] = None
         self.task_states: ExpiringDict[TaskState] = ExpiringDict()
         self.task_states_lock: Lock = Lock()
-        
+
         if self.config.max_concurrent_count > 0:
-            self.queue = WorkQueue(self.config.max_concurrent_count, self._run_workflow)
+            self.task_queue = WorkQueue(self.config.max_concurrent_count, self._run_workflow)
 
     async def launch(self, detach: bool, verbose: bool) -> None:
         if self.config.runtime.type == RuntimeType.NATIVE:
@@ -92,8 +94,8 @@ class ControllerService(AsyncService):
             self.task_states.set(task_id, state)
 
         if wait_for_completion:
-            if self.queue:
-                state = await (await self.queue.schedule(task_id, workflow_id, input))
+            if self.task_queue:
+                state = await (await self.task_queue.schedule(task_id, workflow_id, input))
             else:
                 state = await self._run_workflow(task_id, workflow_id, input)
         else:
@@ -106,8 +108,8 @@ class ControllerService(AsyncService):
             return self.task_states.get(task_id)
 
     async def _start(self) -> None:
-        if self.queue:
-            await self.queue.start()
+        if self.task_queue:
+            await self.task_queue.start()
 
         if self.daemon:
             await self._start_loggers()
@@ -121,8 +123,8 @@ class ControllerService(AsyncService):
         await super()._start()
 
     async def _stop(self) -> None:
-        if self.queue:
-            await self.queue.stop()
+        if self.task_queue:
+            await self.task_queue.stop()
 
         if self.daemon:
             await self._stop_components()

{model_compose-0.3.6 → model_compose-0.3.7}/src/mindor/core/controller/runner/http_client.py

@@ -34,7 +34,7 @@ class HttpControllerClient(ControllerClient):
         await self.client.close()
 
     def _resolve_controller_url(self) -> str:
-        return f"http://localhost:{self.config.port}{self.config.base_path or ''}"
+        return f"http://localhost:{self.config.port}" + (self.config.base_path or "")
     
     def _flatten_for_multipart(self, data: Dict[str, Any], key: str = "") -> List[Tuple[str, Any]]:
         flattened = []

{model_compose-0.3.6 → model_compose-0.3.7}/src/mindor/core/controller/runner/mcp_client.py

@@ -23,7 +23,7 @@ class McpControllerClient(ControllerClient):
         await self.client.close()
 
     def _resolve_controller_url(self) -> str:
-        return f"http://localhost:{self.config.port}{self.config.base_path or ''}"
+        return f"http://localhost:{self.config.port}" + (self.config.base_path or "")
 
     async def _call_tool(self, name: str, arguments: Optional[Dict[str, Any]], workflow: WorkflowSchema) -> Any:
         contents = await self.client.call_tool(name, arguments)

{model_compose-0.3.6 → model_compose-0.3.7}/src/mindor/core/controller/services/http_server.py

@@ -7,11 +7,11 @@ from mindor.dsl.schema.component import ComponentConfig
 from mindor.dsl.schema.listener import ListenerConfig
 from mindor.dsl.schema.gateway import GatewayConfig
 from mindor.dsl.schema.logger import LoggerConfig
-from mindor.dsl.schema.workflow import WorkflowConfig
+from mindor.dsl.schema.workflow import WorkflowConfig, WorkflowVariableConfig, WorkflowVariableGroupConfig
 from mindor.core.utils.http_request import parse_request_body, parse_options_header
 from mindor.core.utils.http_client import HttpEventStreamResource
 from mindor.core.utils.streaming import StreamResource
-from ..base import ControllerService, ControllerType, TaskState, TaskStatus, register_controller
+from ..base import ControllerService, ControllerType, WorkflowSchema, TaskState, TaskStatus, register_controller
 from fastapi import FastAPI, APIRouter, Request, Body, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import Response, JSONResponse, StreamingResponse
@@ -39,6 +39,57 @@ class TaskResult(BaseModel):
             error=instance.error
         )
 
+class WorkflowVariableResult(BaseModel):
+    name: Optional[str]
+    type: str
+    subtype: Optional[str]
+    format: Optional[str]
+    default: Optional[str]
+
+    @classmethod
+    def from_instance(cls, instance: WorkflowVariableConfig) -> Self:
+        return cls(
+            name=instance.name,
+            type=instance.type,
+            subtype=instance.subtype,
+            format=instance.format,
+            default=instance.default
+        )
+
+class WorkflowVariableGroupResult(BaseModel):
+    name: Optional[str]
+    variables: List[WorkflowVariableResult]
+
+    @classmethod
+    def from_instance(cls, instance: WorkflowVariableGroupConfig) -> Self:
+        return cls(
+            name=instance.name,
+            variables=[ WorkflowVariableResult.from_instance(variable) for variable in instance.variables ]
+        )
+
+class WorkflowSchemaResult(BaseModel):
+    workflow_id: str
+    title: Optional[str] = None
+    description: Optional[str] = None
+    input: List[WorkflowVariableResult]
+    output: List[Union[WorkflowVariableResult, WorkflowVariableGroupResult]]
+
+    @classmethod
+    def from_instance(cls, instance: WorkflowSchema) -> Self:
+        return cls(
+            workflow_id=instance.workflow_id,
+            title=instance.title,
+            description=instance.description,
+            input=[ cls._to_variable_result(variable) for variable in instance.input ],
+            output=[ cls._to_variable_result(variable) for variable in instance.output ],
+        )
+    
+    @classmethod
+    def _to_variable_result(cls, variable: Union[WorkflowVariableConfig, WorkflowVariableGroupConfig ]) -> Union[WorkflowVariableResult, WorkflowVariableGroupResult]:
+        if isinstance(variable, WorkflowVariableGroupConfig):
+            return WorkflowVariableGroupResult.from_instance(variable)
+        return WorkflowVariableResult.from_instance(variable)
+
 @register_controller(ControllerType.HTTP_SERVER)
 class HttpServerController(ControllerService):
     def __init__(
@@ -107,6 +158,27 @@ class HttpServerController(ControllerService):
 
             return self._render_task_state(state)
 
+        @self.router.get("/tasks/{task_id}/jobs")
+        async def get_task_jobs(
+            task_id: str
+        ):
+            return None
+
+        @self.router.get("/workflows")
+        async def get_workflow_schemas():
+            return self._render_workflow_schemas(self.workflow_schemas)
+
+        @self.router.get("/workflows/{workflow_id}")
+        async def get_workflow_schema(
+            workflow_id: str,
+        ):
+            workflow = self.workflow_schemas[workflow_id] if workflow_id in self.workflow_schemas else None
+
+            if not workflow:
+                raise HTTPException(status_code=404, detail="Workflow not found.")
+
+            return self._render_workflow_schema(workflow)
+
     async def _serve(self) -> None:
         self.server = uvicorn.Server(uvicorn.Config(
             self.app,
@@ -203,3 +275,11 @@ class HttpServerController(ControllerService):
             headers["Content-Disposition"] = f'attachment; filename="{filename}"'
 
         return headers
+
+    def _render_workflow_schemas(self, workflows: Dict[str, WorkflowSchema]) -> Response:
+        return JSONResponse(content={
+            workflow_id: WorkflowSchemaResult.from_instance(workflow).model_dump(exclude_none=True) for workflow_id, workflow in workflows.items()
+        })
+
+    def _render_workflow_schema(self, workflow: WorkflowSchema) -> Response:
+        return JSONResponse(content=WorkflowSchemaResult.from_instance(workflow).model_dump(exclude_none=True))

{model_compose-0.3.6 → model_compose-0.3.7}/src/mindor/core/controller/services/mcp_server.py

@@ -5,7 +5,7 @@ from mindor.dsl.schema.listener import ListenerConfig
 from mindor.dsl.schema.gateway import GatewayConfig
 from mindor.dsl.schema.logger import LoggerConfig
 from mindor.dsl.schema.workflow import WorkflowConfig, WorkflowVariableConfig, WorkflowVariableType, WorkflowVariableFormat
-from mindor.core.workflow.schema import WorkflowSchema, create_workflow_schema
+from mindor.core.workflow.schema import WorkflowSchema
 from mindor.core.utils.streaming import StreamResource, Base64StreamResource
 from mindor.core.utils.streaming import save_stream_to_temporary_file
 from mindor.core.utils.http_client import create_stream_with_url
@@ -150,9 +150,7 @@ class McpServerController(ControllerService):
         self._configure_tools()
 
     def _configure_tools(self) -> None:
-        schema = create_workflow_schema(self.workflows, self.components)
-
-        for workflow_id, workflow in schema.items():
+        for workflow_id, workflow in self.workflow_schemas.items():
             fn, description = WorkflowToolGenerator().generate(workflow_id, workflow, self._run_workflow_as_tool)
             self.app.add_tool(
                 fn=fn,

{model_compose-0.3.6 → model_compose-0.3.7}/src/mindor/core/controller/webui/gradio.py

@@ -20,13 +20,13 @@ class GradioWebUIBuilder:
     def __init__(self):
         self.field_resolver: FieldResolver = FieldResolver()
 
-    def build(self, schema: Dict[str, WorkflowSchema], runner: Callable[[Optional[str], Any], Awaitable[Any]]) -> gr.Blocks:
+    def build(self, workflow_schemas: Dict[str, WorkflowSchema], workflow_runner: Callable[[Optional[str], Any], Awaitable[Any]]) -> gr.Blocks:
         with gr.Blocks() as blocks:
-            for workflow_id, workflow in schema.items():
+            for workflow_id, workflow in workflow_schemas.items():
                 async def _run_workflow(input: Any, workflow_id=workflow_id) -> Any:
-                    return await runner(workflow_id, input)
+                    return await workflow_runner(workflow_id, input)
 
-                if len(schema) > 1:
+                if len(workflow_schemas) > 1:
                     with gr.Tab(label=workflow.name or workflow_id):
                         self._build_workflow_section(workflow, _run_workflow)
                 else:
@@ -37,7 +37,7 @@ class GradioWebUIBuilder:
     def _build_workflow_section(self, workflow: WorkflowSchema, runner: Callable[[Any], Awaitable[Any]]) -> gr.Column:
         with gr.Column() as section:
             gr.Markdown(f"## **{workflow.title or 'Untitled Workflow'}**")
- 
+
             if workflow.description:
                 gr.Markdown(f"📝 {workflow.description}")
 
@@ -47,14 +47,14 @@ class GradioWebUIBuilder:
 
             gr.Markdown("#### 📤 Output Values")
             output_components = [ self._build_output_component(variable) for variable in workflow.output ]
-            
+
             if not output_components:
                 output_components = [ gr.Textbox(label="", lines=10, interactive=False, show_copy_button=True) ]
 
             async def _run_workflow(*args):
                 input = await self._build_input_value(args, workflow.input)
                 output = await runner(input)
-                
+
                 if len(workflow.output) == 1 and self._is_streaming_variable(workflow.output[0]):
                     text = ""
                     async for chunk in output:
@@ -81,7 +81,7 @@ class GradioWebUIBuilder:
         if isinstance(variable, WorkflowVariableConfig):
             return variable.format in [ WorkflowVariableFormat.SSE_JSON, WorkflowVariableFormat.SSE_TEXT ]
         return False
-        
+
     def _build_input_component(self, variable: WorkflowVariableConfig) -> gr.Component:
         label = (variable.name or "") + (" *" if variable.required else "") + (f" (default: {variable.default})" if variable.default else "")
         info = variable.get_annotation_value("description") or ""

{model_compose-0.3.6 → model_compose-0.3.7}/src/mindor/core/controller/webui/webui.py

@@ -4,14 +4,14 @@ from mindor.dsl.schema.controller.webui import ControllerWebUIConfig, Controller
 from mindor.dsl.schema.component import ComponentConfig
 from mindor.dsl.schema.workflow import WorkflowConfig
 from mindor.core.controller.runner import ControllerRunner
-from mindor.core.workflow.schema import create_workflow_schema
+from mindor.core.workflow.schema import WorkflowSchema, create_workflow_schemas
 from mindor.core.services import AsyncService
 from .gradio import GradioWebUIBuilder
 from gradio import mount_gradio_app
 from fastapi import FastAPI
 from fastapi.staticfiles import StaticFiles
 from pathlib import Path
-import uvicorn, gradio
+import uvicorn
 
 class ControllerWebUI(AsyncService):
     def __init__(
@@ -26,7 +26,7 @@ class ControllerWebUI(AsyncService):
 
         self.config: ControllerWebUIConfig = config
         self.controller: ControllerConfig = controller
-        self.schema = create_workflow_schema(workflows, components)
+        self.workflow_schemas: Dict[str, WorkflowSchema] = create_workflow_schemas(workflows, components)
 
         self.server: Optional[uvicorn.Server] = None
         self.app: FastAPI = FastAPI(openapi_url=None, docs_url=None, redoc_url=None)
@@ -36,13 +36,13 @@ class ControllerWebUI(AsyncService):
 
     def _configure_driver(self) -> None:
         if self.config.driver == ControllerWebUIDriver.GRADIO:
-            blocks: gradio.Blocks = GradioWebUIBuilder().build(
-                schema=self.schema,
-                runner=self._run_workflow
+            blocks = GradioWebUIBuilder().build(
+                workflow_schemas=self.workflow_schemas,
+                workflow_runner=self._run_workflow
             )
             self.app = mount_gradio_app(self.app, blocks, path="")
             return
-        
+
         if self.config.driver == ControllerWebUIDriver.STATIC:
             static_files = StaticFiles(
                 directory=Path(self.config.static_dir).resolve(), 
@@ -70,5 +70,5 @@ class ControllerWebUI(AsyncService):
 
     async def _run_workflow(self, workflow_id: Optional[str], input: Any) -> Any:
         if self.runner:
-            return await self.runner.run_workflow(workflow_id, input, self.schema[workflow_id])
+            return await self.runner.run_workflow(workflow_id, input, self.workflow_schemas[workflow_id])
         return None

{model_compose-0.3.6 → model_compose-0.3.7}/src/mindor/core/listener/services/http_callback.py

@@ -41,8 +41,10 @@ class HttpCallbackContext:
     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_CALLBACK)

{model_compose-0.3.6 → model_compose-0.3.7}/src/mindor/core/runtime/env.py

@@ -17,3 +17,13 @@ def load_env_files(work_dir: Union[ str, Path ], env_files: List[Union[ str, Pat
         merged_env.update({k: v for k, v in env_dict.items() if v is not None})
 
     return merged_env
+
+def merge_env_data(env: Dict[str, str], env_data: List[str]) -> Dict[str, str]:
+    for env_entry in env_data:
+        if "=" not in env_entry:
+            raise ValueError(f"Invalid env entry: {env_entry}")
+        
+        key, value = env_entry.split("=", 1)
+        env[key] = value
+
+    return env