model-compose 0.1.12__tar.gz → 0.2.0__tar.gz

{model_compose-0.1.12 → model_compose-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.1.12
+Version: 0.2.0
 Summary: model-compose: Declarative AI Model and Workflow Orchestrator
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT
@@ -15,7 +15,7 @@ Requires-Dist: aiohttp
 Requires-Dist: requests
 Requires-Dist: fastapi
 Requires-Dist: uvicorn
-Requires-Dist: mcp
+Requires-Dist: mcp>=1.10.1
 Requires-Dist: pyngrok
 Requires-Dist: ulid
 Requires-Dist: gradio

{model_compose-0.1.12 → model_compose-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.1.12"
+version = "0.2.0"
 description = "model-compose: Declarative AI Model and Workflow Orchestrator"
 authors = [
     { name = "Hanyeol Cho", email = "hanyeol.cho@gmail.com" }
@@ -16,7 +16,7 @@ dependencies = [
     "requests", 
     "fastapi", 
     "uvicorn",
-    "mcp",
+    "mcp>=1.10.1",
     "pyngrok", 
     "ulid", 
     "gradio",

{model_compose-0.1.12 → model_compose-0.2.0}/src/mindor/core/component/engine/http_client.py

@@ -19,10 +19,6 @@ class HttpClientCompletion(ABC):
     async def run(self, context: ComponentActionContext, client: HttpClient) -> Any:
         pass
 
-    @abstractmethod
-    async def close(self) -> None:
-        pass
-
 class HttpClientPollingCompletion(HttpClientCompletion):
     async def run(self, context: ComponentActionContext, client: HttpClient) -> Any:
         url_or_path = await self._resolve_url_or_path(context)
@@ -31,8 +27,8 @@ class HttpClientPollingCompletion(HttpClientCompletion):
         body        = await context.render_variable(self.config.body)
         headers     = await context.render_variable(self.config.headers)
 
-        interval = parse_duration(self.config.interval) if self.config.interval else 5.0
-        timeout  = parse_duration(self.config.timeout) if self.config.timeout else 300
+        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())
@@ -73,9 +69,6 @@ class HttpClientCallbackCompletion(HttpClientCompletion):
         HttpCallbackListener.register_pending_future(callback_id, future)
 
         return await future
-    
-    async def close(self) -> None:
-        pass
 
 class HttpClientAction:
     def __init__(self, config: HttpClientActionConfig):
@@ -112,10 +105,6 @@ class HttpClientAction:
 
         return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else (result or response)
 
-    async def close(self) -> None:
-        if self.completion:
-            await self.completion.close()
-
     async def _resolve_url_or_path(self, context: ComponentActionContext) -> str:
         if self.config.path:
             return await context.render_variable(self.config.path)

{model_compose-0.1.12 → model_compose-0.2.0}/src/mindor/core/component/engine/mcp_client.py

@@ -17,9 +17,6 @@ class McpClientAction():
         context.register_source("response", response)
 
         return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else response
-    
-    async def close(self) -> None:
-        pass
 
     async def _convert_output_value(self, content: ContentBlock) -> Any:
         if isinstance(content, TextContent):

{model_compose-0.1.12 → model_compose-0.2.0}/src/mindor/core/controller/engine/mcp_server.py

@@ -7,7 +7,7 @@ from mindor.dsl.schema.workflow import WorkflowConfig, WorkflowVariableConfig
 from mindor.core.workflow.schema import WorkflowSchema, create_workflow_schema
 from mindor.core.utils.streaming import StreamResource, Base64StreamResource
 from mindor.core.utils.streaming import save_stream_to_temporary_file
-from mindor.core.utils.http_client import HttpClient
+from mindor.core.utils.http_client import create_stream_with_url
 from .base import ControllerEngine, ControllerType, ControllerEngineMap, TaskState
 from mcp.server.fastmcp.server import FastMCP
 from mcp.types import TextContent, ImageContent, AudioContent
@@ -83,7 +83,7 @@ class WorkflowToolGenerator():
             return await save_stream_to_temporary_file(Base64StreamResource(value), subtype)
 
         if format == "url" and isinstance(value, str):
-            return await save_stream_to_temporary_file(await HttpClient.request_once(value), subtype)
+            return await save_stream_to_temporary_file(await create_stream_with_url(value), subtype)
 
         if isinstance(value, StreamResource):
             return await save_stream_to_temporary_file(value, subtype)

{model_compose-0.1.12 → model_compose-0.2.0}/src/mindor/core/controller/runner/http_client.py

@@ -36,10 +36,10 @@ class HttpControllerClient(ControllerClient):
     def _resolve_controller_url(self) -> str:
         return f"http://localhost:{self.config.port}{self.config.base_path or ''}"
     
-    def _flatten_for_multipart(self, body: Dict[str, Any], key: str = "") -> List[Tuple[str, Any]]:
+    def _flatten_for_multipart(self, data: Dict[str, Any], key: str = "") -> List[Tuple[str, Any]]:
         flattened = []
 
-        for subkey, value in body.items():
+        for subkey, value in data.items():
             full_key = f"{key}[{subkey}]" if key else subkey
 
             if isinstance(value, dict):

{model_compose-0.1.12 → model_compose-0.2.0}/src/mindor/core/controller/runner/mcp_client.py

@@ -4,7 +4,7 @@ from mindor.core.workflow.schema import WorkflowSchema
 from mindor.core.utils.mcp_client import McpClient, ContentBlock, TextContent, ImageContent, AudioContent
 from mindor.core.utils.streaming import StreamResource, FileStreamResource, Base64StreamResource
 from mindor.core.utils.streaming import encode_stream_to_base64
-from mindor.core.utils.http_client import HttpClient
+from mindor.core.utils.http_client import create_stream_with_url
 from mindor.core.utils.image import load_image_from_stream
 from .runner import ControllerClient
 import json, os
@@ -59,7 +59,7 @@ class McpControllerClient(ControllerClient):
             return await load_image_from_stream(Base64StreamResource(value), subtype)
 
         if format == "url" and isinstance(value, str):
-            return await load_image_from_stream(await HttpClient.request_once(value), subtype)
+            return await load_image_from_stream(await create_stream_with_url(value), subtype)
 
         if isinstance(value, StreamResource):
             return await load_image_from_stream(value, subtype)

{model_compose-0.1.12 → model_compose-0.2.0}/src/mindor/core/controller/webui/gradio.py

@@ -4,7 +4,7 @@ from mindor.core.workflow.schema import WorkflowSchema
 from mindor.core.utils.streaming import StreamResource, Base64StreamResource
 from mindor.core.utils.streaming import save_stream_to_temporary_file
 from mindor.core.utils.http_request import create_upload_file
-from mindor.core.utils.http_client import HttpClient
+from mindor.core.utils.http_client import create_stream_with_url
 from mindor.core.utils.image import load_image_from_stream
 import gradio as gr
 import json
@@ -184,7 +184,7 @@ class GradioWebUIBuilder:
             return await load_image_from_stream(Base64StreamResource(value), subtype)
 
         if format == "url" and isinstance(value, str):
-            return await load_image_from_stream(await HttpClient.request_once(value), subtype)
+            return await load_image_from_stream(await create_stream_with_url(value), subtype)
 
         if isinstance(value, StreamResource):
             return await load_image_from_stream(value, subtype)
@@ -196,7 +196,7 @@ class GradioWebUIBuilder:
             return await save_stream_to_temporary_file(Base64StreamResource(value), subtype)
 
         if format == "url" and isinstance(value, str):
-            return await save_stream_to_temporary_file(await HttpClient.request_once(value), subtype)
+            return await save_stream_to_temporary_file(await create_stream_with_url(value), subtype)
 
         if isinstance(value, StreamResource):
             return await save_stream_to_temporary_file(value, subtype)

{model_compose-0.1.12 → model_compose-0.2.0}/src/mindor/core/utils/http_client.py

@@ -32,14 +32,16 @@ class HttpStreamResource(StreamResource):
             yield chunk
 
 class HttpClient:
+    shared_instance: Optional["HttpClient"] = None
+
     def __init__(self, base_url: Optional[str] = None, headers: Optional[Dict[str, str]] = None):
         self.base_url: Optional[str] = base_url
         self.headers: Optional[Dict[str, str]] = headers
-        self.session = aiohttp.ClientSession(self.base_url.rstrip("/") + "/" if self.base_url else None, headers=self.headers)
+        self.session: aiohttp.ClientSession = self._create_session(self.base_url)
 
     async def __aenter__(self):
         if not self.session:
-            self.session = aiohttp.ClientSession(self.base_url.rstrip("/") + "/" if self.base_url else None, headers=self.headers)
+            self.session = self._create_session(self.base_url)
         return self
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
@@ -56,7 +58,7 @@ class HttpClient:
     ) -> Union[Any, Tuple[Any, int]]:
         response: aiohttp.ClientResponse = None
         try:
-            response = await self._request_with_session(self.session, url_or_path, method, params, body, headers)
+            response = await self._request_with_session(self.session, url_or_path, method, params, body, { **(self.headers or {}), **(headers or {})})
             content, _ = await self._parse_response_content(response)
 
             if raise_on_error and response.status >= 400:
@@ -76,6 +78,12 @@ class HttpClient:
             await self.session.close()
             self.session = None
 
+    @classmethod
+    def get_shared_instance(cls) -> "HttpClient":
+        if not cls.shared_instance:
+            cls.shared_instance = HttpClient()
+        return cls.shared_instance
+    
     @classmethod
     async def request_once(cls, *args, **kwargs):
         instance = cls()
@@ -83,7 +91,10 @@ class HttpClient:
             return await instance.request(*args, **kwargs)
         finally:
             await instance.close()
-    
+
+    def _create_session(self, base_url: Optional[str]) -> aiohttp.ClientSession:
+        return aiohttp.ClientSession(base_url.rstrip("/") + "/" if base_url else None)
+
     async def _request_with_session(
         self,
         session: aiohttp.ClientSession,
@@ -122,3 +133,6 @@ class HttpClient:
         filename = disposition.get("filename")
 
         return (HttpStreamResource(response, content_type, filename), content_type)
+
+async def create_stream_with_url(url: str):
+    return await HttpClient.get_shared_instance().request(url)

{model_compose-0.1.12 → model_compose-0.2.0}/src/mindor/core/utils/image.py

@@ -10,5 +10,5 @@ async def load_image_from_stream(stream: StreamResource, extension: Optional[str
             async for chunk in stream:
                 data.extend(chunk)
             return PILImage.open(io.BytesIO(data))
-    except Exception:
+    except Exception as e:
         return None

{model_compose-0.1.12 → model_compose-0.2.0}/src/mindor/core/utils/renderer.py

@@ -2,7 +2,7 @@ from typing import Callable, Dict, List, Optional, Awaitable, Any
 from .streaming import StreamResource, Base64StreamResource
 from .streaming import encode_stream_to_base64, save_stream_to_temporary_file
 from .http_request import create_upload_file
-from .http_client import HttpClient
+from .http_client import create_stream_with_url
 from starlette.datastructures import UploadFile
 import re, json, base64
 
@@ -128,7 +128,7 @@ class VariableRenderer:
             return await save_stream_to_temporary_file(Base64StreamResource(value), subtype)
 
         if format == "url" and isinstance(value, str):
-            return await save_stream_to_temporary_file(await HttpClient.request_once(value), subtype)
+            return await save_stream_to_temporary_file(await create_stream_with_url(value), subtype)
 
         if isinstance(value, StreamResource):
             return await save_stream_to_temporary_file(value, subtype)

model_compose-0.2.0/src/mindor/core/utils/time.py

@@ -0,0 +1,29 @@
+from typing import Union, Optional
+from datetime import timedelta, datetime
+import zoneinfo
+
+def parse_duration(value: Union[str, float, int]) -> timedelta:
+    if isinstance(value, (float, int)):
+        return timedelta(seconds=value)
+
+    if value.endswith("s"):
+        return timedelta(seconds=float(value[:-1]))
+    
+    if value.endswith("m"):
+        return timedelta(minutes=float(value[:-1]))
+    
+    if value.endswith("h"):
+        return timedelta(hours=float(value[:-1]))
+    
+    if value.endswith("d"):
+        return timedelta(days=float(value[:-1]))
+
+    raise ValueError(f"Unsupported duration format: {value}")
+
+def parse_datetime(value: Union[str, datetime], timezone: Optional[str]) -> datetime:
+    time = datetime.fromisoformat(value) if isinstance(value, str) else value
+    
+    if timezone and time.tzinfo is None:
+        time = time.replace(tzinfo=zoneinfo.ZoneInfo(timezone))
+
+    return time

model_compose-0.2.0/src/mindor/core/workflow/job/__init__.py

@@ -0,0 +1 @@
+from .job import *

model_compose-0.2.0/src/mindor/core/workflow/job/impl/__init__.py

@@ -0,0 +1,3 @@
+from .base import *
+from .action import *
+from .wait import *

model_compose-0.1.12/src/mindor/core/workflow/job.py → model_compose-0.2.0/src/mindor/core/workflow/job/impl/action.py

@@ -1,18 +1,16 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Any
-from mindor.dsl.schema.workflow import JobConfig
+from mindor.dsl.schema.job import ActionJobConfig, JobType
 from mindor.dsl.schema.component import ComponentConfig
-from mindor.core.component import ComponentEngine
-from .context import WorkflowContext
+from mindor.core.component import ComponentEngine, ComponentResolver, create_component
+from .base import Job, JobMap, WorkflowContext
 import asyncio, ulid
 
-class Job:
-    def __init__(self, id: str, config: JobConfig, component_provider: Callable[[str, Union[ComponentConfig, str]], ComponentEngine]):
-        self.id: str = id
-        self.config: JobConfig = config
-        self.component_provider: Callable[[str, Union[ComponentConfig, str]], ComponentEngine] = component_provider
+class ActionJob(Job):
+    def __init__(self, id: str, config: ActionJobConfig, components: Dict[str, ComponentConfig]):
+        super().__init__(id, config, components)
 
     async def run(self, context: WorkflowContext) -> Any:
-        component: ComponentEngine = self.component_provider(self.id, await context.render_variable(self.config.component))
+        component: ComponentEngine = self._create_component(self.id, await context.render_variable(self.config.component))
 
         if not component.started:
             await component.start()
@@ -35,3 +33,14 @@ class Job:
         context.register_source("output", output)
 
         return output
+
+    def _create_component(self, id: str, component: Union[ComponentConfig, str]) -> ComponentEngine:
+        return create_component(*self._resolve_component(id, component), daemon=False)
+
+    def _resolve_component(self, id: str, component: Union[ComponentConfig, str]) -> Tuple[str, ComponentConfig]:
+        if isinstance(component, str):
+            return ComponentResolver(self.components).resolve(component)
+    
+        return id, component
+
+JobMap[JobType.ACTION] = ActionJob

model_compose-0.2.0/src/mindor/core/workflow/job/impl/base.py

@@ -0,0 +1,17 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Any
+from abc import ABC, abstractmethod
+from mindor.dsl.schema.job import JobConfig, JobType
+from mindor.dsl.schema.component import ComponentConfig
+from mindor.core.workflow.context import WorkflowContext
+
+class Job(ABC):
+    def __init__(self, id: str, config: JobConfig, components: Dict[str, ComponentConfig]):
+        self.id: str = id
+        self.config: JobConfig = config
+        self.components: Dict[str, ComponentConfig] = components
+
+    @abstractmethod
+    async def run(self, context: WorkflowContext) -> Any:
+        pass
+
+JobMap: Dict[JobType, Type[Job]] = {}

model_compose-0.2.0/src/mindor/core/workflow/job/impl/wait.py

@@ -0,0 +1,43 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Any
+from mindor.dsl.schema.job import WaitJobConfig, WaitJobType
+from mindor.dsl.schema.component import ComponentConfig
+from mindor.core.utils.time import parse_duration, parse_datetime
+from .base import Job, JobType, JobMap, WorkflowContext
+from datetime import datetime
+import asyncio
+
+class WaitJob(Job):
+    def __init__(self, id: str, config: WaitJobConfig, components: Dict[str, ComponentConfig]):
+        super().__init__(id, config, components)
+
+    async def run(self, context: WorkflowContext) -> Any:
+        if self.config.mode == WaitJobType.TIME_INTERVAL:
+            return await self._wait_until_time_interval(context)
+
+        if self.config.mode == WaitJobType.SPECIFIC_TIME:
+            return await self._wait_until_specific_time(context)
+
+        return None
+    
+    async def _wait_until_time_interval(self, context: WorkflowContext) -> Any:
+        duration = parse_duration((await context.render_variable(self.config.duration)) or 0.0)
+        duration = duration.total_seconds()
+        
+        if duration > 0.0:
+            await asyncio.sleep(duration)
+
+        return None
+
+    async def _wait_until_specific_time(self, context: WorkflowContext) -> Any:
+        timezone = await context.render_variable(self.config.timezone)
+        time = parse_datetime((await context.render_variable(self.config.time)) or datetime(2000, 1, 1, 0, 0, 0), timezone)
+        
+        now = datetime.now(tz=time.tzinfo)
+        duration = (time - now).total_seconds()
+
+        if duration > 0.0:
+            await asyncio.sleep(duration)
+
+        return None
+
+JobMap[JobType.WAIT] = WaitJob

model_compose-0.2.0/src/mindor/core/workflow/job/job.py

@@ -0,0 +1,7 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Any
+from mindor.dsl.schema.workflow import JobConfig
+from mindor.dsl.schema.component import ComponentConfig
+from .impl import Job, JobMap
+
+def create_job(id: str, config: JobConfig, components: Dict[str, ComponentConfig]) -> Job:
+    return JobMap[config.type](id, config, components)

{model_compose-0.1.12 → model_compose-0.2.0}/src/mindor/core/workflow/schema.py

@@ -2,6 +2,7 @@ from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annot
 from dataclasses import dataclass, asdict
 from pydantic import BaseModel
 from mindor.dsl.schema.workflow import WorkflowConfig, WorkflowVariableConfig, WorkflowVariableGroupConfig
+from mindor.dsl.schema.job import ActionJobConfig
 from mindor.dsl.schema.component import ComponentConfig
 import re, json
 
@@ -154,6 +155,9 @@ class WorkflowVariableResolver:
 
         if variable.type in [ "image", "audio", "video", "file", "select" ] and variable.subtype:
             config_dict["options"] = variable.subtype.split(",")
+        
+        if variable.annotations is None:
+            config_dict["annotations"] = []
 
         return WorkflowVariableConfig(**config_dict)
 
@@ -192,7 +196,7 @@ class WorkflowInputVariableResolver(WorkflowVariableResolver):
         variables: List[WorkflowVariable] = []
 
         for job in workflow.jobs.values():
-            if not job.input or job.input == "${input}":
+            if isinstance(job, ActionJobConfig) and (not job.input or job.input == "${input}"):
                 action_id = job.action or "__default__"
                 if isinstance(job.component, str):
                     component: Optional[ComponentConfig] = components[job.component] if job.component in components else None
@@ -205,10 +209,7 @@ class WorkflowInputVariableResolver(WorkflowVariableResolver):
                     if action:
                         variables.extend(self._enumerate_input_variables(action, "input", internal=True))
             else:
-                variables.extend(self._enumerate_input_variables(job.input, "input"))
-
-            for value in [ job.component, job.action, job.repeat_count ]:
-                variables.extend(self._enumerate_input_variables(value, "input"))
+                variables.extend(self._enumerate_input_variables(job, "input"))
 
         return self._to_variable_config_list(variables)
 
@@ -226,7 +227,7 @@ class WorkflowOutputVariableResolver(WorkflowVariableResolver):
             if repeat_count != 1:
                 variables.append(WorkflowVariableGroup(variables=(job_variables := []), repeat_count=repeat_count))
 
-            if not job.output or job.output == "${output}":
+            if isinstance(job, ActionJobConfig) and (not job.output or job.output == "${output}"):
                 action_id = job.action or "__default__"
                 if isinstance(job.component, str):
                     component: Optional[ComponentConfig] = components[job.component] if job.component in components else None

{model_compose-0.1.12 → model_compose-0.2.0}/src/mindor/core/workflow/workflow.py

@@ -3,7 +3,7 @@ from mindor.dsl.schema.workflow import WorkflowConfig, JobConfig
 from mindor.dsl.schema.component import ComponentConfig
 from mindor.core.component import ComponentEngine, ComponentResolver, create_component
 from .context import WorkflowContext
-from .job import Job
+from .job import Job, create_job
 import asyncio
 
 class JobGraphValidator:
@@ -74,12 +74,12 @@ class WorkflowResolver:
         return default_ids[0] if default_ids else "__default__"
 
 class WorkflowRunner:
-    def __init__(self, jobs: Dict[str, JobConfig], component_provider: Callable[[str, Union[ComponentConfig, str]], ComponentEngine]):
+    def __init__(self, jobs: Dict[str, JobConfig], components: Dict[str, ComponentConfig]):
         self.jobs: Dict[str, JobConfig] = jobs
-        self.component_provider: Callable[[str, Union[ComponentConfig, str]], ComponentEngine] = component_provider
+        self.components: Dict[str, ComponentConfig] = components
 
     async def run(self, context: WorkflowContext) -> Any:
-        pending_jobs: Dict[str, Job] = { job_id: Job(job_id, job, self.component_provider) for job_id, job in self.jobs.items() }
+        pending_jobs: Dict[str, Job] = { job_id: create_job(job_id, job, self.components) for job_id, job in self.jobs.items() }
         running_job_ids: Set[str] = set()
         completed_job_ids: Set[str] = set()
         scheduled_job_tasks: Dict[str, asyncio.Task] = {}
@@ -131,21 +131,12 @@ class Workflow:
 
     async def run(self, task_id: str, input: Dict[str, Any]) -> Any:
         context = WorkflowContext(task_id, input)
-        runner = WorkflowRunner(self.config.jobs, self._create_component)
+        runner = WorkflowRunner(self.config.jobs, self.components)
 
         return await runner.run(context)
 
     def validate(self) -> None:
         JobGraphValidator(self.config.jobs).validate()
 
-    def _create_component(self, id: str, component: Union[ComponentConfig, str]) -> ComponentEngine:
-        return create_component(*self._resolve_component(id, component), daemon=False)
-
-    def _resolve_component(self, id: str, component: Union[ComponentConfig, str]) -> Tuple[str, ComponentConfig]:
-        if isinstance(component, str):
-            return ComponentResolver(self.components).resolve(component)
-    
-        return id, component
-
 def create_workflow(id: str, config: WorkflowConfig, components: Dict[str, ComponentConfig]) -> Workflow:
     return Workflow(id, config, components)

{model_compose-0.1.12 → model_compose-0.2.0}/src/mindor/dsl/schema/action/impl/http_client.py

@@ -11,9 +11,9 @@ class PollingCompletionConfig(CommonCompletionConfig):
     endpoint: Optional[str] = None
     path: Optional[str] = None
     method: Literal[ "GET", "POST", "PUT", "DELETE", "PATCH" ] = "GET"
-    headers: Optional[Dict[str, str]] = Field(default_factory=dict)
-    body: Optional[Dict[str, Any]] = Field(default_factory=dict)
-    params: Optional[Dict[str, str]] = Field(default_factory=dict)
+    headers: Dict[str, str] = Field(default_factory=dict)
+    body: Dict[str, Any] = Field(default_factory=dict)
+    params: Dict[str, str] = Field(default_factory=dict)
     status: Optional[str] = None
     success_when: Optional[List[Union[int, str]]] = None
     fail_when: Optional[List[Union[int, str]]] = None
@@ -49,9 +49,9 @@ class HttpClientActionConfig(CommonActionConfig):
     endpoint: Optional[str] = None
     path: Optional[str] = None
     method: Literal[ "GET", "POST", "PUT", "DELETE", "PATCH" ] = "POST"
-    headers: Optional[Dict[str, str]] = Field(default_factory=dict)
-    body: Optional[Dict[str, Any]] = Field(default_factory=dict)
-    params: Optional[Dict[str, str]] = Field(default_factory=dict)
+    headers: Dict[str, str] = Field(default_factory=dict)
+    body: Dict[str, Any] = Field(default_factory=dict)
+    params: Dict[str, str] = Field(default_factory=dict)
     completion: Optional[HttpClientCompletionConfig] = None
 
     @model_validator(mode="before")

model_compose-0.2.0/src/mindor/dsl/schema/action/impl/mcp_client.py

@@ -0,0 +1,9 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+from .common import CommonActionConfig
+
+class McpClientActionConfig(CommonActionConfig):
+    tool: str = Field(default="__default__", description="Name of the tool to invoke.")
+    arguments: Dict[str, Any] = Field(default_factory=dict, description="Arguments to pass to the tool.")
+    headers: Dict[str, str] = Field(default_factory=dict, description="Optional HTTP headers to include in the tool call.")

{model_compose-0.1.12 → model_compose-0.2.0}/src/mindor/dsl/schema/action/impl/shell.py

@@ -6,5 +6,5 @@ from .common import CommonActionConfig
 class ShellActionConfig(CommonActionConfig):
     command: List[str] = Field(..., description="The shell command to execute, as a list of arguments.")
     working_dir: Optional[str] = Field(default=None, description="Working directory for the command.")
-    env: Optional[Dict[str, str]] = Field(default_factory=dict, description="Environment variables to set when executing the command.")
+    env: Dict[str, str] = Field(default_factory=dict, description="Environment variables to set when executing the command.")
     timeout: Optional[float] = Field(default=None, description="Maximum time allowed for the command to run, in seconds.")

{model_compose-0.1.12 → model_compose-0.2.0}/src/mindor/dsl/schema/component/impl/common.py

@@ -5,7 +5,7 @@ from .types import ComponentType
 
 class CommonComponentConfig(BaseModel):
     type: ComponentType
-    runtime: Literal[ "docker", "native" ] = "native"
-    max_concurrent_count: int = 1
-    default: bool = False
-    actions: Optional[Dict[str, CommonActionConfig]] = Field(default_factory=dict)
+    runtime: Literal[ "docker", "native" ] = Field(default="native")
+    max_concurrent_count: int = Field(default=1)
+    default: bool = Field(default=False)
+    actions: Dict[str, CommonActionConfig] = Field(default_factory=dict)

{model_compose-0.1.12 → model_compose-0.2.0}/src/mindor/dsl/schema/component/impl/http_client.py

@@ -6,9 +6,9 @@ from .common import ComponentType, CommonComponentConfig
 
 class HttpClientComponentConfig(CommonComponentConfig):
     type: Literal[ComponentType.HTTP_CLIENT]
-    base_url: Optional[str] = None
-    headers: Optional[Dict[str, Any]] = Field(default_factory=dict)
-    actions: Optional[Dict[str, HttpClientActionConfig]] = Field(default_factory=dict)
+    base_url: Optional[str] = Field(default=None)
+    headers: Dict[str, Any] = Field(default_factory=dict)
+    actions: Dict[str, HttpClientActionConfig] = Field(default_factory=dict)
 
     @model_validator(mode="before")
     def inflate_single_action(cls, values: Dict[str, Any]):

{model_compose-0.1.12 → model_compose-0.2.0}/src/mindor/dsl/schema/component/impl/http_server.py

@@ -6,6 +6,6 @@ from .common import ComponentType, CommonComponentConfig
 
 class HttpServerComponentConfig(CommonComponentConfig):
     type: Literal[ComponentType.HTTP_SERVER]
-    port: Optional[int] = Field(None, ge=1, le=65535)
-    base_path: Optional[str] = None
-    actions: Optional[Dict[str, HttpServerActionConfig]] = Field(default_factory=dict)
+    port: Optional[int] = Field(default=None, ge=1, le=65535)
+    base_path: Optional[str] = Field(default=None)
+    actions: Dict[str, HttpServerActionConfig] = Field(default_factory=dict)

{model_compose-0.1.12 → model_compose-0.2.0}/src/mindor/dsl/schema/component/impl/mcp_client.py

@@ -6,9 +6,9 @@ from .common import ComponentType, CommonComponentConfig
 
 class McpClientComponentConfig(CommonComponentConfig):
     type: Literal[ComponentType.MCP_CLIENT]
-    url: str = Field(..., description="URL of the MCP server to invoke tools")
-    headers: Optional[Dict[str, Any]] = Field(default_factory=dict)
-    actions: Optional[Dict[str, McpClientActionConfig]] = Field(default_factory=dict)
+    url: str = Field(..., description="URL of the MCP server to invoke tools.")
+    headers: Dict[str, Any] = Field(default_factory=dict)
+    actions: Dict[str, McpClientActionConfig] = Field(default_factory=dict)
 
     @model_validator(mode="before")
     def inflate_single_action(cls, values: Dict[str, Any]):

{model_compose-0.1.12 → model_compose-0.2.0}/src/mindor/dsl/schema/component/impl/mcp_server.py

@@ -6,4 +6,4 @@ from .common import ComponentType, CommonComponentConfig
 
 class McpServerComponentConfig(CommonComponentConfig):
     type: Literal[ComponentType.MCP_SERVER]
-    actions: Optional[Dict[str, McpServerActionConfig]] = Field(default_factory=dict)
+    actions: Dict[str, McpServerActionConfig] = Field(default_factory=dict)

{model_compose-0.1.12 → model_compose-0.2.0}/src/mindor/dsl/schema/component/impl/shell.py

@@ -9,7 +9,7 @@ class ShellComponentConfig(CommonComponentConfig):
     base_dir: Optional[str] = Field(default=None, description="Base working directory for all actions in this component.")
     env: Optional[Dict[str, str]] = Field(default_factory=dict, description="Environment variables to set for all actions in this component.")
     actions: Optional[Dict[str, ShellActionConfig]] = Field(default_factory=dict, description="Shell actions mapped by an identifier.")
-    
+
     @model_validator(mode="before")
     def inflate_single_action(cls, values: Dict[str, Any]):
         if "actions" not in values:

model_compose-0.2.0/src/mindor/dsl/schema/job/__init__.py

@@ -0,0 +1 @@
+from .job import *

model_compose-0.2.0/src/mindor/dsl/schema/job/impl/__init__.py

@@ -0,0 +1,3 @@
+from .common import *
+from .action import *
+from .wait import *