model-compose 0.4.71__tar.gz → 0.4.72__tar.gz

{model_compose-0.4.71 → model_compose-0.4.72}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.4.71
+Version: 0.4.72
 Summary: model-compose: Declarative AI Workflow Orchestrator
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT
@@ -22,7 +22,6 @@ Requires-Dist: websockets
 Requires-Dist: uvicorn
 Requires-Dist: mcp>=1.10.1
 Requires-Dist: ulid
-Requires-Dist: gradio>=6.0.0
 Requires-Dist: Pillow
 Requires-Dist: beautifulsoup4
 Requires-Dist: lxml

{model_compose-0.4.71 → model_compose-0.4.72}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.4.71"
+version = "0.4.72"
 description = "model-compose: Declarative AI Workflow Orchestrator"
 authors = [
     { name = "Hanyeol Cho", email = "hanyeol.cho@gmail.com" }
@@ -23,7 +23,6 @@ dependencies = [
     "uvicorn",
     "mcp>=1.10.1",
     "ulid",
-    "gradio>=6.0.0",
     "Pillow",
     "beautifulsoup4",
     "lxml",

{model_compose-0.4.71 → model_compose-0.4.72}/src/mindor/core/component/base.py

@@ -86,21 +86,31 @@ class ComponentService(AsyncService):
         if self._docker_manager:
             await self._stop_docker_runtime()
 
-    async def run(self, action_id: str, run_id: str, input: Dict[str, Any], workflow=None) -> Dict[str, Any]:
+    async def run(self, action_id: str, run_id: str, input: Dict[str, Any], workflow=None, job_id: Optional[str] = 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, workflow=workflow)
+        context = ComponentActionContext(run_id, input, workflow=workflow, component_id=self.id, job_id=job_id)
 
-        if self.work_queue:
-            return await (await self.work_queue.schedule(action, context))
+        await context.event_notifier.notify("started", input=input)
 
-        self._active_counter.acquire()
         try:
-            return await self._run(action, context)
-        finally:
-            self._active_counter.release()
+            if self.work_queue:
+                output = await (await self.work_queue.schedule(action, context))
+            else:
+                self._active_counter.acquire()
+                try:
+                    output = await self._run(action, context)
+                finally:
+                    self._active_counter.release()
+        except Exception as e:
+            await context.event_notifier.notify("failed", error=str(e))
+            raise
+
+        await context.event_notifier.notify("completed", output=output)
+
+        return output
 
     async def _start(self) -> None:
         if self.work_queue:

{model_compose-0.4.71 → model_compose-0.4.72}/src/mindor/core/component/context.py

@@ -8,15 +8,54 @@ from PIL import Image as PILImage
 
 if TYPE_CHECKING:
     from mindor.core.workflow.context import WorkflowContext
+    from mindor.core.workflow.workflow import ComponentEventNotifier
+
+class ComponentActionEventNotifier:
+    def __init__(self, notifier: Optional[ComponentEventNotifier], component_id: Optional[str], job_id: Optional[str], run_id: Optional[str]):
+        self.notifier: Optional[ComponentEventNotifier] = notifier
+        self.component_id: Optional[str] = component_id
+        self.job_id: Optional[str] = job_id
+        self.run_id: Optional[str] = run_id
+
+    async def notify(
+        self,
+        event: Literal[ "started", "completed", "failed", "internal" ],
+        kind: Optional[str] = None,
+        input: Optional[Any] = None,
+        output: Optional[Any] = None,
+        error: Optional[str] = None,
+    ) -> None:
+        if self.notifier is None:
+            return
+        await self.notifier.notify(
+            event=event,
+            job_id=self.job_id,
+            component_id=self.component_id,
+            run_id=self.run_id,
+            kind=kind,
+            input=input,
+            output=output,
+            error=error,
+        )
 
 class ComponentActionContext:
-    def __init__(self, run_id: str, input: Dict[str, Any], workflow: Optional[WorkflowContext] = None):
+    def __init__(
+        self,
+        run_id: str,
+        input: Dict[str, Any],
+        workflow: Optional[WorkflowContext] = None,
+        component_id: Optional[str] = None,
+        job_id: Optional[str] = None,
+    ):
         self.run_id: str = run_id
         self.input: Dict[str, Any] = input
         self.workflow: Optional[WorkflowContext] = workflow
+        self.component_id: Optional[str] = component_id
+        self.job_id: Optional[str] = job_id
         self.context: Dict[str, Any] = { "run_id": run_id }
         self.sources: Dict[str, Any] = {}
         self.renderer: VariableRenderer = VariableRenderer(self._resolve_source)
+        self.event_notifier: ComponentActionEventNotifier = self._build_event_notifier()
 
     def register_source(self, key: str, source: Any) -> None:
         self.sources[key] = source
@@ -24,7 +63,7 @@ class ComponentActionContext:
     async def render_variable(self, value: Any, ignore_files: bool = False) -> Any:
         return await self.renderer.render(value, ignore_files)
 
-    async def render_image(self, value: Any) -> Optional[PILImage.Image]:
+    async def render_image(self, value: Any) -> Any:
         return await ImageValueRenderer().render(await self.render_variable(value))
 
     async def render_file(self, value: Any) -> Optional[str]:
@@ -56,3 +95,11 @@ class ComponentActionContext:
             return gateway.get_context(int(port))
 
         return None
+
+    def _build_event_notifier(self) -> ComponentActionEventNotifier:
+        return ComponentActionEventNotifier(
+            self.workflow.component_event_notifier if self.workflow else None,
+            self.component_id,
+            self.job_id,
+            self.run_id
+        )

{model_compose-0.4.71 → model_compose-0.4.72}/src/mindor/core/component/runtime/process_manager.py

@@ -39,8 +39,8 @@ class ComponentProcessRuntimeManager(ProcessRuntimeManager):
         """Convert DSL ProcessRuntimeConfig to foundation ProcessWorkerParams"""
         return ProcessWorkerParams(
             env=config.env,
-            start_timeout=parse_duration(config.start_timeout).total_seconds(),
-            stop_timeout=parse_duration(config.stop_timeout).total_seconds()
+            start_timeout=parse_duration(config.start_timeout),
+            stop_timeout=parse_duration(config.stop_timeout)
         )
 
     def _component_worker_factory(

{model_compose-0.4.71 → model_compose-0.4.72}/src/mindor/core/component/services/agent.py

@@ -49,6 +49,7 @@ class AgentAction:
 
                     assistant_message = await self._build_assistant_message(response)
                     messages.append(assistant_message)
+                    await context.event_notifier.notify("internal", kind="message", output=assistant_message)
                     yield assistant_message
 
                     tool_calls = self._extract_tool_calls(response)
@@ -58,6 +59,7 @@ class AgentAction:
                     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)
+                        await context.event_notifier.notify("internal", kind="tool", output=tool_message)
                         yield tool_message
 
             return _stream_message_generator()
@@ -68,7 +70,8 @@ class AgentAction:
 
             assistant_message = await self._build_assistant_message(response)
             messages.append(assistant_message)
- 
+            await context.event_notifier.notify("internal", kind="message", output=assistant_message)
+
             tool_calls = self._extract_tool_calls(response)
             if not tool_calls:
                 break
@@ -76,6 +79,7 @@ class AgentAction:
             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)
+                await context.event_notifier.notify("internal", kind="tool", output=tool_message)
 
         return messages
 

{model_compose-0.4.71 → model_compose-0.4.72}/src/mindor/core/component/services/audio_converter/audio_converter.py

@@ -1,17 +1,10 @@
 from typing import Optional, List, Any
 from mindor.dsl.schema.component import AudioConverterComponentConfig, AudioConverterDriver
-from mindor.dsl.schema.action import ActionConfig, AudioConverterActionConfig
+from mindor.dsl.schema.action import ActionConfig
 from ...base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
 from ...context import ComponentActionContext
 from .base import AudioConverterService, AudioConverterServiceRegistry
 
-class AudioConverterAction:
-    def __init__(self, config: AudioConverterActionConfig):
-        self.config: AudioConverterActionConfig = config
-
-    async def run(self, context: ComponentActionContext, service: AudioConverterService) -> Any:
-        return await service.run(self.config, context)
-
 @register_component(ComponentType.AUDIO_CONVERTER)
 class AudioConverterComponent(ComponentService):
     def __init__(
@@ -42,4 +35,4 @@ class AudioConverterComponent(ComponentService):
         await self.service.stop()
 
     async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
-        return await AudioConverterAction(action).run(context, self.service)
+        return await self.service.run(action, context)

{model_compose-0.4.71 → model_compose-0.4.72}/src/mindor/core/component/services/audio_extractor/audio_extractor.py

@@ -1,18 +1,11 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from collections.abc import AsyncIterator
 from mindor.dsl.schema.component import AudioExtractorComponentConfig, AudioExtractorDriver
-from mindor.dsl.schema.action import ActionConfig, AudioExtractorActionConfig
+from mindor.dsl.schema.action import ActionConfig
 from ...base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
 from ...context import ComponentActionContext
 from .base import AudioExtractorService, AudioExtractorServiceRegistry
 
-class AudioExtractorAction:
-    def __init__(self, config: AudioExtractorActionConfig):
-        self.config: AudioExtractorActionConfig = config
-
-    async def run(self, context: ComponentActionContext, service: AudioExtractorService) -> Any:
-        return await service.run(self.config, context)
-
 @register_component(ComponentType.AUDIO_EXTRACTOR)
 class AudioExtractorComponent(ComponentService):
     def __init__(
@@ -43,4 +36,4 @@ class AudioExtractorComponent(ComponentService):
         await self.service.stop()
 
     async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
-        return await AudioExtractorAction(action).run(context, self.service)
+        return await self.service.run(action, context)

{model_compose-0.4.71 → model_compose-0.4.72}/src/mindor/core/component/services/graph_store/drivers/arangodb.py

@@ -260,7 +260,7 @@ class ArangoDBGraphStoreService(GraphStoreService):
         url = self.config.url if self.config.url else f"{self.config.protocol}://{self.config.host}:{self.config.port}"
         client = ArangoClient(
             hosts=url,
-            request_timeout=parse_duration(self.config.timeout).total_seconds()
+            request_timeout=parse_duration(self.config.timeout)
         )
 
         database = client.db(

{model_compose-0.4.71 → model_compose-0.4.72}/src/mindor/core/component/services/graph_store/drivers/neo4j.py

@@ -306,5 +306,5 @@ class Neo4jGraphStoreService(GraphStoreService):
         return AsyncGraphDatabase.driver(
             url,
             auth=auth,
-            connection_timeout=parse_duration(self.config.timeout).total_seconds()
+            connection_timeout=parse_duration(self.config.timeout)
         )

{model_compose-0.4.71 → model_compose-0.4.72}/src/mindor/core/component/services/graph_store/graph_store.py

@@ -1,18 +1,11 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from collections.abc import AsyncIterator
 from mindor.dsl.schema.component import GraphStoreComponentConfig, GraphStoreDriver
-from mindor.dsl.schema.action import ActionConfig, GraphStoreActionConfig
+from mindor.dsl.schema.action import ActionConfig
 from ...base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
 from ...context import ComponentActionContext
 from .base import GraphStoreService, GraphStoreServiceRegistry
 
-class GraphStoreAction:
-    def __init__(self, config: GraphStoreActionConfig):
-        self.config: GraphStoreActionConfig = config
-
-    async def run(self, context: ComponentActionContext, service: GraphStoreService) -> Any:
-        return await service.run(self.config, context)
-
 @register_component(ComponentType.GRAPH_STORE)
 class GraphStoreComponent(ComponentService):
     def __init__(
@@ -44,4 +37,4 @@ class GraphStoreComponent(ComponentService):
         await self.service.stop()
 
     async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
-        return await GraphStoreAction(action).run(context, self.service)
+        return await self.service.run(action, context)

{model_compose-0.4.71 → model_compose-0.4.72}/src/mindor/core/component/services/image_processor.py

@@ -70,8 +70,8 @@ class ImageProcessorAction:
         height = await context.render_variable(self.config.height)
 
         if image:
-            return image.crop(x, y, x + width, y + height)
-        
+            return image.crop((x, y, x + width, y + height))
+
         return None
 
     async def _rotate(self, context: ComponentActionContext) -> Optional[PILImage.Image]:
@@ -112,6 +112,8 @@ class ImageProcessorAction:
         if image:
             return image.filter(ImageFilter.GaussianBlur(radius=radius))
 
+        return None
+
     async def _sharpen(self, context: ComponentActionContext) -> Optional[PILImage.Image]:
         image  = await context.render_image(self.config.image)
         factor = await context.render_variable(self.config.factor)
@@ -119,7 +121,7 @@ class ImageProcessorAction:
         if image:
             return ImageEnhance.Sharpness(image).enhance(factor)
 
-        return FileNotFoundError
+        return None
 
     async def _adjust_brightness(self, context: ComponentActionContext) -> Optional[PILImage.Image]:
         image  = await context.render_image(self.config.image)
@@ -137,7 +139,7 @@ class ImageProcessorAction:
         if image:
             return ImageEnhance.Contrast(image).enhance(factor)
 
-        return image
+        return None
 
     async def _adjust_saturation(self, context: ComponentActionContext) -> Optional[PILImage.Image]:
         image  = await context.render_image(self.config.image)

{model_compose-0.4.71 → model_compose-0.4.72}/src/mindor/core/component/services/shell.py

@@ -24,7 +24,7 @@ class ShellAction:
         command = await context.render_variable(self.config.command)
         env = await context.render_variable({ **(self.env or {}), **(self.config.env or {}) })
 
-        timeout = parse_duration(self.config.timeout).total_seconds() if self.config.timeout else None
+        timeout = parse_duration(self.config.timeout) if self.config.timeout else None
         result = await self._run_command(command, working_dir, env, timeout)
         context.register_source("result", result)
 

{model_compose-0.4.71 → model_compose-0.4.72}/src/mindor/core/component/services/vector_store/drivers/chroma.py

@@ -257,7 +257,7 @@ class ChromaVectorStoreService(VectorStoreService):
             return HttpClient(
                 **self._resolve_connection_params(),
                 **self._resolve_database_params(),
-                timeout=parse_duration(self.config.timeout).total_seconds()
+                timeout=parse_duration(self.config.timeout)
             )
 
         if self.config.mode == "local":

{model_compose-0.4.71 → model_compose-0.4.72}/src/mindor/core/component/services/vector_store/drivers/milvus.py

@@ -317,7 +317,7 @@ class MilvusVectorStoreService(VectorStoreService):
             user=self.config.user or "",
             password=self.config.password or "",
             db_name=self.config.database or "",
-            timeout=parse_duration(self.config.timeout).total_seconds()
+            timeout=parse_duration(self.config.timeout)
         )
 
     async def _shutdown(self) -> None:

{model_compose-0.4.71 → model_compose-0.4.72}/src/mindor/core/component/services/vector_store/vector_store.py

@@ -1,18 +1,11 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from collections.abc import AsyncIterator
 from mindor.dsl.schema.component import VectorStoreComponentConfig, VectorStoreDriver
-from mindor.dsl.schema.action import ActionConfig, VectorStoreActionConfig
+from mindor.dsl.schema.action import ActionConfig
 from ...base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
 from ...context import ComponentActionContext
 from .base import VectorStoreService, VectorStoreServiceRegistry
 
-class VectorStoreAction:
-    def __init__(self, config: VectorStoreActionConfig):
-        self.config: VectorStoreActionConfig = config
-
-    async def run(self, context: ComponentActionContext, service: VectorStoreService) -> Any:
-        return await service.run(self.config, context)
-
 @register_component(ComponentType.VECTOR_STORE)
 class VectorStoreComponent(ComponentService):
     def __init__(
@@ -44,4 +37,4 @@ class VectorStoreComponent(ComponentService):
         await self.service.stop()
 
     async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
-        return await VectorStoreAction(action).run(context, self.service)
+        return await self.service.run(action, context)

{model_compose-0.4.71 → model_compose-0.4.72}/src/mindor/core/component/services/video_converter/video_converter.py

@@ -1,18 +1,11 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from collections.abc import AsyncIterator
 from mindor.dsl.schema.component import VideoConverterComponentConfig, VideoConverterDriver
-from mindor.dsl.schema.action import ActionConfig, VideoConverterActionConfig
+from mindor.dsl.schema.action import ActionConfig
 from ...base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
 from ...context import ComponentActionContext
 from .base import VideoConverterService, VideoConverterServiceRegistry
 
-class VideoConverterAction:
-    def __init__(self, config: VideoConverterActionConfig):
-        self.config: VideoConverterActionConfig = config
-
-    async def run(self, context: ComponentActionContext, service: VideoConverterService) -> Any:
-        return await service.run(self.config, context)
-
 @register_component(ComponentType.VIDEO_CONVERTER)
 class VideoConverterComponent(ComponentService):
     def __init__(
@@ -43,4 +36,4 @@ class VideoConverterComponent(ComponentService):
         await self.service.stop()
 
     async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
-        return await VideoConverterAction(action).run(context, self.service)
+        return await self.service.run(action, context)

{model_compose-0.4.71 → model_compose-0.4.72}/src/mindor/core/component/services/video_scene_detector/drivers/ffmpeg.py

@@ -4,6 +4,7 @@ from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annot
 from mindor.dsl.schema.component import VideoSceneDetectorComponentConfig
 from mindor.dsl.schema.action import VideoSceneDetectorActionConfig
 from mindor.core.logger import logging
+from mindor.core.utils.time import format_timecode
 from ..base import VideoSceneDetectorService, VideoSceneDetectorDriver, register_video_scene_detector_service
 from ..base import ComponentActionContext
 import asyncio
@@ -44,11 +45,11 @@ class FFmpegVideoSceneDetectorAction:
             end = boundaries[i + 1]
             scenes.append({
                 "index": i,
-                "start": self._format_timecode(start),
-                "end": self._format_timecode(end),
+                "start": format_timecode(start),
+                "end": format_timecode(end),
                 "start_frame": int(start * frame_rate),
                 "end_frame": int(end * frame_rate),
-                "duration": self._format_timecode(end - start)
+                "duration": format_timecode(end - start)
             })
 
         return { "scenes": scenes, "total_scenes": len(scenes) }
@@ -131,13 +132,6 @@ class FFmpegVideoSceneDetectorAction:
 
         return float(result["format"]["duration"])
 
-    @staticmethod
-    def _format_timecode(seconds: float) -> str:
-        h = int(seconds // 3600)
-        m = int((seconds % 3600) // 60)
-        s = seconds % 60
-        return f"{h:02d}:{m:02d}:{s:06.3f}"
-
 @register_video_scene_detector_service(VideoSceneDetectorDriver.FFMPEG)
 class FFmpegVideoSceneDetectorService(VideoSceneDetectorService):
     def __init__(self, id: str, config: VideoSceneDetectorComponentConfig, daemon: bool):

{model_compose-0.4.71 → model_compose-0.4.72}/src/mindor/core/component/services/video_scene_detector/drivers/transnetv2.py

@@ -4,6 +4,7 @@ from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annot
 from mindor.dsl.schema.component import VideoSceneDetectorComponentConfig
 from mindor.dsl.schema.action import VideoSceneDetectorActionConfig
 from mindor.core.logger import logging
+from mindor.core.utils.time import format_timecode
 from ..base import VideoSceneDetectorService, VideoSceneDetectorDriver, register_video_scene_detector_service
 from ..base import ComponentActionContext
 import asyncio
@@ -52,11 +53,11 @@ class TransNetV2VideoSceneDetectorAction:
 
             scenes.append({
                 "index": i,
-                "start": TransNetV2VideoSceneDetectorAction._format_timecode(start_time),
-                "end": TransNetV2VideoSceneDetectorAction._format_timecode(end_time),
+                "start": format_timecode(start_time),
+                "end": format_timecode(end_time),
                 "start_frame": start_frame,
                 "end_frame": end_frame,
-                "duration": TransNetV2VideoSceneDetectorAction._format_timecode(end_time - start_time)
+                "duration": format_timecode(end_time - start_time)
             })
 
         logging.info(f"TransNetV2 detected {len(scenes)} scenes in '{video}'")
@@ -84,13 +85,6 @@ class TransNetV2VideoSceneDetectorAction:
 
         return float(numerator) / float(denominator)
 
-    @staticmethod
-    def _format_timecode(seconds: float) -> str:
-        h = int(seconds // 3600)
-        m = int((seconds % 3600) // 60)
-        s = seconds % 60
-        return f"{h:02d}:{m:02d}:{s:06.3f}"
-
 @register_video_scene_detector_service(VideoSceneDetectorDriver.TRANSNETV2)
 class TransNetV2VideoSceneDetectorService(VideoSceneDetectorService):
     def __init__(self, id: str, config: VideoSceneDetectorComponentConfig, daemon: bool):

{model_compose-0.4.71 → model_compose-0.4.72}/src/mindor/core/component/services/video_scene_detector/video_scene_detector.py

@@ -1,18 +1,11 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from collections.abc import AsyncIterator
 from mindor.dsl.schema.component import VideoSceneDetectorComponentConfig, VideoSceneDetectorDriver
-from mindor.dsl.schema.action import ActionConfig, VideoSceneDetectorActionConfig
+from mindor.dsl.schema.action import ActionConfig
 from ...base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
 from ...context import ComponentActionContext
 from .base import VideoSceneDetectorService, VideoSceneDetectorServiceRegistry
 
-class VideoSceneDetectorAction:
-    def __init__(self, config: VideoSceneDetectorActionConfig):
-        self.config: VideoSceneDetectorActionConfig = config
-
-    async def run(self, context: ComponentActionContext, service: VideoSceneDetectorService) -> Any:
-        return await service.run(self.config, context)
-
 @register_component(ComponentType.VIDEO_SCENE_DETECTOR)
 class VideoSceneDetectorComponent(ComponentService):
     def __init__(
@@ -44,4 +37,4 @@ class VideoSceneDetectorComponent(ComponentService):
         await self.service.stop()
 
     async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
-        return await VideoSceneDetectorAction(action).run(context, self.service)
+        return await self.service.run(action, context)

{model_compose-0.4.71 → model_compose-0.4.72}/src/mindor/core/component/services/web_browser/drivers/chrome.py

@@ -29,7 +29,7 @@ class ChromeBrowserSession(WebBrowserSession):
         }.get(wait_until)
 
         if event:
-            loop = asyncio.get_running_loop()
+            loop: asyncio.AbstractEventLoop = asyncio.get_running_loop()
             nav_done: asyncio.Future = loop.create_future()
 
             async def _on_event(params):

{model_compose-0.4.71 → model_compose-0.4.72}/src/mindor/core/component/services/web_browser/web_browser.py

@@ -16,7 +16,7 @@ class WebBrowserAction:
         self.timeout = timeout
 
     async def run(self, context: ComponentActionContext, session: WebBrowserSession) -> Any:
-        timeout = parse_duration((await context.render_variable(self.config.timeout) if self.config.timeout else self.timeout) or 30.0).total_seconds()
+        timeout = parse_duration((await context.render_variable(self.config.timeout) if self.config.timeout else self.timeout) or 30.0)
 
         result = await self._dispatch(context, session, timeout)
         context.register_source("result", result)

{model_compose-0.4.71 → model_compose-0.4.72}/src/mindor/core/component/services/web_scraper.py

@@ -38,7 +38,7 @@ class WebScraperAction:
         # Merge headers and cookies: component defaults + action overrides
         merged_headers = { **self.headers, **headers }
         merged_cookies = { **self.cookies, **cookies }
-        timeout = parse_duration((await context.render_variable(self.config.timeout) if self.config.timeout else self.timeout) or 60.0).total_seconds()
+        timeout = parse_duration((await context.render_variable(self.config.timeout) if self.config.timeout else self.timeout) or 60.0)
 
         # Fetch HTML content (with optional form submission)
         if submit or enable_javascript:

{model_compose-0.4.71 → model_compose-0.4.72}/src/mindor/core/component/services/websocket_client.py

@@ -22,7 +22,7 @@ class WebSocketClientAction:
         format  = await context.render_variable(self.config.receive.format)
         collect = await context.render_variable(self.config.receive.collect)
         timeout_str = await context.render_variable(self.config.receive.timeout)
-        timeout = parse_duration(timeout_str).total_seconds() if timeout_str else None
+        timeout = parse_duration(timeout_str) if timeout_str else None
 
         connection, owned = await client.connect(
             path=path,
@@ -128,8 +128,8 @@ class WebSocketClientComponent(ComponentService):
     async def _start(self) -> None:
         self.client = WebSocketClient(
             base_url=self.config.base_url,
-            ping_interval=parse_duration(self.config.ping_interval).total_seconds() if self.config.ping_interval else None,
-            ping_timeout=parse_duration(self.config.ping_timeout).total_seconds() if self.config.ping_timeout else None,
+            ping_interval=parse_duration(self.config.ping_interval) if self.config.ping_interval else None,
+            ping_timeout=parse_duration(self.config.ping_timeout) if self.config.ping_timeout else None,
             additional_headers=self.config.headers or None,
             params=self.config.params or None
         )

{model_compose-0.4.71 → model_compose-0.4.72}/src/mindor/core/component/services/websocket_server.py

@@ -23,7 +23,7 @@ class WebSocketServerAction:
         format  = await context.render_variable(self.config.receive.format)
         collect = await context.render_variable(self.config.receive.collect)
         timeout_str = await context.render_variable(self.config.receive.timeout)
-        timeout = parse_duration(timeout_str).total_seconds() if timeout_str else None
+        timeout = parse_duration(timeout_str) if timeout_str else None
 
         connection, owned = await client.connect(
             path=path,
@@ -145,8 +145,8 @@ class WebSocketServerComponent(ComponentService):
         base_url = f"ws://localhost:{self.config.port}" + (self.config.base_path or "")
         self.client = WebSocketClient(
             base_url=base_url,
-            ping_interval=parse_duration(self.config.ping_interval).total_seconds() if self.config.ping_interval else None,
-            ping_timeout=parse_duration(self.config.ping_timeout).total_seconds() if self.config.ping_timeout else None,
+            ping_interval=parse_duration(self.config.ping_interval) if self.config.ping_interval else None,
+            ping_timeout=parse_duration(self.config.ping_timeout) if self.config.ping_timeout else None,
             additional_headers=self.config.headers or None,
             params=self.config.params or None
         )