model-compose 0.1.7__tar.gz → 0.1.8__tar.gz

{model_compose-0.1.7/src/model_compose.egg-info → model_compose-0.1.8}/PKG-INFO

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

{model_compose-0.1.7 → model_compose-0.1.8}/pyproject.toml

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

{model_compose-0.1.7 → model_compose-0.1.8}/src/mindor/core/component/engine/shell.py

@@ -3,6 +3,7 @@ from mindor.dsl.schema.component import ShellComponentConfig
 from mindor.dsl.schema.action import ActionConfig, ShellActionConfig
 from .base import ComponentEngine, ComponentType, ComponentEngineMap, ActionConfig
 from .context import ComponentContext
+from asyncio.subprocess import Process
 import asyncio, os
 
 class ShellAction:
@@ -32,16 +33,26 @@ class ShellAction:
         try:
             stdout, stderr = await asyncio.wait_for(process.communicate(), timeout=timeout)
         except asyncio.TimeoutError:
-            process.kill()
-            await process.wait()
-            raise RuntimeError(f"Command timed out: {' '.join(command)}")
+            if await self._kill_process(process):
+                raise RuntimeError(f"Command timed out: {' '.join(command)}")
 
         return { 
-            "exit_code": process.returncode, 
             "stdout": stdout.decode().strip(), 
-            "stderr": stderr.decode().strip() 
+            "stderr": stderr.decode().strip(),
+            "exit_code": process.returncode
         }
 
+    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
+
     def _resolve_working_directory(self) -> str:
         working_dir = self.config.working_dir
         if working_dir:

model_compose-0.1.8/src/mindor/core/controller/engine/mcp_server.py

