model-compose 0.4.33__tar.gz → 0.4.34__tar.gz

{model_compose-0.4.33 → model_compose-0.4.34}/PKG-INFO

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

{model_compose-0.4.33 → model_compose-0.4.34}/pyproject.toml

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

{model_compose-0.4.33 → model_compose-0.4.34}/src/mindor/core/component/services/__init__.py

@@ -12,4 +12,7 @@ from .image_processor import *
 from .web_scraper import *
 from .web_browser import *
 from .agent import *
+from .video_converter import *
 from .video_scene_detector import *
+from .audio_extractor import *
+from .key_value_store import *

model_compose-0.4.34/src/mindor/core/component/services/audio_extractor/__init__.py

@@ -0,0 +1 @@
+from .audio_extractor import *

model_compose-0.4.34/src/mindor/core/component/services/audio_extractor/audio_extractor.py

@@ -0,0 +1,46 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from collections.abc import AsyncIterator
+from mindor.dsl.schema.component import AudioExtractorComponentConfig, AudioExtractorDriver
+from mindor.dsl.schema.action import ActionConfig, AudioExtractorActionConfig
+from ...base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
+from ...context import ComponentActionContext
+from .base import AudioExtractorService, AudioExtractorServiceRegistry
+
+class AudioExtractorAction:
+    def __init__(self, config: AudioExtractorActionConfig):
+        self.config: AudioExtractorActionConfig = config
+
+    async def run(self, context: ComponentActionContext, service: AudioExtractorService) -> Any:
+        return await service.run(self.config, context)
+
+@register_component(ComponentType.AUDIO_EXTRACTOR)
+class AudioExtractorComponent(ComponentService):
+    def __init__(
+        self,
+        id: str,
+        config: AudioExtractorComponentConfig,
+        global_configs: ComponentGlobalConfigs,
+        daemon: bool
+    ):
+        super().__init__(id, config, global_configs, daemon)
+        self.service: AudioExtractorService = self._create_service(self.config.driver)
+
+    def _create_service(self, driver: AudioExtractorDriver) -> AudioExtractorService:
+        try:
+            if not AudioExtractorServiceRegistry:
+                from . import drivers
+            return AudioExtractorServiceRegistry[driver](self.id, self.config, self.daemon)
+        except KeyError:
+            raise ValueError(f"Unsupported audio extractor driver: {driver}")
+
+    def _get_setup_requirements(self) -> Optional[List[str]]:
+        return self.service.get_setup_requirements()
+
+    async def _serve(self) -> None:
+        await self.service.start()
+
+    async def _shutdown(self) -> None:
+        await self.service.stop()
+
+    async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
+        return await AudioExtractorAction(action).run(context, self.service)

model_compose-0.4.34/src/mindor/core/component/services/audio_extractor/base.py

@@ -0,0 +1,30 @@
+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 AudioExtractorComponentConfig, AudioExtractorDriver
+from mindor.dsl.schema.action import AudioExtractorActionConfig
+from mindor.core.foundation import AsyncService
+from ...context import ComponentActionContext
+
+class AudioExtractorService(AsyncService):
+    def __init__(self, id: str, config: AudioExtractorComponentConfig, daemon: bool):
+        super().__init__(daemon)
+        self.id: str = id
+        self.config: AudioExtractorComponentConfig = config
+
+    def get_setup_requirements(self) -> Optional[List[str]]:
+        return None
+
+    async def run(self, action: AudioExtractorActionConfig, context: ComponentActionContext) -> Any:
+        return await self._run(action, context)
+
+    @abstractmethod
+    async def _run(self, action: AudioExtractorActionConfig, context: ComponentActionContext) -> Any:
+        pass
+
+def register_audio_extractor_service(driver: AudioExtractorDriver):
+    def decorator(cls: Type[AudioExtractorService]) -> Type[AudioExtractorService]:
+        AudioExtractorServiceRegistry[driver] = cls
+        return cls
+    return decorator
+
+AudioExtractorServiceRegistry: Dict[AudioExtractorDriver, Type[AudioExtractorService]] = {}

model_compose-0.4.34/src/mindor/core/component/services/audio_extractor/drivers/__init__.py

