gaard-api 0.2.17__tar.gz → 0.2.18__tar.gz

{gaard_api-0.2.17/src/gaard_api.egg-info → gaard_api-0.2.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gaard-api
-Version: 0.2.17
+Version: 0.2.18
 Summary: GAARD backend web services providing admin interface
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{gaard_api-0.2.17 → gaard_api-0.2.18}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gaard-api"
-version = "0.2.17"
+version = "0.2.18"
 description = "GAARD backend web services providing admin interface"
 readme = "README.md"
 requires-python = ">=3.11"

{gaard_api-0.2.17 → gaard_api-0.2.18}/src/gaard_api/admin/services.py

@@ -1839,10 +1839,19 @@ def upsert_analysis_business_logic_suggestion(
         session.flush()
         return existing
 
+    should_enable = auto_enable or existing.enabled
     existing.source_audit_id = source_audit_id
-    existing.status = BUSINESS_LOGIC_STATUS_ACTIVE if auto_enable else BUSINESS_LOGIC_STATUS_PENDING
-    existing.safety = BUSINESS_LOGIC_SAFETY_SAFE if auto_enable else BUSINESS_LOGIC_SAFETY_REVIEW
-    existing.enabled = auto_enable
+    existing.status = (
+        BUSINESS_LOGIC_STATUS_ACTIVE
+        if should_enable
+        else BUSINESS_LOGIC_STATUS_PENDING
+    )
+    existing.safety = (
+        BUSINESS_LOGIC_SAFETY_SAFE
+        if should_enable
+        else BUSINESS_LOGIC_SAFETY_REVIEW
+    )
+    existing.enabled = should_enable
     existing.error_category = normalized_type
     existing.title = normalized_title
     existing.rule_text = normalized_rule

{gaard_api-0.2.17 → gaard_api-0.2.18}/src/gaard_api/analysis_findings.py

@@ -186,6 +186,46 @@ def create_analysis_finding(
     return finding
 
 
+def get_analysis_finding_for_business_logic_suggestion(
+    session: Session,
+    *,
+    investigation_id: str,
+    owner_user_id: str,
+    business_logic_suggestion_id: int,
+) -> AnalysisFinding | None:
+    return session.scalar(
+        select(AnalysisFinding)
+        .where(
+            AnalysisFinding.investigation_id == investigation_id,
+            AnalysisFinding.owner_user_id == owner_user_id,
+            AnalysisFinding.business_logic_suggestion_id == business_logic_suggestion_id,
+        )
+        .order_by(AnalysisFinding.id.asc())
+    )
+
+
+def refresh_analysis_finding_observation(
+    finding: AnalysisFinding,
+    *,
+    statement: str,
+    finding_type: str,
+    confidence: float,
+    critique: str,
+    scope: dict[str, Any],
+    evidence_refs: list[str],
+) -> AnalysisFinding:
+    finding.statement = remove_thinking_blocks(statement).strip()[:4_000]
+    finding.finding_type = (finding_type.strip() or "finding")[:100]
+    finding.confidence = max(0.0, min(1.0, float(confidence)))
+    finding.critique = remove_thinking_blocks(critique).strip()[:4_000]
+    finding.scope_json = json_dumps(scope)
+    finding.evidence_refs_json = json_dumps(
+        unique_texts(text_list(finding.evidence_refs_json) + evidence_refs)
+    )
+    finding.contract_version = FINDING_CONTRACT_VERSION
+    return finding
+
+
 def get_owned_analysis_finding(
     session: Session,
     *,

{gaard_api-0.2.17 → gaard_api-0.2.18}/src/gaard_api/api/v1/analysis.py

@@ -45,10 +45,12 @@ from gaard_api.analysis_findings import (
     create_analysis_finding,
     create_radar_finding_decision,
     format_working_knowledge,
+    get_analysis_finding_for_business_logic_suggestion,
     get_owned_analysis_finding,
     list_active_analysis_findings,
     list_owned_analysis_findings,
     record_finding_usage,
+    refresh_analysis_finding_observation,
     serialize_analysis_finding,
     serialize_finding_decision,
     serialize_working_knowledge_item,
@@ -1221,22 +1223,42 @@ def save_business_logic_finding(
             auto_enable=runtime_config.analysis_auto_enable_business_logic,
             actor=f"analysis:{session_id}",
         )
-        finding_record = create_analysis_finding(
+        critique = first_non_empty(
+            finding.critique,
+            "Confirmed only by evidence from this investigation and datasource.",
+        )
+        scope = finding_scope(finding, connector.connector_key, context)
+        evidence_refs = finding_evidence_refs(finding, context)
+        finding_record = get_analysis_finding_for_business_logic_suggestion(
             session,
             investigation_id=session_id,
             owner_user_id=record.user_id,
-            connector_id=connector.id,
             business_logic_suggestion_id=suggestion.id,
-            statement=statement,
-            finding_type=finding.knowledge_type,
-            confidence=finding.confidence,
-            critique=first_non_empty(
-                finding.critique,
-                "Confirmed only by evidence from this investigation and datasource.",
-            ),
-            scope=finding_scope(finding, connector.connector_key, context),
-            evidence_refs=finding_evidence_refs(finding, context),
         )
+        if finding_record is None:
+            finding_record = create_analysis_finding(
+                session,
+                investigation_id=session_id,
+                owner_user_id=record.user_id,
+                connector_id=connector.id,
+                business_logic_suggestion_id=suggestion.id,
+                statement=statement,
+                finding_type=finding.knowledge_type,
+                confidence=finding.confidence,
+                critique=critique,
+                scope=scope,
+                evidence_refs=evidence_refs,
+            )
+        else:
+            refresh_analysis_finding_observation(
+                finding_record,
+                statement=statement,
+                finding_type=finding.knowledge_type,
+                confidence=finding.confidence,
+                critique=critique,
+                scope=scope,
+                evidence_refs=evidence_refs,
+            )
         session.commit()
         finding_payload = serialize_analysis_finding(finding_record)
         return {

{gaard_api-0.2.17 → gaard_api-0.2.18}/src/gaard_api/main.py

@@ -40,7 +40,7 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
 
 app = FastAPI(
     title="GAARD API",
-    version="0.2.17",
+    version="0.2.18",
     description="Self-hosted AI SQL Gateway for governed natural-language access to relational data.",
     lifespan=lifespan,
 )

{gaard_api-0.2.17 → gaard_api-0.2.18/src/gaard_api.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gaard-api
-Version: 0.2.17
+Version: 0.2.18
 Summary: GAARD backend web services providing admin interface
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{gaard_api-0.2.17 → gaard_api-0.2.18}/tests/test_analysis_api.py

@@ -376,6 +376,146 @@ def test_analysis_database_step_can_record_business_logic_suggestion(
         assert suggestions[0].error_category == "analysis.dictionary_value"
 
 
+def test_repeated_analysis_finding_preserves_review_decisions(
+    analysis_client: TestClient,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    headers = auth_headers(analysis_client)
+    connector = create_active_default_datasource()
+
+    def repeated_finding() -> analysis_module.AnalysisBusinessLogicFinding:
+        return analysis_module.AnalysisBusinessLogicFinding(
+            create_suggestion=True,
+            knowledge_type="semantic_mapping",
+            title="Cardiology dictionary mapping",
+            rule_text="The dictionary value for cardiology is cardiology.",
+            statement="The dictionary value for cardiology is cardiology.",
+            confidence=0.94,
+            critique="The mapping is confirmed only in the current datasource.",
+            scope={"entity": "specialization", "field": "specialization_name"},
+            evidence_refs=["query:dictionary-check"],
+        )
+
+    class RepeatedFindingPlanner:
+        def __init__(self) -> None:
+            self.calls = 0
+            self.working_knowledge_seen: list[list[dict[str, Any]]] = []
+
+        def decide(
+            self, request: Any, datasource_context: Any, context: dict[str, Any]
+        ) -> analysis_module.AnalysisPlannerDecision:
+            self.calls += 1
+            self.working_knowledge_seen.append(list(context.get("working_knowledge") or []))
+            return analysis_module.AnalysisPlannerDecision(
+                action=analysis_module.AnalysisAction.ASK_USER,
+                visible_question=f"Review mapping attempt {self.calls}.",
+                visible_reasoning="The same semantic mapping was observed again.",
+                user_question="Continue after review.",
+                business_logic=repeated_finding(),
+            )
+
+    planner = RepeatedFindingPlanner()
+    monkeypatch.setattr(analysis_module, "create_analysis_planner", lambda: planner)
+
+    response = analysis_client.post(
+        "/api/v1/analysis/stream",
+        headers=headers,
+        json={"question": "Find the cardiology dictionary value.", "user_id": "spoofed"},
+    )
+    assert response.status_code == 200
+    events = parse_ndjson(response.text)
+    session_id = events[0]["session_id"]
+    first_suggestion = next(
+        item["business_logic_suggestion"]
+        for item in events
+        if item["event"] == "business_logic_suggestion"
+    )
+    finding_id = first_suggestion["finding_id"]
+
+    radar_decision_payload = {
+        "finding_id": finding_id,
+        "decision": "accept_for_investigation",
+        "confidence": 0.93,
+        "verdict": "The observed values explain the terminology lookup.",
+        "scope": {
+            "investigation_id": session_id,
+            "radar_run_id": "radar-repeat-1",
+        },
+        "evidence_refs": ["query:dictionary-check"],
+    }
+    accepted_response = analysis_client.post(
+        f"/api/v1/analysis/{session_id}/finding-decisions",
+        headers=headers,
+        json=radar_decision_payload,
+    )
+    assert accepted_response.status_code == 200
+    assert accepted_response.json()["accepted"] is True
+
+    repeat_response = analysis_client.post(
+        f"/api/v1/analysis/{session_id}/messages/stream",
+        headers=headers,
+        json={"message": "Continue."},
+    )
+    assert repeat_response.status_code == 200
+    repeat_events = parse_ndjson(repeat_response.text)
+    repeated_suggestion = next(
+        item["business_logic_suggestion"]
+        for item in repeat_events
+        if item["event"] == "business_logic_suggestion"
+    )
+    assert repeated_suggestion["finding_id"] == finding_id
+    assert repeated_suggestion["finding"]["status"] == "accepted_for_investigation"
+    assert planner.working_knowledge_seen[-1][0]["finding_id"] == finding_id
+
+    persistent_response = analysis_client.put(
+        f"/api/v1/analysis/{session_id}/findings/{finding_id}/decision",
+        headers=headers,
+        json={
+            "finding_id": finding_id,
+            "decision": "accept_as_persistent_business_logic",
+            "confidence": 0.93,
+            "verdict": "An administrator approved this as durable logic.",
+            "scope": {"investigation_id": session_id},
+            "evidence_refs": ["query:dictionary-check"],
+        },
+    )
+    assert persistent_response.status_code == 200
+
+    repeat_after_persistent_response = analysis_client.post(
+        f"/api/v1/analysis/{session_id}/messages/stream",
+        headers=headers,
+        json={"message": "Continue again."},
+    )
+    assert repeat_after_persistent_response.status_code == 200
+    repeat_after_persistent_events = parse_ndjson(repeat_after_persistent_response.text)
+    repeated_persistent_suggestion = next(
+        item["business_logic_suggestion"]
+        for item in repeat_after_persistent_events
+        if item["event"] == "business_logic_suggestion"
+    )
+    assert repeated_persistent_suggestion["finding_id"] == finding_id
+    assert repeated_persistent_suggestion["finding"]["status"] == (
+        "accepted_as_persistent_business_logic"
+    )
+
+    with create_session() as session:
+        findings = list(
+            session.scalars(
+                select(AnalysisFinding).where(
+                    AnalysisFinding.investigation_id == session_id
+                )
+            )
+        )
+        assert len(findings) == 1
+        assert findings[0].finding_id == finding_id
+        assert findings[0].decision == "accept_as_persistent_business_logic"
+        assert findings[0].status == "accepted_as_persistent_business_logic"
+        suggestions = list_business_logic_suggestions(session, connector.id)
+        assert len(suggestions) == 1
+        assert suggestions[0].enabled is True
+        assert suggestions[0].status == "active"
+
+
 def test_investigation_finding_review_lifecycle_and_scoped_working_knowledge(
     analysis_client: TestClient,
     monkeypatch: pytest.MonkeyPatch,