model-compose 0.0.5__tar.gz → 0.0.7__tar.gz

{model_compose-0.0.5/src/model_compose.egg-info → model_compose-0.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.0.5
+Version: 0.0.7
 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.5 → model_compose-0.0.7}/pyproject.toml

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

{model_compose-0.0.5 → model_compose-0.0.7}/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.5 → model_compose-0.0.7}/src/mindor/core/component/engine/base.py

@@ -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.5 → model_compose-0.0.7}/src/mindor/core/component/engine/http_client.py

@@ -1,18 +1,42 @@
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
-from mindor.dsl.schema.component import HttpClientComponentConfig, HttpClientActionConfig, HttpUrl
+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, content_type: Optional[str], filename: 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: Union[str, None], config: HttpClientActionConfig):
-        self.base_url: Union[HttpUrl, None] = base_url
+    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) -> Dict[str, Any]:
+    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)
@@ -21,32 +45,41 @@ class HttpClientAction:
 
         response = await self._request(url, method, params, body, headers)
 
-        if not self.config.output:
-            return response
-
         if response:
             context.register_source("response", response)
 
-        return context.render_template(self.config.output)
+        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:
-        async with aiohttp.ClientSession() as session:
-            async with session.request(
+        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
-            ) as response:
-                if response.status >= 400:
-                    raise ValueError(f"Request failed with status {response.status}")
+            )
+
+            if response.status >= 400:
+                raise ValueError(f"Request failed with status {response.status}")
+
+            content = await self._parse_response_content(session, response)
 
-                return await self._deserialize_response_body(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:
@@ -60,22 +93,19 @@ class HttpClientAction:
 
         return json.dumps(body)
     
-    async def _deserialize_response_body(self, response: aiohttp.ClientResponse) -> Any:
+    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"))
+        _, disposition = parse_options_header(response.headers.get("Content-Disposition", ""))
+        filename = disposition.get("filename")
 
-        return {
-            "filename": disposition.get("filename"),
-            "content_type": content_type,
-            "stream": response.content
-        }
+        return HttpStreamResource(session, response.content, content_type, filename)
 
 class HttpClientComponent(BaseComponent):
     def __init__(self, id: str, config: HttpClientComponentConfig, env: Dict[str, str], daemon: bool):
@@ -87,7 +117,7 @@ class HttpClientComponent(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 await HttpClientAction(self.config.base_url, action).run(context)
 
 ComponentEngineMap[ComponentType.HTTP_CLIENT] = HttpClientComponent

{model_compose-0.0.5 → model_compose-0.0.7}/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.5 → model_compose-0.0.7}/src/mindor/core/controller/engine/http_server.py

@@ -5,15 +5,19 @@ 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 Response, JSONResponse, StreamingResponse
+from starlette.background import BackgroundTask
+import asyncio, uvicorn
 
 class WorkflowTaskRequestBody(BaseModel):
     workflow_id: Optional[str] = None
-    input: Optional[Dict[str, Any]] = None
+    input: Optional[Any] = None
     wait_for_completion: bool = True
+    output_only: bool = False
 
 class TaskResult(BaseModel):
     task_id: str
@@ -42,35 +46,31 @@ 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:
+                return self._render_task_output(state)
+            
+            return self._render_task_state(state)
 
-        @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)
-
-        @self.router.get("/tasks/{task_id}/output")
-        async def get_task_output(
-            task_id: str
-        ):
-            state = self.get_task_state(task_id)
+            if output_only:
+                return self._render_task_output(state)
 
