model-compose 0.4.24__tar.gz → 0.4.26__tar.gz

{model_compose-0.4.24 → model_compose-0.4.26}/PKG-INFO

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

{model_compose-0.4.24 → model_compose-0.4.26}/pyproject.toml

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

{model_compose-0.4.24 → model_compose-0.4.26}/src/mindor/cli/interrupt.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING
+
+from typing import Any
 import click
 import json
 
@@ -9,17 +11,15 @@ if TYPE_CHECKING:
 def prompt_for_interrupt(state: TaskState) -> Any:
     interrupt = state.interrupt
 
-    click.echo("", err=True)
-    click.echo(f"--- Interrupted (job: {interrupt.job_id}, phase: {interrupt.phase}) ---", err=True)
-
     if interrupt.message:
-        click.echo(f"\n{interrupt.message}", err=True)
+        click.echo(interrupt.message, err=True)
 
     if interrupt.metadata:
         click.echo(json.dumps(interrupt.metadata, indent=2, ensure_ascii=False), err=True)
 
     click.echo("", err=True)
-    raw = click.prompt("Enter response (JSON or text, empty to continue)", default="", show_default=False)
+    click.echo("✋ Action required — press Enter to continue, or type an answer (JSON or text):", err=True)
+    raw = input()
 
     if not raw:
         return None

{model_compose-0.4.24 → model_compose-0.4.26}/src/mindor/core/component/base.py

@@ -72,12 +72,12 @@ class ComponentService(AsyncService):
         await super().start(background)
         await self.wait_until_ready()
 
-    async def run(self, action_id: str, run_id: str, input: Dict[str, Any]) -> Dict[str, Any]:
+    async def run(self, action_id: str, run_id: str, input: Dict[str, Any], workflow=None) -> Dict[str, Any]:
         if self._process_manager:
             return await self._process_manager.run(action_id, run_id, input)
 
         _, action = ActionResolver(self.config.actions).resolve(action_id)
-        context = ComponentActionContext(run_id, input)
+        context = ComponentActionContext(run_id, input, workflow=workflow)
 
         if self.work_queue:
             return await (await self.work_queue.schedule(action, context))

{model_compose-0.4.24 → model_compose-0.4.26}/src/mindor/core/component/context.py

@@ -1,12 +1,19 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.core.utils.renderers import VariableRenderer, ImageValueRenderer, FileValueRenderer
 from mindor.core.gateway import find_gateway_by_port
 from PIL import Image as PILImage
 
+if TYPE_CHECKING:
+    from mindor.core.workflow.context import WorkflowContext
+
 class ComponentActionContext:
-    def __init__(self, run_id: str, input: Dict[str, Any]):
+    def __init__(self, run_id: str, input: Dict[str, Any], workflow: Optional[WorkflowContext] = None):
         self.run_id: str = run_id
         self.input: Dict[str, Any] = input
+        self.workflow: Optional[WorkflowContext] = workflow
         self.context: Dict[str, Any] = { "run_id": run_id }
         self.sources: Dict[str, Any] = {}
         self.renderer: VariableRenderer = VariableRenderer(self._resolve_source)

{model_compose-0.4.24 → model_compose-0.4.26}/src/mindor/core/component/services/agent.py

@@ -48,7 +48,7 @@ class AgentAction:
                     if not tool_calls:
                         break
 
-                    tool_messages = await asyncio.gather(*[self._execute_tool_call(tc) for tc in tool_calls])
+                    tool_messages = await asyncio.gather(*[self._execute_tool_call(tc, context) for tc in tool_calls])
                     for tool_message in tool_messages:
                         messages.append(tool_message)
                         yield tool_message
@@ -66,20 +66,20 @@ class AgentAction:
             if not tool_calls:
                 break
 
-            tool_messages = await asyncio.gather(*[self._execute_tool_call(tc) for tc in tool_calls])
+            tool_messages = await asyncio.gather(*[self._execute_tool_call(tc, context) for tc in tool_calls])
             for tool_message in tool_messages:
                 messages.append(tool_message)
 
         return messages
 
