model-compose 0.0.4__tar.gz → 0.0.6__tar.gz

{model_compose-0.0.4/src/model_compose.egg-info → model_compose-0.0.6}/PKG-INFO

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

{model_compose-0.0.4 → model_compose-0.0.6}/pyproject.toml

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

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/core/component/engine/__init__.py

@@ -1,4 +1,4 @@
 from .base import *
+from .stream import *
 from .http_server import *
 from .http_client import *
-

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/core/component/engine/base.py

@@ -1,5 +1,5 @@
-from abc import ABC, abstractmethod
 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
@@ -78,9 +78,9 @@ class BaseComponent(ABC):
         if self.daemon_task:
             await self.daemon_task
 
-    async def run(self, action_id: Union[str, None], input: Dict[str, Any]) -> Dict[str, Any]:
+    async def run(self, action_id: Union[str, None], call_id: str, input: Dict[str, Any]) -> Dict[str, Any]:
         _, action = ActionResolver(self.config.actions).resolve(action_id)
-        context = ComponentContext(input, self.env)
+        context = ComponentContext(call_id, input, self.env)
 
         if self.queue:
             return await (await self.queue.schedule(action, context))
@@ -117,7 +117,7 @@ class BaseComponent(ABC):
         pass
 
     @abstractmethod
-    async def _run(self, action: ActionConfig, context: ComponentContext) -> Dict[str, Any]:
+    async def _run(self, action: ActionConfig, context: ComponentContext) -> Any:
         pass
 
 ComponentEngineMap: Dict[ComponentType, Type[BaseComponent]] = {}

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/core/component/engine/context.py

@@ -2,9 +2,11 @@ from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annot
 from mindor.core.utils.template import TemplateRenderer
 
 class ComponentContext:
-    def __init__(self, input: Dict[str, Any], env: Dict[str, str]):
+    def __init__(self, call_id: str, input: Dict[str, Any], env: Dict[str, str]):
+        self.call_id: str = call_id
         self.input: Dict[str, Any] = input
         self.env: Dict[str, str] = env
+        self.context: Dict[str, Any] = { "call_id": call_id }
         self.sources: Dict[str, Any] = {}
         self.renderer: TemplateRenderer = TemplateRenderer(self._resolve_source)
 
@@ -21,4 +23,6 @@ class ComponentContext:
             return self.input
         if key == "env":
             return self.env
+        if key == "context":
+            return self.context
         raise KeyError(f"Unknown source: {key}")

model_compose-0.0.6/src/mindor/core/component/engine/http_client.py

