qwen-sci 0.2.2__py3-none-any.whl

src/agents/idea_agent/run.py

@@ -0,0 +1,276 @@
+import os
+import traceback
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, Optional, Any
+
+from omegaconf import OmegaConf
+
+from src.agents.idea_agent.agent.artifacts import artifact_set
+from src.agents.idea_agent.agent.ligagent import LigAgent
+from src.agents.idea_agent.utils.core.ablation_inputs import (
+    ingest_ablation_results_if_available,
+)
+from src.agents.idea_agent.utils.core.logger import get_logger, init_logger
+from src.agents.idea_agent.utils.core.config_loader import (
+    get_config_value,
+    load_idea_agent_config,
+    load_project_config,
+)
+from src.agents.idea_agent.utils.core.json_utils import read_json_file
+from src.agents.idea_agent.utils.core.run_inputs import clean_optional_text, load_topic, resolve_run_inputs
+from src.agents.idea_agent.utils.workflow.idea_contract import (
+    normalize_idea_contract,
+    normalize_mature_ideas,
+    mature_idea_legacy_text,
+)
+from src.agents.idea_agent.utils.workflow.ligagent_flow import run_agent_loop
+from src.pipeline.survey_idea_loader import (
+    SurveyIdeaContext,
+    SurveyIdeaLoadError,
+    load_survey_idea_context,
+)
+from src.research_run_ids import create_research_run_id
+
+DEFAULT_OUTPUT_ROOT = Path(__file__).resolve().parent / "runs"
+IDEA_AGENT_ROOT = Path(__file__).resolve().parent
+
+def _load_previous_idea_candidate() -> Optional[Dict[str, Any]]:
+    previous_candidate_path = clean_optional_text(os.getenv("IDEA_AGENT_PREVIOUS_CANDIDATE_PATH"))
+    if not previous_candidate_path:
+        return None
+    payload = read_json_file(Path(previous_candidate_path))
+    return normalize_idea_contract(payload, allow_legacy=True, keep_extra=True)
+
+
+def _resolve_runtime_survey_config(
+    survey_config: Optional[object],
+    survey_context: Optional[SurveyIdeaContext],
+) -> tuple[Optional[object], Optional[str]]:
+    if survey_context is None:
+        return None, None
+    if survey_config is None:
+        fallback_project_config = load_project_config(
+            str(Path(__file__).resolve().parents[2] / "config" / "default.yaml")
+        )
+        survey_config = fallback_project_config.get("survey")
+    runtime_config = OmegaConf.create(OmegaConf.to_container(survey_config, resolve=False))
+    base_dir = survey_context.base_dir
+    OmegaConf.update(runtime_config, "BasicInfo.topic", survey_context.topic, merge=False)
+    OmegaConf.update(runtime_config, "BasicInfo.survey_run_id", survey_context.survey_run_id, merge=False)
+    OmegaConf.update(
+        runtime_config,
+        "BasicInfo.survey_manifest_path",
+        str(survey_context.manifest_path),
+        merge=False,
+    )
+    OmegaConf.update(runtime_config, "BasicInfo.base_dir", str(base_dir), merge=False)
+    OmegaConf.update(runtime_config, "BasicInfo.save_path", str(base_dir / "survey.md"), merge=False)
+    OmegaConf.update(runtime_config, "BasicInfo.save_json_path", str(base_dir / "survey.json"), merge=False)
+    OmegaConf.update(
+        runtime_config,
+        "BasicInfo.evaluation_save_path",
+        str(base_dir / "evaluation.txt"),
+        merge=False,
+    )
+    OmegaConf.update(
+        runtime_config,
+        "BasicInfo.project_context_artifact_path",
+        str(base_dir / "project_context.json"),
+        merge=False,
+    )
+    return runtime_config, survey_context.topic
+
+
+def _run_topic(
+    topic: str,
+    output_root: str,
+    run_id: str,
+    include_console: bool,
+    rag_config: str,
+    resolved_inputs: Dict[str, object],
+    survey_config: Optional[object] = None,
+    survey_context: Optional[SurveyIdeaContext] = None,
+    idea_config: Optional[object] = None,
+) -> str:
+    run_dir = Path(output_root) / run_id
+    run_dir.mkdir(parents=True, exist_ok=True)
+    (run_dir / "logs").mkdir(parents=True, exist_ok=True)
+    (run_dir / "run_metadata.json").write_text(
+        json.dumps(
+            {
+                "research_run_id": run_id,
+                "topic": topic,
+                "started_at": datetime.now().isoformat(timespec="microseconds"),
+                "survey": (
+                    {
+                        "manifest_path": str(survey_context.manifest_path),
+                        "survey_run_id": survey_context.survey_run_id,
+                        "project_id": survey_context.project_id,
+                        "project_context_fingerprint": survey_context.project_context_fingerprint,
+                        "legacy": survey_context.legacy,
+                    }
+                    if survey_context is not None
+                    else None
+                ),
+            },
+            ensure_ascii=False,
+            indent=2,
+        ),
+        encoding="utf-8",
+    )
+
+    os.environ["IDEA_AGENT_TASK_TOPIC"] = topic
+    print(f"[{topic}] 🏃 Starting run in {run_dir}...")
+
+    init_logger(
+        log_dir=str(run_dir / "logs"),
+        filename="ligagent.log",
+        include_console=include_console,
+        include_timestamp=False,
+        force_reinit=True,
+    )
+    logger = get_logger()
+    logger.info("========================================")
+    logger.info("💡 The research topic is %s", topic)
+
+    config = idea_config if idea_config is not None else load_idea_agent_config()
+    agent = LigAgent(
+        run_dir=run_dir,
+        rag_config=rag_config,
+        config=config,
+        survey_config=survey_config,
+    )
+    if survey_context is not None:
+        artifact_set(agent.artifact, "survey_idea_context", survey_context.to_payload())
+    agent.bootstrap_topic(topic)
+    previous_candidate = _load_previous_idea_candidate()
+    if previous_candidate is not None:
+        artifact_set(agent.artifact, "latest_candidate", previous_candidate)
+
+    mature_ideas = normalize_mature_ideas(
+        resolved_inputs.get("mature_ideas"),
+        legacy_value=resolved_inputs.get("mature_idea"),
+        default_source=str(resolved_inputs.get("mature_idea_source") or "user_input"),
+    )
+    if mature_ideas:
+        artifact_set(agent.artifact, "mature_ideas", mature_ideas)
+    legacy_mature_idea = clean_optional_text(str(resolved_inputs.get("mature_idea") or "")) or mature_idea_legacy_text(mature_ideas)
+    if legacy_mature_idea:
+        artifact_set(agent.artifact, "mature_idea", legacy_mature_idea)
+    artifact_set(agent.artifact, "mature_idea_source", str(resolved_inputs.get("mature_idea_source") or ""))
+    if clean_optional_text(str(resolved_inputs.get("refinement_scope") or "")):
+        artifact_set(
+            agent.artifact,
+            "refinement_scope",
+            clean_optional_text(str(resolved_inputs["refinement_scope"])),
+        )
+    artifact_set(
+        agent.artifact,
+        "refinement_scope_source",
+        str(resolved_inputs.get("refinement_scope_source") or ""),
+    )
+    ingest_ablation_results_if_available(agent, resolved_inputs, logger)
+
+    try:
+        run_agent_loop(agent, logger)
+    except (Exception, KeyboardInterrupt):
+        logger.info("Artifact snapshot at failure: %s", getattr(agent, "artifact", {}))
+        tb = traceback.format_exc()
+        logger.error("Traceback:\n%s", tb)
+        raise RuntimeError(f"Worker failed for topic '{topic}': {tb}") from None
+
+    logger.info("✅ Finished topic '%s'. Results in %s", topic, run_dir)
+    return str(run_dir)
+
+
+def run_idea_workflow(
+    *,
+    config_path: str | None = None,
+    topic: str | None = None,
+    output_root: str | None = None,
+    run_id: str | None = None,
+    survey_manifest: str | None = None,
+    include_console: bool | None = None,
+) -> str:
+    """Run one Idea workflow and return its exact result directory."""
+
+    config = load_idea_agent_config(config_path)
+    project_config = load_project_config(config_path)
+    _apply_env_config(config)
+    requested_manifest = clean_optional_text(
+        survey_manifest
+        or os.getenv("IDEA_AGENT_SURVEY_MANIFEST")
+        or str(get_config_value(config, "run.survey_manifest", "") or "")
+    )
+    survey_context: Optional[SurveyIdeaContext] = None
+    if requested_manifest:
+        survey_context = load_survey_idea_context(requested_manifest)
+    resolved_inputs = resolve_run_inputs(config, default_output_root=str(DEFAULT_OUTPUT_ROOT))
+    requested_topic = clean_optional_text(topic or str(resolved_inputs.get("topic") or ""))
+    if survey_context is not None:
+        if requested_topic and requested_topic.casefold() != survey_context.topic.casefold():
+            raise SurveyIdeaLoadError(
+                "Explicit Idea topic does not match the selected Survey manifest: "
+                f"{requested_topic!r} != {survey_context.topic!r}"
+            )
+        requested_topic = survey_context.topic
+        resolved_inputs["topic_source"] = "survey_manifest"
+    resolved_inputs["topic"] = requested_topic
+    if output_root is not None:
+        resolved_inputs["output_root"] = str(output_root)
+    if survey_context is not None:
+        resolved_inputs["survey_manifest"] = str(survey_context.manifest_path)
+    resolved_topic = load_topic(str(resolved_inputs["topic"]))
+    survey_config, _survey_topic = _resolve_runtime_survey_config(
+        get_config_value(project_config, "survey", None),
+        survey_context,
+    )
+    resolved_output_root = Path(str(resolved_inputs["output_root"])).expanduser()
+    if not resolved_output_root.is_absolute():
+        resolved_output_root = IDEA_AGENT_ROOT / resolved_output_root
+    resolved_output_root.mkdir(parents=True, exist_ok=True)
+    return _run_topic(
+        resolved_topic,
+        str(resolved_output_root),
+        run_id or create_research_run_id(),
+        bool(resolved_inputs["console_logs"]) if include_console is None else include_console,
+        str(resolved_inputs["rag_config"]),
+        resolved_inputs,
+        survey_config,
+        survey_context,
+        config,
+    )
+
+
+def _apply_env_config(config: Optional[object]) -> None:
+    if config is None:
+        return
+    env_map = {
+        "OPENAI_API_KEY": "run.openai_api_key",
+        "OPENAI_BASE_URL": "run.openai_base_url",
+        "S2_API_KEY": "run.s2_api_key",
+        "S2_API_TIMEOUT": "run.s2_api_timeout",
+    }
+    for env_var, key in env_map.items():
+        if env_var not in os.environ:
+            value = get_config_value(config, key, None)
+            if value is not None:
+                os.environ[env_var] = str(value)
+
+def main() -> int:
+    try:
+        result_dir = run_idea_workflow()
+        print(f"✅ completed -> {result_dir}")
+        return 0
+    except SurveyIdeaLoadError as exc:
+        print(f"Survey manifest error: {exc}")
+        return 2
+    except Exception as exc:
+        print(f"❌ failed: {exc}")
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

