model-compose 0.4.66__tar.gz → 0.4.67__tar.gz

{model_compose-0.4.66 → model_compose-0.4.67}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.4.66
+Version: 0.4.67
 Summary: model-compose: Declarative AI Workflow Orchestrator
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT
@@ -49,7 +49,7 @@ Dynamic: license-file
 
 **Compose AI Systems, Deploy Anywhere.**
 
-Define workflows, agents, models, and comprehensive AI services in YAML. Run them locally, scale them in production, and deploy across any environment without rewriting your stack.
+Define AI workflows, agents, models, and tools in a single YAML file — then run them locally, in containers, or in production without rewriting your stack.
 
 Inspired by `docker-compose` — one YAML file defines your entire AI system.
 
@@ -476,7 +476,7 @@ Whether it's fixing bugs, improving docs, or adding examples — every bit helps
 # Setup for development
 git clone https://github.com/hanyeol/model-compose.git
 cd model-compose
-pip install -e .[dev]
+pip install -e .
 ```
 
 ---

{model_compose-0.4.66 → model_compose-0.4.67}/README.md

@@ -18,7 +18,7 @@
 
 **Compose AI Systems, Deploy Anywhere.**
 
-Define workflows, agents, models, and comprehensive AI services in YAML. Run them locally, scale them in production, and deploy across any environment without rewriting your stack.
+Define AI workflows, agents, models, and tools in a single YAML file — then run them locally, in containers, or in production without rewriting your stack.
 
 Inspired by `docker-compose` — one YAML file defines your entire AI system.
 
@@ -445,7 +445,7 @@ Whether it's fixing bugs, improving docs, or adding examples — every bit helps
 # Setup for development
 git clone https://github.com/hanyeol/model-compose.git
 cd model-compose
-pip install -e .[dev]
+pip install -e .
 ```
 
 ---

{model_compose-0.4.66 → model_compose-0.4.67}/pyproject.toml

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

{model_compose-0.4.66 → model_compose-0.4.67}/src/mindor/core/component/services/datasets/datasets.py

@@ -110,10 +110,10 @@ class DatasetsAction:
         if not isinstance(dataset, Dataset):
             raise ValueError(f"Expected Dataset instance, but got {type(dataset).__name__}")
 
-        def format_example(example):
+        def _format_example(example):
             return { output_column: format_template_example(template, example) }
 
-        return dataset.map(format_example, remove_columns=remove_columns)
+        return dataset.map(_format_example, remove_columns=remove_columns)
 
 @register_component(ComponentType.DATASETS)
 class DatasetsComponent(ComponentService):

{model_compose-0.4.66 → model_compose-0.4.67}/src/mindor/core/component/services/http_client.py

@@ -25,9 +25,9 @@ class HttpClientPollingCompletion(HttpClientCompletion):
     async def run(self, context: ComponentActionContext, client: HttpClient, streaming: bool = False) -> Any:
         url_or_path = await self._resolve_url_or_path(context)
         method      = await context.render_variable(self.config.method)
-        params      = await context.render_variable(self.config.params)
+        params      = _drop_none_values(await context.render_variable(self.config.params))
         body        = await context.render_variable(self.config.body)
-        headers     = await context.render_variable(self.config.headers)
+        headers     = _drop_none_values(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)

{model_compose-0.4.66 → model_compose-0.4.67}/src/mindor/core/component/services/model/tasks/image_upscale/custom/real_esrgan.py

@@ -57,10 +57,11 @@ class RealEsrganImageUpscaleTaskService(ImageUpscaleTaskService):
 
     def _patch_huggingface_hub_compatibility(self) -> None:
         import huggingface_hub as hub
+    
         if not hasattr(hub, "cached_download"):
-            def cached_download(*args, **kwargs):
+            def _raise_not_implemented(*args, **kwargs):
                 raise NotImplementedError("cached_download is deprecated; not intended to be used.")
-            hub.cached_download = cached_download
+            hub.cached_download = _raise_not_implemented
 
     def get_setup_requirements(self) -> Optional[List[str]]:
         return [ "realesrgan>=1.0@git+https://github.com/sberbank-ai/Real-ESRGAN.git" ]

{model_compose-0.4.66 → model_compose-0.4.67}/src/mindor/core/compose/validator.py

