"""Composition root for request-scoped services. Route modules used to each carry their own ``_create_*_service()`` factory -- 35 of them across 20 modules. Because the wiring was duplicated rather than shared, the factories drifted: four of the seven ``WorkflowService`` builders omitted ``event_bus`` entirely, so whether a workflow mutation published an event depended on which route you happened to enter through. That is how ``branch_routes`` stopped pushing branch events and ``node_material_routes`` stopped publishing material-binding events -- not a bug anyone wrote, a bug that grew out of copy-paste assembly. Assembling in one place makes the dependency set a single decision. Adding a collaborator here reaches every route at once, which is exactly the property the per-module factories lacked. """ from __future__ import annotations from backend.services.event_stream_service import get_default_event_bus from backend.services.workflow_service import WorkflowService from core.audit_service import AuditService from database.db_helper import Database, load_database_settings from database.repositories.profile_repository import ProfileRepository from database.repositories.workflow_repository import WorkflowRepository def create_database() -> Database: """Build a ``Database`` from the active configuration.""" return Database(load_database_settings()) def create_workflow_service(database: Database | None = None) -> WorkflowService: """Assemble ``WorkflowService`` with its full collaborator set. ``event_bus`` is not optional in practice: without it every ``publish(...)`` call inside the service becomes a silent no-op and the frontend's event stream simply never sees the change. """ resolved = database or create_database() return WorkflowService( workflow_repository=WorkflowRepository(resolved), profile_repository=ProfileRepository(resolved), audit_service=AuditService(resolved), event_bus=get_default_event_bus(), ) # --------------------------------------------------------------------------- # Generation service assembly # # This used to live in ``backend/routes/node_routes.py``, which forced # ``workflow_round_worker_runtime`` -- a background worker with no HTTP # involvement whatsoever -- to import from the route layer just to start up. # That was the repository's only service -> route dependency, and it made the # worker transitively drag in every route module's imports. Assembly is # composition-root work, so it lives here. # --------------------------------------------------------------------------- from backend.services.cost_guard_service import CostGuardService from backend.services.cost_service import CostService from backend.services.generation_service import GenerationService from backend.services.image_service import ImageService from backend.services.material_catalog_resolver import MaterialCatalogResolver from backend.services.model_provider_bootstrap import sync_generation_provider_from_config from backend.services.model_provider_runtime import ModelProviderRuntime from backend.services.model_provider_service import ModelProviderService from backend.services.prompt_expansion_service import PromptExpansionService from backend.services.prompt_governance_service import ( GenerationRouteService, ImageModerationService, PromptModerationService, PromptSemanticNormalizer, PromptTranslationService, ) from backend.services.queue_service import QueueService from backend.services.workflow_material_snapshot_service import WorkflowMaterialSnapshotService from core.astrbot_provider_bridge import astrbot_structured_text_callable from database.db_helper import load_config_payload from database.repositories.advanced_material_repository import AdvancedMaterialRepository from database.repositories.image_repository import ImageRepository from database.repositories.job_repository import JobRepository from database.repositories.material_repository import MaterialRepository from database.repositories.model_provider_repository import ModelProviderRepository from engines.single_flow import SingleFlowEngine def create_generation_service() -> GenerationService: """Public runtime factory shared by HTTP routes and background workers.""" database = Database(load_database_settings()) audit_service = AuditService(database) workflow_repository = WorkflowRepository(database) material_repository = MaterialRepository(database) material_catalog = MaterialCatalogResolver( material_repository, AdvancedMaterialRepository(database), ) event_bus = get_default_event_bus() model_provider_service = ModelProviderService(ModelProviderRepository(database)) model_provider_runtime = ModelProviderRuntime(model_provider_service) config_payload = load_config_payload() sync_generation_provider_from_config(model_provider_service, config_payload) generation_config = config_payload.get("generation") if isinstance(config_payload.get("generation"), dict) else {} model_assignments = config_payload.get("model_assignments") if isinstance(config_payload.get("model_assignments"), dict) else {} governance_config = config_payload.get("prompt_governance") if isinstance(config_payload.get("prompt_governance"), dict) else {} translation_config = governance_config.get("translation") if isinstance(governance_config.get("translation"), dict) else {} moderation_config = governance_config.get("moderation") if isinstance(governance_config.get("moderation"), dict) else {} routing_config = governance_config.get("routing") if isinstance(governance_config.get("routing"), dict) else {} image_moderation_config = governance_config.get("image_moderation") if isinstance(governance_config.get("image_moderation"), dict) else {} translation_route = str(translation_config.get("model_route") or model_assignments.get("prompt_planning") or "").strip() moderation_route = str(moderation_config.get("model_route") or model_assignments.get("cross_review_primary") or "").strip() translation_callable = (model_provider_runtime.structured_text_callable(translation_route) or astrbot_structured_text_callable(translation_route)) if translation_route else None moderation_callable = (model_provider_runtime.structured_text_callable(moderation_route) or astrbot_structured_text_callable(moderation_route)) if moderation_route else None single_flow_engine = SingleFlowEngine( image_provider_factory=model_provider_runtime.image_provider_for_route, allow_mock_fallback=False, ) image_moderation_route = str(image_moderation_config.get("model_route") or "").strip() image_moderation_callable = model_provider_runtime.structured_vision_callable( image_moderation_route, storage=single_flow_engine.storage, ) if image_moderation_route else None if translation_callable: raw_translation_callable = translation_callable translation_callable = lambda request: raw_translation_callable({**request, "purpose": "Chinese-to-English image prompt translation and structured visual decomposition"}) if moderation_callable: raw_moderation_callable = moderation_callable moderation_callable = lambda request: raw_moderation_callable({**request, "purpose": "image prompt content risk classification"}) return GenerationService( workflow_service=create_workflow_service(database), queue_service=QueueService( repository=JobRepository(database), audit_service=audit_service, event_bus=event_bus, ), image_service=ImageService( image_repository=ImageRepository(database), workflow_repository=workflow_repository, audit_service=audit_service, ), single_flow_engine=single_flow_engine, model_provider_service=model_provider_service, cost_guard_service=CostGuardService(CostService(database)), prompt_expansion_service=PromptExpansionService(), event_bus=event_bus, default_model_route=str(generation_config.get("default_model") or "").strip() or None, require_resolved_model_route=True, material_resolver=material_catalog, material_snapshot_service=WorkflowMaterialSnapshotService( workflow_repository, material_catalog, ), model_assignments=model_assignments, prompt_translation_service=PromptTranslationService(translation_config, translation_callable), prompt_semantic_normalizer=PromptSemanticNormalizer(), prompt_moderation_service=PromptModerationService(moderation_config, moderation_callable), generation_route_service=GenerationRouteService(routing_config), image_moderation_service=ImageModerationService(image_moderation_config, image_moderation_callable), )