@@ -0,0 +1,158 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Awaitable, Any
+from mindor.dsl.schema.controller import McpServerControllerConfig
+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, WorkflowVariableConfig
+from mindor.core.workflow.schema import WorkflowSchema, create_workflow_schema
+from mindor.core.utils.streaming import StreamResource
+from .base import ControllerEngine, ControllerType, ControllerEngineMap, TaskState
+from mcp.server.fastmcp.server import FastMCP
+from mcp.types import TextContent, ImageContent, AudioContent
+import uvicorn, re, json
+
+_invalid_function_chars_regex = re.compile(r"[^a-zA-Z0-9_]")
+
+class WorkflowToolGenerator():
+    def generate(self, workflow_id: str, workflow: WorkflowSchema, runner: Callable[[Optional[str], Any], Awaitable[Any]]) -> Tuple[Callable[[Any], Awaitable[Any]], str]:
+        async def _run_workflow(input: Any, workflow_id=workflow_id, variables=workflow.output) -> Any:
+            return await self._build_output_value(await runner(workflow_id, input), variables)
+
+        async def _build_input_value(arguments, variables=workflow.input) -> Any:
+            return await self._build_input_value(arguments, variables)
+
+        safe_workflow_id = re.sub(_invalid_function_chars_regex, "_", workflow_id)
+        arguments = ",".join([ variable.name or "input" for variable in workflow.input ])
+        code = f"async def _run_workflow_{safe_workflow_id}({arguments}): return await _run_workflow(await _build_input_value([{arguments}]))"
+        context = { "_run_workflow": _run_workflow, "_build_input_value": _build_input_value }
+        exec(compile(code, f"<string>", "exec"), context)
+
+        return (context[f"_run_workflow_{safe_workflow_id}"], self._generate_description(workflow))
+
+    async def _build_input_value(self, arguments: List[Any], variables: List[WorkflowVariableConfig]) -> Any:
+        input: Dict[str, Any] = {}
+
+        for value, variable in zip(arguments, variables):
+            type, subtype, format = variable.type.value, variable.subtype, variable.format.value if variable.format else None
+            input[variable.name or "input"] = await self._convert_input_value(value, type, subtype, format, variable.default)
+
+        return input
+
+    async def _convert_input_value(self, value: Any, type: str, subtype: Optional[str], format: Optional[str], default: Optional[Any]) -> Any:
+        if type in [ "image", "audio", "video", "file" ]:
+            if format and format != "path":
+                pass
+
+        return value if value != "" else None
+
+    async def _build_output_value(self, state: TaskState, variables: List[WorkflowVariableConfig]) -> List[Union[TextContent, ImageContent, AudioContent]]:
+        output: List[Union[TextContent, ImageContent]] = []
+
+        if state.output:
+            for variable in variables:
+                type, subtype, format = variable.type.value, variable.subtype, variable.format.value if variable.format else None
+                output.append(await self._convert_output_value(state.output, type, subtype, format))
+
+        return output
+
+    async def _convert_output_value(self, value: Any, type: str, subtype: Optional[str], format: Optional[str]) -> Union[TextContent, ImageContent, AudioContent]:
+        if type in [ "image", "audio", "video", "file" ]:
+            if format and format != "path":
+                pass
+
+        if isinstance(value, (dict, list)):
+            return TextContent(type="text", text=json.dumps(value))
+
+        return TextContent(type="text", text=str(value))
+
+    def _generate_description(self, workflow: WorkflowSchema) -> str:
+        lines = []
+
+        lines.append(workflow.description or workflow.title or "")
+        lines.append("")
+        lines.append("Args:")
+
+        for variable in workflow.input:
+            name, type = variable.name or "input", self._get_docstring_type(variable)
+            description = variable.get_annotation_value("description") or ""
+            lines.append(f"    {name} ({type}): {description}")
+
+        lines.append("Returns:")
+
+        if len(workflow.output) == 1 and not workflow.output[0].name:
+            variable = workflow.output[0]
+            name, type = variable.name or "", self._get_docstring_type(variable)
+            lines.append(f"    {type}: {description}")
+        else:
+            lines.append(f"    dict: results containing:")
+            for variable in workflow.output:
+                name, type = variable.name or "", self._get_docstring_type(variable)
+                description = variable.get_annotation_value("description") or ""
+                lines.append(f"        - {name} ({type}): {description}")
+
+        return "\n".join(lines)
+
+    def _get_docstring_type(self, variable: WorkflowVariableConfig) -> str:
+        type, subtype, format = variable.type.value, variable.subtype, variable.format.value if variable.format else None
+
+        if type == "object[]":
+            return "list[dict]"
+
+        if type == "number":
+            return "float"
+
+        if type == "integer":
+            return "int"
+
+        return "str"
+
+class McpServerController(ControllerEngine):
+    def __init__(
+        self,
+        config: McpServerControllerConfig,
+        components: Dict[str, ComponentConfig],
+        listeners: List[ListenerConfig],
+        gateways: List[GatewayConfig],
+        workflows: Dict[str, WorkflowConfig],
+        env: Dict[str, str],
+        daemon: bool
+    ):
+        super().__init__(config, components, listeners, gateways, workflows, env, daemon)
+
+        self.server: Optional[uvicorn.Server] = None
+        self.app: FastMCP = FastMCP(self.config.name, settings={
+            "streamable_http_path": self.config.base_path
+        })
+
+        self._configure_tools()
+
+    def _configure_tools(self) -> None:
+        schema = create_workflow_schema(self.workflows, self.components)
+
+        for workflow_id, workflow in schema.items():
+            fn, description = WorkflowToolGenerator().generate(workflow_id, workflow, self._run_workflow_as_tool)
+            self.app.add_tool(
+                fn=fn,
+                name=workflow.name or workflow_id,
+                title=workflow.title,
+                description=description,
+                annotations=None
+            )
+    
+    async def _run_workflow_as_tool(self, workflow_id: Optional[str], input: Any) -> TaskState:
+        return await self.run_workflow(workflow_id, input, wait_for_completion=True)
+
+    async def _serve(self) -> None:
+        self.server = uvicorn.Server(uvicorn.Config(
+            self.app.streamable_http_app(),
+            host=self.config.host,
+            port=self.config.port,
+            log_level="info"
+        ))
+        await self.server.serve()
+
+    async def _shutdown(self) -> None:
+        if self.server:
+            self.server.should_exit = True
+
+ControllerEngineMap[ControllerType.MCP_SERVER] = McpServerController

