feat: add OpenAI as provider for text and image generation

- Add openai_text.py: text generation via OpenAI chat completions API
  (gpt-4o, gpt-4o-mini, gpt-4.1, gpt-4.1-mini, gpt-4.1-nano, o3-mini)
- Add openai_image.py: image generation via OpenAI images API
  (gpt-image-1 with reference image support, dall-e-3, dall-e-2)
- Refactor builder provider dispatch from TargetType to model-name index
  to support multiple providers per target type
- Fix circular import between config.py and providers/__init__.py
  using TYPE_CHECKING guard
- Fix stale default model assertions in tests
- Add openai>=1.0.0 dependency

bulkgen/builder.py

@@ -9,16 +9,14 @@ from collections.abc import Callable
 from dataclasses import dataclass, field
 from pathlib import Path
 
-from bulkgen.config import (
-    ProjectConfig,
-    TargetType,
-    target_type_from_capabilities,
-)
+from bulkgen.config import ProjectConfig
 from bulkgen.graph import build_graph, get_build_order, get_subgraph_for_target
 from bulkgen.providers import Provider
 from bulkgen.providers.blackforest import BlackForestProvider
 from bulkgen.providers.mistral import MistralProvider
-from bulkgen.resolve import infer_required_capabilities, resolve_model
+from bulkgen.providers.openai_image import OpenAIImageProvider
+from bulkgen.providers.openai_text import OpenAITextProvider
+from bulkgen.resolve import resolve_model
 from bulkgen.state import (
     BuildState,
     is_target_dirty,
@@ -100,32 +98,43 @@ def _collect_all_deps(target_name: str, config: ProjectConfig) -> list[str]:
     return deps
 
 
-def _create_providers() -> dict[TargetType, Provider]:
+def _create_providers() -> list[Provider]:
     """Create provider instances from environment variables."""
-    providers: dict[TargetType, Provider] = {}
+    providers: list[Provider] = []
     bfl_key = os.environ.get("BFL_API_KEY", "")
     if bfl_key:
-        providers[TargetType.IMAGE] = BlackForestProvider(api_key=bfl_key)
+        providers.append(BlackForestProvider(api_key=bfl_key))
     mistral_key = os.environ.get("MISTRAL_API_KEY", "")
     if mistral_key:
-        providers[TargetType.TEXT] = MistralProvider(api_key=mistral_key)
+        providers.append(MistralProvider(api_key=mistral_key))
+    openai_key = os.environ.get("OPENAI_API_KEY", "")
+    if openai_key:
+        providers.append(OpenAITextProvider(api_key=openai_key))
+        providers.append(OpenAIImageProvider(api_key=openai_key))
     return providers
 
 
+def _build_provider_index(providers: list[Provider]) -> dict[str, Provider]:
+    """Build a model-name → provider lookup from a list of providers."""
+    index: dict[str, Provider] = {}
+    for provider in providers:
+        for model in provider.get_provided_models():
+            index[model.name] = provider
+    return index
+
+
 async def _build_single_target(
     target_name: str,
     config: ProjectConfig,
     project_dir: Path,
-    providers: dict[TargetType, Provider],
+    provider_index: dict[str, Provider],
 ) -> None:
     """Build a single target by dispatching to the appropriate provider."""
     target_cfg = config.targets[target_name]
     model_info = resolve_model(target_name, target_cfg, config.defaults)
-    required = infer_required_capabilities(target_name, target_cfg)
-    target_type = target_type_from_capabilities(required)
     resolved_prompt = _resolve_prompt(target_cfg.prompt, project_dir)
 
-    provider = providers[target_type]
+    provider = provider_index[model_info.name]
     await provider.generate(
         target_name=target_name,
         target_config=target_cfg,
@@ -152,6 +161,7 @@ async def run_build(
     """
     result = BuildResult()
     providers = _create_providers()
+    provider_index = _build_provider_index(providers)
 
     graph = build_graph(config, project_dir)
 
@@ -181,7 +191,7 @@ async def run_build(
                 continue
 
             if _is_dirty(name, config, project_dir, state):
-                if not _has_provider(name, config, providers, result, on_progress):
+                if not _has_provider(name, config, provider_index, result, on_progress):
                     continue
                 dirty_targets.append(name)
             else:
@@ -195,7 +205,7 @@ async def run_build(
             on_progress(BuildEvent.TARGET_BUILDING, name, "")
 
         outcomes = await _build_generation(
-            dirty_targets, config, project_dir, providers
+            dirty_targets, config, project_dir, provider_index
         )
 
         _process_outcomes(outcomes, config, project_dir, state, result, on_progress)
@@ -238,19 +248,15 @@ def _is_dirty(
 def _has_provider(
     target_name: str,
     config: ProjectConfig,
-    providers: dict[TargetType, Provider],
+    provider_index: dict[str, Provider],
     result: BuildResult,
     on_progress: ProgressCallback = _noop_callback,
 ) -> bool:
     """Check that the required provider is available; record failure if not."""
     target_cfg = config.targets[target_name]
-    required = infer_required_capabilities(target_name, target_cfg)
-    target_type = target_type_from_capabilities(required)
-    if target_type not in providers:
-        env_var = (
-            "BFL_API_KEY" if target_type is TargetType.IMAGE else "MISTRAL_API_KEY"
-        )
-        msg = f"Missing {env_var} environment variable"
+    model_info = resolve_model(target_name, target_cfg, config.defaults)
+    if model_info.name not in provider_index:
+        msg = f"No provider available for model '{model_info.name}' (provider: {model_info.provider}) — check API key environment variables"
         result.failed[target_name] = msg
         on_progress(BuildEvent.TARGET_NO_PROVIDER, target_name, msg)
         return False
@@ -261,13 +267,13 @@ async def _build_generation(
     dirty_targets: list[str],
     config: ProjectConfig,
     project_dir: Path,
-    providers: dict[TargetType, Provider],
+    provider_index: dict[str, Provider],
 ) -> list[tuple[str, Exception | None]]:
     """Build all dirty targets in a generation concurrently."""
 
     async def _build_one(name: str) -> tuple[str, Exception | None]:
         try:
-            await _build_single_target(name, config, project_dir, providers)
+            await _build_single_target(name, config, project_dir, provider_index)
         except Exception as exc:  # noqa: BLE001
             return (name, exc)
         return (name, None)