model-compose 0.0.3__tar.gz → 0.0.5__tar.gz

{model_compose-0.0.3/src/model_compose.egg-info → model_compose-0.0.5}/PKG-INFO

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

{model_compose-0.0.3 → model_compose-0.0.5}/pyproject.toml

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

{model_compose-0.0.3 → model_compose-0.0.5}/src/mindor/core/component/engine/base.py

@@ -1,5 +1,5 @@
-from abc import ABC, abstractmethod
 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 ComponentConfig, ComponentType
 from mindor.dsl.schema.action import ActionConfig
@@ -78,9 +78,9 @@ class BaseComponent(ABC):
         if self.daemon_task:
             await self.daemon_task
 
-    async def run(self, action_id: Union[str, None], input: Dict[str, Any]) -> Dict[str, Any]:
+    async def run(self, action_id: Union[str, None], call_id: str, input: Dict[str, Any]) -> Dict[str, Any]:
         _, action = ActionResolver(self.config.actions).resolve(action_id)
-        context = ComponentContext(input, self.env)
+        context = ComponentContext(call_id, input, self.env)
 
         if self.queue:
             return await (await self.queue.schedule(action, context))

{model_compose-0.0.3 → model_compose-0.0.5}/src/mindor/core/component/engine/context.py

@@ -2,9 +2,11 @@ from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annot
 from mindor.core.utils.template import TemplateRenderer
 
 class ComponentContext:
-    def __init__(self, input: Dict[str, Any], env: Dict[str, str]):
+    def __init__(self, call_id: str, input: Dict[str, Any], env: Dict[str, str]):
+        self.call_id: str = call_id
         self.input: Dict[str, Any] = input
         self.env: Dict[str, str] = env
+        self.context: Dict[str, Any] = { "call_id": call_id }
         self.sources: Dict[str, Any] = {}
         self.renderer: TemplateRenderer = TemplateRenderer(self._resolve_source)
 
@@ -21,4 +23,6 @@ class ComponentContext:
             return self.input
         if key == "env":
             return self.env
+        if key == "context":
+            return self.context
         raise KeyError(f"Unknown source: {key}")

{model_compose-0.0.3 → model_compose-0.0.5}/src/mindor/core/component/engine/http_client.py

@@ -1,10 +1,10 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.component import HttpClientComponentConfig, HttpClientActionConfig, HttpUrl
+from mindor.core.utils.http_headers import parse_options_header, get_header_value
 from .base import BaseComponent, ComponentType, ComponentEngineMap, ActionConfig
 from .context import ComponentContext
 
-from requests.structures import CaseInsensitiveDict
-from urllib.parse import urlencode, urljoin
+from urllib.parse import urlencode
 import aiohttp, json
 
 class HttpClientAction:
@@ -22,14 +22,14 @@ class HttpClientAction:
         response = await self._request(url, method, params, body, headers)
 
         if not self.config.output:
-            return response or {}
+            return response
 
         if response:
             context.register_source("response", response)
 
         return context.render_template(self.config.output)
 
