proactive_code/run_experiment.py

import argparse
import json
import os
import re
import sys
from pathlib import Path


SCRIPT_DIR = Path(__file__).resolve().parent
ROOT_DIR = SCRIPT_DIR.parent
if str(SCRIPT_DIR) not in sys.path:
    sys.path.insert(0, str(SCRIPT_DIR))

from knowledge_retriever import KnowledgeRetriever


DEFAULT_MODELS = [
    "qwen3.6-max",
    "qwen_plus",
    "deepseek_v3",
    "deepseek_r1",
    "llama4_scout",
]

MODEL_CONFIGS = {
    "qwen3.6-max": {
        "display_name": "qwen3.6-max",
        "model_name": "qwen3.6-max-preview",
        "base_url": "https://dashscope.aliyuncs.com/compatible-mode/v1",
        "api_key_env": ["DASHSCOPE_API_KEY", "QWEN_API_KEY"],
        "response_format": True,
        "temperature": 0.0,
        "extra_body": {"enable_thinking": False},
    },
    "qwen_plus": {
        "display_name": "Qwen-Plus",
        "model_name": "qwen-plus",
        "base_url": "https://dashscope.aliyuncs.com/compatible-mode/v1",
        "api_key_env": ["DASHSCOPE_API_KEY", "QWEN_API_KEY"],
        "response_format": True,
        "temperature": 0.0,
    },
    "deepseek_v3": {
        "display_name": "DeepSeek-V3",
        "model_name": "deepseek-chat",
        "base_url": "https://api.deepseek.com",
        "api_key_env": [
            "DEEPSEEK_API_KEY",
            "ZHIZENGZENG_API_KEY",
            "OPENAI_COMPAT_API_KEY",
            "OPENAI_API_KEY",
        ],
        "response_format": True,
        "temperature": 0.0,
    },
    "deepseek_r1": {
        "display_name": "DeepSeek-R1",
        "model_name": "deepseek-reasoner",
        "base_url": "https://api.deepseek.com",
        "api_key_env": [
            "DEEPSEEK_API_KEY",
            "ZHIZENGZENG_API_KEY",
            "OPENAI_COMPAT_API_KEY",
            "OPENAI_API_KEY",
        ],
        "response_format": False,
        "temperature": 0.6,
    },
    "llama4_scout": {
        "display_name": "Llama4-scout",
        "model_name": "llama-4-scout",
        "base_url": "https://api.zhizengzeng.com/v1/",
        "api_key_env": ["ZHIZENGZENG_API_KEY", "OPENAI_COMPAT_API_KEY", "OPENAI_API_KEY"],
        "response_format": False,
        "temperature": 0.0,
    },
}

SETTING_DIRS = {
    "raw_logs_context": "raw_logs_context",
    "static_kb": "static_kb",
    "full_kb": "full_kb",
}


def load_json(path):
    with open(path, "r", encoding="utf-8") as f:
        return json.load(f)


def save_json(data, path):
    path = Path(path)
    path.parent.mkdir(parents=True, exist_ok=True)
    tmp_path = path.with_suffix(path.suffix + ".tmp")
    with tmp_path.open("w", encoding="utf-8") as f:
        json.dump(data, f, indent=2, ensure_ascii=False)
        f.flush()
        os.fsync(f.fileno())
    tmp_path.replace(path)


def clean_json_response(content):
    content = (content or "").strip()
    content = re.sub(r"<think>.*?</think>", "", content, flags=re.DOTALL).strip()

    match = re.search(r"```json(.*?)```", content, re.DOTALL | re.IGNORECASE)
    if match:
        content = match.group(1).strip()
    else:
        match_plain = re.search(r"```(.*?)```", content, re.DOTALL)
        if match_plain:
            content = match_plain.group(1).strip()

    decoder = json.JSONDecoder()
    try:
        obj, _ = decoder.raw_decode(content)
        if isinstance(obj, dict):
            return json.dumps(obj, ensure_ascii=False)
    except json.JSONDecodeError:
        pass

    for index, char in enumerate(content):
        if char != "{":
            continue
        try:
            obj, _ = decoder.raw_decode(content[index:])
        except json.JSONDecodeError:
            continue
        if isinstance(obj, dict):
            return json.dumps(obj, ensure_ascii=False)

    return content


