evals-lab 0.1.3 → 0.2.0

package/lab/server.py

@@ -288,9 +288,44 @@ DEFAULT_SOURCE_TYPE = "files"
 # The Entra app the page signs in to Microsoft 365 with (docs/power-automate.md
 # § Registering the app). A single-page app has no secret, so both are public
 # and served to the page; the token it gets stays in the browser, and the
-# server never sees one. Unset, a Power Automate workflow cannot be made.
+# server never sees one. The deployment's own, when it names one, then the one
+# entered in Setup (MicrosoftApp), then the published app below; with none, a
+# Power Automate workflow cannot be made.
 M365_CLIENT_ID = os.environ.get("M365_CLIENT_ID") or None
 M365_TENANT = os.environ.get("M365_TENANT") or "organizations"
+# The multitenant app published for every lab, a tenant's admin consenting to
+# it once. None until it is registered and its publisher verified: an
+# unverified app from another organisation is one most tenants' users may not
+# consent to, so shipping it earlier would only move the failure to sign-in.
+PUBLIC_M365_CLIENT_ID = None
+
+GUID = re.compile(r"[0-9a-fA-F]{8}-(?:[0-9a-fA-F]{4}-){3}[0-9a-fA-F]{12}")
+TENANT_DOMAIN = re.compile(r"(?=.{4,253}$)(?:[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?\.)+[A-Za-z]{2,63}")
+
+
+def microsoft_config():
+    """The Microsoft app this lab signs in with, and where it came from."""
+    if M365_CLIENT_ID:
+        return {"clientId": M365_CLIENT_ID, "tenant": M365_TENANT, "from": "env"}
+    kept = MICROSOFT.get() if MICROSOFT is not None else None
+    if kept:
+        return {**kept, "from": "lab"}
+    if PUBLIC_M365_CLIENT_ID:
+        return {"clientId": PUBLIC_M365_CLIENT_ID, "tenant": "organizations", "from": "default"}
+    return None
+
+
+def microsoft_problem(client_id, tenant):
+    """Why a client and tenant cannot be this lab's Microsoft app, or None."""
+    if not GUID.fullmatch(client_id):
+        return "a client ID is a GUID, the app registration's Application (client) ID"
+    if tenant.lower() in ("common", "consumers"):
+        # Microsoft retired cloud flows for personal accounts on 2025-07-26,
+        # so an authority that admits them only admits a sign-in with no flows.
+        return "a personal Microsoft account has no Power Automate flows: name a tenant, or organizations"
+    if not (tenant == "organizations" or GUID.fullmatch(tenant) or TENANT_DOMAIN.fullmatch(tenant)):
+        return "a tenant is its Directory (tenant) ID, one of its domains, or organizations"
+    return None
 
 # How much of a flow a Source keeps: a definition's size, and how many of its
 # versions -- the documents rule's ten.
@@ -420,7 +455,7 @@ SOURCE_TYPES["power-automate"]["take"] = take_record
 
 # The sign-ins a Source type may be made with, and whether this lab has each:
 # a type naming one this lab lacks cannot be made.
-SIGN_INS = {"microsoft": lambda: M365_CLIENT_ID is not None}
+SIGN_INS = {"microsoft": lambda: microsoft_config() is not None}
 
 
 # The browser stores that follow their user between devices, by their
@@ -1441,7 +1476,7 @@ def scenario_ref(sc, i):
     what version 4's upgrade gives one, by position."""
     sid = sc.get("id") if isinstance(sc, dict) else None
     name = (sc.get("name") or "").strip() if isinstance(sc, dict) and isinstance(sc.get("name"), str) else ""
-    return (sid if isinstance(sid, str) and sid else f"s{i + 1}"), (name or f"Scenario {i + 1}")
+    return (sid if isinstance(sid, str) and sid else f"s{i + 1}"), (name or f"Target {i + 1}")
 
 
 class Prompts:
