model-compose 0.4.11__tar.gz → 0.4.13__tar.gz

{model_compose-0.4.11/src/model_compose.egg-info → model_compose-0.4.13}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.4.11
-Summary: model-compose: Declarative AI Model and Workflow Orchestrator
+Version: 0.4.13
+Summary: model-compose: Declarative AI Workflow Orchestrator
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/hanyeol/model-compose
@@ -38,7 +38,7 @@ Dynamic: license-file
 
 ---
 
-# 🤖 model-compose
+# 🤖 Model-Compose
 
 **model-compose** is a declarative AI workflow orchestrator inspired by `docker-compose`. It lets you define and run AI model pipelines using simple YAML files — no custom code required. Effortlessly connect external AI services (OpenAI, Anthropic, Google, etc.), run local AI models, integrate vector stores, and more — all within powerful, composable workflows.
 
@@ -54,12 +54,13 @@ Dynamic: license-file
 
 ## ✨ Features
 
-- 🎨 **Zero Code**: Pure YAML configuration—no scripting required
+- 🎨 **No-Code**: Pure YAML configuration—no scripting required
 - 🔄 **Composable**: Reusable components and multi-step workflows
 - 🚀 **Production Ready**: HTTP/MCP servers + Web UI + Docker deployment
 - 🔌 **Connect Anything**: External AI services, local models, vector stores, and more
 - ⚡ **Stream & Scale**: Real-time streaming and event-driven automation
-- 🛠️ **Developer Friendly**: Environment variables, tunneling, webhooks
+- ⚙️ **Configuration**: Environment variables, flexible settings
+- 🔗 **Integration**: Webhooks, tunneling, HTTP servers
 
 ---
 
@@ -114,10 +115,15 @@ workflows:
       - component: chatgpt
 ```
 
+Create a `.env` file:
+
+```bash
+OPENAI_API_KEY=your-key
+```
+
 Run it:
 
 ```bash
-export OPENAI_API_KEY=your-key
 model-compose up
 ```
 
@@ -129,7 +135,7 @@ Your API is now live at `http://localhost:8080` and Web UI at `http://localhost:
 ## 💡 Key Capabilities
 
 ### 🖥️ Built-in Web UI
-Add a visual interface with just 3 lines of YAML:
+Add a web interface by adding just 2 lines to your YAML:
 ```yaml
 controller:
   webui:
@@ -141,9 +147,9 @@ Instantly get a user-friendly interface to test and monitor your workflows. Supp
 Transform your workflows into MCP tools by changing one line:
 ```yaml
 controller:
-  type: mcp-server  # Change from http-server to mcp-server
+  type: mcp-server
 ```
-No code changes needed. Your workflows become instantly accessible via the Model Context Protocol.
+Just set the type to `mcp-server`. Your workflows become instantly accessible via the Model Context Protocol.
 
 ### 🐳 Docker Deployment
 Deploy anywhere with built-in Docker support:

{model_compose-0.4.11 → model_compose-0.4.13}/README.md

@@ -14,7 +14,7 @@
 
 ---
 
-# 🤖 model-compose
+# 🤖 Model-Compose
 
 **model-compose** is a declarative AI workflow orchestrator inspired by `docker-compose`. It lets you define and run AI model pipelines using simple YAML files — no custom code required. Effortlessly connect external AI services (OpenAI, Anthropic, Google, etc.), run local AI models, integrate vector stores, and more — all within powerful, composable workflows.
 
@@ -30,12 +30,13 @@
 
 ## ✨ Features
 
-- 🎨 **Zero Code**: Pure YAML configuration—no scripting required
+- 🎨 **No-Code**: Pure YAML configuration—no scripting required
 - 🔄 **Composable**: Reusable components and multi-step workflows
 - 🚀 **Production Ready**: HTTP/MCP servers + Web UI + Docker deployment
 - 🔌 **Connect Anything**: External AI services, local models, vector stores, and more
 - ⚡ **Stream & Scale**: Real-time streaming and event-driven automation
-- 🛠️ **Developer Friendly**: Environment variables, tunneling, webhooks
+- ⚙️ **Configuration**: Environment variables, flexible settings
+- 🔗 **Integration**: Webhooks, tunneling, HTTP servers
 
 ---
 
@@ -90,10 +91,15 @@ workflows:
       - component: chatgpt
 ```
 
