qwen-sci 0.2.2__py3-none-any.whl

src/agents/idea_agent/tests/test_profile_native_skill_rendering.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+from src.agents.idea_agent.utils.mcts.mcts_runtime import SkillCatalog
+from src.agents.idea_agent.utils.mcts.scientific_intervention_ontology import (
+    get_scientific_intervention_profile,
+    get_scientific_object_schema,
+)
+
+
+def test_profile_payload_exposes_native_object_schema() -> None:
+    profile = get_scientific_intervention_profile("clinical_health")
+    assert profile is not None
+    payload = profile.to_payload()
+    schema = payload["scientific_object_schema"]
+    assert "intervention_or_exposure" in schema["object_types"]
+    assert "intervene" in schema["allowed_operations"]
+    assert "clinical_endpoint" in schema["measurement_or_observation_roles"]
+    assert "safety_or_external_validity_boundary" in schema["boundary_condition_roles"]
+
+
+def test_non_cs_skill_rendering_uses_native_placeholders() -> None:
+    catalog = SkillCatalog()
+    schema = get_scientific_object_schema("physical_materials_chemical")
+    assert schema is not None
+    rendered = catalog.render_skill_for_profile(
+        "feedback-closed-loop",
+        "physical_materials_chemical",
+        schema,
+    )
+    blueprint = " ".join(rendered.atomic_blueprint)
+    assert "feedback_monitor" not in blueprint
+    assert "adaptation_rule" not in blueprint
+    assert "characterization_feedback" in blueprint
+    assert "profile-native" in " ".join(rendered.guardrails)
+    assert "characterize" in rendered.preferred_operations
+
+
+def test_cs_skill_rendering_preserves_legacy_blueprint() -> None:
+    catalog = SkillCatalog()
+    base = catalog.skills["mechanism-commit-innovation"]
+    rendered = catalog.render_skill_for_profile(
+        base,
+        "computational_algorithmic",
+        get_scientific_object_schema("computational_algorithmic"),
+    )
+    assert rendered.atomic_blueprint == base.atomic_blueprint
+    assert rendered.rendered_profile_id == "computational_algorithmic"
+
+
+def test_catalog_prompt_can_render_native_operation_reference() -> None:
+    catalog = SkillCatalog()
+    prompt = catalog.format_for_prompt(
+        profile_id="formal_theoretical",
+        object_schema=get_scientific_object_schema("formal_theoretical"),
+    )
+    assert "profile-native scientific objects" in prompt
+    assert "proof_or_verification" in prompt
+    assert "data flow" not in prompt.lower()
+
+
+def test_non_cs_skill_prompt_hides_architecture_skills() -> None:
+    catalog = SkillCatalog()
+    prompt = catalog.format_for_prompt(
+        profile_id="clinical_health",
+        object_schema=get_scientific_object_schema("clinical_health"),
+    )
+    assert "surgical-modularity" not in prompt
+    assert "speculative-execution-with-repair" not in prompt
+    assert "pipeline" not in prompt.lower()
+
+
+def test_profile_selection_disables_speculation_for_non_operational_profiles() -> None:
+    catalog = SkillCatalog()
+    selected = catalog.select_skills(
+        defect_tags=["rollback_blindspot"],
+        max_children=8,
+        structural_profile={
+            "control_centered": True,
+            "scope_kind": "execution_path",
+            "training_free_like": False,
+            "has_multi_path_shape": True,
+        },
+        profile_id="formal_theoretical",
+    )
+    assert all(item.skill.name != "speculative-execution-with-repair" for item in selected)
+
+
+def test_profile_native_defects_contribute_to_skill_overlap() -> None:
+    catalog = SkillCatalog()
+    selected = catalog.select_skills(
+        defect_tags=["missing_boundary_condition"],
+        max_children=8,
+        structural_profile={
+            "control_centered": True,
+            "scope_kind": "execution_path",
+            "training_free_like": False,
+            "has_multi_path_shape": True,
+        },
+        profile_id="clinical_health",
+    )
+    alternative = next(
+        item for item in selected if item.skill.name == "alternative-path-contrast"
+    )
+    assert alternative.defect_score > 0.0
+
+
+def test_non_cs_feedback_skill_can_use_observation_loop_without_control_center() -> None:
+    catalog = SkillCatalog()
+    selected = catalog.select_skills(
+        defect_tags=["measurement_construct_mismatch"],
+        max_children=8,
+        structural_profile={
+            "profile_id": "physical_materials_chemical",
+            "control_centered": False,
+            "scope_kind": "existing_subsystem",
+            "training_free_like": False,
+            "has_multi_path_shape": False,
+        },
+        profile_id="physical_materials_chemical",
+    )
+    feedback = next(item for item in selected if item.skill.name == "feedback-closed-loop")
+    assert feedback.structure_fit > 0.0