@@ -1597,27 +1632,28 @@ class Prompts:
         recorded once: a second call for the same run changes nothing."""
         # The caller's connection: a Row still reads by index, as it does.
         db.row_factory = sqlite3.Row
-        for i, sc in enumerate(run.get("scenarios") or []):
-            if not isinstance(sc, dict):
-                continue
+        for i, sc, k, cell in cells_of(run):
             sid, sname = scenario_ref(sc, i)
-            for k, cell in enumerate(sc.get("stages") or []):
-                text = cell.get("prompt") if isinstance(cell, dict) else None
-                if not isinstance(text, str) or not text.strip():
-                    continue
-                pid = version = None
-                ref = cell.get("from")
-                if isinstance(ref, dict) and isinstance(ref.get("id"), str) and self._live(db, ref["id"]):
-                    pid = ref["id"]
-                    hit = db.execute("SELECT version FROM prompt_versions WHERE prompt_id = ? AND text = ? "
-                                     "ORDER BY version DESC LIMIT 1", (pid, text)).fetchone()
-                    version = hit[0] if hit else self._cut(db, pid, text)
-                if pid is None:
-                    hit = self._matching(db, text)
-                    pid, version = (hit[0], hit[1]) if hit else (self._insert(db, "", text), 1)
-                db.execute("INSERT OR IGNORE INTO prompt_uses (prompt_id, version, run_id, scenario_id, "
-                           "scenario_name, job, at) VALUES (?, ?, ?, ?, ?, ?, ?)",
-                           (pid, version, rid, sid, sname, k, at))
+            # Echo's words are no wording under test: the item is its reply,
+            # and over Prompt only the words are the reply itself.
+            if isinstance(cell, dict) and cell.get("type") in UNRECORDED_STEPS:
+                continue
+            text = cell.get("prompt") if isinstance(cell, dict) else None
+            if not isinstance(text, str) or not text.strip():
+                continue
+            pid = version = None
+            ref = cell.get("from")
+            if isinstance(ref, dict) and isinstance(ref.get("id"), str) and self._live(db, ref["id"]):
+                pid = ref["id"]
+                hit = db.execute("SELECT version FROM prompt_versions WHERE prompt_id = ? AND text = ? "
+                                 "ORDER BY version DESC LIMIT 1", (pid, text)).fetchone()
+                version = hit[0] if hit else self._cut(db, pid, text)
+            if pid is None:
+                hit = self._matching(db, text)
+                pid, version = (hit[0], hit[1]) if hit else (self._insert(db, "", text), 1)
+            db.execute("INSERT OR IGNORE INTO prompt_uses (prompt_id, version, run_id, scenario_id, "
+                       "scenario_name, job, at) VALUES (?, ?, ?, ?, ?, ?, ?)",
+                       (pid, version, rid, sid, sname, k, at))
 
     def backfill(self, runs):
         """The runs from before the library, read into it once. [runs] is
@@ -2542,16 +2578,56 @@ def registered_ids(manifest: dict) -> set:
 # ---- Connections: the lab's grants to outside services (#127) --------------
 #
 # One Google grant per lab, for Sources that read a Drive folder. The OAuth
-# client is the deployment's (env vars), never the repository's or the
-# store's; the refresh token the grant yields is the store's, in a table of
-# its own, so /api/state -- which serves the synced documents to the page --
-# can never carry it. The page is told only whether there is a grant and
-# whose. The hosts are fixed here, not chosen by anything a request carries,
-# and reached through OPENER: no redirects, no proxy from the environment.
+# client it signs in with is the deployment's (GOOGLE_* below), then the one
+# entered in Setup (GoogleApp), then the published app (PUBLIC_GOOGLE_APP),
+# as Microsoft's is (docs/power-automate.md). The refresh token the grant
+# yields is the store's, in a table of its own, so /api/state -- which serves
+# the synced documents to the page -- can never carry it, and nor can the
+# client's secret. The page is told only whether there is a grant and whose.
+# The hosts are fixed here, not chosen by anything a request carries, and
+# reached through OPENER: no redirects, no proxy from the environment.
 GOOGLE_CLIENT_ID = os.environ.get("GOOGLE_CLIENT_ID") or None
 GOOGLE_CLIENT_SECRET = os.environ.get("GOOGLE_CLIENT_SECRET") or None
 GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY") or None