src/agents/idea_agent/tests/test_advanced_analysis_contract.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from src.agents.idea_agent.utils.workflow.advanced_analysis_contract import (
+    build_advanced_analysis_repair_prompt,
+    validate_advanced_analysis_response,
+)
+
+
+def _valid_response() -> dict:
+    mature_idea = {
+        "idea_id": "seed-1",
+        "title": "A grounded mature idea",
+        "hypothesis": "The stated mechanism changes the outcome.",
+        "scientific_object": "The target physical process",
+        "mechanism": "A bounded causal relation",
+        "assumptions": ["The boundary condition holds."],
+        "evidence_basis": ["SURVEY_ANCHOR: The survey identifies the missing relation."],
+        "target_gap_ids": ["gap-1"],
+        "refinement_scope": "Derive and test the bounded relation.",
+        "falsifier": "A measurement that contradicts the predicted relation.",
+        "counterexamples": ["The relation fails outside the stated boundary."],
+        "retrieval_queries": ["bounded causal relation evidence"],
+        "mechanism_chain": ["object -> mechanism -> observable consequence"],
+        "validation_targets": ["Derive the predicted boundary."],
+        "anchor_policy": "scoped_survey_anchor",
+        "maturity_status": "mature",
+        "idea_source": "survey_gap",
+        "lineage": "Derived from Survey gap-1.",
+        "independence_rationale": "Uses a distinct causal relation and falsifier.",
+    }
+    return {
+        "key_methods": ["Formal causal analysis"],
+        "field_consensus": ["The stated boundary constrains the process."],
+        "existing_problems": ["The causal relation has not been established."],
+        "evaluation_gaps": [{
+            "gap": "No direct discriminating measurement exists.",
+            "why_it_matters": "The mechanism cannot otherwise be validated.",
+            "validation_expectation": "Measure the predicted boundary relation.",
+        }],
+        "future_directions": ["Test the relation in an adjacent regime."],
+        "preserve_current_idea": {"keep_original": False, "reason": ""},
+        "mature_ideas": [mature_idea],
+        "grounded_mature_idea": "The Survey gap supports a bounded causal relation.",
+        "grounded_refinement_scope": "Derive and validate the stated relation.",
+        "root_idea": {
+            "title": "Bounded relation root idea",
+            "abstract": "Derive a bounded causal relation for the target process.",
+            "core_contribution": "A falsifiable boundary relation.",
+            "method": "Construct and test the formal relation.",
+            "risks": "The boundary may not hold in all regimes.",
+            "target_defects": ["unclear_mechanism"],
+            "rationale": "It directly resolves the Survey bottleneck.",
+            "supporting_papers": ["SURVEY_ANCHOR: The Survey identifies the missing relation."],
+        },
+        "divergent_idea_seeds": [],
+        "cross_domain_inspiration": [],
+        "tldr": "Derive and validate the bounded relation identified by the Survey.",
+    }
+
+
+def test_advanced_analysis_contract_accepts_complete_response() -> None:
+    errors = validate_advanced_analysis_response(
+        _valid_response(),
+        require_grounded_fields=True,
+        require_gap_ids=True,
+    )
+
+    assert errors == []
+
+
+def test_advanced_analysis_contract_rejects_the_partial_response_seen_in_run() -> None:
+    response = {
+        "key_methods": [],
+        "existing_problems": [],
+        "future_directions": [],
+        "tldr": "A short concept list",
+    }
+
+    errors = validate_advanced_analysis_response(
+        response,
+        require_grounded_fields=True,
+        require_gap_ids=True,
+    )
+    repair_prompt = build_advanced_analysis_repair_prompt("original evidence prompt", response, errors)
+
+    assert "missing required top-level field: root_idea" in errors
+    assert "key_methods must be a non-empty list of non-empty strings" in errors
+    assert "mature_ideas must be a non-empty list" in errors
+    assert "REQUIRED CONTRACT REPAIR" in repair_prompt
+    assert "root_idea" in repair_prompt