@@ -202,7 +202,7 @@ class ComposeValidator:
         visiting: Set[str] = set()
         visited: Set[str] = set()
 
-        def detect_cycle(job_id: str):
+        def _detect_cycle(job_id: str):
             if job_id in visiting:
                 self.errors.append(
                     f"workflows[{workflow_index}]: Dependency cycle detected involving job '{job_id}' in workflow '{workflow_id}'"
@@ -215,11 +215,11 @@ class ComposeValidator:
             visiting.add(job_id)
 
             for dependency_id in job_map[job_id].depends_on:
-                detect_cycle(dependency_id)
+                _detect_cycle(dependency_id)
 
             visiting.remove(job_id)
             visited.add(job_id)
 
         for job in job_map.values():
             if job.id not in visited:
-                detect_cycle(job.id)
+                _detect_cycle(job.id)

{model_compose-0.4.66 → model_compose-0.4.67}/src/mindor/core/controller/adapters/services/http_server.py

@@ -12,7 +12,7 @@ from mindor.core.utils.http_request import parse_request_body, parse_options_hea
 from mindor.core.utils.http_response import HttpEventStreamer
 from mindor.core.utils.image import ImageStreamResource
 from mindor.core.utils.streaming import StreamResource, EventIteratorStreamResource
-from mindor.core.controller.base import TaskState, TaskStatus, InterruptState
+from mindor.core.controller.base import TaskState, TaskStatus, InterruptState, JobEvent
 from mindor.core.workflow.schema import WorkflowSchema
 from mindor.core.workflow import WorkflowResolver
 from ..base import ControllerAdapterService, register_controller_adapter
@@ -370,6 +370,7 @@ class HttpServerControllerAdapterService(ControllerAdapterService):
 
     async def _start(self) -> None:
         self.controller.add_task_state_listener(self._on_task_state_change)
+        self.controller.add_job_event_listener(self._on_job_event)
         await super()._start()
 
     async def _serve(self) -> None:
@@ -386,7 +387,9 @@ class HttpServerControllerAdapterService(ControllerAdapterService):
 
     async def _shutdown(self) -> None:
         self.controller.remove_task_state_listener(self._on_task_state_change)
+        self.controller.remove_job_event_listener(self._on_job_event)
         await self.websocket_manager.disconnect_all()
+
         if self.server:
             self.server.should_exit = True
 
@@ -400,6 +403,16 @@ class HttpServerControllerAdapterService(ControllerAdapterService):
                 }
             )
 
+    async def _on_job_event(self, event: JobEvent) -> None:
+        if self.websocket_manager.has_task_subscribers(event.task_id):
+            await self.websocket_manager.broadcast_to_task_subscribers(
+                event.task_id,
+                {
+                    "type": "job_event",
+                    "data": self._serialize_job_event(event)
+                }
+            )
+
     def _serialize_task_state(self, task_id: str, state: TaskState) -> dict:
         result = {
             "task_id": task_id,
@@ -428,6 +441,33 @@ class HttpServerControllerAdapterService(ControllerAdapterService):
             }
         return result
 
+    def _serialize_job_event(self, event: JobEvent) -> dict:
+        result = {
+            "task_id": event.task_id,
+            "run_id": event.run_id,
+            "workflow_id": event.workflow_id,
+            "job_id": event.job_id,
+            "event": event.event,
+            "elapsed": None,
+            "output": None,
+            "error": None,
+            "next_job_id": None,
+            "timestamp": datetime.now(timezone.utc).isoformat()
+        }
+        if event.elapsed is not None:
+            result["elapsed"] = event.elapsed
+        if event.output is not None:
+            try:
+                json.dumps(event.output)
+                result["output"] = event.output
+            except (TypeError, ValueError):
+                result["output"] = None
+        if event.error:
+            result["error"] = str(event.error)
+        if event.next_job_id:
+            result["next_job_id"] = event.next_job_id
+        return result
+
     async def _handle_websocket_message(self, client_id: str, raw: str) -> None:
         try:
             message = json.loads(raw)

{model_compose-0.4.66 → model_compose-0.4.67}/src/mindor/core/controller/adapters/services/mcp_server.py

@@ -49,7 +49,7 @@ class McpServerControllerAdapterService(ControllerAdapterService):
         self._configure_resume_tool()
 
     def _configure_resume_tool(self) -> None:
-        async def resume_workflow(task_id: str, job_id: str, answer: str = "") -> List[ContentBlock]:
+        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.controller.resume_workflow(task_id, job_id, parsed_answer)
@@ -60,7 +60,7 @@ class McpServerControllerAdapterService(ControllerAdapterService):
             return await self._build_state_response(state)
 
         self.app.add_tool(
-            fn=resume_workflow,
+            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    answer (str): Optional JSON string with answer to resume with",

{model_compose-0.4.66 → model_compose-0.4.67}/src/mindor/core/controller/adapters/services/queue_subscriber/drivers/redis.py

@@ -5,6 +5,8 @@ from typing import Optional, Dict, List, Any
 from collections.abc import AsyncIterator
 from mindor.dsl.schema.controller import RedisQueueSubscriberControllerAdapterConfig, QueueSubscriberDriver
 from mindor.core.controller.base import TaskState, TaskStatus
+from mindor.core.controller.queue.serialize import deserialize_input
+from mindor.core.controller.queue.errors import BlobNotFoundError, BlobCorruptedError, BlobUnauthorizedError,
 from mindor.core.utils.time import parse_duration
 from mindor.core.logger import logging
 from ..base import CommonQueueSubscriberControllerAdapterService, register_queue_subscriber_controller_adapter_service
@@ -22,7 +24,7 @@ class RedisCommonQueueSubscriberControllerAdapterService(CommonQueueSubscriberCo
         daemon: bool
     ):
         super().__init__(config, controller, daemon)
-        self._redis = None
+        self._client = None
         self._workers: List[asyncio.Task] = []
         self._stop_event: asyncio.Event = asyncio.Event()
         self._worker_id: str = config.worker_id or ulid.ulid()
@@ -33,11 +35,11 @@ class RedisCommonQueueSubscriberControllerAdapterService(CommonQueueSubscriberCo
     async def _serve(self) -> None:
         import redis.asyncio as aioredis
 
-        self._redis = aioredis.from_url(
+        self._client = aioredis.from_url(
             self._build_redis_url(),
             db=self.config.database,
             password=self.config.password,
-            decode_responses=True,
+            decode_responses=False,
         )
 
         workflows = self.config.workflows or list(self.controller.workflow_schemas.keys())
@@ -51,8 +53,8 @@ class RedisCommonQueueSubscriberControllerAdapterService(CommonQueueSubscriberCo
         try:
             await asyncio.gather(*self._workers)
         finally:
-            await self._redis.aclose()
-            self._redis = None
+            await self._client.aclose()
+            self._client = None
 
     async def _shutdown(self) -> None:
         self._stop_event.set()
@@ -63,13 +65,13 @@ class RedisCommonQueueSubscriberControllerAdapterService(CommonQueueSubscriberCo
     async def _consumer_loop(self, worker_index: int, queue_keys: list[str]) -> None:
         while not self._stop_event.is_set():
             try:
-                result = await self._redis.brpop(queue_keys, timeout=int(parse_duration(self.config.pop_timeout).total_seconds()))
+                result = await self._client.brpop(queue_keys, timeout=int(parse_duration(self.config.pop_timeout).total_seconds()))
 
                 if result is None:
                     continue
 
                 queue_key, raw_message = result
-                workflow_id = self._workflow_id_from_queue_key(queue_key)
+                workflow_id = self._workflow_id_from_queue_key(queue_key.decode("utf-8"))
 
                 try:
                     message = json.loads(raw_message)
@@ -87,16 +89,24 @@ class RedisCommonQueueSubscriberControllerAdapterService(CommonQueueSubscriberCo
         task_id = message.get("task_id")
         run_id  = message.get("run_id")
         input   = message.get("input", {})
-        result_key = f"{self.config.name}:{workflow_id}:{run_id}"
-        resume_key = f"{result_key}:resume"
+        result_key  = f"{self.config.name}:{workflow_id}:{run_id}"
+        resume_key  = f"{result_key}:resume"
+        blob_prefix = f"{self.config.name}:{workflow_id}:{run_id}:blob:"
+
+        try:
+            input = await deserialize_input(input, self._client, blob_prefix)
+        except (BlobNotFoundError, BlobCorruptedError, BlobUnauthorizedError) as e:
+            state = TaskState(task_id=task_id, status=TaskStatus.FAILED, error=str(e))
+            await self._publish_result(workflow_id, task_id, run_id, state)
+            return
 
-        async def on_interrupt(interrupt):
+        async def _on_interrupt(interrupt):
             state = TaskState(task_id=task_id, status=TaskStatus.INTERRUPTED, interrupt=interrupt)
             await self._publish_result(workflow_id, task_id, run_id, state)
             return await self._wait_for_resume(resume_key)
 
         try:
-            state = await self.controller.run_workflow(workflow_id, input, wait_for_completion=True, on_interrupt=on_interrupt)
+            state = await self.controller.run_workflow(workflow_id, input, wait_for_completion=True, on_interrupt=_on_interrupt)
         except Exception as e:
             state = TaskState(task_id=task_id, status=TaskStatus.FAILED, error=str(e))
 
@@ -106,7 +116,7 @@ class RedisCommonQueueSubscriberControllerAdapterService(CommonQueueSubscriberCo
             await self._publish_result(workflow_id, task_id, run_id, state)
 
     async def _wait_for_resume(self, resume_key: str) -> Any:
-        pubsub = self._redis.pubsub()
+        pubsub = self._client.pubsub()
         await pubsub.subscribe(resume_key)
 
         try:
@@ -131,11 +141,11 @@ class RedisCommonQueueSubscriberControllerAdapterService(CommonQueueSubscriberCo
 
         result_ttl = int(parse_duration(self.config.result_ttl).total_seconds())
         if result_ttl > 0:
-            await self._redis.setex(result_key, result_ttl, result)
+            await self._client.setex(result_key, result_ttl, result)
         else:
-            await self._redis.set(result_key, result)
+            await self._client.set(result_key, result)
 
-        await self._redis.publish(result_key, result)
+        await self._client.publish(result_key, result)
 
     async def _publish_stream_result(self, workflow_id: str, task_id: str, run_id: str, state: TaskState) -> None:
         result_key = f"{self.config.name}:{workflow_id}:{run_id}"
@@ -149,19 +159,19 @@ class RedisCommonQueueSubscriberControllerAdapterService(CommonQueueSubscriberCo
             "worker_id": self._worker_id,
             "stream_key": stream_key,
         })
-        await self._redis.publish(result_key, result)
+        await self._client.publish(result_key, result)
 
         try:
             async for chunk in state.output:
                 data = chunk if isinstance(chunk, str) else json.dumps(chunk, default=str, ensure_ascii=False)
-                await self._redis.xadd(stream_key, { "event": "chunk", "data": data })
+                await self._client.xadd(stream_key, { "event": "chunk", "data": data })
 
-            await self._redis.xadd(stream_key, { "event": "done" })
+            await self._client.xadd(stream_key, { "event": "done" })
         except Exception as e:
-            await self._redis.xadd(stream_key, { "event": "error", "data": str(e) })
+            await self._client.xadd(stream_key, { "event": "error", "data": str(e) })
         finally:
             if result_ttl > 0:
-                await self._redis.expire(stream_key, result_ttl)
+                await self._client.expire(stream_key, result_ttl)
 
             if hasattr(state.output, 'aclose'):
                 await state.output.aclose()

{model_compose-0.4.66 → model_compose-0.4.67}/src/mindor/core/controller/base.py

@@ -66,7 +66,20 @@ class TaskState:
     session_id: Optional[str] = None
     metadata: Optional[Any] = None
 
+@dataclass
+class JobEvent:
+    task_id: str
+    workflow_id: str
+    job_id: str
+    event: Literal[ "started", "completed", "failed", "routed" ]
+    run_id: Optional[Union[str, List[str]]] = None
+    elapsed: Optional[float] = None
+    output: Optional[Any] = None
+    error: Optional[str] = None
+    next_job_id: Optional[str] = None
+
 TaskStateListener = Callable[['str', 'TaskState'], Awaitable[None]]
+JobEventListener = Callable[['JobEvent'], Awaitable[None]]
 
 class ControllerService(AsyncService):
     _shared_instance: Optional[ControllerService] = None
@@ -114,6 +127,7 @@ class ControllerService(AsyncService):
         self._inflight_tasks: Set[asyncio.Task] = set()
         self._shutting_down: bool = False
         self._task_state_listeners: List[TaskStateListener] = []
+        self._job_event_listeners: List[JobEventListener] = []
         self._listener_tasks: Set[asyncio.Task] = set()
 
         if self.config.max_concurrent_count > 0:
@@ -250,8 +264,8 @@ class ControllerService(AsyncService):
             state = TaskState(task_id=task_id, status=TaskStatus.FAILED, workflow_id=workflow_id, error=str(e), session_id=session_id, metadata=metadata)
             with self.task_states_lock:
                 self.task_states.set(task_id, state, 1 * 3600)
+            self._signal_task_state_change(task_id)
             self._notify_task_state_change(task_id)
-            self._invoke_task_state_listeners(task_id)
             raise
 
         self._inflight_tasks.add(task)
@@ -287,8 +301,8 @@ class ControllerService(AsyncService):
         new_state = TaskState(task_id=task_id, status=TaskStatus.PROCESSING, workflow_id=state.workflow_id, session_id=state.session_id, metadata=state.metadata)
         with self.task_states_lock:
             self.task_states.set(task_id, new_state)
+        self._signal_task_state_change(task_id)
         self._notify_task_state_change(task_id)
-        self._invoke_task_state_listeners(task_id)
 
         return new_state
 
@@ -305,6 +319,16 @@ class ControllerService(AsyncService):
         except ValueError:
             pass
 
+    def add_job_event_listener(self, listener: JobEventListener) -> None:
+        if listener not in self._job_event_listeners:
+            self._job_event_listeners.append(listener)
+
+    def remove_job_event_listener(self, listener: JobEventListener) -> None:
+        try:
+            self._job_event_listeners.remove(listener)
+        except ValueError:
+            pass
+
     def get_task_state(self, task_id: str) -> Optional[TaskState]:
         with self.task_states_lock:
             return self.task_states.get(task_id)
@@ -517,17 +541,31 @@ class ControllerService(AsyncService):
         state = TaskState(task_id=task_id, status=TaskStatus.PROCESSING, workflow_id=workflow_id, session_id=session_id, metadata=metadata)
         with self.task_states_lock:
             self.task_states.set(task_id, state)
+        self._signal_task_state_change(task_id)
         self._notify_task_state_change(task_id)
-        self._invoke_task_state_listeners(task_id)
+
+        async def _on_job_event(payload: Dict[str, Any]) -> None:
+            event = JobEvent(
+                task_id=task_id,
+                workflow_id=payload.get("workflow_id") or workflow_id,
+                job_id=payload["job_id"],
+                event=payload["event"],
+                run_id=payload.get("run_id"),
+                elapsed=payload.get("elapsed"),
+                output=payload.get("output"),
+                error=payload.get("error"),
+                next_job_id=payload.get("next_job_id"),
+            )
+            self._notify_job_event(event)
 
         try:
-            async def run_workflow(workflow_id, input, interrupt_handler):
+            async def _run_workflow(workflow_id, input, interrupt_handler):
                 if self._queue and not any(workflow.id == workflow_id for workflow in self.workflows):
                     return await self._queue.dispatch(task_id, workflow_id, input, interrupt_handler)
-                return await self._create_workflow(workflow_id).run(task_id, input, interrupt_handler, run_workflow, session_id=session_id, metadata=metadata)
+                return await self._create_workflow(workflow_id).run(task_id, input, interrupt_handler, _run_workflow, session_id=session_id, metadata=metadata, on_job_event=_on_job_event)
 
             interrupt_handler = self._attach_interrupt_handler(task_id, workflow_id, on_interrupt, task_metadata=metadata)
-            output = await run_workflow(workflow_id, input, interrupt_handler)
+            output = await _run_workflow(workflow_id, input, interrupt_handler)
             state = TaskState(task_id=task_id, status=TaskStatus.COMPLETED, workflow_id=workflow_id, output=output, session_id=session_id, metadata=metadata)
         except Exception as e:
             import traceback
@@ -538,8 +576,8 @@ class ControllerService(AsyncService):
 
         with self.task_states_lock:
             self.task_states.set(task_id, state, 1 * 3600)
+        self._signal_task_state_change(task_id)
         self._notify_task_state_change(task_id)
-        self._invoke_task_state_listeners(task_id)
 
         return state
 
@@ -567,7 +605,7 @@ class ControllerService(AsyncService):
         on_interrupt: Optional[Callable[[InterruptState], Awaitable[Any]]] = None,
         task_metadata: Optional[Any] = None
     ) -> InterruptHandler:
-        async def callback(point: InterruptPoint):
+        async def _callback(point: InterruptPoint):
             interrupt = InterruptState(
                 job_id=point.job_id,
                 phase=point.phase,
@@ -578,14 +616,14 @@ class ControllerService(AsyncService):
             state = TaskState(task_id=task_id, status=TaskStatus.INTERRUPTED, workflow_id=workflow_id, interrupt=interrupt, session_id=session_id, metadata=task_metadata)
             with self.task_states_lock:
                 self.task_states.set(task_id, state)
+            self._signal_task_state_change(task_id)
             self._notify_task_state_change(task_id)
-            self._invoke_task_state_listeners(task_id)
 
             if on_interrupt:
                 answer = await on_interrupt(interrupt)
                 point.future.set_result(answer)
 
-        handler = InterruptHandler(callback)
+        handler = InterruptHandler(_callback)
         self.interrupt_handlers[task_id] = handler
 
         return handler
@@ -604,21 +642,19 @@ class ControllerService(AsyncService):
         error_state = TaskState(task_id=task_id, status=TaskStatus.FAILED, workflow_id=workflow_id, error=str(task.exception()), session_id=state.session_id if state else None, metadata=state.metadata if state else None)
         with self.task_states_lock:
             self.task_states.set(task_id, error_state, 1 * 3600)
+        self._signal_task_state_change(task_id)
         self._notify_task_state_change(task_id)
-        self._invoke_task_state_listeners(task_id)
 
-    def _notify_task_state_change(self, task_id: str) -> None:
+    def _signal_task_state_change(self, task_id: str) -> None:
         event = self.task_events.get(task_id)
         if event:
             event.set()
 
-    def _invoke_task_state_listeners(self, task_id: str) -> None:
+    def _notify_task_state_change(self, task_id: str) -> None:
         state = self.get_task_state(task_id)
         if state and self._task_state_listeners:
-            for listener in list(self._task_state_listeners):
-                task = asyncio.create_task(
-                    self._invoke_task_state_listener(listener, task_id, state)
-                )
+            for listener in self._task_state_listeners:
+                task = asyncio.create_task(self._invoke_task_state_listener(listener, task_id, state))
                 self._listener_tasks.add(task)
                 task.add_done_callback(self._listener_tasks.discard)
 
@@ -628,6 +664,18 @@ class ControllerService(AsyncService):
         except Exception:
             logging.warning("Task state listener error for task %s", task_id, exc_info=True)
 
+    def _notify_job_event(self, event: JobEvent) -> None:
+        for listener in self._job_event_listeners:
+            task = asyncio.create_task(self._invoke_job_event_listener(listener, event))
+            self._listener_tasks.add(task)
+            task.add_done_callback(self._listener_tasks.discard)
+
+    async def _invoke_job_event_listener(self, listener: JobEventListener, event: JobEvent) -> None:
+        try:
+            await listener(event)
+        except Exception:
+            logging.warning("Job event listener error for task %s job %s", event.task_id, event.job_id, exc_info=True)
+
     async def _cancel_pending_listener_tasks(self) -> None:
         for task in list(self._listener_tasks):
             task.cancel()

{model_compose-0.4.66 → model_compose-0.4.67}/src/mindor/core/controller/queue/base.py

@@ -23,7 +23,7 @@ class CommonControllerQueueService(AsyncService):
         input: Dict[str, Any],
         interrupt_handler: InterruptHandler
     ) -> Any:
-        async def on_interrupt(data: Dict[str, Any]) -> Any:
+        async def _on_interrupt(data: Dict[str, Any]) -> Any:
             point = InterruptPoint(
                 task_id=task_id,
                 job_id=data.get("job_id", ""),
@@ -35,7 +35,7 @@ class CommonControllerQueueService(AsyncService):
             await interrupt_handler.interrupt(point)
             return await point.future
 
-        return await self._dispatch(task_id, workflow_id, input, on_interrupt)
+        return await self._dispatch(task_id, workflow_id, input, _on_interrupt)
 
     @abstractmethod
     async def _dispatch(