-GOOGLE_APP_ID = os.environ.get("GOOGLE_APP_ID") or None
+# A deployment reached at its own address signs in with a Web application
+# client, whose redirect it registers; "installed" is Google's Desktop app.
+GOOGLE_CLIENT_TYPE = os.environ.get("GOOGLE_CLIENT_TYPE") or "web"
+GOOGLE_CLIENT_TYPES = ("installed", "web")
+# An OAuth client's id is its project's number, a dash, and Google's own
+# suffix: the number is the app id the Picker is told, so it is never asked.
+GOOGLE_CLIENT = re.compile(r"(\d+)-[0-9a-z]+\.apps\.googleusercontent\.com")
+GOOGLE_KEY = re.compile(r"[A-Za-z0-9_-]{30,60}")
+
+
+def read_published_google(path):
+    """The published app from the file the npm package's build writes
+    beside server.py: (app, None), (None, None) when there is no file, or
+    (None, why) for a file that is not one."""
+    if not path.is_file():
+        return None, None
+    try:
+        got = json.loads(path.read_text("utf-8"))
+    except (OSError, ValueError):
+        return None, f"{path} is not JSON"
+    if not (isinstance(got, dict) and isinstance(got.get("clientId"), str)
+            and GOOGLE_CLIENT.fullmatch(got["clientId"]) and isinstance(got.get("clientSecret"), str)
+            and got["clientSecret"] and isinstance(got.get("apiKey"), str) and GOOGLE_KEY.fullmatch(got["apiKey"])):
+        return None, f"{path} is not a Google app: {{ clientId, clientSecret, apiKey }}"
+    return {"clientId": got["clientId"], "clientSecret": got["clientSecret"],
+            "apiKey": got["apiKey"], "clientType": "installed"}, None
+
+
+# The Desktop-app client published for every lab, so a lab installed from
+# npm signs in with nothing to set up. A Desktop client signs in back to any
+# port on this machine with no redirect registered, and Google does not hold
+# its secret to be one: it is in every copy of the package by design. It
+# serves only a lab reached on this machine -- one reached at its own address
+# brings a Web application client of its own. Never in the repository: the
+# package's build writes it beside server.py from the Package workflow's
+# PUBLIC_GOOGLE_APP secret (docs/google-drive.md § The published app), and
+# a checkout or the image has none.
+GOOGLE_APP_FILE = HERE / "google-app.json"
+PUBLIC_GOOGLE_APP, PUBLIC_GOOGLE_PROBLEM = read_published_google(GOOGLE_APP_FILE)
 # drive.file: only what the user picks in Google's Picker, and non-sensitive,
 # so the app can be published without Google's verification (#127).
 GOOGLE_SCOPE = "https://www.googleapis.com/auth/drive.file"
@@ -2565,6 +2641,94 @@ GOOGLE_CALLBACK = "/api/connections/google/callback"
 GOOGLE_STATE_SECONDS = 600
 
 