{model_compose-0.1.7 → model_compose-0.1.8}/src/mindor/core/controller/webui/gradio.py

@@ -62,18 +62,15 @@ class GradioWebUIBuilder:
 
     def _build_input_component(self, variable: WorkflowVariableConfig) -> gr.Component:
         label = (variable.name or "") + (" *" if variable.required else "") + (f" (default: {variable.default})" if variable.default else "")
-        info = variable.description or ""
+        info = variable.get_annotation_value("description") or ""
         default = variable.default
 
         if variable.type == "string" or variable.format in [ "base64", "url" ]:
             return gr.Textbox(label=label, value="", info=info)
 
-        if variable.type == "number":
-            return gr.Number(label=label, value="", precision=None, info=info)
-        
-        if variable.type == "integer":
-            return gr.Number(label=label, value="", precision=0, info=info)
-        
+        if variable.type in [ "integer", "number" ]:
+            return gr.Number(label=label, value="", info=info)
+
         if variable.type == "boolean":
             return gr.Checkbox(label=label, value=default or False, info=info)
         
@@ -96,14 +93,14 @@ class GradioWebUIBuilder:
     
     async def _build_input_value(self, arguments: List[Any], variables: List[WorkflowVariableConfig]) -> Any:
         if len(variables) == 1 and not variables[0].name:
-            return arguments[0]
+            value, variable = arguments[0], variables[0]
+            type, subtype, format = variable.type.value, variable.subtype, variable.format.value if variable.format else None
+            return await self._convert_input_value(value, type, subtype, format, variable.internal)
 
         input: Dict[str, Any] = {}
-        
         for value, variable in zip(arguments, variables):
             type, subtype, format = variable.type.value, variable.subtype, variable.format.value if variable.format else None
             input[variable.name] = await self._convert_input_value(value, type, subtype, format, variable.internal)
-
         return input
 
     async def _convert_input_value(self, value: Any, type: str, subtype: Optional[str], format: Optional[str], internal: bool) -> Any:
@@ -125,13 +122,16 @@ class GradioWebUIBuilder:
             return groups
 
         label = variable.name or ""
-        info = variable.description or ""
+        info = variable.get_annotation_value("description") or ""
 
         if variable.type in [ "string", "base64" ]:
             return gr.Textbox(label=label, interactive=False, show_copy_button=True, info=info)
 
         if variable.type == "markdown":
             return gr.Markdown(label=label)
+        
+        if variable.type in [ "json", "object[]" ]:
+            return gr.JSON(label=label)
 
         if variable.type == "image":
             return gr.Image(label=label, interactive=False)

model_compose-0.1.8/src/mindor/core/gateway/engine/ssh_tunnel.py

@@ -0,0 +1,25 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Iterator, Any
+from mindor.dsl.schema.gateway import SshTunnelGatewayConfig
+from .base import GatewayEngine, GatewayType, GatewayEngineMap
+from pyngrok import ngrok
+
+class SshTunnelGateway(GatewayEngine):
+    def __init__(self, id: str, config: SshTunnelGatewayConfig, env: Dict[str, str], daemon: bool):
+        super().__init__(id, config, env, daemon)
+
+        self.tunnel: Optional[Any] = None
+        self.public_url: Optional[str] = None
+
+    def get_context(self) -> Dict[str, Any]:
+        return {
+            "public_url": self.public_url,
+            "port": self.config.port
+        }
+
+    async def _serve(self) -> None:
+        pass
+
+    async def _shutdown(self) -> None:
+        pass
+  
+GatewayEngineMap[GatewayType.SSH_TUNNEL] = SshTunnelGateway

model_compose-0.1.8/src/mindor/core/utils/ssh_client.py

@@ -0,0 +1,4 @@
+from typing import Optional, Dict, Tuple, AsyncIterator, Any
+
+class SshClient:
+    pass

{model_compose-0.1.7 → model_compose-0.1.8}/src/mindor/core/utils/template.py