+Create a `.env` file:
+
+```bash
+OPENAI_API_KEY=your-key
+```
+
 Run it:
 
 ```bash
-export OPENAI_API_KEY=your-key
 model-compose up
 ```
 
@@ -105,7 +111,7 @@ Your API is now live at `http://localhost:8080` and Web UI at `http://localhost:
 ## 💡 Key Capabilities
 
 ### 🖥️ Built-in Web UI
-Add a visual interface with just 3 lines of YAML:
+Add a web interface by adding just 2 lines to your YAML:
 ```yaml
 controller:
   webui:
@@ -117,9 +123,9 @@ Instantly get a user-friendly interface to test and monitor your workflows. Supp
 Transform your workflows into MCP tools by changing one line:
 ```yaml
 controller:
-  type: mcp-server  # Change from http-server to mcp-server
+  type: mcp-server
 ```
-No code changes needed. Your workflows become instantly accessible via the Model Context Protocol.
+Just set the type to `mcp-server`. Your workflows become instantly accessible via the Model Context Protocol.
 
 ### 🐳 Docker Deployment
 Deploy anywhere with built-in Docker support:

{model_compose-0.4.11 → model_compose-0.4.13}/pyproject.toml

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

{model_compose-0.4.11 → model_compose-0.4.13}/src/mindor/core/component/context.py

@@ -43,6 +43,6 @@ class ComponentActionContext:
         gateway = find_gateway_by_port(int(port)) if port else None
 
         if gateway:
-            return gateway.get_context()
+            return gateway.get_context(int(port))
 
         return None

{model_compose-0.4.11 → model_compose-0.4.13}/src/mindor/core/gateway/base.py

@@ -12,7 +12,11 @@ class GatewayService(AsyncService):
         self.config: GatewayConfig = config
 
     @abstractmethod
-    def get_context(self) -> Dict[str, Any]:
+    def get_context(self, port: int) -> Optional[Dict[str, Any]]:
+        pass
+
+    @abstractmethod
+    def serves_port(self, port: int) -> bool:
         pass
 
     async def _install_package(self, package_spec: str, repository: Optional[str]) -> None:

{model_compose-0.4.11 → model_compose-0.4.13}/src/mindor/core/gateway/gateway.py

@@ -20,6 +20,7 @@ def create_gateway(id: str, config: GatewayConfig, daemon: bool) -> GatewayServi
 
 def find_gateway_by_port(port: int) -> Optional[GatewayService]:
     for gateway in GatewayInstances.values():
-        if gateway.config.port == port:
+        if gateway.serves_port(port):
             return gateway
+
     return None

{model_compose-0.4.11 → model_compose-0.4.13}/src/mindor/core/gateway/services/http_tunnel/base.py

@@ -6,22 +6,33 @@ from mindor.core.logger import logging
 class CommonHttpTunnelGateway:
     def __init__(self, config: HttpTunnelGatewayConfig):
         self.config: HttpTunnelGatewayConfig = config
-        self.public_url: Optional[str] = None
+        self.public_urls = Optional[Dict[int, str]]
 
     def get_setup_requirements(self) -> Optional[List[str]]:
         return None
 
     async def serve(self) -> None:
-        self.public_url = await self._serve()
-        logging.info("HTTP tunnel started on port %d: %s", self.config.port, self.public_url)
+        self.public_urls = await self._serve()
+
+        for port, public_url in (self.public_urls or {}).items():
+            logging.info("HTTP tunnel started on port %d: %s", port, public_url)
 
     async def shutdown(self) -> None:
         await self._shutdown()
-        logging.info("HTTP tunnel stopped on port %d: %s", self.config.port, self.public_url)
-        self.public_url = None
+
+        for port, public_url in (self.public_urls or {}).items():
+            logging.info("HTTP tunnel stopped on port %d: %s", port, public_url)
+
+        self.public_urls = None
+
+    def get_public_url(self, port: int) -> Optional[str]:
+        if self.public_urls:
+            return self.public_urls.get(port)
+
+        return None
 
     @abstractmethod
-    async def _serve(self) -> str:
+    async def _serve(self) -> Optional[Dict[int, str]]:
         pass
 
     @abstractmethod

{model_compose-0.4.11 → model_compose-0.4.13}/src/mindor/core/gateway/services/http_tunnel/drivers/ngrok.py