+def google_app():
+    """The Google app this lab signs in with -- secret included, for the
+    server's own use only -- and where it came from; None with none."""
+    if GOOGLE_CLIENT_ID:
+        return {"clientId": GOOGLE_CLIENT_ID, "clientSecret": GOOGLE_CLIENT_SECRET,
+                "apiKey": GOOGLE_API_KEY, "clientType": GOOGLE_CLIENT_TYPE, "from": "env"}
+    kept = GOOGLE.get() if GOOGLE is not None else None
+    if kept:
+        return {**kept, "from": "lab"}
+    if PUBLIC_GOOGLE_APP:
+        return {**PUBLIC_GOOGLE_APP, "from": "default"}
+    return None
+
+
+def google_public(app):
+    """What the page is told of an app: everything but its secret."""
+    if app is None:
+        return None
+    m = GOOGLE_CLIENT.fullmatch(app.get("clientId") or "")
+    return {"clientId": app.get("clientId"), "clientType": app.get("clientType"),
+            "apiKey": app.get("apiKey"), "appId": m.group(1) if m else None,
+            "hasSecret": bool(app.get("clientSecret")), "from": app["from"]}
+
+
+def loopback_origin(origin) -> bool:
+    """Whether a page's origin is this machine: where a Desktop client may
+    send the browser back to."""
+    host = urllib.parse.urlsplit(origin).hostname or ""
+    return host in ("localhost", "::1") or host.startswith("127.")
+
+
+class GoogleApp:
+    """The Google app entered in Setup: a client and its secret, from the
+    client file Google hands out, and the Picker's key. Kept so a lab with no
+    deployment around it needs no environment variable; the secret is
+    written here and never read back out to the page."""
+
+    KEYS = ("google.clientId", "google.clientSecret", "google.apiKey", "google.clientType")
+
+    def __init__(self, store: Store):
+        self.store = store
+        with store.lock, closing(sqlite3.connect(store.path)) as db, db:
+            db.execute("CREATE TABLE IF NOT EXISTS settings (key TEXT PRIMARY KEY, value TEXT NOT NULL)")
+
+    def _read(self, db):
+        rows = dict(db.execute("SELECT key, value FROM settings WHERE key IN (?, ?, ?, ?)", self.KEYS))
+        return dict(zip(("clientId", "clientSecret", "apiKey", "clientType"),
+                        (rows.get(k) or None for k in self.KEYS)))
+
+    def get(self):
+        with self.store.lock, closing(sqlite3.connect(self.store.path)) as db:
+            got = self._read(db)
+        return {**got, "clientType": got["clientType"] or "installed"} if got["clientId"] else None
+
+    def set(self, payload):
+        """Keeps what is sent, or with no client id forgets it all: (kept,
+        error, whether the client changed). A secret not sent is kept while
+        the client is the same one, and forgotten when it is not: a secret
+        belongs to its client."""
+        if not isinstance(payload, dict):
+            return None, (400, "a Google app is { clientId, clientSecret, apiKey, clientType }"), False
+        client = payload.get("clientId")
+        secret, key = payload.get("clientSecret"), payload.get("apiKey")
+        ctype = payload.get("clientType") or "installed"
+        if not isinstance(client, str) or not all(v is None or isinstance(v, str) for v in (secret, key)):
+            return None, (400, "a Google app is { clientId, clientSecret, apiKey, clientType }"), False
+        client, key = client.strip(), (key or "").strip()
+        with self.store.lock, closing(sqlite3.connect(self.store.path)) as db, db:
+            had = self._read(db)
+            changed = (had["clientId"] or "") != client
+            if not client:
+                db.execute("DELETE FROM settings WHERE key IN (?, ?, ?, ?)", self.KEYS)
+                return None, None, changed
+            if not GOOGLE_CLIENT.fullmatch(client):
+                return None, (400, "a client ID ends .apps.googleusercontent.com"), False
+            if key and not GOOGLE_KEY.fullmatch(key):
+                return None, (400, "that is not an API key"), False
+            if ctype not in GOOGLE_CLIENT_TYPES:
+                return None, (400, "a client is a Desktop app or a Web application"), False
+            if secret is None:
+                secret = None if changed else had["clientSecret"]
+            secret = (secret or "").strip()
+            db.execute("DELETE FROM settings WHERE key IN (?, ?, ?, ?)", self.KEYS)
+            db.executemany("INSERT INTO settings VALUES (?, ?)",
+                           [(k, v) for k, v in zip(self.KEYS, (client, secret, key, ctype)) if v])
+        return self.get(), None, changed
+
+
 class Connections:
     """The lab's grants, held server-side; the page sees their state only."""
 
@@ -2584,7 +2748,8 @@ class Connections:
 
     @staticmethod
     def configured() -> bool:
-        return all((GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET, GOOGLE_API_KEY, GOOGLE_APP_ID))
+        app = google_app()
+        return bool(app and app.get("clientId") and app.get("clientSecret"))
 
     def _row(self):
         with self.store.lock, closing(sqlite3.connect(self.store.path)) as db:
@@ -2598,15 +2763,21 @@ class Connections:
 
     def start(self, origin: str):
         """The consent address the page sends the browser to."""
+        app = google_app()
         if not self.configured():
             return None, (409, "Google is not configured for this lab")
+        if app["clientType"] == "installed" and not loopback_origin(origin):
+            return None, (409, "a Desktop app client signs in only on this machine: "
+                               "give this lab a Web application client in Configure…")
         state = secrets.token_urlsafe(24)
         now = time.time()
         with self.lock:
             self.states = {s: v for s, v in self.states.items() if v[0] > now}