@@ -11,12 +11,13 @@ class TemplateRenderer:
         self.source_resolver: Callable[[str], Awaitable[Any]] = source_resolver
         self.patterns: Dict[str, re.Pattern] = {
             "variable": re.compile(
-                r"""\$\{                                                             # ${ 
-                    ([a-zA-Z_][^.\s]*)                                               # key: input, env, etc.
-                    (?:\.([^\s\|\}]+))?                                              # path: key, key.path[0], etc.
-                    (?:\s*as\s*([^\s\|\}/;]+)(?:/([^\s\|\};]+))?(?:;([^\s\|\}]+))?)? # type/subtype;format
-                    (?:\s*\|\s*([^\}]+))?                                            # default value after `|`
-                \}""",                                                               # }
+                r"""\$\{                                                          # ${ 
+                    (?:\s*([a-zA-Z_][^.\s]*))                                     # key: input, env, etc.
+                    (?:\.([^\s|}]+))?                                             # path: key, key.path[0], etc.
+                    (?:\s*as\s*([^\s/;}]+)(?:/([^\s;}]+))?(?:;([^\s}]+))?)?       # type/subtype;format
+                    (?:\s*\|\s*((?:\$\{[^}]+\}|\\[$@{}]|(?!\s*(?:@\(|\$\{)).)+))? # default value after `|`
+                    (?:\s*(@\(\s*[\w]+\s+(?:\\[$@{}]|(?!\s*\$\{).)+\)))?          # annotations
+                \s*\}""",                                                         # }
                 re.VERBOSE,
             ),
             "keypath": re.compile(r"[-_\w]+|\[\d+\]"),
@@ -39,18 +40,19 @@ class TemplateRenderer:
 
     async def _render_text(self, text: str, ignore_files: bool) -> Any:
         while True:
-            match = self.patterns["variable"].search(text)
+            m = self.patterns["variable"].search(text)
             
-            if not match:
+            if not m:
                 break
 
-            key, path, type, subtype, format, default, variable = (*match.group(1, 2, 3, 4, 5, 6), match.group(0))
+            key, path, type, subtype, format, default, variable = (*m.group(1, 2, 3, 4, 5, 6), m.group(0))
             try:
                 value = self._resolve_by_path(await self.source_resolver(key), path)
             except Exception:
                 value = None
 
-            value = default if value is None else value
+            if value is None and default is not None:
+                value = await self._render_text(default, ignore_files)
 
             if type and value is not None:
                 value = await self._convert_value_to_type(value, type, subtype, format, ignore_files)
@@ -89,13 +91,24 @@ class TemplateRenderer:
 
         if type == "integer":
             return int(value)
-
-        if type == "json":
-            return json.loads(value)
         
         if type == "boolean":
             return str(value).lower() in [ "true", "1" ]
+
+        if type == "json":
+            if isinstance(value, str):
+                return json.loads(value)
+            return value
         
+        if type == "object[]":
+            if isinstance(value, list):
+                objects = [ v for v in value if isinstance(v, dict) ]
+                if subtype:
+                    paths = [ (path, path.split(".")[-1]) for path in subtype.split(",") ]
+                    return [ { key: self._resolve_by_path(obj, path) for path, key in paths } for obj in objects ]
+                return objects
+            return []
+
         if type == "base64":
             if isinstance(value, StreamResource):
                 return await encode_stream_to_base64(value)

{model_compose-0.1.7 → model_compose-0.1.8}/src/mindor/core/workflow/schema.py

@@ -1,27 +1,24 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from dataclasses import dataclass, asdict
 from pydantic import BaseModel
 from mindor.dsl.schema.workflow import WorkflowConfig, WorkflowVariableConfig, WorkflowVariableGroupConfig
 from mindor.dsl.schema.component import ComponentConfig
 import re, json
 
+@dataclass
+class WorkflowVariableAnnotation:
+    name: str
+    value: str
+
+@dataclass
 class WorkflowVariable:
-    def __init__(self, name: Optional[str], type: str, subtype: Optional[str], format: Optional[str], default: Optional[Any], internal: bool = False):
-        self.name: Optional[str] = name
-        self.type: str = type
-        self.subtype: Optional[str] = subtype
-        self.format: Optional[str] = format
-        self.default: Optional[Any] = default
-        self.internal: bool = internal
-
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            "name": self.name,
-            "type": self.type,
-            "subtype": self.subtype,
-            "format": self.format,
-            "default": self.default,
-            "internal": self.internal
-        }
+    name: Optional[str]
+    type: str
+    subtype: Optional[str]
+    format: Optional[str]
+    default: Optional[Any]
+    annotations: Optional[List[WorkflowVariableAnnotation]]
+    internal: bool
 
     def __eq__(self, other):
         if not isinstance(other, WorkflowVariable):