-            if not state:
-                raise HTTPException(status_code=404, detail="Task not found")
-            
-            return state.output
+            return self._render_task_state(state)
 
     async def _serve(self) -> None:
         self.server = uvicorn.Server(uvicorn.Config(
@@ -84,4 +84,39 @@ class HttpServerController(BaseController):
     async def _shutdown(self) -> None:
         self.server.should_exit = True
 
+    def _render_task_output(self, state: TaskState) -> Response:
+        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 self._render_stream_resource(state.output)
+        
+        return JSONResponse(content=state.output)
+
+    def _render_task_state(self, state: TaskState) -> Response:
+        return JSONResponse(content=TaskResult.from_instance(state).model_dump(exclude_none=True))
+    
+    def _render_stream_resource(self, resource: StreamResource) -> Response:
+        def _close_stream():
+            asyncio.run(resource.close()) 
+
+        return StreamingResponse(
+            resource,
+            media_type=resource.content_type, 
+            headers=self._build_stream_resource_headers(resource), 
+            background=BackgroundTask(_close_stream)
+        )
+    
+    def _build_stream_resource_headers(self, resource: StreamResource) -> Dict[str, str]:
+        headers: Dict[str, str] = { "Cache-Control": "no-cache" }
+
+        if resource.filename:
+            filename = resource.filename.replace('"', '\\"')
+            headers["Content-Disposition"] = f'attachment; filename="{filename}"'
+
+        return headers
+
 ControllerEngineMap[ControllerType.HTTP_SERVER] = HttpServerController

model_compose-0.0.7/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.5 → model_compose-0.0.7}/src/mindor/core/workflow/job.py

@@ -11,17 +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]:
-        component = self.component_provider(self.config.component)
+    async def run(self, context: WorkflowContext) -> Any:
+        component = self.component_provider(self.id, self.config.component)
 
         if not component.started:
             await component.start()
 
         call_id = ulid.ulid()
-        input = context.render_template(self.config.input)
+        input = context.render_template(self.config.input) if self.config.input 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.5 → model_compose-0.0.7}/src/mindor/core/workflow/workflow.py

@@ -76,16 +76,16 @@ class WorkflowResolver:
         return default_ids[0] if default_ids else "__default__"
 
 class WorkflowRunner:
-    def __init__(self, jobs: Dict[str, JobConfig], component_provider: Callable[[Union[ComponentConfig, str]], BaseComponent]):
+    def __init__(self, jobs: Dict[str, JobConfig], component_provider: Callable[[Union[str, ComponentConfig, str]], BaseComponent]):
         self.jobs: Dict[str, JobConfig] = jobs
-        self.component_provider: Callable[[Union[ComponentConfig, str]], BaseComponent] = component_provider
+        self.component_provider: Callable[[Union[str, 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,7 +130,7 @@ class Workflow:
         self.components: Dict[str, ComponentConfig] = components
         self.env: Dict[str, str] = env
 
-    async def run(self, task_id: str, input: Dict[str, Any]) -> Dict[str, Any]:
+    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)
 
@@ -143,14 +144,14 @@ class Workflow:
     def validate(self) -> None:
         JobGraphValidator(self.config.jobs).validate()
 
-    def _create_component(self, component: Union[ComponentConfig, str]) -> BaseComponent:
-        return create_component(*self._resolve_component(component), env=self.env, daemon=False)
+    def _create_component(self, id: str, component: Union[ComponentConfig, str]) -> BaseComponent:
+        return create_component(*self._resolve_component(id, component), env=self.env, daemon=False)
 
-    def _resolve_component(self, component: Union[ComponentConfig, str]) -> Tuple[str, ComponentConfig]:
+    def _resolve_component(self, id: str, component: Union[ComponentConfig, str]) -> Tuple[str, ComponentConfig]:
         if isinstance(component, str):
             return ComponentResolver(self.components).resolve(component)
     
-        return self.id, component
+        return id, component
 
 def create_workflow(id: str, config: WorkflowConfig, components: Dict[str, ComponentConfig], env: Dict[str, str]) -> Workflow:
     return Workflow(id, config, components, env)

{model_compose-0.0.5 → model_compose-0.0.7}/src/mindor/dsl/schema/action/impl/http_client.py

@@ -1,5 +1,5 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
-from pydantic import BaseModel, Field, HttpUrl
+from pydantic import BaseModel, Field
 from pydantic import model_validator
 from .common import CommonActionConfig
 
@@ -12,7 +12,7 @@ class CallbackCompletionConfig(CommonCompletionConfig):
 
 class PollingCompletionConfig(CommonCompletionConfig):
     type: Literal["polling"]
-    endpoint: Optional[HttpUrl] = None
+    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)
@@ -36,7 +36,7 @@ HttpClientCompletionConfig = Annotated[
 ]
 
 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)