-    async def _execute_tool_call(self, tool_call: Dict[str, Any]) -> Dict[str, Any]:
+    async def _execute_tool_call(self, tool_call: Dict[str, Any], context: ComponentActionContext) -> Dict[str, Any]:
         tool_name = tool_call["function"]["name"]
         tool_arguments = tool_call["function"].get("arguments", {})
         if isinstance(tool_arguments, str):
             tool_arguments = json.loads(tool_arguments)
 
         if tool_name in self.tools:
-            result = await self.tools[tool_name].fn(**tool_arguments)
+            result = await self.tools[tool_name].fn(**tool_arguments, context=context.workflow)
             content = json.dumps(result) if isinstance(result, (dict, list)) else str(result)
         else:
             content = f"Error: Unknown tool '{tool_name}'"
@@ -189,6 +189,8 @@ class AgentComponent(ComponentService):
 
         return tools
 
-    async def _run_workflow(self, workflow_id: str, input: Any) -> Any:
+    async def _run_workflow(self, workflow_id: str, input: Any, context=None) -> Any:
         workflow = create_workflow(*WorkflowResolver(self.global_configs.workflows).resolve(workflow_id), self.global_configs)
-        return await workflow.run(ulid.ulid(), input)
+        task_id = context.task_id if context else ulid.ulid()
+        interrupt_handler = context.interrupt_handler if context else None
+        return await workflow.run(task_id, input, interrupt_handler)

{model_compose-0.4.24 → model_compose-0.4.26}/src/mindor/core/component/services/workflow.py

@@ -15,7 +15,8 @@ class WorkflowAction:
         workflow = self._create_workflow(self.config.workflow)
         input = await context.render_variable(self.config.input)
 
-        output = await workflow.run(context.run_id, input)
+        interrupt_handler = context.workflow.interrupt_handler if context.workflow else None
+        output = await workflow.run(context.run_id, input, interrupt_handler)
         context.register_source("output", output)
 
         return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else output

{model_compose-0.4.24 → model_compose-0.4.26}/src/mindor/core/compose/manager.py

@@ -39,8 +39,8 @@ class ComposeManager:
 
         return state
 
-    async def resume_workflow(self, task_id: str, job_id: str, data: Any = None) -> TaskState:
-        await self.controller.resume_workflow(task_id, job_id, data)
+    async def resume_workflow(self, task_id: str, job_id: str, answer: Any = None) -> TaskState:
+        await self.controller.resume_workflow(task_id, job_id, answer)
         return await self.controller.wait_for_terminal_state(task_id)
 
     async def _save_output(self, output: Any, path: str) -> None:

{model_compose-0.4.24 → model_compose-0.4.26}/src/mindor/core/controller/base.py

@@ -191,7 +191,7 @@ class ControllerService(AsyncService):
 
         return state
 
-    async def resume_workflow(self, task_id: str, job_id: str, data: Any = None) -> TaskState:
+    async def resume_workflow(self, task_id: str, job_id: str, answer: Any = None) -> TaskState:
         with self.task_states_lock:
             state = self.task_states.get(task_id)
 
@@ -208,7 +208,7 @@ class ControllerService(AsyncService):
         if not handler:
             raise ValueError(f"No active interrupt handler for task '{task_id}'")
 
-        success = handler.resolve(task_id, job_id, data)
+        success = handler.resolve(task_id, job_id, answer)
         if not success:
             raise ValueError(f"No active interrupt found for task '{task_id}', job '{job_id}'")
 
@@ -363,7 +363,7 @@ class ControllerService(AsyncService):
 
         try:
             workflow = self._create_workflow(workflow_id)
-            interrupt_handler = self._attach_interrupt_handler(task_id, workflow_id, workflow)
+            interrupt_handler = self._attach_interrupt_handler(task_id, workflow_id)
 
             output = await workflow.run(task_id, input, interrupt_handler)
             state = TaskState(task_id=task_id, status=TaskStatus.COMPLETED, workflow_id=workflow_id, output=output)
