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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.4.24"
+version = "0.4.25"
 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.25}/src/mindor/cli/interrupt.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 from typing import TYPE_CHECKING, Any
+
 import click
 import json
 
@@ -9,17 +10,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 a response (JSON or text):", err=True)
+    raw = input()
 
     if not raw:
         return None

{model_compose-0.4.24 → model_compose-0.4.25}/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.25}/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.25}/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.25}/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.25}/src/mindor/core/controller/base.py

@@ -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.25}/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.25}/src/mindor/core/workflow/job/impl/action.py

@@ -36,7 +36,7 @@ class ActionJob(Job):
                 if answer is not None:
                     input = answer
 
-            output = await component.run(self.config.action, run_id, input)
+            output = await component.run(self.config.action, run_id, input, workflow=context)
             context.register_source("output", output)
 
             if self.config.interrupt and self.config.interrupt.after:
@@ -59,16 +59,16 @@ class ActionJob(Job):
 
         return output
 
-    async def _interrupt(self, context: WorkflowContext, phase: str, config: ActionInterruptPointConfig) -> Any:
-        if config.condition:
-            input  = await context.render_variable(config.condition.input)
-            value  = await context.render_variable(config.condition.value)
-            if not evaluate_condition(config.condition.operator, input, value):
+    async def _interrupt(self, context: WorkflowContext, phase: str, point: ActionInterruptPointConfig) -> Any:
+        if point.condition:
+            input  = await context.render_variable(point.condition.input)
+            value  = await context.render_variable(point.condition.value)
+            if not evaluate_condition(point.condition.operator, input, value):
                 logging.debug("[task-%s] Job '%s' interrupt at '%s' phase skipped: condition not met.", context.task_id, self.id, phase)
                 return None
 
-        message  = (await context.render_variable(config.message) ) if config.message  else None
-        metadata = (await context.render_variable(config.metadata)) if config.metadata else None
+        message  = (await context.render_variable(point.message) ) if point.message  else None
+        metadata = (await context.render_variable(point.metadata)) if point.metadata else None
 
         loop = asyncio.get_running_loop()
         future = loop.create_future()

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

@@ -21,16 +21,16 @@ class WorkflowTool:
     parameters: List[WorkflowToolParameter]
 
 class WorkflowToolGenerator():
-    def generate(self, workflow_id: str, workflow: WorkflowSchema, runner: Callable[[Optional[str], Any], Awaitable[Any]]) -> WorkflowTool:
-        async def _run_workflow(input: Any, workflow_id=workflow_id) -> Any:
-            return await runner(workflow_id, input)
+    def generate(self, workflow_id: str, workflow: WorkflowSchema, runner: Callable[[str, Any, Any], Awaitable[Any]]) -> WorkflowTool:
+        async def _run_workflow(workflow_id, input: Any, context=None) -> Any:
+            return await runner(workflow_id, input, context)
 
         async def _build_input_value(arguments, workflow=workflow) -> Any:
             return await self._build_input_value(arguments, workflow)
 
         safe_workflow_id = re.sub(_invalid_function_chars_regex, "_", workflow_id)
         arguments = ",".join([ variable.name or "input" for variable in workflow.input ])
-        code = f"async def _run_workflow_{safe_workflow_id}({arguments}): return await _run_workflow(await _build_input_value([{arguments}]))"
+        code = f"async def _run_workflow_{safe_workflow_id}({arguments}, context=None): return await _run_workflow('{workflow_id}', await _build_input_value([{arguments}]), context=context)"
         context = { "_run_workflow": _run_workflow, "_build_input_value": _build_input_value }
         exec(compile(code, f"<string>", "exec"), context)
 

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

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