@@ -32,40 +29,56 @@ class WorkflowVariable:
 
     def __hash__(self):
         return hash(self.name) if self.name is not None else id(self)
-    
+
+@dataclass
 class WorkflowVariableGroup:
-    def __init__(self, name: Optional[str], variables: List[WorkflowVariable], repeat_count: int):
-        self.name: Optional[str] = name
-        self.variables: List[WorkflowVariable] = variables
-        self.repeat_count: int = repeat_count
+    name: Optional[str]
+    variables: List[WorkflowVariable]
+    repeat_count: int
 
 class WorkflowVariableResolver:
     def __init__(self):
         self.patterns: Dict[str, re.Pattern] = {
             "variable": re.compile(
-                r"""\$\{                                                             # ${ 
-                    ([a-zA-Z_][^.\s]*)                                               # key: input, env, etc.
-                    (?:\.([^\s\|\}]+))?                                              # path: key, key.path[0], etc.
-                    (?:\s*as\s*([^\s\|\}/;]+)(?:/([^\s\|\};]+))?(?:;([^\s\|\}]+))?)? # type/subtype;format
-                    (?:\s*\|\s*([^\}]+))?                                            # default value after `|`
-                \}""",                                                               # }
+                r"""\$\{                                                          # ${ 
+                    (?:\s*([a-zA-Z_][^.\s]*))                                     # key: input, env, etc.
+                    (?:\.([^\s|}]+))?                                             # path: key, key.path[0], etc.
+                    (?:\s*as\s*([^\s/;}]+)(?:/([^\s;}]+))?(?:;([^\s}]+))?)?       # type/subtype;format
+                    (?:\s*\|\s*((?:\$\{[^}]+\}|\\[$@{}]|(?!\s*(?:@\(|\$\{)).)+))? # default value after `|`
+                    (?:\s*(@\(\s*[\w]+\s+(?:\\[$@{}]|(?!\s*\$\{).)+\)))?          # annotations
+                \s*\}""",                                                         # }
                 re.VERBOSE,
             ),
-            "keypath": re.compile(r"[-_\w]+|\[\d+\]"),
+            "annotation": {
+                "outer": re.compile(r"^@\(|\)$"),
+                "delimiter": re.compile(r"\)\s+@\("),
+                "inner": re.compile(r"([\w]+)\s+(.+)"),
+            }
         }
 
     def _enumerate_input_variables(self, value: Any, wanted_key: str, internal: bool = False) -> List[WorkflowVariable]:
         if isinstance(value, str):
             variables: List[WorkflowVariable] = []
 
-            for match in self.patterns["variable"].finditer(value):
-                key, path, type, subtype, format, default = match.group(1, 2, 3, 4, 5, 6)
+            for m in self.patterns["variable"].finditer(value):
+                key, path, type, subtype, format, default, annotations = m.group(1, 2, 3, 4, 5, 6, 7)
 
                 if type and default:
-                    default = self._parse_as_type(default, type)
+                    default = self._parse_value_as_type(default, type)
+
+                if annotations:
+                    annotations = self._parse_annotations(annotations)
 
                 if key == wanted_key:
-                    variables.append(WorkflowVariable(path, type or "string", subtype, format, default, internal))
+                    variables.append(WorkflowVariable(
+                        name=path, 
+                        type=type or "string", 
+                        subtype=subtype,
+                        format=format,
+                        default=default,
+                        annotations=annotations,
+                        internal=internal
+                    ))
 
             return variables
 
