agentinputlab 0.1.0a1__py3-none-any.whl

workers/reformer/induction.py

@@ -0,0 +1,457 @@
+"""Bounded pattern induction using a caller-mounted, pinned ReFormeR checkout.
+
+The native extractor's prompt, parser and iterative replacement rule execute
+unchanged. Only its Ollama transport and two broken import paths are bridged.
+Use a dedicated process: upstream imports and logging are process-global.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import math
+import sys
+import threading
+import types
+from collections.abc import Mapping, Sequence
+from contextlib import contextmanager, redirect_stdout
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any
+
+from agentinputlab.contracts import ValidationError
+
+from .driver import (
+    INDUCTION_PATH,
+    PROMPT_MANAGER_PATH,
+    PROMPT_PATH,
+    UPSTREAM_COMMIT,
+    BackendConfig,
+    CompatibilityPolicy,
+    CompletionBackend,
+    Controls,
+    DriverError,
+    OpenAICompatibleBackend,
+    UsageTracker,
+    _canonical_hash,
+    _canonical_json,
+    _load_module,
+    _load_patterns,
+    _loads_strict_json,
+    _sha256_file,
+    load_compatibility_policy,
+    verify_checkout,
+)
+
+RELEASE_ID = "training.reformer.pattern_induction"
+PROMPT_BUILDER_PATH = "reformer/patterns/query_reformulation_prompts.py"
+ADAPTER_REVISION = "native-induction-import-transport-bridge.v1"
+_IMPORT_LOCK = threading.RLock()
+
+
+def _save(path: Path, value: Any) -> None:
+    with path.open("x", encoding="utf-8") as handle:
+        handle.write(_canonical_json(value) + "\n")
+
+
+@dataclass(frozen=True, slots=True)
+class ReFormeRQueryPair:
+    query_id: str
+    original_query: str
+    reformulated_query: str | None = None
+    split: str = "train"
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.split, str) or self.split not in {"train", "validation", "test"}:
+            raise ValidationError("ReFormeR pair split must be train, validation or test")
+        for name in ("query_id", "original_query"):
+            value = getattr(self, name)
+            if not isinstance(value, str) or not value.strip() or len(value) > 48_000:
+                raise ValidationError(f"ReFormeR {name} must be non-empty bounded text")
+            if "\x00" in value:
+                raise ValidationError(f"ReFormeR {name} must not contain NUL")
+        # Held-out queries are used for split isolation, never for induction.
+        # Their callers need not invent unused target rewrites to declare them.
+        if self.split != "train" and self.reformulated_query is None:
+            return
+        value = self.reformulated_query
+        if not isinstance(value, str) or not value.strip() or len(value) > 48_000:
+            raise ValidationError("ReFormeR reformulated_query must be non-empty bounded text")
+        if "\x00" in value:
+            raise ValidationError("ReFormeR reformulated_query must not contain NUL")
+
+
+@dataclass(frozen=True, slots=True)
+class ReFormeRInductionControls:
+    batch_size: int = 2
+    max_patterns: int = 25
+    max_model_calls: int = 8
+    max_tokens: int = 4096
+    max_cost_usd: float = 10.0
+    seed: int = 17
+
+    def __post_init__(self) -> None:
+        for name in ("batch_size", "max_patterns", "max_model_calls", "max_tokens", "seed"):
+            value = getattr(self, name)
+            if (
+                isinstance(value, bool)
+                or not isinstance(value, int)
+                or value < (0 if name == "seed" else 1)
+            ):
+                raise ValidationError(f"ReFormeR induction {name} is invalid")
+        if (
+            isinstance(self.max_cost_usd, bool)
+            or not isinstance(self.max_cost_usd, (int, float))
+            or not math.isfinite(self.max_cost_usd)
+            or self.max_cost_usd < 0
+        ):
+            raise ValidationError("ReFormeR induction max_cost_usd is invalid")
+
+
+def validate_induction_splits(
+    training_pairs: Sequence[ReFormeRQueryPair],
+    held_out_pairs: Sequence[ReFormeRQueryPair],
+) -> dict[str, Any]:
+    """Audit caller-declared splits; does not infer unseen dataset membership."""
+    if not training_pairs or not held_out_pairs:
+        raise ValidationError("ReFormeR fit requires train pairs and declared held-out pairs")
+    seen_ids: set[str] = set()
+    seen_queries: set[str] = set()
+    for pairs, train in ((training_pairs, True), (held_out_pairs, False)):
+        for pair in pairs:
+            if not isinstance(pair, ReFormeRQueryPair):
+                raise ValidationError("ReFormeR fit requires ReFormeRQueryPair records")
+            if (pair.split == "train") is not train:
+                raise ValidationError("ReFormeR training/held-out split assignment is invalid")
+            query = " ".join(pair.original_query.casefold().split())
+            if pair.query_id in seen_ids or query in seen_queries:
+                raise ValidationError("ReFormeR duplicate ID/query or train/held-out overlap")
+            seen_ids.add(pair.query_id)
+            seen_queries.add(query)
+    return {
+        "training_ids": [pair.query_id for pair in training_pairs],
+        "held_out_ids": [pair.query_id for pair in held_out_pairs],
+        "training_sha256": _canonical_hash([asdict(pair) for pair in training_pairs]),
+        "held_out_sha256": _canonical_hash([asdict(pair) for pair in held_out_pairs]),
+        "scope": "caller_declared_records_only",
+        "held_out_used_in_model_prompts": False,
+    }
+
+
+def _blocked_ollama(*args, **kwargs):
+    raise DriverError("UNDECLARED_MODEL_TRANSPORT", "native Ollama transport is not enabled")
+
+
+@contextmanager
+def _native_induction(root: Path):
+    """Bind the pinned source's missing relative/absolute imports, then restore."""
+    with _IMPORT_LOCK:
+        prefix = "_ail_reformer_induction_" + hashlib.sha256(str(root).encode()).hexdigest()[:16]
+        package = prefix + ".reformer"
+        patterns = package + ".patterns"
+        names = (
+            prefix,
+            package,
+            patterns,
+            package + ".prompt_manager",
+            patterns + ".prompt_manager",
+            patterns + ".query_reformulation_prompts",
+            patterns + ".iterative_pattern_extraction",
+            "query_reformulation_prompts",
+            "ollama",
+        )
+        previous = {name: sys.modules.get(name) for name in names}
+        bytecode = sys.dont_write_bytecode
+        sys.dont_write_bytecode = True
+        try:
+            for name, path in (
+                (prefix, root),
+                (package, root / "reformer"),
+                (patterns, root / "reformer/patterns"),
+            ):
+                module = types.ModuleType(name)
+                module.__package__ = name
+                module.__path__ = [str(path)]
+                sys.modules[name] = module
+            stub = types.ModuleType("ollama")
+            stub.Client = _blocked_ollama
+            sys.modules["ollama"] = stub
+            manager = _load_module(package + ".prompt_manager", root / PROMPT_MANAGER_PATH)
+            sys.modules[patterns + ".prompt_manager"] = manager
+            prompts = _load_module(
+                patterns + ".query_reformulation_prompts", root / PROMPT_BUILDER_PATH
+            )
+            sys.modules["query_reformulation_prompts"] = prompts
+            native = _load_module(patterns + ".iterative_pattern_extraction", root / INDUCTION_PATH)
+            yield native.IterativePatternExtractor, prompts.QueryPair
+        finally:
+            sys.dont_write_bytecode = bytecode
+            for name, value in previous.items():
+                if value is None:
+                    sys.modules.pop(name, None)
+                else:
+                    sys.modules[name] = value
+
+
+@dataclass(frozen=True, slots=True)
+class ReFormeRPatternArtifact:
+    root: Path
+    artifact_id: str
+    pattern_sha256: str
+    patterns: tuple[Mapping[str, Any], ...]
+
+    @property
+    def pattern_path(self) -> Path:
+        return self.root / "patterns.json"
+
+    @classmethod
+    def load(cls, root: str | Path) -> ReFormeRPatternArtifact:
+        supplied = Path(root).expanduser()
+        if supplied.is_symlink():
+            raise ValidationError("ReFormeR artifact root must not be a symlink")
+        folder = supplied.resolve(strict=True)
+        for name in ("artifact.json", "fit-terminal.json", "patterns.json"):
+            if (folder / name).is_symlink() or not (folder / name).is_file():
+                raise ValidationError("ReFormeR fitted artifact file is unavailable")
+        terminal = _loads_strict_json((folder / "fit-terminal.json").read_text(encoding="utf-8"))
+        meta = _loads_strict_json((folder / "artifact.json").read_text(encoding="utf-8"))
+        if (
+            not isinstance(terminal, dict)
+            or terminal.get("status") != "candidate_generated"
+            or not isinstance(meta, dict)
+            or meta.get("release_id") != RELEASE_ID
+            or meta.get("schema_version") != "agentinputlab.reformer.pattern_artifact.v1"
+            or meta.get("upstream_commit") != UPSTREAM_COMMIT
+            or meta.get("artifact_id")
+            != _canonical_hash({key: value for key, value in meta.items() if key != "artifact_id"})
+            or terminal.get("artifact_id") != meta.get("artifact_id")
+            or _sha256_file(folder / "patterns.json") != meta.get("pattern_sha256")
+        ):
+            raise ValidationError("ReFormeR fitted artifact identity/status mismatch")
+        patterns = _load_patterns(folder / "patterns.json")
+        if not meta.get("usage", {}).get("model_calls") or not meta.get("split_audit"):
+            raise ValidationError("ReFormeR fitted artifact lacks fit provenance")
+        return cls(folder, meta["artifact_id"], meta["pattern_sha256"], patterns)
+
+
+class ReFormeRPatternInduction:
+    """Fit a pattern library; candidate generation is not held-out acceptance."""
+
+    def __init__(self, controls: ReFormeRInductionControls | None = None):
+        self.controls = controls or ReFormeRInductionControls()
+
+    def fit(
+        self,
+        *,
+        checkout: str | Path,
+        training_pairs: Sequence[ReFormeRQueryPair],
+        held_out_pairs: Sequence[ReFormeRQueryPair],
+        output_root: str | Path,
+        backend_config: BackendConfig,
+        backend: CompletionBackend,
+        source_license_acknowledged: bool = False,
+        policy: CompatibilityPolicy | None = None,
+    ) -> ReFormeRPatternArtifact:
+        if source_license_acknowledged is not True:
+            raise ValidationError("ReFormeR requires acknowledgement of caller-mounted source")
+        training_pairs, held_out_pairs = tuple(training_pairs), tuple(held_out_pairs)
+        audit = validate_induction_splits(training_pairs, held_out_pairs)
+        c = self.controls
+        batches = (len(training_pairs) + c.batch_size - 1) // c.batch_size
+        if batches > c.max_model_calls:
+            raise ValidationError("ReFormeR declared training batches exceed model-call budget")
+        policy = policy or load_compatibility_policy()
+        source = verify_checkout(Path(checkout), policy)
+        if not {INDUCTION_PATH, PROMPT_PATH, PROMPT_BUILDER_PATH} <= set(policy.source_hashes):
+            raise ValidationError("ReFormeR induction source closure is incomplete")
+        if _canonical_json(backend.fingerprint()) != _canonical_json(backend_config.fingerprint):
+            raise ValidationError("ReFormeR induction backend identity differs from config")
+        supplied = Path(output_root).expanduser()
+        if supplied.is_symlink():
+            raise ValidationError("ReFormeR fit output must not be a symlink")
+        root = supplied.resolve()
+        if root.is_relative_to(source) or source.is_relative_to(root):
+            raise ValidationError("ReFormeR fit output must be separate from upstream source")
+        root.mkdir(parents=True, exist_ok=False)
+        tracker = UsageTracker(
+            Controls(c.max_model_calls, c.max_tokens, c.max_cost_usd), backend_config
+        )
+        _save(
+            root / "fit-start.json",
+            {
+                "release_id": RELEASE_ID,
+                "adapter_revision": ADAPTER_REVISION,
+                "controls": asdict(c),
+                "backend": dict(backend_config.fingerprint),
+                "backend_settings": {
+                    "per_call_output_tokens": backend_config.max_output_tokens,
+                    "temperature": backend_config.temperature,
+                },
+                "source_hashes": dict(policy.source_hashes),
+                "split_audit": audit,
+                "automatic_retry": False,
+                "upstream_transport": "replaced_ollama_with_bounded_backend",
+                "import_path_repairs": ["patterns.prompt_manager", "query_reformulation_prompts"],
+            },
+        )
+        try:
+            with _native_induction(source) as (extractor_class, pair_class):
+                extractor = extractor_class.__new__(extractor_class)
+                extractor.max_patterns = c.max_patterns
+                extractor.consolidated_patterns = []
+                extractor.individual_patterns = []
+                for index in range(batches):
+                    if _canonical_json(backend.fingerprint()) != _canonical_json(
+                        backend_config.fingerprint
+                    ):
+                        raise ValidationError("ReFormeR training backend changed identity")
+                    pairs = training_pairs[index * c.batch_size : (index + 1) * c.batch_size]
+                    native_pairs = [
+                        pair_class(pair.original_query, pair.reformulated_query, pair.query_id)
+                        for pair in pairs
+                    ]
+                    journal = root / f"batch-{index + 1:04d}"
+                    journal.mkdir()
+
+                    def call_llm(messages, *, _journal=journal, _index=index):
+                        _save(
+                            _journal / "request.json",
+                            {
+                                "messages": messages,
+                                "seed": c.seed + _index,
+                                "max_output_tokens": backend_config.max_output_tokens,
+                                "temperature": backend_config.temperature,
+                                "backend": dict(backend_config.fingerprint),
+                            },
+                        )
+                        text = tracker.complete(
+                            backend,
+                            stage="pattern_induction",
+                            messages=messages,
+                            seed=c.seed + _index,
+                        )
+                        _save(
+                            _journal / "response.json",
+                            {
+                                "text": text,
+                                "usage_cumulative": tracker.as_dict(),
+                                "model_trace": tracker.stages,
+                            },
+                        )
+                        return {"choices": [{"message": {"content": text}}]}
+
+                    extractor.call_llm = call_llm
+                    # Native parser and consolidation semantics, not a local replacement.
+                    with redirect_stdout(sys.stderr):
+                        result = extractor.extract_patterns_from_batch(native_pairs, index + 1)
+                    extractor.consolidated_patterns = result
+                    _save(
+                        journal / "native-result.json",
+                        {
+                            "patterns": [asdict(pattern) for pattern in result],
+                            "individual_patterns": extractor.individual_patterns,
+                            "empty_native_result": not bool(result),
+                        },
+                    )
+                _save(root / "patterns.json", [asdict(p) for p in extractor.consolidated_patterns])
+            verify_checkout(source, policy)
+            if _canonical_json(backend.fingerprint()) != _canonical_json(
+                backend_config.fingerprint
+            ):
+                raise ValidationError("ReFormeR training backend changed identity")
+            patterns = _load_patterns(root / "patterns.json")
+            meta = {
+                "schema_version": "agentinputlab.reformer.pattern_artifact.v1",
+                "release_id": RELEASE_ID,
+                "upstream_commit": UPSTREAM_COMMIT,
+                "source_hashes": dict(policy.source_hashes),
+                "split_audit": audit,
+                "backend": dict(backend_config.fingerprint),
+                "controls": asdict(c),
+                "usage": tracker.as_dict(),
+                "pattern_count": len(patterns),
+                "pattern_sha256": _sha256_file(root / "patterns.json"),
+                "held_out_acceptance_complete": False,
+                "paper_result_parity_claimed": False,
+            }
+            meta["artifact_id"] = _canonical_hash(meta)
+            _save(root / "artifact.json", meta)
+            _save(
+                root / "fit-terminal.json",
+                {
+                    "status": "candidate_generated",
+                    "artifact_id": meta["artifact_id"],
+                    "usage": tracker.as_dict(),
+                    "model_trace": tracker.stages,
+                    "automatic_retry": False,
+                    "held_out_acceptance_complete": False,
+                },
+            )
+            return ReFormeRPatternArtifact.load(root)
+        except Exception as exc:
+            terminal = {
+                "status": "failed_fit" if tracker.model_calls else "entry_failure",
+                "error_type": type(exc).__name__,
+                "error_code": exc.code if isinstance(exc, DriverError) else None,
+                "usage": tracker.as_dict(),
+                "model_trace": tracker.stages,
+                "provider_usage_unknown": tracker.model_calls > len(tracker.stages)
+                or any(
+                    "failure_code" in stage and stage.get("provider_usage") is None
+                    for stage in tracker.stages
+                ),
+                "automatic_retry": False,
+                "held_out_acceptance_complete": False,
+            }
+            if not (root / "fit-terminal.json").exists():
+                _save(root / "fit-terminal.json", terminal)
+            raise
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--checkout", required=True)
+    parser.add_argument(
+        "--pairs", required=True, type=Path, help="JSON list of declared split pairs"
+    )
+    parser.add_argument("--backend-config", required=True, type=Path)
+    parser.add_argument("--output", required=True, type=Path)
+    parser.add_argument("--acknowledge-external-source", action="store_true")
+    parser.add_argument("--batch-size", type=int, default=2)
+    parser.add_argument("--max-patterns", type=int, default=25)
+    parser.add_argument("--max-model-calls", type=int, default=8)
+    parser.add_argument("--max-tokens", type=int, default=4096)
+    parser.add_argument("--seed", type=int, default=17)
+    args = parser.parse_args(argv)
+    pairs = [ReFormeRQueryPair(**row) for row in _loads_strict_json(args.pairs.read_text())]
+    config = BackendConfig.from_json(args.backend_config.read_text(encoding="utf-8"))
+    controls = ReFormeRInductionControls(
+        batch_size=args.batch_size,
+        max_patterns=args.max_patterns,
+        max_model_calls=args.max_model_calls,
+        max_tokens=args.max_tokens,
+        seed=args.seed,
+    )
+    artifact = ReFormeRPatternInduction(controls).fit(
+        checkout=args.checkout,
+        training_pairs=[p for p in pairs if p.split == "train"],
+        held_out_pairs=[p for p in pairs if p.split != "train"],
+        output_root=args.output,
+        backend_config=config,
+        backend=OpenAICompatibleBackend(config),
+        source_license_acknowledged=args.acknowledge_external_source,
+    )
+    print(
+        _canonical_json(
+            {
+                "status": "candidate_generated",
+                "artifact_id": artifact.artifact_id,
+                "pattern_sha256": artifact.pattern_sha256,
+            }
+        )
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

workers/rrr/README.md

@@ -0,0 +1,126 @@
+# Rewrite-Retrieve-Read quarantined inference worker
+
+The toolkit's recommended RRR entrypoint is
+[`rewrite.rrr.common_support_prompt`](../../docs/rrr-controlled.md), which uses
+the configured backbone and shared retriever. It runs through the Python core
+without this external worker or an author warm-up/PPO checkpoint. This document
+covers the separately selected external-worker profiles.
+
+This worker supports the separable inference chain from
+[`xbmxb/RAG-query-rewriting`](https://github.com/xbmxb/RAG-query-rewriting) at
+commit `6bab6243e60c7f3e526b6ee44f95381b1024d471`:
+
+`rewrite prompt/model -> parsed query -> fixed search artifact -> snippets -> frozen reader`
+
+It remains `external_only`. The repository has no root license file, its
+published `complete()` function is an empty stub, and a redacted security scan
+of the pinned tarball reports credential-risk assignments in seven source
+paths. AgentInputLab therefore never vendors, extracts, imports, or echoes the
+upstream source or any suspected value. The tarball is used only for commit,
+byte-hash, absent-license, AST-symbol, and risk-count evidence. Output evidence
+is `pinned_tarball_compatible_chain`, not native execution or paper parity.
+
+## Mandatory gates
+
+Execution requires all of the following:
+
+1. the adapter sets `source_license_acknowledged=True`;
+2. the adapter sets `checkpoint_license_acknowledged=True`;
+3. the worker receives `--acknowledge-noassertion-source`;
+4. the worker receives `--acknowledge-noassertion-checkpoints`;
+5. the operator explicitly keeps the risky tarball quarantined with
+   `--acknowledge-credential-quarantine`.
+
+Source, rewriter, reader, prompt, search cache, and dataset licenses are
+independent. Both checkpoint manifests must retain `license: "NOASSERTION"`.
+No upstream data, cache, source, or weights are included in wheels/sdists.
+
+## Frozen comparison identity
+
+Every request binds the two prompt byte hashes; prompt/warm-up/PPO rewriter
+checkpoint revision; frozen-reader revision; model-deployment fingerprints;
+search-cache or controlled-retriever artifact; corpus/index revisions; top-k;
+search time window; seed; input character limits; generation token limits; and
+the complete input hash. Successful requests report two model calls and one
+search; failures retain only the calls and usage actually consumed. Local
+encoder-decoder output accounting excludes the supplied decoder-start prefix,
+while decoded output and generation limits stay unchanged.
+Requests cannot choose paths, modules, URLs, environment variables, or
+credentials.
+
+The official single-query parser boundary is preserved: generation ends at
+`**`, queries use `;`, and this release accepts exactly one query. Search uses
+the rewritten query; the frozen reader receives the original task query plus
+the joined snippets, matching the upstream `rewrite -> rewrite2` data flow.
+
+`bing_cache` is a `controlled_adapter` with `search_profile=bing_cache`. It
+replays a frozen Bing result artifact; the worker never calls the
+credential-bearing Bing code.
+`controlled_static` requires a matching retriever fingerprint and is always
+labelled `controlled_adapter`, never native.
+
+## Checkpoint inference only
+
+The rewriter checkpoint manifest supports `prompt`, `warmup_checkpoint`, and
+`ppo_checkpoint`; these are inference profiles. The reader uses
+`frozen_reader`. Local loading uses Hugging Face with
+`local_files_only=True`, `trust_remote_code=False`, and deterministic greedy
+generation. There is no PPO training command or code path.
+
+```json
+{
+  "schema_version": "agentinputlab.rrr.checkpoint.v1",
+  "role": "rewriter",
+  "profile": "ppo_checkpoint",
+  "revision": "immutable-checkpoint-revision",
+  "model_type": "seq2seq",
+  "license": "NOASSERTION",
+  "files": {
+    "config.json": "<sha256>",
+    "model.safetensors": "<sha256>"
+  }
+}
+```
+
+## Search cache and commands
+
+The JSON search artifact uses schema `agentinputlab.rrr.search-cache.v1` and
+records `mode`, corpus/index revisions, ISO date window, and exact query-to-row
+entries. Its raw SHA-256 is `search_artifact_hash`.
+
+Source/symbol/security smoke test (never imports source):
+
+```bash
+python workers/rrr/driver.py \
+  --source-tarball /mounted/6bab6243.tar.gz \
+  --smoke-source
+```
+
+Inference:
+
+```bash
+python workers/rrr/driver.py \
+  --source-tarball /mounted/6bab6243.tar.gz \
+  --prompt /mounted/rewrite-prompt.txt \
+  --reader-prompt /mounted/reader-prompt.txt \
+  --search-cache /mounted/search-cache.json \
+  --rewriter-checkpoint /mounted/rewriter \
+  --rewriter-manifest /mounted/rewriter-manifest.json \
+  --reader-checkpoint /mounted/reader \
+  --reader-manifest /mounted/reader-manifest.json \
+  --acknowledge-noassertion-source \
+  --acknowledge-noassertion-checkpoints \
+  --acknowledge-credential-quarantine
+```
+
+Fake-tarball tests prove transport, trajectory, redaction, identity, fairness,
+budgets, and license gates only. The opt-in real-tarball test proves byte and
+source-symbol evidence. Neither is a benchmark-result parity claim.
+
+An existing pinned Git checkout can replace the archive for the same inference
+chain. Use `--source-checkout /mounted/RAG-query-rewriting` instead of
+`--source-tarball`. This verifies the exact commit/root, the manifest's required
+file SHA-256 locks, tracked Python Git blobs, AST symbols and credential-risk
+inventory without reading bundled datasets or downloading the archive. It never
+imports the checkout. Evidence is `pinned_checkout_compatible_chain`; the complete
+archive checksum and historical Bing/checkpoint parity are not claimed.

workers/rrr/__init__.py

@@ -0,0 +1 @@
+"""Pinned Rewrite-Retrieve-Read worker package."""

workers/rrr/compatibility_manifest.json

@@ -0,0 +1,57 @@
+{
+  "schema_version": "agentinputlab.rrr.compatibility.v1",
+  "evidence_level": "pinned_tarball_compatible_chain",
+  "upstream": {
+    "repository": "https://github.com/xbmxb/RAG-query-rewriting",
+    "commit": "6bab6243e60c7f3e526b6ee44f95381b1024d471",
+    "archive_root": "RAG-query-rewriting-6bab6243e60c7f3e526b6ee44f95381b1024d471",
+    "tarball_sha256": "1fc4e570e00cb6be98914ec8e59f575864d5808db1cca463d9de1d1f7929b2fb",
+    "license_spdx": "NOASSERTION",
+    "license_file_present": false
+  },
+  "source_files": {
+    "README.md": "09c104d796416cdf24089cae5fbfaf2d348cccb39f525b5e1a3cb85f0eff2cb9",
+    "generate/inference.py": "9ef3486c2abf7091dd7173a0f3fe3f35aebecd4679eae47ef8c447bddcfea95d",
+    "generate/main-0514.py": "aad3c565e5fcf7185c4cb0cc66ee4a14661e634a715aaca8f31ed2e0b7f09aad",
+    "generate/bingenv.py": "7a7e61f3111c06db61e9e67b30f85b30cb164b2f6ad5631aee08fb4d496d50ec",
+    "generate/bing.py": "d1b1cb3c9c0041adb31163d714e95f5525137957e057be2ffc841e56cb81e045",
+    "generate/interllama.py": "9f78e03af4f7258b20d3429055cce6aaf2a63e8fd9107ca30e02fc74e0ae9fd6",
+    "generate/inprompts/myprompt.jsonl": "1483b80e5b81a26b97641cc2a5c4535c045eb39394d2b88651aade0d4afa5fb4",
+    "result_models/README.md": "f207247939fd65d359a5c3821047ec4db1df5757d2b7aac0bc22a6726c0f9dfd",
+    "rl/RL4LMs/rl4lms/envs/text_generation/warm_start.py": "0ee13eebfe1cc17cfad6c3d343cd06771e445db33a3c7014884b02381cd3c920"
+  },
+  "required_symbols": {
+    "generate/inference.py": ["add_prompt", "run_main", "run_searchre"],
+    "generate/main-0514.py": ["rewrite", "rewrite2"],
+    "generate/bingenv.py": ["BingEnv"],
+    "rl/RL4LMs/rl4lms/envs/text_generation/warm_start.py": ["ActorOnlyWarmStartMixin"]
+  },
+  "credential_risk_paths": [
+    "datasets/tasks/mmlu/evaluate.py",
+    "generate/bing.py",
+    "generate/bing_utils/bing.py",
+    "rl/RL4LMs/rl4lms/envs/text_generation/bing.py",
+    "rl/RL4LMs/rl4lms/envs/text_generation/bing_utils/bing.py",
+    "rl/RL4LMs/rl4lms/envs/text_generation/llm_utils.py",
+    "rl/RL4LMs/rl4lms/envs/text_generation/vicuna_utils.py"
+  ],
+  "runtime_contract": {
+    "stage_order": ["rewrite", "retrieve", "snippet", "reader"],
+    "query_separator": ";",
+    "generation_terminator": "**",
+    "search_wrapper": "search[{query}]",
+    "snippet_joiner": " ",
+    "supported_rewriter_profiles": ["prompt", "warmup_checkpoint", "ppo_checkpoint"],
+    "supported_search_modes": ["bing_cache", "controlled_static"],
+    "imports_upstream_runtime": false,
+    "trains_ppo": false
+  },
+  "artifact_policy": {
+    "checkpoint_license": "NOASSERTION",
+    "bundle_source": false,
+    "bundle_checkpoints": false,
+    "bundle_search_cache": false,
+    "local_files_only": true,
+    "trust_remote_code": false
+  }
+}