evals-lab 0.10.0 → 0.11.0

package/lab/server.py

@@ -565,7 +565,20 @@ def redact_flow(value):
 # again, so a page that got it wrong cannot put a key or a malformed record on
 # disk.
 RECORD_FORMAT = "evals-lab/record"
-RECORD_VERSION = 1
+RECORD_VERSION = 2
+# The origins a record names. Version 2 added `edited`: a call changed in the
+# Call dialog, keeping the `run` and `iteration` it came from.
+RECORD_ORIGINS = ("run", "hand", "upload", "edited")
+
+
+def upgrade_record(value):
+    """A version-1 record as today's: flows/record.ts's upgradeRecord. Version
+    2 only widened the origins, so the upgrade is the number. Anything else is
+    returned as it is, for record_problems to judge."""
+    if isinstance(value, dict) and value.get("format") == RECORD_FORMAT and value.get("version") == 1 \
+            and not isinstance(value.get("version"), bool):
+        return {**value, "version": RECORD_VERSION}
+    return value
 
 
 def record_problems(value):
@@ -600,8 +613,8 @@ def record_problems(value):
             or isinstance(res.get("error"), dict))):
         bad.append("a record's result is { status, body }, { error } or null")
     origin = value.get("origin")
-    if not isinstance(origin, dict) or origin.get("kind") not in ("run", "hand", "upload"):
-        bad.append("a record's origin is run, hand or upload")
+    if not isinstance(origin, dict) or origin.get("kind") not in RECORD_ORIGINS:
+        bad.append("a record's origin is run, hand, upload or edited")
     return bad
 
 
@@ -612,6 +625,7 @@ def take_record(name, data):
         value = json.loads(data.decode("utf-8"))
     except (UnicodeDecodeError, ValueError):
         return None, (400, f"{name} is not JSON")
+    value = upgrade_record(value)
     bad = record_problems(value)
     if bad:
         return None, (400, f"{name}: {bad[0]}")
@@ -689,6 +703,12 @@ def take_dynamic(name, data):
         return None, (400, f"{name} is not text")
     if TOKEN_SHAPE.search(text):
         return None, (400, f"{name} holds a token, and a token never reaches the server")
+    # The lab's own secrets have no shape to redact by, and a command can read
+    # them from its parent's environment, so they are matched by value -- a
+    # verbatim read only; an encoded one gets past. A value under 8 characters is too likely to
+    # be ordinary text to refuse a Call for.
+    if any(len(v) >= 8 and v in text for v in (os.environ.get(k) or "" for k in _LAB_SECRET_ENV)):
+        return None, (400, f"{name} holds one of the lab's own secrets")
     for pattern, to in SECRET_TEXT:
         text = pattern.sub(to, text)
     return text.encode("utf-8"), None
@@ -750,14 +770,14 @@ def _header_pairs(spec):
 def connection_auth(pid):
     """The one auth header a dynamic API Source borrows from the connection
     [pid] it names, and the key it carries so the relay's https-or-loopback
-    rule can bind. The key is the profiles store's, by id, sent the way the
+    rule can bind. The key is the connections store's, by id, sent the way the
     connection's type says (an HTTP endpoint's Key header, else the type's own,
     auth_headers) -- it never leaves the server or reaches a Call (#258).
     Returns (headers, key, None); ({}, "", None) for no connection or no key;
     or (None, None, (code, why))."""
     if not pid:
         return {}, "", None
-    doc = (STORE.all().get("promptlab.profiles") or {}) if STORE is not None else {}
+    doc = (STORE.all().get("promptlab.connections") or {}) if STORE is not None else {}
     profiles = (doc.get("body") or {}).get("list") or []
     profile = next((p for p in profiles if isinstance(p, dict) and p.get("id") == pid), None)
     if profile is None:
@@ -858,7 +878,8 @@ def _outside_root(real):
     root = Path(LOCAL_ROOT).resolve()
     return real != root and root not in real.parents
 
-# The lab's own secrets in its environment, never handed to a command it runs.
+# The lab's own secrets in its environment, never handed to a command it runs
+# nor kept in a Call (take_dynamic).
 _LAB_SECRET_ENV = ("LAB_PASSWORD", "GOOGLE_CLIENT_SECRET", "GOOGLE_API_KEY")
 
 