def coerce_bool(value):
    if isinstance(value, bool):
        return value
    if isinstance(value, str):
        return value.strip().lower() in {"true", "yes", "1"}
    return bool(value)


def resolve_api_key(config, explicit_key):
    if explicit_key:
        return explicit_key
    for env_name in config["api_key_env"]:
        value = os.getenv(env_name)
        if value:
            return value
    names = ", ".join(config["api_key_env"])
    raise RuntimeError(
        f"No API key found. Set one of these environment variables: {names}, "
        "or pass --api-key."
    )


def parse_time(time_full):
    try:
        parts = str(time_full).split()
        return parts[0], parts[1]
    except Exception:
        return "Unknown", "00:00"


def format_raw_logs_context(raw_logs_text):
    text = (raw_logs_text or "").strip()
    text = re.sub(r"^### .*\n", "", text, count=1).strip()
    return "### Recent Raw Historical Activity Memory\n" + text + "\n"


def split_retrieved_context(lines):
    rule_lines = []
    habit_lines = []
    other_lines = []
    for line in lines or []:
        stripped = str(line).strip()
        if stripped.startswith("[Rule "):
            rule_lines.append(stripped)
        elif stripped.startswith("[Habit "):
            habit_lines.append(stripped)
        elif stripped:
            other_lines.append(stripped)
    return rule_lines, habit_lines, other_lines


def format_list_block(lines, empty_text):
    if lines:
        return "\n".join(f"- {line}" for line in lines)
    return empty_text


def format_structured_context(setting, retrieved_context):
    rule_lines, habit_lines, other_lines = split_retrieved_context(retrieved_context)

    if setting == "raw_logs_context":
        return (
            "### Available Structured Knowledge\n"
            "No static rules or long-term habit summaries are provided in this setting.\n"
        )
    if setting == "static_kb":
        static_text = format_list_block(rule_lines + other_lines, "None retrieved for this event.")
        return "### Retrieved Static Rule Context\n" f"{static_text}\n"

    static_text = format_list_block(rule_lines, "None retrieved for this event.")
    habit_text = format_list_block(habit_lines + other_lines, "None retrieved for this event.")
    return (
        "### Retrieved Static Rule Context\n"
        f"{static_text}\n\n"
        "### Retrieved Long-Term Habit Context\n"
        f"{habit_text}\n"
    )


def output_requirements():
    return (
        "Output decision:\n"
        "- Set proactive=true when at least one specific trigger is supported.\n"
        "- Set proactive=false when no specific trigger is supported.\n"
        "- If proactive=true, content must be concise and must name the concrete concern or action.\n"
        "- If proactive=true, decision_basis must briefly state the evidence-based reason for the "
        "intervention. It should identify the trigger type when applicable, such as safety hazard, "
        "anomaly, static-rule violation, short-term deviation, habit omission, habit delay, habit "
        "blockage, habit substitution, habit displacement, or habit conflict.\n"
        "- decision_basis is an evaluation-only grounding field. Do not write a long chain of thought; "
        "write one concise sentence grounded in the current event and available context.\n"
        "- Avoid generic messages such as \"Do you need help?\", \"Is everything okay?\", or \"Would "
        "you like assistance?\" unless tied to a concrete risk, rule violation, anomaly, or deviation.\n\n"
        "Output requirements:\n"
        "- Return a strict JSON object only.\n"
        "- Include the input id exactly.\n"
        "- If proactive=true, content should be a concise user-facing assistance message.\n"
        "- If proactive=true, decision_basis should be a concise grounding statement for the decision.\n"
        "- If proactive=false, content must be an empty string.\n"
        "- If proactive=false, decision_basis must be an empty string.\n\n"
        "JSON format:\n"
        "{\n"
        "  \"id\": \"E001\",\n"
        "  \"proactive\": true,\n"
        "  \"content\": \"Concise assistance message.\",\n"
        "  \"decision_basis\": \"Brief evidence-based reason for the intervention.\"\n"
        "}"
    )


