agentinputlab 0.1.0a1__py3-none-any.whl

agentinputlab/contracts/lifecycle.py

@@ -0,0 +1,164 @@
+"""Lifecycle-aware intervention protocols.
+
+The semantic protocols are deliberately distinct even though all of them return
+an :class:`InputPatch`.  This prevents stateful retrieval or clarification from
+being mislabeled as a one-shot string rewriter.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from typing import Any, Protocol, runtime_checkable
+
+from .enums import SemanticFamily
+from .errors import ValidationError
+from .intent import IntentContract
+from .patch import InputPatch
+from .serialization import content_hash, freeze_mapping, to_jsonable
+from .state import ContextBlock, FrozenAgentState
+from .trace import ExecutionTrace
+
+
+@dataclass(frozen=True, slots=True)
+class InterventionContext:
+    backend: Any = None
+    dense_embedder: Any = None
+    retriever: Any = None
+    vector_searcher: Any = None
+    tools: Any = None
+    external_runtime: Any = None
+    artifact_manager: Any = None
+    seed: int = 0
+    run_config: Mapping[str, Any] = field(default_factory=dict)
+    intent_contract: IntentContract | None = None
+    budget_ledger: Any = None
+    monitor: Any = None
+    pricing_catalog: Any = None
+    strict_intent: bool = True
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "run_config", freeze_mapping(self.run_config))
+        if isinstance(self.seed, bool) or not isinstance(self.seed, int) or self.seed < 0:
+            raise ValidationError("seed must be a non-negative integer")
+        if self.intent_contract is not None and not isinstance(
+            self.intent_contract, IntentContract
+        ):
+            raise TypeError("intent_contract must be an IntentContract")
+
+
+@runtime_checkable
+class Intervention(Protocol):
+    method_id: str
+    release_id: str
+    family: SemanticFamily
+
+    def propose(self, state: FrozenAgentState, context: InterventionContext) -> InputPatch:
+        """Propose a patch without mutating the frozen state."""
+
+
+@runtime_checkable
+class Reformulator(Intervention, Protocol):
+    family: SemanticFamily
+
+
+@runtime_checkable
+class Decomposer(Intervention, Protocol):
+    family: SemanticFamily
+
+
+@runtime_checkable
+class EvidenceAcquirer(Intervention, Protocol):
+    family: SemanticFamily
+
+
+@runtime_checkable
+class Clarifier(Intervention, Protocol):
+    family: SemanticFamily
+
+
+@runtime_checkable
+class ContextCurator(Intervention, Protocol):
+    family: SemanticFamily
+
+
+@dataclass(frozen=True, slots=True)
+class CompositeResult:
+    """Terminal result of a full agent/search architecture.
+
+    Composite methods keep their final answer and multi-step trajectory instead
+    of pretending to be a one-shot input patch.  A downstream experiment may
+    separately derive a controlled evidence patch, but that is a different
+    release profile and estimand.
+    """
+
+    method_id: str
+    release_id: str
+    source_state_hash: str
+    final_answer: str
+    evidence: tuple[ContextBlock, ...]
+    trace: ExecutionTrace
+    implementation_identity: str
+    profile_kind: str
+    metadata: Mapping[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        evidence = tuple(self.evidence)
+        if (
+            not isinstance(self.method_id, str)
+            or not self.method_id.strip()
+            or not isinstance(self.release_id, str)
+            or not self.release_id.strip()
+        ):
+            raise ValidationError("composite result requires method and release IDs")
+        if not isinstance(self.source_state_hash, str) or not self.source_state_hash.strip():
+            raise ValidationError("composite result requires source_state_hash")
+        if not isinstance(self.final_answer, str) or not self.final_answer.strip():
+            raise ValidationError("composite final_answer must be non-empty text")
+        if not all(isinstance(block, ContextBlock) for block in evidence):
+            raise ValidationError("composite evidence must contain ContextBlock instances")
+        if not isinstance(self.trace, ExecutionTrace):
+            raise ValidationError("composite result requires an ExecutionTrace")
+        if self.trace.method_id != self.method_id or self.trace.release_id != self.release_id:
+            raise ValidationError("composite trace identity does not match result identity")
+        if (
+            not isinstance(self.implementation_identity, str)
+            or not self.implementation_identity.strip()
+            or not isinstance(self.profile_kind, str)
+            or not self.profile_kind.strip()
+        ):
+            raise ValidationError("composite implementation/profile identity must not be empty")
+        object.__setattr__(self, "evidence", evidence)
+        object.__setattr__(self, "metadata", freeze_mapping(self.metadata))
+
+    @property
+    def result_hash(self) -> str:
+        return content_hash(self)
+
+    def as_dict(self) -> dict[str, Any]:
+        return to_jsonable(self)
+
+
+@runtime_checkable
+class CompositeIntervention(Protocol):
+    method_id: str
+    release_id: str
+    family: SemanticFamily
+
+    def run(self, state: FrozenAgentState, context: InterventionContext) -> CompositeResult:
+        """Run a full architecture and return its terminal outcome and trace."""
+
+
+@runtime_checkable
+class OfflineRecipe(Protocol):
+    method_id: str
+    release_id: str
+
+    def fit(
+        self,
+        train_examples: tuple[Any, ...],
+        *,
+        validation_examples: tuple[Any, ...] = (),
+        context: InterventionContext,
+    ) -> Any:
+        """Produce a versioned, replayable artifact without consulting test data."""

agentinputlab/contracts/patch.py

@@ -0,0 +1,167 @@
+"""Typed, auditable input patches and deterministic materialization."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass, field, replace
+from typing import Any
+
+from .enums import PatchOp
+from .errors import StateConflictError, ValidationError
+from .serialization import content_hash, deep_freeze_jsonable, freeze_mapping, to_jsonable
+from .state import ContextBlock, FrozenAgentState, Message
+from .trace import ExecutionTrace
+
+
+@dataclass(frozen=True, slots=True)
+class PatchOperation:
+    op: PatchOp
+    value: Any = None
+    target: str = ""
+    rationale: str = ""
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "value", _freeze_patch_value(self.value))
+        if self.op is PatchOp.NO_OP and self.value not in (None, ""):
+            raise ValidationError("NO_OP cannot carry a replacement value")
+
+
+@dataclass(frozen=True, slots=True)
+class InputPatch:
+    method_id: str
+    release_id: str
+    source_state_hash: str
+    operations: tuple[PatchOperation, ...]
+    trace: ExecutionTrace
+    implementation_identity: str
+    profile_kind: str
+    metadata: Mapping[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        operations = tuple(self.operations)
+        if not all(isinstance(operation, PatchOperation) for operation in operations):
+            raise ValidationError("patch operations must be PatchOperation instances")
+        if not isinstance(self.trace, ExecutionTrace):
+            raise ValidationError("patch trace must be an ExecutionTrace")
+        object.__setattr__(self, "operations", operations)
+        object.__setattr__(self, "metadata", freeze_mapping(self.metadata))
+        if not self.operations:
+            raise ValidationError("patch requires at least one operation; use NO_OP explicitly")
+        if self.trace.method_id != self.method_id or self.trace.release_id != self.release_id:
+            raise ValidationError("trace identity does not match patch identity")
+
+    @classmethod
+    def no_op(
+        cls,
+        state: FrozenAgentState,
+        *,
+        method_id: str = "no_op",
+        release_id: str = "baseline.no_op",
+        rationale: str = "",
+        profile_kind: str = "controlled_adapter",
+    ) -> InputPatch:
+        trace = ExecutionTrace(method_id=method_id, release_id=release_id)
+        return cls(
+            method_id=method_id,
+            release_id=release_id,
+            source_state_hash=state.state_hash,
+            operations=(PatchOperation(PatchOp.NO_OP, rationale=rationale),),
+            trace=trace,
+            implementation_identity="builtin",
+            profile_kind=profile_kind,
+        )
+
+    @property
+    def patch_hash(self) -> str:
+        return content_hash(self)
+
+    def as_dict(self) -> dict[str, Any]:
+        return to_jsonable(self)
+
+    def apply(self, state: FrozenAgentState) -> FrozenAgentState:
+        """Apply operations in order after checking the paired-state identity."""
+
+        if state.state_hash != self.source_state_hash:
+            raise StateConflictError(
+                f"patch expected state {self.source_state_hash}, got {state.state_hash}"
+            )
+        current = state
+        for operation in self.operations:
+            current = _apply_operation(current, operation)
+        return current
+
+
+def _apply_operation(state: FrozenAgentState, operation: PatchOperation) -> FrozenAgentState:
+    if operation.op is PatchOp.NO_OP:
+        return state
+    if operation.op is PatchOp.REPLACE_QUERY:
+        return replace(state, query=str(operation.value))
+    if operation.op is PatchOp.APPEND_QUERY:
+        separator = "\n\n" if state.query else ""
+        return replace(state, query=f"{state.query}{separator}{operation.value}")
+    if operation.op is PatchOp.REPLACE_INSTRUCTION:
+        return replace(state, instruction=str(operation.value))
+    if operation.op is PatchOp.APPEND_INSTRUCTION:
+        separator = "\n\n" if state.instruction else ""
+        return replace(state, instruction=f"{state.instruction}{separator}{operation.value}")
+    if operation.op is PatchOp.ADD_CONTEXT:
+        blocks = _coerce_context(operation.value)
+        return replace(state, context=(*state.context, *blocks))
+    if operation.op is PatchOp.REPLACE_CONTEXT:
+        return replace(state, context=_coerce_context(operation.value))
+    if operation.op is PatchOp.ADD_MESSAGE:
+        message = operation.value
+        if isinstance(message, dict):
+            message = Message(**message)
+        if not isinstance(message, Message):
+            raise ValidationError("ADD_MESSAGE requires Message or mapping")
+        return replace(state, messages=(*state.messages, message))
+    if operation.op is PatchOp.REPLACE_MESSAGES:
+        return replace(state, messages=_coerce_messages(operation.value))
+    if operation.op is PatchOp.SET_METADATA:
+        if not isinstance(operation.value, Mapping):
+            raise ValidationError("SET_METADATA requires a mapping")
+        merged = dict(state.metadata)
+        merged.update(operation.value)
+        return replace(state, metadata=merged)
+    if operation.op is PatchOp.REQUEST_CLARIFICATION:
+        merged = dict(state.metadata)
+        merged["clarification_request"] = str(operation.value)
+        return replace(state, metadata=merged)
+    raise ValidationError(f"unsupported patch operation: {operation.op}")
+
+
+def _coerce_context(value: Any) -> tuple[ContextBlock, ...]:
+    values = value if isinstance(value, (tuple, list)) else (value,)
+    blocks: list[ContextBlock] = []
+    for item in values:
+        if isinstance(item, ContextBlock):
+            blocks.append(item)
+        elif isinstance(item, str):
+            blocks.append(ContextBlock(text=item))
+        elif isinstance(item, Mapping):
+            blocks.append(ContextBlock(**item))
+        else:
+            raise ValidationError("context operation requires ContextBlock/string/mapping")
+    return tuple(blocks)
+
+
+def _coerce_messages(value: Any) -> tuple[Message, ...]:
+    values = value if isinstance(value, (tuple, list)) else (value,)
+    messages: list[Message] = []
+    for item in values:
+        if isinstance(item, Message):
+            messages.append(item)
+        elif isinstance(item, Mapping):
+            messages.append(Message(**item))
+        else:
+            raise ValidationError("REPLACE_MESSAGES requires Message instances or mappings")
+    return tuple(messages)
+
+
+def _freeze_patch_value(value: Any) -> Any:
+    if isinstance(value, (ContextBlock, Message)):
+        return value
+    if isinstance(value, (tuple, list)):
+        return tuple(_freeze_patch_value(item) for item in value)
+    return deep_freeze_jsonable(value)

agentinputlab/contracts/serialization.py

@@ -0,0 +1,93 @@
+"""Canonical serialization and hashing helpers."""
+
+from __future__ import annotations
+
+import dataclasses
+import hashlib
+import json
+from collections.abc import Mapping
+from enum import Enum
+from pathlib import Path
+from types import MappingProxyType
+from typing import Any
+
+
+def deep_freeze_jsonable(value: Any) -> Any:
+    """Detach and recursively freeze a canonically serializable value.
+
+    Mutable caller-owned containers must never be able to change a state,
+    dependency, trace, or patch hash after construction.
+    """
+
+    if dataclasses.is_dataclass(value):
+        return deep_freeze_jsonable(to_jsonable(value))
+    if isinstance(value, Enum):
+        return deep_freeze_jsonable(value.value)
+    if isinstance(value, Mapping):
+        frozen: dict[str, Any] = {}
+        for key, item in value.items():
+            if not isinstance(key, str):
+                raise TypeError("canonical mapping keys must be strings")
+            frozen[key] = deep_freeze_jsonable(item)
+        return MappingProxyType(frozen)
+    if isinstance(value, (set, frozenset)):
+        raise TypeError("sets are not permitted in canonical serialized values")
+    if isinstance(value, (tuple, list)):
+        return tuple(deep_freeze_jsonable(item) for item in value)
+    if isinstance(value, Path):
+        return str(value)
+    if value is None or isinstance(value, (str, int, float, bool)):
+        return value
+    raise TypeError(f"Unsupported canonical value: {type(value).__name__}")
+
+
+def freeze_mapping(value: Mapping[str, Any] | None) -> Mapping[str, Any]:
+    """Return a detached, recursively immutable string-keyed mapping."""
+
+    frozen = deep_freeze_jsonable(dict(value or {}))
+    if not isinstance(frozen, Mapping):  # pragma: no cover - construction invariant
+        raise TypeError("freeze_mapping did not produce a mapping")
+    return frozen
+
+
+def to_jsonable(value: Any) -> Any:
+    """Convert public dataclasses and common immutable containers to JSON values."""
+
+    if dataclasses.is_dataclass(value):
+        return {
+            field.name: to_jsonable(getattr(value, field.name))
+            for field in dataclasses.fields(value)
+        }
+    if isinstance(value, Enum):
+        return value.value
+    if isinstance(value, dict):
+        return {str(key): to_jsonable(item) for key, item in value.items()}
+    if hasattr(value, "items"):
+        return {str(key): to_jsonable(item) for key, item in value.items()}
+    if isinstance(value, (set, frozenset)):
+        raise TypeError("sets are not permitted in canonical serialized values")
+    if isinstance(value, (tuple, list)):
+        return [to_jsonable(item) for item in value]
+    if isinstance(value, Path):
+        return str(value)
+    if value is None or isinstance(value, (str, int, float, bool)):
+        return value
+    raise TypeError(f"Unsupported canonical value: {type(value).__name__}")
+
+
+def canonical_json(value: Any) -> str:
+    """Serialize without platform- or insertion-order-dependent variation."""
+
+    return json.dumps(
+        to_jsonable(value),
+        ensure_ascii=False,
+        sort_keys=True,
+        separators=(",", ":"),
+        allow_nan=False,
+    )
+
+
+def content_hash(value: Any) -> str:
+    """Return a SHA-256 content identity for a canonical value."""
+
+    return hashlib.sha256(canonical_json(value).encode("utf-8")).hexdigest()

agentinputlab/contracts/state.py

@@ -0,0 +1,127 @@
+"""Immutable input state presented to an intervention."""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from typing import Any
+
+from .errors import ValidationError
+from .serialization import content_hash, freeze_mapping, to_jsonable
+
+
+def _frozen_mapping(value: Mapping[str, Any] | None) -> Mapping[str, Any]:
+    try:
+        return freeze_mapping(value)
+    except TypeError as exc:
+        raise ValidationError(f"state metadata must be canonically serializable: {exc}") from exc
+
+
+@dataclass(frozen=True, slots=True)
+class Message:
+    role: str
+    content: str
+    name: str | None = None
+
+    def __post_init__(self) -> None:
+        if not self.role.strip():
+            raise ValidationError("message.role must not be empty")
+
+
+@dataclass(frozen=True, slots=True)
+class ContextBlock:
+    text: str
+    block_id: str = ""
+    source: str = ""
+    score: float | None = None
+    metadata: Mapping[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "metadata", _frozen_mapping(self.metadata))
+        if not self.text:
+            raise ValidationError("context block text must not be empty")
+
+
+@dataclass(frozen=True, slots=True)
+class ExecutionBudget:
+    """Per-run resource ceilings.
+
+    ``max_context_tokens`` is the cumulative number of provider-reported LLM
+    input tokens across every model call in one run.  It is not a per-request
+    window-size limit; a run with two 600-token requests consumes 1,200 context
+    tokens for this budget.
+    """
+
+    max_model_calls: int = 8
+    max_retrieval_calls: int = 8
+    max_tool_calls: int = 8
+    max_output_tokens: int = 4096
+    max_context_tokens: int | None = None
+    max_cost_usd: float | None = None
+
+    def __post_init__(self) -> None:
+        for name in (
+            "max_model_calls",
+            "max_retrieval_calls",
+            "max_tool_calls",
+            "max_output_tokens",
+        ):
+            value = getattr(self, name)
+            if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+                raise ValidationError(f"{name} must be a non-negative integer")
+        if self.max_context_tokens is not None and (
+            isinstance(self.max_context_tokens, bool)
+            or not isinstance(self.max_context_tokens, int)
+            or self.max_context_tokens < 0
+        ):
+            raise ValidationError("max_context_tokens must be a non-negative integer or None")
+        if self.max_cost_usd is not None and (
+            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("max_cost_usd must be finite and non-negative or None")
+
+
+@dataclass(frozen=True, slots=True)
+class FrozenAgentState:
+    """A hash-addressed snapshot used for paired pre-action experiments."""
+
+    query: str
+    task_id: str = ""
+    instruction: str = ""
+    context: tuple[ContextBlock, ...] = ()
+    messages: tuple[Message, ...] = ()
+    tool_names: tuple[str, ...] = ()
+    metadata: Mapping[str, Any] = field(default_factory=dict)
+    budget: ExecutionBudget = field(default_factory=ExecutionBudget)
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.query, str) or not isinstance(self.instruction, str):
+            raise ValidationError("state query and instruction must be strings")
+        if not self.query.strip() and not self.instruction.strip():
+            raise ValidationError("state requires a non-empty query or instruction")
+        context = tuple(self.context)
+        messages = tuple(self.messages)
+        tool_names = tuple(self.tool_names)
+        if not all(isinstance(item, ContextBlock) for item in context):
+            raise ValidationError("state context entries must be ContextBlock instances")
+        if not all(isinstance(item, Message) for item in messages):
+            raise ValidationError("state messages must be Message instances")
+        if not all(isinstance(item, str) and item for item in tool_names):
+            raise ValidationError("state tool_names must contain non-empty strings")
+        if not isinstance(self.budget, ExecutionBudget):
+            raise ValidationError("state budget must be an ExecutionBudget")
+        object.__setattr__(self, "context", context)
+        object.__setattr__(self, "messages", messages)
+        object.__setattr__(self, "tool_names", tool_names)
+        object.__setattr__(self, "metadata", _frozen_mapping(self.metadata))
+
+    def canonical_dict(self) -> dict[str, Any]:
+        return to_jsonable(self)
+
+    @property
+    def state_hash(self) -> str:
+        return content_hash(self)

agentinputlab/contracts/trace.py

@@ -0,0 +1,59 @@
+"""Serializable method-specific execution traces."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from typing import Any
+
+from .enums import TracePhase
+from .serialization import content_hash, freeze_mapping, to_jsonable
+
+
+@dataclass(frozen=True, slots=True)
+class TraceEvent:
+    phase: TracePhase
+    name: str
+    payload: Mapping[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "payload", freeze_mapping(self.payload))
+
+    def as_dict(self) -> dict[str, Any]:
+        return to_jsonable(self)
+
+
+@dataclass(frozen=True, slots=True)
+class ExecutionTrace:
+    method_id: str
+    release_id: str
+    events: tuple[TraceEvent, ...] = ()
+    counters: Mapping[str, int | float] = field(default_factory=dict)
+    warnings: tuple[str, ...] = ()
+
+    def __post_init__(self) -> None:
+        events = tuple(self.events)
+        warnings = tuple(self.warnings)
+        if not all(isinstance(event, TraceEvent) for event in events):
+            raise TypeError("trace events must be TraceEvent instances")
+        if not all(isinstance(warning, str) for warning in warnings):
+            raise TypeError("trace warnings must be strings")
+        object.__setattr__(self, "events", events)
+        object.__setattr__(self, "counters", freeze_mapping(self.counters))
+        object.__setattr__(self, "warnings", warnings)
+
+    def append(self, event: TraceEvent) -> ExecutionTrace:
+        return ExecutionTrace(
+            method_id=self.method_id,
+            release_id=self.release_id,
+            events=(*self.events, event),
+            counters=dict(self.counters),
+            warnings=self.warnings,
+        )
+
+    @property
+    def trace_hash(self) -> str:
+        return content_hash(self)
+
+    def as_dict(self) -> dict[str, Any]:
+        return to_jsonable(self)

agentinputlab/contracts/worker.py

@@ -0,0 +1,42 @@
+"""Versioned external-worker request and response envelopes."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from typing import Any
+
+from .errors import ValidationError
+from .serialization import freeze_mapping
+
+
+@dataclass(frozen=True, slots=True)
+class WorkerRequest:
+    schema_version: int
+    release_id: str
+    request_id: str
+    payload: Mapping[str, Any]
+    dependency_hashes: Mapping[str, str] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        if self.schema_version != 1:
+            raise ValidationError(f"unsupported worker request schema: {self.schema_version}")
+        object.__setattr__(self, "payload", freeze_mapping(self.payload))
+        object.__setattr__(self, "dependency_hashes", freeze_mapping(self.dependency_hashes))
+
+
+@dataclass(frozen=True, slots=True)
+class WorkerResponse:
+    schema_version: int
+    request_id: str
+    status: str
+    payload: Mapping[str, Any] = field(default_factory=dict)
+    error_code: str = ""
+    error_message: str = ""
+
+    def __post_init__(self) -> None:
+        if self.schema_version != 1:
+            raise ValidationError(f"unsupported worker response schema: {self.schema_version}")
+        if self.status not in {"ok", "error"}:
+            raise ValidationError(f"invalid worker response status: {self.status}")
+        object.__setattr__(self, "payload", freeze_mapping(self.payload))

agentinputlab/core/__init__.py

@@ -0,0 +1,7 @@
+"""Compatibility exports for the pre-implementation repository layout.
+
+New code should import from :mod:`agentinputlab.contracts`.
+"""
+
+from agentinputlab.contracts import *  # noqa: F403
+from agentinputlab.contracts import __all__ as __all__

agentinputlab/data/__init__.py

@@ -0,0 +1,32 @@
+"""Data acquisition, checksum, preprocessing, index, and overlap utilities."""
+
+from .downloader import (
+    DownloadPolicy,
+    DownloadResponse,
+    DownloadTransport,
+    StreamingDownloadResponse,
+    StreamingDownloadTransport,
+    ValidatedDownloadTarget,
+    download_artifact,
+    download_artifact_streamed,
+    validate_download_url,
+)
+from .http import PinnedHTTPSDownloadTransport
+from .overlap import OverlapRecord, detect_id_overlap
+from .trec_sample import prepare_trec_dl_sample
+
+__all__ = [
+    "DownloadPolicy",
+    "DownloadResponse",
+    "DownloadTransport",
+    "OverlapRecord",
+    "PinnedHTTPSDownloadTransport",
+    "StreamingDownloadResponse",
+    "StreamingDownloadTransport",
+    "ValidatedDownloadTarget",
+    "detect_id_overlap",
+    "download_artifact",
+    "download_artifact_streamed",
+    "prepare_trec_dl_sample",
+    "validate_download_url",
+]