@@ -895,7 +916,8 @@ def command_config_problems(config):
 def produce_file(config):
     """Read a File on disk Source's one Call now: the path its config names,
     capped at the file cap. The lab's own data directory is never read -- it
-    holds the store, keys included. Returns the shape _relay_produce does."""
+    holds the store, keys included -- nor /proc, which holds the server's
+    environment. Returns the shape _relay_produce does."""
     path = config.get("path") if isinstance(config, dict) else None
     request = {"path": path}
     if not isinstance(path, str) or not path.strip():
@@ -910,6 +932,10 @@ def produce_file(config):
     for own in {Path(d).resolve() for d in (DATA_DIR, STORE and Path(STORE.path).parent) if d}:
         if real == own or own in real.parents:
             return {"error": "the lab's own data is not a file it reads", "request": request, "status": None}
+    # /proc holds the server's own environment (every secret it was started
+    # with, not only the lab's) and its memory: the process, not a file.
+    if real == Path("/proc") or Path("/proc") in real.parents:
+        return {"error": "the server's own process is not a file it reads", "request": request, "status": None}
     if not real.is_file():
         return {"error": "that path is not a file", "request": request, "status": None}
     try:
@@ -1024,8 +1050,10 @@ SIGN_INS = {"microsoft": lambda: microsoft_config() is not None}
 # in the store: a document is not migrated or deleted because nothing reads it.
 # promptlab.cases, .rules and their .base copies went that way when a dataset
 # became a row of its own (#86), and promptlab.mappings once a dataset named
-# the Source it grades (#199).
-SYNCED = ("promptlab.workflows", "promptlab.profiles",
+# the Source it grades (#199). promptlab.profiles went once a Target profile
+# was split into an AI Connection and a Connection Profile (#445), each kept
+# in a document of its own; its rows are what the split read.
+SYNCED = ("promptlab.workflows", "promptlab.connections", "promptlab.connectionProfiles",
           "promptlab.versions", "promptlab.tokens")
 MAX_DOC = 8 * 1024 * 1024
 RUNS_PAGE = 25
@@ -1088,14 +1116,16 @@ QUEUE_WAIT = 1.0
 WATCH_EVERY = 5.0
 
 
-# A Target profile's key is written from the page and never read back by it
+# An AI Connection's key is written from the page and never read back by it
 # (#258): a client holding the lab's password -- CI's runners and their logs
-# among them -- is handed no key. Where a profile holds one, what is served
+# among them -- is handed no key. Where a connection holds one, what is served
 # (/api/state, the page's carried copy, a refused write's current copy) holds
-# KEY_HELD and the profile's id instead, and a write that brings that back
-# keeps the key the store holds for the id: the profile's own, or the one it
-# was cloned or restored from. KEY_HELD starts with a character no key can
-# (header_safe), so a pasted key is never taken for it.
+# KEY_HELD and the connection's id instead, and a write that brings that back
+# keeps the key the store holds for the id: the connection's own, or the one
+# it was cloned or restored from. KEY_HELD starts with a character no key can
+# (header_safe), so a pasted key is never taken for it. A Target profile held
+# the key before the split (#445); a connection keeps its id, so a KEY_HELD
+# the page carried then still names it.
 KEY_HELD = "\u2022held:"
 
 
@@ -1104,11 +1134,12 @@ def held(key) -> bool:
 
 
 def profiles_in(name: str, body):
-    """Every profile a synced document holds: the profiles store's list, and
-    each profile version's copy."""
+    """Everything keyed a synced document holds: the connections store's
+    list, and each profile version's copy -- a Target profile's settings and
+    key, under its connection's id."""
     if not isinstance(body, dict):
         return
-    if name == "promptlab.profiles":
+    if name == "promptlab.connections":
         for p in body.get("list") or []:
             if isinstance(p, dict):
                 yield p
@@ -1165,7 +1196,9 @@ SHARE_NEW = "*new"
 # its pipeline/dataset slices per-workspace, its profile slice global, because
 # profiles are global so their Restore must be too. served()/write() route
 # each key by these; any other key is per-workspace.
-DOC_GLOBAL = ("promptlab.profiles", "promptlab.tokens")
+# promptlab.profiles stays global though no longer served: its row is what
+# the split on open reads (split_profiles).
+DOC_GLOBAL = ("promptlab.connections", "promptlab.connectionProfiles", "promptlab.profiles", "promptlab.tokens")
 DOC_SPLIT = "promptlab.versions"
 
 
@@ -1232,6 +1265,30 @@ class Store:
             db.execute("UPDATE runs SET workspace = ? WHERE workspace IS NULL", (self.default_ws,))
             if cols and "workspace" not in cols:
                 self._rebuild_docs(db)