def build_raw_logs_system_prompt():
    return (
        "You are a Proactive Smart Home Assistant.\n"
        "You are in the w/o KB setting. You receive only the current home observation and a short "
        "recent raw historical activity memory. You do not receive static household rules or "
        "long-term habit summaries.\n\n"
        "Decision stance:\n"
        "- Be proactive enough to catch credible needs from the current event, common sense, and "
        "short-term raw memory. Do not be a passive logger.\n"
        "- Be precise, not chatty. A proactive message must name a concrete concern or next action. "
        "If you can only offer a vague check-in, return false.\n"
        "- The current event is the strongest evidence. Recent raw memory is only short-term context; "
        "it is not a rule base and not a long-term habit summary.\n\n"
        "Intervention triggers:\n"
        "1. Safety/common-sense hazards: intervene for falls, fire/flame risk, unattended appliances, "
        "unsafe tool use, health risks, environmental risks, or other credible hazards.\n"
        "2. Anomalous states: intervene when the observation itself is abnormal or concerning, such as "
        "being stationary after a fall, a door left open, an appliance running unattended, or an "
        "unusual state requiring timely checking.\n"
        "3. Short-term deviations from raw memory: intervene for a plausible missed, delayed, blocked, "
        "displaced, or conflicting activity when the current event gives a concrete cue. Useful cues "
        "include still/remains/continues past a relevant time, left/forgot/skipped, unfinished or "
        "unattended state, conflicting location, replacement activity, or explicit absence/delay.\n\n"
        "Non-intervention safeguards:\n"
        "- Return false for ordinary activities, harmless timing variation, normal progress toward a "
        "task, leisure without a concrete issue, or weak speculation.\n"
        "- Do not infer strict personal rules from one or two days of raw logs.\n"
        "- The current event must show risk, omission, delay, blockage, displacement, or conflict.\n\n"
        + output_requirements()
    )


def build_static_kb_system_prompt():
    return (
        "You are a Proactive Smart Home Assistant.\n"
        "You are in the Static KB setting. You receive the current home observation, a short recent "
        "raw historical activity memory, and retrieved static household rules. You do not receive "
        "long-term habit summaries.\n\n"
        "Decision stance:\n"
        "- First judge safety, anomalies, and short-term raw-memory deviations from the current event "
        "and recent raw memory. Then use retrieved static rules as additional explicit constraints.\n"
        "- Static rules expand the reasons to intervene; they must not make you ignore a clear safety "
        "risk, anomaly, or short-term problem already visible from raw evidence.\n"
        "- If no static rule is retrieved, that does not prove the event is normal. Continue using "
        "the current event, common sense, and recent raw memory.\n\n"
        "Intervention triggers:\n"
        "1. Safety/common-sense hazards: intervene for falls, fire/flame risk, unattended appliances, "
        "unsafe tool use, health risks, environmental risks, or other credible hazards.\n"
        "2. Anomalous states: intervene when the observation itself is abnormal or concerning, such as "
        "being stationary after a fall, a door left open, an appliance running unattended, or an "
        "unusual state requiring timely checking.\n"
        "3. Short-term raw-memory deviations: intervene for plausible missed, delayed, blocked, "
        "displaced, or conflicting activity when the current event gives a concrete cue. Do not need "
        "a habit KB for clear short-term problems.\n"
        "4. Static rule violations: intervene when the current event satisfies a retrieved rule's "
        "forbidden, required, deadline, count, duration, or presence condition. For duration/count/"
        "deadline rules, require supporting evidence such as continued activity, elapsed time, missed "
        "deadline, repeated count, or incomplete state. For stove/presence rules, intervene only when "
        "the user is absent, leaving, inattentive, or the appliance/fire is unattended; do not intervene "
        "when the user is clearly present and supervising.\n\n"
        "Non-intervention safeguards:\n"
        "- Return false for ordinary activities, harmless timing variation, normal progress toward a "
        "task, leisure without a concrete issue, or weak speculation.\n"
        "- Do not use raw memory as a long-term habit summary.\n"
        "- Do not trigger a static rule merely because a keyword overlaps; the current event must "
        "semantically satisfy the rule condition.\n\n"
        + output_requirements()
    )