-            self.states[state] = (now + GOOGLE_STATE_SECONDS, origin)
+            # The app is kept with the state: the code Google sends back is
+            # exchanged with the client that asked for it, whatever changes.
+            self.states[state] = (now + GOOGLE_STATE_SECONDS, origin, app)
         return GOOGLE_CONSENT_URL + "?" + urllib.parse.urlencode({
-            "client_id": GOOGLE_CLIENT_ID, "redirect_uri": origin + GOOGLE_CALLBACK,
+            "client_id": app["clientId"], "redirect_uri": origin + GOOGLE_CALLBACK,
             "response_type": "code", "scope": GOOGLE_SCOPE, "state": state,
             "access_type": "offline", "prompt": "consent", "include_granted_scopes": "true",
         }), None
@@ -2626,7 +2797,7 @@ class Connections:
         which never include the code or a token."""
         state = (query.get("state") or [""])[0]
         with self.lock:
-            lapses, origin = self.states.pop(state, (0, ""))
+            lapses, origin, app = self.states.pop(state, (0, "", None))
         if lapses <= time.time():
             return "that sign-in had lapsed or was not this lab's; sign in again"
         if query.get("error"):
@@ -2636,7 +2807,7 @@ class Connections:
             return "Google sent no code back"
         try:
             got = self._call(GOOGLE_TOKEN_URL, {
-                "code": code, "client_id": GOOGLE_CLIENT_ID, "client_secret": GOOGLE_CLIENT_SECRET,
+                "code": code, "client_id": app["clientId"], "client_secret": app["clientSecret"],
                 "redirect_uri": origin + GOOGLE_CALLBACK, "grant_type": "authorization_code"})
         except (OSError, ValueError) as e:
             return f"the code could not be exchanged ({type(e).__name__})"
@@ -2654,6 +2825,12 @@ class Connections:
                         time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())))
         return None
 
+    def forget(self):
+        """Drops the grant without a word to Google: the client it was made
+        with is no longer this lab's, so the grant is no use to it."""
+        with self.store.lock, closing(sqlite3.connect(self.store.path)) as db, db:
+            db.execute("DELETE FROM connections WHERE id = 'google'")
+
     def sign_out(self):
         """Forgets the grant, and asks Google to revoke it; a revoke that
         fails still forgets it here, which is what signing out means."""
@@ -2668,6 +2845,43 @@ class Connections:
         self.problem = None
 
 
+class MicrosoftApp:
+    """The Microsoft app entered in Setup: a client ID and a tenant, neither
+    secret, kept so a lab installed rather than deployed needs no environment
+    variable to read a flow."""
+
+    KEYS = ("m365.clientId", "m365.tenant")
+
+    def __init__(self, store: Store):
+        self.store = store
+        with store.lock, closing(sqlite3.connect(store.path)) as db, db:
+            db.execute("CREATE TABLE IF NOT EXISTS settings (key TEXT PRIMARY KEY, value TEXT NOT NULL)")
+
+    def get(self):
+        with self.store.lock, closing(sqlite3.connect(self.store.path)) as db:
+            rows = dict(db.execute("SELECT key, value FROM settings WHERE key IN (?, ?)", self.KEYS))
+        client = rows.get(self.KEYS[0])
+        return {"clientId": client, "tenant": rows.get(self.KEYS[1]) or "organizations"} if client else None
+
+    def set(self, client_id, tenant):
+        """Keeps them, or with no client ID forgets them: (kept, error)."""
+        if not isinstance(client_id, str) or not isinstance(tenant, str):
+            return None, (400, "a Microsoft app is { clientId, tenant }")
+        client_id, tenant = client_id.strip(), tenant.strip() or "organizations"
+        if tenant.lower() == "organizations":
+            tenant = "organizations"
+        with self.store.lock, closing(sqlite3.connect(self.store.path)) as db, db:
+            if not client_id:
+                db.execute("DELETE FROM settings WHERE key IN (?, ?)", self.KEYS)
+                return None, None
+            bad = microsoft_problem(client_id, tenant)
+            if bad:
+                return None, (400, bad)
+            db.executemany("INSERT INTO settings VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value",
+                           zip(self.KEYS, (client_id, tenant)))
+        return self.get(), None
+
+
 class Plugins:
     """The installed plugins: their files on disk, their manifests in the store."""
 
@@ -3517,17 +3731,17 @@ def worker_destinations(run: dict):
         base = api_base(str(conn.get("url") or "")) or api_base(OLLAMA)
         why = allowed(base, "")
         if why:
-            return None, f"Setup profile {name}: {why}"
+            return None, f"Target profile {name}: {why}"
         profile = next((p for p in stored if isinstance(p, dict) and p.get("id") == pid), None)
         if profile is None:
-            return None, f"Setup profile {name} not found"
+            return None, f"Target profile {name} not found"
         key = str(profile.get("key") or "").strip()
         if key:
             if not header_safe(key):
-                return None, f"Setup profile {name} has a key that cannot go in a header"
+                return None, f"Target profile {name} has a key that cannot go in a header"
             why = allowed(base, key)
             if why:
-                return None, f"Setup profile {name}: {why}"
+                return None, f"Target profile {name}: {why}"
             env[key_var(pid)] = key
     return env, None
 
@@ -3546,12 +3760,17 @@ def worker_destinations(run: dict):
 # 7: chains are jobs: the field is `jobs` and each job's type is "job".
 # 8: a job is its steps; the content is job 1's Attach Content step.
 # 9: a test is Metrics; a Single Test or a Graded set is read converted.
-PIPELINE_VERSION = 9
+# 10: a job's steps are its stages, and each scenario is a target whose own
+# step in each job is what it sends there (docs/pipeline-model.md §16).
+PIPELINE_VERSION = 10
 # What a stored run may be: the current version, and the ones evals-core.ts's
-# upgradePipeline reads. A new submission is always the current one.
-READABLE_VERSIONS = (1, 2, 3, 4, 5, 6, 7, 8, 9)
-SCENARIO_CAP = 4
-RUN_FIELDS = ("version", "id", "name", "jobs", "scenarios", "tests", "profiles", "comment", "plugins")
+# upgradePipeline reads. A new submission is upgraded to the current one.
+READABLE_VERSIONS = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+TARGET_CAP = 4
+# Target steps whose words the Prompt library does not record as a use: they
+# ask no model (evals-core.ts's STEP_TYPES.echo).
+UNRECORDED_STEPS = {"echo"}
+RUN_FIELDS = ("version", "id", "name", "jobs", "targets", "tests", "profiles", "comment", "plugins")
 
 
 def content_of(doc):
@@ -3751,16 +3970,20 @@ def upgrade_run(run):
     return up, None
 
 
-def answers_from_item(run, sc, cell):
-    """Whether job 1 of a scenario is answered from its item's own text --
-    a local type (Echo) over a Source or Text -- so its prompt may be blank:
-    evals-core.ts's rule, mirrored. Over Prompt only the prompt is the reply."""
-    content = content_of(run)
-    if not isinstance(content, dict) or content.get("type") not in ("source", "text"):
-        return False
-    ref = cell.get("profile") or sc.get("profile")
-    conn = (run.get("profiles") or {}).get(ref.get("id")) if isinstance(ref, dict) else None
-    return isinstance(conn, dict) and conn.get("type") in LOCAL_CONNECTIONS
+def cells_of(run):
+    """Every target's step in every job of a run, as (i, target, k, step):
+    version 10's targets and their steps, or an earlier version's scenarios
+    and their cells -- what the Prompt library records a use from, whichever
+    version a stored run is."""
+    if not isinstance(run, dict):
+        return
+    targets = run.get("targets") if isinstance(run.get("targets"), list) else run.get("scenarios")
+    for i, t in enumerate(targets if isinstance(targets, list) else []):
+        if not isinstance(t, dict):
+            continue
+        steps = t.get("steps") if isinstance(t.get("steps"), list) else t.get("stages")
+        for k, step in enumerate(steps if isinstance(steps, list) else []):
+            yield i, t, k, step
 
 
 def run_problems(run):
@@ -3805,36 +4028,41 @@ def run_problems(run):
             bad.append(f"{at} has to be an object")
             continue
         connection_problems(pid, conn, at, bad)
