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

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

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

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

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

@@ -1,6 +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
 
@@ -17,7 +18,7 @@ def prompt_for_interrupt(state: TaskState) -> Any:
         click.echo(json.dumps(interrupt.metadata, indent=2, ensure_ascii=False), err=True)
 
     click.echo("", err=True)
-    click.echo("✋ Action required — press Enter to continue, or type a response (JSON or text):", err=True)
+    click.echo("✋ Action required — press Enter to continue, or type an answer (JSON or text):", err=True)
     raw = input()
 
     if not raw:

{model_compose-0.4.25 → 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.25 → 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}'")
 

{model_compose-0.4.25 → 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.25 → 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.25 → 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.25 → 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.25 → 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.25 → 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.25 → 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.25 → 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.25 → 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
 

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

@@ -178,8 +178,5 @@ class Workflow:
     def validate(self) -> None:
         JobGraphValidator(self.config.jobs).validate()
 
-    def uses_interrupts(self) -> bool:
-        return any(getattr(job, "interrupt", None) for job in self.config.jobs)
-
 def create_workflow(id: str, config: WorkflowConfig, global_configs: ComponentGlobalConfigs) -> Workflow:
     return Workflow(id, config, global_configs)

{model_compose-0.4.25 → model_compose-0.4.26}/src/model_compose.egg-info/PKG-INFO

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