+            self._split_profiles(db)
+
+    def _split_profiles(self, db):
+        """A store from before the split (#445) opened once: its Target
+        profiles become AI Connections, each keeping the profile's id, its key
+        and its Setup choices (`at`, the lab's grader), and -- where a profile
+        set settings of its own -- Connection Profiles (split_profiles). The
+        old document stays, unserved. Idempotent: a store holding the
+        connections document already, even an emptied one, is left as it is;
+        a store with no profiles has nothing to split."""
+        if db.execute("SELECT 1 FROM docs WHERE name = 'promptlab.connections' AND workspace IS NULL").fetchone():
+            return
+        row = db.execute("SELECT body FROM docs WHERE name = 'promptlab.profiles' AND workspace IS NULL").fetchone()
+        try:
+            body = json.loads(row[0]) if row and row[0] else None
+        except ValueError:
+            body = None
+        if not isinstance(body, dict):
+            return
+        connections, profiles = split_profiles(body.get("list"))
+        kept = {k: body[k] for k in ("at", "grader") if k in body}
+        at = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+        self._put(db, "promptlab.connections", None, 1, {"list": connections, "at": "", **kept}, at)
+        self._put(db, "promptlab.connectionProfiles", None, 1, {"list": profiles}, at)
 
     def _ensure_default(self, db) -> str:
         """The flagged default workspace's id, seeding "Default" (/w/default,
@@ -1363,8 +1420,8 @@ class Store:
                 (name, ws, version, text, at))
 
     def _keyring(self, db, now: dict) -> dict:
-        """Each profile id's key as the store holds it: its profile's, else a
-        dropped one's, else its newest version's."""
+        """Each connection id's key as the store holds it: its connection's,
+        else a dropped one's, else its newest version's."""
         ring = {}
         for p in profiles_in("promptlab.versions", now.get("promptlab.versions", {}).get("body")):
             pid, key = str(p.get("id") or ""), p.get("key")
@@ -1372,7 +1429,7 @@ class Store:
                 ring[pid] = key
         db.execute("DELETE FROM dropped_keys WHERE at < ?", (time.time() - TRASH_SECONDS,))
         ring.update(db.execute("SELECT id, key FROM dropped_keys").fetchall())
-        for p in profiles_in("promptlab.profiles", now.get("promptlab.profiles", {}).get("body")):
+        for p in profiles_in("promptlab.connections", now.get("promptlab.connections", {}).get("body")):
             key = p.get("key")
             if isinstance(key, str) and key and not held(key):
                 ring[str(p.get("id") or "")] = key
@@ -1408,14 +1465,14 @@ class Store:
                     for p in profiles_in(n, d["body"]):
                         if held(p.get("key")):
                             p["key"] = ring.get(p["key"][len(KEY_HELD):], "")
-                if "promptlab.profiles" in docs:
+                if "promptlab.connections" in docs:
                     kept = {str(p.get("id") or "") for p in profiles_in(
-                        "promptlab.profiles", docs["promptlab.profiles"]["body"])}
+                        "promptlab.connections", docs["promptlab.connections"]["body"])}
                     db.executemany("DELETE FROM dropped_keys WHERE id = ?", [(i,) for i in kept])
                     db.executemany(
                         "INSERT OR REPLACE INTO dropped_keys (id, key, at) VALUES (?, ?, ?)",
                         [(str(p.get("id") or ""), p["key"], time.time())
-                         for p in profiles_in("promptlab.profiles", have("promptlab.profiles")["body"])
+                         for p in profiles_in("promptlab.connections", have("promptlab.connections")["body"])
                          if str(p.get("id") or "") not in kept and isinstance(p.get("key"), str) and p["key"]])
                 for n, d in docs.items():
                     version, body = have(n)["version"] + 1, d["body"]
@@ -1434,9 +1491,10 @@ class Store:
             return {n: have(n)["version"] + 1 for n in docs}, None
 
     # ---- shared-by-choice connections (docs/workspaces.md) ------------------
-    # A Target profile or an Account (kind "profile"/"account", id the
-    # profile's or the account's) is usable in a workspace by its share set in
-    # `connection_shares`: a row for that workspace, or the SHARE_ALL sentinel.
+    # An AI Connection or an Account (kind "profile"/"account", id the
+    # connection's -- the Target profile's it kept -- or the account's) is
+    # usable in a workspace by its share set in `connection_shares`: a row for
+    # that workspace, or the SHARE_ALL sentinel.
     # No row at all is the migration and new-connection default -- shared with
     # every workspace, so nothing stops running the moment workspaces exist
     # (open question 2, resolved All); narrowing a connection is adding the
@@ -1498,10 +1556,10 @@ class Store:
         return row[0] if row else "this workspace"
 
     def profile_name(self, pid: str) -> str:
-        """A Target profile's display name, by id, from the global profiles
+        """An AI Connection's display name, by id, from the global connections
         document -- for the refusal sentence. The id itself when none is held."""
         with self.lock, closing(sqlite3.connect(self.path)) as db:
