model-compose 0.3.6__tar.gz → 0.3.8__tar.gz

{model_compose-0.3.6/src/model_compose.egg-info → model_compose-0.3.8}/PKG-INFO

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

{model_compose-0.3.6 → model_compose-0.3.8}/pyproject.toml

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

{model_compose-0.3.6 → model_compose-0.3.8}/src/mindor/cli/compose.py

@@ -4,14 +4,14 @@ from pathlib import Path
 import asyncio
 
 from mindor.dsl.loader import load_compose_config
-from mindor.core.runtime.env import load_env_files
+from mindor.core.runtime.env import load_env_files, merge_env_data
 from mindor.core.compose import *
 
 @click.group()
 @click.option(
     "--file", "-f", "config_files", multiple=True,
     type=click.Path(exists=True, dir_okay=False, path_type=Path),
-    help="Compose configuration files"
+    help="Compose configuration files."
 )
 @click.pass_context
 def compose_command(ctx: click.Context, config_files: List[Path]) -> None:
@@ -44,6 +44,7 @@ def up_command(
     async def _async_command():
         try:
             env = load_env_files(".", env_files or [])
+            env = merge_env_data(env, env_data)
             config = load_compose_config(".", config_files, env)
             await launch_services(config, detach, verbose)
         except Exception as e:
@@ -73,6 +74,7 @@ def down_command(
     async def _async_command():
         try:
             env = load_env_files(".", env_files or [])
+            env = merge_env_data(env, env_data)
             config = load_compose_config(".", config_files, env)
             await terminate_services(config, verbose)
         except Exception as e:
@@ -102,6 +104,7 @@ def start_command(
     async def _async_command():
         try:
             env = load_env_files(".", env_files or [])
+            env = merge_env_data(env, env_data)
             config = load_compose_config(".", config_files, env)
             await start_services(config, verbose)
         except Exception as e:
@@ -131,6 +134,7 @@ def stop_command(
     async def _async_command():
         try:
             env = load_env_files(".", env_files or [])
+            env = merge_env_data(env, env_data)
             config = load_compose_config(".", config_files, env)
             await stop_services(config, verbose)
         except Exception as e:
@@ -176,6 +180,7 @@ def run_command(
     async def _async_command():
         try:
             env = load_env_files(".", env_files or [])
+            env = merge_env_data(env, env_data)
             config = load_compose_config(".", config_files, env)
             input = json.loads(input_json) if input_json else {}
             state = await run_workflow(config, workflow_id, input, output_path, verbose)

{model_compose-0.3.6 → model_compose-0.3.8}/src/mindor/core/component/base.py

@@ -57,6 +57,12 @@ class ComponentService(AsyncService):
         if self.config.max_concurrent_count > 0:
             self.queue = WorkQueue(self.config.max_concurrent_count, self._run)
 
+    async def setup(self) -> None:
+        await self._setup()
+
+    async def teardown(self) -> None:
+        await self._teardown()
+
     async def run(self, action_id: Union[str, None], run_id: str, input: Dict[str, Any]) -> Dict[str, Any]:
         _, action = ActionResolver(self.config.actions).resolve(action_id)
         context = ComponentActionContext(run_id, input)
@@ -66,6 +72,12 @@ class ComponentService(AsyncService):
 
         return await self._run(action, context)
 
+    async def _setup(self) -> None:
+        pass
+
+    async def _teardown(self) -> None:
+        pass
+
     async def _start(self) -> None:
         if self.queue:
             await self.queue.start()

{model_compose-0.3.6 → model_compose-0.3.8}/src/mindor/core/component/context.py

@@ -19,17 +19,23 @@ class ComponentActionContext:
     async def _resolve_source(self, key: str, index: Optional[int]) -> Any:
         if key in self.sources:
             return self.sources[key][index] if index is not None else self.sources[key]
+
         if key == "input":
             return self.input
+
         if key == "context":
             return self.context
+
         if key.startswith("gateway:"):
             return self._resolve_gateway(key)
+
         raise KeyError(f"Unknown source: {key}")
 
     def _resolve_gateway(self, key: str) -> Any:
         _, port = key.split(":")
         gateway = find_gateway_by_port(int(port)) if port else None
+
         if gateway:
             return gateway.get_context()
+
         return None

model_compose-0.3.8/src/mindor/core/component/services/http_server.py

@@ -0,0 +1,137 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Any
+from abc import ABC, abstractmethod
+from mindor.dsl.schema.component import HttpServerComponentConfig
+from mindor.dsl.schema.action import ActionConfig, HttpServerActionConfig, HttpServerCompletionType, HttpServerCompletionConfig
+from mindor.core.listener import HttpCallbackListener
+from mindor.core.utils.http_client import HttpClient
+from mindor.core.utils.http_status import is_status_code_matched
+from mindor.core.utils.time import parse_duration
+from mindor.core.utils.shell import run_command_streaming
+from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
+from ..context import ComponentActionContext
+from datetime import datetime, timezone
+import asyncio
+
+class HttpServerCompletion(ABC):
+    def __init__(self, config: HttpServerCompletionConfig):
+        self.config: HttpServerCompletionConfig = config
+
+    @abstractmethod
+    async def run(self, context: ComponentActionContext, client: HttpClient) -> Any:
+        pass
+
+class HttpServerPollingCompletion(HttpServerCompletion):
+    async def run(self, context: ComponentActionContext, client: HttpClient) -> Any:
+        path    = await context.render_variable(self.config.path)
+        method  = await context.render_variable(self.config.method)
+        params  = await context.render_variable(self.config.params)
+        body    = await context.render_variable(self.config.body)
+        headers = 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)
+        deadline = datetime.now(timezone.utc) + timeout
+
+        await asyncio.sleep(interval.total_seconds())
+
+        while datetime.now(timezone.utc) < deadline:
+            response, status_code = await client.request(path or "", method, params, body, headers, raise_on_error=False)
+            context.register_source("result", response)
+
+            status = (await context.render_variable(self.config.status)) if self.config.status else None
+            if status:
+                if status in (self.config.success_when or []):
+                    return response
+                if status in (self.config.fail_when or []):
+                    raise RuntimeError(f"Polling failed: status '{status}' matched a failure condition.")
+            else: # use status code
+                if is_status_code_matched(status_code, self.config.success_when or []):
+                    return response
+                if is_status_code_matched(status_code, self.config.fail_when or []):
+                    raise RuntimeError(f"Polling failed: status code '{status_code}' matched a failure condition.")
+
+            await asyncio.sleep(interval.total_seconds())
+
+        raise TimeoutError(f"Polling timed out after {timeout}.")
+
+class HttpServerCallbackCompletion(HttpServerCompletion):
+    async def run(self, context: ComponentActionContext, client: HttpClient) -> Any:
+        callback_id = await context.render_variable(self.config.wait_for)
+        future: asyncio.Future = asyncio.get_running_loop().create_future()
+        HttpCallbackListener.register_pending_future(callback_id, future)
+
+        return await future
+
+class HttpServerAction:
+    def __init__(self, config: HttpServerActionConfig):
+        self.config: HttpServerActionConfig = config
+        self.completion: HttpServerCompletion = None
+
+        if self.config.completion:
+            self._configure_completion()
+
+    def _configure_completion(self) -> None:
+        if self.config.completion.type == HttpServerCompletionType.POLLING:
+            self.completion = HttpServerPollingCompletion(self.config.completion)
+            return
+        
+        if self.config.completion.type == HttpServerCompletionType.CALLBACK:
+            self.completion = HttpServerCallbackCompletion(self.config.completion)
+            return
+        
+        raise ValueError(f"Unsupported http completion type: {self.config.completion.type}")
+
+    async def run(self, context: ComponentActionContext, client: HttpClient) -> Any:
+        path    = await context.render_variable(self.config.path)
+        method  = await context.render_variable(self.config.method)
+        params  = await context.render_variable(self.config.params)
+        body    = await context.render_variable(self.config.body)
+        headers = await context.render_variable(self.config.headers)
+
+        response, result = await client.request(path or "", method, params, body, headers), None
+        context.register_source("response", response)
+
+        if self.completion:
+            result = await self.completion.run(context, client)
+            context.register_source("result", result)
+
+        return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else (result or response)
+
+@register_component(ComponentType.HTTP_SERVER)
+class HttpServerComponent(ComponentService):
+    def __init__(self, id: str, config: HttpServerComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
+        super().__init__(id, config, global_configs, daemon)
+
+        self.client: Optional[HttpClient] = None
+
+    async def _setup(self) -> None:
+        if self.config.commands.install:
+            for command in self.config.commands.install:
+                await run_command_streaming(command, self.config.working_dir, self.config.env)
+
+        if self.config.commands.build:
+            for command in self.config.commands.build:
+                await run_command_streaming(command, self.config.working_dir, self.config.env)
+
+    async def _teardown(self):
+        pass
+
+    async def _start(self) -> None:
+        base_url = f"http://localhost:{self.config.port}" + (self.config.base_path or "")
+        self.client = HttpClient(base_url, self.config.headers)
+        await super()._start()
+
+    async def _stop(self) -> None:
+        await super()._stop()
+        await self.client.close()
+        self.client = None
+
+    async def _serve(self) -> None:
+        if self.config.commands.start:
+            await run_command_streaming(self.config.commands.start, self.config.working_dir, self.config.env, block=False)
+
+    async def _shutdown(self) -> None:
+        pass
+
+    async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
+        return await HttpServerAction(action).run(context, self.client)

model_compose-0.3.8/src/mindor/core/component/services/mcp_server.py

@@ -0,0 +1,68 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.component import McpServerComponentConfig
+from mindor.dsl.schema.action import ActionConfig, McpServerActionConfig
+from mindor.core.utils.mcp_client import McpClient, ContentBlock, TextContent, ImageContent, AudioContent
+from mindor.core.utils.shell import run_command_streaming
+from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
+from ..context import ComponentActionContext
+
+class McpServerAction:
+    def __init__(self, config: McpServerActionConfig):
+        self.config: McpServerActionConfig = config
+
+    async def run(self, context: ComponentActionContext, client: McpClient) -> Any:
+        tool      = await context.render_variable(self.config.tool)
+        arguments = await context.render_variable(self.config.arguments)
+
+        response = [ await self._convert_output_value(content) for content in await client.call_tool(tool, arguments) ]
+        context.register_source("response", response)
+
+        return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else response
+
+    async def _convert_output_value(self, content: ContentBlock) -> Any:
+        if isinstance(content, TextContent):
+            return content.text
+
+        if isinstance(content, (ImageContent, AudioContent)):
+            return content.data
+
+        return None
+
+@register_component(ComponentType.MCP_SERVER)
+class McpServerComponent(ComponentService):
+    def __init__(self, id: str, config: McpServerComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
+        super().__init__(id, config, global_configs, daemon)
+
+        self.client: Optional[McpClient] = None 
+
+    async def _setup(self) -> None:
+        if self.config.commands.install:
+            for command in self.config.commands.install:
+                await run_command_streaming(command, self.config.working_dir, self.config.env)
+
+        if self.config.commands.build:
+            for command in self.config.commands.build:
+                await run_command_streaming(command, self.config.working_dir, self.config.env)
+
+    async def _teardown(self):
+        pass
+
+    async def _start(self) -> None:
+        base_url = f"http://localhost:{self.config.port}" + (self.config.base_path or "")
+        self.client = McpClient(base_url, self.config.headers)
+        await super()._start()
+
+    async def _stop(self) -> None:
+        await super()._stop()
+        await self.client.close()
+        self.client = None
+
+    async def _serve(self) -> None:
+        if self.config.commands.start:
+            await run_command_streaming(self.config.commands.start, self.config.working_dir, self.config.env, block=False)
+
+    async def _shutdown(self) -> None:
+        pass
+
+    async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
+        return await McpServerAction(action).run(context, self.client)

{model_compose-0.3.6 → model_compose-0.3.8}/src/mindor/core/component/services/shell.py

@@ -1,10 +1,10 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.component import ShellComponentConfig
 from mindor.dsl.schema.action import ActionConfig, ShellActionConfig
+from mindor.core.utils.shell import run_command
 from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
 from ..context import ComponentActionContext
-from asyncio.subprocess import Process
-import asyncio, os
+import os
 
 class ShellAction:
     def __init__(self, config: ShellActionConfig, base_dir: Optional[str], env: Optional[Dict[str, str]]):
@@ -22,39 +22,17 @@ class ShellAction:
         return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result
     
     async def _run_command(self, command: List[str], working_dir: str, env: Dict[str, str], timeout: Optional[float]) -> Dict[str, Any]:
-        process = await asyncio.create_subprocess_exec(
-            *command,
-            cwd=working_dir,
-            env={ **os.environ, **env },
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE
-        )
+        stdout, stderr, exit_code = await run_command(command, working_dir, env, timeout)
 
-        try:
-            stdout, stderr = await asyncio.wait_for(process.communicate(), timeout=timeout)
-        except asyncio.TimeoutError:
-            if await self._kill_process(process):
-                raise RuntimeError(f"Command timed out: {' '.join(command)}")
-
-        return { 
-            "stdout": stdout.decode().strip(), 
+        return {
+            "stdout": stdout.decode().strip(),
             "stderr": stderr.decode().strip(),
-            "exit_code": process.returncode
+            "exit_code": exit_code
         }
 
-    async def _kill_process(self, process: Process) -> bool:
-        if process.returncode is None:
-            process.kill()
-            try:
-                await process.wait()
-            except Exception as e:
-                pass
-            return True
-        else:
-            return False
-
     async def _resolve_working_directory(self) -> str:
         working_dir = self.config.working_dir
+
         if working_dir:
             if self.base_dir:
                 working_dir = os.path.abspath(os.path.join(self.base_dir, working_dir))
@@ -62,6 +40,7 @@ class ShellAction:
                 working_dir = os.path.abspath(working_dir)
         else:
             working_dir = self.base_dir or os.getcwd()
+
         return working_dir
 
 @register_component(ComponentType.SHELL)

{model_compose-0.3.6 → model_compose-0.3.8}/src/mindor/core/compose/compose.py

@@ -9,7 +9,7 @@ async def terminate_services(config: ComposeConfig, verbose: bool):
     await ComposeManager(config, daemon=False).terminate_services(verbose)
 
 async def start_services(config: ComposeConfig, verbose: bool):
-    await ComposeManager(config, daemon=False).start_services(verbose)
+    await ComposeManager(config, daemon=True).start_services(verbose)
 
 async def stop_services(config: ComposeConfig, verbose: bool):
     await ComposeManager(config, daemon=False).stop_services(verbose)

{model_compose-0.3.6 → model_compose-0.3.8}/src/mindor/core/compose/manager.py

@@ -16,16 +16,16 @@ class ComposeManager:
         )
 
     async def launch_services(self, detach: bool, verbose: bool):
-        await self.controller.launch(detach, verbose)
+        await self.controller.launch_services(detach, verbose)
 
     async def terminate_services(self, verbose: bool):
-        await self.controller.terminate(verbose)
+        await self.controller.terminate_services(verbose)
 
     async def start_services(self, verbose: bool):
-        await self.controller.start()
+        await self.controller.start_services(verbose)
 
     async def stop_services(self, verbose: bool):
-        await self.controller.stop()
+        await self.controller.stop_services(verbose)
 
     async def run_workflow(self, workflow_id: Optional[str], input: Dict[str, Any], output_path: Optional[str], verbose: bool) -> TaskState:
         if not self.controller.started:

{model_compose-0.3.6 → model_compose-0.3.8}/src/mindor/core/controller/base.py

@@ -1,13 +1,12 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from enum import Enum
 from dataclasses import dataclass
-from pydantic import BaseModel
 from mindor.dsl.schema.controller import ControllerConfig, ControllerType
 from mindor.dsl.schema.component import ComponentConfig
 from mindor.dsl.schema.listener import ListenerConfig
 from mindor.dsl.schema.gateway import GatewayConfig
 from mindor.dsl.schema.workflow import WorkflowConfig
-from mindor.dsl.schema.runtime import RuntimeType, DockerBuildConfig
+from mindor.dsl.schema.runtime import RuntimeType
 from mindor.dsl.schema.logger import LoggerConfig, LoggerType, ConsoleLoggerConfig
 from mindor.core.services import AsyncService
 from mindor.core.component import ComponentService, ComponentGlobalConfigs, create_component
@@ -16,12 +15,15 @@ from mindor.core.gateway import GatewayService, create_gateway
 from mindor.core.workflow import Workflow, WorkflowResolver, create_workflow
 from mindor.core.logger import LoggerService, create_logger
 from mindor.core.controller.webui import ControllerWebUI
+from mindor.core.workflow.schema import WorkflowSchema, create_workflow_schemas
 from mindor.core.utils.workqueue import WorkQueue
 from mindor.core.utils.caching import ExpiringDict
 from .runtime.specs import ControllerRuntimeSpecs
+from .runtime.native import NativeRuntimeLauncher
 from .runtime.docker import DockerRuntimeLauncher
 from threading import Lock
-import asyncio, ulid
+from pathlib import Path
+import asyncio, ulid, os
 
 class TaskStatus(str, Enum):
     PENDING    = "pending"
@@ -55,17 +57,23 @@ class ControllerService(AsyncService):
         self.listeners: List[ListenerConfig] = listeners
         self.gateways: List[GatewayConfig] = gateways
         self.loggers: List[LoggerConfig] = loggers
-        self.queue: Optional[WorkQueue] = None
+        self.workflow_schemas: Dict[str, WorkflowSchema] = create_workflow_schemas(self.workflows, self.components)
+        self.task_queue: Optional[WorkQueue] = None
         self.task_states: ExpiringDict[TaskState] = ExpiringDict()
         self.task_states_lock: Lock = Lock()
-        
+
         if self.config.max_concurrent_count > 0:
-            self.queue = WorkQueue(self.config.max_concurrent_count, self._run_workflow)
+            self.task_queue = WorkQueue(self.config.max_concurrent_count, self._run_workflow)
 
-    async def launch(self, detach: bool, verbose: bool) -> None:
+    async def launch_services(self, detach: bool, verbose: bool) -> None:
         if self.config.runtime.type == RuntimeType.NATIVE:
             if detach:
-                pass
+                await self._start_loggers()
+                await NativeRuntimeLauncher().launch_detached()
+                await self._stop_loggers()
+                return
+
+            await self._setup_components()
             await self.start()
             await self.wait_until_stopped()
             return
@@ -73,16 +81,46 @@ class ControllerService(AsyncService):
         if self.config.runtime.type == RuntimeType.DOCKER:
             await self._start_loggers()
             await DockerRuntimeLauncher(self.config, verbose).launch(self._get_runtime_specs(), detach)
+            await self._stop_loggers()
             return
 
-    async def terminate(self, verbose: bool) -> None:
+    async def terminate_services(self, verbose: bool) -> None:
         if self.config.runtime.type == RuntimeType.NATIVE:
-            await self.stop()
+            await self._start_loggers()
+            await NativeRuntimeLauncher().stop()
+            await self._teardown_components()
+            await self._stop_loggers()
             return
-        
+
         if self.config.runtime.type == RuntimeType.DOCKER:
             await self._start_loggers()
             await DockerRuntimeLauncher(self.config, verbose).terminate()
+            await self._stop_loggers()
+            return
+
+    async def start_services(self, verbose: bool) -> None:
+        if self.config.runtime.type == RuntimeType.NATIVE:
+            await self.start()
+            await self.wait_until_stopped()
+            return
+
+        if self.config.runtime.type == RuntimeType.DOCKER:
+            await self._start_loggers()
+            await DockerRuntimeLauncher(self.config, verbose).start()
+            await self._stop_loggers()
+            return
+
+    async def stop_services(self, verbose: bool) -> None:
+        if self.config.runtime.type == RuntimeType.NATIVE:
+            await self._start_loggers()
+            await NativeRuntimeLauncher().stop()
+            await self._stop_loggers()
+            return
+
+        if self.config.runtime.type == RuntimeType.DOCKER:
+            await self._start_loggers()
+            await DockerRuntimeLauncher(self.config, verbose).stop()
+            await self._stop_loggers()
             return
 
     async def run_workflow(self, workflow_id: Optional[str], input: Dict[str, Any], wait_for_completion: bool = True) -> TaskState:
@@ -92,8 +130,8 @@ class ControllerService(AsyncService):
             self.task_states.set(task_id, state)
 
         if wait_for_completion:
-            if self.queue:
-                state = await (await self.queue.schedule(task_id, workflow_id, input))
+            if self.task_queue:
+                state = await (await self.task_queue.schedule(task_id, workflow_id, input))
             else:
                 state = await self._run_workflow(task_id, workflow_id, input)
         else:
@@ -106,11 +144,12 @@ class ControllerService(AsyncService):
             return self.task_states.get(task_id)
 
     async def _start(self) -> None:
-        if self.queue:
-            await self.queue.start()
+        if self.task_queue:
+            await self.task_queue.start()
+
+        await self._start_loggers()
 
         if self.daemon:
-            await self._start_loggers()
             await self._start_gateways()
             await self._start_listeners()
             await self._start_components()
@@ -118,23 +157,38 @@ class ControllerService(AsyncService):
             if self.config.webui:
                 await self._start_webui()
 
+            asyncio.create_task(self._watch_stop_request())
+
         await super()._start()
 
     async def _stop(self) -> None:
-        if self.queue:
-            await self.queue.stop()
+        if self.task_queue:
+            await self.task_queue.stop()
 
         if self.daemon:
             await self._stop_components()
             await self._stop_listeners()
             await self._stop_gateways()
-            await self._stop_loggers()
 
             if self.config.webui:
                 await self._stop_webui()
 
         await super()._stop()
 
+    async def _on_stop(self) -> None:
+        await self._stop_loggers()
+
+    async def _watch_stop_request(self, interval: float = 1.0) -> None:
+        stop_file = Path.cwd() / ".stop"
+
+        while self.started:
+            if stop_file.exists():
+                await self.stop()
+                break
+            await asyncio.sleep(interval)
+
+        os.unlink(stop_file)
+
     async def _start_listeners(self) -> None:
         await asyncio.gather(*[ listener.start() for listener in self._create_listeners() ])
 
@@ -147,6 +201,12 @@ class ControllerService(AsyncService):
     async def _stop_gateways(self) -> None:
         await asyncio.gather(*[ gateway.stop() for gateway in self._create_gateways() ])
 
+    async def _setup_components(self) -> None:
+        await asyncio.gather(*[ component.setup() for component in self._create_components() ])
+
+    async def _teardown_components(self) -> None:
+        await asyncio.gather(*[ component.teardown() for component in self._create_components() ])
+
     async def _start_components(self) -> None:
         await asyncio.gather(*[ component.start() for component in self._create_components() ])
 
@@ -198,7 +258,7 @@ class ControllerService(AsyncService):
         state = TaskState(task_id=task_id, status=TaskStatus.PROCESSING)
         with self.task_states_lock:
             self.task_states.set(task_id, state)
-        
+
         try:
             workflow = self._create_workflow(workflow_id)
             output = await workflow.run(task_id, input)

{model_compose-0.3.6 → model_compose-0.3.8}/src/mindor/core/controller/runner/http_client.py

@@ -34,7 +34,7 @@ class HttpControllerClient(ControllerClient):
         await self.client.close()
 
     def _resolve_controller_url(self) -> str:
-        return f"http://localhost:{self.config.port}{self.config.base_path or ''}"
+        return f"http://localhost:{self.config.port}" + (self.config.base_path or "")
     
     def _flatten_for_multipart(self, data: Dict[str, Any], key: str = "") -> List[Tuple[str, Any]]:
         flattened = []

{model_compose-0.3.6 → model_compose-0.3.8}/src/mindor/core/controller/runner/mcp_client.py

@@ -23,7 +23,7 @@ class McpControllerClient(ControllerClient):
         await self.client.close()
 
     def _resolve_controller_url(self) -> str:
-        return f"http://localhost:{self.config.port}{self.config.base_path or ''}"
+        return f"http://localhost:{self.config.port}" + (self.config.base_path or "")
 
     async def _call_tool(self, name: str, arguments: Optional[Dict[str, Any]], workflow: WorkflowSchema) -> Any:
         contents = await self.client.call_tool(name, arguments)