gravity-cli 0.6.0__tar.gz → 0.7.0__tar.gz

{gravity_cli-0.6.0 → gravity_cli-0.7.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.5
 Name: gravity-cli
-Version: 0.6.0
+Version: 0.7.0
 Summary: gravity cli — init, run, and push python agents to the Gravity marketplace
 License-Expression: Apache-2.0
 License-File: LICENSE
 License-File: NOTICE
 Requires-Python: >=3.12
-Requires-Dist: gravity-schema==0.6.0
+Requires-Dist: gravity-schema==0.7.0
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: keyring>=25.0.0
 Requires-Dist: python-dotenv>=1.0.0

{gravity_cli-0.6.0 → gravity_cli-0.7.0}/packages/gravity-schema/gravity_schema/__init__.py

@@ -22,13 +22,19 @@ from .errors import (
 )
 from .export import manifest_json_schema
 from .manifest import (
+    ActionSpec,
     ApprovalsSpec,
+    ChooseOneSpec,
+    CollectionSpec,
     DependenciesSpec,
     InputSpec,
     InputType,
     Manifest,
+    MemoryScope,
+    MemorySpec,
     ModelsSpec,
     ModelTier,
+    OfferAs,
     PermissionsSpec,
     ResourcesSpec,
     RuntimeSpec,
@@ -36,6 +42,7 @@ from .manifest import (
     StateSpec,
     TriggersSpec,
 )
+from .rules import apply_rules, chosen_actions, problems, visible_inputs
 from .source_scan import is_agent_source, undeclared_write_tools
 from .validation import (
     check_imported_write_approvals,
@@ -70,6 +77,17 @@ __all__ = [  # noqa: RUF022 - grouped by concern, not alphabetical
     "ScheduleSpec",
     "ApprovalsSpec",
     "StateSpec",
+    "MemorySpec",
+    "MemoryScope",
+    "CollectionSpec",
+    "ChooseOneSpec",
+    "ActionSpec",
+    "OfferAs",
+    # input rules
+    "visible_inputs",
+    "apply_rules",
+    "problems",
+    "chosen_actions",
     # validation
     "validate_manifest",
     "load_manifest_text",

{gravity_cli-0.6.0 → gravity_cli-0.7.0}/packages/gravity-schema/gravity_schema/contract.py

@@ -67,6 +67,22 @@ MAX_MEMORY_MB: Final[int] = 4096
 MIN_STATE_KB: Final[int] = 1
 MAX_STATE_KB: Final[int] = 256
 
+# Memory collections (manifest `memory.collections`): keyed records, per user or per thread.
+MAX_COLLECTIONS: Final[int] = 20
+MAX_ITEM_KB: Final[int] = 64
+DEFAULT_ITEM_KB: Final[int] = 16
+MAX_ITEMS_PER_COLLECTION: Final[int] = 10_000
+MAX_KEEP_DAYS: Final[int] = 730
+DEFAULT_KEEP_DAYS: Final[int] = 30
+# Across every collection and the notebook, one user's memory of one agent.
+MAX_MEMORY_BYTES_PER_USER: Final[int] = 25 * 1024 * 1024
+MAX_MEMORY_WRITES_PER_RUN: Final[int] = 5_000
+# memory.previous(): the last finished run's result, passed whole up to this size.
+MAX_PREVIOUS_KB: Final[int] = 256
+
+# Declared actions (manifest `actions`).
+MAX_ACTIONS: Final[int] = 20
+
 
 # Generous bounds, so a pathological manifest can't tie up the validator.
 

{gravity_cli-0.6.0 → gravity_cli-0.7.0}/packages/gravity-schema/gravity_schema/errors.py

@@ -36,6 +36,9 @@ class ErrorCode(str, Enum):
     INVALID_STATE = "INVALID_STATE"
     INVALID_KIND = "INVALID_KIND"
     INVALID_OUTPUT = "INVALID_OUTPUT"
+    INVALID_CONDITION = "INVALID_CONDITION"
+    INVALID_ACTION = "INVALID_ACTION"
+    INVALID_MEMORY = "INVALID_MEMORY"
     LOCKFILE_MISMATCH = "LOCKFILE_MISMATCH"
     MISSING_FIELD = "MISSING_FIELD"
     UNKNOWN_FIELD = "UNKNOWN_FIELD"

{gravity_cli-0.6.0 → gravity_cli-0.7.0}/packages/gravity-schema/gravity_schema/manifest.py

@@ -34,6 +34,10 @@ class InputType(str, Enum):
     SECRET = "secret"
     # The agent gets a short-lived URL it fetches through the gateway.
     FILE = "file"
+    # Several of `options`; the value is a list.
+    MULTI_SELECT = "multi-select"
+    # One of this agent's declared `actions`; the chosen action runs (rules.py).
+    ACTION_CHOICE = "action-choice"
 
 
 # Which Python types each input's `default` may be.
@@ -48,8 +52,14 @@ _PYTHON_TYPES: dict[InputType, tuple[type, ...]] = {
     InputType.DATE: (str,),
     InputType.SECRET: (str,),
     InputType.FILE: (),  # never has a default
+    InputType.MULTI_SELECT: (list,),
+    InputType.ACTION_CHOICE: (str,),
 }
 
+# A `show_if` value: what the named input or slot must be for this question to be asked.
+Scalar = str | bool | int | float
+ShowIf = dict[str, Scalar | list[Scalar]]
+
 
 class ModelTier(str, Enum):
     """Capability tier, not a model name - the LLM gateway resolves it."""
@@ -189,6 +199,13 @@ class InputSpec(BaseModel):
     # File inputs only: extensions without the dot. None accepts any file.
     accept: Annotated[list[str] | None, Field(max_length=C.MAX_FILE_EXTENSIONS)] = None
     default: Any | None = None
+    # Asked only when every named earlier input or slot has one of the given values (rules.py).
+    show_if: Annotated[ShowIf | None, Field(max_length=C.MAX_INPUTS)] = None
+    # multi-select only: how many options may be picked.
+    min: Annotated[int | None, Field(ge=0, le=C.MAX_OPTIONS)] = None
+    max: Annotated[int | None, Field(ge=1, le=C.MAX_OPTIONS)] = None
+    # action-choice only: the declared actions offered, in order.
+    actions: Annotated[list[str] | None, Field(max_length=C.MAX_ACTIONS)] = None
 
     @field_validator("name")
     @classmethod
@@ -210,28 +227,69 @@ class InputSpec(BaseModel):
 
     @model_validator(mode="after")
     def _check_options(self) -> InputSpec:
-        is_dropdown = self.type is InputType.STATIC_DROPDOWN
+        is_dropdown = self.type in (InputType.STATIC_DROPDOWN, InputType.MULTI_SELECT)
 
         if is_dropdown and not self.options:
             raise PydanticCustomError(
                 ErrorCode.INVALID_INPUT.value,
-                "Input '{value}' is a static-dropdown but declares no options.",
+                "Input '{value}' is a {type} but declares no options.",
                 {
                     "value": self.name,
+                    "type": self.type.value,
                     "remediation": "Add an `options:` list, or use type 'text'.",
                 },
             )
         if self.options and not is_dropdown:
             raise PydanticCustomError(
                 ErrorCode.INVALID_INPUT.value,
-                "Input '{value}' declares options but is not a static-dropdown.",
+                "Input '{value}' declares options but is not a static-dropdown or multi-select.",
                 {
                     "value": self.name,
-                    "remediation": "Set type to 'static-dropdown', or remove `options`.",
+                    "remediation": "Set type to 'static-dropdown' or 'multi-select', or remove `options`.",
                 },
             )
         return self
 
+    @model_validator(mode="after")
+    def _check_choice_fields(self) -> InputSpec:
+        multi = self.type is InputType.MULTI_SELECT
+        if (self.min is not None or self.max is not None) and not multi:
+            raise PydanticCustomError(
+                ErrorCode.INVALID_INPUT.value,
+                "Input '{value}' sets min or max but is not a multi-select.",
+                {"value": self.name, "remediation": "Set type to 'multi-select', or remove min and max."},
+            )
+        if multi:
+            count = len(self.options or [])
+            lo, hi = self.min or 0, self.max if self.max is not None else count
+            if lo > hi or hi > count:
+                raise PydanticCustomError(
+                    ErrorCode.INVALID_INPUT.value,
+                    "Input '{value}' asks for between {lo} and {hi} picks of {count} options.",
+                    {"value": self.name, "lo": lo, "hi": hi, "count": count,
+                     "remediation": "Keep min <= max <= the number of options."},
+                )
+        choice = self.type is InputType.ACTION_CHOICE
+        if choice and not self.actions:
+            raise PydanticCustomError(
+                ErrorCode.INVALID_INPUT.value,
+                "Input '{value}' is an action-choice but lists no actions.",
+                {"value": self.name, "remediation": "Add `actions:` with the names of declared actions."},
+            )
+        if self.actions is not None and not choice:
+            raise PydanticCustomError(
+                ErrorCode.INVALID_INPUT.value,
+                "Input '{value}' lists actions but is not an action-choice.",
+                {"value": self.name, "remediation": "Set type to 'action-choice', or remove `actions`."},
+            )
+        if self.actions and len(set(self.actions)) != len(self.actions):
+            raise PydanticCustomError(
+                ErrorCode.INVALID_INPUT.value,
+                "Input '{value}' lists an action twice.",
+                {"value": self.name, "remediation": "List each action once."},
+            )
+        return self
+
     @model_validator(mode="after")
     def _check_accept(self) -> InputSpec:
         if self.accept is None:
@@ -304,13 +362,15 @@ class InputSpec(BaseModel):
                 },
             )
 
-        if self.options and self.default not in self.options:
+        picks = self.default if isinstance(self.default, list) else [self.default]
+        allowed = self.options if self.options else self.actions
+        if allowed and any(p not in allowed for p in picks):
             raise PydanticCustomError(
                 ErrorCode.INVALID_INPUT.value,
                 "Default for input '{value}' is not one of its options.",
                 {
                     "value": self.name,
-                    "remediation": f"Use one of: {', '.join(self.options)}.",
+                    "remediation": f"Use one of: {', '.join(allowed)}.",
                 },
             )
         return self
@@ -462,6 +522,51 @@ class StateSpec(BaseModel):
     max_kb: Annotated[int, Field(ge=C.MIN_STATE_KB, le=C.MAX_STATE_KB)] = C.MAX_STATE_KB
 
 
+class MemoryScope(str, Enum):
+    """Whose memory: shared by all of one user's conversations with the agent, or one conversation's."""
+
+    USER = "user"
+    THREAD = "thread"
+
+
+class CollectionSpec(BaseModel):
+    """Keyed records the agent keeps across runs. Every item expires `keep_days` after its last write."""
+
+    model_config = _STRICT
+
+    per: MemoryScope = MemoryScope.USER
+    keep_days: Annotated[int, Field(ge=1, le=C.MAX_KEEP_DAYS)] = C.DEFAULT_KEEP_DAYS
+    max_items: Annotated[int, Field(ge=1, le=C.MAX_ITEMS_PER_COLLECTION)] = C.MAX_ITEMS_PER_COLLECTION
+    max_item_kb: Annotated[int, Field(ge=1, le=C.MAX_ITEM_KB)] = C.DEFAULT_ITEM_KB
+
+
+class MemorySpec(BaseModel):
+    """Memory across runs: the small notebook (what `state.max_kb` was) and named collections."""
+
+    model_config = _STRICT
+
+    notebook_kb: Annotated[int, Field(ge=C.MIN_STATE_KB, le=C.MAX_STATE_KB)] | None = None
+    notebook_per: MemoryScope = MemoryScope.USER
+    collections: dict[str, CollectionSpec] = Field(default_factory=dict)
+
+    @model_validator(mode="after")
+    def _check_collections(self) -> MemorySpec:
+        if len(self.collections) > C.MAX_COLLECTIONS:
+            raise PydanticCustomError(
+                ErrorCode.LIMIT_EXCEEDED.value,
+                "At most {limit} memory collections.",
+                {"limit": C.MAX_COLLECTIONS, "remediation": "Merge collections, or keep several kinds of record in one."},
+            )
+        for name in self.collections:
+            if not C.INPUT_NAME_RE.match(name):
+                raise PydanticCustomError(
+                    ErrorCode.INVALID_MEMORY.value,
+                    "Collection name '{value}' is not a valid identifier.",
+                    {"value": name, "remediation": "Use lowercase letters, digits and underscores."},
+                )
+        return self
+
+
 class OutputSpec(BaseModel):
     """One rendering of the run's corpus a consumer may pick; the platform delivers it, not the agent."""
 
@@ -499,6 +604,8 @@ class SlotSpec(BaseModel):
     label: Annotated[str, Field(max_length=C.MAX_LABEL_LENGTH)]
     default: str
     adapters: dict[str, list[str]]  # adapter name -> the catalog tools it calls
+    # The consumer may pick several adapters; the pick is a list and every pick's tools are granted.
+    multiple: bool = False
 
     @model_validator(mode="after")
     def _check(self) -> SlotSpec:
@@ -550,6 +657,82 @@ class DisplaySpec(BaseModel):
     chart: ChartHint | None = None
 
 
+class ChooseOneSpec(BaseModel):
+    """An "either / or" group: once one of these inputs is filled the others are hidden.
+    With `required`, one of them must be filled."""
+
+    model_config = _STRICT
+
+    label: Annotated[str, Field(max_length=C.MAX_LABEL_LENGTH)]
+    inputs: Annotated[list[str], Field(min_length=2, max_length=C.MAX_INPUTS)]
+    required: bool = False
+
+
+class ActionSpec(BaseModel):
+    """One thing the agent can do. The runner passes the chosen ones in state["actions"]."""
+
+    model_config = _STRICT
+
+    name: Annotated[str, Field(max_length=C.MAX_NAME_LENGTH)]
+    label: Annotated[str, Field(max_length=C.MAX_LABEL_LENGTH)]
+    # Runs on the first run of a conversation, with the other defaults, in declaration order.
+    default: bool = False
+    # Offered only once these actions have completed in the conversation.
+    requires: Annotated[list[str], Field(max_length=C.MAX_ACTIONS)] = Field(default_factory=list)
+    # Works on the rows the person selects in the result; their keys arrive as action_inputs["rows"].
+    per_row: bool = False
+    # Extra questions asked only for this action, under the same rules as top-level inputs.
+    inputs: Annotated[list[InputSpec], Field(max_length=C.MAX_INPUTS)] = Field(default_factory=list)
+    # Its own recurring run; the consumer turns it on.
+    schedule: ScheduleSpec | None = None
+    # Never scheduled and never repeated by a whole-flow schedule after it once succeeded.
+    run_once: bool = False
+    # Run these next, each as its own run on the same conversation, when this one completes.
+    then: Annotated[list[str], Field(max_length=C.MAX_ACTIONS)] = Field(default_factory=list)
+
+    @field_validator("name")
+    @classmethod
+    def _check_name(cls, v: str) -> str:
+        if not C.INPUT_NAME_RE.match(v):
+            raise PydanticCustomError(
+                ErrorCode.INVALID_ACTION.value,
+                "Action name '{value}' is not a valid identifier.",
+                {"value": v, "remediation": "Use lowercase letters, digits and underscores."},
+            )
+        return v
+
+    @model_validator(mode="after")
+    def _check(self) -> ActionSpec:
+        if self.run_once and self.schedule is not None:
+            raise PydanticCustomError(
+                ErrorCode.INVALID_ACTION.value,
+                "Action '{value}' is run_once, so it cannot have a schedule.",
+                {"value": self.name, "remediation": "Remove `schedule` or `run_once`."},
+            )
+        names = [i.name for i in self.inputs]
+        if len(set(names)) != len(names):
+            raise PydanticCustomError(
+                ErrorCode.DUPLICATE_INPUT.value,
+                "Action '{value}' declares an input twice.",
+                {"value": self.name, "remediation": "Rename or remove the duplicate input."},
+            )
+        for spec in self.inputs:
+            if spec.type is InputType.ACTION_CHOICE:
+                raise PydanticCustomError(
+                    ErrorCode.INVALID_ACTION.value,
+                    "Action '{value}' asks an action-choice question.",
+                    {"value": self.name, "remediation": "Offer actions at the top level or under the output."},
+                )
+        return self
+
+
+class OfferAs(str, Enum):
+    """How the actions under a result are shown."""
+
+    BUTTONS = "buttons"
+    QUESTION = "question"
+
+
 class Manifest(BaseModel):
     """A complete agent declaration. Structural only: tool existence is checked in validation.py."""
 
@@ -576,6 +759,14 @@ class Manifest(BaseModel):
     outputs: dict[str, OutputSpec] = Field(default_factory=dict)
     # How the result shows on screen; absent, the page decides from the result itself.
     display: DisplaySpec | None = None
+    # "Either / or" input groups (rules.py).
+    choose_one: Annotated[list[ChooseOneSpec], Field(max_length=C.MAX_INPUTS)] = Field(default_factory=list)
+    # Memory across runs; `state` is the older spelling of the notebook alone.
+    memory: MemorySpec | None = None
+    # What the agent can do. Absent: one entry point, as always.
+    actions: Annotated[list[ActionSpec], Field(max_length=C.MAX_ACTIONS)] = Field(default_factory=list)
+    offer_as: OfferAs = OfferAs.BUTTONS
+    offer_label: Annotated[str, Field(max_length=C.MAX_LABEL_LENGTH)] | None = None
 
     @field_validator("contract")
     @classmethod
@@ -706,6 +897,133 @@ class Manifest(BaseModel):
             )
         return self
 
+    @model_validator(mode="after")
+    def _check_memory(self) -> Manifest:
+        if self.state is not None and self.memory is not None:
+            raise PydanticCustomError(
+                ErrorCode.INVALID_MEMORY.value,
+                "Both `state` and `memory` are declared.",
+                {"remediation": "Move state.max_kb to memory.notebook_kb and remove `state`."},
+            )
+        return self
+
+    @model_validator(mode="after")
+    def _check_actions(self) -> Manifest:
+        by_name: dict[str, ActionSpec] = {}
+        for a in self.actions:
+            if a.name in by_name:
+                raise PydanticCustomError(
+                    ErrorCode.INVALID_ACTION.value,
+                    "Action '{value}' is declared more than once.",
+                    {"value": a.name, "remediation": "Rename or remove the duplicate action."},
+                )
+            by_name[a.name] = a
+        for a in self.actions:
+            for field in ("requires", "then"):
+                unknown = [n for n in getattr(a, field) if n not in by_name or n == a.name]
+                if unknown:
+                    raise PydanticCustomError(
+                        ErrorCode.INVALID_ACTION.value,
+                        "Action '{value}' {field} '{other}', which is not another declared action.",
+                        {"value": a.name, "field": field, "other": unknown[0],
+                         "remediation": f"Use one of: {', '.join(n for n in by_name if n != a.name) or '(none)'}."},
+                    )
+            for n in a.then:
+                if by_name[n].run_once:
+                    raise PydanticCustomError(
+                        ErrorCode.INVALID_ACTION.value,
+                        "Action '{value}' chains into '{other}', which is run_once.",
+                        {"value": a.name, "other": n, "remediation": "Chain only actions that may run again."},
+                    )
+        for field in ("requires", "then"):
+            loop = _cycle({a.name: getattr(a, field) for a in self.actions})
+            if loop:
+                raise PydanticCustomError(
+                    ErrorCode.INVALID_ACTION.value,
+                    "Actions loop through `{field}`: {value}.",
+                    {"field": field, "value": " -> ".join(loop), "remediation": "Break the loop."},
+                )
+        # Default actions run first, in order, so each one's requirements must be earlier defaults.
+        done: set[str] = set()
+        for a in self.actions:
+            if not a.default:
+                continue
+            missing = [n for n in a.requires if n not in done]
+            if missing:
+                raise PydanticCustomError(
+                    ErrorCode.INVALID_ACTION.value,
+                    "Default action '{value}' requires '{other}', which does not run before it.",
+                    {"value": a.name, "other": missing[0],
+                     "remediation": "Make that action a default declared earlier, or drop `default`."},
+                )
+            done.add(a.name)
+        if self.actions and not done:
+            raise PydanticCustomError(
+                ErrorCode.INVALID_ACTION.value,
+                "No action is marked `default: true`, so a first run would do nothing.",
+                {"remediation": "Mark the first action(s) default: true."},
+            )
+        for i in [*self.inputs, *(x for a in self.actions for x in a.inputs)]:
+            unknown = [n for n in i.actions or [] if n not in by_name]
+            if unknown:
+                raise PydanticCustomError(
+                    ErrorCode.INVALID_ACTION.value,
+                    "Input '{value}' offers action '{other}', which is not declared.",
+                    {"value": i.name, "other": unknown[0], "remediation": "Declare it under `actions`."},
+                )
+        return self
+
+    @model_validator(mode="after")
+    def _check_conditions(self) -> Manifest:
+        # Slots are asked first, so any slot counts as earlier; an input only after it is declared.
+        _check_show_if(self.inputs, self.slots, "inputs")
+        for a in self.actions:
+            _check_show_if(a.inputs, self.slots, f"actions.{a.name}.inputs", earlier=self.inputs)
+        names = {i.name: i for i in self.inputs}
+        grouped: set[str] = set()
+        for g in self.choose_one:
+            for n in g.inputs:
+                if n not in names:
+                    raise PydanticCustomError(
+                        ErrorCode.INVALID_CONDITION.value,
+                        "choose_one '{value}' names '{other}', which is not an input.",
+                        {"value": g.label, "other": n, "remediation": "Name declared inputs only."},
+                    )
+                if n in grouped:
+                    raise PydanticCustomError(
+                        ErrorCode.INVALID_CONDITION.value,
+                        "Input '{value}' is in more than one choose_one group.",
+                        {"value": n, "remediation": "Keep each input in one group."},
+                    )
+                if names[n].required:
+                    raise PydanticCustomError(
+                        ErrorCode.INVALID_CONDITION.value,
+                        "Input '{value}' is in a choose_one group and also required on its own.",
+                        {"value": n, "remediation": "Remove its `required`; set `required: true` on the group."},
+                    )
+                grouped.add(n)
+            if len(set(g.inputs)) != len(g.inputs):
+                raise PydanticCustomError(
+                    ErrorCode.INVALID_CONDITION.value,
+                    "choose_one '{value}' names an input twice.",
+                    {"value": g.label, "remediation": "List each input once."},
+                )
+        return self
+
+    @property
+    def notebook_kb(self) -> int | None:
+        """The notebook's cap, None when the agent keeps no notebook."""
+        if self.memory is not None:
+            return self.memory.notebook_kb
+        return self.state.max_kb if self.state is not None else None
+
+    @property
+    def default_actions(self) -> list[str]:
+        return [a.name for a in self.actions if a.default]
+
+    def action(self, name: str) -> ActionSpec | None:
+        return next((a for a in self.actions if a.name == name), None)
+
     @property
     def declared_tools(self) -> frozenset[str]:
         """Every tool this agent could ever be granted, across all adapters."""
@@ -718,9 +1036,11 @@ class Manifest(BaseModel):
         tools = list(self.permissions.tools)
         for name, slot in self.slots.items():
             pick = inputs.get(name, slot.default)
-            if pick not in slot.adapters:
-                raise ValueError(f"{name}={pick!r}: not an adapter of this agent ({', '.join(slot.adapters)})")
-            tools += [t for t in slot.adapters[pick] if t not in tools]
+            picks = pick if slot.multiple and isinstance(pick, list) and pick else [pick]
+            for p in picks:
+                if not isinstance(p, str) or p not in slot.adapters:
+                    raise ValueError(f"{name}={p!r}: not an adapter of this agent ({', '.join(slot.adapters)})")
+                tools += [t for t in slot.adapters[p] if t not in tools]
         return tools
 
     def entrypoint_parts(self) -> tuple[str, str]:
@@ -728,5 +1048,78 @@ class Manifest(BaseModel):
 
     def default_inputs(self) -> dict[str, Any]:
         return {i.name: i.default for i in self.inputs if i.default is not None} | {
-            name: s.default for name, s in self.slots.items()
+            name: [s.default] if s.multiple else s.default for name, s in self.slots.items()
         }
+
+
+def _cycle(edges: dict[str, list[str]]) -> list[str] | None:
+    """A loop in `edges` as [a, b, ..., a], or None."""
+    state: dict[str, int] = {}  # 1 visiting, 2 done
+    path: list[str] = []
+
+    def visit(n: str) -> list[str] | None:
+        state[n] = 1
+        path.append(n)
+        for m in edges.get(n, []):
+            if state.get(m) == 1:
+                return [*path[path.index(m):], m]
+            if state.get(m) is None and (found := visit(m)):
+                return found
+        path.pop()
+        state[n] = 2
+        return None
+
+    for n in edges:
+        if state.get(n) is None and (found := visit(n)):
+            return found
+    return None
+
+
+def _check_show_if(
+    inputs: list[InputSpec],
+    slots: dict[str, SlotSpec],
+    where: str,
+    earlier: list[InputSpec] = (),
+) -> None:
+    """Each condition names a slot or an input asked before this one, with values it can take."""
+    seen: dict[str, InputSpec] = {i.name: i for i in earlier}
+    for spec in inputs:
+        for ref, want in (spec.show_if or {}).items():
+            values = want if isinstance(want, list) else [want]
+            if not values:
+                raise PydanticCustomError(
+                    ErrorCode.INVALID_CONDITION.value,
+                    "{where}.{value}.show_if.{ref} lists no values.",
+                    {"where": where, "value": spec.name, "ref": ref, "remediation": "Give one value or a list."},
+                )
+            if ref in slots:
+                allowed: list[Any] | None = list(slots[ref].adapters)
+            elif ref in seen:
+                other = seen[ref]
+                if other.type is InputType.BOOLEAN:
+                    allowed = [True, False]
+                elif other.options:
+                    allowed = list(other.options)
+                elif other.actions:
+                    allowed = list(other.actions)
+                else:
+                    allowed = None  # free text: any value
+            else:
+                raise PydanticCustomError(
+                    ErrorCode.INVALID_CONDITION.value,
+                    "{where}.{value}.show_if names '{ref}', which is not a slot or an input asked before it.",
+                    {"where": where, "value": spec.name, "ref": ref,
+                     "remediation": "Name a slot, or an input declared above this one."},
+                )
+            bad = [v for v in values if allowed is not None and v not in allowed]
+            # True == 1 in Python: a boolean condition must be written as a boolean.
+            if seen.get(ref) is not None and seen[ref].type is InputType.BOOLEAN:
+                bad += [v for v in values if not isinstance(v, bool)]
+            if bad:
+                raise PydanticCustomError(
+                    ErrorCode.INVALID_CONDITION.value,
+                    "{where}.{value}.show_if.{ref} = {bad!r} is not a value '{ref}' can take.",
+                    {"where": where, "value": spec.name, "ref": ref, "bad": bad[0],
+                     "remediation": f"Use one of: {', '.join(map(str, allowed or []))}."},
+                )
+        seen[spec.name] = spec