gaard-core 0.1.0__tar.gz → 0.2.0__tar.gz

{gaard_core-0.1.0 → gaard_core-0.2.0}/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.4
 Name: gaard-core
-Version: 0.1.0
+Version: 0.2.0
 Summary: Core GAARD query pipeline, prompt compiler, policies and SQL validation
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
+Requires-Dist: gaard-plugin-api<0.3.0,>=0.2.0
 Requires-Dist: pydantic>=2.7.0
 Requires-Dist: sqlglot>=25.0.0
 Provides-Extra: dev

{gaard_core-0.1.0 → gaard_core-0.2.0}/pyproject.toml

@@ -4,11 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gaard-core"
-version = "0.1.0"
+version = "0.2.0"
 description = "Core GAARD query pipeline, prompt compiler, policies and SQL validation"
 readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
+    "gaard-plugin-api>=0.2.0,<0.3.0",
     "pydantic>=2.7.0",
     "sqlglot>=25.0.0",
 ]

{gaard_core-0.1.0 → gaard_core-0.2.0}/src/gaard_core/query_pipeline/models.py

@@ -19,11 +19,6 @@ class QueryIntentDecision(StrEnum):
     AMBIGUOUS = "ambiguous"
 
 
-class QueryMode(StrEnum):
-    SQL = "sql"
-    INVESTIGATION = "investigation"
-
-
 class QueryIntentClassification(BaseModel):
     decision: QueryIntentDecision = QueryIntentDecision.AMBIGUOUS
     confidence: float = 0.0
@@ -35,7 +30,7 @@ class QueryRequest(BaseModel):
     question: str = Field(min_length=1)
     datasource_id: str = "default"
     user_id: str = "local-admin"
-    mode: QueryMode = QueryMode.SQL
+    interpret: bool = True
 
 
 class GeneratedSql(BaseModel):

{gaard_core-0.1.0 → gaard_core-0.2.0}/src/gaard_core/query_pipeline/pipeline.py

@@ -73,6 +73,26 @@ class QueryPipeline:
         self.sql_validator.validate(generated_sql.sql)
 
         result = self.executor.execute(generated_sql.sql)
