diff --git a/backend/routes/node_routes.py b/backend/routes/node_routes.py index 8b0292c..4c21852 100644 --- a/backend/routes/node_routes.py +++ b/backend/routes/node_routes.py @@ -10,6 +10,7 @@ from backend.routes.common import handle_request from backend.services.event_stream_service import get_default_event_bus from backend.services.generation_service import GenerationService from backend.services.image_service import ImageService +from backend.services.model_provider_runtime import ModelProviderRuntime from backend.services.model_provider_service import ModelProviderService from backend.services.queue_service import QueueService from backend.services.workflow_service import WorkflowService @@ -211,6 +212,8 @@ def _create_generation_service() -> GenerationService: audit_service = AuditService(database) workflow_repository = WorkflowRepository(database) event_bus = get_default_event_bus() + model_provider_service = ModelProviderService(ModelProviderRepository(database)) + model_provider_runtime = ModelProviderRuntime(model_provider_service) return GenerationService( workflow_service=WorkflowService( workflow_repository=workflow_repository, @@ -228,6 +231,7 @@ def _create_generation_service() -> GenerationService: workflow_repository=workflow_repository, audit_service=audit_service, ), - model_provider_service=ModelProviderService(ModelProviderRepository(database)), + single_flow_engine=SingleFlowEngine(image_provider_factory=model_provider_runtime.image_provider_for_route), + model_provider_service=model_provider_service, event_bus=event_bus, ) diff --git a/backend/services/model_provider_runtime.py b/backend/services/model_provider_runtime.py new file mode 100644 index 0000000..6f27da8 --- /dev/null +++ b/backend/services/model_provider_runtime.py @@ -0,0 +1,50 @@ +"""Runtime helpers for building provider clients from persisted routes.""" + +from __future__ import annotations + +from typing import Any + +from backend.services.model_provider_service import ModelProviderService +from core.secret_service import SecretStore, resolve_secret_value +from engines.image_provider import ImageProvider, ImageProviderConfig, OpenAIImageProvider + + +class ModelProviderRuntime: + def __init__( + self, + model_provider_service: ModelProviderService, + *, + secret_store: SecretStore | None = None, + ): + self.model_provider_service = model_provider_service + self.secret_store = secret_store + + def image_provider_for_route(self, route_context: dict[str, Any]) -> ImageProvider | None: + route_name = str(route_context.get("route_name") or "").strip() + if not route_name: + return None + resolved = self.model_provider_service.resolve_route(route_name, modality="image_generation") + if not resolved: + return None + provider = resolved.get("provider") or {} + if str(provider.get("provider_type") or "openai_compatible") != "openai_compatible": + return None + secret = resolve_secret_value( + env_var=provider.get("api_key_env_var"), + secret_ref=provider.get("api_key_secret_ref"), + secret_store=self.secret_store, + ) + if not secret.value: + return None + return OpenAIImageProvider( + ImageProviderConfig( + provider_id=str(resolved["provider_id"]), + base_url=str(provider.get("base_url") or ""), + api_key=secret.value, + image_model=str(resolved["model_id"]), + image_endpoint=str(provider.get("image_endpoint") or "/v1/images/generations"), + provider_type=str(provider.get("provider_type") or "openai_compatible"), + timeout_seconds=int(provider.get("timeout_seconds") or 180), + extra_headers=dict(provider.get("extra_headers") or {}), + ) + ) diff --git a/engines/single_flow.py b/engines/single_flow.py index 9ee6a60..5b7e82b 100644 --- a/engines/single_flow.py +++ b/engines/single_flow.py @@ -4,13 +4,15 @@ from __future__ import annotations import base64 import re +import urllib.request from dataclasses import dataclass from pathlib import Path -from typing import Any +from typing import Any, Callable from backend.dto.job_dto import GenerationTask from backend.dto.workflow_dto import WorkflowNode from core.storage import VfsStorage +from engines.image_provider import ImageGenerationRequest, ImageProvider, ImageProviderError ONE_PIXEL_PNG = base64.b64decode( @@ -31,14 +33,52 @@ class MockGeneratedAsset: class SingleFlowEngine: - def __init__(self, storage: VfsStorage | None = None): + def __init__( + self, + storage: VfsStorage | None = None, + image_provider_factory: Callable[[dict[str, Any]], ImageProvider | None] | None = None, + ): self.storage = storage or VfsStorage() + self.image_provider_factory = image_provider_factory def generate(self, node: WorkflowNode, task: GenerationTask, request: dict[str, Any]) -> list[MockGeneratedAsset]: count = _bounded_count(request.get("count", 1)) prompt = _compose_prompt(node.prompt, request.get("prompt_patch")) model_route = str(request.get("model_route") or node.model_route or "image_low") width, height = _dimensions(str(request.get("aspect_ratio") or "1:1")) + provider = self._image_provider(request) + if provider is not None: + try: + return self._generate_with_provider(provider, task, request, prompt, model_route, width, height, count) + except ImageProviderError as exc: + return self._generate_mock( + task, + request, + prompt, + model_route, + width, + height, + count, + provider_error={ + "provider_id": exc.provider_id, + "error_type": exc.error_type, + "status_code": exc.status_code, + }, + ) + return self._generate_mock(task, request, prompt, model_route, width, height, count) + + def _generate_mock( + self, + task: GenerationTask, + request: dict[str, Any], + prompt: str, + model_route: str, + width: int, + height: int, + count: int, + *, + provider_error: dict[str, Any] | None = None, + ) -> list[MockGeneratedAsset]: assets: list[MockGeneratedAsset] = [] task_stem = _safe_file_stem(task.task_id) for index in range(count): @@ -60,15 +100,83 @@ class SingleFlowEngine: "engine": "single_flow_mock", "quality": request.get("quality", "low"), "mock": True, + **({"provider_error": provider_error} if provider_error else {}), }, ) ) return assets - def _write_png(self, uri: str) -> None: + def _generate_with_provider( + self, + provider: ImageProvider, + task: GenerationTask, + request: dict[str, Any], + prompt: str, + model_route: str, + width: int, + height: int, + count: int, + ) -> list[MockGeneratedAsset]: + route = dict(request.get("resolved_model_route") or {}) + result = provider.generate_image( + ImageGenerationRequest( + prompt=prompt, + model=str(route.get("model_id") or model_route), + size=f"{width}x{height}", + count=count, + input_images=tuple(str(item) for item in request.get("input_images") or request.get("image") or []), + metadata={"task_id": task.task_id, "model_route": model_route}, + ) + ) + assets: list[MockGeneratedAsset] = [] + task_stem = _safe_file_stem(task.task_id) + for index, image in enumerate(result.images): + if not image.has_image_data: + continue + image_bytes = _image_bytes(image.b64_json, image.url) + image_uri = f"storage://images/single/{task_stem}_{index + 1}.png" + thumbnail_uri = f"storage://thumbnails/single/{task_stem}_{index + 1}.png" + self._write_png(image_uri, image_bytes) + self._write_png(thumbnail_uri, image_bytes) + assets.append( + MockGeneratedAsset( + image_uri=image_uri, + thumbnail_uri=thumbnail_uri, + positive_prompt=image.revised_prompt or prompt, + model_route=model_route, + width=width, + height=height, + seed=int(request.get("seed") or 1000 + index), + metadata={ + "engine": "single_flow_provider", + "mock": False, + "provider_id": result.provider_id, + "provider_model": result.model, + "usage": result.usage, + "source_url": image.url, + }, + ) + ) + if not assets: + raise ImageProviderError( + "image provider returned no usable image payloads", + provider_id=result.provider_id, + error_type="invalid_response", + ) + return assets + + def _write_png(self, uri: str, content: bytes = ONE_PIXEL_PNG) -> None: path = self.storage.resolve_uri(uri) Path(path).parent.mkdir(parents=True, exist_ok=True) - Path(path).write_bytes(ONE_PIXEL_PNG) + Path(path).write_bytes(content) + + def _image_provider(self, request: dict[str, Any]) -> ImageProvider | None: + if not self.image_provider_factory: + return None + route = request.get("resolved_model_route") if isinstance(request.get("resolved_model_route"), dict) else {} + if route.get("status") != "resolved": + return None + return self.image_provider_factory(route) def _bounded_count(value: Any) -> int: @@ -97,3 +205,12 @@ def _dimensions(aspect_ratio: str) -> tuple[int, int]: def _safe_file_stem(value: str) -> str: stem = re.sub(r"[^A-Za-z0-9_-]+", "_", str(value or "").strip()).strip("_") return stem or "task" + + +def _image_bytes(b64_json: str | None, url: str | None) -> bytes: + if b64_json: + return base64.b64decode(re.sub(r"\s+", "", b64_json)) + if url: + with urllib.request.urlopen(url, timeout=120) as response: + return response.read() + raise ImageProviderError("image payload is empty", provider_id="unknown", error_type="invalid_response") diff --git a/tests/test_model_provider_runtime.py b/tests/test_model_provider_runtime.py new file mode 100644 index 0000000..8968a71 --- /dev/null +++ b/tests/test_model_provider_runtime.py @@ -0,0 +1,43 @@ +from __future__ import annotations + +import os +import tempfile +import unittest +from pathlib import Path + +from backend.services.model_provider_runtime import ModelProviderRuntime +from backend.services.model_provider_service import ModelProviderService +from database.db_helper import Database, DatabaseSettings, SqliteSettings +from database.repositories.model_provider_repository import ModelProviderRepository + + +class ModelProviderRuntimeTests(unittest.TestCase): + def test_runtime_builds_openai_provider_from_env_secret(self): + with tempfile.TemporaryDirectory() as tmp: + database = Database(DatabaseSettings(sqlite=SqliteSettings(path=str(Path(tmp) / "imagestudio.db")))) + database.initialize() + service = ModelProviderService(ModelProviderRepository(database)) + service.upsert_provider( + { + "provider_id": "site_b", + "base_url": "https://botcf.com", + "image_endpoint": "/v1/images/generations", + "api_key_env_var": "IMAGESTUDIO_TEST_SITE_B", + "timeout_seconds": 180, + } + ) + service.upsert_route({"route_name": "image_high", "provider_id": "site_b", "model_id": "image2"}) + os.environ["IMAGESTUDIO_TEST_SITE_B"] = "secret-value" + try: + provider = ModelProviderRuntime(service).image_provider_for_route({"route_name": "image_high"}) + finally: + os.environ.pop("IMAGESTUDIO_TEST_SITE_B", None) + + self.assertIsNotNone(provider) + self.assertEqual(provider.config.provider_id, "site_b") + self.assertEqual(provider.config.image_model, "image2") + self.assertEqual(provider.config.api_key, "secret-value") + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_single_flow_generation.py b/tests/test_single_flow_generation.py index 0216561..b145c7f 100644 --- a/tests/test_single_flow_generation.py +++ b/tests/test_single_flow_generation.py @@ -26,6 +26,7 @@ from database.repositories.model_provider_repository import ModelProviderReposit from database.repositories.profile_repository import ProfileRepository from database.repositories.workflow_repository import WorkflowRepository from engines.single_flow import SingleFlowEngine +from engines.image_provider import GeneratedImagePayload, ImageGenerationResult class SingleFlowGenerationTests(unittest.TestCase): @@ -251,6 +252,79 @@ storage: self.assertFalse(any(":\\" in str(value) or str(self.root) in str(value) for value in serialized.values())) self.assertNotIn("local_path", asset.metadata) + def test_single_flow_engine_can_persist_provider_payloads(self): + class FakeProvider: + provider_id = "site_b" + + def generate_image(self, request): + return ImageGenerationResult( + provider_id=self.provider_id, + model=request.model or "image2", + images=[ + GeneratedImagePayload( + b64_json="iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+/p9sAAAAASUVORK5CYII=", + revised_prompt=request.prompt, + ) + ], + usage={"total_tokens": 12}, + ) + + engine = SingleFlowEngine( + VfsStorage(self.config_service), + image_provider_factory=lambda route: FakeProvider(), + ) + node = WorkflowNode( + node_id="node_001", + workflow_id="workflow_001", + node_key="single", + title="Single", + description=None, + step_name=None, + node_type="single_image", + status="running", + branch_name="main", + prompt="portrait", + negative_prompt=None, + model_route="image_high", + selected_image_id=None, + sort_order=1, + metadata={}, + created_at="2026-01-01T00:00:00Z", + updated_at="2026-01-01T00:00:00Z", + ) + task = GenerationTask( + task_id="task_provider", + profile_id="profile_001", + workflow_id="workflow_001", + node_id="node_001", + task_type="generate", + status="running", + model_route="image_high", + progress=20, + idempotency_key=None, + request={}, + result={}, + error_message=None, + metadata={}, + created_at="2026-01-01T00:00:00Z", + updated_at="2026-01-01T00:00:00Z", + ) + + assets = engine.generate( + node, + task, + { + "model_route": "image_high", + "resolved_model_route": {"status": "resolved", "route_name": "image_high", "model_id": "image2"}, + }, + ) + + self.assertEqual(len(assets), 1) + self.assertFalse(assets[0].metadata["mock"]) + self.assertEqual(assets[0].metadata["provider_id"], "site_b") + self.assertEqual(assets[0].metadata["usage"]["total_tokens"], 12) + self.assertTrue(VfsStorage(self.config_service).ensure_file(assets[0].image_uri).exists()) + def test_queue_service_rejects_invalid_task_transition(self): task = self.queue_service.create_task({"status": "succeeded"}, self.ctx)