@@ -0,0 +1,123 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, AsyncIterator, Any
+from mindor.dsl.schema.component import HttpClientComponentConfig, HttpClientActionConfig
+from mindor.core.utils.http_headers import parse_options_header, get_header_value
+from mindor.core.utils.resources import StreamResource
+from .base import BaseComponent, ComponentType, ComponentEngineMap, ActionConfig
+from .context import ComponentContext
+
+from urllib.parse import urlencode
+import aiohttp, json
+
+class HttpStreamResource(StreamResource):
+    def __init__(self, session: aiohttp.ClientSession, stream: aiohttp.StreamReader, filename: Optional[str], content_type: Optional[str]):
+        super().__init__(content_type, filename)
+
+        self.session: aiohttp.ClientSession = session
+        self.stream: aiohttp.StreamReader = stream
+
+    def get_stream(self):
+        return self.stream
+    
+    async def close(self):
+        await self.session.close()
+
+    async def _iterate_stream(self) -> AsyncIterator[bytes]:
+        _, buffer_size = self.stream.get_read_buffer_limits()
+        chunk_size = buffer_size or 65536
+
+        while not self.stream.at_eof():
+            chunk = await self.stream.read(chunk_size)
+            if not chunk:
+                break
+            yield chunk
+
+class HttpClientAction:
+    def __init__(self, base_url: Optional[str], config: HttpClientActionConfig):
+        self.base_url: Optional[str] = base_url
+        self.config: HttpClientActionConfig = config
+
+    async def run(self, context: ComponentContext) -> Any:
+        url     = self._resolve_request_url(context)
+        method  = context.render_template(self.config.method)
+        params  = context.render_template(self.config.params)
+        body    = context.render_template(self.config.body)
+        headers = context.render_template(self.config.headers)
+
+        response = await self._request(url, method, params, body, headers)
+
+        if response:
+            context.register_source("response", response)
+
+        return context.render_template(self.config.output) if self.config.output else response
+
+    async def _request(self, url: str, method: str, params: Optional[Dict[str, Any]], body: Optional[Any], headers: Optional[Dict[str, str]]) -> Any:
+        session = aiohttp.ClientSession()
+        try:
+            response = await session.request(                
+                method,
+                url,
+                params=params,
+                data=self._serialize_request_body(body, headers) if body is not None else None, 
+                headers=headers
+            )
+
+            if response.status >= 400:
+                raise ValueError(f"Request failed with status {response.status}")
+
+            content = await self._parse_response_content(session, response)
+
+            if isinstance(content, HttpStreamResource):
+                pass
+            else:
+                await session.close()
+
+            return content
+        except:
+            await session.close()
+            raise
+
+    def _resolve_request_url(self, context: ComponentContext) -> str:
+        if self.base_url and self.config.path:
+            return context.render_template(str(self.base_url)) + context.render_template(self.config.path)
+
+        return context.render_template(str(self.config.endpoint))
+    
+    def _serialize_request_body(self, body: Any, headers: Optional[Dict[str, str]]) -> Any:
+        content_type, _ = parse_options_header(get_header_value(headers, "Content-Type", ""))
+
+        if content_type == "application/x-www-form-urlencoded":
+            return urlencode(body)
+
+        if isinstance(body, (str, bytes)):
+            return body
+
+        return json.dumps(body)
+    
+    async def _parse_response_content(self, session: aiohttp.ClientSession, response: aiohttp.ClientResponse) -> Any:
+        content_type, _ = parse_options_header(response.headers.get("Content-Type", ""))
+
+        if content_type == "application/json":
+            return await response.json()
+
+        if content_type.startswith("text/"):
+            return await response.text()
+
+        _, disposition = parse_options_header(response.headers.get("Content-Disposition", ""))
+        filename = disposition.get("filename")
+
+        return HttpStreamResource(session, response.content, filename, content_type)
+
+class HttpClientComponent(BaseComponent):
+    def __init__(self, id: str, config: HttpClientComponentConfig, env: Dict[str, str], daemon: bool):
+        super().__init__(id, config, env, daemon)
+
+    async def _serve(self) -> None:
+        pass
+
+    async def _shutdown(self) -> None:
+        pass
+
+    async def _run(self, action: ActionConfig, context: ComponentContext) -> Any:
+        return await HttpClientAction(self.config.base_url, action).run(context)
+
+ComponentEngineMap[ComponentType.HTTP_CLIENT] = HttpClientComponent

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/core/component/engine/http_server.py

@@ -13,7 +13,7 @@ class HttpServerComponent(BaseComponent):
     async def _shutdown(self) -> None:
         pass
 
-    async def _run(self, action: ActionConfig, context: ComponentContext) -> Dict[str, Any]:
+    async def _run(self, action: ActionConfig, context: ComponentContext) -> Any:
         return {}
 
 ComponentEngineMap[ComponentType.HTTP_SERVER] = HttpServerComponent

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/core/controller/engine/base.py

@@ -1,6 +1,6 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 
 from mindor.dsl.schema.controller import ControllerConfig, ControllerType
 from mindor.dsl.schema.component import ComponentConfig
@@ -125,7 +125,7 @@ class BaseController(ABC):
         
         try:
             workflow = create_workflow(*WorkflowResolver(self.workflows).resolve(workflow_id), self.components, self.env)
-            output = await workflow.run(input)
+            output = await workflow.run(task_id, input)
             state = TaskState(task_id=task_id, status="completed", output=output)
         except Exception as e:
             state = TaskState(task_id=task_id, status="failed", error=str(e))

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/core/controller/engine/http_server.py

@@ -1,19 +1,23 @@
-from pydantic import BaseModel
 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.workflow import WorkflowConfig
+from mindor.core.utils.resources import StreamResource 
 from .base import BaseController, ControllerType, ControllerEngineMap, TaskState
 
 from fastapi import FastAPI, APIRouter, Body, HTTPException
-import uvicorn
+from fastapi.responses import JSONResponse, StreamingResponse
+from starlette.background import BackgroundTask
+import asyncio, uvicorn
 
 class WorkflowTaskRequestBody(BaseModel):
     workflow_id: Optional[str] = None
     input: Optional[Dict[str, Any]] = None
     wait_for_completion: bool = True
+    output_only: bool = False
 
 class TaskResult(BaseModel):
     task_id: str
@@ -42,30 +46,66 @@ class HttpServerController(BaseController):
         self.app.include_router(self.router, prefix=self.config.base_path)
 
     def _configure_routes(self):
-        @self.router.post("/workflows", response_model=TaskResult, response_model_exclude_none=True)
+        @self.router.post("/workflows")
         async def run_workflow(
             body: WorkflowTaskRequestBody = Body(...)
         ):
             state = await self.run_workflow(body.workflow_id, body.input, body.wait_for_completion)
 