@@ -84,13 +97,24 @@ class WorkflowVariableResolver:
         variables: List[WorkflowVariable] = []
         
         if isinstance(value, str):
-            for match in self.patterns["variable"].finditer(value):
-                key, path, type, subtype, format, default = match.group(1, 2, 3, 4, 5, 6)
+            for m in self.patterns["variable"].finditer(value):
+                key, path, type, subtype, format, default, annotations = m.group(1, 2, 3, 4, 5, 6, 7)
 
                 if type and default:
-                    default = self._parse_as_type(default, type)
-
-                variables.append(WorkflowVariable(name, type or "string", subtype, format, default, internal))
+                    default = self._parse_value_as_type(default, type)
+
+                if annotations:
+                    annotations = self._parse_annotations(annotations)
+
+                variables.append(WorkflowVariable(
+                    name=name,
+                    type=type or "string",
+                    subtype=subtype,
+                    format=format,
+                    default=default,
+                    annotations=annotations,
+                    internal=internal
+                ))
             
             return variables
         
@@ -126,20 +150,20 @@ class WorkflowVariableResolver:
         return configs
     
     def _to_variable_config(self, variable: WorkflowVariable) -> WorkflowVariableConfig:
-        config_dict = variable.to_dict()
+        config_dict = asdict(variable)
 
         if variable.type in [ "image", "audio", "video", "file", "select" ] and variable.subtype:
             config_dict["options"] = variable.subtype.split(",")
 
         return WorkflowVariableConfig(**config_dict)
 
-    def _parse_as_type(self, value: Any, type: str) -> Any:
-        if type == "number":
-            return float(value)
-
+    def _parse_value_as_type(self, value: Any, type: str) -> Any:
         if type == "integer":
             return int(value)
         
+        if type == "number":
+            return float(value)
+
         if type == "boolean":
             return str(value).lower() in [ "true", "1" ]
         
@@ -147,6 +171,21 @@ class WorkflowVariableResolver:
             return json.loads(value)
  
         return value
+    
+    def _parse_annotations(self, value: str) -> List[WorkflowVariableAnnotation]:
+        parts: List[str] = re.split(self.patterns["annotation"]["delimiter"], re.sub(self.patterns["annotation"]["outer"], "", value))
+        annotations: List[WorkflowVariableAnnotation] = []
+
+        for part in parts:
+            m = re.match(self.patterns["annotation"]["inner"], part.strip())
+            
+            if not m:
+                continue
+
+            name, value = m.group(1, 2)
+            annotations.append(WorkflowVariableAnnotation(name=name, value=value))
+
+        return annotations
 
 class WorkflowInputVariableResolver(WorkflowVariableResolver):
     def resolve(self, workflow: WorkflowConfig, components: Dict[str, ComponentConfig]) -> List[WorkflowVariableConfig]:
@@ -185,7 +224,7 @@ class WorkflowOutputVariableResolver(WorkflowVariableResolver):
             repeat_count: int = job.repeat_count if isinstance(job.repeat_count, int) else 0
 
             if repeat_count != 1:
-                variables.append(WorkflowVariableGroup(None, job_variables := [], repeat_count))
+                variables.append(WorkflowVariableGroup(variables=(job_variables := []), repeat_count=repeat_count))
 
             if not job.output or job.output == "${output}":
                 action_id = job.action or "__default__"

{model_compose-0.1.7 → model_compose-0.1.8}/src/mindor/dsl/schema/gateway/gateway.py

@@ -4,7 +4,8 @@ from .impl import *
 
 GatewayConfig = Annotated[
     Union[ 
-        HttpTunnelGatewayConfig
+        HttpTunnelGatewayConfig,
+        SshTunnelGatewayConfig
     ],
     Field(discriminator="type")
 ]

{model_compose-0.1.7 → model_compose-0.1.8}/src/mindor/dsl/schema/gateway/impl/__init__.py

@@ -1,2 +1,3 @@
 from .common import *
 from .http_tunnel import *
