gravity-cli 0.7.5__tar.gz → 0.8.0__tar.gz

{gravity_cli-0.7.5 → gravity_cli-0.8.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.5
 Name: gravity-cli
-Version: 0.7.5
+Version: 0.8.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.7.5
+Requires-Dist: gravity-schema==0.8.0
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: keyring>=25.0.0
 Requires-Dist: python-dotenv>=1.0.0

{gravity_cli-0.7.5 → gravity_cli-0.8.0}/packages/gravity-schema/gravity_schema/catalog.yaml

@@ -327,6 +327,24 @@
   guarantee: certified
   side_effect: write
 
+- name: x.user_lookup
+  slug: TWITTER_USER_LOOKUP_BY_USERNAME
+  toolkit: twitter
+  description: look up an X account by its @username (without the @) through the person's own X developer app; returns its id (what x.send_dm takes), name, bio and counts
+  scopes: [users.read]
+  breadth: generic
+  guarantee: certified
+  side_effect: read
+
+- name: x.send_dm
+  slug: TWITTER_SEND_A_NEW_MESSAGE_TO_A_USER
+  toolkit: twitter
+  description: send a direct message on X to one account (participant_id from x.user_lookup) from the person's own X developer app, billed to their X API account; X delivers it only when the recipient accepts messages from them
+  scopes: [dm.write, dm.read, tweet.read, users.read]
+  breadth: generic
+  guarantee: certified
+  side_effect: write
+
 - name: forms.create
   slug: GOOGLEFORMS_CREATE_FORM
   toolkit: googleforms
@@ -399,6 +417,42 @@
   guarantee: community
   side_effect: read
 
+- name: byteforms.create_form
+  slug: BYTEFORMS_CREATE_FORM
+  toolkit: byteforms
+  description: create a public Byteforms form from text, email and phone fields, with an optional close date (stop_submissions_after) and submission cap; returns its id and public_id for the link; runs on Gravity's own Byteforms account where Gravity connected one
+  scopes: []
+  breadth: generic
+  guarantee: community
+  side_effect: write
+
+- name: byteforms.get_form
+  slug: BYTEFORMS_GET_FORM_BY_ID
+  toolkit: byteforms
+  description: read one Byteforms form by its numeric id (fields, options, link)
+  scopes: []
+  breadth: generic
+  guarantee: community
+  side_effect: read
+
+- name: byteforms.list_forms
+  slug: BYTEFORMS_GET_ALL_FORMS2
+  toolkit: byteforms
+  description: list the forms on the Byteforms account
+  scopes: []
+  breadth: generic
+  guarantee: community
+  side_effect: read
+
+- name: byteforms.get_responses
+  slug: BYTEFORMS_GET_FORM_RESPONSES
+  toolkit: byteforms
+  description: read the responses to one Byteforms form by its numeric id, newest first, with a cursor for more
+  scopes: []
+  breadth: generic
+  guarantee: community
+  side_effect: read
+
 - name: scrapecreators.linkedin_profile
   slug: SCRAPECREATORS_GET_LINKEDIN_PROFILE
   toolkit: scrapecreators

{gravity_cli-0.7.5 → gravity_cli-0.8.0}/packages/gravity-schema/gravity_schema/manifest.py

@@ -596,6 +596,15 @@ class OutputSpec(BaseModel):
         return v
 
 
+class AdapterOption(BaseModel):
+    """How one pick reads to the person when the app's name alone does not say it."""
+
+    model_config = _STRICT
+
+    title: Annotated[str, Field(min_length=1, max_length=C.MAX_LABEL_LENGTH)]
+    about: Annotated[str, Field(max_length=C.MAX_LABEL_LENGTH)] | None = None
+
+
 class SlotSpec(BaseModel):
     """A swappable part. Adapter <name> is src/adapters/<slot>/<name>.py; its tools are granted only when picked."""
 
@@ -606,9 +615,28 @@ class SlotSpec(BaseModel):
     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
+    # Asked when this action runs instead of at setup, after the action's own questions; the pick is kept for later runs.
+    ask_in: Annotated[str, Field(max_length=C.MAX_NAME_LENGTH)] | None = None
+    # With ask_in: asked only when this holds (names the action's inputs, setup inputs or other slots).
+    show_if: Annotated[ShowIf | None, Field(max_length=C.MAX_INPUTS)] = None
+    # Per adapter: the option's title and one line on what picking it means.
+    options: dict[str, AdapterOption] = Field(default_factory=dict)
 
     @model_validator(mode="after")
     def _check(self) -> SlotSpec:
+        unknown = [n for n in self.options if n not in self.adapters]
+        if unknown:
+            raise PydanticCustomError(
+                ErrorCode.INVALID_INPUT.value,
+                "Slot option '{value}' is not one of its adapters.",
+                {"value": unknown[0], "remediation": f"Describe adapters only: {', '.join(self.adapters)}."},
+            )
+        if self.show_if and not self.ask_in:
+            raise PydanticCustomError(
+                ErrorCode.INVALID_CONDITION.value,
+                "A slot's show_if needs ask_in: a setup choice is always asked.",
+                {"remediation": "Add ask_in: <action>, or drop show_if."},
+            )
         for name, tools in self.adapters.items():
             if not C.INPUT_NAME_RE.match(name):
                 raise PydanticCustomError(
@@ -1042,6 +1070,20 @@ class Manifest(BaseModel):
         _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)
+        actions = {a.name: a for a in self.actions}
+        for name, slot in self.slots.items():
+            if slot.ask_in is None:
+                continue
+            if slot.ask_in not in actions:
+                raise PydanticCustomError(
+                    ErrorCode.INVALID_ACTION.value,
+                    "Slot '{value}' is asked in action '{other}', which is not declared.",
+                    {"value": name, "other": slot.ask_in, "remediation": "Name an action under `actions`."},
+                )
+            # Checked as a question asked after the action's own: any of them, the setup inputs and the other slots.
+            asked = InputSpec.model_construct(name=name, type=InputType.STATIC_DROPDOWN, show_if=slot.show_if)
+            others = {k: v for k, v in self.slots.items() if k != name}
+            _check_show_if([asked], others, f"slots.{name}", earlier=[*self.inputs, *actions[slot.ask_in].inputs])
         names = {i.name: i for i in self.inputs}
         grouped: set[str] = set()
         for g in self.choose_one:

{gravity_cli-0.7.5 → gravity_cli-0.8.0}/packages/gravity-schema/gravity_schema/rules.py

@@ -83,6 +83,21 @@ def visible_action_inputs(manifest: Manifest, action: ActionSpec, answers: dict[
     return _walk(action.inputs, [], action_answers, known)
 
 
+def action_slots(manifest: Manifest, action: ActionSpec, answers: dict[str, Any],
+                 action_answers: dict[str, Any]) -> list[str]:
+    """The setup choices this action asks after its own questions (slots with ask_in), in manifest order."""
+    known = _slot_picks(manifest, answers)
+    for name in visible_inputs(manifest, answers):
+        if name in answers:
+            known[name] = answers[name]
+    for name in visible_action_inputs(manifest, action, answers, action_answers):
+        if name in action_answers:
+            known[name] = action_answers[name]
+    return [name for name, slot in manifest.slots.items()
+            if slot.ask_in == action.name
+            and all(ref in known and _holds(known[ref], want) for ref, want in (slot.show_if or {}).items())]
+
+
 def apply_rules(manifest: Manifest, answers: dict[str, Any]) -> dict[str, Any]:
     """The answers a run gets: slot picks and visible inputs; a hidden input's value is dropped."""
     keep = set(visible_inputs(manifest, answers)) | set(manifest.slots)

{gravity_cli-0.7.5 → gravity_cli-0.8.0}/packages/gravity-schema/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "gravity-schema"
-version = "0.7.5"
+version = "0.8.0"
 description = "Gravity agent manifest contract — models, validation, and JSON Schema export"
 readme = "README.md"
 license = "Apache-2.0"

{gravity_cli-0.7.5 → gravity_cli-0.8.0}/packages/gravity-schema/schema/manifest.schema.json

@@ -110,6 +110,36 @@
       "title": "ActionSpec",
       "type": "object"
     },
+    "AdapterOption": {
+      "additionalProperties": false,
+      "description": "How one pick reads to the person when the app's name alone does not say it.",
+      "properties": {
+        "about": {
+          "anyOf": [
+            {
+              "maxLength": 200,
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "About"
+        },
+        "title": {
+          "maxLength": 200,
+          "minLength": 1,
+          "title": "Title",
+          "type": "string"
+        }
+      },
+      "required": [
+        "title"
+      ],
+      "title": "AdapterOption",
+      "type": "object"
+    },
     "AgentKind": {
       "description": "transform: input in, result out (the platform delivers). interactive: tools mid-flow,\nmaybe several turns. monitor: scheduled or event-driven, remembers the last run.",
       "enum": [
@@ -693,6 +723,19 @@
           "title": "Adapters",
           "type": "object"
         },
+        "ask_in": {
+          "anyOf": [
+            {
+              "maxLength": 64,
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Ask In"
+        },
         "default": {
           "title": "Default",
           "type": "string"
@@ -706,6 +749,61 @@
           "default": false,
           "title": "Multiple",
           "type": "boolean"
+        },
+        "options": {
+          "additionalProperties": {
+            "$ref": "#/$defs/AdapterOption"
+          },
+          "title": "Options",
+          "type": "object"
+        },
+        "show_if": {
+          "anyOf": [
+            {
+              "additionalProperties": {
+                "anyOf": [
+                  {
+                    "type": "string"
+                  },
+                  {
+                    "type": "boolean"
+                  },
+                  {
+                    "type": "integer"
+                  },
+                  {
+                    "type": "number"
+                  },
+                  {
+                    "items": {
+                      "anyOf": [
+                        {
+                          "type": "string"
+                        },
+                        {
+                          "type": "boolean"
+                        },
+                        {
+                          "type": "integer"
+                        },
+                        {
+                          "type": "number"
+                        }
+                      ]
+                    },
+                    "type": "array"
+                  }
+                ]
+              },
+              "maxProperties": 50,
+              "type": "object"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Show If"
         }
       },
       "required": [

gravity_cli-0.8.0/packages/gravity-schema/tests/test_slots.py

@@ -0,0 +1,104 @@
+"""Slots: a swappable adapter per slot; only the picked adapter's tools are granted."""
+
+import pytest
+from gravity_schema import dev_catalog, validate_manifest
+from gravity_schema.errors import ManifestValidationError
+
+BASE = {
+    "name": "digest",
+    "runtime": {"entrypoint": "src/agent.py:graph"},
+    "permissions": {"tools": ["gmail.read"]},
+    "slots": {
+        "deliver": {
+            "label": "Where to send it",
+            "default": "gmail",
+            "adapters": {"gmail": ["gmail.draft"], "linear": ["linear.list_teams", "linear.create_issue"]},
+        }
+    },
+}
+
+
+def test_only_the_picked_adapter_is_granted():
+    m = validate_manifest(BASE, catalog=dev_catalog())
+    assert m.tools_for({}) == ["gmail.read", "gmail.draft"]
+    assert m.tools_for({"deliver": "linear"}) == ["gmail.read", "linear.list_teams", "linear.create_issue"]
+    assert m.default_inputs()["deliver"] == "gmail"
+    with pytest.raises(ValueError):
+        m.tools_for({"deliver": "../../etc"})  # a pick is never a free path
+
+
+def test_bad_slots_are_rejected():
+    for patch in (
+        {"default": "slack"},                                   # default not an adapter
+        {"adapters": {"gmail": ["GMAIL_SEND_EMAIL"]}, "default": "gmail"},  # vendor slug
+    ):
+        bad = {**BASE, "slots": {"deliver": {**BASE["slots"]["deliver"], **patch}}}
+        with pytest.raises(ManifestValidationError):
+            validate_manifest(bad)
+    clash = {**BASE, "inputs": [{"name": "deliver", "type": "text", "label": "x"}]}
+    with pytest.raises(ManifestValidationError):
+        validate_manifest(clash)
+
+
+def test_adapter_tools_are_checked_against_the_catalog():
+    bad = {**BASE, "slots": {"deliver": {**BASE["slots"]["deliver"], "adapters": {"gmail": ["gmail.nope"]}}}}
+    with pytest.raises(ManifestValidationError) as e:
+        validate_manifest(bad, catalog=dev_catalog())
+    assert "slots.deliver.adapters.gmail[0]" in str(e.value.issues[0].location)
+
+
+def test_approvals_may_name_an_adapter_tool():
+    m = validate_manifest({**BASE, "approvals": {"required_for": ["gmail.draft"]}})
+    assert "gmail.draft" in m.declared_tools
+
+
+# A choice that only one step needs: asked when that action runs, under the action's own answers.
+ASKED = {
+    **BASE,
+    "actions": [
+        {"name": "find", "label": "Find", "default": True},
+        {"name": "reach", "label": "Reach out", "requires": ["find"], "inputs": [
+            {"name": "channels", "type": "multi-select", "label": "Where?", "options": ["Email", "X message"], "min": 1}]},
+    ],
+    "slots": {
+        **BASE["slots"],
+        "x_send": {
+            "label": "How should I send your X messages?",
+            "default": "manual",
+            "ask_in": "reach",
+            "show_if": {"channels": "X message"},
+            "adapters": {"x_api": ["gmail.draft"], "manual": []},
+            "options": {"x_api": {"title": "My X developer app", "about": "Uses your own keys"},
+                        "manual": {"title": "I'll send them myself"}},
+        },
+    },
+}
+
+
+def test_an_action_asks_its_own_setup_choice():
+    from gravity_schema.rules import action_slots, visible_inputs
+
+    m = validate_manifest(ASKED)
+    reach = next(a for a in m.actions if a.name == "reach")
+    assert action_slots(m, reach, {}, {"channels": ["Email", "X message"]}) == ["x_send"]
+    assert action_slots(m, reach, {}, {"channels": ["Email"]}) == []
+    assert action_slots(m, m.actions[0], {}, {}) == []
+    assert visible_inputs(m, {}) == []  # never a setup question
+    assert m.tools_for({}) == ["gmail.read", "gmail.draft"]  # the default pick grants nothing more
+    assert m.tools_for({"x_send": "x_api"}) == ["gmail.read", "gmail.draft"]
+    assert m.slots["x_send"].options["manual"].about is None
+
+
+def test_bad_action_asked_slots_are_rejected():
+    slot = ASKED["slots"]["x_send"]
+    for patch in (
+        {"ask_in": "nowhere"},                                  # not an action
+        {"show_if": {"channels": "Fax"}},                       # a value channels cannot take
+        {"show_if": {"later": "x"}},                            # names nothing asked before
+        {"ask_in": None},                                       # show_if without ask_in
+        {"options": {"carrier_pigeon": {"title": "Pigeon"}}},   # describes no adapter
+        {"options": {"manual": {"title": ""}}},                 # an empty title
+    ):
+        bad = {**ASKED, "slots": {**ASKED["slots"], "x_send": {**slot, **patch}}}
+        with pytest.raises(ManifestValidationError):
+            validate_manifest(bad)

{gravity_cli-0.7.5 → gravity_cli-0.8.0}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "gravity-cli"
-version = "0.7.5"
+version = "0.8.0"
 description = "gravity cli — init, run, and push python agents to the Gravity marketplace"
 readme = "README.md"
 license = "Apache-2.0"
 license-files = ["LICENSE", "NOTICE"]
 requires-python = ">=3.12"
 dependencies = [
-    "gravity-schema==0.7.5",  # released in lockstep: always the same version as this package
+    "gravity-schema==0.8.0",  # released in lockstep: always the same version as this package
     "typer>=0.15.0",
     "httpx>=0.27.0",
     "rich>=13.9.0",

{gravity_cli-0.7.5 → gravity_cli-0.8.0}/src/gravity_cli/BUILDER_GUIDE.md

@@ -90,6 +90,9 @@ inputs:                             # becomes the user's form; arrives as state[
     type: email                     # text | textarea | number | boolean | static-dropdown | email | url | date | secret | file
     label: "Where to send the digest"
     required: true
+                                    # number, email, url, date and boolean answers are checked on every hosted run: a wrong
+                                    # form is refused on the question ("Enter one email address"); a url typed as
+                                    # example.com arrives as https://example.com
 
 permissions:
   tools:                            # EVERY tool your code calls, by Gravity name (§7)
@@ -457,7 +460,10 @@ that only works for tools loaded with `await gravity.tools()`: a gated call made
 fails there with `APPROVAL_REQUIRED`. The example's `load_tools()` does this, and falls back to the MCP client
 when `gravity` is not installed (`gravity run`, `gravity dev`, tests). After the decision the node that made
 the call runs again from its start, so keep the gated call last in its node. If you wrap the call in a broad
-`except`, re-raise `langgraph.errors.GraphBubbleUp` first (`except GraphBubbleUp: raise`), or the pause is swallowed.
+`except`, re-raise `langgraph.errors.GraphBubbleUp` first (`except GraphBubbleUp: raise`). If you forget, the
+hosted platform raises the caught pause again when the node ends, so the person is still asked; but the code after
+your `except` has already run once (it thought the call failed) and runs again after the decision. Under
+`gravity run` nothing raises it again, so test the approval path locally.
 
 ### 6.2 Platform adapters: let the user choose where results go
 
@@ -489,6 +495,27 @@ slots:
       linear: [linear.list_teams, linear.create_issue, linear.get_issue]
 ```
 
+A choice that only one step needs is asked by that step instead of at setup: give the slot
+`ask_in: <action>` (and a `show_if` on that action's answers if it applies only sometimes). The
+step asks it after its own questions, the run gets the pick's tools, and the pick is kept for later
+runs. Until then the `default` applies, so default to the pick that needs no account. `options`
+says what each pick means:
+
+```yaml
+slots:
+  x_send:
+    label: "How should I send your X messages?"
+    default: manual
+    ask_in: reach_out
+    show_if: { channels: "X message" }
+    adapters:
+      x_api: [x.user_lookup, x.send_dm]
+      manual: []
+    options:
+      x_api: { title: "My X developer app", about: "Sends through your own X app; X bills your developer account." }
+      manual: { title: "I'll send them myself", about: "I write each message; you send it." }
+```
+
 `src/adapters/deliver/__init__.py`: the contract every adapter follows:
 
 ```python
@@ -657,6 +684,8 @@ memory.previous()   # the last finished run of this conversation: action, inputs
 - There is no user id in the API: the run decides whose memory it is, so your code can never reach
   another user's. A write over a limit raises `MemoryQuotaError` and writes nothing.
 - Items expire `keep_days` after their last write. The user sees and deletes what the agent keeps.
+- Each call is one blocking request. Read a collection once (`find(limit=500)`) and reuse the list instead of
+  calling `get` per record; check many keys with one `has_many`.
 - Under `gravity run` the same calls use `.gravity/memory/`; `gravity memory ls` shows it.
 
 ### 6.5 Actions: more than one thing to do

{gravity_cli-0.7.5 → gravity_cli-0.8.0}/src/gravity_cli/CHANGELOG.md

@@ -4,6 +4,16 @@ Shown by `gravity update` and `gravity changelog`, and after an update. Each rel
 then one bullet per change: `- new|improved|fixed: A one-line headline. The detail behind it.`
 Write it for a builder, not for a maintainer. `tests/test_changelog.py` fails a release that has no entry.
 
+## 0.8.0 - 2026-10-25
+
+- new: A step can ask its own setup choice. A slot with `ask_in: <action>` is asked when that action runs (after its own questions, under its own `show_if`), not at setup; the run gets the pick's tools and asks for its app if needed. `options` gives each pick a title and a line on what it means.
+- new: X through the person's own X developer app. x.user_lookup finds an account by @username and x.send_dm sends it a message, billed to their X API account (Composio's X toolkit has no shared app, so each person connects their own).
+- improved: Docs on what the platform does with a caught approval pause, and on keeping memory calls few.
+
+## 0.7.6 - 2026-10-24
+
+- new: Byteforms tools. byteforms.create_form builds a public form from text, email and phone fields with a close date, and byteforms.get_responses reads what people sent (plus get_form and list_forms). Where Gravity has connected its own Byteforms account, every user's runs use it and nobody connects anything.
+
 ## 0.7.5 - 2026-10-24
 
 - new: ScrapeCreators tools on Gravity's account. scrapecreators.linkedin_profile reads a public LinkedIn profile in full (experience with descriptions, education, recent activity) where LinkedIn refuses a plain read, plus linkedin_post, twitter_profile, twitter_tweets, reddit_search (no Reddit API key) and social_profiles. They run through Composio Instant, charged to the run's budget.

{gravity_cli-0.7.5 → gravity_cli-0.8.0}/src/gravity_cli/docs/Gravity.agent.md

@@ -291,6 +291,17 @@ slots:                             # swappable adapters (section 10)
     adapters:
       gravity: []                  # kept in Gravity
       gmail: [gmail.draft]
+  x_send:                          # a choice only one step needs: asked when that step runs, not at setup
+    label: "How should I send your X messages?"
+    default: manual
+    ask_in: reply_drafts           # the action that asks it, after its own questions; the pick is kept for later runs
+    # show_if: { channels: "X message" }   # only when that step's answers (or setup answers, or other slots) match
+    adapters:
+      x_api: [x.user_lookup, x.send_dm]
+      manual: []
+    options:                       # how each pick reads, when the app's name alone does not say it
+      x_api: { title: "My X developer app", about: "Sends through your own X app; X bills your developer account." }
+      manual: { title: "I'll send them myself", about: "I write each message; you send it." }
 
 actions:                           # what the agent can do (section 10); leave out for one entry point
   - name: digest
@@ -342,7 +353,11 @@ Rules the validator enforces beyond field types:
   scheduled run from a manual one: no trigger field is sent.
 - **Triggers**: something must be able to start the agent; `kind: monitor` needs a schedule or a webhook.
 - **Slots**: the pick arrives as `state["inputs"][<slot>]` (a list for `multiple: true`). A run is granted
-  `permissions.tools` plus only the picked adapters' tools.
+  `permissions.tools` plus only the picked adapters' tools. A slot with `ask_in: <action>` is not asked at setup: that
+  action asks it after its own questions (when its `show_if` holds; it may name that action's inputs), the run gets the
+  pick's tools and asks to connect the pick's app if needed, and the pick is kept for later runs. Until it is asked, the
+  `default` applies, so make the default the pick that needs nothing (no account, no tools). `options` gives each
+  adapter a `title` and an `about` line for the person; without it the app's name is shown.
 - **Conditions** (`INVALID_CONDITION`): a `show_if` names a slot or an input declared above it, with values that
   input can take (an option, an adapter, `true`/`false` for a boolean). Every condition in one `show_if` must hold;
   a multi-select or multiple slot holds when any pick matches. A hidden question is never asked, never required,
@@ -459,7 +474,8 @@ async def graph():
 | No checkpointer or store passed to `compile()` | `wf.compile()` | passing one: it is replaced |
 | `messages` only for conversations, with `add_messages` | section 3 | a plain list reducer (replaces the history) |
 | No `interrupt()` of your own | gated tools pause the run for you; `gravity.ask()` asks a question | a bare `interrupt()`: `UNSUPPORTED_INTERRUPT` fails the run |
-| A gated call is never wrapped in a broad `except` | call it plainly; if you must catch, `except GraphBubbleUp: raise` first (`from langgraph.errors import GraphBubbleUp`) | `except Exception` around it: that swallows the pause for approval, so the message is sent unasked or never sent |
+| A gated call is never wrapped in a broad `except` | call it plainly; if you must catch, `except GraphBubbleUp: raise` first (`from langgraph.errors import GraphBubbleUp`) | `except Exception` around it: that catches the pause for approval. Hosted, the platform raises a caught pause again when the node ends, so the person is still asked, but everything after your `except` already ran once and runs again on resume; under `gravity run` nothing catches it for you |
+| Memory calls are few per run | `find(limit=500)` once and reuse the list; `has_many(keys)` for many keys | `get(key)` inside a loop over every record: each call is one blocking request, and hundreds of them stall the run |
 
 Also:
 
@@ -578,13 +594,18 @@ one at a time.
 | `static-dropdown` | One of `options` | string |
 | `multi-select` | Any of `options`, between `min` and `max` | list of strings |
 | `action-choice` | One of the agent's `actions` (that action runs) | string, and `state["actions"]` is that action |
-| `email`, `url`, `date` | A validated field | string |
+| `email`, `url`, `date` | A validated field: a wrong form is refused on the question itself ("Enter a web address, like example.com") | string; a `url` typed as `example.com` arrives as `https://example.com` |
 | `secret` | A masked field, sealed, never shown again | string, for that run only |
 | `file` | An upload limited by `accept` | a signed https link: accept a link, a path or text in your loader |
 
 - Hosted, **every run is checked server-side**: a visible `required` input must be there for manual, chat, webhook
   and scheduled runs alike, and a hidden one (its `show_if` fails, or the unfilled half of a `choose_one`) is
   dropped. Write `show_if: { deliver: gmail }` instead of "only when delivering to Gmail" in a label.
+- The **type is checked on every run** too: a `number`, `email`, `url`, `date` or `boolean` answer of the wrong
+  form ("fifty", "not-an-email", "my notion page") is refused with what to type, so your code never sees it. Pick
+  the type that matches: a website or a page link is `url`, not `text`. A number cannot carry `min`/`max` (only a
+  `multi-select` can), so when your agent keeps a number in a range, say so in the label and in the result ("You
+  asked for 50 leads; one run looks for 3 to 20") instead of changing it silently.
 - A **required** `file` input on its own is refused by the hosted build (`FILE_INPUT_UNSUPPORTED`) although
   `gravity validate` accepts it. For "upload or paste", put the file and a textarea in a `choose_one` group with
   `required: true`: either one satisfies it. Scheduled runs cannot carry a file input.
@@ -712,6 +733,10 @@ memory.previous()                                 # this conversation's last fin
   and deletes what an agent keeps on My agents; the builder sees counts per collection, never content.
 - `previous()` is `{"action", "actions", "inputs" (no secrets), "result", "finished_at", "truncated"}`; a result
   over 256 KB is left out and `summary` describes its shape instead.
+- Every call is one blocking request to the platform (about a third of a second), even inside an `async` node.
+  Read a collection once with `find(limit=...)` and keep the list, check many keys with `has_many`, and write only
+  what changed. A run that makes hundreds of calls in a row is slow; the platform keeps it alive, but the person
+  waits.
 - Update memory **after** the side effect succeeded, so a failed delivery is retried. Keep the notebook small.
   A follow-up such as "compare 1 and 2" can be answered from memory with no search.
 - Under `gravity run` the same calls use `.gravity/memory/` with the same limits, if the `gravity` SDK is installed

{gravity_cli-0.7.5 → gravity_cli-0.8.0}/uv.lock

@@ -164,7 +164,7 @@ wheels = [
 
 [[package]]
 name = "gravity-cli"
-version = "0.7.5"
+version = "0.8.0"
 source = { editable = "." }
 dependencies = [
     { name = "gravity-schema" },
@@ -201,7 +201,7 @@ dev = [
 
 [[package]]
 name = "gravity-schema"
-version = "0.7.5"
+version = "0.8.0"
 source = { editable = "packages/gravity-schema" }
 dependencies = [
     { name = "pydantic" },

gravity_cli-0.7.5/packages/gravity-schema/tests/test_slots.py

@@ -1,52 +0,0 @@
-"""Slots: a swappable adapter per slot; only the picked adapter's tools are granted."""
-
-import pytest
-from gravity_schema import dev_catalog, validate_manifest
-from gravity_schema.errors import ManifestValidationError
-
-BASE = {
-    "name": "digest",
-    "runtime": {"entrypoint": "src/agent.py:graph"},
-    "permissions": {"tools": ["gmail.read"]},
-    "slots": {
-        "deliver": {
-            "label": "Where to send it",
-            "default": "gmail",
-            "adapters": {"gmail": ["gmail.draft"], "linear": ["linear.list_teams", "linear.create_issue"]},
-        }
-    },
-}
-
-
-def test_only_the_picked_adapter_is_granted():
-    m = validate_manifest(BASE, catalog=dev_catalog())
-    assert m.tools_for({}) == ["gmail.read", "gmail.draft"]
-    assert m.tools_for({"deliver": "linear"}) == ["gmail.read", "linear.list_teams", "linear.create_issue"]
-    assert m.default_inputs()["deliver"] == "gmail"
-    with pytest.raises(ValueError):
-        m.tools_for({"deliver": "../../etc"})  # a pick is never a free path
-
-
-def test_bad_slots_are_rejected():
-    for patch in (
-        {"default": "slack"},                                   # default not an adapter
-        {"adapters": {"gmail": ["GMAIL_SEND_EMAIL"]}, "default": "gmail"},  # vendor slug
-    ):
-        bad = {**BASE, "slots": {"deliver": {**BASE["slots"]["deliver"], **patch}}}
-        with pytest.raises(ManifestValidationError):
-            validate_manifest(bad)
-    clash = {**BASE, "inputs": [{"name": "deliver", "type": "text", "label": "x"}]}
-    with pytest.raises(ManifestValidationError):
-        validate_manifest(clash)
-
-
-def test_adapter_tools_are_checked_against_the_catalog():
-    bad = {**BASE, "slots": {"deliver": {**BASE["slots"]["deliver"], "adapters": {"gmail": ["gmail.nope"]}}}}
-    with pytest.raises(ManifestValidationError) as e:
-        validate_manifest(bad, catalog=dev_catalog())
-    assert "slots.deliver.adapters.gmail[0]" in str(e.value.issues[0].location)
-
-
-def test_approvals_may_name_an_adapter_tool():
-    m = validate_manifest({**BASE, "approvals": {"required_for": ["gmail.draft"]}})
-    assert "gmail.draft" in m.declared_tools