-            return TaskResult.from_instance(state)
+            if body.output_only and body.wait_for_completion:
+                if state.status == "failed":
+                    raise HTTPException(status_code=500, detail=str(state.error))
+                
+                if isinstance(state.output, StreamResource):
+                    return StreamingResponse(
+                        state.output,
+                        media_type=state.output.content_type,
+                        headers = {
+                            "Content-Disposition": f"attachment; filename={state.output.filename}"
+                        } if state.output.filename else {},
+                        #background=BackgroundTask(lambda: asyncio.create_task(state.output.close()))
+                    )
+
+                return state.output
+            
+            return JSONResponse(content=TaskResult.from_instance(state).model_dump(exclude_none=True))
 
-        @self.router.get("/tasks/{task_id}", response_model=TaskResult, response_model_exclude_none=True)
+        @self.router.get("/tasks/{task_id}")
         async def get_task_state(
-            task_id: str
+            task_id: str,
+            output_only: bool = False
         ):
             state = self.get_task_state(task_id)
 
             if not state:
-                raise HTTPException(status_code=404, detail="Task not found")
+                raise HTTPException(status_code=404, detail="Task not found.")
             
-            return TaskResult.from_instance(state)
+            if output_only:
+                if state.status in [ "pending", "processing" ]:
+                    raise HTTPException(status_code=202, detail="Task is still in progress.")
+                
+                if state.status == "failed":
+                    raise HTTPException(status_code=500, detail=str(state.error))
+
+                if isinstance(state.output, StreamResource):
+                    return StreamingResponse(
+                        state.output,
+                        media_type=state.output.content_type,
+                        headers = {
+                            "Content-Disposition": f"attachment; filename={state.output.filename}"
+                        } if state.output.filename else {},
+                        # background=BackgroundTask(lambda: asyncio.create_task(state.output.close()))
+                    )
+
+                return state.output
+
+            return JSONResponse(content=TaskResult.from_instance(state).model_dump(exclude_none=True))
 
     async def _serve(self) -> None:
         self.server = uvicorn.Server(uvicorn.Config(
-            self.app, 
-            host=self.config.host, 
-            port=self.config.port, 
+            self.app,
+            host=self.config.host,
+            port=self.config.port,
             log_level="info"
         ))
         await self.server.serve()

model_compose-0.0.6/src/mindor/core/listener/__init__.py

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

model_compose-0.0.6/src/mindor/core/listener/engine/__init__.py

@@ -0,0 +1,2 @@
+from .base import *
+from .http_callback import *

model_compose-0.0.6/src/mindor/core/listener/engine/base.py

@@ -0,0 +1,13 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+from mindor.dsl.schema.listener import ListenerConfig, ListenerType
+from mindor.core.listener import BaseListener, create_listener
+
+class BaseListener(ABC):
+    def __init__(self, config: ListenerConfig, env: Dict[str, str]):
+        self.config: ListenerConfig = config
+        self.env: Dict[str, str] = env
+
+ListenerEngineMap: Dict[ListenerType, Type[BaseListener]] = {}

model_compose-0.0.6/src/mindor/core/listener/engine/http_callback.py

@@ -0,0 +1,37 @@
+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.listener import HttpCallbackListenerConfig
+from .base import BaseListener, ListenerType, ListenerEngineMap
+
+from fastapi import FastAPI, APIRouter, Body, HTTPException
+import uvicorn
+
+class HttpCallbackListener(BaseListener):
+    def __init__(self, config: HttpCallbackListenerConfig, env: Dict[str, str]):
+        super().__init__(config, env)
+        
+        self.server: Optional[uvicorn.Server] = None
+        self.app: FastAPI = FastAPI()
+        self.router: APIRouter = APIRouter()
+
+        self._configure_routes()
+        self.app.include_router(self.router, prefix=self.config.base_path)
+
+    def _configure_routes(self):
+        pass
+
+    async def _serve(self) -> None:
+        self.server = uvicorn.Server(uvicorn.Config(
+            self.app, 
+            host=self.config.host, 
+            port=self.config.port, 
+            log_level="info"
+        ))
+        await self.server.serve()
+ 
+    async def _shutdown(self) -> None:
+        self.server.should_exit = True
+
+ListenerEngineMap[ListenerType.HTTP_CALLBACK] = HttpCallbackListener

model_compose-0.0.6/src/mindor/core/listener/listener.py