-    scenarios = run.get("scenarios")
-    if not isinstance(scenarios, list) or not 1 <= len(scenarios) <= SCENARIO_CAP:
-        return bad + [f"a run needs between one and {SCENARIO_CAP} scenarios"]
-    ids = [sc.get("id") for sc in scenarios if isinstance(sc, dict)]
-    for i, sc in enumerate(scenarios):
-        at = f"scenario {i + 1}"
-        if not isinstance(sc, dict):
+    targets = run.get("targets")
+    if not isinstance(targets, list) or not 1 <= len(targets) <= TARGET_CAP:
+        return bad + [f"a run needs between one and {TARGET_CAP} targets"]
+    ids = [t.get("id") for t in targets if isinstance(t, dict)]
+    for i, t in enumerate(targets):
+        at = f"target {i + 1}"
+        if not isinstance(t, dict):
             bad.append(f"{at} has to be an object")
             continue
         # The id the Prompt library records a use under (version 4).
-        if not isinstance(sc.get("id"), str) or not sc["id"].strip():
+        if not isinstance(t.get("id"), str) or not t["id"].strip():
             bad.append(f"{at} has no id")
-        elif ids.count(sc["id"]) > 1:
-            bad.append(f"{at} has the id of another scenario")
-        stages = sc.get("stages")
-        if not isinstance(stages, list) or len(stages) != len(jobs):
-            bad.append(f"{at} has to have one prompt per job")
+        elif ids.count(t["id"]) > 1:
+            bad.append(f"{at} has the id of another target")
+        steps = t.get("steps")
+        if not isinstance(steps, list) or len(steps) != len(jobs):
+            bad.append(f"{at} has to have one step per job")
             continue
-        refs = [sc.get("profile")] + [c.get("profile") for c in stages
-                                      if isinstance(c, dict) and c.get("profile") is not None]
-        for k, cell in enumerate(stages):
-            if not isinstance(cell, dict) or not isinstance(cell.get("prompt"), str) or (
-                    not cell["prompt"].strip() and not (k == 0 and answers_from_item(run, sc, cell))):
+        # A target with no profile is one whose steps ask none (Echo) or each
+        # name their own; which steps need one is the core's to judge.
+        refs = ([t["profile"]] if t.get("profile") is not None else []) + [
+            st.get("profile") for st in steps if isinstance(st, dict) and st.get("profile") is not None]
+        # Whether the words may be blank -- Echo answering from the item --
+        # is the core's to judge, and the worker refuses the run in its words.
+        for k, step in enumerate(steps):
+            if not isinstance(step, dict) or not isinstance(step.get("type"), str):
+                bad.append(f"{at}, job {k + 1} has to name what it sends")
+            elif not isinstance(step.get("prompt"), str):
                 bad.append(f"{at}, job {k + 1} has no prompt")
-            elif cell.get("from") is not None and not (
-                    isinstance(cell["from"], dict) and isinstance(cell["from"].get("id"), str)):
+            elif step.get("from") is not None and not (
+                    isinstance(step["from"], dict) and isinstance(step["from"].get("id"), str)):
                 bad.append(f"{at}, job {k + 1} names the prompt it was picked from without an id")
         for ref in refs:
             if not isinstance(ref, dict) or ref.get("id") not in table:
-                bad.append(f"{at} names a Setup profile the run does not carry")
+                bad.append(f"{at} names a Target profile the run does not carry")
     content = content_of(run)
     kind = content.get("type") if isinstance(content, dict) else None
     if kind == "source":
@@ -3873,10 +4101,12 @@ if DATA_DIR:
     PACKS = Packs(STORE)
     PLUGINS = Plugins(STORE)
     CONNECTIONS = Connections(STORE)
+    MICROSOFT = MicrosoftApp(STORE)
+    GOOGLE = GoogleApp(STORE)
     QUEUE = Queue(STORE)
     QUEUE.prompts = PROMPTS
 else:
-    STORE = SOURCES = PROMPTS = DATASETS = PACKS = PLUGINS = CONNECTIONS = QUEUE = None
+    STORE = SOURCES = PROMPTS = DATASETS = PACKS = PLUGINS = CONNECTIONS = MICROSOFT = GOOGLE = QUEUE = None
 
 
 class NoRedirects(urllib.request.HTTPRedirectHandler):
@@ -4030,9 +4260,10 @@ class Handler(BaseHTTPRequestHandler):
             # The lab's own limits, for the page to disable rather than
             # hard-code: how many scenarios a run may have.
             # And the Microsoft app a flow is read with, when there is one.