-    async def _request(self, url: str, method: str, params: Optional[Dict[str, Any]], body: Optional[Dict[str, Any]], headers: Optional[Dict[str, str]]) -> Union[dict, str, bytes]:
+    async def _request(self, url: str, method: str, params: Optional[Dict[str, Any]], body: Optional[Any], headers: Optional[Dict[str, str]]) -> Any:
         async with aiohttp.ClientSession() as session:
             async with session.request(
                 method,
@@ -49,19 +49,19 @@ class HttpClientAction:
         
         return context.render_template(str(self.config.endpoint))
     
-    def _serialize_request_body(self, body: Dict[str, Any], headers: Optional[Dict[str, str]]) -> str:
-        content_type = CaseInsensitiveDict(headers or {}).get("Content-Type", "").lower()
-
-        if content_type == "application/json":
-            return json.dumps(body)
+    def _serialize_request_body(self, body: Any, headers: Optional[Dict[str, str]]) -> Any:
+        content_type, _ = parse_options_header(get_header_value(headers, "Content-Type", ""))
 
         if content_type == "application/x-www-form-urlencoded":
             return urlencode(body)
-        
-        return str(body)
+
+        if isinstance(body, (str, bytes)):
+            return body
+
+        return json.dumps(body)
     
-    async def _deserialize_response_body(self, response: aiohttp.ClientResponse) -> Union[dict, str, bytes]:
-        content_type = response.headers.get("Content-Type", "").lower()
+    async def _deserialize_response_body(self, response: aiohttp.ClientResponse) -> Any:
+        content_type, _ = parse_options_header(response.headers.get("Content-Type", ""))
 
         if content_type == "application/json":
             return await response.json()
@@ -69,7 +69,13 @@ class HttpClientAction:
         if content_type.startswith("text/"):
             return await response.text()
 
-        return await response.read()
+        _, disposition = parse_options_header(response.headers.get("Content-Disposition"))
+
+        return {
+            "filename": disposition.get("filename"),
+            "content_type": content_type,
+            "stream": response.content
+        }
 
 class HttpClientComponent(BaseComponent):
     def __init__(self, id: str, config: HttpClientComponentConfig, env: Dict[str, str], daemon: bool):

{model_compose-0.0.3 → model_compose-0.0.5}/src/mindor/core/controller/engine/base.py

@@ -1,6 +1,6 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 
 from mindor.dsl.schema.controller import ControllerConfig, ControllerType
 from mindor.dsl.schema.component import ComponentConfig
@@ -125,7 +125,7 @@ class BaseController(ABC):
         
         try:
             workflow = create_workflow(*WorkflowResolver(self.workflows).resolve(workflow_id), self.components, self.env)
-            output = await workflow.run(input)
+            output = await workflow.run(task_id, input)
             state = TaskState(task_id=task_id, status="completed", output=output)
         except Exception as e:
             state = TaskState(task_id=task_id, status="failed", error=str(e))

{model_compose-0.0.3 → model_compose-0.0.5}/src/mindor/core/controller/engine/http_server.py

@@ -1,13 +1,13 @@
-from pydantic import BaseModel
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from typing_extensions import Self
+from pydantic import BaseModel
 
 from mindor.dsl.schema.controller import HttpServerControllerConfig
 from mindor.dsl.schema.component import ComponentConfig
 from mindor.dsl.schema.workflow import WorkflowConfig
 from .base import BaseController, ControllerType, ControllerEngineMap, TaskState
 
-from fastapi import FastAPI, Body, HTTPException
+from fastapi import FastAPI, APIRouter, Body, HTTPException
 import uvicorn
 
 class WorkflowTaskRequestBody(BaseModel):
@@ -36,11 +36,13 @@ class HttpServerController(BaseController):
         
         self.server: Optional[uvicorn.Server] = None
         self.app: FastAPI = FastAPI()
-
+        self.router: APIRouter = APIRouter()
+        
         self._configure_routes()
+        self.app.include_router(self.router, prefix=self.config.base_path)
 
     def _configure_routes(self):
-        @self.app.post("/workflows", response_model=TaskResult, response_model_exclude_none=True)
+        @self.router.post("/workflows", response_model=TaskResult, response_model_exclude_none=True)
         async def run_workflow(
             body: WorkflowTaskRequestBody = Body(...)
         ):
@@ -48,7 +50,7 @@ class HttpServerController(BaseController):
 
             return TaskResult.from_instance(state)
 
-        @self.app.get("/tasks/{task_id}", response_model=TaskResult, response_model_exclude_none=True)
+        @self.router.get("/tasks/{task_id}", response_model=TaskResult, response_model_exclude_none=True)
         async def get_task_state(
             task_id: str
         ):
@@ -59,11 +61,22 @@ class HttpServerController(BaseController):
             
             return TaskResult.from_instance(state)
 
+        @self.router.get("/tasks/{task_id}/output")
+        async def get_task_output(
+            task_id: str
+        ):
+            state = self.get_task_state(task_id)
+
+            if not state:
+                raise HTTPException(status_code=404, detail="Task not found")
+            
+            return state.output
+
     async def _serve(self) -> None:
         self.server = uvicorn.Server(uvicorn.Config(
-            self.app, 
-            host=self.config.host, 
-            port=self.config.port, 
+            self.app,
+            host=self.config.host,
+            port=self.config.port,
             log_level="info"
         ))
         await self.server.serve()

model_compose-0.0.5/src/mindor/core/listener/__init__.py

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

model_compose-0.0.5/src/mindor/core/listener/engine/__init__.py

@@ -0,0 +1,2 @@
+from .base import *
+from .http_callback import *

model_compose-0.0.5/src/mindor/core/listener/engine/base.py

@@ -0,0 +1,13 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+from mindor.dsl.schema.listener import ListenerConfig, ListenerType
+from mindor.core.listener import BaseListener, create_listener
+
+class BaseListener(ABC):
+    def __init__(self, config: ListenerConfig, env: Dict[str, str]):
+        self.config: ListenerConfig = config
+        self.env: Dict[str, str] = env
+
+ListenerEngineMap: Dict[ListenerType, Type[BaseListener]] = {}

model_compose-0.0.5/src/mindor/core/listener/engine/http_callback.py

@@ -0,0 +1,37 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from typing_extensions import Self
+from pydantic import BaseModel
+
+from mindor.dsl.schema.listener import HttpCallbackListenerConfig
+from .base import BaseListener, ListenerType, ListenerEngineMap
+
+from fastapi import FastAPI, APIRouter, Body, HTTPException
+import uvicorn
+
+class HttpCallbackListener(BaseListener):
+    def __init__(self, config: HttpCallbackListenerConfig, env: Dict[str, str]):
+        super().__init__(config, env)
+        
+        self.server: Optional[uvicorn.Server] = None
+        self.app: FastAPI = FastAPI()
+        self.router: APIRouter = APIRouter()
+
+        self._configure_routes()
+        self.app.include_router(self.router, prefix=self.config.base_path)
+
+    def _configure_routes(self):
+        pass
+
+    async def _serve(self) -> None:
+        self.server = uvicorn.Server(uvicorn.Config(
+            self.app, 
+            host=self.config.host, 
+            port=self.config.port, 
+            log_level="info"
+        ))
+        await self.server.serve()
+ 
+    async def _shutdown(self) -> None:
+        self.server.should_exit = True
+
+ListenerEngineMap[ListenerType.HTTP_CALLBACK] = HttpCallbackListener

model_compose-0.0.5/src/mindor/core/listener/listener.py

@@ -0,0 +1,9 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.listener import ListenerConfig
+from .engine import BaseListener, ListenerEngineMap
+
+def create_listener(config: ControllerConfig, env: Dict[str, str]) -> BaseListener:
+    try:
+        return ListenerEngineMap[config.type](config, env)
+    except KeyError:
+        raise ValueError(f"Unsupported listener type: {config.type}")

model_compose-0.0.5/src/mindor/core/utils/http_headers.py

@@ -0,0 +1,24 @@
+from typing import Dict, Tuple, Optional
+from requests.structures import CaseInsensitiveDict
+import re
+
+_token_pattern  = r"([\w!#$%&'*+\-.^_`|~]+)"
+_quoted_pattern = r'"([^"]*)"'
+_option_regex = re.compile(fr";\s*{_token_pattern}=(?:{_token_pattern}|{_quoted_pattern})", re.ASCII)
+_firefox_escape_fix = re.compile(r'\\"(?!; |\s*$)')
+
+def parse_options_header(value: str) -> Tuple[str, Dict[str, str]]:
+    value = _firefox_escape_fix.sub("%22", value)
+    pos = value.find(";")
+    if pos >= 0:
+        options = { 
+            m.group(1).lower(): m.group(2) or m.group(3).replace("%22", "") for m in _option_regex.finditer(value[pos:])
+        }
+        value = value[:pos]
+    else:
+        options = {}
+
+    return value.strip().lower(), options
+
+def get_header_value(headers: Dict[str, str], header: str, default_value: Optional[str] = None) -> Optional[str]:
+    return CaseInsensitiveDict(headers or {}).get(header, default_value)

{model_compose-0.0.3 → model_compose-0.0.5}/src/mindor/core/workflow/context.py

@@ -2,9 +2,11 @@ from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annot
 from mindor.core.utils.template import TemplateRenderer
 
 class WorkflowContext:
-    def __init__(self, input: Dict[str, Any], env: Dict[str, str]):
+    def __init__(self, task_id: str, input: Dict[str, Any], env: Dict[str, str]):
+        self.task_id: str = task_id
         self.input: Dict[str, Any] = input
         self.env: Dict[str, str] = env
+        self.context: Dict[str, Any] = { "task_id": task_id }
         self.sources: Dict[str, Any] = { "jobs": {} }
         self.renderer = TemplateRenderer(self._resolve_source)
 
@@ -24,4 +26,6 @@ class WorkflowContext:
             return self.input
         if key == "env":
             return self.env
+        if key == "context":
+            return self.context
         raise KeyError(f"Unknown source: {key}")

{model_compose-0.0.3 → model_compose-0.0.5}/src/mindor/core/workflow/job.py

@@ -3,6 +3,7 @@ from mindor.dsl.schema.workflow import JobConfig
 from mindor.dsl.schema.component import ComponentConfig
 from mindor.core.component import BaseComponent
 from .context import WorkflowContext
+import ulid
 
 class Job:
     def __init__(self, id: str, config: JobConfig, component_provider: Callable[[Union[ComponentConfig, str]], BaseComponent]):
@@ -16,8 +17,9 @@ class Job:
         if not component.started:
             await component.start()
 
+        call_id = ulid.ulid()
         input = context.render_template(self.config.input)
-        output = await component.run(self.config.action, input)
+        output = await component.run(self.config.action, call_id, input)
 
         context.register_source("output", output)
         output = context.render_template(self.config.output)

{model_compose-0.0.3 → model_compose-0.0.5}/src/mindor/core/workflow/workflow.py

@@ -129,8 +129,8 @@ class Workflow:
         self.components: Dict[str, ComponentConfig] = components
         self.env: Dict[str, str] = env
 
-    async def run(self, input: Dict[str, Any]) -> Dict[str, Any]:
-        context = WorkflowContext(input, self.env)
+    async def run(self, task_id: str, input: Dict[str, Any]) -> Dict[str, Any]:
+        context = WorkflowContext(task_id, input, self.env)
         runner = WorkflowRunner(self.config.jobs, self._create_component)
 
         output = await runner.run(context)

{model_compose-0.0.3 → model_compose-0.0.5}/src/mindor/dsl/schema/action/impl/http_client.py

@@ -1,9 +1,17 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from pydantic import BaseModel, Field, HttpUrl
 from pydantic import model_validator
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from .common import CommonActionConfig
 
-class HttpClientActionCompletionConfig(CommonActionConfig):
+class CommonCompletionConfig(BaseModel):
+    type: Literal[ "callback", "polling" ]
+
+class CallbackCompletionConfig(CommonCompletionConfig):
+    type: Literal["callback"]
+    wait_for: str
+
+class PollingCompletionConfig(CommonCompletionConfig):
+    type: Literal["polling"]
     endpoint: Optional[HttpUrl] = None
     path: Optional[str] = None
     method: Literal[ "GET", "POST", "PUT", "DELETE", "PATCH" ] = "GET"
@@ -19,6 +27,14 @@ class HttpClientActionCompletionConfig(CommonActionConfig):
             raise ValueError("Either 'endpoint' or 'path' must be set, but not both.")
         return values
 
+HttpClientCompletionConfig = Annotated[ 
+    Union[ 
+        CallbackCompletionConfig,
+        PollingCompletionConfig
+    ],
+    Field(discriminator="type")
+]
+
 class HttpClientActionConfig(CommonActionConfig):
     endpoint: Optional[HttpUrl] = None
     path: Optional[str] = None
@@ -27,7 +43,7 @@ class HttpClientActionConfig(CommonActionConfig):
     body: Optional[Dict[str, Any]] = Field(default_factory=dict)
     params: Optional[Dict[str, str]] = Field(default_factory=dict)
     deferred: bool = False
-    completion: Optional[HttpClientActionCompletionConfig] = None
+    completion: Optional[HttpClientCompletionConfig] = None
 
     @model_validator(mode="before")
     def validate_endpoint_or_path(cls, values):

{model_compose-0.0.3 → model_compose-0.0.5}/src/mindor/dsl/schema/component/impl/http_client.py

@@ -1,6 +1,6 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from pydantic import BaseModel, Field, HttpUrl
 from pydantic import model_validator
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.action import HttpClientActionConfig
 from .common import ComponentType, CommonComponentConfig
 
@@ -27,7 +27,7 @@ class HttpClientComponentConfig(CommonComponentConfig):
 
     @model_validator(mode="after")
     def validate_baseurl_with_completion(self):
-        for action_id, action in self.actions.items():
-            if action.completion and action.completion.path and not self.base_url:
-                raise ValueError(f"Completion for action '{action_id}' uses 'path' but 'base_url' is not set in the component.")
+        # for action_id, action in self.actions.items():
+        #     if action.completion and action.completion.path and not self.base_url:
+        #         raise ValueError(f"Completion for action '{action_id}' uses 'path' but 'base_url' is not set in the component.")
         return self

{model_compose-0.0.3 → model_compose-0.0.5}/src/mindor/dsl/schema/controller/impl/http_server.py

@@ -1,9 +1,10 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from pydantic import BaseModel, Field, HttpUrl
 from pydantic import model_validator
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from .common import ControllerType, CommonControllerConfig
 
 class HttpServerControllerConfig(CommonControllerConfig):
     type: Literal[ControllerType.HTTP_SERVER]
     host: Optional[str] = "0.0.0.0"
     port: Optional[int] = 8080
+    base_path: Optional[str] = None

model_compose-0.0.5/src/mindor/dsl/schema/listener/__init__.py

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

model_compose-0.0.5/src/mindor/dsl/schema/listener/impl/__init__.py

@@ -0,0 +1,2 @@
+from .common import *
+from .http_callback import *

model_compose-0.0.5/src/mindor/dsl/schema/listener/impl/common.py

@@ -0,0 +1,7 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from .types import ListenerType
+
+class CommonListenerConfig(BaseModel):
+    type: ListenerType
+    runtime: Literal[ "docker", "native" ] = "native"

model_compose-0.0.5/src/mindor/dsl/schema/listener/impl/http_callback.py

@@ -0,0 +1,25 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field, HttpUrl
+from pydantic import model_validator
+from .common import ListenerType, CommonListenerConfig
+
+class HttpCallbackConfig(BaseModel):
+    path: str
+    method: Literal[ "GET", "POST", "PUT", "DELETE", "PATCH" ] = "GET"
+    bulk: bool = False
+    identify_by: str
+
+class HttpCallbackListenerConfig(CommonListenerConfig):
+    type: Literal[ListenerType.HTTP_CALLBACK]
+    host: Optional[str] = "0.0.0.0"
+    port: Optional[int] = 8090
+    base_path: Optional[str] = None
+    callbacks: Optional[List[HttpCallbackConfig]] = Field(default_factory=list)
+
+    @model_validator(mode="before")
+    def inflate_single_callback(cls, values):
+        if "callbacks" not in values:
+            callback_keys = set(HttpCallbackConfig.model_fields.keys())
+            if any(k in values for k in callback_keys):
+                values["callbacks"] = [ { k: values.pop(k) for k in callback_keys if k in values } ]
+        return values

model_compose-0.0.5/src/mindor/dsl/schema/listener/impl/types.py

@@ -0,0 +1,4 @@
+from enum import Enum
+
+class ListenerType(str, Enum):
+    HTTP_CALLBACK = "http-callback"

model_compose-0.0.5/src/mindor/dsl/schema/listener/listener.py

@@ -0,0 +1,10 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field, HttpUrl
+from .impl import *
+
+ListenerConfig = Annotated[
+    Union[ 
+        HttpCallbackListenerConfig
+    ],
+    Field(discriminator="type")
+]

{model_compose-0.0.3 → model_compose-0.0.5/src/model_compose.egg-info}/PKG-INFO

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

{model_compose-0.0.3 → model_compose-0.0.5}/src/model_compose.egg-info/SOURCES.txt

@@ -21,10 +21,16 @@ src/mindor/core/controller/engine/__init__.py
 src/mindor/core/controller/engine/base.py
 src/mindor/core/controller/engine/http_server.py
 src/mindor/core/controller/engine/mcp_server.py
+src/mindor/core/listener/__init__.py
+src/mindor/core/listener/listener.py
+src/mindor/core/listener/engine/__init__.py
+src/mindor/core/listener/engine/base.py
+src/mindor/core/listener/engine/http_callback.py
 src/mindor/core/runtime/__init__.py
 src/mindor/core/runtime/env.py
 src/mindor/core/utils/__init__.py
 src/mindor/core/utils/expiring.py
+src/mindor/core/utils/http_headers.py
 src/mindor/core/utils/template.py
 src/mindor/core/utils/workqueue.py
 src/mindor/core/workflow/__init__.py
@@ -60,6 +66,12 @@ src/mindor/dsl/schema/controller/impl/common.py
 src/mindor/dsl/schema/controller/impl/http_server.py
 src/mindor/dsl/schema/controller/impl/mcp_server.py
 src/mindor/dsl/schema/controller/impl/types.py
+src/mindor/dsl/schema/listener/__init__.py
+src/mindor/dsl/schema/listener/listener.py
+src/mindor/dsl/schema/listener/impl/__init__.py
+src/mindor/dsl/schema/listener/impl/common.py
+src/mindor/dsl/schema/listener/impl/http_callback.py
+src/mindor/dsl/schema/listener/impl/types.py
 src/mindor/dsl/schema/runtime/__init__.py
 src/mindor/dsl/schema/runtime/runtime.py
 src/mindor/dsl/schema/runtime/impl/__init__.py

{model_compose-0.0.3 → model_compose-0.0.5}/src/mindor/dsl/loader.py

@@ -1,5 +1,5 @@
-from pydantic import BaseModel, ValidationError
 from typing import Union, List, Type
+from pydantic import BaseModel, ValidationError
 from pathlib import Path
 import yaml
 

{model_compose-0.0.3 → model_compose-0.0.5}/src/mindor/dsl/schema/action/action.py

@@ -1,5 +1,5 @@
-from pydantic import BaseModel, Field
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
 from .impl import *
 
 ActionConfig = Annotated[ 

{model_compose-0.0.3 → model_compose-0.0.5}/src/mindor/dsl/schema/action/impl/common.py

@@ -1,5 +1,5 @@
-from pydantic import BaseModel, Field
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
 
 class CommonActionConfig(BaseModel):
     output: Optional[Dict[str, Any]] = Field(default_factory=dict)

{model_compose-0.0.3 → model_compose-0.0.5}/src/mindor/dsl/schema/action/impl/http_server.py

@@ -1,6 +1,6 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from pydantic import BaseModel, Field, HttpUrl
 from pydantic import model_validator
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from .common import CommonActionConfig
 
 class HttpServerActionConfig(CommonActionConfig):

{model_compose-0.0.3 → model_compose-0.0.5}/src/mindor/dsl/schema/action/impl/mcp_client.py

@@ -1,6 +1,6 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from pydantic import BaseModel, Field, HttpUrl
 from pydantic import model_validator
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from .common import CommonActionConfig
 
 class McpClientActionConfig(CommonActionConfig):

{model_compose-0.0.3 → model_compose-0.0.5}/src/mindor/dsl/schema/action/impl/mcp_server.py

@@ -1,6 +1,6 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from pydantic import BaseModel, Field, HttpUrl
 from pydantic import model_validator
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from .common import CommonActionConfig
 
 class McpServerActionConfig(CommonActionConfig):

{model_compose-0.0.3 → model_compose-0.0.5}/src/mindor/dsl/schema/component/impl/common.py

@@ -1,5 +1,5 @@
-from pydantic import BaseModel, Field, HttpUrl
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field, HttpUrl
 from .types import ComponentType
 
 class CommonComponentConfig(BaseModel):

{model_compose-0.0.3 → model_compose-0.0.5}/src/mindor/dsl/schema/component/impl/http_server.py

@@ -1,6 +1,6 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from pydantic import BaseModel, Field, HttpUrl
 from pydantic import model_validator
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.action import HttpServerActionConfig
 from .common import ComponentType, CommonComponentConfig
 

{model_compose-0.0.3 → model_compose-0.0.5}/src/mindor/dsl/schema/component/impl/mcp_client.py

@@ -1,6 +1,6 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from pydantic import BaseModel, Field, HttpUrl
 from pydantic import model_validator
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.action import McpClientActionConfig
 from .common import ComponentType, CommonComponentConfig
 

{model_compose-0.0.3 → model_compose-0.0.5}/src/mindor/dsl/schema/component/impl/mcp_server.py

@@ -1,6 +1,6 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from pydantic import BaseModel, Field, HttpUrl
 from pydantic import model_validator
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.action import McpServerActionConfig
 from .common import ComponentType, CommonComponentConfig
 

{model_compose-0.0.3 → model_compose-0.0.5}/src/mindor/dsl/schema/compose.py

@@ -1,6 +1,6 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from pydantic import BaseModel, Field
 from pydantic import model_validator
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 
 from .controller import ControllerConfig
 from .component import ComponentConfig

{model_compose-0.0.3 → model_compose-0.0.5}/src/mindor/dsl/schema/controller/controller.py

@@ -1,5 +1,5 @@
-from pydantic import BaseModel, Field, HttpUrl
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field, HttpUrl
 from .impl import *
 
 ControllerConfig = Annotated[

{model_compose-0.0.3 → model_compose-0.0.5}/src/mindor/dsl/schema/controller/impl/common.py

@@ -1,5 +1,5 @@
-from pydantic import BaseModel, Field
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
 from .types import ControllerType
 
 class CommonControllerConfig(BaseModel):

{model_compose-0.0.3 → model_compose-0.0.5}/src/mindor/dsl/schema/controller/impl/mcp_server.py

@@ -1,6 +1,6 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from pydantic import BaseModel, Field, HttpUrl
 from pydantic import model_validator
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from .common import ControllerType, CommonControllerConfig
 
 class McpServerControllerConfig(CommonControllerConfig):

{model_compose-0.0.3 → model_compose-0.0.5}/src/mindor/dsl/schema/runtime/impl/common.py

@@ -1,5 +1,5 @@
-from pydantic import BaseModel, Field
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
 from .types import RuntimeType
 
 class CommonRumtimeConfig(BaseModel):

{model_compose-0.0.3 → model_compose-0.0.5}/src/mindor/dsl/schema/runtime/impl/docker.py

@@ -1,6 +1,6 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from pydantic import BaseModel, Field, HttpUrl
 from pydantic import model_validator
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from .common import RuntimeType, CommonRumtimeConfig
 
 class DockerRuntimeConfig(CommonRumtimeConfig):

{model_compose-0.0.3 → model_compose-0.0.5}/src/mindor/dsl/schema/runtime/runtime.py

@@ -1,5 +1,5 @@
-from pydantic import BaseModel, Field, HttpUrl
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field, HttpUrl
 from .impl import *
 
 RuntimeConfig = Annotated[ 

{model_compose-0.0.3 → model_compose-0.0.5}/src/mindor/dsl/schema/workflow.py

@@ -1,6 +1,6 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from pydantic import BaseModel, Field
 from pydantic import model_validator
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from .component import ComponentConfig
 
 class JobConfig(BaseModel):