@@ -0,0 +1,9 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from mindor.dsl.schema.listener import ListenerConfig
+from .engine import BaseListener, ListenerEngineMap
+
+def create_listener(config: ControllerConfig, env: Dict[str, str]) -> BaseListener:
+    try:
+        return ListenerEngineMap[config.type](config, env)
+    except KeyError:
+        raise ValueError(f"Unsupported listener type: {config.type}")

model_compose-0.0.6/src/mindor/core/utils/http_headers.py

@@ -0,0 +1,24 @@
+from typing import Dict, Tuple, Optional
+from requests.structures import CaseInsensitiveDict
+import re
+
+_token_pattern  = r"([\w!#$%&'*+\-.^_`|~]+)"
+_quoted_pattern = r'"([^"]*)"'
+_option_regex = re.compile(fr";\s*{_token_pattern}=(?:{_token_pattern}|{_quoted_pattern})", re.ASCII)
+_firefox_escape_fix = re.compile(r'\\"(?!; |\s*$)')
+
+def parse_options_header(value: str) -> Tuple[str, Dict[str, str]]:
+    value = _firefox_escape_fix.sub("%22", value)
+    pos = value.find(";")
+    if pos >= 0:
+        options = { 
+            m.group(1).lower(): m.group(2) or m.group(3).replace("%22", "") for m in _option_regex.finditer(value[pos:])
+        }
+        value = value[:pos]
+    else:
+        options = {}
+
+    return value.strip().lower(), options
+
+def get_header_value(headers: Dict[str, str], header: str, default_value: Optional[str] = None) -> Optional[str]:
+    return CaseInsensitiveDict(headers or {}).get(header, default_value)

model_compose-0.0.6/src/mindor/core/utils/resources.py

@@ -0,0 +1,28 @@
+from typing import Optional, AsyncIterator
+from abc import ABC, abstractmethod
+
+class StreamResource(ABC):
+    def __init__(self, content_type: Optional[str], filename: Optional[str]):
+        self.content_type = content_type or "application/octet-stream"
+        self.filename = filename
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+
+    def __aiter__(self):
+        return self._iterate_stream()
+
+    @abstractmethod
+    def get_stream(self):
+        pass
+    
+    @abstractmethod
+    async def close(self):
+        pass
+
+    @abstractmethod
+    async def _iterate_stream(self) -> AsyncIterator[bytes]:
+        pass

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/core/workflow/context.py

@@ -2,9 +2,11 @@ from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annot
 from mindor.core.utils.template import TemplateRenderer
 
 class WorkflowContext:
-    def __init__(self, input: Dict[str, Any], env: Dict[str, str]):
+    def __init__(self, task_id: str, input: Dict[str, Any], env: Dict[str, str]):
+        self.task_id: str = task_id
         self.input: Dict[str, Any] = input
         self.env: Dict[str, str] = env
+        self.context: Dict[str, Any] = { "task_id": task_id }
         self.sources: Dict[str, Any] = { "jobs": {} }
         self.renderer = TemplateRenderer(self._resolve_source)
 
@@ -24,4 +26,6 @@ class WorkflowContext:
             return self.input
         if key == "env":
             return self.env
+        if key == "context":
+            return self.context
         raise KeyError(f"Unknown source: {key}")

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/core/workflow/job.py

@@ -3,6 +3,7 @@ from mindor.dsl.schema.workflow import JobConfig
 from mindor.dsl.schema.component import ComponentConfig
 from mindor.core.component import BaseComponent
 from .context import WorkflowContext
+import ulid
 
 class Job:
     def __init__(self, id: str, config: JobConfig, component_provider: Callable[[Union[ComponentConfig, str]], BaseComponent]):
@@ -10,16 +11,17 @@ class Job:
         self.config: JobConfig = config
         self.component_provider: Callable[[Union[ComponentConfig, str]], BaseComponent] = component_provider
 
-    async def run(self, context: WorkflowContext) -> Dict[str, Any]:
+    async def run(self, context: WorkflowContext) -> Any:
         component = self.component_provider(self.config.component)
 
         if not component.started:
             await component.start()
 
-        input = context.render_template(self.config.input)
-        output = await component.run(self.config.action, input)
+        call_id = ulid.ulid()
+        input = context.render_template(self.config.input) if self.config.output else context.input
+        output = await component.run(self.config.action, call_id, input)
 
-        context.register_source("output", output)
-        output = context.render_template(self.config.output)
+        if output:
+            context.register_source("output", output)
 
-        return output
+        return context.render_template(self.config.output) if self.config.output else output

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/core/workflow/workflow.py

@@ -80,12 +80,12 @@ class WorkflowRunner:
         self.jobs: Dict[str, JobConfig] = jobs
         self.component_provider: Callable[[Union[ComponentConfig, str]], BaseComponent] = component_provider
 