+        if not request.interpret:
+            duration_ms = round((time.perf_counter() - started_at) * 1000, 2)
+            return QueryResponse(
+                question=request.question,
+                answer="",
+                sql=generated_sql.sql,
+                rows=result.rows,
+                metadata={
+                    "duration_ms": duration_ms,
+                    "datasource_id": request.datasource_id,
+                    "user_id": request.user_id,
+                    "confidence": generated_sql.confidence,
+                    "assumptions": generated_sql.assumptions,
+                    "sql_generation_mode": self.sql_generation_mode,
+                    "result_interpretation_mode": "none",
+                    "output_classification_mode": "none",
+                    "output_classification": OutputClassification.UNKNOWN.value,
+                    "raw_sql_output": True,
+                },
+            )
 
         try:
             answer = self.interpreter.interpret(

{gaard_core-0.1.0 → gaard_core-0.2.0}/src/gaard_core.egg-info/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.4
 Name: gaard-core
-Version: 0.1.0
+Version: 0.2.0
 Summary: Core GAARD query pipeline, prompt compiler, policies and SQL validation
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
+Requires-Dist: gaard-plugin-api<0.3.0,>=0.2.0
 Requires-Dist: pydantic>=2.7.0
 Requires-Dist: sqlglot>=25.0.0
 Provides-Extra: dev

{gaard_core-0.1.0 → gaard_core-0.2.0}/src/gaard_core.egg-info/SOURCES.txt

@@ -9,19 +9,10 @@ src/gaard_core.egg-info/SOURCES.txt
 src/gaard_core.egg-info/dependency_links.txt
 src/gaard_core.egg-info/requires.txt
 src/gaard_core.egg-info/top_level.txt
-src/gaard_core/audit/__init__.py
-src/gaard_core/evaluation/__init__.py
 src/gaard_core/execution/__init__.py
 src/gaard_core/execution/mock_executor.py
-src/gaard_core/investigation/__init__.py
-src/gaard_core/investigation/llm_readiness_agent.py
-src/gaard_core/investigation/loop.py
-src/gaard_core/investigation/mock_readiness_agent.py
-src/gaard_core/investigation/models.py
-src/gaard_core/policy_engine/__init__.py
 src/gaard_core/prompt_compiler/__init__.py
 src/gaard_core/prompt_compiler/intent_classification_prompt.py
-src/gaard_core/prompt_compiler/investigation_readiness_prompt.py
 src/gaard_core/prompt_compiler/models.py
 src/gaard_core/prompt_compiler/result_classification_prompt.py
 src/gaard_core/prompt_compiler/result_interpretation_prompt.py
@@ -45,11 +36,8 @@ src/gaard_core/schema/__init__.py
 src/gaard_core/schema/cache.py
 src/gaard_core/schema/context.py
 src/gaard_core/schema/models.py
-src/gaard_core/security/__init__.py
-src/gaard_core/semantic_layer/__init__.py
 src/gaard_core/sql_validator/__init__.py
 src/gaard_core/sql_validator/select_only.py
-tests/test_investigation_readiness.py
 tests/test_json_utils.py
 tests/test_llm_output.py
 tests/test_llm_query_intent_classifier.py

{gaard_core-0.1.0 → gaard_core-0.2.0}/src/gaard_core.egg-info/requires.txt

@@ -1,3 +1,4 @@
+gaard-plugin-api<0.3.0,>=0.2.0
 pydantic>=2.7.0
 sqlglot>=25.0.0
 

{gaard_core-0.1.0 → gaard_core-0.2.0}/tests/test_query_pipeline.py

@@ -45,6 +45,11 @@ class FailingInterpreter:
         raise LlmProviderError("LLM provider request failed.")
 
 
+class FailingClassifier:
+    def classify(self, request: QueryRequest, answer: str):
+        raise AssertionError("classifier should not be called")
+
+
 def test_query_pipeline_wraps_llm_provider_error_during_sql_generation() -> None:
     pipeline = QueryPipeline(sql_generator=FailingSqlGenerator())
 
@@ -69,3 +74,22 @@ def test_query_pipeline_wraps_llm_provider_error_during_result_interpretation()
     assert exc_info.value.code == "LLM_PROVIDER_ERROR"
     assert exc_info.value.phase == "result_interpretation"
     assert exc_info.value.sql == "SELECT 1 AS value"
+
+
+def test_query_pipeline_can_return_raw_sql_output_without_interpretation() -> None:
+    pipeline = QueryPipeline(
+        sql_generator=StaticSqlGenerator(),
+        executor=StaticExecutor(),
+        interpreter=FailingInterpreter(),
+        classifier=FailingClassifier(),
+    )
+
+    response = pipeline.handle(QueryRequest(question="Inspect raw value", interpret=False))
+
+    assert response.answer == ""
+    assert response.sql == "SELECT 1 AS value"
+    assert response.rows == [{"value": 1}]
+    assert response.metadata["result_interpretation_mode"] == "none"
+    assert response.metadata["output_classification_mode"] == "none"
+    assert response.metadata["output_classification"] == "unknown"
+    assert response.metadata["raw_sql_output"] is True

gaard_core-0.1.0/src/gaard_core/investigation/__init__.py

@@ -1,25 +0,0 @@
-from gaard_core.investigation.loop import InvestigationLoop
-from gaard_core.investigation.llm_readiness_agent import LlmInvestigationReadinessAgent
-from gaard_core.investigation.mock_readiness_agent import MockInvestigationReadinessAgent
-from gaard_core.investigation.models import (
-    InvestigationContext,
-    InvestigationIteration,
-    InvestigationLoopConfig,
-    InvestigationLoopResult,
-    InvestigationReadinessDecision,
-    InvestigationRoute,
-    RequiredAnalysisTask,
-)
-
-__all__ = [
-    "InvestigationContext",
-    "InvestigationIteration",
-    "InvestigationLoop",
-    "InvestigationLoopConfig",
-    "InvestigationLoopResult",
-    "InvestigationReadinessDecision",
-    "InvestigationRoute",
-    "LlmInvestigationReadinessAgent",
-    "MockInvestigationReadinessAgent",
-    "RequiredAnalysisTask",
-]

gaard_core-0.1.0/src/gaard_core/investigation/llm_readiness_agent.py

@@ -1,220 +0,0 @@
-import json
-from typing import Any, Protocol
-
-from gaard_core.investigation.models import (
-    InvestigationContext,
-    InvestigationReadinessDecision,
-    InvestigationRoute,
-    RequiredAnalysisTask,
-)
-from gaard_core.llm_output import remove_thinking_blocks
-from gaard_core.prompt_compiler.investigation_readiness_prompt import (
-    InvestigationReadinessPromptCompiler,
-)
-from gaard_core.prompt_compiler.models import CompiledPrompt
-from gaard_llm.openai_compatible.client import OpenAICompatibleClient
-from gaard_llm.providers.models import ChatCompletionRequest, ChatMessage
-
-
-class InvestigationReadinessPromptCompilerProtocol(Protocol):
-    def compile(self, context: InvestigationContext) -> CompiledPrompt:
-        pass
-
-
-class LlmInvestigationReadinessAgent:
-    name = "llm_investigation_readiness"
-
-    def __init__(
-        self,
-        client: OpenAICompatibleClient,
-        model: str,
-        extra_body: dict[str, Any] | None = None,
-        prompt_compiler: InvestigationReadinessPromptCompilerProtocol | None = None,
-    ) -> None:
-        self.client = client
-        self.model = model
-        self.extra_body = extra_body or {}
-        self.prompt_compiler = prompt_compiler or InvestigationReadinessPromptCompiler()
-
-    def assess(self, context: InvestigationContext) -> InvestigationReadinessDecision:
-        compiled_prompt = self.prompt_compiler.compile(context=context)
-
-        response = self.client.create_chat_completion(
-            ChatCompletionRequest(
-                model=self.model,
-                temperature=0.0,
-                extra_body=self.extra_body,
-                messages=[
-                    ChatMessage(
-                        role="system",
-                        content=compiled_prompt.system_prompt,
-                    ),
-                    ChatMessage(
-                        role="user",
-                        content=compiled_prompt.user_prompt,
-                    ),
-                ],
-            )
-        )
-
-        return parse_investigation_readiness_decision(response.content)
-
-
-def parse_investigation_readiness_decision(value: str) -> InvestigationReadinessDecision:
-    cleaned = remove_thinking_blocks(value).strip()
-
-    try:
-        payload = json.loads(cleaned)
-    except json.JSONDecodeError:
-        return InvestigationReadinessDecision(
-            ready_for_sql=False,
-            route=InvestigationRoute.ANALYSIS,
-            confidence=0.0,
-            reason="Investigation readiness agent returned invalid JSON.",
-            missing_information=["valid readiness JSON"],
-            required_analysis=["Retry readiness assessment with a valid JSON response."],
-            model_response={"raw": cleaned},
-        )
-
-    if not isinstance(payload, dict):
-        return InvestigationReadinessDecision(
-            ready_for_sql=False,
-            route=InvestigationRoute.ANALYSIS,
-            confidence=0.0,
-            reason="Investigation readiness agent returned a non-object JSON value.",
-            missing_information=["valid readiness JSON object"],
-            required_analysis=["Retry readiness assessment with a JSON object response."],
-            model_response={"raw": payload},
-        )
-
-    ready_for_sql = parse_bool(payload.get("ready_for_sql"))
-    route = parse_route(payload.get("route"), ready_for_sql)
-
-    if route == InvestigationRoute.SQL and not ready_for_sql:
-        route = InvestigationRoute.ANALYSIS
-
-    if route == InvestigationRoute.ANALYSIS:
-        ready_for_sql = False
-
-    missing_information = parse_string_list(payload.get("missing_information"))
-    required_analysis = parse_string_list(payload.get("required_analysis"))
-
-    return InvestigationReadinessDecision(
-        ready_for_sql=ready_for_sql,
-        route=route,
-        confidence=parse_confidence(payload.get("confidence")),
-        reason=str(payload.get("reason") or ""),
-        missing_information=missing_information,
-        required_analysis=required_analysis,
-        required_analysis_tasks=parse_required_analysis_tasks(
-            payload.get("required_analysis_tasks"),
-            missing_information,
-            required_analysis,
-        ),
-        assumptions=parse_string_list(payload.get("assumptions")),
-        model_response=payload,
-    )
-
-
-def parse_route(value: object, ready_for_sql: bool) -> InvestigationRoute:
-    if isinstance(value, str):
-        normalized = value.strip().lower().replace("-", "_").replace(" ", "_")
-        if normalized in {"sql", "ready", "ready_for_sql"}:
-            return InvestigationRoute.SQL
-        if normalized in {"analysis", "analyze", "requires_analysis"}:
-            return InvestigationRoute.ANALYSIS
-
-    return InvestigationRoute.SQL if ready_for_sql else InvestigationRoute.ANALYSIS
-
-
-def parse_bool(value: object) -> bool:
-    if isinstance(value, bool):
-        return value
-
-    if isinstance(value, str):
-        return value.strip().lower() in {"true", "yes", "tak", "1"}
-
-    return False
-
-
-def parse_confidence(value: object) -> float:
-    try:
-        confidence = float(value)
-    except (TypeError, ValueError):
-        return 0.0
-
-    return max(0.0, min(1.0, confidence))
-
-
-def parse_string_list(value: object) -> list[str]:
-    if not isinstance(value, list):
-        return []
-
-    items: list[str] = []
-    for item in value:
-        if item is None:
-            continue
-        text = str(item).strip()
-        if text:
-            items.append(text)
-
-    return items
-
-
-def parse_required_analysis_tasks(
-    value: object,
-    missing_information: list[str],
-    required_analysis: list[str],
-) -> list[RequiredAnalysisTask]:
-    if isinstance(value, list):
-        tasks = [
-            parse_required_analysis_task(item)
-            for item in value
-            if isinstance(item, dict)
-        ]
-        tasks = [task for task in tasks if task.required_analysis]
-        if tasks:
-            return tasks
-
-    return required_analysis_tasks_from_lists(missing_information, required_analysis)
-
-
-def parse_required_analysis_task(value: dict[str, object]) -> RequiredAnalysisTask:
-    return RequiredAnalysisTask(
-        missing_information=str(value.get("missing_information") or "").strip(),
-        required_analysis=str(value.get("required_analysis") or "").strip(),
-        category=normalize_analysis_category(value.get("category")),
-        expected_output=str(value.get("expected_output") or "").strip(),
-    )
-
-
-def required_analysis_tasks_from_lists(
-    missing_information: list[str],
-    required_analysis: list[str],
-) -> list[RequiredAnalysisTask]:
-    tasks: list[RequiredAnalysisTask] = []
-    for index, analysis_question in enumerate(required_analysis):
-        tasks.append(
-            RequiredAnalysisTask(
-                missing_information=missing_information[index]
-                if index < len(missing_information)
-                else "",
-                required_analysis=analysis_question,
-            )
-        )
-
-    return tasks
-
-
-def normalize_analysis_category(value: object) -> str:
-    normalized = str(value or "unknown").strip().lower().replace("-", "_").replace(" ", "_")
-    allowed_categories = {
-        "dictionary_value",
-        "relationship_logic",
-        "filter_logic",
-        "aggregation_logic",
-        "entity_mapping",
-        "unknown",
-    }
-
-    return normalized if normalized in allowed_categories else "unknown"

gaard_core-0.1.0/src/gaard_core/investigation/loop.py

@@ -1,83 +0,0 @@
-from typing import Protocol
-
-from gaard_core.investigation.models import (
-    InvestigationContext,
-    InvestigationIteration,
-    InvestigationLoopConfig,
-    InvestigationLoopResult,
-    InvestigationReadinessDecision,
-    InvestigationRoute,
-)
-
-
-class InvestigationReadinessAgent(Protocol):
-    name: str
-
-    def assess(self, context: InvestigationContext) -> InvestigationReadinessDecision:
-        pass
-
-
-class InvestigationLoop:
-    def __init__(
-        self,
-        readiness_agent: InvestigationReadinessAgent,
-        config: InvestigationLoopConfig | None = None,
-    ) -> None:
-        self.readiness_agent = readiness_agent
-        self.config = config or InvestigationLoopConfig()
-
-    def run(self, context: InvestigationContext) -> InvestigationLoopResult:
-        iterations: list[InvestigationIteration] = []
-
-        for iteration_number in range(1, self.config.max_iterations + 1):
-            decision = self.readiness_agent.assess(context)
-            normalized_decision = self._normalize_decision(decision)
-            iterations.append(
-                InvestigationIteration(
-                    iteration=iteration_number,
-                    agent=self.readiness_agent.name,
-                    decision=normalized_decision,
-                )
-            )
-
-            if normalized_decision.route == InvestigationRoute.SQL:
-                return InvestigationLoopResult(
-                    route=InvestigationRoute.SQL,
-                    ready_for_sql=True,
-                    max_iterations=self.config.max_iterations,
-                    confidence_threshold=self.config.readiness_confidence_threshold,
-                    iterations=iterations,
-                )
-
-            return InvestigationLoopResult(
-                route=InvestigationRoute.ANALYSIS,
-                ready_for_sql=False,
-                max_iterations=self.config.max_iterations,
-                confidence_threshold=self.config.readiness_confidence_threshold,
-                iterations=iterations,
-            )
-
-        return InvestigationLoopResult(
-            route=InvestigationRoute.ANALYSIS,
-            ready_for_sql=False,
-            max_iterations=self.config.max_iterations,
-            confidence_threshold=self.config.readiness_confidence_threshold,
-            iterations=iterations,
-        )
-
-    def _normalize_decision(
-        self,
-        decision: InvestigationReadinessDecision,
-    ) -> InvestigationReadinessDecision:
-        ready = (
-            decision.ready_for_sql
-            and decision.confidence >= self.config.readiness_confidence_threshold
-        )
-        route = InvestigationRoute.SQL if ready else InvestigationRoute.ANALYSIS
-
-        return decision.model_copy(
-            update={
-                "ready_for_sql": ready,
-                "route": route,
-            }
-        )

gaard_core-0.1.0/src/gaard_core/investigation/mock_readiness_agent.py

@@ -1,20 +0,0 @@
-from gaard_core.investigation.models import (
-    InvestigationContext,
-    InvestigationReadinessDecision,
-    InvestigationRoute,
-)
-
-
-class MockInvestigationReadinessAgent:
-    name = "mock_investigation_readiness"
-
-    def __init__(self, decision: InvestigationReadinessDecision | None = None) -> None:
-        self.decision = decision or InvestigationReadinessDecision(
-            ready_for_sql=True,
-            route=InvestigationRoute.SQL,
-            confidence=1.0,
-            reason="Mock readiness agent allows the normal SQL pipeline.",
-        )
-
-    def assess(self, context: InvestigationContext) -> InvestigationReadinessDecision:
-        return self.decision

gaard_core-0.1.0/src/gaard_core/investigation/models.py

@@ -1,62 +0,0 @@
-from enum import StrEnum
-from typing import Any
-
-from pydantic import BaseModel, Field
-
-
-class InvestigationRoute(StrEnum):
-    SQL = "sql"
-    ANALYSIS = "analysis"
-
-
-class InvestigationContext(BaseModel):
-    question: str = Field(min_length=1)
-    datasource_id: str = "default"
-    user_id: str = "local-admin"
-    formatted_schema: str = ""
-    business_logic: str = ""
-
-
-class RequiredAnalysisTask(BaseModel):
-    missing_information: str = ""
-    required_analysis: str = ""
-    category: str = "unknown"
-    expected_output: str = ""
-
-
-class InvestigationReadinessDecision(BaseModel):
-    ready_for_sql: bool = False
-    route: InvestigationRoute = InvestigationRoute.ANALYSIS
-    confidence: float = 0.0
-    reason: str = ""
-    missing_information: list[str] = Field(default_factory=list)
-    required_analysis: list[str] = Field(default_factory=list)
-    required_analysis_tasks: list[RequiredAnalysisTask] = Field(default_factory=list)
-    assumptions: list[str] = Field(default_factory=list)
-    model_response: dict[str, Any] = Field(default_factory=dict)
-
-
-class InvestigationIteration(BaseModel):
-    iteration: int
-    agent: str
-    decision: InvestigationReadinessDecision
-
-
-class InvestigationLoopConfig(BaseModel):
-    max_iterations: int = Field(default=1, ge=1)
-    readiness_confidence_threshold: float = Field(default=0.85, ge=0.0, le=1.0)
-
-
-class InvestigationLoopResult(BaseModel):
-    route: InvestigationRoute
-    ready_for_sql: bool
-    max_iterations: int
-    confidence_threshold: float
-    iterations: list[InvestigationIteration] = Field(default_factory=list)
-
-    @property
-    def final_decision(self) -> InvestigationReadinessDecision | None:
-        if not self.iterations:
-            return None
-
-        return self.iterations[-1].decision

gaard_core-0.1.0/src/gaard_core/prompt_compiler/investigation_readiness_prompt.py

@@ -1,84 +0,0 @@
-from gaard_core.investigation.models import InvestigationContext, InvestigationRoute
-from gaard_core.json_utils import json_dumps
-from gaard_core.prompt_compiler.models import CompiledPrompt
-
-
-class InvestigationReadinessPromptCompiler:
-    def compile(self, context: InvestigationContext) -> CompiledPrompt:
-        payload = {
-            "question": context.question,
-            "datasource_id": context.datasource_id,
-            "user_id": context.user_id,
-            "schema": context.formatted_schema,
-            "business_logic": context.business_logic,
-        }
-
-        return CompiledPrompt(
-            system_prompt=self._build_system_prompt(),
-            user_prompt=self._build_user_prompt(payload),
-            metadata={
-                "allowed_routes": [item.value for item in InvestigationRoute],
-            },
-        )
-
-    def _build_system_prompt(self) -> str:
-        return """You are GAARD Investigation Readiness.
-
-Your task is to decide whether GAARD already knows enough to create a correct SQL query for the user's question.
-
-Assume nothing. Verify continuously.
-
-Use only:
-- the user's question,
-- the active datasource schema,
-- the approved or previously saved business logic supplied in the payload.
-
-You do not generate SQL.
-You do not answer the user.
-You decide only whether normal SQL generation may start safely.
-
-Return ready_for_sql=true only when all information needed for correct SQL is explicit in the question, schema, and business logic:
-- requested business entity or metric,
-- relevant tables, views and columns,
-- required filters and dictionary/status values,
-- required joins or relationships,
-- requested output shape such as count, list, detail, or aggregation.
-
-Return ready_for_sql=false when any material element is missing, ambiguous, inferred only from the model, or would require checking data values before SQL can be trusted. In that case route must be analysis.
-
-Output rules:
-- Return only a JSON object.
-- Do not include markdown.
-- Do not include reasoning outside the JSON.
-- Do not include <think> blocks.
-- Use exactly this JSON shape:
-  {"ready_for_sql":false,"route":"analysis","confidence":0.0,"reason":"short reason","missing_information":[],"required_analysis":[],"required_analysis_tasks":[],"assumptions":[]}
-
-Required analysis task shape:
-{"missing_information":"what is missing","required_analysis":"specific read-only data question for SQL analysis","category":"dictionary_value","expected_output":"what kind of result would resolve this"}
-
-Allowed categories:
-- dictionary_value
-- relationship_logic
-- filter_logic
-- aggregation_logic
-- entity_mapping
-- unknown
-"""
-
-    def _build_user_prompt(self, payload: dict[str, str]) -> str:
-        return f"""Assess whether normal SQL generation can start.
-
-Input JSON:
-{json_dumps(payload, ensure_ascii=False, indent=2)}
-
-Return one JSON object with:
-- ready_for_sql: boolean
-- route: sql or analysis
-- confidence: number from 0 to 1
-- reason: short explanation
-- missing_information: list of missing or ambiguous items
-- required_analysis: list of checks that Analysis mode should perform when ready_for_sql=false
-- required_analysis_tasks: list of structured SQL-analysis tasks with missing_information, required_analysis, category, expected_output
-- assumptions: list of any assumptions that would affect SQL correctness
-"""

gaard_core-0.1.0/tests/test_investigation_readiness.py

@@ -1,150 +0,0 @@
-from gaard_core.investigation.llm_readiness_agent import (
-    parse_investigation_readiness_decision,
-)
-from gaard_core.investigation.loop import InvestigationLoop
-from gaard_core.investigation.mock_readiness_agent import MockInvestigationReadinessAgent
-from gaard_core.investigation.models import (
-    InvestigationContext,
-    InvestigationLoopConfig,
-    InvestigationReadinessDecision,
-    InvestigationRoute,
-    RequiredAnalysisTask,
-)
-from gaard_core.prompt_compiler.investigation_readiness_prompt import (
-    InvestigationReadinessPromptCompiler,
-)
-
-
-def test_parse_readiness_decision_routes_ready_json_to_sql() -> None:
-    decision = parse_investigation_readiness_decision(
-        """
-        {
-          "ready_for_sql": true,
-          "route": "sql",
-          "confidence": 0.94,
-          "reason": "Schema and business logic identify the needed columns.",
-          "missing_information": [],
-          "required_analysis": [],
-          "assumptions": []
-        }
-        """
-    )
-
-    assert decision.ready_for_sql is True
-    assert decision.route == InvestigationRoute.SQL
-    assert decision.confidence == 0.94
-
-
-def test_parse_readiness_decision_invalid_json_requires_analysis() -> None:
-    decision = parse_investigation_readiness_decision("ready")
-
-    assert decision.ready_for_sql is False
-    assert decision.route == InvestigationRoute.ANALYSIS
-    assert "valid readiness JSON" in decision.missing_information
-
-
-def test_parse_readiness_decision_requires_consistent_ready_signal() -> None:
-    decision = parse_investigation_readiness_decision(
-        '{"ready_for_sql": false, "route": "sql", "confidence": 0.99}'
-    )
-
-    assert decision.ready_for_sql is False
-    assert decision.route == InvestigationRoute.ANALYSIS
-
-
-def test_parse_readiness_decision_reads_structured_required_analysis_tasks() -> None:
-    decision = parse_investigation_readiness_decision(
-        """
-        {
-          "ready_for_sql": false,
-          "route": "analysis",
-          "confidence": 0.91,
-          "missing_information": ["specialty dictionary value"],
-          "required_analysis": ["List distinct doctors.specialization values."],
-          "required_analysis_tasks": [
-            {
-              "missing_information": "specialty dictionary value",
-              "required_analysis": "List distinct doctors.specialization values.",
-              "category": "dictionary-value",
-              "expected_output": "specialization values"
-            }
-          ],
-          "assumptions": []
-        }
-        """
-    )
-
-    assert decision.required_analysis_tasks == [
-        RequiredAnalysisTask(
-            missing_information="specialty dictionary value",
-            required_analysis="List distinct doctors.specialization values.",
-            category="dictionary_value",
-            expected_output="specialization values",
-        )
-    ]
-
-
-def test_parse_readiness_decision_builds_tasks_from_legacy_lists() -> None:
-    decision = parse_investigation_readiness_decision(
-        """
-        {
-          "ready_for_sql": false,
-          "route": "analysis",
-          "confidence": 0.91,
-          "missing_information": ["specialty dictionary value"],
-          "required_analysis": ["List distinct doctors.specialization values."],
-          "assumptions": []
-        }
-        """
-    )
-
-    assert decision.required_analysis_tasks == [
-        RequiredAnalysisTask(
-            missing_information="specialty dictionary value",
-            required_analysis="List distinct doctors.specialization values.",
-        )
-    ]
-
-
-def test_investigation_loop_requires_confidence_threshold_for_sql() -> None:
-    agent = MockInvestigationReadinessAgent(
-        InvestigationReadinessDecision(
-            ready_for_sql=True,
-            route=InvestigationRoute.SQL,
-            confidence=0.5,
-            reason="Low confidence.",
-        )
-    )
-
-    result = InvestigationLoop(
-        readiness_agent=agent,
-        config=InvestigationLoopConfig(
-            max_iterations=1,
-            readiness_confidence_threshold=0.85,
-        ),
-    ).run(
-        InvestigationContext(
-            question="ile jest wizyt",
-            formatted_schema="Table: appointments",
-        )
-    )
-
-    assert result.ready_for_sql is False
-    assert result.route == InvestigationRoute.ANALYSIS
-    assert result.iterations[0].decision.ready_for_sql is False
-
-
-def test_readiness_prompt_includes_schema_and_business_logic() -> None:
-    compiled = InvestigationReadinessPromptCompiler().compile(
-        InvestigationContext(
-            question="ile jest aktywnych pacjentów",
-            datasource_id="medical",
-            user_id="alice",
-            formatted_schema="Table: patients",
-            business_logic="Active patient means patients.status = 'active'.",
-        )
-    )
-
-    assert "Assume nothing. Verify continuously." in compiled.system_prompt
-    assert "Table: patients" in compiled.user_prompt
-    assert "patients.status = 'active'" in compiled.user_prompt