agentinputlab 0.1.0a1__py3-none-any.whl

workers/decomp/live.py

@@ -0,0 +1,137 @@
+"""Isolated pinned-native DecomP driver with an explicit host callback seam."""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib
+import importlib.metadata
+import json
+import os
+import sys
+import traceback
+import urllib.parse
+import urllib.request
+from pathlib import Path
+from uuid import uuid4
+
+from agentinputlab.contracts.serialization import content_hash
+
+from . import driver
+
+
+def failure_response(exc, checkout):
+    """Expose source locations/types, never raw exception text or provider bodies."""
+    result = {"status":"error","failure_code":exc.code,"message":exc.public_message}
+    cause = exc.__cause__
+    if cause is not None:
+        result["upstream_error_type"] = type(cause).__name__
+        frames = []
+        for frame in traceback.extract_tb(cause.__traceback__)[-16:]:
+            try:
+                relative = Path(frame.filename).resolve().relative_to(Path(checkout).resolve())
+            except ValueError:
+                continue
+            if relative.as_posix().startswith("src/decomp/"):
+                frames.append({"file":relative.as_posix(),"line":frame.lineno,"function":frame.name})
+        result["upstream_source_frames"] = frames
+    return result
+
+
+class Callback:
+    def __init__(self, url, key_env, request_id, checkout, policy):
+        parsed = urllib.parse.urlparse(url)
+        if (parsed.scheme != "http" or parsed.hostname != "127.0.0.1" or parsed.port is None
+                or parsed.path != "/callback" or parsed.username or parsed.password or parsed.query or parsed.fragment):
+            raise driver.DriverError("CONFIGURATION_INVALID", "callback must use numeric loopback")
+        if not key_env.isidentifier() or not os.environ.get(key_env):
+            raise driver.DriverError("CONFIGURATION_INVALID", "callback credential unavailable")
+        self.url, self.key = url, os.environ[key_env]
+        self.request_id, self.checkout, self.policy, self.attested = request_id, checkout, policy, False
+
+    def attest(self):
+        for name, module in tuple(sys.modules.items()):
+            if name.startswith("decomp."):
+                location = getattr(module, "__file__", None)
+                if location and not Path(location).resolve().is_relative_to(self.checkout.root / "src"):
+                    raise driver.DriverError("IMPORT_STATE_UNSAFE", "native module escaped checkout")
+        versions = {}
+        for name, expected in self.policy["live_required_versions"].items():
+            distribution = importlib.metadata.distribution(name)
+            if distribution.version != expected:
+                raise driver.DriverError("DEPENDENCY_MISMATCH", "native worker dependency version differs")
+            import_name = {"jsonnet": "_jsonnet", "python-dateutil": "dateutil"}.get(name, name.replace("-", "_"))
+            dependency = importlib.import_module(import_name)
+            origin = getattr(dependency, "__file__", None)
+            if not origin or not any(Path(distribution.locate_file(file)).resolve() == Path(origin).resolve()
+                                     for file in (distribution.files or ())):
+                raise driver.DriverError("DEPENDENCY_ORIGIN_MISMATCH", "native dependency import escaped distribution")
+            versions[name] = distribution.version
+        def sha(path):
+            return hashlib.sha256(path.read_bytes()).hexdigest()
+        value = {"schema": "agentinputlab.decomp.live-attestation.v1", "driver_sha256": sha(Path(driver.__file__)),
+            "live_sha256": sha(Path(__file__)), "compatibility_manifest_sha256": self.checkout.manifest_sha256,
+            "required_versions": versions,
+            "english_stopwords_sha256": sha(Path(os.environ["NLTK_DATA"])/"corpora/stopwords/english"),
+            "source_files_verified": True, "import_origins_verified": True}
+        self.call("attest", value)
+        self.attested = True
+
+    def call(self, kind, payload):
+        raw = {"request_id": self.request_id, "call_id": uuid4().hex, "kind": kind, "payload": payload}
+        request = urllib.request.Request(self.url, data=json.dumps(raw, allow_nan=False).encode(),
+            headers={"Authorization": "Bearer " + self.key, "Content-Type": "application/json"})
+        result, failed = None, False
+        try:
+            with urllib.request.build_opener(urllib.request.ProxyHandler({})).open(request, timeout=240) as response:
+                body = response.read(4 * 1024 * 1024 + 1)
+            if len(body) > 4 * 1024 * 1024:
+                raise ValueError("callback response byte limit")
+            result = json.loads(body)
+            if result.get("ok") is not True:
+                raise ValueError("host callback rejected")
+        except Exception:
+            failed = True
+        if failed:
+            raise driver.DriverError("HOST_CALLBACK_FAILED", "bound native completion failed; no retry")
+        return result["payload"]
+
+    def complete(self, **parameters):
+        if not self.attested:
+            self.attest()
+        return self.call("model", parameters)
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description=__doc__)
+    for key in ("checkout", "callback-url", "callback-key-env"):
+        parser.add_argument("--" + key, required=True)
+    parser.add_argument("--planner-component", action="store_true")
+    args = parser.parse_args(argv)
+    try:
+        raw = sys.stdin.buffer.readline(driver.MAX_REQUEST_BYTES + 1)
+        if len(raw) > driver.MAX_REQUEST_BYTES or not raw or sys.stdin.buffer.read(1):
+            raise driver.DriverError("INVALID_REQUEST", "one bounded JSON line required")
+        envelope = json.loads(raw)
+        if set(envelope) != {"request_id", "request"} or content_hash(envelope["request"]) != envelope["request_id"]:
+            raise driver.DriverError("INVALID_REQUEST", "native request identity differs")
+        request = dict(envelope["request"])
+        request.pop("execution_budget")
+        request.pop("seed")
+        native = driver.DecompDriver(environment={driver.UPSTREAM_ENV: args.checkout})
+        checkout = native._checkout()
+        callback = Callback(args.callback_url, args.callback_key_env, envelope["request_id"], checkout, checkout.manifest)
+        native.native_completion = callback.complete
+        result = native.run_planner(request) if args.planner_component else native.run(request)
+        if not callback.attested:
+            raise driver.DriverError("NATIVE_MODEL_NOT_CALLED", "no native model call was made")
+        response = {"status": "ok", "payload": result}
+    except driver.DriverError as exc:
+        response = failure_response(exc, args.checkout)
+    except Exception as exc:
+        response = {"status": "error", "failure_code": "WORKER_INTERNAL_FAILURE", "error_type": type(exc).__name__}
+    sys.stdout.write(json.dumps(response, sort_keys=True, allow_nan=False) + "\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

workers/decomp/runtime.py

@@ -0,0 +1,231 @@
+"""Core bridge adapter for the pinned DecomP worker driver."""
+
+from __future__ import annotations
+
+import hashlib
+import threading
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+from typing import Any
+
+from agentinputlab.algorithms.decompose.decomp.worker_bridge import (
+    DecompFrontierEvent,
+    DecompGraphNode,
+    DecompParticipantCall,
+    DecompWorkerRequest,
+    DecompWorkerResponse,
+    validate_decomp_full_response,
+)
+from agentinputlab.contracts import AlgorithmOutputError, ExternalDependencyError
+from agentinputlab.contracts.serialization import to_jsonable
+
+from .driver import DEFAULT_MANIFEST, UPSTREAM_COMMIT, DecompDriver, DriverError
+
+_UPSTREAM_PROCESS_STATE_LOCK = threading.RLock()
+
+
+class PinnedDecompRuntime:
+    """Adapt :class:`DecompDriver` to ``DecompWorkerRuntime`` without a fallback."""
+
+    def __init__(
+        self,
+        *,
+        manifest_path: Path = DEFAULT_MANIFEST,
+        environment: Mapping[str, str] | None = None,
+    ) -> None:
+        self.driver = DecompDriver(
+            manifest_path=manifest_path,
+            environment=environment,
+        )
+
+    def fingerprint(self) -> Mapping[str, Any]:
+        try:
+            with _UPSTREAM_PROCESS_STATE_LOCK:
+                upstream = self.driver.smoke_upstream_core()
+            driver_sha = _sha256_file(Path(__file__).with_name("driver.py"))
+            adapter_sha = _sha256_file(Path(__file__))
+        except DriverError as exc:
+            raise ExternalDependencyError(
+                f"pinned DecomP runtime identity failed with {exc.code}"
+            ) from exc
+        return {
+            "worker_id": "agentinputlab.decomp.pinned.in_process.v1",
+            "execution_mode": "in_process_external_environment",
+            "concurrency_mode": "process_global_serial_rlock",
+            "upstream_revision": UPSTREAM_COMMIT,
+            "upstream_symbol": upstream["symbol"],
+            "compatibility_manifest_sha256": upstream["manifest_sha256"],
+            "driver_sha256": driver_sha,
+            "runtime_adapter_sha256": adapter_sha,
+        }
+
+    def run(self, request: DecompWorkerRequest) -> DecompWorkerResponse:
+        if not isinstance(request, DecompWorkerRequest):
+            raise TypeError("PinnedDecompRuntime requires DecompWorkerRequest")
+        request_mapping = {
+            "case_id": request.case_id,
+            "question": request.question,
+            "paras": list(request.paras),
+            "paragraph_ids": list(request.paragraph_ids),
+            "context_hash": request.context_hash,
+            "config_artifact_id": request.config_artifact_id,
+            "backend_binding": to_jsonable(request.backend_binding),
+            "max_steps": request.max_steps,
+            "upstream_revision": request.upstream_revision,
+            "schema_version": request.schema_version,
+        }
+        try:
+            # Upstream mutates process-global CWD/sys.path while importing its
+            # pinned package, so all in-process identities share one serial lock.
+            with _UPSTREAM_PROCESS_STATE_LOCK:
+                raw = self.driver.run(request_mapping)
+        except DriverError as exc:
+            error_type = (
+                AlgorithmOutputError
+                if exc.code
+                in {
+                    "UPSTREAM_OUTPUT_INVALID",
+                    "USAGE_ACCOUNTING_UNAVAILABLE",
+                }
+                else ExternalDependencyError
+            )
+            raise error_type(f"pinned DecomP driver failed with {exc.code}") from exc
+        response = _parse_response(raw)
+        validate_decomp_full_response(response)
+        return response
+
+
+def _parse_response(value: Mapping[str, Any]) -> DecompWorkerResponse:
+    if not isinstance(value, Mapping):
+        raise AlgorithmOutputError("DecomP driver response must be a mapping")
+    try:
+        nodes = tuple(
+            DecompGraphNode(
+                node_id=_text(item, "node_id", "node"),
+                question=_text(item, "question", "node", allow_empty=True),
+                answer=_text(item, "answer", "node", allow_empty=True),
+                handler=_text(item, "handler", "node", allow_empty=True),
+                depth=_nonnegative_integer(item.get("depth"), "node.depth"),
+            )
+            for item in _mapping_sequence(value.get("nodes"), "nodes")
+        )
+        edges = tuple(_edge(item) for item in _sequence(value.get("dependency_edges"), "edges"))
+        participant_calls = tuple(
+            DecompParticipantCall(
+                index=_nonnegative_integer(item.get("index"), "participant_call.index"),
+                participant=_text(item, "participant", "participant_call"),
+                input_state_id=_text(item, "input_state_id", "participant_call"),
+                output_state_id=_text(item, "output_state_id", "participant_call"),
+                command=_text(item, "command", "participant_call", allow_empty=True),
+            )
+            for item in _mapping_sequence(value.get("participant_calls"), "participant_calls")
+        )
+        frontier = tuple(
+            DecompFrontierEvent(
+                index=_nonnegative_integer(item.get("index"), "frontier.index"),
+                state_id=_text(item, "state_id", "frontier"),
+                score=_finite_number(item.get("score"), "frontier.score"),
+                next_command=_text(
+                    item,
+                    "next_command",
+                    "frontier",
+                    allow_empty=True,
+                ),
+                action=_text(item, "action", "frontier"),
+            )
+            for item in _mapping_sequence(value.get("frontier"), "frontier")
+        )
+        usage = value.get("usage")
+        artifacts = value.get("native_artifacts", {})
+        if not isinstance(usage, Mapping) or not isinstance(artifacts, Mapping):
+            raise AlgorithmOutputError("DecomP response usage/artifacts must be mappings")
+        response = DecompWorkerResponse(
+            case_id=_text(value, "case_id", "response"),
+            profile_id=_text(value, "profile_id", "response"),
+            upstream_revision=_text(value, "upstream_revision", "response"),
+            paragraph_ids=tuple(
+                _text_value(item, "response.paragraph_ids")
+                for item in _sequence(value.get("paragraph_ids"), "paragraph_ids")
+            ),
+            context_hash=_text(value, "context_hash", "response"),
+            nodes=nodes,
+            dependency_edges=edges,
+            participant_calls=participant_calls,
+            frontier=frontier,
+            reasoning_chain=_text(value, "reasoning_chain", "response"),
+            final_answer=_text(value, "final_answer", "response", allow_empty=True),
+            termination=_text(value, "termination", "response"),
+            component_only=value.get("component_only", False),
+            usage=dict(usage),
+            schema_version=_text(value, "schema_version", "response"),
+            native_artifacts={str(key): str(item) for key, item in artifacts.items()},
+        )
+    except (KeyError, TypeError, ValueError) as exc:
+        if isinstance(exc, AlgorithmOutputError):
+            raise
+        raise AlgorithmOutputError("DecomP driver response is malformed") from exc
+    return response
+
+
+def _mapping_sequence(value: Any, label: str) -> tuple[Mapping[str, Any], ...]:
+    result = _sequence(value, label)
+    if not all(isinstance(item, Mapping) for item in result):
+        raise AlgorithmOutputError(f"DecomP {label} must contain mappings")
+    return result  # type: ignore[return-value]
+
+
+def _sequence(value: Any, label: str) -> tuple[Any, ...]:
+    if isinstance(value, (str, bytes)) or not isinstance(value, Sequence):
+        raise AlgorithmOutputError(f"DecomP {label} must be a sequence")
+    return tuple(value)
+
+
+def _edge(value: Any) -> tuple[str, str]:
+    edge = _sequence(value, "edge")
+    if len(edge) != 2 or not all(isinstance(item, str) and item for item in edge):
+        raise AlgorithmOutputError("DecomP edge must contain two state IDs")
+    return edge[0], edge[1]
+
+
+def _text(
+    value: Mapping[str, Any],
+    key: str,
+    label: str,
+    *,
+    allow_empty: bool = False,
+) -> str:
+    item = value.get(key)
+    if not isinstance(item, str) or (not allow_empty and not item.strip()):
+        raise AlgorithmOutputError(f"DecomP {label}.{key} must be text")
+    return item
+
+
+def _text_value(value: Any, label: str) -> str:
+    if not isinstance(value, str) or not value.strip():
+        raise AlgorithmOutputError(f"DecomP {label} must contain text")
+    return value
+
+
+def _nonnegative_integer(value: Any, label: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+        raise AlgorithmOutputError(f"DecomP {label} must be a non-negative integer")
+    return value
+
+
+def _finite_number(value: Any, label: str) -> float:
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise AlgorithmOutputError(f"DecomP {label} must be numeric")
+    result = float(value)
+    if result != result or result in {float("inf"), float("-inf")}:
+        raise AlgorithmOutputError(f"DecomP {label} must be finite")
+    return result
+
+
+def _sha256_file(path: Path) -> str:
+    try:
+        return hashlib.sha256(path.read_bytes()).hexdigest()
+    except OSError as exc:
+        raise DriverError("RUNTIME_SOURCE_MISSING", "runtime source file is unavailable") from exc
+
+
+__all__ = ["PinnedDecompRuntime"]

workers/infocqr/README.md

@@ -0,0 +1,106 @@
+# InfoCQR pinned teacher/cache worker
+
+This worker integrates the inference-time material in
+[`smartyfh/InfoCQR@2953c461`](https://github.com/smartyfh/InfoCQR/tree/2953c461aa0c6817b1b7656dbd5168050227b31d)
+without copying upstream source into AgentInputLab.
+
+It supports two bounded paths:
+
+1. checksum-locked replay of the author's QReCC JSONL caches (`rw_zsl`,
+   `rw_fsl`, and the T5-candidate teacher editor cache);
+2. live teacher inference by dynamically loading and directly calling the
+   pinned official `generate_rewrite()` function for zero-shot, four-shot,
+   self-edit, or editor-only prompts.
+
+`self_edit` follows the repository trajectory: official four-shot generation,
+pinned post-processing, then official self-editor generation. `t5_edit` only
+accepts an explicitly supplied initial candidate whose artifact SHA is bound in
+the request; the worker does not claim that candidate came from released
+InfoCQR weights.
+
+## License and source gates
+
+The audited checkout has no `LICENSE`, `COPYING`, or `NOTICE` file. Its source
+and included generation caches therefore remain `NOASSERTION` and are never
+vendored. Execution requires both:
+
+- worker startup with `--acknowledge-noassertion-license`;
+- `source_license_acknowledged=true` in every hashed request.
+
+The worker verifies the exact commit when Git metadata is present, every
+relevant source-file hash in all cases, the README evidence hash, and the
+continued absence of a license file. A GitHub source tarball is identified by
+the complete audited source-hash set.
+
+## Bound experimental identity
+
+Every request binds the QReCC revision/split, conversation source/number/turn,
+ordered `NewContext`, current query, prompt source SHA, teacher deployment
+fingerprint, retriever/corpus fingerprint, corpus ID, cache byte SHA when
+replaying, seed, and model-call/token/cost ceilings. Endpoint and credentials
+are startup-only and cannot be injected through JSONL.
+
+The upstream first-turn scripts copy `Truth_rewrite` when `NewContext` is empty.
+Cached first turns therefore fail closed unless the caller deliberately enables
+`allow_first_turn_truth_rewrite`; live teacher mode calls the official prompt
+function instead and never receives `Truth_rewrite`.
+
+## Verify and run
+
+Verify source plus a manifest-known author cache without importing provider
+SDKs or making a model call:
+
+```bash
+python workers/infocqr/driver.py \
+  --checkout /opt/upstreams/InfoCQR \
+  --known-cache test_rw_fsl \
+  --verify-only
+```
+
+Run live generation against either a hosted OpenAI-compatible API or local
+vLLM endpoint:
+
+```bash
+python workers/infocqr/driver.py \
+  --checkout /opt/upstreams/InfoCQR \
+  --acknowledge-noassertion-license \
+  --backend-config-json "$INFOCQR_BACKEND_CONFIG"
+```
+
+Example configuration:
+
+```json
+{
+  "base_url": "http://127.0.0.1:8000/v1",
+  "api_key_env": "INFOCQR_API_KEY",
+  "model": "Qwen/Qwen2.5-7B-Instruct",
+  "fingerprint": {
+    "provider": "vllm",
+    "model": "Qwen/Qwen2.5-7B-Instruct",
+    "revision": "deployment-or-weight-revision"
+  },
+  "timeout_seconds": 60,
+  "max_output_tokens": 2560,
+  "temperature": 0,
+  "input_cost_per_million": 0,
+  "output_cost_per_million": 0
+}
+```
+
+A custom cache requires all of `--cache-path`, `--cache-artifact-id`,
+`--cache-sha256`, `--cache-profile`, and `--cache-split`.
+
+## Deliberate limits
+
+- The repository publishes T5 training/test scripts but no student checkpoint.
+  This legacy teacher/cache worker keeps its `T5_CHECKPOINT_UNAVAILABLE` gate.
+  The separate [trained student adapter](../../docs/infocqr-student.md) now
+  accepts a caller-mounted, checksum-pinned trained checkpoint and provenance
+  receipt. It executes native source serialization/collation and local T5
+  inference; no generic t5-base, teacher or author cache is substituted.
+- The legacy OpenAI SDK call is replaced only at the provider transport seam.
+  Prompt construction still executes the exact pinned official function.
+- `post_processing.py` exposes only a file-oriented `main`; its exact pinned
+  branch order is transparently reproduced and hash-labeled in the response.
+- Cache/live plumbing and source prompt parity are tested. Paper-result parity
+  is not claimed.

workers/infocqr/__init__.py

@@ -0,0 +1 @@
+"""Pinned external worker for the InfoCQR teacher and author caches."""

workers/infocqr/compatibility_manifest.json

@@ -0,0 +1,84 @@
+{
+  "schema_version": "agentinputlab.infocqr.compatibility.v1",
+  "upstream": {
+    "repository": "https://github.com/smartyfh/InfoCQR.git",
+    "commit": "2953c461aa0c6817b1b7656dbd5168050227b31d",
+    "license_spdx": "NOASSERTION",
+    "license_file_present": false,
+    "license_evidence_path": "README.md",
+    "license_evidence_sha256": "56a86f36169028602eda0fdf2a0ebd893eb3aaf10cfe790d90eabddb0f73d757",
+    "require_clean_checkout": true
+  },
+  "source_files": {
+    "README.md": "56a86f36169028602eda0fdf2a0ebd893eb3aaf10cfe790d90eabddb0f73d757",
+    "requirements.txt": "1e2b9e614b3ac85cbebabc1c94bc1fd92d04fc5817af2af0cf26fadf4ba864dc",
+    "rewrite_chatgpt_zsl.py": "93d6ba61da042f15ed6d506b3d69bac1a16d3e33453b84ec8f6b7317d018defc",
+    "rewrite_chatgpt_inctx.py": "9c447f5292a6c936160ab847d3eb18db4704ea62f3d46a896ef5613aac2ce6a6",
+    "rewrite_chatgpt_editor.py": "5c71071d213ac562651d5577e623f73d0b98ffc3279f2dc1727127e8475d1bba",
+    "rewrite_chatgpt_self_editor.py": "2fba6bb3b24a7b332c7896b89c7ae6480c2d21272f42bad893ee5151c7739373",
+    "post_processing.py": "7201ceaeb16beaaf3af874faf083ce4f64dd630636a2e302edf398cc4da8d3dd",
+    "fuse_rewrite.py": "81f521240d53b8e34de3a806d7f09223b9c8ea39bf9394bbafae9dff957c01f9",
+    "dataset_cleaning.py": "9d4bdd7f8c20b05a1baafce35f725fcffd319a40442a16d2526cd4fd05be968b",
+    "T5QR/T5test.py": "c9c1b78d8147035ea3c300e7b29c791fb171ce399f8c1269a6e1a11b9bc05eb8",
+    "T5QR/T5train.py": "d40bc17e365d9f626fd5bf1fd14fffd3073c0b6772434a78eac6412d6fd2f4de"
+  },
+  "prompt_profiles": {
+    "rw_zsl": {
+      "source_path": "rewrite_chatgpt_zsl.py",
+      "source_sha256": "93d6ba61da042f15ed6d506b3d69bac1a16d3e33453b84ec8f6b7317d018defc",
+      "official_function": "generate_rewrite"
+    },
+    "rw_fsl": {
+      "source_path": "rewrite_chatgpt_inctx.py",
+      "source_sha256": "9c447f5292a6c936160ab847d3eb18db4704ea62f3d46a896ef5613aac2ce6a6",
+      "official_function": "generate_rewrite"
+    },
+    "t5_edit": {
+      "source_path": "rewrite_chatgpt_editor.py",
+      "source_sha256": "5c71071d213ac562651d5577e623f73d0b98ffc3279f2dc1727127e8475d1bba",
+      "official_function": "generate_rewrite"
+    },
+    "self_edit": {
+      "source_path": "rewrite_chatgpt_self_editor.py",
+      "source_sha256": "2fba6bb3b24a7b332c7896b89c7ae6480c2d21272f42bad893ee5151c7739373",
+      "official_function": "generate_rewrite"
+    }
+  },
+  "known_author_caches": {
+    "test_rw_zsl": {
+      "path": "datasets/qrecc/test_chatgpt_ZSL.jsonl",
+      "sha256": "c5304470e0f0399d8f432d9f4701015ca3aad40e56bcb06fcdb8a350efdf7134",
+      "profile": "rw_zsl",
+      "split": "test"
+    },
+    "test_rw_fsl": {
+      "path": "datasets/qrecc/test_chatgpt_ICL.jsonl",
+      "sha256": "9007463f7d6af418ee933d476abb4c449f39f0aa06d2c46662178b0050c777ce",
+      "profile": "rw_fsl",
+      "split": "test"
+    },
+    "test_t5_edit": {
+      "path": "datasets/qrecc/test_chatgpt_editor.jsonl",
+      "sha256": "115993dd58b5307fd411329ccfd3fc4e6ccd10d33116db718e3824cc7d728150",
+      "profile": "t5_edit",
+      "split": "test"
+    },
+    "test_self_edit": {
+      "path": "datasets/qrecc/test_chatgpt_ICL_editor.jsonl",
+      "sha256": "da2778285f9d616bcfb5dff0ca2d0079d5bed54aca8086352135e698b9373f5f",
+      "profile": "self_edit",
+      "split": "test"
+    }
+  },
+  "execution": {
+    "vendored_upstream_source": false,
+    "license_acknowledgement_required_at_startup": true,
+    "license_acknowledgement_required_per_request": true,
+    "official_teacher_function_called": true,
+    "common_support_profile": "controlled_adapter_visible_dialogue_only",
+    "post_processing_compatibility_hash": "7201ceaeb16beaaf3af874faf083ce4f64dd630636a2e302edf398cc4da8d3dd",
+    "t5_student_runtime_enabled": false,
+    "released_t5_checkpoint_present": false,
+    "paper_result_parity_claimed": false
+  }
+}