def build_full_kb_system_prompt():
    return (
        "You are a Proactive Smart Home Assistant.\n"
        "You are in the Full KB setting. You receive the current home observation, a short recent raw "
        "historical activity memory, retrieved static household rules, and retrieved long-term habit "
        "context.\n\n"
        "Decision stance:\n"
        "- First judge safety, anomalies, short-term raw-memory deviations, and static rule violations. "
        "Then use retrieved habit context as additional evidence for long-term routine deviations.\n"
        "- Static rules and habit context expand the reasons to intervene; they must not suppress a "
        "clear safety risk, anomaly, rule violation, or short-term problem already visible.\n"
        "- Habit context is probabilistic. A retrieved habit is background evidence, not a reminder list.\n\n"
        "Intervention triggers:\n"
        "1. Safety/common-sense hazards: intervene for falls, fire/flame risk, unattended appliances, "
        "unsafe tool use, health risks, environmental risks, or other credible hazards.\n"
        "2. Anomalous states: intervene when the observation itself is abnormal or concerning, such as "
        "being stationary after a fall, a door left open, an appliance running unattended, or an "
        "unusual state requiring timely checking.\n"
        "3. Static rule violations: intervene when the current event satisfies a retrieved rule's "
        "forbidden, required, deadline, count, duration, or presence condition. For duration/count/"
        "deadline rules, require supporting evidence such as continued activity, elapsed time, missed "
        "deadline, repeated count, or incomplete state. For stove/presence rules, intervene only when "
        "the user is absent, leaving, inattentive, or the appliance/fire is unattended; do not intervene "
        "when the user is clearly present and supervising.\n"
        "4. Short-term raw-memory deviations: intervene for plausible missed, delayed, blocked, "
        "displaced, or conflicting activity when the current event gives a concrete cue.\n"
        "5. Long-term habit deviations: intervene if the current event and retrieved habit context "
        "together indicate omission, delay, overdue status, substitution, blockage, displacement, or "
        "conflict. Retrieved lines such as possibly missed, overdue, blocked, displaced, conflicting "
        "location, or replacement activity are strong supporting evidence when they fit the event.\n\n"
        "Habit safeguards:\n"
        "- A habit match alone is not a reason to intervene.\n"
        "- Treat current routine, nearby routine transition, upcoming routine, or same-location routine "
        "as normal context unless the current event also shows omission, delay, blockage, substitution, "
        "displacement, conflict, or risk.\n"
        "- If the current event is consistent with a retrieved habit or shows normal progress toward it, "
        "remain silent.\n"
        + output_requirements()
    )


def build_system_prompt(setting):
    if setting == "raw_logs_context":
        return build_raw_logs_system_prompt()
    if setting == "static_kb":
        return build_static_kb_system_prompt()
    if setting == "full_kb":
        return build_full_kb_system_prompt()
    raise ValueError(f"Unknown setting: {setting}")


def build_messages(args, item, retriever=None, raw_logs_text=None):
    entry_id = item.get("id", "")
    time_full = item.get("time", "")
    location = item.get("location", "")
    event_desc = item.get("event", "")
    current_day, current_time = parse_time(time_full)

    base_event = (
        f"ID: {entry_id}\n"
        f"Time: {time_full}\n"
        f"Location: {location}\n"
        f"Event Observation: {event_desc}"
    )

    retrieved_context = []
    if retriever is not None:
        retrieved_context = retriever.get_relevant_context(
            current_day,
            current_time,
            location,
            event_desc,
        )

    user_input = (
        f"{format_raw_logs_context(raw_logs_text)}\n"
        f"{format_structured_context(args.setting, retrieved_context)}\n"
        f"### Current Event\n{base_event}"
    )

    return (
        [
            {"role": "system", "content": build_system_prompt(args.setting)},
            {"role": "user", "content": user_input},
        ],
        retrieved_context,
    )


def create_client(args, config):
    try:
        from openai import OpenAI
    except ModuleNotFoundError as exc:
        raise RuntimeError(
            "The Python package 'openai' is required for API runs. "
            "Run this script in the conda environment used by the experiment scripts, "
            "or install the package in the current environment."
        ) from exc

    api_key = resolve_api_key(config, args.api_key)
    base_url = args.base_url or config["base_url"]
    return OpenAI(api_key=api_key, base_url=base_url)


def call_model(client, config, args, messages):
    kwargs = {
        "model": args.model_name or config["model_name"],
        "messages": messages,
        "temperature": args.temperature if args.temperature is not None else config["temperature"],
    }
    if config["response_format"] and not args.disable_json_mode:
        kwargs["response_format"] = {"type": "json_object"}
    if config.get("extra_body"):
        kwargs["extra_body"] = config["extra_body"]
    response = client.chat.completions.create(**kwargs)
    return response.choices[0].message.content


