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

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

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

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

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

{model_compose-0.2.0/src/mindor/core/component/engine → model_compose-0.2.2/src/mindor/core/component}/base.py

@@ -1,8 +1,10 @@
 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
+from mindor.dsl.schema.listener import ListenerConfig
+from mindor.dsl.schema.gateway import GatewayConfig
+from mindor.dsl.schema.workflow import WorkflowConfig
 from mindor.core.services import AsyncService
 from mindor.core.utils.workqueue import WorkQueue
 from .context import ComponentActionContext
@@ -30,12 +32,26 @@ class ActionResolver:
 
         return default_ids[0] if default_ids else "__default__"
 
+class ComponentGlobalConfigs:
+    def __init__(
+        self, 
+        components: Dict[str, ComponentConfig],
+        listeners: List[ListenerConfig],
+        gateways: List[GatewayConfig],
+        workflows: Dict[str, WorkflowConfig]
+    ):
+        self.components: Dict[str, ComponentConfig] = components
+        self.listeners: List[ListenerConfig] = listeners
+        self.gateways: List[GatewayConfig] = gateways
+        self.workflows: Dict[str, WorkflowConfig] = workflows
+
 class ComponentEngine(AsyncService):
-    def __init__(self, id: str, config: ComponentConfig, daemon: bool):
+    def __init__(self, id: str, config: ComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
         super().__init__(daemon)
 
         self.id: str = id
         self.config: ComponentConfig = config
+        self.global_configs: ComponentGlobalConfigs = global_configs
         self.queue: Optional[WorkQueue] = None
 
         if self.config.max_concurrent_count > 0:
@@ -66,4 +82,10 @@ class ComponentEngine(AsyncService):
     async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
         pass
 
-ComponentEngineMap: Dict[ComponentType, Type[ComponentEngine]] = {}
+def register_component(type: ComponentType):
+    def decorator(cls: Type[ComponentEngine]) -> Type[ComponentEngine]:
+        ComponentRegistry[type] = cls
+        return cls
+    return decorator
+
+ComponentRegistry: Dict[ComponentType, Type[ComponentEngine]] = {}

{model_compose-0.2.0 → model_compose-0.2.2}/src/mindor/core/component/component.py

@@ -1,6 +1,6 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.component import ComponentConfig
-from .engine import ComponentEngine, ComponentEngineMap
+from .base import ComponentEngine, ComponentGlobalConfigs, ComponentRegistry
 
 ComponentInstances: Dict[str, ComponentEngine] = {}
 
@@ -27,12 +27,14 @@ class ComponentResolver:
 
         return default_ids[0] if default_ids else "__default__"
 
-def create_component(id: str, config: ComponentConfig, daemon: bool) -> ComponentEngine:
+def create_component(id: str, config: ComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool) -> ComponentEngine:
     try:
         component = ComponentInstances[id] if id in ComponentInstances else None
 
         if not component:
-            component = ComponentEngineMap[config.type](id, config, daemon)
+            if not ComponentRegistry:
+                from . import engine
+            component = ComponentRegistry[config.type](id, config, global_configs, daemon)
             ComponentInstances[id] = component
 
         return component

{model_compose-0.2.0 → model_compose-0.2.2}/src/mindor/core/component/engine/__init__.py

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

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

@@ -1,13 +1,13 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, AsyncIterator, Any
 from abc import ABC, abstractmethod
 from mindor.dsl.schema.component import HttpClientComponentConfig
-from mindor.dsl.schema.action import ActionConfig, HttpClientActionConfig, HttpClientCompletionConfig
+from mindor.dsl.schema.action import ActionConfig, HttpClientActionConfig, HttpClientCompletionType, HttpClientCompletionConfig
 from mindor.core.listener import HttpCallbackListener
 from mindor.core.utils.http_client import HttpClient
 from mindor.core.utils.http_status import is_status_code_matched
 from mindor.core.utils.time import parse_duration
-from .base import ComponentEngine, ComponentType, ComponentEngineMap
-from .context import ComponentActionContext
+from ..base import ComponentEngine, ComponentType, ComponentGlobalConfigs, register_component
+from ..context import ComponentActionContext
 from datetime import datetime, timezone
 import asyncio
 
@@ -79,11 +79,11 @@ class HttpClientAction:
             self._configure_completion()
 
     def _configure_completion(self) -> None:
-        if self.config.completion.type == "polling":
+        if self.config.completion.type == HttpClientCompletionType.POLLING:
             self.completion = HttpClientPollingCompletion(self.config.completion)
             return
         
-        if self.config.completion.type == "callback":
+        if self.config.completion.type == HttpClientCompletionType.CALLBACK:
             self.completion = HttpClientCallbackCompletion(self.config.completion)
             return
         
@@ -111,9 +111,10 @@ class HttpClientAction:
 
         return await context.render_variable(self.config.endpoint)
 
+@register_component(ComponentType.HTTP_CLIENT)
 class HttpClientComponent(ComponentEngine):
-    def __init__(self, id: str, config: HttpClientComponentConfig, daemon: bool):
-        super().__init__(id, config, daemon)
+    def __init__(self, id: str, config: HttpClientComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
+        super().__init__(id, config, global_configs, daemon)
 
         self.client: HttpClient = None
 
@@ -126,5 +127,3 @@ class HttpClientComponent(ComponentEngine):
 
     async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
         return await HttpClientAction(action).run(context, self.client)
-
-ComponentEngineMap[ComponentType.HTTP_CLIENT] = HttpClientComponent

{model_compose-0.2.0 → model_compose-0.2.2}/src/mindor/core/component/engine/http_server.py

@@ -1,11 +1,13 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.component import HttpServerComponentConfig
-from .base import ComponentEngine, ComponentType, ComponentEngineMap, ActionConfig
-from .context import ComponentActionContext
+from mindor.dsl.schema.action import ActionConfig, HttpServerActionConfig
+from ..base import ComponentEngine, ComponentType, ComponentGlobalConfigs, register_component
+from ..context import ComponentActionContext
 
+@register_component(ComponentType.HTTP_SERVER)
 class HttpServerComponent(ComponentEngine):
-    def __init__(self, id: str, config: HttpServerComponentConfig, daemon: bool):
-        super().__init__(id, config, daemon)
+    def __init__(self, id: str, config: HttpServerComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
+        super().__init__(id, config, global_configs, daemon)
 
     async def _serve(self) -> None:
         pass
@@ -15,5 +17,3 @@ class HttpServerComponent(ComponentEngine):
 
     async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
         return {}
-
-ComponentEngineMap[ComponentType.HTTP_SERVER] = HttpServerComponent

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

@@ -2,8 +2,8 @@ from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annot
 from mindor.dsl.schema.component import McpClientComponentConfig
 from mindor.dsl.schema.action import ActionConfig, McpClientActionConfig
 from mindor.core.utils.mcp_client import McpClient, ContentBlock, TextContent, ImageContent, AudioContent
-from .base import ComponentEngine, ComponentType, ComponentEngineMap, ActionConfig
-from .context import ComponentActionContext
+from ..base import ComponentEngine, ComponentType, ComponentGlobalConfigs, register_component
+from ..context import ComponentActionContext
 
 class McpClientAction():
     def __init__(self, config: McpClientActionConfig):
@@ -27,9 +27,10 @@ class McpClientAction():
 
         return None
 
+@register_component(ComponentType.MCP_CLIENT)
 class McpClientComponent(ComponentEngine):
-    def __init__(self, id: str, config: McpClientComponentConfig, daemon: bool):
-        super().__init__(id, config, daemon)
+    def __init__(self, id: str, config: McpClientComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
+        super().__init__(id, config, global_configs, daemon)
 
     async def _serve(self) -> None:
         self.client = McpClient(self.config.url, self.config.headers)
@@ -40,5 +41,3 @@ class McpClientComponent(ComponentEngine):
 
     async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
         return await McpClientAction(action).run(context, self.client)
-
-ComponentEngineMap[ComponentType.MCP_CLIENT] = McpClientComponent

{model_compose-0.2.0 → model_compose-0.2.2}/src/mindor/core/component/engine/mcp_server.py

@@ -1,11 +1,13 @@
 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 ComponentActionContext
+from mindor.dsl.schema.action import ActionConfig, McpServerActionConfig
+from ..base import ComponentEngine, ComponentType, ComponentGlobalConfigs, register_component
+from ..context import ComponentActionContext
 
+@register_component(ComponentType.MCP_SERVER)
 class McpServerComponent(ComponentEngine):
-    def __init__(self, id: str, config: McpServerComponentConfig, daemon: bool):
-        super().__init__(id, config, daemon)
+    def __init__(self, id: str, config: McpServerComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
+        super().__init__(id, config, global_configs, daemon)
 
     async def _serve(self) -> None:
         pass
@@ -15,5 +17,3 @@ class McpServerComponent(ComponentEngine):
 
     async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
         return {}
-
-ComponentEngineMap[ComponentType.MCP_SERVER] = McpServerComponent

{model_compose-0.2.0 → model_compose-0.2.2}/src/mindor/core/component/engine/shell.py

@@ -1,8 +1,8 @@
 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 ComponentActionContext
+from ..base import ComponentEngine, ComponentType, ComponentGlobalConfigs, register_component
+from ..context import ComponentActionContext
 from asyncio.subprocess import Process
 import asyncio, os
 
@@ -64,9 +64,10 @@ class ShellAction:
             working_dir = self.base_dir or os.getcwd()
         return working_dir
 
+@register_component(ComponentType.SHELL)
 class ShellComponent(ComponentEngine):
-    def __init__(self, id: str, config: ShellComponentConfig, daemon: bool):
-        super().__init__(id, config, daemon)
+    def __init__(self, id: str, config: ShellComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
+        super().__init__(id, config, global_configs, daemon)
 
     async def _serve(self) -> None:
         pass
@@ -76,5 +77,3 @@ class ShellComponent(ComponentEngine):
 
     async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
         return await ShellAction(action, self.config.base_dir, self.config.env).run(context)
-
-ComponentEngineMap[ComponentType.SHELL] = ShellComponent

model_compose-0.2.2/src/mindor/core/component/engine/workflow.py

@@ -0,0 +1,40 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.component import ComponentConfig, WorkflowComponentConfig
+from mindor.dsl.schema.action import ActionConfig, WorkflowActionConfig
+from mindor.dsl.schema.workflow import WorkflowConfig
+from mindor.core.workflow import Workflow, WorkflowResolver, create_workflow
+from ..base import ComponentEngine, ComponentType, ComponentGlobalConfigs, register_component
+from ..context import ComponentActionContext
+import asyncio, os
+
+class WorkflowAction:
+    def __init__(self, config: WorkflowActionConfig, global_configs: ComponentGlobalConfigs):
+        self.config: WorkflowActionConfig = config
+        self.global_configs: ComponentGlobalConfigs = global_configs
+
+    async def run(self, context: ComponentActionContext) -> Any:
+        workflow_id = await context.render_variable(self.config.workflow)
+        input = await context.render_variable(self.config.input)
+
+        workflow = self._create_workflow(workflow_id)
+        output = await workflow.run(context.call_id, input)
+        context.register_source("output", output)
+
+        return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else output
+
+    def _create_workflow(self, workflow_id: Optional[str]) -> Workflow:
+        return create_workflow(*WorkflowResolver(self.global_configs.workflows).resolve(workflow_id), self.global_configs)
+
+@register_component(ComponentType.WORKFLOW)
+class WorkflowComponent(ComponentEngine):
+    def __init__(self, id: str, config: WorkflowComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):
+        super().__init__(id, config, global_configs, daemon)
+
+    async def _serve(self) -> None:
+        pass
+
+    async def _shutdown(self) -> None:
+        pass
+
+    async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
+        return await WorkflowAction(action, self.global_configs).run(context)

{model_compose-0.2.0/src/mindor/core/controller/engine → model_compose-0.2.2/src/mindor/core/controller}/base.py

@@ -1,27 +1,32 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from enum import Enum
 from dataclasses import dataclass
-
 from mindor.dsl.schema.controller import ControllerConfig, ControllerType
 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.services import AsyncService
-from mindor.core.component import ComponentEngine, create_component
+from mindor.core.component import ComponentEngine, ComponentGlobalConfigs, create_component
 from mindor.core.listener import ListenerEngine, create_listener
 from mindor.core.gateway import GatewayEngine, create_gateway
 from mindor.core.workflow import Workflow, WorkflowResolver, create_workflow
 from mindor.core.controller.webui import ControllerWebUI
 from mindor.core.utils.workqueue import WorkQueue
 from mindor.core.utils.expiring import ExpiringDict
-
 from threading import Lock
 import asyncio, ulid
 
+class TaskStatus(str, Enum):
+    PENDING    = "pending"
+    PROCESSING = "processing"
+    COMPLETED  = "completed"
+    FAILED     = "failed" 
+
 @dataclass
 class TaskState:
     task_id: str
-    status: Literal[ "pending", "processing", "completed", "failed" ]
+    status: TaskStatus
     output: Optional[Any] = None
     error: Optional[Any] = None
 
@@ -51,7 +56,7 @@ class ControllerEngine(AsyncService):
 
     async def run_workflow(self, workflow_id: Optional[str], input: Dict[str, Any], wait_for_completion: bool = True) -> TaskState:
         task_id = ulid.ulid()
-        state = TaskState(task_id=task_id, status="pending")
+        state = TaskState(task_id=task_id, status=TaskStatus.PENDING)
         with self.task_states_lock:
             self.task_states.set(task_id, state)
 
@@ -122,16 +127,16 @@ class ControllerEngine(AsyncService):
         await asyncio.gather(*[ self._create_webui().stop() ])
 
     async def _run_workflow(self, task_id: str, workflow_id: Optional[str], input: Dict[str, Any]) -> TaskState:
-        state = TaskState(task_id=task_id, status="processing")
+        state = TaskState(task_id=task_id, status=TaskStatus.PROCESSING)
         with self.task_states_lock:
             self.task_states.set(task_id, state)
         
         try:
-            workflow = create_workflow(*WorkflowResolver(self.workflows).resolve(workflow_id), self.components)
+            workflow = self._create_workflow(workflow_id)
             output = await workflow.run(task_id, input)
-            state = TaskState(task_id=task_id, status="completed", output=output)
+            state = TaskState(task_id=task_id, status=TaskStatus.COMPLETED, output=output)
         except Exception as e:
-            state = TaskState(task_id=task_id, status="failed", error=str(e))
+            state = TaskState(task_id=task_id, status=TaskStatus.FAILED, error=str(e))
 
         with self.task_states_lock:
             self.task_states.set(task_id, state, 1 * 3600)
@@ -139,7 +144,8 @@ class ControllerEngine(AsyncService):
         return state
 
     def _create_components(self) -> List[ComponentEngine]:
-        return [ create_component(component_id, config, self.daemon) for component_id, config in self.components.items() ]
+        global_configs = self._get_component_global_configs()
+        return [ create_component(component_id, config, global_configs, self.daemon) for component_id, config in self.components.items() ]
     
     def _create_listeners(self) -> List[ListenerEngine]:
         return [ create_listener(f"listener-{index}", config, self.daemon) for index, config in enumerate(self.listeners) ]
@@ -151,6 +157,16 @@ class ControllerEngine(AsyncService):
         return ControllerWebUI(self.config.webui, self.config, self.components, self.workflows, self.daemon)
 
     def _create_workflow(self, workflow_id: Optional[str]) -> Workflow:
-        return create_workflow(*WorkflowResolver(self.workflows).resolve(workflow_id), self.components)
+        global_configs = self._get_component_global_configs()
+        return create_workflow(*WorkflowResolver(self.workflows).resolve(workflow_id), global_configs)
+
+    def _get_component_global_configs(self) -> ComponentGlobalConfigs:
+        return ComponentGlobalConfigs(self.components, self.listeners, self.gateways, self.workflows)
+
+def register_controller(type: ControllerType):
+    def decorator(cls: Type[ControllerEngine]) -> Type[ControllerEngine]:
+        ControllerRegistry[type] = cls
+        return cls
+    return decorator
 
-ControllerEngineMap: Dict[ControllerType, Type[ControllerEngine]] = {}
+ControllerRegistry: Dict[ControllerType, Type[ControllerEngine]] = {}

{model_compose-0.2.0 → model_compose-0.2.2}/src/mindor/core/controller/controller.py

@@ -4,7 +4,7 @@ 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 .engine import ControllerEngine, ControllerEngineMap
+from .base import ControllerEngine, ControllerRegistry
 
 def create_controller(
     config: ControllerConfig, 
@@ -15,6 +15,8 @@ def create_controller(
     daemon: bool
 ) -> ControllerEngine:
     try:
-        return ControllerEngineMap[config.type](config, components, listeners, gateways, workflows, daemon)
+        if not ControllerRegistry:
+            from . import engine
+        return ControllerRegistry[config.type](config, components, listeners, gateways, workflows, daemon)
     except KeyError:
         raise ValueError(f"Unsupported controller type: {config.type}")

{model_compose-0.2.0 → model_compose-0.2.2}/src/mindor/core/controller/engine/__init__.py

@@ -1,3 +1,2 @@
-from .base import *
 from .http_server import *
 from .mcp_server import *

{model_compose-0.2.0 → model_compose-0.2.2}/src/mindor/core/controller/engine/http_server.py

@@ -1,7 +1,6 @@
 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.listener import ListenerConfig
@@ -9,8 +8,7 @@ from mindor.dsl.schema.gateway import GatewayConfig
 from mindor.dsl.schema.workflow import WorkflowConfig
 from mindor.core.utils.http_request import parse_request_body, parse_options_header
 from mindor.core.utils.streaming import StreamResource
-from .base import ControllerEngine, ControllerType, ControllerEngineMap, TaskState
-
+from ..base import ControllerEngine, ControllerType, TaskState, TaskStatus, register_controller
 from fastapi import FastAPI, APIRouter, Request, Body, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import Response, JSONResponse, StreamingResponse
@@ -38,6 +36,7 @@ class TaskResult(BaseModel):
             error=instance.error
         )
 
+@register_controller(ControllerType.HTTP_SERVER)
 class HttpServerController(ControllerEngine):
     def __init__(
         self,
@@ -76,7 +75,7 @@ class HttpServerController(ControllerEngine):
             state = await self.run_workflow(body.workflow_id, body.input, body.wait_for_completion)
 
             if body.output_only and not body.wait_for_completion:
-                raise HTTPException(status_code=400, detail="output_only requires wait_for_completion=True.")
+                raise HTTPException(status_code=400, detail="output_only requires wait_for_completion=true.")
             
             if body.output_only:
                 return self._render_task_output(state)
@@ -130,10 +129,10 @@ class HttpServerController(ControllerEngine):
         return JSONResponse(content=TaskResult.from_instance(state).model_dump(exclude_none=True))
 
     def _render_task_output(self, state: TaskState) -> Response:
-        if state.status in [ "pending", "processing" ]:
+        if state.status in [ TaskStatus.PENDING, TaskStatus.PROCESSING ]:
             raise HTTPException(status_code=202, detail="Task is still in progress.")
 
-        if state.status == "failed":
+        if state.status == TaskStatus.FAILED:
             raise HTTPException(status_code=500, detail=str(state.error))
 
         if isinstance(state.output, StreamResource):
@@ -160,5 +159,3 @@ class HttpServerController(ControllerEngine):
             headers["Content-Disposition"] = f'attachment; filename="{filename}"'
 
         return headers
-
-ControllerEngineMap[ControllerType.HTTP_SERVER] = HttpServerController

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

@@ -3,12 +3,12 @@ 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.dsl.schema.workflow import WorkflowConfig, WorkflowVariableConfig, WorkflowVariableType, WorkflowVariableFormat
 from mindor.core.workflow.schema import WorkflowSchema, create_workflow_schema
 from mindor.core.utils.streaming import StreamResource, Base64StreamResource
 from mindor.core.utils.streaming import save_stream_to_temporary_file
 from mindor.core.utils.http_client import create_stream_with_url
-from .base import ControllerEngine, ControllerType, ControllerEngineMap, TaskState
+from ..base import ControllerEngine, ControllerType, TaskState, register_controller
 from mcp.server.fastmcp.server import FastMCP
 from mcp.types import TextContent, ImageContent, AudioContent
 import uvicorn, re, json
@@ -35,13 +35,12 @@ class WorkflowToolGenerator():
         input: Dict[str, Any] = {}
 
         for value, variable in zip(arguments, workflow.input):
-            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)
+            input[variable.name or "input"] = await self._convert_input_value(value, variable.type, variable.subtype, variable.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" ]:
+    async def _convert_input_value(self, value: Any, type: WorkflowVariableType, subtype: Optional[str], format: Optional[WorkflowVariableFormat], default: Optional[Any]) -> Any:
+        if type in [ WorkflowVariableType.IMAGE, WorkflowVariableType.AUDIO, WorkflowVariableType.VIDEO, WorkflowVariableType.FILE ]:
             if format and format != "path":
                 pass
 
@@ -53,23 +52,21 @@ class WorkflowToolGenerator():
         if state.output:
             if len(workflow.output) == 1 and not workflow.output[0].name:
                 variable = workflow.output[0]
-                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))
+                output.append(await self._convert_output_value(state.output, variable.type, variable.subtype, variable.format))
             else:
                 for variable in workflow.output:
-                    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[variable.name], type, subtype, format))
+                    output.append(await self._convert_output_value(state.output[variable.name], variable.type, variable.subtype, variable.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 == "base64" and len(value) < 1024 * 1024: # at most 1MB
-                if type == "image":
+    async def _convert_output_value(self, value: Any, type: WorkflowVariableType, subtype: Optional[str], format: Optional[WorkflowVariableFormat]) -> Union[TextContent, ImageContent, AudioContent]:
+        if type in [ WorkflowVariableType.IMAGE, WorkflowVariableType.AUDIO, WorkflowVariableType.VIDEO, WorkflowVariableType.FILE ]:
+            if format == WorkflowVariableFormat.BASE64 and len(value) < 1024 * 1024: # at most 1MB
+                if type == WorkflowVariableType.IMAGE:
                     return ImageContent(type="image", data=value, mimeType=f"{type}/{subtype}")
-                if type == "audio":
+                if type == WorkflowVariableType.AUDIO:
                     return AudioContent(type="audio", data=value, mimeType=f"{type}/{subtype}")
-            if not format or format not in [ "path", "url" ]:
+            if not format or format not in [ WorkflowVariableFormat.PATH, WorkflowVariableFormat.URL ]:
                 value = await self._save_value_to_temporary_file(value, subtype, format)
             return TextContent(type="text", text=value)
 
@@ -78,11 +75,11 @@ class WorkflowToolGenerator():
 
         return TextContent(type="text", text=str(value))
 
-    async def _save_value_to_temporary_file(self, value: Any, subtype: Optional[str], format: Optional[str]) -> Optional[str]:
-        if format == "base64" and isinstance(value, str):
+    async def _save_value_to_temporary_file(self, value: Any, subtype: Optional[str], format: Optional[WorkflowVariableFormat]) -> Optional[str]:
+        if format == WorkflowVariableFormat.BASE64 and isinstance(value, str):
             return await save_stream_to_temporary_file(Base64StreamResource(value), subtype)
 
-        if format == "url" and isinstance(value, str):
+        if format == WorkflowVariableFormat.URL and isinstance(value, str):
             return await save_stream_to_temporary_file(await create_stream_with_url(value), subtype)
 
         if isinstance(value, StreamResource):
@@ -119,19 +116,18 @@ class WorkflowToolGenerator():
         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[]":
+        if variable.type == WorkflowVariableType.OBJECTS:
             return "list[dict]"
 
-        if type == "number":
+        if variable.type == WorkflowVariableType.NUMBER:
             return "float"
 
-        if type == "integer":
+        if variable.type == WorkflowVariableType.INTEGER:
             return "int"
 
         return "str"
 
+@register_controller(ControllerType.MCP_SERVER)
 class McpServerController(ControllerEngine):
     def __init__(
         self,
@@ -180,5 +176,3 @@ class McpServerController(ControllerEngine):
     async def _shutdown(self) -> None:
         if self.server:
             self.server.should_exit = True
-
-ControllerEngineMap[ControllerType.MCP_SERVER] = McpServerController

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

@@ -1,5 +1,6 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.controller import ControllerConfig
+from mindor.dsl.schema.workflow import WorkflowVariableType, WorkflowVariableFormat
 from mindor.core.workflow.schema import WorkflowSchema
 from mindor.core.utils.mcp_client import McpClient, ContentBlock, TextContent, ImageContent, AudioContent
 from mindor.core.utils.streaming import StreamResource, FileStreamResource, Base64StreamResource
@@ -29,23 +30,21 @@ class McpControllerClient(ControllerClient):
 
         if len(workflow.output) == 1 and not workflow.output[0].name:
             content, variable = contents[0], workflow.output[0]
-            type, subtype, format = variable.type.value, variable.subtype, variable.format.value if variable.format else None
-            return await self._convert_output_value(content, type, subtype, format)
+            return await self._convert_output_value(content, variable.type, variable.subtype, variable.format)
         
         output = {}
         for content, variable in zip(contents, workflow.output):
-            type, subtype, format = variable.type.value, variable.subtype, variable.format.value if variable.format else None
-            output[variable.name or "output"] = await self._convert_output_value(content, type, subtype, format)
+            output[variable.name or "output"] = await self._convert_output_value(content, variable.type, variable.subtype, variable.format)
         return output
 
-    async def _convert_output_value(self, content: ContentBlock, type: str, subtype: Optional[str], format: Optional[str]) -> Any:
+    async def _convert_output_value(self, content: ContentBlock, type: WorkflowVariableType, subtype: Optional[str], format: Optional[WorkflowVariableFormat]) -> Any:
         if isinstance(content, TextContent):
-            if type in [ "json", "object[]" ]:
+            if type in [ WorkflowVariableType.JSON, WorkflowVariableType.OBJECTS ]:
                 return json.loads(content.text)
-            if type in [ "image", "audio", "video", "file" ]:
+            if type in [ WorkflowVariableType.IMAGE, WorkflowVariableType.AUDIO, WorkflowVariableType.VIDEO, WorkflowVariableType.FILE ]:
                 if not format and os.path.exists(content.text):
                     return FileStreamResource(content.text)
-                if format == "base64": # content.text is path
+                if format == WorkflowVariableFormat.BASE64: # content.text is path
                     return await encode_stream_to_base64(FileStreamResource(content.text))
             return content.text
 
@@ -54,11 +53,11 @@ class McpControllerClient(ControllerClient):
 
         return None
 
-    async def _load_image_from_value(self, value: Any, subtype: Optional[str], format: Optional[str]) -> Optional[str]:
-        if format == "base64" and isinstance(value, str):
+    async def _load_image_from_value(self, value: Any, subtype: Optional[str], format: Optional[WorkflowVariableFormat]) -> Optional[str]:
+        if format == WorkflowVariableFormat.BASE64 and isinstance(value, str):
             return await load_image_from_stream(Base64StreamResource(value), subtype)
 
-        if format == "url" and isinstance(value, str):
+        if format == WorkflowVariableFormat.URL and isinstance(value, str):
             return await load_image_from_stream(await create_stream_with_url(value), subtype)
 
         if isinstance(value, StreamResource):