{model_compose-0.0.5 → model_compose-0.0.7}/src/mindor/dsl/schema/action/impl/http_server.py

@@ -1,5 +1,5 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
-from pydantic import BaseModel, Field, HttpUrl
+from pydantic import BaseModel, Field
 from pydantic import model_validator
 from .common import CommonActionConfig
 

{model_compose-0.0.5 → model_compose-0.0.7}/src/mindor/dsl/schema/action/impl/mcp_client.py

@@ -1,5 +1,5 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
-from pydantic import BaseModel, Field, HttpUrl
+from pydantic import BaseModel, Field
 from pydantic import model_validator
 from .common import CommonActionConfig
 

{model_compose-0.0.5 → model_compose-0.0.7}/src/mindor/dsl/schema/action/impl/mcp_server.py

@@ -1,8 +1,8 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
-from pydantic import BaseModel, Field, HttpUrl
+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.5 → model_compose-0.0.7}/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.5 → model_compose-0.0.7}/src/mindor/dsl/schema/component/impl/common.py

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

{model_compose-0.0.5 → model_compose-0.0.7}/src/mindor/dsl/schema/component/impl/http_client.py

@@ -1,12 +1,12 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
-from pydantic import BaseModel, Field, HttpUrl
+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)
     

{model_compose-0.0.5 → model_compose-0.0.7}/src/mindor/dsl/schema/component/impl/http_server.py

@@ -1,5 +1,5 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
-from pydantic import BaseModel, Field, HttpUrl
+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.5 → model_compose-0.0.7}/src/mindor/dsl/schema/component/impl/mcp_client.py

@@ -1,10 +1,10 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
-from pydantic import BaseModel, Field, HttpUrl
+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.5 → model_compose-0.0.7}/src/mindor/dsl/schema/component/impl/mcp_server.py

@@ -1,5 +1,5 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
-from pydantic import BaseModel, Field, HttpUrl
+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.5 → model_compose-0.0.7}/src/mindor/dsl/schema/controller/controller.py

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

{model_compose-0.0.5 → model_compose-0.0.7}/src/mindor/dsl/schema/controller/impl/http_server.py

@@ -1,5 +1,5 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
-from pydantic import BaseModel, Field, HttpUrl
+from pydantic import BaseModel, Field
 from pydantic import model_validator
 from .common import ControllerType, CommonControllerConfig
 

{model_compose-0.0.5 → model_compose-0.0.7}/src/mindor/dsl/schema/controller/impl/mcp_server.py

@@ -1,5 +1,5 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
-from pydantic import BaseModel, Field, HttpUrl
+from pydantic import BaseModel, Field
 from pydantic import model_validator
 from .common import ControllerType, CommonControllerConfig
 

{model_compose-0.0.5 → model_compose-0.0.7}/src/mindor/dsl/schema/listener/impl/http_callback.py

@@ -1,5 +1,5 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
-from pydantic import BaseModel, Field, HttpUrl
+from pydantic import BaseModel, Field
 from pydantic import model_validator
 from .common import ListenerType, CommonListenerConfig
 

{model_compose-0.0.5 → model_compose-0.0.7}/src/mindor/dsl/schema/listener/listener.py

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

{model_compose-0.0.5 → model_compose-0.0.7}/src/mindor/dsl/schema/runtime/impl/docker.py

@@ -1,5 +1,5 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
-from pydantic import BaseModel, Field, HttpUrl
+from pydantic import BaseModel, Field
 from pydantic import model_validator
 from .common import RuntimeType, CommonRumtimeConfig
 

{model_compose-0.0.5 → model_compose-0.0.7}/src/mindor/dsl/schema/runtime/runtime.py

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

{model_compose-0.0.5 → model_compose-0.0.7/src/model_compose.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.0.5
+Version: 0.0.7
 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.5 → model_compose-0.0.7}/src/model_compose.egg-info/SOURCES.txt

@@ -31,6 +31,7 @@ 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