@@ -397,17 +397,13 @@ class ControllerService(AsyncService):
                 return state
             await event.wait()
 
-    def _attach_interrupt_handler(self, task_id: str, workflow_id: str, workflow: Workflow) -> Optional[InterruptHandler]:
-        if workflow.uses_interrupts():
-            handler = self._create_interrupt_handler(task_id, workflow_id)
-            self.interrupt_handlers[task_id] = handler
-            return handler
-
-        return None
+    def _attach_interrupt_handler(self, task_id: str, workflow_id: str) -> InterruptHandler:
+        handler = self._create_interrupt_handler(task_id, workflow_id)
+        self.interrupt_handlers[task_id] = handler
+        return handler
 
     def _detach_interrupt_handler(self, task_id: str) -> None:
-        if task_id in self.interrupt_handlers:
-            del self.interrupt_handlers[task_id]
+        del self.interrupt_handlers[task_id]
 
     def _create_interrupt_handler(self, task_id: str, workflow_id: str) -> InterruptHandler:
         async def on_interrupt(point: InterruptPoint):

{model_compose-0.4.24 → model_compose-0.4.26}/src/mindor/core/controller/runner/client.py

@@ -8,7 +8,19 @@ class ControllerClient(ABC):
         self.config: ControllerConfig = config
 
     @abstractmethod
-    async def run_workflow(self, workflow_id: Optional[str], input: Any) -> Any:
+    async def run_workflow(self, workflow_id: Optional[str], input: Any, workflow: WorkflowSchema) -> Any:
+        pass
+
+    @abstractmethod
+    async def resume_workflow(self, task_id: str, job_id: str, answer: Any = None) -> dict:
+        pass
+
+    @abstractmethod
+    async def wait_for_completion(self, task_id: str) -> dict:
+        pass
+
+    @abstractmethod
+    async def get_task_output(self, task_id: str) -> Any:
         pass
 
     @abstractmethod

{model_compose-0.4.24 → model_compose-0.4.26}/src/mindor/core/controller/runner/http_client.py

@@ -4,6 +4,7 @@ from mindor.core.workflow.schema import WorkflowSchema
 from mindor.core.utils.http_client import HttpClient
 from .client import ControllerClient
 from starlette.datastructures import UploadFile
+import asyncio
 
 class HttpControllerClient(ControllerClient):
     def __init__(self, config: ControllerConfig):
@@ -31,6 +32,20 @@ class HttpControllerClient(ControllerClient):
 
         return await self.client.request("/workflows/runs", "POST", None, body, headers)
 
+    async def resume_workflow(self, task_id: str, job_id: str, answer: Any = None) -> dict:
+        body = { "job_id": job_id, "answer": answer }
+        return await self.client.request(f"/tasks/{task_id}/resume", "POST", None, body, { "Content-Type": "application/json" })
+
+    async def wait_for_completion(self, task_id: str) -> dict:
+        while True:
+            result = await self.client.request(f"/tasks/{task_id}", "GET")
+            if isinstance(result, dict) and result.get("status") in ("interrupted", "completed", "failed"):
+                return result
+            await asyncio.sleep(0.5)
+
+    async def get_task_output(self, task_id: str) -> Any:
+        return await self.client.request(f"/tasks/{task_id}", "GET", params={ "output_only": "true" })
+
     async def close(self) -> None:
         await self.client.close()
 

{model_compose-0.4.24 → model_compose-0.4.26}/src/mindor/core/controller/runner/mcp_client.py

@@ -17,6 +17,15 @@ class McpControllerClient(ControllerClient):
     async def run_workflow(self, workflow_id: Optional[str], input: Any, workflow: WorkflowSchema) -> Any:
         return await self._call_tool(workflow_id or "__workflow__", input, workflow)
 