@@ -13,24 +13,29 @@ class NgrokHttpTunnelGateway(CommonHttpTunnelGateway):
     def __init__(self, config: HttpTunnelGatewayConfig):
         super().__init__(config)
 
-        self.tunnel: Optional[ngrok.NgrokTunnel] = None
+        self.tunnels: Optional[Dict[int, ngrok.NgrokTunnel]] = None
 
     def get_setup_requirements(self) -> Optional[List[str]]:
         return [ "pyngrok" ]
 
-    async def _serve(self) -> str:
+    async def _serve(self) -> Optional[Dict[int, str]]:
         from pyngrok import ngrok
 
-        self.tunnel = await asyncio.to_thread(
-            ngrok.connect,
-            addr=self.config.port,
-            bind_tls=True
-        )
-        return self.tunnel.public_url
+        self.tunnels = {}
+
+        for port in self.config.port:
+            self.tunnels[port] = await asyncio.to_thread(
+                ngrok.connect,
+                addr=port,
+                bind_tls=True
+            )
+        
+        return { port: tunnel.public_url for port, tunnel in self.tunnels.items() }
 
     async def _shutdown(self) -> None:
         from pyngrok import ngrok
 
-        if self.tunnel:
-            await asyncio.to_thread(ngrok.disconnect, self.tunnel.public_url)
-            self.tunnel = None
+        for tunnel in self.tunnels.values():
+            await asyncio.to_thread(ngrok.disconnect, tunnel.public_url)
+
+        self.tunnels = None

{model_compose-0.4.11 → model_compose-0.4.13}/src/mindor/core/gateway/services/http_tunnel/http_tunnel.py

@@ -2,7 +2,7 @@ from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annot
 from abc import ABC, abstractmethod
 from mindor.dsl.schema.gateway import HttpTunnelGatewayConfig, HttpTunnelGatewayDriver
 from ...base import GatewayService, GatewayType, register_gateway
-from .base import GatewayService, CommonHttpTunnelGateway
+from .base import CommonHttpTunnelGateway
 from .drivers import NgrokHttpTunnelGateway, CloudflareHttpTunnelGateway
 
 @register_gateway(GatewayType.HTTP_TUNNEL)
@@ -28,11 +28,19 @@ class HttpTunnelGateway(GatewayService):
     def _get_setup_requirements(self) -> Optional[List[str]]:
         return self.driver.get_setup_requirements()
 
-    def get_context(self) -> Dict[str, Any]:
-        return {
-            "public_url": self.driver.public_url,
-            "port": self.config.port
-        }
+    def get_context(self, port: int) -> Optional[Dict[str, Any]]:
+        public_url = self.driver.get_public_url(port)
+
+        if public_url:
+            return {
+                "driver": self.config.driver.value,
+                "public_url": public_url
+            }
+
+        return None
+
+    def serves_port(self, port: int) -> bool:
+        return bool(self.driver.get_public_url(port))
 
     async def _serve(self) -> None:
         await self.driver.serve()

model_compose-0.4.13/src/mindor/core/gateway/services/ssh_tunnel.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+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 GatewayService, GatewayType, register_gateway
+from mindor.core.utils.ssh_client import SshClient
+from mindor.core.logger import logging
+import asyncio
+
+if TYPE_CHECKING:
+    pass
+
+@register_gateway(GatewayType.SSH_TUNNEL)
+class SshTunnelGateway(GatewayService):
+    def __init__(self, id: str, config: SshTunnelGatewayConfig, daemon: bool):
+        super().__init__(id, config, daemon)
+
+        self.client: Optional[SshClient] = None
+        self.ports: Dict[int, int] = {}  # {local_port: remote_port}
+        self._shutdown_event: Optional[asyncio.Event] = None
+
+    def _get_setup_requirements(self) -> Optional[List[str]]:
+        return [ "paramiko" ]
+
+    def get_context(self, port: int) -> Optional[Dict[str, Any]]:
+        remote_port = self.ports.get(port)
+        if remote_port is not None:
+            return {
+                "public_address": f"{self.config.connection.host}:{remote_port}"
+            }
+        return None
+
+    def serves_port(self, port: int) -> bool:
+        return port in self.ports
+
+    async def _serve(self) -> None:
+        """Establish SSH tunnel and start remote port forwarding"""
+        logging.info(
+            f"Establishing SSH tunnel to {self.config.connection.host}:{self.config.connection.port}"
+        )
+
+        self._shutdown_event = asyncio.Event()
+
+        self.client = SshClient(self.config.connection)
+        await self.client.connect()
+
+        # Start remote port forwarding for each port mapping
+        for remote_port, local_port in self.config.port:
+            actual_remote_port = await self.client.start_remote_port_forwarding(
+                remote_port=remote_port,
+                local_port=local_port,
+                local_host="localhost"
+            )
+
+            self.ports[local_port] = actual_remote_port
+
+            logging.info(
+                f"Remote port forwarding started: {self.config.connection.host}:{remote_port} -> localhost:{local_port}"
+            )
+
+        # Keep the SSH connection alive until shutdown event is set
+        await self._shutdown_event.wait()
+
+    async def _shutdown(self) -> None:
+        """Stop SSH tunnel and cleanup"""
+        # Signal the _serve task to stop
+        if self._shutdown_event:
+            self._shutdown_event.set()
+
+        if self.client:
+            logging.info(
+                f"Stopping SSH tunnel to {self.config.connection.host}:{self.config.connection.port}"
+            )
+
+            await self.client.close()
+            self.client = None
+            self.ports = {}
+            self._shutdown_event = None

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