def is_fatal_api_error(exc):
    text = str(exc).lower()
    fatal_markers = [
        "401",
        "403",
        "access_denied",
        "access denied",
        "unauthorized",
        "permission",
        "forbidden",
        "invalid api key",
        "invalid_api_key",
        "model not found",
        "model_not_found",
        "does not exist",
    ]
    return any(marker in text for marker in fatal_markers)


def output_path_for(args):
    filename = f"experiment_{args.model}_{args.setting}.json"
    return Path(args.output_root) / SETTING_DIRS[args.setting] / filename


def load_existing_results(path, retry_errors):
    path = Path(path)
    if not path.exists():
        return [], set()
    data = load_json(path)
    done_ids = set()
    for item in data:
        if "id" not in item:
            continue
        if retry_errors and "error" in item:
            continue
        done_ids.add(item["id"])
    if retry_errors:
        data = [item for item in data if not ("error" in item and "id" in item)]
    return data, done_ids


def create_retriever(args):
    if args.setting == "raw_logs_context":
        return None
    if args.setting == "static_kb":
        return KnowledgeRetriever(args.static_kb, None)
    return KnowledgeRetriever(args.static_kb, args.habit_kb)


def normalize_text_field(value):
    if value is None:
        return ""
    if isinstance(value, str):
        return value.strip()
    return str(value).strip()


def parse_model_decision(raw_content):
    cleaned = clean_json_response(raw_content)
    decision = json.loads(cleaned)
    proactive = coerce_bool(decision.get("proactive", False))
    content = normalize_text_field(decision.get("content", decision.get("proposed_action", "")))
    decision_basis = normalize_text_field(decision.get("decision_basis", ""))
    if not proactive:
        content = ""
        decision_basis = ""
    return decision, proactive, content, decision_basis


def build_result_entry(args, item, proactive, proposed_action, decision_basis):
    return {
        "id": item.get("id"),
        "model": args.model,
        "setting": args.setting,
        "input_time": item.get("time", ""),
        "input_location": item.get("location", ""),
        "input_event": item.get("event", ""),
        "proactive": proactive,
        "proposed_action": proposed_action,
        "decision_basis": decision_basis,
    }


def run_single_experiment(args):
    config = MODEL_CONFIGS[args.model]
    test_data = load_json(args.test_file)
    output_path = output_path_for(args)

    existing_results, done_ids = load_existing_results(output_path, args.retry_errors)
    results = list(existing_results) if args.resume else []
    if not args.resume:
        done_ids = set()

    with open(args.raw_logs_context, "r", encoding="utf-8") as f:
        raw_logs_text = f.read()

    retriever = create_retriever(args)
    client = None if args.dry_run else create_client(args, config)

    print(">>> HomeActEval experiment")
    print(f">>> Model: {config['display_name']} ({args.model})")
    print(f">>> Setting: {args.setting}")
    print(f">>> Test file: {args.test_file}")
    print(f">>> Raw logs context file: {args.raw_logs_context}")
    print(f">>> Output: {output_path}")
    print(f">>> Resume: {args.resume}; already completed: {len(done_ids)}")

    processed_now = 0
    consecutive_errors = 0
    for index, item in enumerate(test_data, start=1):
        entry_id = item.get("id")
        if entry_id in done_ids:
            continue
        if args.limit is not None and processed_now >= args.limit:
            break

        messages, retrieved_context = build_messages(args, item, retriever, raw_logs_text)

        if args.dry_run:
            print("\n=== DRY RUN PROMPT ===")
            print(json.dumps(messages, indent=2, ensure_ascii=False))
            print("=== END DRY RUN ===")
            return

        print(f"[{index}/{len(test_data)}] Processing {entry_id}...", end="", flush=True)
        raw_content = None
        last_error = None
        try:
            raw_content = call_model(client, config, args, messages)
            decision, proactive, proposed_action, decision_basis = parse_model_decision(raw_content)
            result_entry = build_result_entry(
                args=args,
                item=item,
                proactive=proactive,
                proposed_action=proposed_action,
                decision_basis=decision_basis,
            )

            if decision.get("id") not in {None, entry_id}:
                result_entry["model_returned_id"] = decision.get("id")
            if proactive and not decision_basis:
                result_entry["parse_warning"] = "Missing decision_basis for proactive=true."
            if args.save_retrieved_context:
                result_entry["retrieved_context"] = retrieved_context
            if args.save_raw_response:
                result_entry["raw_response"] = raw_content

            results.append(result_entry)
            done_ids.add(entry_id)
            processed_now += 1
            consecutive_errors = 0
            print(f" Done. Proactive: {proactive}")
        except Exception as exc:
            last_error = exc
            result_entry = {
                "id": entry_id,
                "model": args.model,
                "setting": args.setting,
                "input_time": item.get("time", ""),
                "input_location": item.get("location", ""),
                "input_event": item.get("event", ""),
                "decision_basis": "",
                "error": str(exc),
            }
            if args.save_raw_response and raw_content:
                result_entry["raw_response"] = raw_content
            results.append(result_entry)
            done_ids.add(entry_id)
            processed_now += 1
            consecutive_errors += 1
            print(f" Error: {exc}")

        save_json(results, output_path)

        if "error" in results[-1]:
            if last_error is not None and is_fatal_api_error(last_error):
                print(
                    "\nFatal API/access error detected. Stopping early to avoid "
                    "writing the same error for the remaining benchmark items."
                )
                print("After fixing the API key/model access/model name, rerun with --resume --retry-errors.")
                break
            if consecutive_errors >= args.max_consecutive_errors:
                print(
                    f"\nReached {consecutive_errors} consecutive errors. Stopping early. "
                    "Inspect the output before resuming."
                )
                print("After fixing the issue, rerun with --resume --retry-errors.")
                break

    save_json(results, output_path)
    print(f"\nExperiment finished or paused. Results saved to: {output_path}")
    print(f"Current records in output: {len(results)}")