+    async def resume_workflow(self, task_id: str, job_id: str, answer: Any = None) -> dict:
+        raise NotImplementedError("MCP client does not support workflow interrupts")
+
+    async def wait_for_completion(self, task_id: str) -> dict:
+        raise NotImplementedError("MCP client does not support workflow interrupts")
+
+    async def get_task_output(self, task_id: str) -> Any:
+        raise NotImplementedError("MCP client does not support workflow interrupts")
+
     async def close(self) -> None:
         await self.client.close()
 

{model_compose-0.4.24 → model_compose-0.4.26}/src/mindor/core/controller/runner/runner.py

@@ -27,5 +27,14 @@ class ControllerRunner:
     async def run_workflow(self, workflow_id: Optional[str], input: Any, schema: WorkflowSchema) -> Any:
         return await self.client.run_workflow(workflow_id, input, schema)
 
+    async def resume_workflow(self, task_id: str, job_id: str, answer: Any = None) -> dict:
+        return await self.client.resume_workflow(task_id, job_id, answer)
+
+    async def wait_for_completion(self, task_id: str) -> dict:
+        return await self.client.wait_for_completion(task_id)
+
+    async def get_task_output(self, task_id: str) -> Any:
+        return await self.client.get_task_output(task_id)
+
     async def close(self) -> None:
         await self.client.close()

{model_compose-0.4.24 → model_compose-0.4.26}/src/mindor/core/controller/services/http_server.py

@@ -29,7 +29,7 @@ class WorkflowRunRequestBody(BaseModel):
 
 class WorkflowResumeRequestBody(BaseModel):
     job_id: str
-    data: Optional[Any] = None
+    answer: Optional[Any] = None
 
 class InterruptResult(BaseModel):
     job_id: str
@@ -43,9 +43,7 @@ class InterruptResult(BaseModel):
             job_id=instance.job_id,
             phase=instance.phase,
             message=instance.message,
-            metadata=instance.metadata,
-            input=instance.input,
-            output=instance.output
+            metadata=instance.metadata
         )
 
 class TaskResult(BaseModel):
@@ -217,7 +215,7 @@ class HttpServerController(ControllerService):
             body: WorkflowResumeRequestBody = Body(...)
         ):
             try:
-                state = await self.resume_workflow(task_id, body.job_id, body.data)
+                state = await self.resume_workflow(task_id, body.job_id, body.answer)
                 return JSONResponse(content=TaskResult.to_dict(state))
             except ValueError as e:
                 raise HTTPException(status_code=400, detail=str(e))
@@ -290,7 +288,7 @@ class HttpServerController(ControllerService):
 
     def _render_task_output(self, state: TaskState) -> Response:
         if state.status in [ TaskStatus.PENDING, TaskStatus.PROCESSING, TaskStatus.INTERRUPTED ]:
-            raise HTTPException(status_code=202, detail="Task is still in progress.")
+            return JSONResponse(status_code=202, content=TaskResult.to_dict(state))
 
         if state.status == TaskStatus.FAILED:
             raise HTTPException(status_code=500, detail=str(state.error))

{model_compose-0.4.24 → model_compose-0.4.26}/src/mindor/core/controller/services/mcp_server.py

@@ -50,12 +50,12 @@ class McpServerController(ControllerService):
         self._configure_resume_tool()
 
     def _configure_resume_tool(self) -> None:
-        async def resume_workflow(task_id: str, job_id: str, data: str = "") -> List[ContentBlock]:
-            parsed_data = json.loads(data) if data else None
+        async def resume_workflow(task_id: str, job_id: str, answer: str = "") -> List[ContentBlock]:
+            parsed_answer = json.loads(answer) if answer else None
             try:
-                await self.resume_workflow(task_id, job_id, parsed_data)
+                await self.resume_workflow(task_id, job_id, parsed_answer)
             except ValueError as e:
-                return [TextContent(type="text", text=json.dumps({"error": str(e)}))]
+                return [ TextContent(type="text", text=json.dumps({"error": str(e)})) ]
 
             state = await self.wait_for_terminal_state(task_id)
             return await self._build_state_response(state)