@@ -0,0 +1,206 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional, Dict, List, Tuple, Any
+from mindor.dsl.schema.transport.ssh import SshConnectionConfig, SshKeyfileAuthConfig, SshPasswordAuthConfig
+from mindor.core.logger import logging
+import asyncio
+import os
+import threading
+
+if TYPE_CHECKING:
+    import paramiko
+
+class SshClient:
+    """SSH client with remote port forwarding support"""
+    shared_instance: Optional["SshClient"] = None
+
+    def __init__(self, connection_config: SshConnectionConfig):
+        self.config: SshConnectionConfig = connection_config
+        self.client: Optional[paramiko.SSHClient] = None
+        self.transport: Optional[paramiko.Transport] = None
+        self.port_forwards: List[Tuple[int, int]] = []
+        self._shutdown_event: Optional[threading.Event] = None
+        self._forward_threads: List[threading.Thread] = []
+
+    async def __aenter__(self):
+        await self.connect()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+
+    async def connect(self) -> None:
+        """Establish SSH connection"""
+        import paramiko
+
+        def _connect():
+            client = paramiko.SSHClient()
+            client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+
+            connect_params = {
+                "hostname": self.config.host,
+                "port": self.config.port,
+                "username": self.config.auth.username,
+            }
+            self._configure_auth(connect_params)
+
+            logging.debug(f"Connecting to {self.config.host}:{self.config.port}...")
+            client.connect(**connect_params)
+            logging.debug(f"SSH connection established to {self.config.host}:{self.config.port}")
+
+            return client
+
+        self.client = await asyncio.to_thread(_connect)
+        self.transport = self.client.get_transport()
+        self._shutdown_event = threading.Event()
+
+    def _configure_auth(self, connect_params: Dict[str, Any]) -> None:
+        if isinstance(self.config.auth, SshKeyfileAuthConfig):
+            keyfile_path = os.path.expanduser(self.config.auth.keyfile)
+            connect_params["key_filename"] = keyfile_path
+            return
+
+        if isinstance(self.config.auth, SshPasswordAuthConfig):
+            connect_params["password"] = self.config.auth.password
+            return
+
+    async def start_remote_port_forwarding(
+        self,
+        remote_port: int,
+        local_port: int,
+        local_host: str = "localhost"
+    ) -> int:
+        """
+        Start remote port forwarding
+
+        Args:
+            remote_port: Port on the remote SSH server
+            local_port: Port on the local machine to forward to
+            local_host: Local host address (default: localhost)
+
+        Returns:
+            The actual remote port bound (may differ if remote_port was 0)
+        """
+        import paramiko
+
+        def _start_forwarding():
+            actual_remote_port = self.transport.request_port_forward(
+                address="0.0.0.0",  # Bind to all interfaces on remote
+                port=remote_port
+            )
+
+            logging.debug(
+                f"Remote port forwarding: {self.config.host}:{actual_remote_port} -> "
+                f"{local_host}:{local_port}"
+            )
+
+            def handler():
+                while self._shutdown_event and not self._shutdown_event.is_set():
+                    try:
+                        channel = self.transport.accept(timeout=1.0)
+                        if channel is None:
+                            continue
+
+                        forward_thread = threading.Thread(
+                            target=self._handle_forward,
+                            args=(channel, local_host, local_port),
+                            daemon=True
+                        )
+                        forward_thread.start()
+                    except Exception as e:
+                        if self._shutdown_event and not self._shutdown_event.is_set():
+                            logging.error(f"Error accepting connection: {e}")
+                        break
+
+            handler_thread = threading.Thread(target=handler, daemon=True)
+            handler_thread.start()
+            self._forward_threads.append(handler_thread)
+
+            return actual_remote_port
+
+        actual_remote_port = await asyncio.to_thread(_start_forwarding)
+        self.port_forwards.append((actual_remote_port, local_port))
+
+        return actual_remote_port
+
+    def _handle_forward(
+        self,
+        remote_channel: paramiko.Channel,
+        local_host: str,
+        local_port: int
+    ) -> None:
+        """Handle a single forwarded connection"""
+        import socket
+
+        try:
+            local_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            local_socket.connect((local_host, local_port))
+
+            def forward_data(source, destination):
+                try:
+                    while True:
+                        data = source.recv(1024)
+                        if len(data) == 0:
+                            break
+                        destination.sendall(data)
+                except Exception:
+                    pass
+                finally:
+                    source.close()
+                    destination.close()
+
+            threads = [
+                threading.Thread(target=forward_data, args=(remote_channel, local_socket), daemon=True),
+                threading.Thread(target=forward_data, args=(local_socket, remote_channel), daemon=True),
+            ]
+
+            for thread in threads:
+                thread.start()
+
+            for thread in threads:
+                thread.join()
+
+        except Exception as e:
+            logging.error(f"Error handling forward connection: {e}")
+        finally:
+            try:
+                remote_channel.close()
+            except Exception:
+                pass
+
+    async def close(self) -> None:
+        """Close SSH connection and stop all port forwarding"""
+        if self._shutdown_event:
+            self._shutdown_event.set()
+
+        def _close():
+            # Cancel all remote port forwards
+            for remote_port, _ in self.port_forwards:
+                try:
+                    self.transport.cancel_port_forward("0.0.0.0", remote_port)
+                    logging.debug(f"Cancelled remote port forward on port {remote_port}")
+                except Exception as e:
+                    logging.warning(f"Error cancelling port forward {remote_port}: {e}")
+
+            if self.client:
+                self.client.close()
+                logging.debug(f"SSH connection closed to {self.config.host}:{self.config.port}")
+
+        if self.client:
+            await asyncio.to_thread(_close)
+
+        self.client = None
+        self.transport = None
+        self.port_forwards = []
+        self._forward_threads = []
+        self._shutdown_event = None
+
+    def is_connected(self) -> bool:
+        """Check if SSH connection is active"""
+        return self.client is not None and self.transport is not None and self.transport.is_active()
+
+    @classmethod
+    def get_shared_instance(cls, connection_config: SshConnectionConfig) -> "SshClient":
+        """Get or create shared SSH client instance"""
+        if not cls.shared_instance:
+            cls.shared_instance = SshClient(connection_config)
+        return cls.shared_instance