-            row = db.execute("SELECT body FROM docs WHERE name = 'promptlab.profiles' "
+            row = db.execute("SELECT body FROM docs WHERE name = 'promptlab.connections' "
                              "AND workspace IS NULL").fetchone()
         try:
             for p in (json.loads(row[0]) or {}).get("list", []) if row and row[0] else []:
@@ -1827,6 +1885,15 @@ CONFIG_KEYS_MAX = 10
 CONFIG_VALUE_MAX = 400
 
 
+class _Refused(Exception):
+    """A refusal found inside a transaction: rolls it back, carrying the
+    (code, sentence) the caller answers with."""
+
+    def __init__(self, err):
+        super().__init__(err[1])
+        self.err = err
+
+
 class Sources:
     """
     A named bag of files a run might be over (#526).
@@ -2426,11 +2493,12 @@ class Sources:
         content = result.get("content")
         if content is None:
             # A failed production: kept as a Call with its error, no file.
-            name = dynamic_item_name(cfg, (request or {}).get("url", "") or secrets.token_hex(6))
+            name = self._snapshot_name(sid, dynamic_item_name(cfg, (request or {}).get("url", "")
+                                                              or secrets.token_hex(6)))
             self._record_call(sid, name, "snapshot", provider, request, status, result.get("error"), None)
             return {"name": name, "origin": "snapshot", "at": None, "provider": provider,
                     "request": request, "status": status, "error": result.get("error")}, None
-        name = dynamic_item_name(cfg, content)
+        name = self._snapshot_name(sid, dynamic_item_name(cfg, content))
         kept, take_err = entry["take"](name, content)
         if take_err:
             code, message = take_err
@@ -2438,7 +2506,8 @@ class Sources:
             return {"name": name, "origin": "snapshot", "at": None, "provider": provider,
                     "request": request, "status": status, "error": message}, None
         # The name is stable (the URL's), so a re-snapshot overwrites the item
-        # rather than adding a second: remove the old file first, then add.
+        # rather than adding a second: remove the old file first, then add. An
+        # Edited Call is never the one overwritten (_snapshot_name).
         self.remove_files(sid, [name])
         stored, add_err = self.add_file(sid, name, kept)
         if add_err:
@@ -2447,6 +2516,162 @@ class Sources:
         return {"name": stored, "origin": "snapshot", "at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
                 "provider": provider, "request": request, "status": status, "bytes": len(kept)}, None
 
+    def _snapshot_name(self, sid, name):
+        """The name a snapshot is kept under: [name], unless an Edited Call
+        holds it -- a snapshot never overwrites an edit -- and then the first
+        of `<stem>-2`, `<stem>-3`... that none does. One that is not Edited is
+        overwritten, as the stable name always was."""
+        with self.store.lock, closing(sqlite3.connect(self.store.path)) as db:
+            edited = {r[0] for r in db.execute(
+                "SELECT name FROM source_calls WHERE source = ? AND origin = 'edited'", (sid,))}
+        if name not in edited:
+            return name
+        stem, ext = os.path.splitext(name)
+        n = 2
+        while f"{stem}-{n}{ext}" in edited:
+            n += 1
+        return f"{stem}-{n}{ext}"
+
+    # ---- a Call opened in the Call dialog: edited, renamed, cloned (#438) ---
+    #
+    # Both kinds of Call -- a dynamic Source's and a Power Automate record --
+    # are files of a Source whose kind has a `take` hook, so a saved edit goes
+    # through the same check as content arriving any other way: a key refused,
+    # the rest redacted. A File Library has no hook and no Calls.
+
+    # The origins a dynamic Call's provenance row may be put back to (Undo).
+    CALL_ORIGINS = ("snapshot", "run", "upload", "hand", "edited")
+
+    def _calls_entry(self, sid):
+        """The enforcement entry of a user Source whose files are Calls, or
+        (None, error)."""
+        with self.store.lock, closing(sqlite3.connect(self.store.path)) as db:
+            r = db.execute("SELECT system FROM sources WHERE id = ? AND (workspace = ? OR system = 1)",
+                           (sid, workspace_of(self.store))).fetchone()
+        if r is None:
+            return None, (404, "no such source")
+        if r[0]:
+            return None, (403, "the sample library is read-only")
+        entry = self.type_of(sid) or {}
+        if entry.get("take") is None:
+            return None, (400, "that Source keeps no Calls")
+        return entry, None
+
+    def _names_held(self, db, sid):
+        """Every name a Source's files and Calls hold: what a new name may not be."""
+        return ({r[0] for r in db.execute("SELECT name FROM source_files WHERE source = ?", (sid,))}
+                | {r[0] for r in db.execute("SELECT name FROM source_calls WHERE source = ?", (sid,))})
+
+    def edit_call(self, sid, name, to=None, content=None, origin=None, named_by=None):
+        """One Call as the Call dialog saves it: renamed to [to], its text
+        replaced by [content], or both, in one write. The text goes through
+        the Source's `take` hook as an upload does. A rename keeps the
+        extension and refuses a name in use, or a Call that a dataset's cases
+        name ([named_by] answers which datasets do), since a case finds its
+        item by name. A dynamic Call's origin becomes `edited` when its text
+        changed -- a rename alone is no edit -- unless [origin] puts back the
+        one it had (Undo). Nothing is written unless all of it passes.
+        Returns ({name, origin, bytes}, None), or (None, (code, sentence)) --
+        (code, sentence, "name") when the Name field is what is wrong."""
+        entry, err = self._calls_entry(sid)
+        if err:
+            return None, err
+        path = self.file_path(sid, name)
+        if path is None or not path.is_file():
+            return None, (404, f"{name} is not a Call of that Source")
+        if origin is not None and origin not in self.CALL_ORIGINS:
+            return None, (400, "that is not an origin a Call has")
+        new = name
+        if to is not None and to != name:
+            new = source_name(to)
+            if new is None or new != to:
+                return None, (400, "that name is not accepted here", "name")
+            if Path(new).suffix.lower() != Path(name).suffix.lower():
+                return None, (400, "a Call keeps its extension", "name")
+            with self.store.lock, closing(sqlite3.connect(self.store.path)) as db:
+                taken = new in self._names_held(db, sid)
+            if taken:
+                return None, (409, f"{new} is taken.", "name")
+            users = named_by(name) if named_by else []
+            if users:
+                return None, (409, f"{users[0]} names {name} in its cases.", "name")
+        old = path.read_bytes()
+        data = old
+        if content is not None:
+            if not isinstance(content, str):
+                return None, (400, "a Call's content is text")
+            raw = content.encode("utf-8")
+            if not raw:
+                return None, (400, "a Call needs some content")
+            if len(raw) > MAX_FILE:
+                return None, (413, "that is over the file cap")
+            data, take_err = entry["take"](new, raw)
+            if take_err:
+                return None, take_err
+        changed = data != old
+        folder = self.dir / sid
+        tmp = None
+        if changed or new != name:
+            with tempfile.NamedTemporaryFile("wb", dir=folder, delete=False) as f:
+                f.write(data)
+                tmp = f.name
+        try:
+            with self.store.lock, closing(sqlite3.connect(self.store.path)) as db, db:
+                if new != name and new in self._names_held(db, sid):
+                    raise _Refused((409, f"{new} is taken.", "name"))
+                total = db.execute("SELECT bytes FROM sources WHERE id = ?", (sid,)).fetchone()[0]
+                if total + len(data) - len(old) > MAX_SOURCE:
+                    raise _Refused((413, "that would take the source past its cap"))
+                db.execute("UPDATE source_files SET name = ?, bytes = ? WHERE source = ? AND name = ?",
+                           (new, len(data), sid, name))
+                db.execute("UPDATE sources SET bytes = bytes + ? WHERE id = ?", (len(data) - len(old), sid))
+                row = db.execute("SELECT origin FROM source_calls WHERE source = ? AND name = ?",
+                                 (sid, name)).fetchone()
+                now = None
+                if row is not None:
+                    now = origin or ("edited" if changed else row[0])
+                    db.execute("UPDATE source_calls SET name = ?, file = ?, origin = ? "
+                               "WHERE source = ? AND name = ?", (new, new, now, sid, name))
+        except _Refused as no:
+            if tmp:
+                os.unlink(tmp)
+            return None, no.err
+        if tmp:
+            os.replace(tmp, folder / new)
+            if new != name:
+                (folder / name).unlink(missing_ok=True)
+        return {"name": new, "origin": now, "bytes": len(data)}, None
+
+    def clone_call(self, sid, name):
+        """A copy of one Call under `<stem>-copy` (then `-copy-2`, ...), its
+        file and, for a dynamic Call, its provenance -- origin, request,
+        status and when it was produced -- as they are. Returns ({name}, None),
+        or (None, error)."""
+        entry, err = self._calls_entry(sid)
+        if err:
+            return None, err
+        path = self.file_path(sid, name)
+        if path is None or not path.is_file():
+            return None, (404, f"{name} is not a Call of that Source")
+        stem, ext = os.path.splitext(name)
+        with self.store.lock, closing(sqlite3.connect(self.store.path)) as db:
+            held = self._names_held(db, sid)
+        n = 1
+        while True:
+            tail = "-copy" if n == 1 else f"-copy-{n}"
+            copy = stem[:120 - len(tail) - len(ext)] + tail + ext
+            if copy not in held:
+                break
+            n += 1
+        stored, err = self.add_file(sid, copy, path.read_bytes())
+        if err:
+            return None, err
+        with self.store.lock, closing(sqlite3.connect(self.store.path)) as db, db:
+            db.execute("INSERT INTO source_calls (source, name, origin, at, provider, request, status, error, file) "
+                       "SELECT source, ?, origin, at, provider, request, status, error, ? "
+                       "FROM source_calls WHERE source = ? AND name = ?", (stored, stored, sid, name))
+        return {"name": stored}, None
+
     def remove_calls(self, sid, names):
         """Calls out by name: a file-backed Call to the trash (Undo restores
         it), a failed Call's row dropped outright (it has no file). Returns
@@ -3871,6 +4096,24 @@ class Datasets:
             "SELECT name FROM datasets WHERE trash IS NULL AND id IS NOT ? AND workspace = ?",
             (but, workspace_of(self.store)))}
 
+    def naming_item(self, sid, item) -> list:
+        """The names of this workspace's groups previewed against Source
+        [sid] whose cases name [item]: what renaming that item would break."""
+        out = []
+        with self.store.lock, self._connect() as db:
+            for r in db.execute("SELECT name, body, preview FROM datasets WHERE trash IS NULL "
+                                "AND workspace = ? AND preview IS NOT NULL ORDER BY name COLLATE NOCASE",
+                                (workspace_of(self.store),)):
+                try:
+                    ref, body = json.loads(r["preview"]), json.loads(r["body"])
+                except ValueError:
+                    continue
+                cases = body.get("cases") if isinstance(body, dict) else None
+                if isinstance(ref, dict) and ref.get("id") == sid and isinstance(cases, list) \
+                        and any(isinstance(c, dict) and c.get("item") == item for c in cases):
+                    out.append(r["name"])
+        return out
+
     def list(self) -> list:
         with self.store.lock, self._connect() as db:
             counts = self._counts(db)
@@ -6942,7 +7185,7 @@ def bundle_problems(files, keys=()):
         for key in keys:
             key = str(key or "").strip()
             if len(key) >= 4 and key in text:
-                return f"{path} holds a Target profile's key, and a key never leaves the lab"
+                return f"{path} holds a connection's key, and a key never leaves the lab"
         if TOKEN_SHAPE.search(text):
             return f"{path} holds a token, and a key never leaves the lab"
         m = BUNDLE_KEY_FIELD.search(text)
@@ -6965,7 +7208,7 @@ def build_bundle(payload):
         return None, (400, "a bundle holds pipeline.yaml and profiles.yaml")
     stored = []
     if STORE is not None:
-        stored = ((STORE.all().get("promptlab.profiles") or {}).get("body") or {}).get("list") or []
+        stored = ((STORE.all().get("promptlab.connections") or {}).get("body") or {}).get("list") or []
     why = bundle_problems(files, [p.get("key") for p in stored if isinstance(p, dict)])
     if why:
         return None, (400, why)
@@ -6994,10 +7237,12 @@ def build_bundle(payload):
 
 
 # Shared-by-choice enforcement (docs/workspaces.md): the one sentence the Run
-# bar turns into a Share link, and the profiles that earn it -- the run's
-# Target profiles not shared with workspace `ws`. A local profile reaches
-# nothing, so sharing does not gate it. Keyed by the run's profiles table,
-# whose keys are the profile ids the share set is written against.
+# bar turns into a Share link, and the connections that earn it -- the AI
+# Connections the run resolved to that are not shared with workspace `ws`,
+# a profile's own connection included where it answers on one. A local
+# connection reaches nothing, so sharing does not gate it. A share set is
+# written against the id a Target profile had, which its connection keeps
+# (#445), so a "profile" row names the connection.
 def not_shared_sentence(names, wsname: str) -> str:
     verb = "is" if len(names) == 1 else "are"
     return f"{', '.join(names)} {verb} not shared with {wsname}."
@@ -7007,12 +7252,16 @@ def unshared_profiles(run: dict, ws):
     table = run.get("profiles") if isinstance(run, dict) else None
     if not isinstance(table, dict) or STORE is None:
         return []
-    out = []
-    for pid, conn in table.items():
+    out, seen = [], set()
+    for key, conn in table.items():
         if isinstance(conn, dict) and conn.get("type") in LOCAL_CONNECTIONS:
             continue
-        if not STORE.shared("profile", pid, ws):
-            out.append({"id": pid, "name": (isinstance(conn, dict) and conn.get("name")) or pid})
+        cid = answer_connection(key, conn)
+        if cid in seen:
+            continue
+        seen.add(cid)
+        if not STORE.shared("profile", cid, ws):
+            out.append({"id": cid, "name": (isinstance(conn, dict) and conn.get("name")) or cid})
     return out
 
 
@@ -7029,27 +7278,29 @@ def worker_destinations(run: dict):
         return None, not_shared_sentence([b["name"] for b in bad], STORE.workspace_name(ws))
     stored = []
     if STORE is not None:
-        doc = STORE.all().get("promptlab.profiles") or {}
+        doc = STORE.all().get("promptlab.connections") or {}
         stored = (doc.get("body") or {}).get("list") or []
+    # One variable a connection, however many targets or profiles share it.
     env = {}
-    for pid, conn in table.items():
+    for key, conn in table.items():
+        pid = answer_connection(key, conn)
         name = conn.get("name") or pid
         if isinstance(conn, dict) and conn.get("type") in LOCAL_CONNECTIONS:
             continue
         base = api_base(str(conn.get("url") or "")) or api_base(OLLAMA)
         why = allowed(base, "")
         if why:
-            return None, f"Target profile {name}: {why}"
+            return None, f"Connection {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"Target profile {name} not found"
+            return None, f"Connection {name} not found"
         key = str(profile.get("key") or "").strip()
         if key:
             if not header_safe(key):
-                return None, f"Target profile {name} has a key that cannot go in a header"
+                return None, f"Connection {name} has a key that cannot go in a header"
             why = allowed(base, key)
             if why:
-                return None, f"Target profile {name}: {why}"
+                return None, f"Connection {name}: {why}"
             env[key_var(pid, conn.get("slug"))] = key
     return env, None
 
@@ -7078,11 +7329,14 @@ def worker_destinations(run: dict):
 # inline Drop items / Reject rules migrate into a private one (§18, #339).
 # 15: every cleaning step is a filter -- a job's Tidy / Drop prompt echoes /
 # Remove duplicates / Keep first / Case modifiers and its List `preamble`
-# setting migrate into before/after-Read-as filter sets (§18, #405).
-PIPELINE_VERSION = 15
+# setting migrate into Pre-/Post-format filter sets (§18, #405).
+# 16: a target names an AI Connection and, optionally, a Connection Profile,
+# where it named one Target profile; the run's table is keyed by the pair
+# (answer_key), each entry naming the connection whose key it takes (#445).
+PIPELINE_VERSION = 16
 # What a stored run may be: the current version, and the ones evals-core.ts's
 # upgradePipeline reads. A new submission is upgraded to the current one.
-READABLE_VERSIONS = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
+READABLE_VERSIONS = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)
 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).
@@ -7133,11 +7387,88 @@ BUILTIN_CONNECTION_TYPES = dict(CONNECTION_TYPES)
 BUILTIN_LOCAL = set(LOCAL_CONNECTIONS)
 BUILTIN_CHAT_PATHS = dict(CONNECTION_CHAT_PATHS)
 BUILTIN_AUTH = dict(CONNECTION_AUTH)
-CONNECTION_FIELDS = ("name", "slug", "url", "model", "type", "temperature", "px", "format",
+CONNECTION_FIELDS = ("name", "slug", "connection", "url", "model", "type", "temperature", "px", "format",
                      "quality", "options")
 LOOKS_LIKE_A_KEY = re.compile(r"^(?:api[-_]?)?key$|^(?:authorization|bearer|secret|password|token)$",
                               re.IGNORECASE)
 PROFILE_ID = re.compile(r"[A-Za-z0-9]+(?:-[A-Za-z0-9]+)?")
+# A run's table key (evals-core.ts answerKey): a connection's id, then a dot
+# and its profile's id -- or nothing, for none -- or a grader's bare id.
+ANSWER_KEY = re.compile(r"[A-Za-z0-9]+(?:-[A-Za-z0-9]+)?(?:\.(?:[A-Za-z0-9]+(?:-[A-Za-z0-9]+)?)?)?")
+
+
+def answer_key(connection: str, profile=None) -> str:
+    return f"{connection}.{profile or ''}"
+
+
+def answer_connection(key, conn) -> str:
+    """The AI Connection a run's entry [key] takes its key from: the one it
+    names, or -- a run from before version 16 -- the key's own id."""
+    cid = conn.get("connection") if isinstance(conn, dict) else None
+    return cid if isinstance(cid, str) and cid else str(key).split(".", 1)[0]
+
+
+def run_answer(table, key):
+    """What a run's table holds for [key] (evals-core.ts runAnswer): its own
+    entry, or -- a run from before version 16, keyed by Target profile id --
+    the connection's, where the key names no profile."""
+    if key in table:
+        return table[key]
+    head, dot, tail = key.partition(".")
+    return table.get(head) if dot and not tail else None
+
+
+# What an AI Connection keeps of a Target profile (evals-core.ts
+# AI_CONNECTION_FIELDS), beside the settings of its type that say how it is
+# reached (CONNECTION_SCOPED, the registry's `scope: "connection"`); every
+# other setting set is a Connection Profile's. Mirrored, and held to the
+# core's splitProfile, by proxy-check.py.
+AI_CONNECTION_FIELDS = ("id", "name", "slug", "type", "url", "key", "model", "profile")
+CONNECTION_SCOPED = {"http": ("auth", "headers", "testPath")}
+# evals-core.ts REPLY_TOKENS_BEFORE, and the setting of each type that sent it.
+REPLY_TOKENS_BEFORE = "160"
+REPLY_TOKENS_SETTING = {"openai-compatible": "nPredict", "llama.cpp": "nPredict", "anthropic": "maxTokens"}
+
+
+def pin_reply_tokens(p):
+    """evals-core.ts pinReplyTokens: a profile with no Reply tokens setting, of
+    a type that sent the cap, has the cap it was sending written in. The split
+    keeps no blank setting, so after it nothing could tell such a profile from
+    one made since; it is pinned here, before."""
+    key = REPLY_TOKENS_SETTING.get(str(p.get("type")))
+    return p if not key or key in p else {**p, key: REPLY_TOKENS_BEFORE}
+
+
+def split_profile(p):
+    """A Target profile as (AI Connection, Connection Profile or None): the
+    connection keeps its id, key and address; a profile, stamped with the id
+    it came from, holds every other setting it set (its reply-token cap
+    pinned, pin_reply_tokens)."""
+    p = pin_reply_tokens(p)
+    scoped = CONNECTION_SCOPED.get(p.get("type"), ())
+    conn, settings = {}, {}
+    for k, v in p.items():
+        if k in AI_CONNECTION_FIELDS or k in scoped:
+            conn[k] = v
+        elif v is not None and v != "":
+            settings[k] = v
+    if not settings:
+        return conn, None
+    pid = str(p.get("id") or "")
+    return conn, {"id": pid, "name": str(p.get("name") or ""), "fromProfile": pid, **settings}
+
+
+def split_profiles(listed):
+    """A profiles store's list as (connections, connection profiles)."""
+    connections, profiles = [], []
+    for p in listed if isinstance(listed, list) else []:
+        if not isinstance(p, dict):
+            continue
+        conn, prof = split_profile(p)
+        connections.append(conn)
+        if prof is not None:
+            profiles.append(prof)
+    return connections, profiles
 # evals-core.ts's SLUG and SLUG_MAX: what a key's variable is spelt from.
 PROFILE_SLUG = re.compile(r"[a-z0-9]+(?:-[a-z0-9]+)*")
 SLUG_MAX = 32
@@ -7218,7 +7549,7 @@ def connection_problems(pid, conn, at, bad):
     if slug is not None and not (isinstance(slug, str) and PROFILE_SLUG.fullmatch(slug) and len(slug) <= SLUG_MAX):
         bad.append(f"{at}: slug has to be lowercase letters and digits, with hyphens between, at most {SLUG_MAX}")
         slug = None
-    var = key_var(pid, slug)
+    var = key_var(answer_connection(pid, conn), slug)
     _fields(conn, at, CONNECTION_FIELDS, bad, var)
     ctype = conn.get("type")
     if not isinstance(ctype, str) or ctype not in CONNECTION_TYPES:
@@ -7364,17 +7695,23 @@ def run_problems(run):
     spelt = {}
     for pid, conn in table.items():
         at = f"profile {pid}"
-        if not PROFILE_ID.fullmatch(str(pid)):
+        if not ANSWER_KEY.fullmatch(str(pid)):
             bad.append(f"{at}: an id is letters and digits, with at most one hyphen")
             continue
         if not isinstance(conn, dict):
             bad.append(f"{at} has to be an object")
             continue
-        # Two profiles spelling one variable would hand one the other's key.
-        var = key_var(pid, conn.get("slug") if isinstance(conn.get("slug"), str) else None)
-        if var in spelt:
-            bad.append(f"profiles {spelt[var]} and {pid} both take their key from ${var}")
-        spelt[var] = pid
+        if conn.get("connection") is not None and not (
+                isinstance(conn["connection"], str) and PROFILE_ID.fullmatch(conn["connection"])):
+            bad.append(f"{at}: connection has to be an AI Connection's id")
+            continue
+        # Entries sharing a connection share its key; two connections
+        # spelling one variable would hand one the other's.
+        cid = answer_connection(pid, conn)
+        var = key_var(cid, conn.get("slug") if isinstance(conn.get("slug"), str) else None)
+        if var in spelt and spelt[var] != cid:
+            bad.append(f"profiles {spelt[var]} and {cid} both take their key from ${var}")
+        spelt[var] = cid
         connection_problems(pid, conn, at, bad)
     targets = run.get("targets")
     if not isinstance(targets, list) or not 1 <= len(targets) <= TARGET_CAP:
@@ -7394,10 +7731,17 @@ def run_problems(run):
         if not isinstance(steps, list) or len(steps) != len(jobs):
             bad.append(f"{at} has to have one step per job")
             continue
-        # 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]
+        # A target with no connection is one whose steps ask none (Echo) or
+        # each name their own; which steps need one is the core's to judge.
+        # Each pair named -- the target's, a step's own -- is one the run
+        # carries (evals-core.ts targetAnswerOf).
+        def pair(o, base=None):
+            c = o.get("connection") if o.get("connection") is not None else (base or {}).get("connection")
+            p = o.get("profile")
+            return c, p
+        refs = [pair(t)] if t.get("connection") is not None or t.get("profile") is not None else []
+        refs += [pair(st, t) for st in steps
+                 if isinstance(st, dict) and (st.get("connection") is not None or 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):
@@ -7408,9 +7752,11 @@ def run_problems(run):
             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 Target profile the run does not carry")
+        for c, p in refs:
+            if (not isinstance(c, dict) or not isinstance(c.get("id"), str)
+                    or (p is not None and not (isinstance(p, dict) and isinstance(p.get("id"), str)))
+                    or run_answer(table, answer_key(c["id"], p["id"] if p else None)) is None):
+                bad.append(f"{at} names a connection the run does not carry")
     content = content_of(run)
     kind = content.get("type") if isinstance(content, dict) else None
     if kind == "source":
@@ -7747,7 +8093,7 @@ class Handler(BaseHTTPRequestHandler):
                 return self._send(404, b"not found", "text/plain")
             return self._json(200, {"plugins": PLUGINS.list(), "cap": PLUGIN_CAP})
         if path == "/api/connections/shares":
-            # Which workspaces may use each Target profile and Account
+            # Which workspaces may use each AI Connection and Account
             # (docs/workspaces.md): the share sets the Connections menus read.
             # Keyed by "<kind>:<id>", workspace ids and the sentinels, no key.
             if STORE is None:
@@ -8480,7 +8826,7 @@ class Handler(BaseHTTPRequestHandler):
                     if revs[name] is None:
                         return self._json(400, {"error": f"{name!r} is not in that Source"})
                 content["revs"] = revs
-        # A profile not shared with this workspace blocks the run with the
+        # A connection not shared with this workspace blocks the run with the
         # sentence the Run bar shows and the connections it names, so its Share
         # link can grant them at once (docs/workspaces.md).
         ws = workspace_of(STORE) if STORE is not None else None
@@ -9001,6 +9347,24 @@ class Handler(BaseHTTPRequestHandler):
                 code, message = err
                 return self._json(code, {"error": message})
             return self._json(200, {"trash": token})
+        if len(parts) == 6 and parts[4] == "calls" and parts[5] in ("edit", "clone"):
+            payload = self._payload() or {}
+            name = source_name(payload.get("name"))
+            if name is None:
+                return self._json(400, {"error": "a call name is not accepted here"})
+            if parts[5] == "clone":
+                call, err = SOURCES.clone_call(parts[3], name)
+            else:
+                to = payload.get("to")
+                if to is not None and not isinstance(to, str):
+                    return self._json(400, {"error": "that name is not accepted here", "field": "name"})
+                sid = parts[3]
+                call, err = SOURCES.edit_call(
+                    sid, name, to, payload.get("content"), payload.get("origin"),
+                    named_by=(lambda item: DATASETS.naming_item(sid, item)) if DATASETS else None)
+            if err:
+                return self._json(err[0], {"error": err[1], **({"field": err[2]} if len(err) > 2 else {})})
+            return self._json(201 if parts[5] == "clone" else 200, {"call": call})
         if len(parts) == 5 and parts[4] == "copy":
             payload = self._payload() or {}
             source, err = SOURCES.copy_files(parts[3], payload.get("from"),