@@ -64,7 +64,7 @@ class McpServerController(ControllerService):
             fn=resume_workflow,
             name="resume_workflow",
             title="Resume an interrupted workflow",
-            description="Resume a workflow that was paused at a Human-in-the-Loop interrupt point.\n\nArgs:\n    task_id (str): The task ID of the interrupted workflow\n    job_id (str): The job ID where the interrupt occurred\n    data (str): Optional JSON string with modified data to resume with",
+            description="Resume a workflow that was paused at a Human-in-the-Loop interrupt point.\n\nArgs:\n    task_id (str): The task ID of the interrupted workflow\n    job_id (str): The job ID where the interrupt occurred\n    answer (str): Optional JSON string with answer to resume with",
             annotations=None
         )
 

{model_compose-0.4.24 → model_compose-0.4.26}/src/mindor/core/controller/webui/gradio.py

@@ -1,6 +1,10 @@
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Awaitable, Any
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Any
 from mindor.dsl.schema.workflow import WorkflowVariableConfig, WorkflowVariableGroupConfig, WorkflowVariableType, WorkflowVariableFormat
 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, BytesStreamResource
 from mindor.core.utils.http_request import create_upload_file
@@ -11,6 +15,9 @@ from PIL import Image as PILImage
 import gradio as gr
 import json, re
 
+if TYPE_CHECKING:
+    from mindor.core.controller.runner import ControllerRunner
+
 _variable_name_regex = re.compile(r"^([^[]+)(?:\[(\w+)\])?$")
 
 class ComponentGroup:
@@ -22,40 +29,62 @@ class GradioWebUIBuilder:
     def __init__(self):
         self.field_resolver: FieldResolver = FieldResolver()
 
-    def build(self, workflow_schemas: Dict[str, WorkflowSchema], workflow_runner: Callable[[Optional[str], Any], Awaitable[Any]]) -> gr.Blocks:
+    def build(self, workflow_schemas: Dict[str, WorkflowSchema], runner: Callable[[], ControllerRunner]) -> gr.Blocks:
         with gr.Blocks() as blocks:
             for workflow_id, workflow in workflow_schemas.items():
-                async def _run_workflow(input: Any, workflow_id=workflow_id) -> Any:
-                    return await workflow_runner(workflow_id, input)
-
                 if len(workflow_schemas) > 1:
                     with gr.Tab(label=workflow.name or workflow_id):
-                        self._build_workflow_section(workflow, _run_workflow)
+                        self._build_workflow_section(workflow_id, workflow, runner)
                 else:
-                    self._build_workflow_section(workflow, _run_workflow)
+                    self._build_workflow_section(workflow_id, workflow, runner)
 
         return blocks
 
-    def _build_workflow_section(self, workflow: WorkflowSchema, runner: Callable[[Any], Awaitable[Any]]) -> gr.Column:
+    def _build_workflow_section(self,
+        workflow_id: str,
+        workflow: WorkflowSchema,
+        runner: Callable[[], ControllerRunner]
+    ) -> gr.Column:
         with gr.Column() as section:
             gr.Markdown(f"## **{workflow.title or 'Untitled Workflow'}**")
 
             if workflow.description:
                 gr.Markdown(f"📝 {workflow.description}")
 
-            gr.Markdown("#### 📥 Input Parameters")
+            gr.Markdown("#### Input Parameters")
             input_components = [ self._build_input_component(variable) for variable in workflow.input ]
+            
             run_button = gr.Button("🚀 Run Workflow", variant="primary")
 
