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".*?", "", 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())