model-compose 0.3.10__tar.gz → 0.3.11__tar.gz

{model_compose-0.3.10/src/model_compose.egg-info → model_compose-0.3.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.3.10
+Version: 0.3.11
 Summary: model-compose: Declarative AI Model and Workflow Orchestrator
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT
@@ -165,7 +165,7 @@ controller:
     port: 8081
 
 components:
-  chatgpt:
+  - id: chatgpt
     type: http-client
     base_url: https://api.openai.com/v1
     path: /chat/completions
@@ -182,10 +182,10 @@ components:
       quote: ${response.choices[0].message.content}
 
 workflows:
-  generate-quote:
+  - id: generate-quote
     default: true
     jobs:
-      get-quote:
+      - id: get-quote
         component: chatgpt
 ```
 
@@ -302,7 +302,7 @@ controller:
   base_path: /mcp
 
 components:
-  chatgpt:
+  - id: chatgpt
     type: http-client
     base_url: https://api.openai.com/v1
     path: /chat/completions
@@ -319,10 +319,10 @@ components:
       quote: ${response.choices[0].message.content}
 
 workflows:
-  generate-quote:
+  - id: generate-quote
     default: true
     jobs:
-      get-quote:
+      - id: get-quote
         component: chatgpt
 ```
 This configuration launches the controller as an **MCP server**, which listens on port 8080 and exposes your workflows over a **JSON-RPC API**.

{model_compose-0.3.10 → model_compose-0.3.11}/README.md

@@ -136,7 +136,7 @@ controller:
     port: 8081
 
 components:
-  chatgpt:
+  - id: chatgpt
     type: http-client
     base_url: https://api.openai.com/v1
     path: /chat/completions
@@ -153,10 +153,10 @@ components:
       quote: ${response.choices[0].message.content}
 
 workflows:
-  generate-quote:
+  - id: generate-quote
     default: true
     jobs:
-      get-quote:
+      - id: get-quote
         component: chatgpt
 ```
 
@@ -273,7 +273,7 @@ controller:
   base_path: /mcp
 
 components:
-  chatgpt:
+  - id: chatgpt
     type: http-client
     base_url: https://api.openai.com/v1
     path: /chat/completions
@@ -290,10 +290,10 @@ components:
       quote: ${response.choices[0].message.content}
 
 workflows:
-  generate-quote:
+  - id: generate-quote
     default: true
     jobs:
-      get-quote:
+      - id: get-quote
         component: chatgpt
 ```
 This configuration launches the controller as an **MCP server**, which listens on port 8080 and exposes your workflows over a **JSON-RPC API**.

{model_compose-0.3.10 → model_compose-0.3.11}/pyproject.toml

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

{model_compose-0.3.10 → model_compose-0.3.11}/src/mindor/core/component/base.py

@@ -10,40 +10,41 @@ from mindor.core.utils.workqueue import WorkQueue
 from .context import ComponentActionContext
 
 class ActionResolver:
-    def __init__(self, actions: Dict[str, ActionConfig]):
-        self.actions = actions
+    def __init__(self, actions: List[ActionConfig]):
+        self.actions: List[ActionConfig] = actions
 
     def resolve(self, action_id: Optional[str]) -> Tuple[str, ActionConfig]:
         action_id = action_id or self._find_default_id(self.actions)
+        action = next((action for action in self.actions if action.id == action_id), None)
 
-        if not action_id in self.actions:
+        if action is None:
             raise ValueError(f"Action not found: {action_id}")
 
-        return action_id, self.actions[action_id]
+        return action_id, action
 
-    def _find_default_id(self, actions: Dict[str, ActionConfig]) -> str:
-        default_ids = [ action_id for action_id, action in actions.items() if action.default ]
+    def _find_default_id(self, actions: List[ActionConfig]) -> str:
+        default_ids = [ action.id for action in actions if action.default or action.id == "__default__" ]
 
         if len(default_ids) > 1: 
             raise ValueError("Multiple actions have default: true")
 
-        if not default_ids and "__default__" not in actions:
+        if not default_ids:
             raise ValueError("No default action defined.")
 
-        return default_ids[0] if default_ids else "__default__"
+        return default_ids[0]
 
 class ComponentGlobalConfigs:
     def __init__(
         self, 
-        components: Dict[str, ComponentConfig],
+        components: List[ComponentConfig],
         listeners: List[ListenerConfig],
         gateways: List[GatewayConfig],
-        workflows: Dict[str, WorkflowConfig]
+        workflows: List[WorkflowConfig]
     ):
-        self.components: Dict[str, ComponentConfig] = components
+        self.components: List[ComponentConfig] = components
         self.listeners: List[ListenerConfig] = listeners
         self.gateways: List[GatewayConfig] = gateways
-        self.workflows: Dict[str, WorkflowConfig] = workflows
+        self.workflows: List[WorkflowConfig] = workflows
 
 class ComponentService(AsyncService):
     def __init__(self, id: str, config: ComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool):

{model_compose-0.3.10 → model_compose-0.3.11}/src/mindor/core/component/component.py

@@ -5,27 +5,28 @@ from .base import ComponentService, ComponentGlobalConfigs, ComponentRegistry
 ComponentInstances: Dict[str, ComponentService] = {}
 
 class ComponentResolver:
-    def __init__(self, components: Dict[str, ComponentConfig]):
-        self.components: Dict[str, ComponentConfig] = components
+    def __init__(self, components: List[ComponentConfig]):
+        self.components: List[ComponentConfig] = components
 
     def resolve(self, component_id: Optional[str]) -> Tuple[str, ComponentConfig]:
         component_id = component_id or self._find_default_id(self.components)
+        component = next((component for component in self.components if component.id == component_id), None)
 
-        if not component_id in self.components:
+        if component is None:
             raise ValueError(f"Component not found: {component_id}")
 
-        return component_id, self.components[component_id]
+        return component_id, component
 
-    def _find_default_id(self, components: Dict[str, ComponentConfig]) -> str:
-        default_ids = [ component_id for component_id, component in components.items() if component.default ]
+    def _find_default_id(self, components: List[ComponentConfig]) -> str:
+        default_ids = [ component.id for component in components if component.default or component.id == "__default__" ]
 
         if len(default_ids) > 1:
             raise ValueError("Multiple components have default: true")
 
-        if not default_ids and "__default__" not in components:
+        if not default_ids:
             raise ValueError("No default component defined.")
 
-        return default_ids[0] if default_ids else "__default__"
+        return default_ids[0]
 
 def create_component(id: str, config: ComponentConfig, global_configs: ComponentGlobalConfigs, daemon: bool) -> ComponentService:
     try:

{model_compose-0.3.10 → model_compose-0.3.11}/src/mindor/core/component/context.py

@@ -13,15 +13,15 @@ class ComponentActionContext:
     def register_source(self, key: str, source: Any) -> None:
         self.sources[key] = source
 
-    def has_reference(self, key: str, value: Any) -> bool:
-        return self.renderer.has_reference(key, value)
-
     async def render_variable(self, value: Any, ignore_files: bool = False) -> Any:
         return await self.renderer.render(value, ignore_files)
 
     async def render_image(self, value: Any) -> Any:
         return await ImageValueRenderer().render(await self.render_variable(value))
 
+    def contains_variable_reference(self, key: str, value: Any) -> bool:
+        return self.renderer.contains_reference(key, value)
+
     async def _resolve_source(self, key: str, index: Optional[int]) -> Any:
         if key in self.sources:
             return self.sources[key][index] if index is not None else self.sources[key]

{model_compose-0.3.10 → model_compose-0.3.11}/src/mindor/core/component/services/http_server.py

@@ -56,7 +56,7 @@ class HttpServerPollingCompletion(HttpServerCompletion):
 
 class HttpServerCallbackCompletion(HttpServerCompletion):
     async def run(self, context: ComponentActionContext, client: HttpClient) -> Any:
-        callback_id = await context.render_variable(self.config.wait_for)
+        callback_id = await context.render_variable(self.config.wait_for) if self.config.wait_for else "__default__"
         future: asyncio.Future = asyncio.get_running_loop().create_future()
         HttpCallbackListener.register_pending_future(callback_id, future)
 

{model_compose-0.3.10 → model_compose-0.3.11}/src/mindor/core/component/services/model/tasks/text_classification.py

@@ -1,7 +1,6 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.component import ModelComponentConfig
 from mindor.dsl.schema.action import ModelActionConfig, TextClassificationModelActionConfig
-from mindor.core.utils.streamer import AsyncStreamer
 from mindor.core.logger import logging
 from ..base import ModelTaskService, ModelTaskType, register_model_task_service
 from ..base import ComponentActionContext
@@ -26,7 +25,7 @@ class TextClassificationTaskAction:
         stream               = await context.render_variable(self.config.stream)
 
         is_single_input: bool = True if not isinstance(text, list) else False
-        has_iterable_result: bool = context.has_reference("result[]", self.config.output)
+        is_output_array_mode: bool = context.contains_variable_reference("result[]", self.config.output)
         texts: List[str] = [ text ] if is_single_input else text
         results = []
 
@@ -38,7 +37,7 @@ class TextClassificationTaskAction:
 
                 with torch.inference_mode():
                     outputs: SequenceClassifierOutput = self.model(**inputs)
-                    logits = outputs.logits  # shape: (batch_size, num_classes)
+                    logits = outputs.logits # shape: (batch_size, num_classes)
                     predictions = []
 
                     if return_probabilities:
@@ -54,7 +53,7 @@ class TextClassificationTaskAction:
                         for predicted_index in predicted_indices:
                             predictions.append(labels[predicted_index] if labels else predicted_index)
 
-                if self.config.output and has_iterable_result:
+                if self.config.output and is_output_array_mode:
                     rendered_outputs = []
                     for prediction in predictions:
                         context.register_source("result[]", prediction)
@@ -67,7 +66,7 @@ class TextClassificationTaskAction:
         if stream:
             async def _stream_generator():
                 async for predictions in _predict():
-                    if not has_iterable_result:
+                    if not is_output_array_mode:
                         for prediction in predictions:
                             context.register_source("result", prediction)
                             yield (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result
@@ -80,7 +79,7 @@ class TextClassificationTaskAction:
             async for predictions in _predict():
                 results.extend(predictions)
 
-            if not has_iterable_result:
+            if not is_output_array_mode:
                 result = results[0] if is_single_input else results
                 context.register_source("result", result)
 

{model_compose-0.3.10 → model_compose-0.3.11}/src/mindor/core/component/services/model/tasks/text_embedding.py

@@ -1,7 +1,6 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.component import ModelComponentConfig
 from mindor.dsl.schema.action import ModelActionConfig, TextEmbeddingModelActionConfig
-from mindor.core.utils.streamer import AsyncStreamer
 from mindor.core.logger import logging
 from ..base import ModelTaskService, ModelTaskType, register_model_task_service
 from ..base import ComponentActionContext
@@ -27,7 +26,7 @@ class TextEmbeddingTaskAction:
         stream           = await context.render_variable(self.config.stream)
 
         is_single_input: bool = True if not isinstance(text, list) else False
-        has_iterable_result: bool = context.has_reference("result[]", self.config.output)
+        is_output_array_mode: bool = context.contains_variable_reference("result[]", self.config.output)
         texts: List[str] = [ text ] if is_single_input else text
         results = []
 
@@ -39,7 +38,7 @@ class TextEmbeddingTaskAction:
 
                 with torch.inference_mode():
                     outputs: BaseModelOutput = self.model(**inputs)
-                    last_hidden_state = outputs.last_hidden_state  # (batch_size, seq_len, hidden_size)
+                    last_hidden_state = outputs.last_hidden_state # (batch_size, seq_len, hidden_size)
 
                 attention_mask = inputs.get("attention_mask", None)
                 embeddings = self._pool_hidden_state(last_hidden_state, attention_mask, pooling)
@@ -49,7 +48,7 @@ class TextEmbeddingTaskAction:
 
                 embeddings = embeddings.cpu().tolist()
 
-                if self.config.output and has_iterable_result:
+                if self.config.output and is_output_array_mode:
                     rendered_outputs = []
                     for embedding in embeddings:
                         context.register_source("result[]", embedding)
@@ -62,7 +61,7 @@ class TextEmbeddingTaskAction:
         if stream:
             async def _stream_generator():
                 async for embeddings in _embed():
-                    if not has_iterable_result:
+                    if not is_output_array_mode:
                         for embedding in embeddings:
                             context.register_source("result", embedding)
                             yield (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result
@@ -75,7 +74,7 @@ class TextEmbeddingTaskAction:
             async for embeddings in _embed():
                 results.extend(embeddings)
 
-            if not has_iterable_result:
+            if not is_output_array_mode:
                 result = results[0] if is_single_input else results
                 context.register_source("result", result)
 

{model_compose-0.3.10 → model_compose-0.3.11}/src/mindor/core/controller/base.py

@@ -42,8 +42,8 @@ class ControllerService(AsyncService):
     def __init__(
         self,
         config: ControllerConfig,
-        workflows: Dict[str, WorkflowConfig],
-        components: Dict[str, ComponentConfig],
+        workflows: List[WorkflowConfig],
+        components: List[ComponentConfig],
         listeners: List[ListenerConfig],
         gateways: List[GatewayConfig],
         loggers: List[LoggerConfig],
@@ -52,8 +52,8 @@ class ControllerService(AsyncService):
         super().__init__(daemon)
 
         self.config: ControllerConfig = config
-        self.workflows: Dict[str, WorkflowConfig] = workflows
-        self.components: Dict[str, ComponentConfig] = components
+        self.workflows: List[WorkflowConfig] = workflows
+        self.components: List[ComponentConfig] = components
         self.listeners: List[ListenerConfig] = listeners
         self.gateways: List[GatewayConfig] = gateways
         self.loggers: List[LoggerConfig] = loggers
@@ -233,7 +233,7 @@ class ControllerService(AsyncService):
 
     def _create_components(self) -> List[ComponentService]:
         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() ]
+        return [ create_component(component.id, component, global_configs, self.daemon) for component in self.components ]
     
     def _create_loggers(self) -> List[LoggerService]:
         return [ create_logger(f"logger-{index}", config, self.daemon) for index, config in enumerate(self.loggers or [ self._get_default_logger_config() ]) ]

{model_compose-0.3.10 → model_compose-0.3.11}/src/mindor/core/controller/controller.py

@@ -9,8 +9,8 @@ from .base import ControllerService, ControllerRegistry, TaskStatus
 
 def create_controller(
     config: ControllerConfig,
-    workflows: Dict[str, WorkflowConfig],
-    components: Dict[str, ComponentConfig],
+    workflows: List[WorkflowConfig],
+    components: List[ComponentConfig],
     listeners: List[ListenerConfig],
     gateways: List[GatewayConfig],
     loggers: List[LoggerConfig],

{model_compose-0.3.10 → model_compose-0.3.11}/src/mindor/core/controller/runtime/specs.py

@@ -11,22 +11,21 @@ class ControllerRuntimeSpecs:
     def __init__(
         self,
         controller: ControllerConfig,
-        components: Dict[str, ComponentConfig],
+        components: List[ComponentConfig],
         listeners: List[ListenerConfig],
         gateways: List[GatewayConfig],
-        workflows: Dict[str, WorkflowConfig]
+        workflows: List[WorkflowConfig]
     ):
         self.controller: ControllerConfig = controller
-        self.components: Dict[str, ComponentConfig] = components
+        self.components: List[ComponentConfig] = components
         self.listeners: List[ListenerConfig] = listeners
         self.gateways: List[GatewayConfig] = gateways
-        self.workflows: Dict[str, WorkflowConfig] = workflows
+        self.workflows: List[WorkflowConfig] = workflows
 
     def generate_native_runtime_specs(self) -> Dict[str, Any]:
         specs: Dict[str, Any] = {}
 
-        specs["controller"] = self.controller.model_dump()
-        specs["controller"]["runtime"] = "native"
+        specs["controller"] = { **self.controller.model_dump(), "runtime": "native" }
 
         if getattr(self.controller.webui, "server_dir", None):
             specs["controller"]["webui"]["server_dir"] = "webui/server"
@@ -34,13 +33,12 @@ class ControllerRuntimeSpecs:
         if getattr(self.controller.webui, "static_dir", None):
             specs["controller"]["webui"]["static_dir"] = "webui/static"
 
-        specs["components"] = {}
-        for id, component in self.components.items():
-            specs["components"][id] = component.model_dump()
-            specs["components"][id]["runtime"] = "native"
+        specs["components"] = [
+            { **component.model_dump(), "runtime": "native" } for component in self.components
+        ]
 
         specs["listeners"] = [ listener.model_dump() for listener in self.listeners ]
         specs["gateways" ] = [ gateway.model_dump()  for gateway  in self.gateways  ]
-        specs["workflows"] = { id: workflow.model_dump() for id, workflow in self.workflows.items() }
+        specs["workflows"] = [ workflow.model_dump() for workflow in self.workflows ]
 
         return enum_union_to_str(specs)

{model_compose-0.3.10 → model_compose-0.3.11}/src/mindor/core/controller/services/http_server.py

@@ -95,10 +95,10 @@ class HttpServerController(ControllerService):
     def __init__(
         self,
         config: HttpServerControllerConfig,
-        components: Dict[str, ComponentConfig],
+        components: List[ComponentConfig],
         listeners: List[ListenerConfig],
         gateways: List[GatewayConfig],
-        workflows: Dict[str, WorkflowConfig],
+        workflows: List[WorkflowConfig],
         loggers: List[LoggerConfig],
         daemon: bool
     ):

{model_compose-0.3.10 → model_compose-0.3.11}/src/mindor/core/controller/services/mcp_server.py

@@ -133,8 +133,8 @@ class McpServerController(ControllerService):
     def __init__(
         self,
         config: McpServerControllerConfig,
-        workflows: Dict[str, WorkflowConfig],
-        components: Dict[str, ComponentConfig],
+        workflows: List[WorkflowConfig],
+        components: List[ComponentConfig],
         listeners: List[ListenerConfig],
         gateways: List[GatewayConfig],
         loggers: List[LoggerConfig],

{model_compose-0.3.10 → model_compose-0.3.11}/src/mindor/core/controller/webui/webui.py

@@ -18,8 +18,8 @@ class ControllerWebUI(AsyncService):
         self,
         config: ControllerWebUIConfig,
         controller: ControllerConfig,
-        components: Dict[str, ComponentConfig],
-        workflows: Dict[str, WorkflowConfig],
+        components: List[ComponentConfig],
+        workflows: List[WorkflowConfig],
         daemon: bool
     ):
         super().__init__(daemon)

{model_compose-0.3.10 → model_compose-0.3.11}/src/mindor/core/listener/services/http_callback.py

@@ -76,7 +76,7 @@ class HttpCallbackListener(ListenerService):
             succeeded = await self._is_callback_succeeded(callback, context)
 
             async for item in context.items():
-                callback_id = await item.render_variable(callback.identify_by)
+                callback_id = await item.render_variable(callback.identify_by) if callback.identify_by else "__default__"
                 future: asyncio.Future = self._get_pending_future(callback_id)
 
                 if future:

{model_compose-0.3.10 → model_compose-0.3.11}/src/mindor/core/utils/renderers.py

@@ -29,8 +29,8 @@ class VariableRenderer:
     async def render(self, value: Any, ignore_files: bool = True) -> Any:
         return await self._render_element(value, ignore_files)
 
-    def has_reference(self, key: str, value: Any) -> bool:
-        return self._has_reference(key, value)
+    def contains_reference(self, key: str, value: Any) -> bool:
+        return self._contains_reference(key, value)
 
     async def _render_element(self, element: Any, ignore_files: bool) -> Any:
         if isinstance(element, str):
@@ -123,19 +123,18 @@ class VariableRenderer:
 
         return None
 
-    def _has_reference(self, key: str, element: Any) -> bool:
+    def _contains_reference(self, key: str, element: Any) -> bool:
         if isinstance(element, str):
             return any(key == m.group(1) for m in self.patterns["variable"].finditer(element))
         
         if isinstance(element, dict):
-            return any([ self._has_reference(key, value) for value in element.values() ])
+            return any([ self._contains_reference(key, value) for value in element.values() ])
         
         if isinstance(element, (list, tuple)):
-            return any([ self._has_reference(key, item) for item in element ])
+            return any([ self._contains_reference(key, item) for item in element ])
         
         return False
 
-
 class ImageValueRenderer:
     async def render(self, value: Any) -> Any:
         return await self._render_element(value)

{model_compose-0.3.10 → model_compose-0.3.11}/src/mindor/core/workflow/job/impl/__init__.py

@@ -2,4 +2,5 @@ from .action import *
 from .delay import *
 from .if_ import *
 from .switch import *
-from .random_router import *
+from .random_router import *
+from .filter import *

{model_compose-0.3.10 → model_compose-0.3.11}/src/mindor/core/workflow/job/impl/delay.py

@@ -1,16 +1,16 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Any
 from mindor.dsl.schema.job import DelayJobConfig, DelayJobMode
-from mindor.dsl.schema.component import ComponentConfig
+from mindor.core.component import ComponentGlobalConfigs
 from mindor.core.utils.time import parse_duration, parse_datetime, TimeTracker
 from mindor.core.logger import logging
 from ..base import Job, JobType, WorkflowContext, RoutingTarget, register_job
-from datetime import datetime, timedelta
+from datetime import datetime
 import asyncio
 
 @register_job(JobType.DELAY)
 class DelayJob(Job):
-    def __init__(self, id: str, config: DelayJobConfig, components: Dict[str, ComponentConfig]):
-        super().__init__(id, config, components)
+    def __init__(self, id: str, config: DelayJobConfig, global_configs: ComponentGlobalConfigs):
+        super().__init__(id, config, global_configs)
 
     async def run(self, context: WorkflowContext) -> Any:
         output = await self._delay(self.config.mode, context)

model_compose-0.3.11/src/mindor/core/workflow/job/impl/filter.py

@@ -0,0 +1,13 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Any
+from mindor.dsl.schema.job import FilterJobConfig
+from mindor.core.component import ComponentGlobalConfigs
+from mindor.core.logger import logging
+from ..base import Job, JobType, WorkflowContext, RoutingTarget, register_job
+
+@register_job(JobType.FILTER)
+class FilterJob(Job):
+    def __init__(self, id: str, config: FilterJobConfig, global_configs: ComponentGlobalConfigs):
+        super().__init__(id, config, global_configs)
+
+    async def run(self, context: WorkflowContext) -> Union[Any, RoutingTarget]:
+        return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else None

{model_compose-0.3.10 → model_compose-0.3.11}/src/mindor/core/workflow/job/impl/if_.py

@@ -1,14 +1,14 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Any
 from mindor.dsl.schema.job import IfJobConfig, IfConditionOperator
-from mindor.dsl.schema.component import ComponentConfig
+from mindor.core.component import ComponentGlobalConfigs
 from mindor.core.logger import logging
 from ..base import Job, JobType, WorkflowContext, RoutingTarget, register_job
 import asyncio, re
 
 @register_job(JobType.IF)
 class IfJob(Job):
-    def __init__(self, id: str, config: IfJobConfig, components: Dict[str, ComponentConfig]):
-        super().__init__(id, config, components)
+    def __init__(self, id: str, config: IfJobConfig, global_configs: ComponentGlobalConfigs):
+        super().__init__(id, config, global_configs)
 
     async def run(self, context: WorkflowContext) -> Union[Any, RoutingTarget]:
         for condition in self.config.conditions:

{model_compose-0.3.10 → model_compose-0.3.11}/src/mindor/core/workflow/job/impl/random_router.py

@@ -1,14 +1,14 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Any
 from mindor.dsl.schema.job import RandomRouterJobConfig, RandomRoutingMode
-from mindor.dsl.schema.component import ComponentConfig
+from mindor.core.component import ComponentGlobalConfigs
 from mindor.core.logger import logging
 from ..base import Job, JobType, WorkflowContext, RoutingTarget, register_job
 import random
 
 @register_job(JobType.RANDOM_ROUTER)
 class RandomRouterJob(Job):
-    def __init__(self, id: str, config: RandomRouterJobConfig, components: Dict[str, ComponentConfig]):
-        super().__init__(id, config, components)
+    def __init__(self, id: str, config: RandomRouterJobConfig, global_configs: ComponentGlobalConfigs):
+        super().__init__(id, config, global_configs)
 
     async def run(self, context: WorkflowContext) -> Union[Any, RoutingTarget]:
         if self.config.mode == RandomRoutingMode.WEIGHTED:

{model_compose-0.3.10 → model_compose-0.3.11}/src/mindor/core/workflow/job/impl/switch.py

@@ -1,14 +1,14 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Any
 from mindor.dsl.schema.job import SwitchJobConfig
-from mindor.dsl.schema.component import ComponentConfig
+from mindor.core.component import ComponentGlobalConfigs
 from mindor.core.logger import logging
 from ..base import Job, JobType, WorkflowContext, RoutingTarget, register_job
 import asyncio
 
 @register_job(JobType.SWITCH)
 class SwitchJob(Job):
-    def __init__(self, id: str, config: SwitchJobConfig, components: Dict[str, ComponentConfig]):
-        super().__init__(id, config, components)
+    def __init__(self, id: str, config: SwitchJobConfig, global_configs: ComponentGlobalConfigs):
+        super().__init__(id, config, global_configs)
 
     async def run(self, context: WorkflowContext) -> Union[Any, RoutingTarget]:
         input = (await context.render_variable(self.config.input)) if self.config.input else context.input