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

{model_compose-0.1.6/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.6
+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
@@ -15,6 +15,7 @@ Requires-Dist: aiohttp
 Requires-Dist: requests
 Requires-Dist: fastapi
 Requires-Dist: uvicorn
+Requires-Dist: mcp
 Requires-Dist: pyngrok
 Requires-Dist: ulid
 Requires-Dist: gradio

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

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.1.6"
+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" }
@@ -16,6 +16,7 @@ dependencies = [
     "requests", 
     "fastapi", 
     "uvicorn",
+    "mcp",
     "pyngrok", 
     "ulid", 
     "gradio",

{model_compose-0.1.6 → model_compose-0.1.8}/src/mindor/core/component/engine/__init__.py

@@ -1,3 +1,6 @@
 from .base import *
 from .http_server import *
 from .http_client import *
+from .mcp_server import *
+from .mcp_client import *
+from .shell import *

model_compose-0.1.8/src/mindor/core/component/engine/mcp_client.py

@@ -0,0 +1,19 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.component import McpClientComponentConfig
+from .base import ComponentEngine, ComponentType, ComponentEngineMap, ActionConfig
+from .context import ComponentContext
+
+class McpClientComponent(ComponentEngine):
+    def __init__(self, id: str, config: McpClientComponentConfig, env: Dict[str, str], daemon: bool):
+        super().__init__(id, config, env, daemon)
+
+    async def _serve(self) -> None:
+        pass
+
+    async def _shutdown(self) -> None:
+        pass
+
+    async def _run(self, action: ActionConfig, context: ComponentContext) -> Any:
+        return {}
+
+ComponentEngineMap[ComponentType.MCP_CLIENT] = McpClientComponent

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

@@ -0,0 +1,19 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.component import McpServerComponentConfig
+from .base import ComponentEngine, ComponentType, ComponentEngineMap, ActionConfig
+from .context import ComponentContext
+
+class McpServerComponent(ComponentEngine):
+    def __init__(self, id: str, config: McpServerComponentConfig, env: Dict[str, str], daemon: bool):
+        super().__init__(id, config, env, daemon)
+
+    async def _serve(self) -> None:
+        pass
+
+    async def _shutdown(self) -> None:
+        pass
+
+    async def _run(self, action: ActionConfig, context: ComponentContext) -> Any:
+        return {}
+
+ComponentEngineMap[ComponentType.MCP_SERVER] = McpServerComponent

model_compose-0.1.8/src/mindor/core/component/engine/shell.py

@@ -0,0 +1,80 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.component import ShellComponentConfig
+from mindor.dsl.schema.action import ActionConfig, ShellActionConfig
+from .base import ComponentEngine, ComponentType, ComponentEngineMap, ActionConfig
+from .context import ComponentContext
+from asyncio.subprocess import Process
+import asyncio, os
+
+class ShellAction:
+    def __init__(self, base_dir: Optional[str], env: Optional[Dict[str, str]], config: ShellActionConfig):
+        self.base_dir: Optional[str] = base_dir
+        self.env: Optional[Dict[str, str]] = env
+        self.config: ShellActionConfig = config
+
+    async def run(self, context: ComponentContext) -> Any:
+        working_dir = self._resolve_working_directory()
+        env = { **(self.env or {}), **(self.config.env or {}) }
+
+        result = await self._run_command(self.config.command, working_dir, env, self.config.timeout)
+        context.register_source("result", result)
+
+        return (await context.render_template(self.config.output, ignore_files=True)) if self.config.output else result
+    
+    async def _run_command(self, command: List[str], working_dir: str, env: Dict[str, str], timeout: Optional[float]) -> Dict[str, Any]:
+        process = await asyncio.create_subprocess_exec(
+            *command,
+            cwd=working_dir,
+            env={**os.environ, **env},
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+
+        try:
+            stdout, stderr = await asyncio.wait_for(process.communicate(), timeout=timeout)
+        except asyncio.TimeoutError:
+            if await self._kill_process(process):
+                raise RuntimeError(f"Command timed out: {' '.join(command)}")
+
+        return { 
+            "stdout": stdout.decode().strip(), 
+            "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:
+            if self.base_dir:
+                working_dir = os.path.abspath(os.path.join(self.base_dir, working_dir))
+            else:
+                working_dir = os.path.abspath(working_dir)
+        else:
+            working_dir = self.base_dir or os.getcwd()
+        return working_dir
+
+class ShellComponent(ComponentEngine):
+    def __init__(self, id: str, config: ShellComponentConfig, env: Dict[str, str], daemon: bool):
+        super().__init__(id, config, env, daemon)
+
+    async def _serve(self) -> None:
+        pass
+
+    async def _shutdown(self) -> None:
+        pass
+
+    async def _run(self, action: ActionConfig, context: ComponentContext) -> Any:
+        return await ShellAction(self.config.base_dir, self.config.env, action).run(context)
+
+ComponentEngineMap[ComponentType.SHELL] = ShellComponent

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.6 → model_compose-0.1.8}/src/mindor/core/controller/runner/mcp_client.py

@@ -1,10 +1,13 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.controller import ControllerConfig
+from mindor.core.utils.mcp_client import McpClient
 from .runner import ControllerClient
 
 class McpControllerClient(ControllerClient):
     def __init__(self, config: ControllerConfig):
         super().__init__(config)
 
+        self.client: McpClient = McpClient()
+
     async def run_workflow(self, workflow_id: Optional[str], input: Any) -> Any:
         pass

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

@@ -1,14 +1,13 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Awaitable, Any
 from mindor.dsl.schema.workflow import WorkflowVariableConfig, WorkflowVariableGroupConfig
+from mindor.core.workflow.schema import WorkflowSchema
 from mindor.core.utils.streaming import StreamResource, Base64StreamResource
 from mindor.core.utils.streaming import save_stream_to_temporary_file
 from mindor.core.utils.http_request import create_upload_file
 from mindor.core.utils.http_client import HttpClient
 from mindor.core.utils.image import load_image_from_stream
-from .schema import WorkflowSchema
-from starlette.datastructures import UploadFile
 import gradio as gr
-import json, os
+import json
 
 class ComponentGroup:
     def __init__(self, group: gr.Component, components: List[gr.Component]):
@@ -48,9 +47,9 @@ class GradioWebUIBuilder:
                 output_components = gr.Textbox(label="", lines=8, interactive=False, show_copy_button=True)
 
             async def _run_workflow(*args):
-                input = await self._build_input_values(args, workflow.input)
+                input = await self._build_input_value(args, workflow.input)
                 output = await runner(input)
-                output = await self._flatten_output_values(output, workflow.output)
+                output = await self._flatten_output_value(output, workflow.output)
                 return output[0] if len(output) == 1 else output
 
             run_button.click(
@@ -63,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)
         
@@ -95,16 +91,16 @@ class GradioWebUIBuilder:
 
         return gr.Textbox(label=label, value=default, info=f"Unsupported type: {variable.type}")
     
-    async def _build_input_values(self, arguments: List[Any], variables: List[WorkflowVariableConfig]) -> Any:
+    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:
@@ -126,11 +122,17 @@ 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)
 
@@ -152,13 +154,13 @@ class GradioWebUIBuilder:
                 flattened.append(item)
         return flattened
     
-    async def _flatten_output_values(self, output: Any, variables: List[Union[WorkflowVariableConfig, WorkflowVariableGroupConfig]]) -> Any:
+    async def _flatten_output_value(self, output: Any, variables: List[Union[WorkflowVariableConfig, WorkflowVariableGroupConfig]]) -> Any:
         flattened = []
         for variable in variables:
             if isinstance(variable, WorkflowVariableGroupConfig):
                 group = output[variable.name] if variable.name else output
                 for value in group:
-                    flattened.extend(await self._flatten_output_values(value, variable.variables))
+                    flattened.extend(await self._flatten_output_value(value, variable.variables))
             else:
                 value = output[variable.name] if variable.name else output
                 type, subtype, format = variable.type.value, variable.subtype, variable.format.value if variable.format else None

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

@@ -3,14 +3,13 @@ from mindor.dsl.schema.controller import ControllerWebUIConfig, ControllerConfig
 from mindor.dsl.schema.component import ComponentConfig
 from mindor.dsl.schema.workflow import WorkflowConfig
 from mindor.core.controller.runner import ControllerRunner
+from mindor.core.workflow.schema import create_workflow_schema
 from mindor.core.services import AsyncService
-from .schema import WorkflowSchema, WorkflowInputVariableResolver, WorkflowOutputVariableResolver
 from .gradio import GradioWebUIBuilder
 
-from fastapi import FastAPI, APIRouter, Body, HTTPException
-import asyncio, uvicorn
+from fastapi import FastAPI
 from gradio import mount_gradio_app
-import gradio
+import uvicorn, gradio
 
 class ControllerWebUI(AsyncService):
     def __init__(
@@ -38,7 +37,7 @@ class ControllerWebUI(AsyncService):
     def _configure_driver(self) -> None:
         if self.config.driver == "gradio":
             blocks: gradio.Blocks = GradioWebUIBuilder().build(
-                schema=self._resolve_workflow_schema(),
+                schema=create_workflow_schema(self.workflows, self.components),
                 runner=self._run_workflow
             )
             self.app = mount_gradio_app(self.app, blocks, path="")
@@ -59,17 +58,3 @@ class ControllerWebUI(AsyncService):
     
     async def _run_workflow(self, workflow_id: Optional[str], input: Any) -> Any:
         return await self.runner.run_workflow(workflow_id, input)
-
-    def _resolve_workflow_schema(self) -> Dict[str, WorkflowSchema]:
-        schema: Dict[str, WorkflowSchema] = {}
-
-        for workflow_id, workflow in self.workflows.items():
-            schema[workflow_id] = WorkflowSchema(
-                name=workflow.name,
-                title=workflow.title, 
-                description=workflow.description,
-                input=WorkflowInputVariableResolver().resolve(workflow, self.components),
-                output=WorkflowOutputVariableResolver().resolve(workflow, self.components)
-            )
-
-        return schema

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.6 → model_compose-0.1.8}/src/mindor/core/utils/http_client.py

@@ -1,4 +1,4 @@
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, AsyncIterator, Any
+from typing import Optional, Dict, Tuple, AsyncIterator, Any
 from .http_request import build_request_body, parse_options_header
 from .streaming import StreamResource
 from requests.structures import CaseInsensitiveDict

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

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

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.6 → model_compose-0.1.8}/src/mindor/core/utils/streaming.py

@@ -2,7 +2,7 @@ from typing import Optional, AsyncIterator
 from abc import ABC, abstractmethod
 from tempfile import NamedTemporaryFile
 from aiofiles.threadpool.binary import AsyncBufferedReader
-import aiofiles, io, base64
+import io, base64
 
 class StreamResource(ABC):
     def __init__(self, content_type: Optional[str], filename: Optional[str]):

{model_compose-0.1.6 → 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)