@@ -0,0 +1 @@
+from .ffmpeg import *

model_compose-0.4.34/src/mindor/core/component/services/audio_extractor/drivers/ffmpeg.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Any
+from mindor.dsl.schema.component import AudioExtractorComponentConfig
+from mindor.dsl.schema.action import AudioExtractorActionConfig
+from mindor.core.logger import logging
+from ..base import AudioExtractorService, AudioExtractorDriver, register_audio_extractor_service
+from ..base import ComponentActionContext
+import asyncio
+import tempfile
+import os
+
+_FORMAT_CODEC_MAP: Dict[str, str] = {
+    "mp3":  "libmp3lame",
+    "wav":  "pcm_s16le",
+    "flac": "flac",
+    "aac":  "aac",
+    "m4a":  "aac",
+    "opus": "libopus",
+    "ogg":  "libvorbis",
+}
+
+class FFmpegAudioExtractorAction:
+    def __init__(self, config: AudioExtractorActionConfig):
+        self.config: AudioExtractorActionConfig = config
+
+    async def run(self, context: ComponentActionContext) -> Any:
+        source  = await context.render_file(self.config.source)
+        format  = await context.render_variable(self.config.format) if self.config.format else "mp3"
+        codec   = await context.render_variable(self.config.codec) if self.config.codec else None
+        bitrate = await context.render_variable(self.config.bitrate) if self.config.bitrate else None
+        track   = int(await context.render_variable(self.config.track)) if self.config.track is not None else None
+
+        output_path = await self._extract(source, format, codec, bitrate, track)
+        result = {
+            "path": output_path,
+            "format": format
+        }
+        context.register_source("result", result)
+
+        return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result
+
+    async def _extract(
+        self,
+        source: str,
+        format: str,
+        codec: Optional[str],
+        bitrate: Optional[str],
+        track: Optional[int]
+    ) -> str:
+        output_path = os.path.join(tempfile.gettempdir(), f"audio_extractor_{os.getpid()}_{id(self)}.{format}")
+
+        command = [ "ffmpeg", "-hide_banner", "-i", source, "-vn" ]
+
+        if track is not None:
+            command.extend([ "-map", f"0:a:{track}" ])
+
+        resolved_codec = codec or _FORMAT_CODEC_MAP.get(format)
+        if resolved_codec:
+            command.extend([ "-c:a", resolved_codec ])
+        if bitrate:
+            command.extend([ "-b:a", bitrate ])
+
+        command.extend([ "-y", output_path ])
+
+        logging.info(f"Extracting audio from '{source}' to '{format}' format")
+
+        process = await asyncio.create_subprocess_exec(
+            *command,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+
+        _, stderr = await process.communicate()
+
+        if process.returncode != 0:
+            error_output = stderr.decode("utf-8", errors="replace")
+            raise RuntimeError(f"ffmpeg audio extraction failed (exit code {process.returncode}): {error_output}")
+
+        logging.info(f"Audio extraction completed: '{output_path}'")
+
+        return output_path
+
+@register_audio_extractor_service(AudioExtractorDriver.FFMPEG)
+class FFmpegAudioExtractorService(AudioExtractorService):
+    def __init__(self, id: str, config: AudioExtractorComponentConfig, daemon: bool):
+        super().__init__(id, config, daemon)
+
+    async def _run(self, action: AudioExtractorActionConfig, context: ComponentActionContext) -> Any:
+        return await FFmpegAudioExtractorAction(action).run(context)

model_compose-0.4.34/src/mindor/core/component/services/key_value_store/__init__.py

@@ -0,0 +1 @@
+from .key_value_store import *

model_compose-0.4.34/src/mindor/core/component/services/key_value_store/base.py

@@ -0,0 +1,31 @@
+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 KeyValueStoreComponentConfig, KeyValueStoreDriver
+from mindor.dsl.schema.action import KeyValueStoreActionConfig
+from mindor.core.foundation import AsyncService
+from ...context import ComponentActionContext
+
+class KeyValueStoreService(AsyncService):
+    def __init__(self, id: str, config: KeyValueStoreComponentConfig, daemon: bool):
+        super().__init__(daemon)
+
+        self.id: str = id
+        self.config: KeyValueStoreComponentConfig = config
+
+    def get_setup_requirements(self) -> Optional[List[str]]:
+        return None
+
+    async def run(self, action: KeyValueStoreActionConfig, context: ComponentActionContext) -> Any:
+        return await self._run(action, context)
+
+    @abstractmethod
+    async def _run(self, action: KeyValueStoreActionConfig, context: ComponentActionContext) -> Any:
+        pass
+
+def register_kv_store_service(driver: KeyValueStoreDriver):
+    def decorator(cls: Type[KeyValueStoreService]) -> Type[KeyValueStoreService]:
+        KeyValueStoreServiceRegistry[driver] = cls
+        return cls
+    return decorator
+
+KeyValueStoreServiceRegistry: Dict[KeyValueStoreDriver, Type[KeyValueStoreService]] = {}

model_compose-0.4.34/src/mindor/core/component/services/key_value_store/drivers/redis.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Any
+from mindor.dsl.schema.component import RedisKeyValueStoreComponentConfig
+from mindor.dsl.schema.action import (
+    KeyValueStoreActionConfig, RedisKeyValueStoreActionConfig, KeyValueStoreActionMethod
+)
+from mindor.core.logger import logging
+from ..base import KeyValueStoreService, KeyValueStoreDriver, register_kv_store_service
+from ..base import ComponentActionContext
+import json
+
+if TYPE_CHECKING:
+    from redis.asyncio import Redis as AsyncRedis
+
+class RedisKeyValueStoreAction:
+    def __init__(self, config: RedisKeyValueStoreActionConfig):
+        self.config: RedisKeyValueStoreActionConfig = config
+
+    async def run(self, context: ComponentActionContext, client: AsyncRedis) -> Any:
+        result = await self._dispatch(context, client)
+        context.register_source("result", result)
+
+        return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result
+
+    async def _dispatch(self, context: ComponentActionContext, client: AsyncRedis) -> Dict[str, Any]:
+        if self.config.method == KeyValueStoreActionMethod.GET:
+            return await self._get(context, client)
+
+        if self.config.method == KeyValueStoreActionMethod.SET:
+            return await self._set(context, client)
+
+        if self.config.method == KeyValueStoreActionMethod.DELETE:
+            return await self._delete(context, client)
+
+        if self.config.method == KeyValueStoreActionMethod.EXISTS:
+            return await self._exists(context, client)
+
+        raise ValueError(f"Unsupported key-value store action method: {self.config.method}")
+
+    async def _get(self, context: ComponentActionContext, client: AsyncRedis) -> Dict[str, Any]:
+        key = await context.render_variable(self.config.key)
+
+        raw = await client.get(key)
+
+        if raw is None:
+            return { "value": None }
+
+        value = raw.decode("utf-8") if isinstance(raw, bytes) else raw
+
+        try:
+            value = json.loads(value)
+        except (json.JSONDecodeError, TypeError):
+            pass
+
+        return { "value": value }
+
+    async def _set(self, context: ComponentActionContext, client: AsyncRedis) -> Dict[str, Any]:
+        key   = await context.render_variable(self.config.key)
+        value = await context.render_variable(self.config.value)
+        ttl   = await context.render_variable(self.config.ttl)
+
+        if isinstance(value, (dict, list)):
+            value = json.dumps(value, ensure_ascii=False)
+        elif not isinstance(value, str):
+            value = str(value)
+
+        if ttl is not None:
+            ttl = int(ttl)
+            result = await client.setex(key, ttl, value)
+        else:
+            result = await client.set(key, value)
+
+        return { "success": bool(result) }
+
+    async def _delete(self, context: ComponentActionContext, client: AsyncRedis) -> Dict[str, Any]:
+        key = await context.render_variable(self.config.key)
+
+        count = await client.delete(key)
+
+        return { "count": count }
+
+    async def _exists(self, context: ComponentActionContext, client: AsyncRedis) -> Dict[str, Any]:
+        key = await context.render_variable(self.config.key)
+
+        count = await client.exists(key)
+
+        return { "exists": bool(count) }
+
+@register_kv_store_service(KeyValueStoreDriver.REDIS)
+class RedisKeyValueStoreService(KeyValueStoreService):
+    def __init__(self, id: str, config: RedisKeyValueStoreComponentConfig, daemon: bool):
+        super().__init__(id, config, daemon)
+
+        self.client: Optional[AsyncRedis] = None
+
+    def get_setup_requirements(self) -> Optional[List[str]]:
+        return [ "redis" ]
+
+    async def _serve(self) -> None:
+        self.client = self._create_client()
+
+    async def _shutdown(self) -> None:
+        if self.client:
+            await self.client.close()
+            self.client = None
+
+    async def _run(self, action: KeyValueStoreActionConfig, context: ComponentActionContext) -> Any:
+        return await RedisKeyValueStoreAction(action).run(context, self.client)
+
+    def _create_client(self) -> AsyncRedis:
+        from redis.asyncio import Redis
+
+        if self.config.url:
+            return Redis.from_url(self.config.url)
+
+        scheme = "rediss" if self.config.secure else "redis"
+        url = f"{scheme}://{self.config.host}:{self.config.port}/{self.config.database}"
+
+        return Redis.from_url(
+            url,
+            password=self.config.password
+        )

model_compose-0.4.34/src/mindor/core/component/services/key_value_store/key_value_store.py

@@ -0,0 +1,47 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from collections.abc import AsyncIterator
+from mindor.dsl.schema.component import KeyValueStoreComponentConfig, KeyValueStoreDriver
+from mindor.dsl.schema.action import ActionConfig, KeyValueStoreActionConfig
+from ...base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
+from ...context import ComponentActionContext
+from .base import KeyValueStoreService, KeyValueStoreServiceRegistry
+
+class KeyValueStoreAction:
+    def __init__(self, config: KeyValueStoreActionConfig):
+        self.config: KeyValueStoreActionConfig = config
+
+    async def run(self, context: ComponentActionContext, service: KeyValueStoreService) -> Any:
+        return await service.run(self.config, context)
+
+@register_component(ComponentType.KEY_VALUE_STORE)
+class KeyValueStoreComponent(ComponentService):
+    def __init__(
+        self,
+        id: str,
+        config: KeyValueStoreComponentConfig,
+        global_configs: ComponentGlobalConfigs,
+        daemon: bool
+    ):
+        super().__init__(id, config, global_configs, daemon)
+
+        self.service: KeyValueStoreService = self._create_service(self.config.driver)
+
+    def _create_service(self, driver: KeyValueStoreDriver) -> KeyValueStoreService:
+        try:
+            if not KeyValueStoreServiceRegistry:
+                from . import drivers
+            return KeyValueStoreServiceRegistry[driver](self.id, self.config, self.daemon)
+        except KeyError:
+            raise ValueError(f"Unsupported key-value store driver: {driver}")
+
+    def _get_setup_requirements(self) -> Optional[List[str]]:
+        return self.service.get_setup_requirements()
+
+    async def _serve(self) -> None:
+        await self.service.start()
+
+    async def _shutdown(self) -> None:
+        await self.service.stop()
+
+    async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
+        return await KeyValueStoreAction(action).run(context, self.service)

{model_compose-0.4.33 → model_compose-0.4.34}/src/mindor/core/component/services/model/base/__init__.py

@@ -1,3 +1,4 @@
 from .common import *
 from .huggingface import *
 from .unsloth import *
+from .llamacpp import *

model_compose-0.4.34/src/mindor/core/component/services/model/base/llamacpp.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Any
+from mindor.dsl.schema.component import ModelComponentConfig, HuggingfaceModelConfig, LocalModelConfig
+from mindor.core.logger import logging
+from .common import ModelTaskService
+
+if TYPE_CHECKING:
+    from llama_cpp import Llama
+
+class LlamaCppModelTaskService(ModelTaskService):
+    def __init__(self, id: str, config: ModelComponentConfig, daemon: bool):
+        super().__init__(id, config, daemon)
+
+        self.model: Optional[Llama] = None
+
+    def get_setup_requirements(self) -> Optional[List[str]]:
+        return [ "llama-cpp-python" ]
+
+    def _load_model(self) -> None:
+        from llama_cpp import Llama
+
+        model_path = self._get_model_path()
+        params = self._get_model_params()
+
+        logging.info(f"Component '{self.id}': loading llama.cpp model from '{model_path}'")
+        self.model = Llama(model_path=model_path, **params)
+
+    def _unload_model(self) -> None:
+        self.model = None
+
+    def _get_model_path(self) -> str:
+        if isinstance(self.config.model, HuggingfaceModelConfig):
+            from .huggingface_hub import get_model_path
+            return get_model_path(self.config.model)
+
+        if isinstance(self.config.model, LocalModelConfig):
+            return self.config.model.path
+
+        if isinstance(self.config.model, str):
+            return self.config.model
+
+        raise ValueError(f"Unknown model config type: {type(self.config.model)}")
+
+    def _get_model_params(self) -> Dict[str, Any]:
+        params: Dict[str, Any] = {}
+
+        n_gpu_layers = getattr(self.config, "n_gpu_layers", None)
+        if n_gpu_layers is not None:
+            params["n_gpu_layers"] = n_gpu_layers
+        else:
+            device = getattr(self.config, "device", "cpu")
+            if device != "cpu":
+                params["n_gpu_layers"] = -1
+
+        n_ctx = getattr(self.config, "context_length", None)
+        if n_ctx is not None:
+            params["n_ctx"] = n_ctx
+
+        n_batch = getattr(self.config, "n_batch", None)
+        if n_batch is not None:
+            params["n_batch"] = n_batch
+
+        n_threads = getattr(self.config, "n_threads", None)
+        if n_threads is not None:
+            params["n_threads"] = n_threads
+
+        verbose = getattr(self.config, "verbose", False)
+        params["verbose"] = bool(verbose)
+
+        return params

{model_compose-0.4.33 → model_compose-0.4.34}/src/mindor/core/component/services/model/tasks/__init__.py

@@ -6,3 +6,4 @@ from .image_to_text import *
 from .image_upscale import *
 from .face_embedding import *
 from .text_to_speech import *
+from .speech_to_text import *

model_compose-0.4.34/src/mindor/core/component/services/model/tasks/chat_completion/__init__.py

@@ -0,0 +1,2 @@
+from .huggingface import *
+from .llamacpp import *

model_compose-0.4.34/src/mindor/core/component/services/model/tasks/chat_completion/llamacpp.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.action import ModelActionConfig, ChatCompletionModelActionConfig
+from ...base import ModelTaskType, ModelDriver, register_model_task_service
+from ...base import LlamaCppModelTaskService, ComponentActionContext
+import asyncio
+
+if TYPE_CHECKING:
+    from llama_cpp import Llama
+
+class LlamaCppChatCompletionTaskAction:
+    def __init__(
+        self,
+        config: ChatCompletionModelActionConfig,
+        model: Llama,
+    ):
+        self.config: ChatCompletionModelActionConfig = config
+        self.model: Llama = model
+
+    async def run(self, context: ComponentActionContext, loop: asyncio.AbstractEventLoop) -> Any:
+        messages      = await context.render_variable(self.config.messages)
+        tools         = await context.render_variable(self.config.tools)
+        streaming     = await context.render_variable(self.config.streaming)
+        gen_params    = await self._resolve_generation_params(context)
+
+        if not isinstance(messages, list):
+            messages = [messages]
+
+        normalized_messages = [self._normalize_message(m) for m in messages]
+
+        call_params: Dict[str, Any] = {
+            "messages": normalized_messages,
+            "stream": bool(streaming),
+            **gen_params,
+        }
+
+        if tools:
+            call_params["tools"] = [self._build_tool_definition(t) for t in tools]
+            call_params["tool_choice"] = "auto"
+
+        if streaming:
+            response = self.model.create_chat_completion(**call_params)
+
+            async def _stream_output_generator():
+                for chunk in response:
+                    delta = chunk["choices"][0].get("delta", {})
+                    token = delta.get("content", "")
+                    if token:
+                        yield await self._render_output_chunk(context, token)
+
+            return _stream_output_generator()
+        else:
+            response = self.model.create_chat_completion(**call_params)
+            choice = response["choices"][0]
+            message = choice["message"]
+
+            tool_calls = message.get("tool_calls")
+            if tool_calls:
+                result = {
+                    "role": message.get("role", "assistant"),
+                    "content": message.get("content"),
+                    "tool_calls": tool_calls,
+                }
+            else:
+                result = message.get("content", "")
+
+            return await self._render_output(context, result)
+
+    def _normalize_message(self, message: Any) -> Dict[str, Any]:
+        if isinstance(message, dict):
+            return message
+        if hasattr(message, "model_dump"):
+            return {k: v for k, v in message.model_dump().items() if v is not None}
+        return dict(message)
+
+    def _build_tool_definition(self, tool: Any) -> Dict[str, Any]:
+        if isinstance(tool, dict):
+            func = tool
+        elif hasattr(tool, "model_dump"):
+            func = {k: v for k, v in tool.model_dump().items() if v is not None}
+        else:
+            func = dict(tool)
+
+        return {"type": "function", "function": func}
+
+    async def _render_output_chunk(self, context: ComponentActionContext, chunk: str) -> Any:
+        context.register_source("result[]", chunk)
+        return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else chunk
+
+    async def _render_output(self, context: ComponentActionContext, result: Any) -> Any:
+        context.register_source("result", result)
+        return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else result
+
+    async def _resolve_generation_params(self, context: ComponentActionContext) -> Dict[str, Any]:
+        max_output_length = await context.render_variable(self.config.params.max_output_length)
+        do_sample         = await context.render_variable(self.config.params.do_sample)
+        temperature       = await context.render_variable(self.config.params.temperature) if do_sample else None
+        top_k             = await context.render_variable(self.config.params.top_k) if do_sample else None
+        top_p             = await context.render_variable(self.config.params.top_p) if do_sample else None
+        stop_sequences    = await context.render_variable(self.config.stop_sequences)
+
+        params: Dict[str, Any] = {
+            "max_tokens": max_output_length,
+        }
+
+        if do_sample:
+            if temperature is not None:
+                params["temperature"] = temperature
+            if top_k is not None:
+                params["top_k"] = top_k
+            if top_p is not None:
+                params["top_p"] = top_p
+        else:
+            params["temperature"] = 0.0
+
+        if stop_sequences:
+            params["stop"] = stop_sequences if isinstance(stop_sequences, list) else [stop_sequences]
+
+        return params
+
+
+@register_model_task_service(ModelTaskType.CHAT_COMPLETION, ModelDriver.LLAMACPP)
+class LlamaCppChatCompletionTaskService(LlamaCppModelTaskService):
+    async def _run(
+        self,
+        action: ModelActionConfig,
+        context: ComponentActionContext,
+        loop: asyncio.AbstractEventLoop
+    ) -> Any:
+        return await LlamaCppChatCompletionTaskAction(action, self.model).run(context, loop)

{model_compose-0.4.33 → model_compose-0.4.34}/src/mindor/core/component/services/model/tasks/image_upscale/common.py

@@ -11,7 +11,7 @@ from PIL import Image as PILImage
 if TYPE_CHECKING:
     import torch
 
-_resample_map = {
+_RESAMPLE_MAP = {
     "bicubic": PILImage.Resampling.BICUBIC,
     "lanczos": PILImage.Resampling.LANCZOS,
 }
@@ -54,11 +54,11 @@ class ImageUpscaleTaskAction:
     def _downsample_image(self, image: PILImage.Image, method: Literal[ "lanczos", "bicubic" ], scale: int = 4) -> PILImage.Image:
         downsample_size = (max(1, image.size[0] // scale), max(1, image.size[1] // scale))
         
-        if method not in _resample_map:
+        if method not in _RESAMPLE_MAP:
             logging.warning(f"Unsupported downsample method: {method}. fallback to 'lanczos' method")
             resample = PILImage.Resampling.LANCZOS
         else:
-            resample = _resample_map[method]
+            resample = _RESAMPLE_MAP[method]
 
         return image.resize(downsample_size, resample)