-    async def run(self, context: WorkflowContext) -> Dict[str, Any]:
+    async def run(self, context: WorkflowContext) -> Any:
         pending_jobs: Dict[str, Job] = { job_id: Job(job_id, job, self.component_provider) for job_id, job in self.jobs.items() }
         running_job_ids: Set[str] = set()
         completed_job_ids: Set[str] = set()
         scheduled_job_tasks: Dict[str, asyncio.Task] = {}
-        output: Dict[str, Any] = {}
+        output: Any = {}
 
         while pending_jobs:
             runnable_jobs = [ job for job in pending_jobs.values() if self._can_run_job(job, running_job_ids, completed_job_ids) ]
@@ -107,7 +107,8 @@ class WorkflowRunner:
                 context.complete_job(completed_job_id, completed_job_output)
 
                 if self._is_terminal_job(completed_job_id):
-                    output.update(completed_job_output)
+                    output = completed_job_output
+                    # output.update(completed_job_output)
 
                 running_job_ids.remove(completed_job_id)
                 completed_job_ids.add(completed_job_id)
@@ -129,8 +130,8 @@ class Workflow:
         self.components: Dict[str, ComponentConfig] = components
         self.env: Dict[str, str] = env
 
-    async def run(self, input: Dict[str, Any]) -> Dict[str, Any]:
-        context = WorkflowContext(input, self.env)
+    async def run(self, task_id: str, input: Dict[str, Any]) -> Any:
+        context = WorkflowContext(task_id, input, self.env)
         runner = WorkflowRunner(self.config.jobs, self._create_component)
 
         output = await runner.run(context)

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/dsl/schema/action/impl/http_client.py

@@ -1,10 +1,18 @@
-from pydantic import BaseModel, Field, HttpUrl
-from pydantic import model_validator
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from pydantic import model_validator
 from .common import CommonActionConfig
 
-class HttpClientActionCompletionConfig(CommonActionConfig):
-    endpoint: Optional[HttpUrl] = None
+class CommonCompletionConfig(BaseModel):
+    type: Literal[ "callback", "polling" ]
+
+class CallbackCompletionConfig(CommonCompletionConfig):
+    type: Literal["callback"]
+    wait_for: str
+
+class PollingCompletionConfig(CommonCompletionConfig):
+    type: Literal["polling"]
+    endpoint: Optional[str] = None
     path: Optional[str] = None
     method: Literal[ "GET", "POST", "PUT", "DELETE", "PATCH" ] = "GET"
     headers: Optional[Dict[str, str]] = Field(default_factory=dict)
@@ -19,15 +27,23 @@ class HttpClientActionCompletionConfig(CommonActionConfig):
             raise ValueError("Either 'endpoint' or 'path' must be set, but not both.")
         return values
 
+HttpClientCompletionConfig = Annotated[ 
+    Union[ 
+        CallbackCompletionConfig,
+        PollingCompletionConfig
+    ],
+    Field(discriminator="type")
+]
+
 class HttpClientActionConfig(CommonActionConfig):
-    endpoint: Optional[HttpUrl] = None
+    endpoint: Optional[str] = None
     path: Optional[str] = None
     method: Literal[ "GET", "POST", "PUT", "DELETE", "PATCH" ] = "POST"
     headers: Optional[Dict[str, str]] = Field(default_factory=dict)
     body: Optional[Dict[str, Any]] = Field(default_factory=dict)
     params: Optional[Dict[str, str]] = Field(default_factory=dict)
     deferred: bool = False
-    completion: Optional[HttpClientActionCompletionConfig] = None
+    completion: Optional[HttpClientCompletionConfig] = None
 
     @model_validator(mode="before")
     def validate_endpoint_or_path(cls, values):

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/dsl/schema/action/impl/http_server.py

@@ -1,6 +1,6 @@
-from pydantic import BaseModel, Field, HttpUrl
-from pydantic import model_validator
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from pydantic import model_validator
 from .common import CommonActionConfig
 
 class HttpServerActionConfig(CommonActionConfig):

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/dsl/schema/action/impl/mcp_client.py

@@ -1,6 +1,6 @@
-from pydantic import BaseModel, Field, HttpUrl
-from pydantic import model_validator
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from pydantic import model_validator
 from .common import CommonActionConfig
 
 class McpClientActionConfig(CommonActionConfig):

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/dsl/schema/action/impl/mcp_server.py

@@ -1,8 +1,8 @@
-from pydantic import BaseModel, Field, HttpUrl
-from pydantic import model_validator
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from pydantic import model_validator
 from .common import CommonActionConfig
 
 class McpServerActionConfig(CommonActionConfig):
     def __init__(self):