-            return self._json(200, {"scenarioCap": SCENARIO_CAP,
-                                    "microsoft": {"clientId": M365_CLIENT_ID, "tenant": M365_TENANT}
-                                    if M365_CLIENT_ID else None})
+            # The app may be entered in Setup unless the deployment names
+            # its own, and only in a lab with a store to keep it in.
+            return self._json(200, {"targetCap": TARGET_CAP, "microsoft": microsoft_config(),
+                                    "microsoftEditable": MICROSOFT is not None and not M365_CLIENT_ID})
         if path == "/api/state":
             if STORE is None:
                 return self._send(404, b"not found", "text/plain")
@@ -4087,6 +4318,10 @@ class Handler(BaseHTTPRequestHandler):
             if CONNECTIONS is None:
                 return self._send(404, b"not found", "text/plain")
             return self._json(200, {"connections": CONNECTIONS.list()})
+        if path == "/api/google":
+            if GOOGLE is None:
+                return self._send(404, b"not found", "text/plain")
+            return self._json(200, {"google": google_public(google_app()), "editable": not GOOGLE_CLIENT_ID})
         if path == GOOGLE_CALLBACK:
             return self._google_callback()
         if path.startswith("/plugins/"):
@@ -4307,6 +4542,26 @@ class Handler(BaseHTTPRequestHandler):
         parts = self.path.split("?", 1)[0].split("/")
         if len(parts) == 4 and parts[:3] == ["", "api", "prompts"] and PROMPTS is not None:
             return self._prompts_put(parts[3])
+        if parts == ["", "api", "google"] and GOOGLE is not None:
+            if GOOGLE_CLIENT_ID:
+                return self._json(409, {"error": "this lab's Google app is its deployment's (GOOGLE_CLIENT_ID)"})
+            _, err, changed = GOOGLE.set(self._payload())
+            if err:
+                return self._json(err[0], {"error": err[1]})
+            # A grant is its client's: one made with another client cannot be
+            # refreshed with this one, so it goes rather than failing later.
+            if changed and CONNECTIONS is not None:
+                CONNECTIONS.forget()
+            return self._json(200, {"google": google_public(google_app()), "editable": True})
+        if parts == ["", "api", "microsoft"] and MICROSOFT is not None:
+            if M365_CLIENT_ID:
+                return self._json(409, {"error": "this lab's Microsoft app is its deployment's (M365_CLIENT_ID)"})
+            payload = self._payload() or {}
+            _, err = MICROSOFT.set(payload.get("clientId"), payload.get("tenant", ""))
+            if err:
+                code, message = err
+                return self._json(code, {"error": message})
+            return self._json(200, {"microsoft": microsoft_config()})
         if len(parts) == 5 and parts[:3] == ["", "api", "sources"] and parts[4] == "definition" \
                 and SOURCES is not None:
             payload, err = self._dataset_payload(DEFINITION_CAP * 2, "a definition")
@@ -4857,7 +5112,7 @@ class Handler(BaseHTTPRequestHandler):
             # made in a lab without that sign-in.
             sign_in = (SOURCE_TYPES.get(kind) or {}).get("signIn")
             if sign_in and not SIGN_INS.get(sign_in, lambda: False)():
-                return self._json(400, {"error": "this lab has no Microsoft app to sign in with (M365_CLIENT_ID)"
+                return self._json(400, {"error": "this lab has no Microsoft app to sign in with (Setup › Connections)"
                                          if sign_in == "microsoft" else f"this lab has no {sign_in} sign-in"})
             source, err = SOURCES.create(payload.get("name"), kind, payload.get("config"))
             if err:
@@ -4982,6 +5237,10 @@ def main():
     if not (DEMO / "manifest.json").is_file():
         raise SystemExit(f"no {DEMO / 'manifest.json'} -- the demo pack sits beside server.py, "
                          "and the image copies it there")
+    # A published app the build wrote and that cannot be read is a broken
+    # package, not one without the app: said at once, not at Sign in.
+    if PUBLIC_GOOGLE_PROBLEM:
+        raise SystemExit(PUBLIC_GOOGLE_PROBLEM)
     print(f"prompt-lab on {HOST}:{PORT}  ->  {OLLAMA} by default", flush=True)
     print(f"samples: {SAMPLES}", flush=True)
     print(f"page:    {WEB_DIST}", flush=True)