src/agents/idea_agent/tests/test_result_persistence.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from src.agents.idea_agent.utils.core.json_utils import read_json_file
+from src.agents.idea_agent.utils.workflow.ligagent_flow import (
+    save_candidate_payload,
+    save_idea_result_payload,
+)
+from src.agents.idea_agent.utils.workflow.ligagent_handlers import _build_mode_result_document
+from src.agents.idea_agent.agent.artifacts import artifact_init
+from src.agents.idea_agent.utils.workflow.result_persistence import (
+    compact_candidate_entry,
+    compact_debate_summary,
+    compact_result_payload,
+)
+
+
+class _Logger:
+    def info(self, *args, **kwargs) -> None:
+        return None
+
+    def error(self, *args, **kwargs) -> None:
+        raise AssertionError(args)
+
+
+def _candidate() -> dict:
+    return {
+        "title": "A candidate",
+        "abstract": "A bounded abstract.",
+        "core_contribution": "A mechanism claim.",
+        "method": "Compare the mechanism-specific observation.",
+        "components": ["sample preparation"],
+        "root_domains": ["materials_science"],
+        "scientific_intervention": {
+            "profile_id": "materials_mechanistic",
+            "contribution_mode": "mechanism",
+            "hypothesis_contract": {"central_hypothesis": "The mechanism changes the relation."},
+            "paper_graph_context": "x" * 200_000,
+        },
+        "evaluation": {"novelty": 0.8, "composite": 0.7, "debug_payload": "y" * 100_000},
+        "search_score": 0.7,
+        "search_path": "root -> mechanism",
+        "search_trace": [{"payload": "z" * 200_000}],
+        "pareto_candidates": {"novel": {"payload": "p" * 200_000}},
+        "idea_result": {"title": "Nested result", "directions": [{"title": "Nested"}]},
+    }
+
+
+def test_compact_candidate_drops_diagnostics_but_keeps_root_seed_fields() -> None:
+    compact = compact_candidate_entry(_candidate())
+
+    assert compact["title"] == "A candidate"
+    assert compact["components"] == ["sample preparation"]
+    assert compact["scientific_intervention"]["profile_id"] == "materials_mechanistic"
+    assert "search_trace" not in compact
+    assert "pareto_candidates" not in compact
+    assert "idea_result" not in compact
+    assert "paper_graph_context" not in compact["scientific_intervention"]
+    assert "debug_payload" not in compact["evaluation"]
+
+
+def test_compact_result_projects_stage_snapshots_and_handoff_evidence() -> None:
+    payload = {
+        "schema_version": "idea_result_v5",
+        "topic": "Topic",
+        "title": "Final idea",
+        "abstract": "Abstract",
+        "method": "Method",
+        "scientific_spec": {"central_hypothesis": "H"},
+        "directions": [
+            {
+                "direction_mode": "evidence_first",
+                "title": "Direction",
+                "hypothesis": {"central_hypothesis": "H"},
+                "experiment_handoff": {
+                    "gap_ids": ["gap-1"],
+                    "gap_records": [{"gap_id": "gap-1", "statement": "Unresolved", "full": "x" * 100_000}],
+                    "evidence_roles": [{
+                        "role_id": "role-1",
+                        "evidence_role": "direct",
+                        "expected_role": "direct observation",
+                        "claim_limits": "Only supports the stated regime.",
+                        "excerpt": "y" * 100_000,
+                    }],
+                    "source_anchors": [{
+                        "anchor_id": "anchor-1",
+                        "paper_id": "p-1",
+                        "claim_anchor": "The paper reports the mechanism.",
+                        "source_pointer": {"section": "Results", "paragraph": 2},
+                        "abstract": "z" * 100_000,
+                    }],
+                },
+            }
+        ],
+        "direction_synthesis": {"directions": [{"direction_mode": "evidence_first", "search_trace": ["raw"]}]},
+        "debate_result": {"directions": [{"direction_mode": "evidence_first", "search_trace": ["raw"]}], "round_count": 2},
+        "legacy_best_entry": _candidate(),
+        "mcts_evolution": {
+            "iterations": [{"iteration": 1, "title": "t", "evaluation": {"large": "x" * 100_000}}],
+            "pareto_front": {"novel": {"idea": {"title": "P", "components": ["large"]}, "evaluation": {"composite": 0.6}}},
+        },
+    }
+
+    compact = compact_result_payload(payload)
+    encoded = json.dumps(compact, ensure_ascii=False)
+
+    assert len(encoded) < 50_000
+    assert compact["directions"][0]["experiment_handoff"]["gap_ids"] == ["gap-1"]
+    roles = compact["directions"][0]["experiment_handoff"]["evidence_roles"]
+    anchors = compact["directions"][0]["experiment_handoff"]["source_anchors"]
+    assert roles[0]["expected_role"] == "direct observation"
+    assert roles[0]["claim_limits"] == "Only supports the stated regime."
+    assert anchors[0]["claim_anchor"] == "The paper reports the mechanism."
+    assert anchors[0]["source_pointer"]["section"] == "Results"
+    assert compact["direction_synthesis"]["directions"][0]["direction_mode"] == "evidence_first"
+    assert compact["debate_result"]["round_count"] == 2
+    assert "search_trace" not in compact["legacy_best_entry"]
+    assert "evaluation" not in compact["mcts_evolution"]["iterations"][0]
+
+
+def test_compact_debate_preserves_scientific_challenge_semantics() -> None:
+    event = compact_debate_summary(
+        {
+            "round": 2,
+            "direction_mode": "evidence_first",
+            "question_type": "causal_mechanism",
+            "target_claim": "The treatment changes the outcome through mechanism M.",
+            "scientific_concern": "The observed effect may have an alternative pathway.",
+            "required_revision": "Specify the boundary condition and falsifier.",
+            "alternative_explanations": ["Pathway N"],
+            "final_scope": "Only the prepared cohort.",
+            "final_status": "SCIENTIFICALLY_QUALIFIED_WITH_UNCERTAINTY",
+        }
+    )
+
+    assert event["target_claim"].startswith("The treatment")
+    assert event["scientific_concern"].startswith("The observed")
+    assert event["required_revision"].startswith("Specify")
+    assert event["alternative_explanations"] == ["Pathway N"]
+    assert event["final_scope"] == "Only the prepared cohort."
+
+
+def test_persisted_json_remains_pretty_indented(tmp_path: Path) -> None:
+    logger = _Logger()
+    result_path = tmp_path / "idea_result.json"
+    candidate_path = tmp_path / "idea_candidate.json"
+    payload = {"title": "A", "directions": [], "legacy_best_entry": _candidate()}
+
+    save_idea_result_payload(payload, result_path, logger)
+    save_candidate_payload(_candidate(), candidate_path, logger)
+
+    raw_result = result_path.read_text(encoding="utf-8")
+    raw_candidate = candidate_path.read_text(encoding="utf-8")
+    assert "\n  \"" in raw_result
+    assert "\n  \"" in raw_candidate
+    assert read_json_file(result_path)["persistence"]["mode"] == "public_compact"
+
+
+def test_mode_document_uses_raw_candidate_for_hypothesis_projection() -> None:
+    source_entry = _candidate()
+    source_entry.update(
+        {
+            "direction_mode": "evidence_first",
+            "central_hypothesis": "The mechanism changes the relation.",
+            "scientific_object": {"object_type": "interface"},
+            "mechanism_or_relation": "interfacial transport",
+            "claim_scope": "the prepared interface",
+        }
+    )
+    mode_payload = _build_mode_result_document(
+        "Topic",
+        {"direction_mode": "evidence_first"},
+        source_entry,
+        artifact_init(),
+        {},
+    )
+
+    public_direction = mode_payload["directions"][0]
+    assert public_direction["hypothesis"]["central_hypothesis"] == "The mechanism changes the relation."
+    assert mode_payload["legacy_best_entry"]["title"] == "A candidate"
+    assert "search_trace" not in mode_payload["legacy_best_entry"]