def selected_values(value, all_values):
    if value == "all":
        return list(all_values)
    return [value]


def run_experiment(args):
    requested_models = selected_values(args.model, DEFAULT_MODELS)
    requested_settings = selected_values(args.setting, SETTING_DIRS.keys())
    original_model = args.model
    original_setting = args.setting

    for model in requested_models:
        for setting in requested_settings:
            args.model = model
            args.setting = setting
            run_single_experiment(args)

    args.model = original_model
    args.setting = original_setting


def parse_args():
    parser = argparse.ArgumentParser(
        description=(
            "Run HomeActEval proactive-interaction experiments with the released "
            "decision policy and decision_basis output field."
        )
    )
    parser.add_argument("--model", choices=DEFAULT_MODELS + ["all"], required=True)
    parser.add_argument(
        "--setting",
        choices=sorted(SETTING_DIRS.keys()) + ["all"],
        required=True,
        help="Evaluate raw_logs_context, static_kb, and full_kb settings.",
    )
    parser.add_argument("--test-file", default=str(ROOT_DIR / "knowledgeBase" / "test_Bench.json"))
    parser.add_argument("--static-kb", default=str(ROOT_DIR / "knowledgeBase" / "staticKB.json"))
    parser.add_argument(
        "--habit-kb",
        default=str(ROOT_DIR / "knowledgeBase" / "extracted_stable_habits_gpt4o.json"),
    )
    parser.add_argument(
        "--raw-logs-context",
        default=str(
            ROOT_DIR
            / "results"
            / "raw_logs_context"
            / "context_recent_days.txt"
        ),
    )
    parser.add_argument("--output-root", default=str(ROOT_DIR / "results"))
    parser.add_argument("--api-key", default=None, help="API key override. Prefer env vars.")
    parser.add_argument("--base-url", default=None, help="Base URL override.")
    parser.add_argument("--model-name", default=None, help="Provider model name override.")
    parser.add_argument("--temperature", type=float, default=None)
    parser.add_argument("--limit", type=int, default=None, help="Process only N new items per run.")
    parser.add_argument(
        "--max-consecutive-errors",
        type=int,
        default=5,
        help="Stop after this many consecutive non-fatal errors.",
    )
    parser.add_argument("--resume", action="store_true", help="Continue from an existing output file.")
    parser.add_argument("--retry-errors", action="store_true", help="Reprocess existing error records.")
    parser.add_argument("--dry-run", action="store_true", help="Print the first prompt without API calls.")
    parser.add_argument("--disable-json-mode", action="store_true")
    parser.add_argument("--save-raw-response", action="store_true")
    parser.add_argument("--save-retrieved-context", action="store_true")
    return parser.parse_args()


if __name__ == "__main__":
    run_experiment(parse_args())