-            gr.Markdown("#### 📤 Output Values")
+            # Interrupt panel (hidden by default)
+            interrupt_state = gr.State(value=None)
+            with gr.Column(visible=False) as interrupt_panel:
+                interrupt_message = gr.Markdown("")
+                interrupt_metadata = gr.JSON(label="Metadata", visible=False)
+                interrupt_answer = gr.Textbox(label="Answer", lines=2, placeholder="Press Resume to continue, or type an answer (JSON or text)")
+                resume_button = gr.Button("▶️ Resume", variant="primary")
+
+            interrupt_outputs = [ interrupt_state, interrupt_panel, interrupt_message, interrupt_metadata, interrupt_answer ]
+
+            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, buttons=["copy"]) ]
 
+            output_components = self._flatten_output_components(output_components)
+
             async def _run_workflow(*args):
-                input = await self._build_input_value(args, workflow.input)
-                output = await runner(input)
+                input  = await self._build_input_value(args, workflow.input)
+                output = await runner().run_workflow(workflow_id, input, workflow)
+
+                # Check if the result is an interrupted TaskResult
+                if isinstance(output, dict) and output.get("status") == "interrupted" and "task_id" in output:
+                    yield self._build_interrupt_updates(output) + tuple(gr.update() for _ in output_components)
+                    return
+
+                # Clear interrupt panel for normal results
+                clear_interrupt = self._clear_interrupt_updates()
 
                 if len(workflow.output) == 1 and self._is_streaming_variable(workflow.output[0]):
                     buffer = "" if workflow.output[0].type == WorkflowVariableType.TEXT else []
@@ -65,16 +94,64 @@ class GradioWebUIBuilder:
                             buffer += chunk[0] or ""
                         else:
                             buffer.append(chunk[0])
-                        yield buffer
+                        yield clear_interrupt + (buffer,)
                 else:
                     if workflow.output:
                         output = await self._flatten_output_value(output, workflow.output)
-                    yield output[0] if len(output) == 1 else output
+                    result = output[0] if len(output) == 1 else output
+                    if isinstance(result, (list, tuple)):
+                        yield clear_interrupt + tuple(result)
+                    else:
+                        yield clear_interrupt + (result,)
+
+            async def _resume_workflow(state: Optional[Dict[str, str]], answer_text: str):
+                task_id, job_id = state["task_id"], state["job_id"]
+
+                # Parse answer: try JSON first, fallback to string
+                answer = answer_text
+                if answer_text:
+                    try:
+                        answer = json.loads(answer_text)
+                    except (json.JSONDecodeError, TypeError):
+                        pass
+
+                await runner().resume_workflow(task_id, job_id, answer if answer_text else None)
+                result = await runner().wait_for_completion(task_id)
+
+                if result.get("status") == "interrupted":
+                    yield self._build_interrupt_updates(result) + tuple(gr.update() for _ in output_components)
+                    return
+
+                clear_interrupt = self._clear_interrupt_updates()
+
+                if result.get("status") == "failed":
+                    raise gr.Error(str(result.get("error", "Workflow failed")))
+
+                # Completed — fetch output
+                output = await runner().get_task_output(task_id)
+                if workflow.output and output is not None:
+                    output = await self._flatten_output_value(output, workflow.output)
+                    result = output[0] if len(output) == 1 else output
+                else:
+                    result = output
+
+                if result is None:
+                    yield clear_interrupt + tuple(gr.update() for _ in output_components)
+                elif isinstance(result, (list, tuple)):
+                    yield clear_interrupt + tuple(result)
+                else:
+                    yield clear_interrupt + (result,)
 
             run_button.click(
                 fn=_run_workflow,
                 inputs=input_components,
-                outputs=self._flatten_output_components(output_components)
+                outputs=interrupt_outputs + output_components
+            )
+
+            resume_button.click(
+                fn=_resume_workflow,
+                inputs=[interrupt_state, interrupt_answer],
+                outputs=interrupt_outputs + output_components
             )
 
         return section
@@ -148,6 +225,29 @@ class GradioWebUIBuilder:
 
         return value if value != "" else None
 