src/agents/idea_agent/tests/test_scientific_intervention_profiles.py

@@ -0,0 +1,241 @@
+from __future__ import annotations
+
+import pytest
+
+from src.agents.idea_agent.utils.mcts.mcts_runtime import build_root_state
+from src.agents.idea_agent.utils.mcts.scientific_intervention_ontology import (
+    IGNORED_PAPERSEEK_OPENALEX_FIELDS,
+    PAPERSEEK_FIELD_CROSSWALK,
+    PAPERSEEK_FIELD_TO_PROFILE,
+    RETAINED_PAPERSEEK_OPENALEX_FIELDS,
+    get_scientific_field_spec,
+    get_scientific_intervention_profile,
+    get_scientific_object_spec,
+    build_scientific_intervention_payload,
+    normalize_project_context_discipline_resolution,
+    resolve_scientific_intervention_profile,
+)
+from src.agents.idea_agent.utils.workflow.idea_contract import normalize_idea_contract
+
+
+class CaptureIdeaState:
+    def __init__(self, **payload: object) -> None:
+        self.__dict__.update(payload)
+
+
+def _resolution(discipline: str) -> dict[str, object]:
+    return {
+        "status": "resolved",
+        "primary_discipline": discipline,
+        "discipline_ids": [discipline],
+    }
+
+
+def test_all_retained_paperseek_fields_have_profiles() -> None:
+    assert len(RETAINED_PAPERSEEK_OPENALEX_FIELDS) == 20
+    assert set(RETAINED_PAPERSEEK_OPENALEX_FIELDS) == set(PAPERSEEK_FIELD_TO_PROFILE)
+    assert set(PAPERSEEK_FIELD_CROSSWALK) == set(RETAINED_PAPERSEEK_OPENALEX_FIELDS)
+    for field_id in RETAINED_PAPERSEEK_OPENALEX_FIELDS:
+        profile = resolve_scientific_intervention_profile(
+            {"paperseek_openalex_field_ids": [field_id]}
+        )
+        assert profile is not None
+        assert profile.profile_id == PAPERSEEK_FIELD_TO_PROFILE[field_id]
+
+
+def test_field_profile_object_registry_covers_retained_fields() -> None:
+    for field_id in RETAINED_PAPERSEEK_OPENALEX_FIELDS:
+        field_spec = get_scientific_field_spec(field_id)
+        assert field_spec is not None
+        assert field_spec.primary_profile == PAPERSEEK_FIELD_TO_PROFILE[field_id]
+        assert field_spec.object_role_ids
+        for object_id in field_spec.object_role_ids:
+            assert get_scientific_object_spec(field_spec.primary_profile, object_id) is not None
+
+
+def test_project_context_domain_is_normalized_to_canonical_discipline() -> None:
+    project_context = {
+        "domain": "Black Hole Formation and Existence",
+        "research_identity": {
+            "llm_payload": {
+                "primary_discipline": "Astrophysics",
+                "secondary_disciplines": ["General Relativity"],
+            }
+        },
+    }
+
+    resolution = normalize_project_context_discipline_resolution(project_context)
+
+    assert resolution["primary_discipline"] == "physics_astronomy"
+    assert resolution["source"] == "survey_project_context_domain"
+
+
+def test_explicit_project_context_field_precedes_profile_and_root_domain() -> None:
+    project_context = {
+        "domain": "materials science",
+        "research_context": {
+            "taxonomy_resolution": {
+                "provider_filters": {
+                    "openalex": {"resolved_field_ids": ["25"]},
+                }
+            }
+        },
+    }
+
+    profile = resolve_scientific_intervention_profile(
+        {
+            "profile_id": "computational_algorithmic",
+            "root_domains": ["computer_science"],
+        },
+        project_context=project_context,
+    )
+
+    assert profile is not None
+    assert profile.profile_id == "physical_materials_chemical"
+
+
+def test_ignored_paperseek_fields_do_not_map_to_a_profile() -> None:
+    assert len(IGNORED_PAPERSEEK_OPENALEX_FIELDS) == 6
+    for field_id in IGNORED_PAPERSEEK_OPENALEX_FIELDS:
+        assert resolve_scientific_intervention_profile(
+            {"paperseek_openalex_field_ids": [field_id]}
+        ) is None
+
+
+def test_unresolved_profile_never_falls_back_to_computer_science() -> None:
+    profile = resolve_scientific_intervention_profile({"status": "unresolved"})
+
+    assert profile is not None
+    assert profile.profile_id == "generic_scientific"
+    assert profile.profile_id != "computational_algorithmic"
+
+
+def test_computer_science_keeps_algorithmic_profile() -> None:
+    profile = resolve_scientific_intervention_profile(_resolution("computer_science"))
+
+    assert profile is not None
+    assert profile.profile_id == "computational_algorithmic"
+
+
+@pytest.mark.parametrize(
+    ("discipline", "profile_id"),
+    [
+        ("materials_science", "physical_materials_chemical"),
+        ("medicine", "clinical_health"),
+        ("earth_planetary_science", "earth_environment_agro"),
+        ("mathematics", "formal_theoretical"),
+        ("engineering", "energy_engineering_systems"),
+        ("computer_science", "computational_algorithmic"),
+    ],
+)
+def test_root_components_follow_the_resolved_profile(
+    discipline: str,
+    profile_id: str,
+) -> None:
+    state = build_root_state(
+        f"fixture for {discipline}",
+        {"discipline_resolution": _resolution(discipline)},
+        CaptureIdeaState,
+    )
+    profile = get_scientific_intervention_profile(profile_id)
+
+    assert profile is not None
+    assert state.scientific_intervention["profile_id"] == profile_id
+    assert state.components == profile.default_component_names()
+    assert [entry["component"] for entry in state.scientific_intervention["component_roles"]] == state.components
+    if profile_id != "computational_algorithmic":
+        assert not set(state.components).intersection(
+            {"backbone_model", "objective", "evaluation_harness"}
+        )
+
+
+def test_prepare_root_context_freezes_profile_for_children() -> None:
+    pytest.importorskip("faiss")
+    from src.agents.idea_agent.agent.mcts import MemoryGuidedMCTS
+
+    mcts = MemoryGuidedMCTS.__new__(MemoryGuidedMCTS)
+
+    prepared = MemoryGuidedMCTS.prepare_root_context(
+        mcts,
+        "battery degradation",
+        {
+            "root_domains": ["materials_science"],
+            "components": [],
+        },
+    )
+
+    assert prepared["scientific_intervention_profile"]["profile_id"] == "physical_materials_chemical"
+    assert prepared["discipline_resolution"]["primary_discipline"] == "materials_science"
+
+
+def test_explicit_algorithm_component_is_preserved_for_non_cs_input() -> None:
+    state = build_root_state(
+        "materials fixture with an explicit machine-learning surrogate model",
+        {
+            "discipline_resolution": _resolution("materials_science"),
+            "components": ["backbone_model"],
+        },
+        CaptureIdeaState,
+    )
+
+    assert state.scientific_intervention["profile_id"] == "physical_materials_chemical"
+    assert state.components == ["backbone_model"]
+
+
+def test_non_cs_legacy_algorithm_component_is_dropped_without_explicit_algorithm_idea() -> None:
+    state = build_root_state(
+        "materials fixture",
+        {
+            "discipline_resolution": _resolution("materials_science"),
+            "components": ["backbone_model", "candidate_mechanism"],
+        },
+        CaptureIdeaState,
+    )
+
+    assert "backbone_model" not in state.components
+    assert "candidate_mechanism" in state.components
+
+
+def test_non_cs_simulation_word_does_not_count_as_explicit_algorithm_semantics() -> None:
+    state = build_root_state(
+        "materials simulation fixture",
+        {
+            "discipline_resolution": _resolution("materials_science"),
+            "components": ["backbone_model", "candidate_mechanism"],
+            "method": "Use physical simulation to inspect the reaction pathway.",
+        },
+        CaptureIdeaState,
+    )
+
+    assert "backbone_model" not in state.components
+    assert "candidate_mechanism" in state.components
+
+
+def test_invalid_contribution_mode_falls_back_to_profile_default() -> None:
+    profile = get_scientific_intervention_profile("clinical_health")
+    assert profile is not None
+    payload = build_scientific_intervention_payload(
+        profile,
+        profile.default_component_names(),
+        {},
+        {"contribution_mode": "not_a_clinical_mode"},
+    )
+
+    assert payload["contribution_mode"] == profile.contribution_modes[0].mode_id
+
+
+def test_legacy_idea_contract_loads_without_intervention_payload() -> None:
+    idea = normalize_idea_contract(
+        {
+            "title": "Legacy title",
+            "abstract": "Legacy abstract",
+            "core_contribute": "Legacy contribution",
+            "methodology": "Legacy method",
+            "components": ["legacy_component"],
+        },
+        allow_legacy=True,
+    )
+
+    assert idea["core_contribution"] == "Legacy contribution"
+    assert idea["method"] == "Legacy method"
+    assert idea["scientific_intervention"] == {}