+from .ssh_tunnel import *

model_compose-0.1.8/src/mindor/dsl/schema/gateway/impl/ssh_tunnel.py

@@ -0,0 +1,7 @@
+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 GatewayType, CommonGatewayConfig
+
+class SshTunnelGatewayConfig(CommonGatewayConfig):
+    type: Literal[GatewayType.SSH_TUNNEL]

{model_compose-0.1.7 → model_compose-0.1.8}/src/mindor/dsl/schema/gateway/impl/types.py

@@ -2,3 +2,4 @@ from enum import Enum
 
 class GatewayType(str, Enum):
     HTTP_TUNNEL = "http-tunnel"
+    SSH_TUNNEL  = "ssh-tunnel"

{model_compose-0.1.7 → model_compose-0.1.8}/src/mindor/dsl/schema/workflow.py

@@ -12,6 +12,7 @@ class WorkflowVariableType(str, Enum):
     NUMBER   = "number"
     BOOLEAN  = "boolean"
     JSON     = "json"
+    OBJECTS  = "object[]"
     # Encoded data
     BASE64   = "base64"
     MARKDOWN = "markdown"
@@ -29,6 +30,10 @@ class WorkflowVariableFormat(str, Enum):
     PATH   = "path"
     STREAM = "stream"
 
+class WorkflowVariableAnnotationConfig(BaseModel):
+    name: str = Field(..., description="The name of the annotation")
+    value: str = Field(..., description="Description of the annotation")
+
 class WorkflowVariableConfig(BaseModel):
     name: Optional[str] = Field(default=None, description="The name of the variable")
     type: WorkflowVariableType = Field(..., description="Type of the variable")
@@ -37,9 +42,14 @@ class WorkflowVariableConfig(BaseModel):
     options: Optional[List[str]] = Field(default=None, description="List of valid options for file or select type")
     required: bool = Field(default=False, description="Whether this variable is required")
     default: Optional[Any] = Field(default=None, description="Default value if not provided")
-    description: Optional[str] = Field(default=None, description="Description of the variable")
+    annotations: Optional[List[WorkflowVariableAnnotationConfig]] = Field(default_factory=list, description="Annotations of the variable")
     internal: bool = Field(default=False, description="Whether this variable is for internal use")
 
+    def get_annotation_value(self, name: str) -> Optional[str]:
+        if self.annotations:
+            return next((annotation.value for annotation in self.annotations if annotation.name == name), None)
+        return None
+
 class WorkflowVariableGroupConfig(BaseModel):
     name: Optional[str] = Field(default=None, description="The name of the group of variables")
     variables: List[WorkflowVariableConfig] = Field(default_factory=list, description="List of variables included in this group")

{model_compose-0.1.7 → model_compose-0.1.8/src/model_compose.egg-info}/PKG-INFO

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

{model_compose-0.1.7 → model_compose-0.1.8}/src/model_compose.egg-info/SOURCES.txt

@@ -37,6 +37,7 @@ src/mindor/core/gateway/gateway.py
 src/mindor/core/gateway/engine/__init__.py
 src/mindor/core/gateway/engine/base.py
 src/mindor/core/gateway/engine/http_tunnel.py
+src/mindor/core/gateway/engine/ssh_tunnel.py
 src/mindor/core/listener/__init__.py
 src/mindor/core/listener/listener.py
 src/mindor/core/listener/engine/__init__.py
@@ -52,6 +53,7 @@ src/mindor/core/utils/http_client.py
 src/mindor/core/utils/http_request.py
 src/mindor/core/utils/image.py
 src/mindor/core/utils/mcp_client.py
+src/mindor/core/utils/ssh_client.py
 src/mindor/core/utils/streaming.py
 src/mindor/core/utils/template.py
 src/mindor/core/utils/time.py
@@ -98,6 +100,7 @@ src/mindor/dsl/schema/gateway/gateway.py
 src/mindor/dsl/schema/gateway/impl/__init__.py
 src/mindor/dsl/schema/gateway/impl/common.py
 src/mindor/dsl/schema/gateway/impl/http_tunnel.py