+    def _build_interrupt_updates(self, result: dict) -> tuple:
+        interrupt = result.get("interrupt", {})
+        state = { "task_id": result["task_id"], "job_id": interrupt.get("job_id") }
+        message = interrupt.get("message") or "The workflow is waiting for your input."
+        metadata = interrupt.get("metadata")
+
+        return (
+            state,
+            gr.update(visible=True),
+            gr.update(value=message),
+            gr.update(value=metadata, visible=metadata is not None),
+            gr.update(value=""),
+        )
+
+    def _clear_interrupt_updates(self) -> tuple:
+        return (
+            None,
+            gr.update(visible=False),
+            gr.update(value=""),
+            gr.update(value=None, visible=False),
+            gr.update(value=""),
+        )
+
     def _build_output_component(self, variable: Union[WorkflowVariableConfig, WorkflowVariableGroupConfig]) -> Union[gr.Component, List[ComponentGroup]]:
         if isinstance(variable, WorkflowVariableGroupConfig):
             groups: List[ComponentGroup] = []
@@ -196,7 +296,7 @@ class GradioWebUIBuilder:
             else:
                 flattened.append(item)
         return flattened
-    
+
     async def _flatten_output_value(self, output: Any, variables: List[Union[WorkflowVariableConfig, WorkflowVariableGroupConfig]]) -> Any:
         flattened = []
         for variable in variables:

{model_compose-0.4.24 → model_compose-0.4.26}/src/mindor/core/controller/webui/webui.py

@@ -1,4 +1,4 @@
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated
 from mindor.dsl.schema.controller import ControllerConfig
 from mindor.dsl.schema.controller.webui import ControllerWebUIConfig, ControllerWebUIDriver
 from mindor.dsl.schema.component import ComponentConfig
@@ -38,14 +38,14 @@ class ControllerWebUI(AsyncService):
         if self.config.driver == ControllerWebUIDriver.GRADIO:
             blocks = GradioWebUIBuilder().build(
                 workflow_schemas=self.workflow_schemas,
-                workflow_runner=self._run_workflow
+                runner=lambda: self.runner
             )
             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(), 
+                directory=Path(self.config.static_dir).resolve(),
                 html=True
             )
             self.app.mount("/", static_files, name="static")
@@ -65,12 +65,7 @@ class ControllerWebUI(AsyncService):
             await self.runner.close()
             self.server = None
             self.runner = None
-    
+
     async def _shutdown(self) -> None:
         if self.server:
             self.server.should_exit = True
-
-    async def _run_workflow(self, workflow_id: Optional[str], input: Any) -> Any:
-        if self.runner:
-            return await self.runner.run_workflow(workflow_id, input, self.workflow_schemas[workflow_id])
-        return None

{model_compose-0.4.24 → model_compose-0.4.26}/src/mindor/core/workflow/context.py

@@ -3,8 +3,7 @@ from mindor.core.utils.renderers import VariableRenderer, ImageValueRenderer
 from mindor.core.workflow.interrupt import InterruptHandler
 
 class WorkflowContext:
-    def __init__(self, task_id: str, input: Dict[str, Any],
-                 interrupt_handler: Optional[InterruptHandler] = None):
+    def __init__(self, task_id: str, input: Dict[str, Any], interrupt_handler: Optional[InterruptHandler] = None):
         self.task_id: str = task_id
         self.input: Dict[str, Any] = input
         self.context: Dict[str, Any] = { "task_id": task_id }

{model_compose-0.4.24 → model_compose-0.4.26}/src/mindor/core/workflow/interrupt.py

@@ -28,7 +28,7 @@ class InterruptHandler:
 
         return await point.future
 
-    def resolve(self, task_id: str, job_id: str, data: Any) -> bool:
+    def resolve(self, task_id: str, job_id: str, answer: Any) -> bool:
         with self._lock:
             point = self._pop_point(task_id, job_id)
 
@@ -36,7 +36,7 @@ class InterruptHandler:
             return False
 
         loop = point.future.get_loop()
-        loop.call_soon_threadsafe(point.future.set_result, data)
+        loop.call_soon_threadsafe(point.future.set_result, answer)
 
         return True