model-compose 0.2.1__tar.gz → 0.2.3__tar.gz

{model_compose-0.2.1 → model_compose-0.2.3}/PKG-INFO

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

{model_compose-0.2.1 → model_compose-0.2.3}/pyproject.toml

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

{model_compose-0.2.1 → model_compose-0.2.3}/src/mindor/core/component/base.py

@@ -2,6 +2,9 @@ from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annot
 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
@@ -29,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:

{model_compose-0.2.1 → model_compose-0.2.3}/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 .base import ComponentEngine, ComponentRegistry
+from .base import ComponentEngine, ComponentGlobalConfigs, ComponentRegistry
 
 ComponentInstances: Dict[str, ComponentEngine] = {}
 
@@ -27,14 +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:
             if not ComponentRegistry:
                 from . import engine
-            component = ComponentRegistry[config.type](id, config, daemon)
+            component = ComponentRegistry[config.type](id, config, global_configs, daemon)
             ComponentInstances[id] = component
 
         return component

{model_compose-0.2.1 → model_compose-0.2.3}/src/mindor/core/component/engine/http_client.py

@@ -1,12 +1,12 @@
 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, register_component
+from ..base import ComponentEngine, ComponentType, ComponentGlobalConfigs, register_component
 from ..context import ComponentActionContext
 from datetime import datetime, timezone
 import asyncio
@@ -63,7 +63,7 @@ class HttpClientPollingCompletion(HttpClientCompletion):
         return await context.render_variable(self.config.endpoint)
 
 class HttpClientCallbackCompletion(HttpClientCompletion):
-    async def run(self, context: ComponentActionContext) -> Any:
+    async def run(self, context: ComponentActionContext, client: HttpClient) -> Any:
         callback_id = await context.render_variable(self.config.wait_for)
         future: asyncio.Future = asyncio.get_event_loop().create_future()
         HttpCallbackListener.register_pending_future(callback_id, future)
@@ -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
         
@@ -113,8 +113,8 @@ class HttpClientAction:
 
 @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
 

{model_compose-0.2.1 → model_compose-0.2.3}/src/mindor/core/component/engine/http_server.py

@@ -1,12 +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, ActionConfig, register_component
+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

{model_compose-0.2.1 → model_compose-0.2.3}/src/mindor/core/component/engine/mcp_client.py

@@ -2,7 +2,7 @@ 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, ActionConfig, register_component
+from ..base import ComponentEngine, ComponentType, ComponentGlobalConfigs, register_component
 from ..context import ComponentActionContext
 
 class McpClientAction():
@@ -29,8 +29,8 @@ class McpClientAction():
 
 @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)

{model_compose-0.2.1 → model_compose-0.2.3}/src/mindor/core/component/engine/mcp_server.py

@@ -1,12 +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, ActionConfig, register_component
+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

{model_compose-0.2.1 → model_compose-0.2.3}/src/mindor/core/component/engine/shell.py

@@ -1,7 +1,7 @@
 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, ActionConfig, register_component
+from ..base import ComponentEngine, ComponentType, ComponentGlobalConfigs, register_component
 from ..context import ComponentActionContext
 from asyncio.subprocess import Process
 import asyncio, os
@@ -66,8 +66,8 @@ class ShellAction:
 
 @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

{model_compose-0.2.1 → model_compose-0.2.3}/src/mindor/core/component/engine/workflow.py

@@ -3,15 +3,14 @@ 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, ActionConfig, register_component
+from ..base import ComponentEngine, ComponentType, ComponentGlobalConfigs, register_component
 from ..context import ComponentActionContext
 import asyncio, os
 
 class WorkflowAction:
-    def __init__(self, config: WorkflowActionConfig):
+    def __init__(self, config: WorkflowActionConfig, global_configs: ComponentGlobalConfigs):
         self.config: WorkflowActionConfig = config
-        self.components: Dict[str, ComponentConfig] = None
-        self.workflows: Dict[str, WorkflowConfig] = None
+        self.global_configs: ComponentGlobalConfigs = global_configs
 
     async def run(self, context: ComponentActionContext) -> Any:
         workflow_id = await context.render_variable(self.config.workflow)
@@ -24,12 +23,12 @@ class WorkflowAction:
         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.workflows).resolve(workflow_id), self.components)
+        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, daemon: bool):
-        super().__init__(id, config, daemon)
+    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
@@ -38,4 +37,4 @@ class WorkflowComponent(ComponentEngine):
         pass
 
     async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
-        return await WorkflowAction(action).run(context)
+        return await WorkflowAction(action, self.global_configs).run(context)

{model_compose-0.2.1 → model_compose-0.2.3}/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 = 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,7 +157,11 @@ 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]:

{model_compose-0.2.1 → model_compose-0.2.3}/src/mindor/core/controller/engine/http_server.py

@@ -8,7 +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, TaskState, register_controller
+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
@@ -75,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)
@@ -129,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):

{model_compose-0.2.1 → model_compose-0.2.3}/src/mindor/core/controller/engine/mcp_server.py

@@ -3,7 +3,7 @@ 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
@@ -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,15 +116,13 @@ 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"

{model_compose-0.2.1 → model_compose-0.2.3}/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):

{model_compose-0.2.1 → model_compose-0.2.3}/src/mindor/core/controller/runner/runner.py

@@ -1,7 +1,6 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from abc import ABC, abstractmethod
-from mindor.dsl.schema.controller import ControllerConfig
-from mindor.dsl.schema.workflow import WorkflowVariableConfig, WorkflowVariableGroupConfig
+from mindor.dsl.schema.controller import ControllerConfig, ControllerType
 from mindor.core.workflow.schema import WorkflowSchema
 from .client import ControllerClient
 from .http_client import HttpControllerClient
@@ -27,11 +26,11 @@ class ControllerRunner:
         self._configure_client()
 
     def _configure_client(self) -> None:
-        if self.config.type == "http-server":
+        if self.config.type == ControllerType.HTTP_SERVER:
             self.client = HttpControllerClient(self.config)
             return
 
-        if self.config.type == "mcp-server":
+        if self.config.type == ControllerType.MCP_SERVER:
             self.client = McpControllerClient(self.config)
             return