+src/mindor/dsl/schema/gateway/impl/ssh_tunnel.py
 src/mindor/dsl/schema/gateway/impl/types.py
 src/mindor/dsl/schema/listener/__init__.py
 src/mindor/dsl/schema/listener/listener.py

model_compose-0.1.7/src/mindor/core/controller/engine/mcp_server.py

@@ -1,93 +0,0 @@
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Awaitable, Any
-from mindor.dsl.schema.controller import McpServerControllerConfig
-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.core.workflow.schema import WorkflowSchema, WorkflowVariableConfig, create_workflow_schema
-from .base import ControllerEngine, ControllerType, ControllerEngineMap
-from mcp.server.fastmcp.server import FastMCP
-import uvicorn
-
-class WorkflowToolGenerator():
-    def generate(self, workflow_id: str, workflow: WorkflowSchema, runner: Callable[[Optional[str], Any], Awaitable[Any]]) -> Tuple[Callable[[Any], Awaitable[Any]], str]:
-        async def _run_workflow(input: Any, workflow_id=workflow_id) -> Any:
-            return await runner(workflow_id, input)
-        
-        async def _build_input_value(*arguments, variables=workflow.input) -> Any:
-            return await self._build_input_value(arguments, variables)
-
-        arguments = ",".join([ variable.name or "input" for variable in workflow.input ])
-        code = f"async def _run_workflow_{workflow_id}({arguments}): return await _run_workflow(await _build_input_value({arguments}))"
-        context = { "_run_workflow": _run_workflow, "_build_input_value": _build_input_value }
-        exec(compile(code, f"<string>", "exec"), context)
-
-        description = ""
-
-        return (context[f"_run_workflow_{workflow_id}"], description)
-
-    async def _build_input_value(self, arguments: List[Any], variables: List[WorkflowVariableConfig]) -> Any:
-        if len(variables) == 1 and not variables[0].name:
-            return arguments[0]
-
-        input: Dict[str, Any] = {}
-        
-        for value, variable in zip(arguments, variables):
-            type, subtype, format = variable.type.value, variable.subtype, variable.format.value if variable.format else None
-            input[variable.name] = await self._convert_input_value(value, type, subtype, format, variable.internal)
-
-        return input
-
-    async def _convert_input_value(self, value: Any, type: str, subtype: Optional[str], format: Optional[str], internal: bool) -> Any:
-        if type in [ "image", "audio", "video", "file" ] and (not internal or not format):
-            pass
-
-        return value if value != "" else None
-
-class McpServerController(ControllerEngine):
-    def __init__(
-        self,
-        config: McpServerControllerConfig,
-        components: Dict[str, ComponentConfig],
-        listeners: List[ListenerConfig],
-        gateways: List[GatewayConfig],
-        workflows: Dict[str, WorkflowConfig],
-        env: Dict[str, str],
-        daemon: bool
-    ):
-        super().__init__(config, components, listeners, gateways, workflows, env, daemon)
-
-        self.server: Optional[uvicorn.Server] = None
-        self.app: FastMCP = FastMCP(self.config.name, settings={
-            "streamable_http_path": self.config.base_path
-        })
-
-        self._configure_tools()
-
-    def _configure_tools(self) -> None:
-        schema = create_workflow_schema(self.workflows, self.components)
-
-        for workflow_id, workflow in schema.items():
-            fn, description = WorkflowToolGenerator().generate(workflow_id, workflow, self._run_workflow)
-            self.app.add_tool(
-                fn=fn,
-                name=workflow.name or workflow_id,
-                annotations=None,
-                title=workflow.title,
-                description=description
-            )
-    
-    async def _serve(self) -> None:
-        self.server = uvicorn.Server(uvicorn.Config(
-            self.app.streamable_http_app(),
-            host=self.config.host,
-            port=self.config.port,
-            log_level="info"
-        ))
-        await self.server.serve()
-
-    async def _shutdown(self) -> None:
-        if self.server:
-            self.server.should_exit = True
-
-ControllerEngineMap[ControllerType.MCP_SERVER] = McpServerController