{model_compose-0.4.11 → model_compose-0.4.13}/src/mindor/dsl/schema/component/impl/common.py

@@ -10,7 +10,7 @@ class CommonComponentConfig(BaseModel):
     id: str = Field(default="__component__", description="ID of component.")
     type: ComponentType = Field(..., description="Type of component.")
     runtime: RuntimeConfig = Field(..., description="Runtime environment settings.")
-    max_concurrent_count: int = Field(default=1, description="Maximum number of concurrent actions this component can handle.")
+    max_concurrent_count: int = Field(default=0, description="Maximum number of concurrent actions this component can handle.")
     default: bool = Field(default=False, description="Whether to use this component when no component is explicitly specified.")
     actions: List[CommonActionConfig] = Field(default_factory=list, description="Actions available within this component.")
 

{model_compose-0.4.11 → model_compose-0.4.13}/src/mindor/dsl/schema/controller/impl/http_server.py

@@ -5,7 +5,7 @@ from .common import ControllerType, CommonControllerConfig
 
 class HttpServerControllerConfig(CommonControllerConfig):
     type: Literal[ControllerType.HTTP_SERVER]
-    host: str = Field(default="0.0.0.0", description="Host address to bind the HTTP server to.")
+    host: str = Field(default="127.0.0.1", description="Host address to bind the HTTP server to.")
     port: int = Field(default=8080, ge=1, le=65535, description="Port number on which the HTTP server will listen.")
     base_path: Optional[str] = Field(default=None, description="Base path to prefix all API routes")
     origins: Optional[str] = Field(default="*", description="CORS allowed origins, specified as a comma-separated string")

