Upload folder using huggingface_hub

README.md

@@ -1,3 +1,57 @@
----
-license: mit
----
+# InteractComp (Encrypted Release)
+
+InteractComp accompanies the paper **"INTERACTCOMP: Evaluating Search Agents with Ambiguous Queries"** (Deng et al., 2025). The benchmark targets a capability gap in modern search agents: recognizing ambiguity, asking clarifying questions, and only then executing retrieval or answering. Despite rapid progress on fully specified web queries, the paper shows that interaction-centric performance remains stagnant—highlighting InteractComp as both an evaluation suite and a training ground for interactive behaviors.
+
+## What's Inside
+- **210 human-authored tasks** spanning 9 web domains. Each instance includes an intentionally ambiguous question, targeted context for disambiguation, the ground-truth answer, and metadata (`id`, `domain`).
+- **Target-distractor methodology:** curators select a target entity and a popular distractor, write questions using only shared attributes, then provide minimal context that exposes the target's unique traits. Ambiguity can only be resolved through interaction.
+- **Interaction sensitivity:** the paper reports that GPT-5 tops out at **13.73% accuracy** under standard agent settings but exceeds 24% when forced to interact extensively. Supplying the full disambiguating context pushes accuracy to 71.5%, demonstrating that the limiting factor is proactive interaction rather than reasoning.
+- **Longitudinal findings:** over 15 months (May 2024 to Sep 2025) agent accuracy on BrowseComp increases seven-fold, yet InteractComp accuracy stagnates between 6% and 14%, exposing a systemic blind spot in agent development.
+- **Transparent pipeline:** the appendix details a five-step construction process (Target and Distractor selection -> Shared and Distinct attributes -> Ambiguous question -> Context snippets -> Reasoning path) ensuring each item is challenging to shortcut yet straightforward to verify post-interaction.
+
+### Reference
+Please cite the paper when using this release:
+
+> **Mingyi Deng, Lijun Huang, Yani Fan, Jiayi Zhang, et al. (2025)**  
+> *INTERACTCOMP: Evaluating Search Agents with Ambiguous Queries*.
+
+## Repository Layout
+
+```
+main/
+|-- dataset/
+|   `-- InteractComp210.encrypted.jsonl   # Encrypted benchmark samples (public)
+|-- interactcomp_decrypt_jsonl.py     # Decryption utility (public)
+```
+
+## Encryption Scheme
+- A shared canary token (default `InteractComp`) is embedded in the `canary` column of every record.
+- Fields `domain`, `question`, `answer`, and `context` are XOR-encrypted byte-wise using a SHA-256 stream derived from that token, then Base64 encoded.
+
+## Decryption Instructions
+
+1. Prepare Python 3.8+.
+2. Place the encrypted JSONL and the decryption script in your working directory (or provide explicit paths).
+3. Run:
+
+```bash
+python interactcomp_decrypt_jsonl.py \
+  --input InteractComp210.encrypted.jsonl \
+  --output InteractComp210.decrypted.jsonl
+```
+
+Optional flags:
+- `--fields` to target a different comma-separated list of encrypted columns.
+- `--canary-field` if the canary column name differs from `canary`.
+- `--canary-value` to supply the token manually when the canary column has been removed from the encrypted file.
+- `--keep-canary` to retain the canary column in the decrypted output.
+
+### Verifying the Result
+Decrypted records should be valid UTF-8 JSON lines matching the original dataset. Use diff tools or hash comparisons against an authorized plaintext copy. If a record fails to decrypt, confirm that the canary value you used matches the one embedded during encryption.
+
+## Token Management
+- Keep the shared canary token confidential if you want to avoid casual decryption. Rotate it and regenerate the encrypted release if exposure is suspected.
+- Consider producing per-recipient encrypted variants (unique tokens) when auditing access or tracing potential leaks.
+
+## License & Intended Use
+This release is intended for non-commercial research on interactive search agents. Any downstream use should comply with the policies outlined in the accompanying paper and institutional review requirements. Contact the maintainers for questions about redistribution or additional licensing terms.

interactcomp_decrypt_jsonl.py

@@ -0,0 +1,126 @@
+import argparse
+import base64
+import hashlib
+import json
+from pathlib import Path
+from typing import Iterable, List, Optional
+
+
+def derive_key(password: str, length: int) -> bytes:
+    hasher = hashlib.sha256()
+    hasher.update(password.encode())
+    key = hasher.digest()
+    return key * (length // len(key)) + key[: length % len(key)]
+
+
+def xor_decrypt(ciphertext_b64: str, password: str) -> str:
+    if ciphertext_b64 is None:
+        return ciphertext_b64
+    if not ciphertext_b64:
+        return ""
+    encrypted = base64.b64decode(ciphertext_b64)
+    key = derive_key(password, len(encrypted))
+    decrypted = bytes(a ^ b for a, b in zip(encrypted, key))
+    return decrypted.decode("utf-8")
+
+
+def parse_fields(value: str) -> List[str]:
+    return [item.strip() for item in value.split(",") if item.strip()]
+
+
+def iter_jsonl(path: Path) -> Iterable[dict]:
+    with path.open("r", encoding="utf-8") as fh:
+        for lineno, line in enumerate(fh, start=1):
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                yield json.loads(line)
+            except json.JSONDecodeError as exc:
+                raise ValueError(f"Invalid JSON on line {lineno}: {exc}") from exc
+
+
+def write_jsonl(path: Path, records: Iterable[dict]) -> None:
+    with path.open("w", encoding="utf-8") as fh:
+        for record in records:
+            json.dump(record, fh, ensure_ascii=True, separators=(",", ":"))
+            fh.write("\n")
+
+
+def decrypt_dataset(
+    input_path: Path,
+    output_path: Path,
+    fields: List[str],
+    canary_field: str,
+    override_canary: Optional[str],
+    drop_canary: bool,
+) -> None:
+    decrypted_records = []
+    for record in iter_jsonl(input_path):
+        token = override_canary if override_canary is not None else record.get(canary_field)
+        if not token:
+            raise ValueError(
+                f"Missing canary token for record (id={record.get('id')}). "
+                f"Set --canary-value if the column is absent."
+            )
+
+        for field in fields:
+            if field not in record:
+                continue
+            value = record[field]
+            if value is None:
+                continue
+            record[field] = xor_decrypt(value, token)
+        if drop_canary:
+            record.pop(canary_field, None)
+        decrypted_records.append(record)
+
+    write_jsonl(output_path, decrypted_records)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Decrypt InteractComp JSONL encrypted with a shared canary token."
+    )
+    parser.add_argument("--input", required=True, help="Path to the encrypted JSONL.")
+    parser.add_argument("--output", required=True, help="Path for the decrypted JSONL.")
+    parser.add_argument(
+        "--fields",
+        default="domain,question,answer,context",
+        help="Comma-separated fields to decrypt (default: domain,question,answer,context).",
+    )
+    parser.add_argument(
+        "--canary-field",
+        default="canary",
+        help="Field name storing the canary token in the encrypted JSONL (default: canary).",
+    )
+    parser.add_argument(
+        "--canary-value",
+        help="Optional explicit canary token. Use when the encrypted file omits the canary column.",
+    )
+    parser.add_argument(
+        "--keep-canary",
+        action="store_true",
+        help="Keep the canary field in the decrypted output.",
+    )
+    args = parser.parse_args()
+
+    input_path = Path(args.input)
+    output_path = Path(args.output)
+    fields = parse_fields(args.fields) if args.fields else []
+
+    if not fields:
+        raise ValueError("At least one field must be specified for decryption.")
+
+    decrypt_dataset(
+        input_path,
+        output_path,
+        fields,
+        args.canary_field,
+        args.canary_value,
+        drop_canary=not args.keep_canary,
+    )
+
+
+if __name__ == "__main__":
+    main()