src/agents/idea_agent/tests/test_gap_hypothesis_bridge.py

@@ -0,0 +1,166 @@
+from __future__ import annotations
+
+import pytest
+
+pytest.importorskip("faiss")
+
+from src.agents.idea_agent.agent.mcts import IdeaState
+from src.agents.idea_agent.utils.mcts.mcts_runtime import build_root_state
+from src.agents.idea_agent.utils.workflow.gap_hypothesis_bridge import (
+    build_gap_hypothesis_seeds,
+    build_gap_seed_context,
+    build_gap_seed_status,
+)
+
+
+class CaptureIdeaState:
+    def __init__(self, **payload: object) -> None:
+        self.__dict__.update(payload)
+
+
+def _handoff(*gaps: dict) -> dict:
+    return {
+        "topic": "A scientific topic",
+        "profile_resolution": {"profile_id": "generic_scientific"},
+        "scope": {"research_object": ["target object"]},
+        "gaps": list(gaps),
+        "anchors": [
+            {
+                "anchor_id": "anchor-1",
+                "label": "Survey anchor",
+                "text_excerpt": "The mechanism remains unresolved.",
+                "source_pointer": {"artifact": "survey.md", "json_pointer": "/gaps/0"},
+            }
+        ],
+        "evidence_roles": [
+            {
+                "subhypothesis_id": "SH1",
+                "target_slot": "mechanism",
+                "expected_role": "MECHANISTIC_EVIDENCE",
+            }
+        ],
+    }
+
+
+def _gap(gap_id: str, **overrides: object) -> dict:
+    payload = {
+        "gap_id": gap_id,
+        "subhypothesis_id": "SH1",
+        "gap_kind": "mechanism_gap",
+        "target_slot": "mechanism",
+        "statement": "The mechanism remains unresolved.",
+        "target_object": "target object",
+        "priority": "high",
+        "status": "open",
+        "anchor_ids": ["anchor-1"],
+        "candidate_defect_tags": [],
+    }
+    payload.update(overrides)
+    return payload
+
+
+def test_bridge_keeps_non_excluded_routes_and_marks_constraints() -> None:
+    handoff = _handoff(
+        _gap("core", candidate_defect_tags=["unclear_mechanism"]),
+        _gap("provisional"),
+        _gap("exploratory"),
+        _gap("future", gap_kind="future_work"),
+        _gap("supporting", target_slot="boundary", gap_kind="boundary_gap"),
+        _gap("verification", target_slot="evaluation", gap_kind="benchmark_only"),
+        _gap("excluded", status="rejected"),
+    )
+    triage = {
+        "gaps": [
+            {"gap_id": "core", "eligibility_route": "core_hypothesis", "audit_status": "verified", "existence_confidence": 0.9, "verification_status": "verified"},
+            {"gap_id": "provisional", "eligibility_route": "provisional_hypothesis", "audit_status": "plausible", "existence_confidence": 0.5},
+            {"gap_id": "exploratory", "eligibility_route": "exploratory_frontier", "audit_status": "weakly_supported", "existence_confidence": 0.2},
+            {"gap_id": "future", "eligibility_route": "future_work_seed", "audit_status": "weakly_supported", "existence_confidence": 0.2},
+            {"gap_id": "supporting", "eligibility_route": "supporting_constraint", "audit_status": "verified", "existence_confidence": 0.8},
+            {"gap_id": "verification", "eligibility_route": "verification_only", "audit_status": "verified", "existence_confidence": 0.8},
+            {"gap_id": "excluded", "eligibility_route": "exclude", "audit_status": "contradicted", "existence_confidence": 0.9},
+        ]
+    }
+
+    seeds = build_gap_hypothesis_seeds(handoff, triage)
+    by_gap = {seed["gap_id"]: seed for seed in seeds}
+
+    assert set(by_gap) == {"core", "provisional", "exploratory", "future", "supporting", "verification"}
+    assert by_gap["core"]["seed_status"] == "verified"
+    assert by_gap["future"]["seed_status"] == "exploratory"
+    assert by_gap["supporting"]["seed_status"] == "constraint"
+    assert by_gap["verification"]["seed_status"] == "constraint"
+    assert by_gap["exploratory"]["candidate_defect_tags"] == ["unexplored_gap"]
+
+
+def test_bridge_falls_back_to_topic_seed_without_usable_gap() -> None:
+    seeds = build_gap_hypothesis_seeds(
+        {"topic": "Electrochemical interfaces", "gaps": []},
+        {"gaps": []},
+        topic="Electrochemical interfaces",
+    )
+
+    assert len(seeds) == 1
+    assert seeds[0]["gap_kind"] == "topic_seed"
+    assert seeds[0]["gap_route"] == "exploratory_frontier"
+    assert seeds[0]["fallback"] is True
+    assert build_gap_seed_status(seeds)["fallback_used"] is True
+    assert "Gap-to-Hypothesis Seeds" in build_gap_seed_context(seeds)
+
+
+def test_root_state_keeps_hypothesis_seed_refs_without_expanding_idea_state() -> None:
+    context = {
+        "scientific_intervention_profile": {"profile_id": "generic_scientific"},
+        "gap_hypothesis_seeds": [
+            {
+                "seed_id": "seed-1",
+                "gap_id": "gap-1",
+                "gap_route": "provisional_hypothesis",
+                "seed_status": "provisional",
+                "target_slot": "mechanism",
+            }
+        ],
+        "gap_seed_status": {"seed_count": 1, "admission_mode": "fail_open_except_explicit_exclusion"},
+    }
+
+    root_state = build_root_state("topic", context, CaptureIdeaState)
+    intervention = root_state.scientific_intervention
+
+    assert intervention["hypothesis_seed_refs"] == [
+        {
+            "seed_id": "seed-1",
+            "gap_id": "gap-1",
+            "gap_route": "provisional_hypothesis",
+            "seed_status": "provisional",
+            "target_slot": "mechanism",
+        }
+    ]
+    assert intervention["gap_seed_status"]["seed_count"] == 1
+
+
+def test_idea_state_projects_hypothesis_contract_fields_without_new_required_fields() -> None:
+    state = IdeaState(
+        title="Title",
+        abstract="Abstract",
+        core_contribution="Contribution",
+        method="Method",
+        risks="Risks",
+        tags=["tag"],
+        operator="seed",
+        target_defects=["unexplored_gap"],
+        rationale="Rationale",
+        scientific_intervention={
+            "direction_mode": "bridge_builder",
+            "hypothesis_contract": {
+                "central_hypothesis": "The relation changes under the condition.",
+                "target_gap_ids": ["gap-1"],
+                "claim_scope": "The stated regime.",
+            },
+        },
+    )
+
+    payload = state.to_payload()
+
+    assert payload["direction_mode"] == "bridge_builder"
+    assert payload["central_hypothesis"] == "The relation changes under the condition."
+    assert payload["target_gap_ids"] == ["gap-1"]
+    assert payload["claim_scope"] == "The stated regime."