{model_compose-0.4.11 → model_compose-0.4.13}/src/mindor/dsl/schema/controller/impl/mcp_server.py

@@ -5,6 +5,6 @@ from .common import ControllerType, CommonControllerConfig
 
 class McpServerControllerConfig(CommonControllerConfig):
     type: Literal[ControllerType.MCP_SERVER]
-    host: str = Field(default="0.0.0.0", description="Host address to bind the MCP server to.")
+    host: str = Field(default="127.0.0.1", description="Host address to bind the MCP server to.")
     port: int = Field(default=8080, ge=1, le=65535, description="Port number on which the MCP server will listen.")
     base_path: Optional[str] = Field(default=None, description="Base path to prefix all MCP endpoints")

{model_compose-0.4.11 → model_compose-0.4.13}/src/mindor/dsl/schema/controller/webui/impl/common.py

@@ -9,5 +9,5 @@ class ControllerWebUIDriver(str, Enum):
 
 class CommonWebUIConfig(BaseModel):
     driver: ControllerWebUIDriver = Field(..., description="Web UI rendering mode.")
-    host: str = Field(default="0.0.0.0", description="Host address to bind the Web UI server to.")
+    host: str = Field(default="127.0.0.1", description="Host address to bind the Web UI server to.")
     port: int = Field(default=8081, ge=1, le=65535, description="Port number to serve the Web UI on.")

{model_compose-0.4.11 → model_compose-0.4.13}/src/mindor/dsl/schema/gateway/impl/common.py

@@ -6,4 +6,3 @@ from .types import GatewayType
 class CommonGatewayConfig(BaseModel):
     type: GatewayType = Field(..., description="Type of gateway service.")
     runtime: RuntimeType = Field(default=RuntimeType.NATIVE, description="Runtime environment for executing the gateway service.")
-    port: int = Field(default=8090, ge=1, le=65535, description="Local port to tunnel through the gateway to the public.")

{model_compose-0.4.11 → model_compose-0.4.13}/src/mindor/dsl/schema/gateway/impl/http_tunnel/impl/common.py

@@ -11,3 +11,12 @@ class HttpTunnelGatewayDriver(str, Enum):
 class CommonHttpTunnelGatewayConfig(CommonGatewayConfig):
     type: Literal[GatewayType.HTTP_TUNNEL]
     driver: HttpTunnelGatewayDriver = Field(..., description="HTTP tunneling service provider.")
+    port: List[int] = Field(..., min_length=1, description="One or more local ports to tunnel through the gateway to the public.")
+    
+    @model_validator(mode="before")
+    def normalize_port(cls, values):
+        port = values.get("port", 8090)  # Default to 8090 if not specified
+        if not isinstance(port, list):
+            port = [ port ]
+        values["port"] = port
+        return values

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

@@ -0,0 +1,26 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+from mindor.dsl.schema.transport.ssh import SshConnectionConfig
+from .common import GatewayType, CommonGatewayConfig
+
+class SshTunnelGatewayConfig(CommonGatewayConfig):
+    type: Literal[GatewayType.SSH_TUNNEL]
+    connection: SshConnectionConfig = Field(..., description="SSH connection configuration.")
+    port: List[Tuple[int, int]] = Field(..., min_length=1, description="One or more port forwarding configuration.")
+
+    @model_validator(mode="before")
+    def normalize_port(cls, values):
+        port = values.get("port", 8090)  # Default to 8090 if not specified
+        if not isinstance(port, list):
+            port = [ port ]
+        values["port"] = [ cls.normalize_single_port(value) for value in port ]
+        return values
+
+    @classmethod
+    def normalize_single_port(cls, value) -> Optional[Tuple[int, int]]:
+        if isinstance(value, str):
+            return tuple(int(port) for port in value.split(":"))
+        if isinstance(value, int):
+            return ( value, value )
+        return None