"""Explicit model profiles and bounded snapshots, with no eager provider imports. Profiles select source/configuration, not a claim about an unidentified provider. The allowlists below are intentionally small: model results, credentials and arbitrary neighboring files are never collected by source capture. """ from __future__ import annotations from contextlib import contextmanager, redirect_stderr, redirect_stdout from dataclasses import replace import hashlib import importlib import json import math import os from pathlib import Path import re import stat import sys from typing import Any from benchkit.artifacts import atomic_write_json from benchkit.source_snapshot import _identity, _open_source_file, inventory_digest PROFILE_SCHEMA = "starvla-rsi.model-profile/v1" SOURCE_SCHEMA = "starvla-rsi.model-source/v8" PLANNED_V2_SOURCE_SCHEMA = "starvla-rsi.model-source/v7" NATIVE_VECTOR_SOURCE_SCHEMA = "starvla-rsi.model-source/v6" TOOLS_SOURCE_SCHEMA = "starvla-rsi.model-source/v5" GROUPED_SOURCE_SCHEMA = "starvla-rsi.model-source/v4" FLAT_AGENT_SOURCE_SCHEMA = "starvla-rsi.model-source/v3" PREVIOUS_SOURCE_SCHEMA = "starvla-rsi.model-source/v2" LEGACY_SOURCE_SCHEMA = "starvla-rsi.model-source/v1" MAX_FILE_BYTES = 256 * 1024 MAX_TOTAL_BYTES = 1024 * 1024 _FACTORIES = { "anonymous_code_agent": "AgentPolicies.anonymous_code_agent.policy:create_policy", "gpt6_astra": "AgentPolicies.gpt6_astra.tools.factory:create_policy", "opus": "AgentPolicies.opus.policy:create_policy", } _GROUPED_FACTORIES = {**_FACTORIES, "gpt6_astra": "AgentPolicies.gpt6_astra.methods.policy:create_policy"} _FLAT_FACTORIES = {**_FACTORIES, "gpt6_astra": "AgentPolicies.gpt6_astra.policy:create_policy"} _HISTORICAL_FACTORIES = {profile: factory.replace("AgentPolicies.", "starVLA.", 1) for profile, factory in _FLAT_FACTORIES.items()} _COMMON_FILES = ("AgentPolicies/__init__.py", "AgentPolicies/policy_support/__init__.py", "AgentPolicies/policy_support/stop_rules.py") # v5 is a complete reviewed inventory, not an extension of retired methods. # Historical v1-v4 inventories below remain immutable and independently usable. _GPT_V5_FILES = ( "__init__.py", "profile.json", "configuration.schema.json", "dependencies.json", "configs/config.json", "configs/codex_native_config.json", "configs/codex_direct_v2_config.json", "configs/codex_planned_config.json", "prompts/codex_native_prompt.txt", "prompts/codex_direct_v2_prompt.txt", "prompts/codex_planned_prompt.txt", "methods/__init__.py", "methods/codex_native.py", "methods/codex_direct.py", "methods/codex_planned.py", "transports/__init__.py", "transports/codex_cli.py", "transports/codex_app_server.py", "tools/__init__.py", "tools/factory.py", "tools/native_io.py", "tools/json_io.py", "tools/eef_contract.py", "tools/runtime_preflight.py", "tools/direct_public_context.py", ) _GPT_V6_FILES = ( "__init__.py", "profile.json", "configuration.schema.json", "dependencies.json", "configs/config.json", "configs/codex_native_config.json", "configs/codex_direct_v3_config.json", "configs/codex_planned_config.json", "prompts/codex_native_prompt.txt", "prompts/codex_direct_v3_prompt.txt", "prompts/codex_planned_prompt.txt", "methods/__init__.py", "methods/codex_native.py", "methods/codex_direct.py", "methods/codex_planned.py", "transports/__init__.py", "transports/codex_cli.py", "transports/codex_app_server.py", "tools/__init__.py", "tools/factory.py", "tools/native_io.py", "tools/json_io.py", "tools/persistent_runtime.py", "tools/runtime_preflight.py", "tools/public_observation.py", ) _GPT_V7_FILES = _GPT_V6_FILES + ( "methods/codex_planned_v2.py", "configs/codex_planned_v2_config.json", "prompts/codex_planned_v2_prompt.txt", ) _GPT_V8_FILES = _GPT_V7_FILES + ( "methods/codex_planned_v3.py", "configs/codex_planned_v3_config.json", "prompts/codex_planned_v3_prompt.txt", ) _LEGACY_COMMON_FILES = ("starVLA/__init__.py", "starVLA/model_profiles.py", "starVLA/providers/__init__.py") _CONFIGURATION_SCHEMA = "starvla-rsi.configuration-schema/v1" _FACTORY_PARAMETERS = frozenset({"prompt", "timeout_s", "max_chunk_length", "min_action_decisions_before_give_up", "control_method", "enforce_action_guard", "image_max_edge", "safety_stop"}) _CREDENTIAL_FIELDS = frozenset({"api_key", "apikey", "authorization", "credentials", "credential", "secret", "client_secret", "password", "token", "api_token", "access_token", "refresh_token", "bearer_token"}) class UnconfiguredModelProfile(ValueError): """A display label is not a verified, runnable provider integration.""" def profile_ids() -> tuple[str, ...]: return tuple(_FACTORIES) def _source_namespace(source_schema: str) -> str: """Bind one exact package root to each immutable source schema.""" if source_schema in (SOURCE_SCHEMA, PLANNED_V2_SOURCE_SCHEMA, NATIVE_VECTOR_SOURCE_SCHEMA, TOOLS_SOURCE_SCHEMA, GROUPED_SOURCE_SCHEMA, FLAT_AGENT_SOURCE_SCHEMA): return "AgentPolicies" if source_schema in (LEGACY_SOURCE_SCHEMA, PREVIOUS_SOURCE_SCHEMA): return "starVLA" raise ValueError("unsupported model source schema") def _profile_relative(profile_id: str, name: str, source_schema: str) -> str: """Each version owns its exact paths, including the v5 default prompt.""" if source_schema in (SOURCE_SCHEMA, PLANNED_V2_SOURCE_SCHEMA, NATIVE_VECTOR_SOURCE_SCHEMA, TOOLS_SOURCE_SCHEMA) and profile_id == "gpt6_astra": if name == "prompt.txt": return "prompts/codex_native_prompt.txt" names = (_GPT_V8_FILES if source_schema == SOURCE_SCHEMA else _GPT_V7_FILES if source_schema == PLANNED_V2_SOURCE_SCHEMA else _GPT_V6_FILES if source_schema == NATIVE_VECTOR_SOURCE_SCHEMA else _GPT_V5_FILES) return next((path for path in names if path.rsplit("/", 1)[-1] == name), name) if source_schema != GROUPED_SOURCE_SCHEMA or profile_id != "gpt6_astra": return name if name in {"policy.py", "codex_policy.py", "codex_direct.py", "codex_native.py", "codex_planned.py", "action_validation.py", "direct_public_context.py"}: return "methods/" + name if name in {"responses.py", "codex_cli.py", "codex_app_server.py"}: return "transports/" + name if name in {"config.json", "codex_config.json", "codex_v2_config.json", "codex_direct_config.json", "codex_direct_v2_config.json", "codex_native_config.json", "codex_planned_config.json"}: return "configs/" + name if name in {"prompt.txt", "codex_prompt.txt", "codex_v2_prompt.txt", "codex_direct_prompt.txt", "codex_direct_v2_prompt.txt", "codex_native_prompt.txt", "codex_planned_prompt.txt"}: return "prompts/" + name return name def _allowed_files(profile_id: str, *, legacy: bool = False, source_schema: str = SOURCE_SCHEMA, method_extensions: bool = True, feedback_extensions: bool = True, persistent_extensions: bool = True, context_extensions: bool = True, native_extensions: bool = True, planned_extensions: bool = True) -> tuple[str, ...]: if not isinstance(profile_id, str) or profile_id not in _FACTORIES: raise ValueError(f"unknown model profile: {profile_id!r}") if legacy: source_schema = LEGACY_SOURCE_SCHEMA namespace = _source_namespace(source_schema) if source_schema in (SOURCE_SCHEMA, PLANNED_V2_SOURCE_SCHEMA, NATIVE_VECTOR_SOURCE_SCHEMA, TOOLS_SOURCE_SCHEMA) and profile_id == "gpt6_astra": names = (_GPT_V8_FILES if source_schema == SOURCE_SCHEMA else _GPT_V7_FILES if source_schema == PLANNED_V2_SOURCE_SCHEMA else _GPT_V6_FILES if source_schema == NATIVE_VECTOR_SOURCE_SCHEMA else _GPT_V5_FILES) return tuple(sorted(_COMMON_FILES + tuple("AgentPolicies/gpt6_astra/" + name for name in names))) legacy = source_schema == LEGACY_SOURCE_SCHEMA common = (tuple(path.replace("AgentPolicies/", namespace + "/", 1) for path in _COMMON_FILES) if not legacy else _LEGACY_COMMON_FILES) files = common + tuple(f"{namespace}/{profile_id}/{name}" for name in ( "__init__.py", "profile.json", "config.json", "prompt.txt", "dependencies.json", "policy.py")) if profile_id == "anonymous_code_agent": files += ("starVLA/providers/mailbox.py" if legacy else f"{namespace}/anonymous_code_agent/mailbox.py",) if not legacy: files += (f"{namespace}/anonymous_code_agent/prompts/control_guidance.txt", f"{namespace}/anonymous_code_agent/prompts/actor_instructions.txt", f"{namespace}/anonymous_code_agent/prompts/simpler_development.txt") elif profile_id == "gpt6_astra" and not legacy: files += (f"{namespace}/gpt6_astra/responses.py", f"{namespace}/gpt6_astra/configuration.schema.json") if method_extensions: if native_extensions: files += tuple(f"{namespace}/gpt6_astra/" + name for name in ( "codex_native.py", "codex_native_config.json", "codex_native_prompt.txt")) files += tuple(f"{namespace}/gpt6_astra/" + name for name in ( "codex_cli.py", "codex_policy.py", "codex_config.json", "codex_prompt.txt")) if feedback_extensions: files += tuple(f"{namespace}/gpt6_astra/" + name for name in ( "action_validation.py", "codex_v2_config.json", "codex_v2_prompt.txt")) if persistent_extensions: files += tuple(f"{namespace}/gpt6_astra/" + name for name in ( "codex_direct.py", "codex_direct_config.json", "codex_direct_prompt.txt", "codex_app_server.py")) if context_extensions: files += tuple(f"{namespace}/gpt6_astra/" + name for name in ( "codex_direct_v2_config.json", "codex_direct_v2_prompt.txt", "direct_public_context.py")) if planned_extensions and native_extensions and source_schema == GROUPED_SOURCE_SCHEMA: files += tuple(f"{namespace}/gpt6_astra/" + name for name in ( "codex_planned.py", "codex_planned_config.json", "codex_planned_prompt.txt")) if source_schema == GROUPED_SOURCE_SCHEMA and profile_id == "gpt6_astra": prefix = f"{namespace}/gpt6_astra/" files = tuple(prefix + _profile_relative(profile_id, path.removeprefix(prefix), source_schema) if path.startswith(prefix) else path for path in files) files += (prefix + "methods/__init__.py", prefix + "transports/__init__.py") return tuple(sorted(files)) def _method_extensions(config: dict) -> dict[str, bool]: """Select historical file sets from captured data, never a live factory. A new extension is an exact version marker, not permission to silently expand the older Responses/EEF inventories or execute captured source. """ method = "control_method" in config feedback = "enforce_action_guard" in config persistent = "codex_direct_extension" in config context = "codex_direct_context_extension" in config native = "codex_native_extension" in config planned = "codex_planned_extension" in config if planned and (not context or not native or config["codex_planned_extension"] != "planned-native/v1"): raise ValueError("unsupported planned-native source extension") if native and (not method or config["codex_native_extension"] != "native-vectors/v1"): raise ValueError("unsupported native-vector source extension") if ((feedback and not method) or (persistent and (not feedback or not method)) or (persistent and config["codex_direct_extension"] != "persistent-tools/v1") or (context and (not persistent or config["codex_direct_context_extension"] != "public-context/v2"))): raise ValueError("unsupported model source extension declaration") return {"method_extensions": method, "feedback_extensions": feedback, "persistent_extensions": persistent, "context_extensions": context, "native_extensions": native, "planned_extensions": planned} def _read(root: Path, relative: str) -> bytes: """Read one allowlisted regular file through no-follow directory handles.""" try: descriptor = _open_source_file(root, Path(relative)) with os.fdopen(descriptor, "rb") as handle: before = os.fstat(handle.fileno()) if not stat.S_ISREG(before.st_mode) or before.st_size > MAX_FILE_BYTES: raise ValueError(f"invalid or oversized model source: {relative}") payload = handle.read(MAX_FILE_BYTES + 1) if len(payload) > MAX_FILE_BYTES or _identity(os.fstat(handle.fileno())) != _identity(before): raise ValueError(f"model source changed while reading: {relative}") return payload except OSError as exc: raise ValueError(f"missing or unsafe model source: {relative}") from exc def _sha(payload: bytes) -> str: return hashlib.sha256(payload).hexdigest() def _json(payload: bytes) -> Any: def pairs(items): result = {} for key, value in items: if key in result: raise ValueError(f"duplicate model JSON key: {key}") result[key] = value return result def constant(value): raise ValueError(f"invalid model JSON constant: {value}") return json.loads(payload, object_pairs_hook=pairs, parse_constant=constant) def _scalar_type(value: Any, kind: str) -> bool: if kind == "number": return type(value) is int or (type(value) is float and math.isfinite(value)) return type(value) is {"string": str, "integer": int, "boolean": bool, "null": type(None)}.get(kind) def validate_configuration(profile_id: str, config: dict, schema: dict) -> dict[str, Any]: """Validate bounded declarative scalar fields; never execute captured model code.""" if (not isinstance(schema, dict) or set(schema) - {"runtime_preflight"} != { "schema_version", "profile_id", "execution", "fields", "factory_parameters"} or ("runtime_preflight" in schema and schema["runtime_preflight"] is not True) or schema.get("schema_version") != _CONFIGURATION_SCHEMA or schema.get("profile_id") != profile_id or schema.get("execution") not in ("direct", "mailbox")): raise ValueError("invalid model configuration schema") fields = schema["fields"] parameters = schema["factory_parameters"] if (not isinstance(fields, dict) or not 1 <= len(fields) <= 64 or not isinstance(config, dict) or set(config) != set(fields) or not isinstance(parameters, list) or any(not isinstance(key, str) for key in parameters) or len(parameters) != len(set(parameters)) or set(parameters) - _FACTORY_PARAMETERS): raise ValueError("model configuration fields or factory parameters differ from schema") for key, rule in fields.items(): if (not isinstance(key, str) or not re.fullmatch(r"[a-z][a-z0-9_]{0,63}", key) or key in _CREDENTIAL_FIELDS or any(key.endswith("_" + name) for name in ("api_key", "token", "secret", "password", "credentials")) or not isinstance(rule, dict) or set(rule) - {"type", "const", "enum", "minimum", "maximum"} or rule.get("type") not in ("string", "integer", "number", "boolean", "null")): raise ValueError("unsafe or unsupported model configuration field schema") kind, value = rule["type"], config[key] if not _scalar_type(value, kind): raise ValueError(f"invalid model configuration type: {key}") if "const" in rule and (not _scalar_type(rule["const"], kind) or value != rule["const"]): raise ValueError(f"model configuration constant mismatch: {key}") if "enum" in rule: choices = rule["enum"] if (not isinstance(choices, list) or not 1 <= len(choices) <= 32 or any(not _scalar_type(choice, kind) for choice in choices) or value not in choices): raise ValueError(f"invalid model configuration choice: {key}") for bound in ("minimum", "maximum"): if bound in rule: limit = rule[bound] if kind not in {"integer", "number"} or not _scalar_type(limit, "number"): raise ValueError(f"invalid model configuration bound: {key}") if (bound == "minimum" and value < limit) or (bound == "maximum" and value > limit): raise ValueError(f"model configuration exceeds declared bounds: {key}") if set(parameters) - {"prompt"} - set(fields): raise ValueError("model factory parameters must bind declared configuration fields") return {"execution": schema["execution"], "factory_parameters": tuple(parameters), **({"runtime_preflight": True} if "runtime_preflight" in schema else {})} def _provider_sdk(value: Any) -> Any: if (not isinstance(value, dict) or set(value) != {"name", "version"} or not isinstance(value["name"], str) or not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_.-]{0,127}", value["name"]) or (value["version"] is not None and (not isinstance(value["version"], str) or not value["version"].strip() or len(value["version"]) > 128))): raise ValueError("invalid declared provider SDK dependency") return value def _profile_data(profile_id: str, payloads: dict[str, bytes], *, require_configured: bool, legacy: bool = False, source_schema: str = SOURCE_SCHEMA, method_extensions: bool = True, feedback_extensions: bool = True, persistent_extensions: bool = True, context_extensions: bool = True, native_extensions: bool = True, planned_extensions: bool = True) -> dict[str, Any]: if legacy: source_schema = LEGACY_SOURCE_SCHEMA namespace = _source_namespace(source_schema) legacy = source_schema == LEGACY_SOURCE_SCHEMA factories = (_FACTORIES if source_schema in (SOURCE_SCHEMA, PLANNED_V2_SOURCE_SCHEMA, NATIVE_VECTOR_SOURCE_SCHEMA, TOOLS_SOURCE_SCHEMA) else _GROUPED_FACTORIES if source_schema == GROUPED_SOURCE_SCHEMA else _FLAT_FACTORIES if namespace == "AgentPolicies" else _HISTORICAL_FACTORIES) prefix = f"{namespace}/{profile_id}/" profile = _json(payloads[prefix + "profile.json"]) config_path = prefix + _profile_relative(profile_id, "config.json", source_schema) prompt_path = prefix + _profile_relative(profile_id, "prompt.txt", source_schema) config = _json(payloads[config_path]) dependencies = _json(payloads[prefix + "dependencies.json"]) if not isinstance(dependencies, dict): raise ValueError("model dependencies must be an object") schema_path = prefix + "configuration.schema.json" configuration = (_json(payloads[schema_path]) if schema_path in payloads else None) execution = {"execution": "mailbox", "factory_parameters": tuple(sorted(_FACTORY_PARAMETERS | {"directory"}))} if configuration is not None: execution = validate_configuration(profile_id, config, configuration) if (not isinstance(profile, dict) or profile.get("schema_version") != PROFILE_SCHEMA or profile.get("id") != profile_id or profile.get("factory") != factories[profile_id] or type(profile.get("configured")) is not bool or profile.get("display_name") != {"anonymous_code_agent": "Anonymous code agent", "gpt6_astra": "GPT6Astra", "opus": "Opus"}[profile_id] or set(profile) != {"schema_version", "id", "display_name", "configured", "factory", "policy"}): raise ValueError("invalid model profile identity or factory") if (not isinstance(config, dict) or config.get("schema_version") != "starvla-rsi.model-config/v1" or config.get("profile_id") != profile_id): raise ValueError("invalid model configuration identity") direct_method = "codex-direct/v3" if source_schema in (SOURCE_SCHEMA, PLANNED_V2_SOURCE_SCHEMA, NATIVE_VECTOR_SOURCE_SCHEMA) else "codex-direct/v2" if source_schema in (SOURCE_SCHEMA, PLANNED_V2_SOURCE_SCHEMA, NATIVE_VECTOR_SOURCE_SCHEMA, TOOLS_SOURCE_SCHEMA) and profile_id == "gpt6_astra" and ( config.get("control_method") not in (("codex-native/v1", direct_method, "codex-planned/v1") + (("codex-planned/v2",) if source_schema in (PLANNED_V2_SOURCE_SCHEMA, SOURCE_SCHEMA) else ()) + (("codex-planned/v3",) if source_schema == SOURCE_SCHEMA else ())) or any(key in config for key in ("codex_direct_extension", "codex_direct_context_extension", "codex_native_extension", "codex_planned_extension"))): raise ValueError("versioned registry requires an active method without historical extension markers") if source_schema in (SOURCE_SCHEMA, PLANNED_V2_SOURCE_SCHEMA, NATIVE_VECTOR_SOURCE_SCHEMA) and profile_id == "gpt6_astra" and "enforce_action_guard" in config: raise ValueError("v6 registry cannot declare the retired Dojo action guard") if dependencies != { "schema_version": "starvla-rsi.model-dependencies/v1", "files": list(_allowed_files(profile_id, source_schema=source_schema, method_extensions=method_extensions, feedback_extensions=feedback_extensions, persistent_extensions=persistent_extensions, context_extensions=context_extensions, native_extensions=native_extensions, planned_extensions=planned_extensions)), "evaluation_dependency": "harness_source/index.json", "provider_sdk": _provider_sdk(dependencies.get("provider_sdk")) if configuration is not None else None, }: raise ValueError("model dependency declaration must match the explicit source allowlist") if profile_id == "anonymous_code_agent": expected_policy = {"name": "code-agent-development", "kind": "external-code-agent", "model": None, "provider": None} if (profile.get("configured") is not True or profile.get("policy") != expected_policy or set(config) != ({"schema_version", "profile_id", "transport", "history", "max_response_bytes"} | (set() if legacy else {"policy_stop_rule_version", "min_action_decisions_before_give_up"})) or config.get("transport") != "mailbox" or config.get("history") != "current_observation_only" or type(config.get("max_response_bytes")) is not int or not 0 < config["max_response_bytes"] <= 1048576): raise ValueError("invalid anonymous mailbox profile configuration") if not legacy: from AgentPolicies.policy_support.stop_rules import validate_minimum validate_minimum(config.get("min_action_decisions_before_give_up")) if config.get("policy_stop_rule_version") != "minimum-action-decisions/v2": raise ValueError("invalid model policy stopping-rule version") elif configuration is not None: policy = profile.get("policy") if (legacy or not profile["configured"] or execution["execution"] != "direct" or not isinstance(policy, dict) or set(policy) != {"name", "kind", "model", "provider"} or any(not isinstance(policy[key], str) or not policy[key].strip() for key in policy) or any(policy[key] != config.get(key) for key in ("provider", "model"))): raise ValueError("invalid configured direct policy identity") from AgentPolicies.policy_support.stop_rules import validate_minimum validate_minimum(config.get("min_action_decisions_before_give_up")) if config.get("policy_stop_rule_version") != "minimum-action-decisions/v2": raise ValueError("invalid model policy stopping-rule version") elif (set(config) != {"schema_version", "profile_id", "provider", "model", "status"} or config.get("status") != "unconfigured; user-facing label only" or profile["configured"] or profile.get("policy") is not None or config.get("provider") is not None or config.get("model") is not None): raise ValueError("named model scaffold has no verified provider integration") if require_configured and not profile["configured"]: raise UnconfiguredModelProfile( f"{profile_id} is unconfigured: its user-facing label has no verified provider/model ID or adapter") prompt = payloads[prompt_path].decode("utf-8") if not prompt.strip() or len(prompt) > 32768: raise ValueError("profile prompt must be nonempty and at most 32768 characters") rows = [{"path": path, "size_bytes": len(payload), "sha256": _sha(payload)} for path, payload in sorted(payloads.items())] identity = {"schema_version": PROFILE_SCHEMA, "id": profile_id, "factory": profile["factory"], "profile_sha256": _sha(payloads[prefix + "profile.json"]), "config_sha256": _sha(payloads[config_path]), "prompt_sha256": _sha(payloads[prompt_path]), "dependencies_sha256": _sha(payloads[prefix + "dependencies.json"]), "source_inventory_sha256": inventory_digest(rows)} return {"profile": profile, "config": config, "prompt": prompt, "identity": identity, "files": rows, "payloads": payloads, "configuration": configuration, **execution} def load_profile(profile_id: str, *, repository: Path | None = None, require_configured: bool = True) -> dict[str, Any]: root = Path(repository) if repository is not None else Path(__file__).absolute().parents[1] payloads = {relative: _read(root, relative) for relative in _allowed_files(profile_id)} if sum(map(len, payloads.values())) > MAX_TOTAL_BYTES: raise ValueError("model source exceeds total byte limit") return _profile_data(profile_id, payloads, require_configured=require_configured) def validate_policy_parameters(data: dict[str, Any], parameters: dict[str, Any]) -> None: """Check factory overrides using captured declarations, without importing a model.""" allowed = set(data["factory_parameters"]) if set(parameters) - allowed: raise ValueError(f"unsupported profile policy parameters: {sorted(set(parameters) - allowed)}") if data["configuration"] is not None: effective = {**data["config"], **{key: value for key, value in parameters.items() if key != "prompt" and value is not None}} validate_configuration(data["profile"]["id"], effective, data["configuration"]) def create_policy(profile_id: str, **parameters): """Resolve one configured factory lazily and bind its exact source identity.""" data = load_profile(profile_id) validate_policy_parameters(data, parameters) parameters.setdefault("prompt", data["prompt"]) module_name, function_name = data["profile"]["factory"].split(":") module = importlib.import_module(module_name) expected = Path(__file__).absolute().parents[1] / (module_name.replace(".", "/") + ".py") if Path(module.__file__).absolute() != expected: raise ValueError("model factory was imported outside the selected package") policy = getattr(module, function_name)(config=data["config"], identity=data["profile"]["policy"], **parameters) policy.descriptor = replace(policy.descriptor, parameters={ **policy.descriptor.parameters, "model_profile": data["identity"], }) return policy @contextmanager def _quiet_runtime(): """Silence Python and native fd output in the single-threaded preflight CLI. Dependency initialization can print before raising. Do not retain those bytes in memory or files. This is output hygiene, not process isolation. """ sys.stdout.flush() sys.stderr.flush() with open(os.devnull, "w", encoding="utf-8") as sink, redirect_stdout(sink), redirect_stderr(sink): saved = [] try: for descriptor in (1, 2): saved.append((descriptor, os.dup(descriptor))) os.dup2(sink.fileno(), descriptor) yield finally: sink.flush() for descriptor, original in reversed(saved): try: os.dup2(original, descriptor) finally: os.close(original) def preflight_policy(policy) -> None: """Invoke a declared model capability, never native code or inference. Exception bodies from third-party imports/constructors are not public diagnostics. Reconstruct only a closed error code outside the handler. """ from benchkit.errors import PolicyPreflightError code = None try: with _quiet_runtime(): check = getattr(policy, "preflight_runtime", None) if not callable(check): code = "unsupported" elif check() is not None: code = "initialization_failed" except PolicyPreflightError as exc: code = exc.code except Exception: code = "initialization_failed" if code is not None: raise PolicyPreflightError(code) from None def preflight_profile(profile_id: str, **parameters): """Construct and locally check a declared profile with closed diagnostics. No benchmark is imported; the returned policy has not started an episode. Use only at the single-threaded CLI boundary (output fds are process-wide). """ from benchkit.errors import PolicyPreflightError code = None policy = None try: with _quiet_runtime(): if not load_profile(profile_id).get("runtime_preflight"): raise PolicyPreflightError("unsupported") policy = create_policy(profile_id, **parameters) preflight_policy(policy) except PolicyPreflightError as exc: code = exc.code except Exception: code = "initialization_failed" if code is not None: raise PolicyPreflightError(code) from None return policy def capture_model_source(output: Path, profile_id: str, prompt: str, *, repository: Path | None = None, freeze: bool = True) -> tuple[dict[str, Any], dict[str, Any]]: """Copy only declared runtime bytes plus the exact combined campaign prompt.""" data = load_profile(profile_id, repository=repository) if not isinstance(prompt, str) or not prompt.strip() or len(prompt) > 32768: raise ValueError("effective policy prompt must be nonempty and at most 32768 characters") payloads = {**data["payloads"], "campaign_prompt.txt": prompt.encode("utf-8")} destination = output / "model_source" destination.mkdir(exist_ok=False) rows = [] for relative, payload in sorted(payloads.items()): target = destination / "files" / relative target.parent.mkdir(parents=True, exist_ok=True) with target.open("xb") as stream: stream.write(payload) if freeze and relative.startswith("AgentPolicies/"): frozen = output / "frozen" / relative frozen.parent.mkdir(parents=True, exist_ok=True) if relative == "AgentPolicies/__init__.py" and frozen.exists(): if _read(output / "frozen", relative) != payload: raise ValueError("model and harness package initializers differ") else: with frozen.open("xb") as stream: stream.write(payload) rows.append({"path": relative, "size_bytes": len(payload), "sha256": _sha(payload)}) index = {"schema_version": SOURCE_SCHEMA, "profile": data["identity"], "files": rows, "file_count": len(rows), "total_bytes": sum(row["size_bytes"] for row in rows), "inventory_sha256": inventory_digest(rows), "scope": "explicit model factory/config/prompt/dependency bytes and combined campaign prompt"} atomic_write_json(destination / "index.json", index, overwrite=False) snapshot = {"schema_version": SOURCE_SCHEMA, "path": "model_source/index.json", "index_sha256": _sha((destination / "index.json").read_bytes()), "inventory_sha256": index["inventory_sha256"], "file_count": len(rows), "total_bytes": index["total_bytes"]} return data["identity"], snapshot def _inventory(root: Path, *, skip_evaluation: bool = False) -> set[str]: """Check every frozen entry, including .txt, extensionless and hidden files.""" files = set() directories = set() entries = 0 for directory, folders, names in os.walk(root, followlinks=False): for name in folders + names: entries += 1 if entries > 256: raise ValueError("model source inventory exceeds entry limit") path = Path(directory) / name relative = path.relative_to(root).as_posix() if path.is_symlink(): raise ValueError("symlink in model source inventory") if name in names: if not path.is_file(): raise ValueError("non-regular model source inventory entry") files.add(relative) elif not (skip_evaluation and relative == "evaluation"): directories.add(relative) if skip_evaluation and Path(directory) == root: folders[:] = [name for name in folders if name != "evaluation"] expected_directories = {parent.as_posix() for relative in files for parent in Path(relative).parents if parent != Path(".")} if directories != expected_directories: raise ValueError("unexpected directory in model source inventory") return files _AGENT_DRIVER_FILES = frozenset({"AgentPolicies/policy_support/runner.py", "AgentPolicies/gpt6_astra/run.py"}) def _captured_driver_paths(output: Path, reference: dict | None, *, source_schema: str) -> set[str]: """Verify exact shared driver bytes independently of the policy inventory. Older frozen bundles have no driver paths and retain their exact model allowlist. New evaluation-source snapshots may contain only these explicit agent-side drivers; an arbitrary neighboring model file is never exempted. """ if reference is None: return set() if (not isinstance(reference, dict) or reference.get("path") != "harness_source/index.json" or reference.get("files_root") != "harness_source/files"): raise ValueError("unsupported driver source reference") payload = _read(output, "harness_source/index.json") if _sha(payload) != reference.get("index_sha256"): raise ValueError("driver source index changed") index = _json(payload) rows = index.get("files") if isinstance(index, dict) else None if (not isinstance(index, dict) or index.get("schema_version") != "starvla-rsi.harness-source/v2" or not isinstance(rows, list) or any(not isinstance(row, dict) or not isinstance(row.get("path"), str) for row in rows) or len({row["path"] for row in rows}) != len(rows) or inventory_digest(rows) != reference.get("inventory_sha256")): raise ValueError("driver source inventory changed") namespace = _source_namespace(source_schema) other_namespace = "starVLA" if namespace == "AgentPolicies" else "AgentPolicies" allowed = {path.replace("AgentPolicies/", namespace + "/", 1) for path in _AGENT_DRIVER_FILES} selected = set() for row in rows: relative = row["path"] if relative.startswith(other_namespace + "/"): raise ValueError("driver source namespace differs from model source schema") if relative not in allowed: continue source = _read(output / "harness_source/files", relative) if (type(row.get("size_bytes")) is not int or len(source) != row["size_bytes"] or _sha(source) != row.get("sha256") or _read(output / "frozen", relative) != source): raise ValueError("captured agent driver changed") selected.add(relative) return selected def _verify_bundle(output: Path, identity: dict, snapshot: dict, *, freeze: bool, driver_snapshot: dict | None = None) -> tuple[dict, bytes]: from benchkit.campaigns.workflow import _campaign_path if not isinstance(identity, dict) or not isinstance(snapshot, dict): raise ValueError("profile campaigns require an explicit model source bundle") profile_id = identity.get("id") schema = snapshot.get("schema_version") namespace = _source_namespace(schema) legacy = schema == LEGACY_SOURCE_SCHEMA if (snapshot.get("path") != "model_source/index.json" or set(snapshot) != {"schema_version", "path", "index_sha256", "inventory_sha256", "file_count", "total_bytes"}): raise ValueError("unsupported model source bundle") _campaign_path(output, "model_source/index.json") index_payload = _read(output, "model_source/index.json") if _sha(index_payload) != snapshot.get("index_sha256"): raise ValueError("model source index changed") index = _json(index_payload) if not isinstance(index, dict): raise ValueError("model source index must be an object") extensions = {"method_extensions": True, "feedback_extensions": True, "persistent_extensions": True, "context_extensions": True} if profile_id == "gpt6_astra" and not legacy and schema not in (SOURCE_SCHEMA, PLANNED_V2_SOURCE_SCHEMA, NATIVE_VECTOR_SOURCE_SCHEMA, TOOLS_SOURCE_SCHEMA): # Read as bounded data only; the authenticated index, file hashes and # complete inventory are checked below. Original Responses-only v2 # bundles predate the selectable method and keep their exact allowlist. captured_config = _json(_read(output / "model_source/files", f"{namespace}/gpt6_astra/" + _profile_relative(profile_id, "config.json", schema))) if not isinstance(captured_config, dict): raise ValueError("model configuration must be an object") extensions = _method_extensions(captured_config) allowed = set(_allowed_files(profile_id, source_schema=schema, **extensions)) rows = index.get("files") expected = allowed | {"campaign_prompt.txt"} if (index.get("schema_version") != schema or index.get("profile") != identity or set(index) != {"schema_version", "profile", "files", "file_count", "total_bytes", "inventory_sha256", "scope"} or not isinstance(rows, list) or len(rows) != len(expected) or any(not isinstance(row, dict) for row in rows) or any(not isinstance(row.get("path"), str) for row in rows) or {row.get("path") for row in rows} != expected or any(set(row) != {"path", "sha256", "size_bytes"} or type(row.get("size_bytes")) is not int or not 0 <= row["size_bytes"] <= MAX_FILE_BYTES for row in rows)): raise ValueError("model source index inventory or identity changed") if sum(row["size_bytes"] for row in rows) > MAX_TOTAL_BYTES: raise ValueError("model source bundle exceeds total byte limit") for key, value in (("inventory_sha256", inventory_digest(rows)), ("file_count", len(rows)), ("total_bytes", sum(row["size_bytes"] for row in rows))): if (type(index.get(key)) is not type(value) or type(snapshot.get(key)) is not type(value) or index[key] != value or snapshot[key] != value): raise ValueError("model source inventory metadata changed") files_root = _campaign_path(output, "model_source/files", directory=True) if _inventory(files_root) != expected: raise ValueError("model source inventory changed") if freeze: package = _campaign_path(output, f"frozen/{namespace}", directory=True) other_namespace = "starVLA" if namespace == "AgentPolicies" else "AgentPolicies" other_package = output / "frozen" / other_namespace if other_package.exists() or other_package.is_symlink(): raise ValueError("mixed frozen model source namespaces") driver_paths = set() if legacy else _captured_driver_paths(output, driver_snapshot, source_schema=schema) if _inventory(package, skip_evaluation=legacy) != { path.removeprefix(namespace + "/") for path in allowed | driver_paths}: raise ValueError("frozen model source inventory changed") payloads = {} prompt_payload = b"" for row in rows: relative = row["path"] payload = _read(files_root, relative) if len(payload) != row["size_bytes"] or _sha(payload) != row["sha256"]: raise ValueError(f"model source changed: {relative}") if relative in allowed: if freeze and _read(output / "frozen", relative) != payload: raise ValueError(f"frozen model source changed: {relative}") payloads[relative] = payload else: prompt_payload = payload data = _profile_data(profile_id, payloads, require_configured=True, source_schema=schema, **extensions) if data["identity"] != identity: raise ValueError("model source identity changed") return data, prompt_payload def verify_model_source(output: Path, manifest: dict[str, Any]) -> dict[str, Any]: """Fail closed on campaign identity, declarations and all frozen siblings.""" data, prompt = _verify_bundle(output, manifest.get("model_profile"), manifest.get("model_source"), freeze=True, driver_snapshot=manifest.get("harness_source")) if (data["profile"]["policy"] != manifest["policy"] or prompt != manifest["policy_prompt"].encode("utf-8") or _sha(manifest["policy_prompt"].encode("utf-8")) != manifest.get("policy_prompt_sha256")): raise ValueError("campaign model profile/configuration identity changed") return data def capture_policy_source(run_dir: Path, policy) -> dict[str, Any]: """Capture standalone run dependencies before reset, bound to its descriptor.""" identity = policy.descriptor.parameters["model_profile"] prompt = policy.prompt if not isinstance(prompt, str) or _sha(prompt.encode("utf-8")) != policy.descriptor.parameters["prompt_sha256"]: raise ValueError("effective model policy prompt changed before capture") captured, snapshot = capture_model_source(run_dir, identity["id"], prompt, freeze=False) if captured != identity: raise ValueError("model policy source changed after factory creation") verify_policy_source(run_dir, policy.descriptor.to_dict(), snapshot) return snapshot def _direct_protocol_overrides(preset: dict, effective: dict, parameters: dict, data: dict) -> set[str]: """Bind a selected protocol to captured data, not a server or live factory. Historical Direct bundles without this declaration retain their original fixed required_protocol and three ordinary method overrides. """ added = {"protocol_presets", "protocol_preset", "native_horizon"} if not (added.intersection(preset) or "protocol_preset" in parameters or "protocol_preset" in data["config"]): return set() table = preset.get("protocol_presets") rule = (data["configuration"] or {}).get("fields", {}).get("protocol_preset", {}) if (not added.issubset(preset) or not isinstance(table, dict) or not 1 <= len(table) <= 8 or not isinstance(rule, dict) or rule.get("type") != "string" or not isinstance(rule.get("enum"), list) or len(rule["enum"]) != len(table) or set(rule["enum"]) != set(table) or "protocol_preset" not in data["factory_parameters"]): raise ValueError("invalid captured Direct protocol preset declaration") for name, entry in table.items(): if (not isinstance(name, str) or not re.fullmatch(r"[a-z][a-z0-9-]{0,63}", name) or not isinstance(entry, dict) or set(entry) != {"required_protocol", "native_horizon"} or not isinstance(entry["required_protocol"], str) or not re.fullmatch(r"[a-z0-9][a-z0-9._/-]{0,255}", entry["required_protocol"]) or type(entry["native_horizon"]) is not int or not 1 <= entry["native_horizon"] <= 1000000): raise ValueError("invalid captured Direct protocol preset entry") default, selected = preset.get("protocol_preset"), parameters.get("protocol_preset") if (type(default) is not str or default not in table or data["config"].get("protocol_preset") != default or type(selected) is not str or selected not in table or effective.get("protocol_preset") != selected): raise ValueError("Direct protocol selector differs from captured declaration") for actual, expected in ((preset, table[default]), (effective, table[selected])): if any(type(actual.get(key)) is not type(value) or actual.get(key) != value for key, value in expected.items()): raise ValueError("Direct protocol/horizon differs from selected captured preset") return {"protocol_preset", "required_protocol", "native_horizon"} def verify_policy_source(run_dir: Path, policy_descriptor: dict, snapshot: dict) -> None: """Verify a run's versioned bundle against its original policy descriptor.""" identity = policy_descriptor.get("parameters", {}).get("model_profile") data, prompt = _verify_bundle(run_dir, identity, snapshot, freeze=False) if (any(policy_descriptor.get(key) != value for key, value in data["profile"]["policy"].items()) or _sha(prompt) != policy_descriptor.get("parameters", {}).get("prompt_sha256")): raise ValueError("run policy identity or effective prompt differs from model source bundle") if snapshot.get("schema_version") in (PREVIOUS_SOURCE_SCHEMA, FLAT_AGENT_SOURCE_SCHEMA, GROUPED_SOURCE_SCHEMA, TOOLS_SOURCE_SCHEMA, NATIVE_VECTOR_SOURCE_SCHEMA, PLANNED_V2_SOURCE_SCHEMA, SOURCE_SCHEMA): namespace = _source_namespace(snapshot["schema_version"]) parameters = policy_descriptor.get("parameters", {}) method = policy_descriptor.get("version") generic = snapshot["schema_version"] in (SOURCE_SCHEMA, PLANNED_V2_SOURCE_SCHEMA, NATIVE_VECTOR_SOURCE_SCHEMA) and identity["id"] == "gpt6_astra" current = snapshot["schema_version"] in (SOURCE_SCHEMA, PLANNED_V2_SOURCE_SCHEMA, NATIVE_VECTOR_SOURCE_SCHEMA, TOOLS_SOURCE_SCHEMA) and identity["id"] == "gpt6_astra" direct_method = "codex-direct/v3" if generic else "codex-direct/v2" if current and (method not in ({"codex-native/v1", direct_method, "codex-planned/v1"} | ({"codex-planned/v2"} if snapshot["schema_version"] in (PLANNED_V2_SOURCE_SCHEMA, SOURCE_SCHEMA) else set()) | ({"codex-planned/v3"} if snapshot["schema_version"] == SOURCE_SCHEMA else set())) or parameters.get("control_method") != method): raise ValueError("unsupported or mismatched versioned model method") if identity["id"] == "gpt6_astra" and (method == "codex-direct/v3" or parameters.get("control_method") == "codex-direct/v3"): if not generic or method != "codex-direct/v3" or parameters.get("control_method") != method: raise ValueError("Codex Direct v3 requires its v6 native-vector source layout") path = f"{namespace}/gpt6_astra/configs/codex_direct_v3_config.json" preset = _json(data["payloads"][path]) effective = parameters.get("effective_config") overrides = {"timeout_s", "max_chunk_length", "image_max_edge"} # Only newly declared profiles permit this override. Historical v3 # bundles keep their original mandatory enabled preset. stop_rule = (data["configuration"] or {}).get("fields", {}).get("safety_stop") if stop_rule is not None: if (stop_rule != {"type": "boolean"} or "safety_stop" not in data["factory_parameters"]): raise ValueError("invalid captured Direct safety-stop declaration") overrides.add("safety_stop") retired_fields = {"required_protocol", "protocol_presets", "protocol_preset", "native_horizon", "enforce_action_guard", "effective_action_rules", "public_feedback_schema", "workspace_context_version", "max_translation_per_decision_m", "max_rotation_per_decision_rad", "quaternion_norm_tolerance"} declarations = {"ordinary_give_up": False, "feedback_projection": "acknowledged_counters_and_actions_plus_declared_robot_state", "initial_state_reference": "first_public_observation_not_action"} if stop_rule is None: declarations["safety_stop"] = True if (not isinstance(preset, dict) or not isinstance(effective, dict) or set(effective) != set(preset) or not overrides <= set(effective) or retired_fields.intersection(preset) or retired_fields.intersection(parameters) or json.dumps({k: v for k, v in effective.items() if k not in overrides}, sort_keys=True, allow_nan=False) != json.dumps({k: v for k, v in preset.items() if k not in overrides}, sort_keys=True, allow_nan=False) or parameters.get("preset_sha256") != _sha(data["payloads"][path]) or preset.get("schema_version") != "starvla-rsi.codex-direct-config/v3" or preset.get("control_method") != method or parameters.get("transport") != "codex-app-server/v1" or preset.get("transport") != "codex-app-server/v1" or preset.get("history") != "persistent_same_episode_thread" or preset.get("terminal_delivery") != "cancel_without_continuation" or parameters.get("provider_calls", "missing") is not None or parameters.get("automatic_crash_resume") is not False or any(type(source.get(k)) is not type(v) or source.get(k) != v for source in (preset, parameters) for k, v in declarations.items()) or any(preset.get(k) != policy_descriptor.get(k) for k in ("provider", "model")) or type(effective["timeout_s"]) not in (int, float) or not 0 < effective["timeout_s"] <= 900 or type(effective["max_chunk_length"]) is not int or not 1 <= effective["max_chunk_length"] <= 32 or type(effective["image_max_edge"]) is not int or not 0 <= effective["image_max_edge"] <= 4096 or type(preset.get("safety_stop")) is not bool or type(effective.get("safety_stop")) is not bool or any(type(parameters.get(k)) is not type(effective[k]) or parameters[k] != effective[k] for k in overrides)): raise ValueError("Codex Direct v3 differs from captured native-vector configuration") return if identity["id"] == "gpt6_astra" and ( parameters.get("control_method") == "codex-planned/v1" or (isinstance(method, str) and method.startswith("codex-planned/"))): if method not in ("codex-planned/v1", "codex-planned/v2", "codex-planned/v3") or snapshot["schema_version"] not in (GROUPED_SOURCE_SCHEMA, TOOLS_SOURCE_SCHEMA, NATIVE_VECTOR_SOURCE_SCHEMA, PLANNED_V2_SOURCE_SCHEMA, SOURCE_SCHEMA): raise ValueError("unsupported or mismatched Codex planned method version") planned_v2 = method == "codex-planned/v2" planned_v3 = method == "codex-planned/v3" if planned_v2 and snapshot["schema_version"] not in (PLANNED_V2_SOURCE_SCHEMA, SOURCE_SCHEMA): raise ValueError("Planned v2 requires its v7 or newer source inventory") if planned_v3 and snapshot["schema_version"] != SOURCE_SCHEMA: raise ValueError("Planned v3 requires its v8 source inventory") filename = ("codex_planned_v3_config.json" if planned_v3 else "codex_planned_v2_config.json" if planned_v2 else "codex_planned_config.json") path = f"{namespace}/gpt6_astra/configs/{filename}" if (not current and not _method_extensions(data["config"])["planned_extensions"]) or path not in data["payloads"]: raise ValueError("Codex planned lacks captured source declaration") preset = _json(data["payloads"][path]) effective = parameters.get("effective_config") overrides = {"timeout_s", "max_chunk_length", "image_max_edge"} if not isinstance(preset, dict): raise ValueError("invalid captured Codex planned preset") optional_stop = preset.get("schema_version") == ( "starvla-rsi.codex-planned-config/v4" if planned_v3 else "starvla-rsi.codex-planned-config/v3" if planned_v2 else "starvla-rsi.codex-planned-config/v2") if optional_stop: # The global field existed for Direct before Planned supported # it. Only Planned's new preset version grants this override. stop_rule = (data["configuration"] or {}).get("fields", {}).get("safety_stop") if stop_rule != {"type": "boolean"} or "safety_stop" not in data["factory_parameters"]: raise ValueError("invalid captured Planned safety-stop declaration") overrides.add("safety_stop") elif (preset.get("safety_stop") is not True or not isinstance(effective, dict) or effective.get("safety_stop") is not True or parameters.get("safety_stop", True) is not True): raise ValueError("historical Codex planned safety stop must remain enabled") if (not isinstance(preset, dict) or not isinstance(effective, dict) or set(effective) != set(preset) or not overrides <= set(effective) or json.dumps({k: v for k, v in effective.items() if k not in overrides}, sort_keys=True, allow_nan=False) != json.dumps({k: v for k, v in preset.items() if k not in overrides}, sort_keys=True, allow_nan=False) or parameters.get("preset_sha256") != _sha(data["payloads"][path]) or parameters.get("control_method") != method or preset.get("control_method") != method or preset.get("schema_version") not in (("starvla-rsi.codex-planned-config/v4",) if planned_v3 else ("starvla-rsi.codex-planned-config/v3",) if planned_v2 else ("starvla-rsi.codex-planned-config/v1", "starvla-rsi.codex-planned-config/v2")) or parameters.get("transport") != "codex-app-server/v1" or preset.get("transport") != "codex-app-server/v1" or preset.get("history") != "persistent_same_episode_thread_with_bounded_public_summary" or preset.get("terminal_delivery") != "cancel_without_continuation" or preset.get("ordinary_give_up") is not False or parameters.get("ordinary_give_up") is not False or any(preset.get(k) != policy_descriptor.get(k) for k in ("provider", "model")) or type(effective["timeout_s"]) not in (int, float) or not 0 < effective["timeout_s"] <= 900 or type(effective["max_chunk_length"]) is not int or not 1 <= effective["max_chunk_length"] <= 32 or type(effective["image_max_edge"]) is not int or not 0 <= effective["image_max_edge"] <= 4096 or type(preset.get("safety_stop")) is not bool or type(effective.get("safety_stop")) is not bool or any(type(parameters.get(k)) is not type(effective[k]) or parameters[k] != effective[k] for k in overrides)): raise ValueError("Codex planned differs from captured configuration") return if identity["id"] == "gpt6_astra" and ( parameters.get("control_method") == "codex-native/v1" or (isinstance(method, str) and method.startswith("codex-native/"))): if method != "codex-native/v1": raise ValueError("unsupported or mismatched Codex native method version") if identity["id"] == "gpt6_astra" and method == "codex-native/v1": path = f"{namespace}/gpt6_astra/" + _profile_relative("gpt6_astra", "codex_native_config.json", snapshot["schema_version"]) if (not current and not _method_extensions(data["config"])["native_extensions"]) or path not in data["payloads"]: raise ValueError("Codex native lacks captured source declaration") preset = _json(data["payloads"][path]) effective = parameters.get("effective_config") overrides = {"timeout_s", "max_chunk_length", "min_action_decisions_before_give_up"} if current and ( type(preset.get("max_attempts")) is not int or not 1 <= preset["max_attempts"] <= 10 or type(preset.get("retry_backoff_s")) not in (int, float) or not math.isfinite(preset["retry_backoff_s"]) or not 0 <= preset["retry_backoff_s"] <= 10 or parameters.get("automatic_retry") != { "scope": "same_policy_decision_before_action_submission", "max_attempts": preset["max_attempts"], "retry_backoff_s": preset["retry_backoff_s"]}): raise ValueError("Codex native retry declaration differs from captured configuration") if (not isinstance(effective, dict) or set(effective) != set(preset) or any(effective[k] != v for k, v in preset.items() if k not in overrides) or parameters.get("preset_sha256") != _sha(data["payloads"][path]) or parameters.get("control_method") != method or parameters.get("transport") != "codex-exec/v1" or parameters.get("max_output_tokens") is not None or parameters.get("invalid_action_handling") != "feedback" or type(effective["timeout_s"]) not in (int, float) or not 0 < effective["timeout_s"] <= 900 or type(effective["max_chunk_length"]) is not int or not 1 <= effective["max_chunk_length"] <= 5 or any(type(parameters.get(k)) is not type(effective[k]) or parameters.get(k) != effective[k] for k in ("timeout_s", "max_chunk_length", "history", "reasoning_effort")) or parameters.get("policy_stop_rule", {}).get("min_action_decisions_before_give_up") != effective["min_action_decisions_before_give_up"]): raise ValueError("Codex native differs from captured configuration") if identity["id"] == "gpt6_astra" and ( parameters.get("transport") == "codex-app-server/v1" or parameters.get("control_method") in ("codex-direct/v1", "codex-direct/v2") or (isinstance(method, str) and method.startswith("codex-direct/"))): if method not in ("codex-direct/v1", "codex-direct/v2"): raise ValueError("unsupported or mismatched Codex Direct method version") if identity["id"] == "gpt6_astra" and method in ("codex-eef/v1", "codex-eef/v2", "codex-direct/v1", "codex-direct/v2"): # Verify this captured model preset as data. Its safety-only stop # behavior must not be replaced by another method's give-up floor. persistent = method in ("codex-direct/v1", "codex-direct/v2") context_v2 = method == "codex-direct/v2" if context_v2 and not current and not _method_extensions(data["config"])["context_extensions"]: raise ValueError("Codex Direct v2 lacks declared public context source extension") if persistent and not current and not _method_extensions(data["config"])["persistent_extensions"]: raise ValueError("Codex Direct method has no declared persistent source extension") preset_name = {"codex-eef/v1": "codex_config.json", "codex-eef/v2": "codex_v2_config.json", "codex-direct/v1": "codex_direct_config.json", "codex-direct/v2": "codex_direct_v2_config.json"}[method] path = f"{namespace}/gpt6_astra/" + _profile_relative("gpt6_astra", preset_name, snapshot["schema_version"]) if path not in data["payloads"]: raise ValueError("Codex method has no declared source extension") payload = data["payloads"][path] preset, effective = _json(payload), parameters.get("effective_config") overrides = {"timeout_s", "max_chunk_length"} if method in ("codex-eef/v2", "codex-direct/v1", "codex-direct/v2"): overrides.add("enforce_action_guard") if context_v2: overrides.add("image_max_edge") edge = effective.get("image_max_edge") if isinstance(effective, dict) else None if (type(edge) is not int or not 0 <= edge <= 4096 or type(parameters.get("image_max_edge")) is not int or parameters["image_max_edge"] != edge or any(type(parameters.get(key)) is not str or parameters[key] != effective.get(key) for key in ("public_feedback_schema", "workspace_context_version"))): raise ValueError("invalid declared Direct image preview size") if persistent and isinstance(preset, dict) and isinstance(effective, dict): overrides.update(_direct_protocol_overrides(preset, effective, parameters, data)) if (not isinstance(preset, dict) or not isinstance(effective, dict) or set(effective) != set(preset) or any(effective[key] != value for key, value in preset.items() if key not in overrides) or parameters.get("preset_sha256") != _sha(payload) or parameters.get("ordinary_give_up") is not False or parameters.get("control_method") != method or preset.get("control_method") != method or parameters.get("transport") != ("codex-app-server/v1" if persistent else "codex-exec/v1") or type(effective["timeout_s"]) not in (int, float) or not 0 < effective["timeout_s"] <= 900 or type(effective["max_chunk_length"]) is not int or not 1 <= effective["max_chunk_length"] <= 5 or type(parameters.get("max_chunk_length")) is not int or parameters.get("max_chunk_length") != effective["max_chunk_length"] or type(parameters.get("timeout_s")) is not type(effective["timeout_s"]) or parameters.get("timeout_s") != effective["timeout_s"]): raise ValueError("Codex method preset differs from captured configuration") if method in ("codex-eef/v2", "codex-direct/v1", "codex-direct/v2") and ( type(effective.get("enforce_action_guard")) is not bool or type(parameters.get("enforce_action_guard")) is not bool or parameters["enforce_action_guard"] is not effective["enforce_action_guard"]): raise ValueError("Codex action guard must be a declared boolean") if persistent: # Versioned configuration and requested identity, not proof of # a model invocation, native execution, sandbox or token usage. if (json.dumps({key: effective[key] for key in preset if key not in overrides}, sort_keys=True, allow_nan=False) != json.dumps({key: value for key, value in preset.items() if key not in overrides}, sort_keys=True, allow_nan=False) or preset.get("schema_version") != ("starvla-rsi.codex-direct-config/v2" if context_v2 else "starvla-rsi.codex-direct-config/v1") or preset.get("transport") != "codex-app-server/v1" or preset.get("history") != "persistent_same_episode_thread" or preset.get("terminal_delivery") != "cancel_without_continuation" or preset.get("ordinary_give_up") is not False or any(preset.get(key) != policy_descriptor.get(key) for key in ("model", "provider")) or "effective_action_rules" in parameters): raise ValueError("Codex Direct configuration or method declaration changed") if method == "codex-eef/v2": enabled = effective["enforce_action_guard"] # Validate this declaration as data, never by importing the model. rules = { "schema_version": "starvla-rsi.codex-eef-action-rules/v2", "mandatory_interface": { "finite_numeric_components": True, "pose_length": 7, "target_quaternion_order": "wxyz", "target_quaternion_norm_tolerance": 1e-5, "measured_quaternion_norm_tolerance": 1e-4, "opening_min": 0, "opening_max": 1, "declared_action_spec_bounds": True}, "model_guard": { "enforce_action_guard": enabled, "binary_gripper_required": enabled, "max_translation_per_decision_m": effective["max_translation_per_decision_m"] if enabled else None, "max_rotation_per_decision_rad": effective["max_rotation_per_decision_rad"] if enabled else None}, "rejection": { "invalid_target_controls_executed": 0, "automatic_in_act_retry": False, "feedback_on_next_normal_call": True, "already_acknowledged_prefix_is_retained": True}} if json.dumps(parameters.get("effective_action_rules"), sort_keys=True) != json.dumps(rules, sort_keys=True): raise ValueError("Codex action rules differ from captured configuration") return from AgentPolicies.policy_support.stop_rules import stop_constraint, validate_minimum, with_stop_rule_prompt rule = policy_descriptor.get("parameters", {}).get("policy_stop_rule", {}) minimum = validate_minimum(rule.get("min_action_decisions_before_give_up")) if (rule != stop_constraint(minimum) or prompt.decode("utf-8") != with_stop_rule_prompt(prompt.decode("utf-8"), minimum)): raise ValueError("run policy stopping rule or effective prompt differs from declared model policy")