-        super.__init__(self)
+        super().__init__()

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/dsl/schema/component/component.py

@@ -1,5 +1,5 @@
-from pydantic import BaseModel, Field, HttpUrl
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
 from .impl import *
 
 ComponentConfig = Annotated[

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/dsl/schema/component/impl/common.py

@@ -1,5 +1,5 @@
-from pydantic import BaseModel, Field, HttpUrl
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
 from .types import ComponentType
 
 class CommonComponentConfig(BaseModel):

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/dsl/schema/component/impl/http_client.py

@@ -1,12 +1,12 @@
-from pydantic import BaseModel, Field, HttpUrl
-from pydantic import model_validator
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from pydantic import model_validator
 from mindor.dsl.schema.action import HttpClientActionConfig
 from .common import ComponentType, CommonComponentConfig
 
 class HttpClientComponentConfig(CommonComponentConfig):
     type: Literal[ComponentType.HTTP_CLIENT]
-    base_url: Optional[HttpUrl] = None
+    base_url: Optional[str] = None
     headers: Optional[Dict[str, Any]] = Field(default_factory=dict)
     actions: Optional[Dict[str, HttpClientActionConfig]] = Field(default_factory=dict)
     
@@ -27,7 +27,7 @@ class HttpClientComponentConfig(CommonComponentConfig):
 
     @model_validator(mode="after")
     def validate_baseurl_with_completion(self):
-        for action_id, action in self.actions.items():
-            if action.completion and action.completion.path and not self.base_url:
-                raise ValueError(f"Completion for action '{action_id}' uses 'path' but 'base_url' is not set in the component.")
+        # for action_id, action in self.actions.items():
+        #     if action.completion and action.completion.path and not self.base_url:
+        #         raise ValueError(f"Completion for action '{action_id}' uses 'path' but 'base_url' is not set in the component.")
         return self

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/dsl/schema/component/impl/http_server.py

@@ -1,6 +1,6 @@
-from pydantic import BaseModel, Field, HttpUrl
-from pydantic import model_validator
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from pydantic import model_validator
 from mindor.dsl.schema.action import HttpServerActionConfig
 from .common import ComponentType, CommonComponentConfig
 

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/dsl/schema/component/impl/mcp_client.py

@@ -1,10 +1,10 @@
-from pydantic import BaseModel, Field, HttpUrl
-from pydantic import model_validator
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from pydantic import model_validator
 from mindor.dsl.schema.action import McpClientActionConfig
 from .common import ComponentType, CommonComponentConfig
 
 class McpClientComponentConfig(CommonComponentConfig):
     type: Literal[ComponentType.MCP_CLIENT]
-    endpoint: HttpUrl
+    endpoint: Optional[str] = None
     actions: Optional[Dict[str, McpClientActionConfig]] = Field(default_factory=dict)

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/dsl/schema/component/impl/mcp_server.py

@@ -1,6 +1,6 @@
-from pydantic import BaseModel, Field, HttpUrl
-from pydantic import model_validator
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from pydantic import model_validator
 from mindor.dsl.schema.action import McpServerActionConfig
 from .common import ComponentType, CommonComponentConfig
 

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/dsl/schema/controller/controller.py

@@ -1,5 +1,5 @@
-from pydantic import BaseModel, Field, HttpUrl
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
 from .impl import *
 
 ControllerConfig = Annotated[

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/dsl/schema/controller/impl/http_server.py

@@ -1,6 +1,6 @@
-from pydantic import BaseModel, Field, HttpUrl
-from pydantic import model_validator
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from pydantic import model_validator
 from .common import ControllerType, CommonControllerConfig
 
 class HttpServerControllerConfig(CommonControllerConfig):

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/dsl/schema/controller/impl/mcp_server.py

@@ -1,6 +1,6 @@
-from pydantic import BaseModel, Field, HttpUrl
-from pydantic import model_validator
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from pydantic import model_validator
 from .common import ControllerType, CommonControllerConfig
 
 class McpServerControllerConfig(CommonControllerConfig):

model_compose-0.0.6/src/mindor/dsl/schema/listener/__init__.py

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

model_compose-0.0.6/src/mindor/dsl/schema/listener/impl/__init__.py

@@ -0,0 +1,2 @@
+from .common import *
+from .http_callback import *

model_compose-0.0.6/src/mindor/dsl/schema/listener/impl/common.py

@@ -0,0 +1,7 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from .types import ListenerType
+
+class CommonListenerConfig(BaseModel):
+    type: ListenerType
+    runtime: Literal[ "docker", "native" ] = "native"

model_compose-0.0.6/src/mindor/dsl/schema/listener/impl/http_callback.py

@@ -0,0 +1,25 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+from .common import ListenerType, CommonListenerConfig
+
+class HttpCallbackConfig(BaseModel):
+    path: str
+    method: Literal[ "GET", "POST", "PUT", "DELETE", "PATCH" ] = "GET"
+    bulk: bool = False
+    identify_by: str
+
+class HttpCallbackListenerConfig(CommonListenerConfig):
+    type: Literal[ListenerType.HTTP_CALLBACK]
+    host: Optional[str] = "0.0.0.0"
+    port: Optional[int] = 8090
+    base_path: Optional[str] = None
+    callbacks: Optional[List[HttpCallbackConfig]] = Field(default_factory=list)
+
+    @model_validator(mode="before")
+    def inflate_single_callback(cls, values):
+        if "callbacks" not in values:
+            callback_keys = set(HttpCallbackConfig.model_fields.keys())
+            if any(k in values for k in callback_keys):
+                values["callbacks"] = [ { k: values.pop(k) for k in callback_keys if k in values } ]
+        return values

model_compose-0.0.6/src/mindor/dsl/schema/listener/impl/types.py

@@ -0,0 +1,4 @@
+from enum import Enum
+
+class ListenerType(str, Enum):
+    HTTP_CALLBACK = "http-callback"

model_compose-0.0.6/src/mindor/dsl/schema/listener/listener.py

@@ -0,0 +1,10 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from .impl import *
+
+ListenerConfig = Annotated[
+    Union[ 
+        HttpCallbackListenerConfig
+    ],
+    Field(discriminator="type")
+]

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/dsl/schema/runtime/impl/docker.py

@@ -1,6 +1,6 @@
-from pydantic import BaseModel, Field, HttpUrl
-from pydantic import model_validator
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from pydantic import model_validator
 from .common import RuntimeType, CommonRumtimeConfig
 
 class DockerRuntimeConfig(CommonRumtimeConfig):

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/dsl/schema/runtime/runtime.py

@@ -1,5 +1,5 @@
-from pydantic import BaseModel, Field, HttpUrl
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
 from .impl import *
 
 RuntimeConfig = Annotated[ 

{model_compose-0.0.4 → model_compose-0.0.6/src/model_compose.egg-info}/PKG-INFO

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

{model_compose-0.0.4 → model_compose-0.0.6}/src/model_compose.egg-info/SOURCES.txt

@@ -21,10 +21,17 @@ src/mindor/core/controller/engine/__init__.py
 src/mindor/core/controller/engine/base.py
 src/mindor/core/controller/engine/http_server.py
 src/mindor/core/controller/engine/mcp_server.py
+src/mindor/core/listener/__init__.py
+src/mindor/core/listener/listener.py
+src/mindor/core/listener/engine/__init__.py
+src/mindor/core/listener/engine/base.py
+src/mindor/core/listener/engine/http_callback.py
 src/mindor/core/runtime/__init__.py
 src/mindor/core/runtime/env.py
 src/mindor/core/utils/__init__.py
 src/mindor/core/utils/expiring.py
+src/mindor/core/utils/http_headers.py
+src/mindor/core/utils/resources.py
 src/mindor/core/utils/template.py
 src/mindor/core/utils/workqueue.py
 src/mindor/core/workflow/__init__.py
@@ -60,6 +67,12 @@ src/mindor/dsl/schema/controller/impl/common.py
 src/mindor/dsl/schema/controller/impl/http_server.py
 src/mindor/dsl/schema/controller/impl/mcp_server.py
 src/mindor/dsl/schema/controller/impl/types.py
+src/mindor/dsl/schema/listener/__init__.py
+src/mindor/dsl/schema/listener/listener.py
+src/mindor/dsl/schema/listener/impl/__init__.py
+src/mindor/dsl/schema/listener/impl/common.py
+src/mindor/dsl/schema/listener/impl/http_callback.py
+src/mindor/dsl/schema/listener/impl/types.py
 src/mindor/dsl/schema/runtime/__init__.py
 src/mindor/dsl/schema/runtime/runtime.py
 src/mindor/dsl/schema/runtime/impl/__init__.py

model_compose-0.0.4/src/mindor/core/component/engine/http_client.py

@@ -1,87 +0,0 @@
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
-from mindor.dsl.schema.component import HttpClientComponentConfig, HttpClientActionConfig, HttpUrl
-from .base import BaseComponent, ComponentType, ComponentEngineMap, ActionConfig
-from .context import ComponentContext
-
-from requests.structures import CaseInsensitiveDict
-from urllib.parse import urlencode, urljoin
-import aiohttp, json
-
-class HttpClientAction:
-    def __init__(self, base_url: Union[str, None], config: HttpClientActionConfig):
-        self.base_url: Union[HttpUrl, None] = base_url
-        self.config: HttpClientActionConfig = config
-
-    async def run(self, context: ComponentContext) -> Dict[str, Any]:
-        url     = self._resolve_request_url(context)
-        method  = context.render_template(self.config.method)
-        params  = context.render_template(self.config.params)
-        body    = context.render_template(self.config.body)
-        headers = context.render_template(self.config.headers)
-
-        response = await self._request(url, method, params, body, headers)
-
-        if not self.config.output:
-            return response or {}
-
-        if response:
-            context.register_source("response", response)
-
-        return context.render_template(self.config.output)
-
-    async def _request(self, url: str, method: str, params: Optional[Dict[str, Any]], body: Optional[Dict[str, Any]], headers: Optional[Dict[str, str]]) -> Union[dict, str, bytes]:
-        async with aiohttp.ClientSession() as session:
-            async with session.request(
-                method,
-                url,
-                params=params,
-                data=self._serialize_request_body(body, headers) if body is not None else None, 
-                headers=headers
-            ) as response:
-                if response.status >= 400:
-                    raise ValueError(f"Request failed with status {response.status}")
-
-                return await self._deserialize_response_body(response)
-
-    def _resolve_request_url(self, context: ComponentContext) -> str:
-        if self.base_url and self.config.path:
-            return context.render_template(str(self.base_url)) + context.render_template(self.config.path)
-        
-        return context.render_template(str(self.config.endpoint))
-    
-    def _serialize_request_body(self, body: Dict[str, Any], headers: Optional[Dict[str, str]]) -> str:
-        content_type = CaseInsensitiveDict(headers or {}).get("Content-Type", "").lower()
-
-        if content_type == "application/json":
-            return json.dumps(body)
-
-        if content_type == "application/x-www-form-urlencoded":
-            return urlencode(body)
-        
-        return str(body)
-    
-    async def _deserialize_response_body(self, response: aiohttp.ClientResponse) -> Union[dict, str, bytes]:
-        content_type = response.headers.get("Content-Type", "").lower()
-
-        if content_type == "application/json":
-            return await response.json()
-        
-        if content_type.startswith("text/"):
-            return await response.text()
-
-        return await response.read()
-
-class HttpClientComponent(BaseComponent):
-    def __init__(self, id: str, config: HttpClientComponentConfig, env: Dict[str, str], daemon: bool):
-        super().__init__(id, config, env, daemon)
-
-    async def _serve(self) -> None:
-        pass
-
-    async def _shutdown(self) -> None:
-        pass
-
-    async def _run(self, action: ActionConfig, context: ComponentContext) -> Dict[str, Any]:
-        return await HttpClientAction(self.config.base_url, action).run(context)
-
-ComponentEngineMap[ComponentType.HTTP_CLIENT] = HttpClientComponent

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/dsl/loader.py

@@ -1,5 +1,5 @@
-from pydantic import BaseModel, ValidationError
 from typing import Union, List, Type
+from pydantic import BaseModel, ValidationError
 from pathlib import Path
 import yaml
 

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/dsl/schema/action/action.py

@@ -1,5 +1,5 @@
-from pydantic import BaseModel, Field
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
 from .impl import *
 
 ActionConfig = Annotated[ 

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/dsl/schema/action/impl/common.py

@@ -1,5 +1,5 @@
-from pydantic import BaseModel, Field
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
 
 class CommonActionConfig(BaseModel):
     output: Optional[Dict[str, Any]] = Field(default_factory=dict)

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/dsl/schema/compose.py

@@ -1,6 +1,6 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from pydantic import BaseModel, Field
 from pydantic import model_validator
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 
 from .controller import ControllerConfig
 from .component import ComponentConfig

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/dsl/schema/controller/impl/common.py

@@ -1,5 +1,5 @@
-from pydantic import BaseModel, Field
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
 from .types import ControllerType
 
 class CommonControllerConfig(BaseModel):

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/dsl/schema/runtime/impl/common.py

@@ -1,5 +1,5 @@
-from pydantic import BaseModel, Field
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
 from .types import RuntimeType
 
 class CommonRumtimeConfig(BaseModel):

{model_compose-0.0.4 → model_compose-0.0.6}/src/mindor/dsl/schema/workflow.py

@@ -1,6 +1,6 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from pydantic import BaseModel, Field
 from pydantic import model_validator
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from .component import ComponentConfig
 
 class JobConfig(BaseModel):