refactor(core): DI-ready Pipeline; add registry + YAML factory + typed trace/result

config/sqlite_pipeline.yaml

@@ -1,6 +1,6 @@
 detector: default
 planner: default
-generator: rules    # or "llm" when available
+generator: rules
 safety: default
 executor: default
 verifier: basic
@@ -9,3 +9,7 @@ repair: default
 adapter:
   kind: sqlite
   dsn: data/chinook.db
+
+llm:
+  provider: openai
+  model: gpt-4o-mini

nl2sql/pipeline_factory.py

@@ -1,5 +1,8 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Optional, cast
 import yaml
-from typing import Any, Dict
+
 from nl2sql.pipeline import Pipeline
 from nl2sql.registry import (
     DETECTORS,
@@ -10,39 +13,72 @@ from nl2sql.registry import (
     VERIFIERS,
     REPAIRS,
 )
+from adapters.db.base import DBAdapter
 from adapters.db.sqlite_adapter import SQLiteAdapter
 from adapters.db.postgres_adapter import PostgresAdapter
-from adapters.db.base import DBAdapter
+
+# 🔁 Use your real LLM provider here
+from adapters.llm.openai_provider import OpenAIProvider  # noqa: F401
+
+
+# ------------------ helpers ------------------ #
+def _require_str(value: Any, *, name: str) -> str:
+    if value is None:
+        raise ValueError(f"Missing required string config: {name}")
+    if not isinstance(value, str):
+        raise TypeError(f"Config {name} must be a string, got {type(value).__name__}")
+    v = value.strip()
+    if not v:
+        raise ValueError(f"Config {name} cannot be empty")
+    return v
 
 
 def _build_adapter(adapter_cfg: Dict[str, Any]) -> DBAdapter:
-    kind = adapter_cfg.get("kind", "sqlite")
+    kind = (adapter_cfg.get("kind") or "sqlite").lower()
     if kind == "sqlite":
-        return SQLiteAdapter(adapter_cfg.get("dsn"))
+        dsn = _require_str(adapter_cfg.get("dsn"), name="adapter.dsn")
+        return SQLiteAdapter(dsn)
     if kind == "postgres":
+        # expect keys like {"kind":"postgres","dsn":"postgresql://..."} OR kwargs your adapter needs
         return PostgresAdapter(**adapter_cfg)
     raise ValueError(f"Unknown adapter kind: {kind}")
 
 
+def _build_llm(llm_cfg: Optional[Dict[str, Any]] = None) -> Any:
+    """
+    Create an LLM client/provider instance.
+    Adjust this to your real signature (model name, base_url, api_key in env, etc.).
+    """
+    _ = llm_cfg or {}
+    # Example: OpenAIProvider() reads env; or pass model via cfg.
+    return OpenAIProvider()
+
+
+# ------------------ main: config → Pipeline ------------------ #
 def pipeline_from_config(path: str) -> Pipeline:
+    """
+    Build a Pipeline from YAML configuration.
+    Inject proper constructor dependencies (llm, db/adapter) to satisfy mypy signatures.
+    """
     with open(path, "r", encoding="utf-8") as fh:
         cfg: Dict[str, Any] = yaml.safe_load(fh)
 
+    # Optional sections
+    adapter_cfg = cast(Dict[str, Any], cfg.get("adapter", {}))
+    llm_cfg = cast(Optional[Dict[str, Any]], cfg.get("llm"))
+
+    # Core deps
+    adapter = _build_adapter(adapter_cfg)
+    llm = _build_llm(llm_cfg)
+
+    # Instantiate stages with required ctor args
     detector = DETECTORS[cfg.get("detector", "default")]()
-    planner = PLANNERS[cfg.get("planner", "default")]()
-    generator = GENERATORS[cfg.get("generator", "rules")]()
+    planner = PLANNERS[cfg.get("planner", "default")](llm=llm)
+    generator = GENERATORS[cfg.get("generator", "rules")](llm=llm)
     safety = SAFETIES[cfg.get("safety", "default")]()
-    executor = EXECUTORS[cfg.get("executor", "default")]()
+    executor = EXECUTORS[cfg.get("executor", "default")](db=adapter)
     verifier = VERIFIERS[cfg.get("verifier", "basic")]()
-    repair = REPAIRS[cfg.get("repair", "default")]()
-
-    # If your Executor needs an adapter inside, set it there (common pattern):
-    adapter_cfg = cfg.get("adapter", {"kind": "sqlite", "dsn": "data/chinook.db"})
-    adapter = _build_adapter(adapter_cfg)
-    if hasattr(executor, "bind_adapter"):
-        executor.bind_adapter(adapter)
-    elif hasattr(executor, "adapter"):
-        executor.adapter = adapter  # fallback
+    repair = REPAIRS[cfg.get("repair", "default")](llm=llm)
 
     return Pipeline(
         detector=detector,
@@ -56,22 +92,22 @@ def pipeline_from_config(path: str) -> Pipeline:
 
 
 def pipeline_from_config_with_adapter(path: str, *, adapter: DBAdapter) -> Pipeline:
-    """Same as pipeline_from_config, but force a specific adapter (per-request override)."""
+    """
+    Same as pipeline_from_config, but force a specific adapter (per-request override).
+    """
     with open(path, "r", encoding="utf-8") as fh:
         cfg: Dict[str, Any] = yaml.safe_load(fh)
 
+    llm_cfg = cast(Optional[Dict[str, Any]], cfg.get("llm"))
+    llm = _build_llm(llm_cfg)
+
     detector = DETECTORS[cfg.get("detector", "default")]()
-    planner = PLANNERS[cfg.get("planner", "default")]()
-    generator = GENERATORS[cfg.get("generator", "rules")]()
+    planner = PLANNERS[cfg.get("planner", "default")](llm=llm)
+    generator = GENERATORS[cfg.get("generator", "rules")](llm=llm)
     safety = SAFETIES[cfg.get("safety", "default")]()
-    executor = EXECUTORS[cfg.get("executor", "default")]()
+    executor = EXECUTORS[cfg.get("executor", "default")](db=adapter)
     verifier = VERIFIERS[cfg.get("verifier", "basic")]()
-    repair = REPAIRS[cfg.get("repair", "default")]()
-
-    if hasattr(executor, "bind_adapter"):
-        executor.bind_adapter(adapter)
-    elif hasattr(executor, "adapter"):
-        executor.adapter = adapter
+    repair = REPAIRS[cfg.get("repair", "default")](llm=llm)
 
     return Pipeline(
         detector=detector,

nl2sql/registry.py

@@ -3,7 +3,6 @@ Registry mapping simple string keys to concrete component classes.
 Used by pipeline_factory to perform lightweight dependency injection.
 """
 
-from typing import Dict, Type
 from nl2sql.ambiguity_detector import AmbiguityDetector
 from nl2sql.planner import Planner
 from nl2sql.generator import Generator
@@ -13,10 +12,10 @@ from nl2sql.verifier import Verifier
 from nl2sql.repair import Repair
 
 # later you can add llm-aware generator variants, etc.
-PLANNERS: Dict[str, Type[Planner]] = {"default": Planner}
-DETECTORS: Dict[str, Type[AmbiguityDetector]] = {"default": AmbiguityDetector}
-GENERATORS: Dict[str, Type[Generator]] = {"rules": Generator}
-SAFETIES: Dict[str, Type[Safety]] = {"default": Safety}
-EXECUTORS: Dict[str, Type[Executor]] = {"default": Executor}
-VERIFIERS: Dict[str, Type[Verifier]] = {"basic": Verifier}
-REPAIRS: Dict[str, Type[Repair]] = {"default": Repair}
+PLANNERS = {"default": Planner}
+GENERATORS = {"rules": Generator}
+EXECUTORS = {"default": Executor}
+REPAIRS = {"default": Repair}
+DETECTORS = {"default": AmbiguityDetector}
+SAFETIES = {"default": Safety}
+VERIFIERS = {"basic": Verifier}