evals-lab 0.10.0 → 0.12.0

package/lab/evals-core.mjs

@@ -146,8 +146,7 @@ import list, { ECHO, CASE_MODES, legacyTagsOut, legacyTagsModifiers, cleaningFil
     held inline, run at the step's `stage` (#432: a set has no stage of its
     own; the step runs its filters of that stage). A job may hold one `filters` step of
     each stage -- a `text` one run on the raw reply before it is read into
-    items (before Read as), an `items` one run on the items after (after Read
-    as). */
+    items (Pre-format), an `items` one run on the items after (Post-format). */
                              
                   
                      
@@ -167,13 +166,11 @@ import list, { ECHO, CASE_MODES, legacyTagsOut, legacyTagsModifiers, cleaningFil
 /** A target step that sends a Power Automate step's request
     (docs/power-automate.md § The HTTP Request step): the flow's own template
     -- method, path, query and body, Workflow Definition Language expressions
-    and all -- with the target's words and fields placed in the body by its
-    HTTP API, evaluated against each item's record. The profile gives the
-    address and the key. */
+    and all -- with the target's words and fields placed in the body by the
+    job's HTTP API (its flow step's), evaluated against each item's record.
+    The profile gives the address and the key. */
                                                
                       
-                                                    
-              
                  
                
                                 
@@ -221,9 +218,11 @@ import list, { ECHO, CASE_MODES, legacyTagsOut, legacyTagsModifiers, cleaningFil
                                                                   
 
 /** What a target's step says beside its type: what to ask in that job,
-    and whom, where it names a profile of its own. */
+    and whom, where it names an AI Connection of its own -- and, optionally,
+    a Connection Profile over it (version 16). */
                        
                  
+                   
                 
                                                                           
                                                                          
@@ -239,7 +238,7 @@ import list, { ECHO, CASE_MODES, legacyTagsOut, legacyTagsModifiers, cleaningFil
  
 
 /** What a target sends in one job: one of the target step types. */
-                                                                                                                                
+                                                                                                                        
 
 /** A target (pipeline-model §16): one column through every job, compared
     side by side in Results -- what version 9 called a scenario. Its step in
@@ -249,8 +248,11 @@ import list, { ECHO, CASE_MODES, legacyTagsOut, legacyTagsModifiers, cleaningFil
                                                 
              
                
-                                                                          
-                                                       
+                                                                       
+                                                                           
+                                                                        
+                                                                             
+                         
                       
                       
  
@@ -345,7 +347,7 @@ import list, { ECHO, CASE_MODES, legacyTagsOut, legacyTagsModifiers, cleaningFil
  * at. `filters` are tried in order -- each drop-item narrows the items the
  * next reads, and the first reject-reply that fires gates the answer.
  */
-/** Which side of Read as a filter runs on (#405): `text` the raw reply before
+/** Which side of Response Format a filter runs on (#405): `text` the raw reply before
     it is read into items (rewrite-text / reject-text), `items` the items after
     (drop-item, rewrite-item, keep-first, reject-reply). A filter's type decides
     its stage; a set belongs to none (#432), and runs its share of filters in
@@ -356,6 +358,9 @@ import list, { ECHO, CASE_MODES, legacyTagsOut, legacyTagsModifiers, cleaningFil
     reply; item, list and answer filters read the items it is read into. */
 export const stageOfScope = (scope        )              => (scope === "text" ? "text" : "items");
 
+/** A filter stage as the page names it: before the reply is formatted, or after. */
+export const FILTER_STAGE_LABEL                              = { text: "Pre-format", items: "Post-format" };
+
                                 
                                      
                     
@@ -401,11 +406,16 @@ export const stageOfScope = (scope        )              => (scope === "text" ?
                  
  
 
-/** A Setup profile as a run carries it: request settings, never the key. */
+/** What a target asked, as a run carries it: the AI Connection and its
+    Connection Profile's settings resolved into one -- request settings,
+    never the key. */
                              
                
-                                                                           
+                                                                                 
                 
+                                                                        
+                                                            
+                      
               
                 
                                                                  
@@ -420,6 +430,8 @@ export const stageOfScope = (scope        )              => (scope === "text" ?
 /** A pipeline resolved at submit (§5): what the queue runs and History
     reads. The additions, and nothing else. */
                                                
+                                                                         
+                                                                       
                                        
                                                          
                    
@@ -455,6 +467,38 @@ export const stageOfScope = (scope        )              => (scope === "text" ?
                              
  
 
+/**
+ * An AI Connection as Setup stores it (version 16): where the lab sends a
+ * prompt -- its type, address, key and model, and any of its type's settings
+ * that say how it is reached (`scope: "connection"`). Its key is one typed
+ * in this browser, or KEY_HELD and its id, or empty.
+ */
+                               
+             
+               
+                
+               
+              
+              
+                
+                             
+ 
+
+/**
+ * A Connection Profile as Setup stores it: settings a target may carry over
+ * its connection -- model and image settings, each optional, an absent one
+ * the lab's default -- and, optionally, the connection it answers on in
+ * place of the target's. One split from a Target profile is stamped with
+ * that profile's id (`fromProfile`), which is what an upgrade finds it by.
+ */
+                                    
+             
+               
+                          
+                       
+                             
+ 
+
 /** A connection's settings in one flat set, the shape a type reads. */
                                                
 
@@ -468,18 +512,22 @@ export const stageOfScope = (scope        )              => (scope === "text" ?
 /** A pipeline read from YAML, references remapped to this lab. */
                                    
                 
-                                                                             
+                                                                         
                                                                          
                     
  
 
-/** A Target profile as an import or export matches it: its slug, where it
+/** An AI Connection as an import or export matches it: its slug, where it
     has one -- withSlugs gives the rest theirs. */
                                                  
 
 /** What an import matches references against: { id, name } each. */
                             
+                                                                       
+                                                   
                                    
+                                                                         
+                                      
                            
                           
                                                                                  
@@ -487,6 +535,8 @@ export const stageOfScope = (scope        )              => (scope === "text" ?
                                                                            
                                                                           
                                                    
+                                                                         
+                                                           
  
 
 /** An import's outcome: the remapped pipeline, or one sentence refusing it. */
@@ -501,7 +551,7 @@ export const stageOfScope = (scope        )              => (scope === "text" ?
                      
                 
                       
-                                                                             
+                                                                         
                                                                            
                   
                     
@@ -576,10 +626,24 @@ export function kept(text        , max = KEPT_CHARS)         {
                  
                   
                       
+                                                                           
+                                                                              
+                                                            
+                          
                                                                    
                
  
 
+/** Which filter discarded a job's reply, or emptied it, and where (#435). */
+                             
+                 
+                     
+                                                 
+              
+                                                                   
+                    
+ 
+
 /** What runPipeline is told besides the stages. */
                              
                                                                    
@@ -943,6 +1007,9 @@ export function kept(text        , max = KEPT_CHARS)         {
            
                       
                   
+                                                                             
+                                                                      
+              
  
 
 /**
@@ -1000,7 +1067,12 @@ export function kept(text        , max = KEPT_CHARS)         {
     the lab holds. Each is optional, and a
     reference nothing is given to look up is not checked. */
                           
-                                                                                                                
+                                                                            
+                                                                     
+                                                                                                                 
+                                                                          
+              
+                                        
                                                                              
                          
                       
@@ -1299,7 +1371,7 @@ const SLOTS                      = ["content", "target", "responses"];
                                                                      
                                                                    
                         
-                                                                              
+                                                                             
                      
                                                        
                   
@@ -1578,6 +1650,10 @@ function datasetRules(body         )                  {
                   
                
                                                
+                                                                           
+                                                                        
+                                                                    
+                       
                                                                             
                                                                              
                                                 
@@ -1641,6 +1717,10 @@ function datasetRules(body         )                  {
                                                     
                                                                                                             
                                                         
+                                                                             
+                                                                          
+                                                                   
+                                         
                                                                                    
                                 
                                                                             
@@ -2092,6 +2172,7 @@ CONNECTION_TYPES.anthropic = {
   // Asked words (a Prompt step, a grader) or sent a flow's whole request (an
   // HTTP Request step): one profile and one key do both.
   answers: ["prompt", "request"],
+  speaks: () => "anthropic",
   // The Messages API: the x-api-key and anthropic-version headers, base64
   // image content blocks, and /v1/models for the list.
   request(conn, prompt, dataUrl, base, key) {
@@ -2417,14 +2498,23 @@ CONNECTION_TYPES.http = {
   id: "http", label: "HTTP endpoint",
   description: "Any API a Power Automate step calls: an address, a key and how the key is sent.",
   settings: [
-    { key: "auth", label: "Key header", control: "select", default: "bearer", hint: "",
+    { key: "auth", label: "Key header", control: "select", default: "bearer", hint: "", scope: "connection",
       choices: [{ value: "bearer", label: "Authorization: Bearer" }, { value: "x-api-key", label: "x-api-key" },
                 { value: "api-key", label: "api-key" }, { value: "none", label: "none" }] },
-    { key: "headers", label: "Headers", control: "text", default: "", hint: "" },
+    { key: "headers", label: "Headers", control: "text", default: "", hint: "", scope: "connection" },
     // What Test connection asks of it: a GET, keyed as a run is.
-    { key: "testPath", label: "Test path", control: "text", default: "", hint: "" },
+    { key: "testPath", label: "Test path", control: "text", default: "", hint: "", scope: "connection" },
+    // Read off the address (httpApiFor); set by hand for one the lab cannot
+    // tell, such as a gateway in front of a provider.
+    { key: "requestFormat", label: "Request format", control: "select", default: "", hint: "", scope: "connection",
+      choices: [{ value: "", label: "From address" },
+                ...Object.entries(HTTP_APIS).map(([value, a]) => ({ value, label: a.label }))] },
   ],
   answers: ["request"],
+  speaks(conn) {
+    const api = String(conn.requestFormat || "") || httpApiFor(originBase(conn.url));
+    return HTTP_APIS[api] && api !== "raw" ? api : null;
+  },
   lists: false,
   baseOf: originBase,
   send(conn, req, base, key) {
@@ -3100,22 +3190,30 @@ async function runPipeline(stages                  , dataUrl               , cal
     // and that answer is graded as though the job had worked.
     const handsOn = i < stages.length - 1;
     const against = res.readAgainst ?? echo;
-    // The before-Read-as (text) filters shape the raw reply before the kind
+    // The Pre-format (text) filters shape the raw reply before the kind
     // reads it (#405): a Rewrite text reshapes it, a Reject text ends the job.
     const pre = applyFilterSet(st.before || [], { body: res.raw ?? "", items: [], instruction: against }, "text");
-    if (pre.reject != null) return result({ error: named(`discarded: ${pre.reject}`) });
+    const by = (filter        , stage             , rejected         )             => ({ filter, stage, job: i + 1, rejected });
+    if (pre.reject != null) return result({ error: named(`discarded: ${pre.reject}`), filteredBy: by(pre.reject, "text", true) });
     const read = reader.read(pre.body, { echo: against, parsing: opts.parsing, settings: st.settings });
     if (read.error) return result({ error: named(read.error) });
     const mod = applyModifiers(mods[i], kind, read.value, { instruction: against, body: read.body ?? res.raw ?? "" });
-    if (mod.reject) return result({ error: named(`discarded: ${mod.reject}`) });
+    if (mod.reject) {
+      return result({ error: named(`discarded: ${mod.reject}`), ...(mod.by ? { filteredBy: by(mod.by, "items", true) } : {}) });
+    }
+    // A filter that dropped the last item: what a zero result is explained by.
+    const emptied = mod.by && reader.terms && !reader.terms(mod.value).length ? { filteredBy: by(mod.by, "items", false) } : {};
     const nothing = handsOn ? reader.handsOn?.(mod.value) : null;
-    if (nothing) return result({ error: named(nothing) });
+    if (nothing) return result({ error: named(nothing), ...emptied });
     const value = mod.value;
     held = { kind, value };
     const gone = [...(read.dropped || []), ...mod.dropped];
     echoed = (read.echoed || 0) + mod.dropped.filter(d => d.by === ECHO).length;
     done.push({ reply: res.raw ?? "", rendered: reader.render?.(value) || {} });
-    if (!handsOn) dropped = gone;
+    if (!handsOn) {
+      dropped = gone;
+      return result({ echoed, dropped, ...emptied });
+    }
   }
   return result({ echoed, dropped });
 }
@@ -3132,7 +3230,7 @@ function readList(reply        , out                             , instruction =
   const reader = OUTPUT_KINDS[out.kind];
   if (!reader) return { items: [], dropped: [], echoed: 0, error: `"${out.kind}" is not an output kind this lab has` };
   const { kind, modifiers, before, ...settings } = out;
-  // The before-Read-as (text) filters shape the raw reply before the kind
+  // The Pre-format (text) filters shape the raw reply before the kind
   // reads it (#405); a Reject text ends the job.
   const pre = applyFilterSet(before || [], { body: reply, items: [], instruction }, "text");
   if (pre.reject != null) return { items: [], dropped: [], echoed: 0, error: `discarded: ${pre.reject}` };
@@ -3153,7 +3251,7 @@ function readList(reply        , out                             , instruction =
     was thrown away. */
 function applyModifiers   (list                                 , kind        , value   ,
                            ctx              = { instruction: "", body: "" })                                              {
-  let v = value;
+  let v = value, by                    ;
   const dropped            = [];
   for (const m of list || []) {
     const entry = MODIFIERS[m.type];
@@ -3164,9 +3262,10 @@ function applyModifiers   (list                                 , kind        ,
     if (!outcome) { v = out     ; continue; }
     v = outcome.value;
     dropped.push(...(outcome.dropped || []));
-    if (outcome.reject) return { value: v, dropped, reject: outcome.reject };
+    if (outcome.reject) return { value: v, dropped, reject: outcome.reject, ...(outcome.by ? { by: outcome.by } : {}) };
+    by = outcome.by ?? by;
   }
-  return { value: v, dropped };
+  return { value: v, dropped, ...(by ? { by } : {}) };
 }
 
 // ---- The pipeline model ----------------------------------------------------
@@ -3205,7 +3304,12 @@ function applyModifiers   (list                                 , kind        ,
 // 12: a Contains metric's Ignore case holds item by item too.
 // 13: an eval is a link to an eval group, or a group of the pipeline's own,
 // and the document has an overall pass rule (pipeline-model §17).
-const PIPELINE_VERSION = 15         ;
+// 14: a job's Responses stage links filter sets on a `filters` step (§18).
+// 15: every cleaning step is a filter, Pre- or Post-format (#405).
+// 16: a target names an AI Connection and, optionally, a Connection Profile,
+// where it named one Target profile; a run's table is keyed by the pair
+// (answerKey) -- the Target profile split in the store as it opens (#445).
+const PIPELINE_VERSION = 17         ;
 
 // Plain objects, so an entry is added by assignment and a reader never needs
 // to know which registered it.
@@ -3338,7 +3442,7 @@ OUTPUT_KINDS.text = {
 // name is only a label and two profiles can share one. #46: the profile
 // carries `type`, and the run's resolved copy carries it too
 // (docs/pipeline-model.md §7).
-const CONNECTION_FIELDS                    = ["name", "slug", "url", "model", "type", "temperature",
+const CONNECTION_FIELDS                    = ["name", "slug", "connection", "url", "model", "type", "temperature",
                            "px", "format", "quality", "options"];
 const SETTING_KEYS = [...new Set(Object.values(CONNECTION_TYPES).flatMap(t => t.settings.map(s => s.key)))];
 const OPTION_FIELDS = ["seed", "nPredict", ...DECODING_KEYS];
@@ -3346,6 +3450,9 @@ const IMAGE_FORMATS                    = ["image/jpeg", "image/webp", "image/png
 // Ids are what a key variable is spelled from, so they stay spellable: a
 // letter or digit run, with at most one hyphen.
 const PROFILE_ID = /^[A-Za-z0-9]+(?:-[A-Za-z0-9]+)?$/;
+// A run's table key (answerKey): a connection's id, then a dot and its
+// profile's id -- or nothing, for none -- or a grader's bare id.
+const ANSWER_KEY = /^[A-Za-z0-9]+(?:-[A-Za-z0-9]+)?(?:\.(?:[A-Za-z0-9]+(?:-[A-Za-z0-9]+)?)?)?$/;
 const LOOKS_LIKE_A_KEY = /^(?:api[-_]?)?key$|^(?:authorization|bearer|secret|password|token)$/i;
 
 /** The variable a profile's key is read from: its slug's, when it has one --
@@ -3441,6 +3548,138 @@ function connectionSettings(c                             )           {
   return { ...rest, ...(options                         || {}) };
 }
 
+// ---- AI Connections and Connection Profiles (version 16) ---------------------
+// A Target profile was one stored thing: where a prompt goes and the settings
+// it goes with. It is two now -- an AI Connection (type, address, key, model)
+// and an optional Connection Profile (settings, and optionally a connection of
+// its own in place of the target's) -- and a target names both. A store from
+// before is split once as it opens (server.py `split_profiles`): each profile
+// becomes a connection keeping its id and, where it set settings, a profile
+// stamped with that id (`fromProfile`). What a run carries of a pair is the
+// two resolved into one Connection, as a profile resolved before.
+
+/** What an AI Connection keeps of a Target profile, beside its type's
+    connection-scoped settings. A legacy `profile` (#46) stays with the
+    connection: it says the type until the page converts it. */
+const AI_CONNECTION_FIELDS                    = ["id", "name", "slug", "type", "url", "key", "model", "profile"];
+/** What a Connection Profile holds that is not a setting. */
+const CONNECTION_PROFILE_FIELDS                    = ["id", "name", "connection", "fromProfile"];
+
+/** The settings of [type] that say how a connection is reached. */
+const connectionScoped = (type        )                    =>
+  (CONNECTION_TYPES[type]?.settings ?? []).filter(s => s.scope === "connection").map(s => s.key);
+
+/** Whether a stored setting is set: blank is the lab's default. */
+const setValue = (v         )          => v != null && v !== "";
+
+/**
+ * A Target profile as an AI Connection and, where it set any setting, the
+ * Connection Profile holding them -- the same id, stamped with its origin.
+ * Resolved together (`mergeAnswer`) they send what the profile sent.
+ * server.py's `split_profile` is its twin, held to it by proxy-check.py.
+ */
+function splitProfile(p         )                                                                  {
+  const scoped = connectionScoped(typeOf(p            ));
+  const connection            = {}, settings            = {};
+  for (const [k, v] of Object.entries(p)) {
+    if (AI_CONNECTION_FIELDS.includes(k) || scoped.includes(k)) connection[k] = v;
+    else if (setValue(v)) settings[k] = v;
+  }
+  const profile = Object.keys(settings).length
+    ? { id: String(p.id ?? ""), name: String(p.name ?? ""), fromProfile: String(p.id ?? ""), ...settings } : null;
+  return { connection, profile };
+}
+
+/** [conn] with [profile]'s settings over it: the one set of settings a
+    request is built from, the shape a Target profile had. A profile sets
+    no connection field. */
+function mergeAnswer(conn                        , profile                           )          {
+  const out          = { ...conn };
+  const scoped = connectionScoped(typeOf(conn            ));
+  for (const [k, v] of Object.entries(profile ?? {})) {
+    if (!CONNECTION_PROFILE_FIELDS.includes(k) && !AI_CONNECTION_FIELDS.includes(k) && !scoped.includes(k) && setValue(v)) out[k] = v;
+  }
+  return out;
+}
+
+/** Whom a target or one of its steps asks: an AI Connection, and the
+    Connection Profile over it, or none. */
+                         
+                  
+                      
+ 
+
+/** The key a run's table holds [connection] under, with [profile] -- or with
+    none, the lab's defaults. A grader names its connection bare, its id alone,
+    so it never meets a target's pair (see `answersOf`). */
+const answerKey = (connection        , profile                )         => `${connection}.${profile ?? ""}`;
+
+/** [key] read back: a pair's connection and profile, or a bare id. */
+function answerOfKey(key        )                                                                {
+  const at = key.indexOf(".");
+  if (at < 0) return { connection: key, profile: null, bare: true };
+  return { connection: key.slice(0, at), profile: key.slice(at + 1) || null, bare: false };
+}
+
+/** Whom target [i] asks in job [k]: its step's own connection or profile,
+    where it names either, else the target's. */
+function targetAnswerOf(doc                                                           , i        , k        )                     {
+  const t = targetsOf(doc)[i];
+  const st = targetStepOf(doc, i, k);
+  const own = st?.connection != null || st?.profile != null;
+  const connection = (own ? st?.connection ?? t?.connection : t?.connection) ?? null;
+  if (!isRef(connection)) return undefined;
+  const profile = (own ? st?.profile : t?.profile) ?? null;
+  return { connection, profile: isRef(profile) ? profile : null };
+}
+
+/** The answer key of target [i] in job [k], or undefined where it asks none. */
+function targetAnswerKey(doc                                                           , i        , k        )                     {
+  const a = targetAnswerOf(doc, i, k);
+  return a ? answerKey(a.connection.id, a.profile?.id) : undefined;
+}
+
+/**
+ * What the lab's two stores answer: each by id, the profile split from a
+ * Target profile's id (what an upgrade and a grader read it by), and an
+ * answer key resolved to the settings it sends -- the profile's connection
+ * where it names one, else the key's, with the profile's settings over it.
+ * A grader's bare id resolves as the Target profile it named did: its
+ * connection under the profile split from it. Null where any part is gone.
+ */
+function answersOf(connections                         , profiles                              ) {
+  const connection = (id        ) => connections.find(c => c?.id === id) ?? null;
+  const profile = (id        ) => profiles.find(p => p?.id === id) ?? null;
+  const split = (id        )             => {
+    const p = profiles.find(x => x?.fromProfile === id);
+    return p ? { id: p.id, name: p.name } : null;
+  };
+  const resolve = (key        )                 => {
+    const at = answerOfKey(key);
+    const pid = at.bare ? split(at.connection)?.id ?? null : at.profile;
+    const p = pid ? profile(pid) : null;
+    if (pid && !p) return null;
+    const c = connection(isRef(p?.connection) ? p .connection .id : at.connection);
+    return c ? mergeAnswer(c, p) : null;
+  };
+  return { connection, profile, split, resolve };
+}
+
+/** The connection a run carries for [key]: its own entry, or -- a run from
+    before version 16, whose table is keyed by Target profile id, and names
+    the connection alone once upgraded -- the one under the connection's id. */
+function runAnswer(run                                           , key        )                         {
+  const table = run?.profiles                                          ;
+  if (!isObj(table)) return undefined;
+  if (Object.hasOwn(table, key)) return table[key];
+  const at = answerOfKey(key);
+  return !at.bare && at.profile == null && Object.hasOwn(table, at.connection) ? table[at.connection] : undefined;
+}
+
+/** The id of the AI Connection whose key a run's entry [key] is sent with. */
+const answerConnectionId = (key        , conn                                        )         =>
+  (isStr(conn?.connection) && conn .connection) || answerOfKey(key).connection;
+
 // The rest of what a connection's fields mean lives in the connection-type
 // registry above (#46): the runner asks a type how to build a request and how
 // to read a reply, and validation asks connectionProblems (below, with the run
@@ -3721,7 +3960,7 @@ DYNAMIC_PROVIDERS["command"] = {   // provider: the Command adapter's own id
     holds, so a tick costs a predicate and not a request. A reader names a field
     it needs; a wizard that reads more declares it here. */
                            
-                                               
+                                                      
                                                          
                                                                      
                                            
@@ -4091,14 +4330,14 @@ LEGACY_TESTS.metrics = {
     if (t.grader != null && !isRef(t.grader)) bad.push("the Metrics name their grader as { id, name }");
     // The eval's own grader, or the lab's.
     const grader = isRef(t.grader) ? t.grader : isRef(ctx.grader) ? ctx.grader : null;
-    if (gradedIn(t.metrics) && !grader) bad.push("a model-graded metric needs a grader: pick one on the eval, or make a Target profile the lab's grader");
+    if (gradedIn(t.metrics) && !grader) bad.push("a model-graded metric needs a grader: pick one on the eval, or make a connection the lab's grader");
     // A grader is asked words, and needs a model to ask.
     const p = grader && ctx.profiles ? ctx.profiles(grader.id) : null;
-    if (grader && ctx.profiles && !p) bad.push(`Target profile ${grader.name || grader.id} not found`);
+    if (grader && ctx.profiles && !p) bad.push(`Connection ${grader.name || grader.id} not found`);
     else if (p) {
       const type = CONNECTION_TYPES[typeOf(p            )];
       if (type && !(type.answers ?? ["prompt"]).includes("prompt")) bad.push(`the grader has to be asked words, and ${type.label} is not`);
-      else if (!type?.local && !String((p            ).model || "").trim()) bad.push("no model on the grader's Target profile");
+      else if (!type?.local && !String((p            ).model || "").trim()) bad.push("no model on the grader's connection");
     }
   },
   rules: t => (Array.isArray(t.metrics) ? t.metrics : []).map((m        , x        ) => ({
@@ -4226,14 +4465,14 @@ EVAL_TYPES.group = {
     if (own.run.length && !wholeRunGroup(t)) bad.push("the group's own body reads each item or the whole run, not both");
     // The group's own grader, or the lab's.
     const grader = isRef(own.grader) ? own.grader : isRef(ctx.grader) ? ctx.grader : null;
-    if (gradedIn(own.every) && !grader) bad.push("a model-graded metric needs a grader: pick one on the eval, or make a Target profile the lab's grader");
+    if (gradedIn(own.every) && !grader) bad.push("a model-graded metric needs a grader: pick one on the eval, or make a connection the lab's grader");
     // A grader is asked words, and needs a model to ask.
     const p = grader && ctx.profiles ? ctx.profiles(grader.id) : null;
-    if (grader && ctx.profiles && !p) bad.push(`Target profile ${grader.name || grader.id} not found`);
+    if (grader && ctx.profiles && !p) bad.push(`Connection ${grader.name || grader.id} not found`);
     else if (p) {
       const type = CONNECTION_TYPES[typeOf(p            )];
       if (type && !(type.answers ?? ["prompt"]).includes("prompt")) bad.push(`the grader has to be asked words, and ${type.label} is not`);
-      else if (!type?.local && !String((p            ).model || "").trim()) bad.push("no model on the grader's Target profile");
+      else if (!type?.local && !String((p            ).model || "").trim()) bad.push("no model on the grader's connection");
     }
   },
   rules: t => ownList(t).map((m        , x        ) => ({
@@ -4565,7 +4804,7 @@ STEP_TYPES.prompt = {
   description: "Asks each target's model its prompt about the item.",
   in: "item", out: "text",
   apply: "runPipeline",
-  fields: ["type", "prompt", "profile", "from"],
+  fields: ["type", "prompt", "connection", "profile", "from"],
   validate(step, _ctx, bad, at){
     if (!isStr(step.prompt)) bad.push(`${at}: prompt has to be text`);
   },
@@ -4591,16 +4830,18 @@ STEP_TYPES.httpRequest = {
   label: "HTTP Request", slot: "target", asks: "request", verbatim: true, modelFrom: "step",
   description: "Sends a Power Automate step's own request, rebuilt from each record, with each target's words in it.",
   firstJobOnly: "an HTTP Request is sent from its item's record, so it is job 1's",
-  // A new target starts from the flow's own words and fields.
-  newStep: (step) => ({ type: "httpRequest", api: step.api, method: step.method, path: step.path,
+  // A new target starts from the flow's own words and fields, read by the
+  // job's HTTP API ([step] carries it: requestStepOf).
+  newStep: (step) => ({ type: "httpRequest", method: step.method, path: step.path,
                         query: clone(step.query), body: clone(step.body),
                         ...(HTTP_APIS[step.api] ?? HTTP_APIS.raw ).cellOf(step.body) }),
   in: "item", out: "text",
   apply: "runPipeline",
-  fields: ["type", "api", "method", "path", "query", "body", "prompt", "profile", "from", "system", "model", "settings", "prefill"],
+  fields: ["type", "method", "path", "query", "body", "prompt", "connection", "profile", "from", "system", "model", "settings", "prefill"],
+  // [step] carries its job's HTTP API, where the job has a flow step to say
+  // it (validatePipeline); the flow step's own check names an unknown one.
   validate(step, _ctx, bad, at){
     const api = HTTP_APIS[step.api];
-    if (!api) bad.push(`${at}: "${step.api}" is not an HTTP API this lab has`);
     if (!HTTP_METHODS.includes(step.method)) bad.push(`${at}: the method is one of ${HTTP_METHODS.join(", ")}`);
     if (!isStr(step.path) || !/^[/@]/.test(step.path)) bad.push(`${at}: the path starts with /`);
     if (!isObj(step.query) || !Object.values(step.query).every(isStr)) bad.push(`${at}: the query is names to text`);
@@ -4608,7 +4849,7 @@ STEP_TYPES.httpRequest = {
     // A key is the Setup profile's, sent by its Key header; one in the
     // template would be kept in the pipeline and every run of it.
     const hit = keyField(step.body) ?? keyField(step.query, "query");
-    if (hit) bad.push(`${at} carries a key at ${hit}, and a key never goes in a pipeline -- the Target profile sends it`);
+    if (hit) bad.push(`${at} carries a key at ${hit}, and a key never goes in a pipeline -- the connection sends it`);
     if (!api) return;
     // Its fields, where its HTTP API has a place for them.
     for (const f of ["system", "model", "prefill"]         ) {
@@ -4723,7 +4964,7 @@ STEP_TYPES.modifier = {
 
 // A filters step: the filter sets a job cleans and gates its reply by, each a
 // link or a private set (#339, #405), at the step's `stage`. A job may hold
-// one of each stage -- a `text` one before Read as, an `items` one after -- so
+// one of each stage -- a `text` one Pre-format, an `items` one Post-format -- so
 // the type is `many`; two of a stage is the job's to refuse. A set belongs to
 // no stage (#432): linked here, it runs the filters whose type fits the step's
 // stage and skips the rest. A private set's body is the core's to judge
@@ -4824,11 +5065,6 @@ function jobTargetType(doc
   return targetStepOf(doc, 0, k)?.type ?? "prompt";
 }
 
-/** The Setup profile target [i] asks in job [k]: its step's own, or the target's. */
-function targetProfileOf(doc                                                           , i        , k        )                  {
-  return targetStepOf(doc, i, k)?.profile ?? targetsOf(doc)[i]?.profile ?? undefined;
-}
-
 /** Whether target [i] is a Recorded target: it replays each call's recorded
     reply rather than sending anything (its job-1 step answers locally with a
     connection that `replays`). A recorded-reply metric compares the recorded
@@ -4882,7 +5118,7 @@ function requestStepOf(doc
 
 /** What httpRequestOf builds a request from: a target's template, and the
     loop its flow step sits in. */
-                                                                                                                          
+                                                                                                                               
 /** What httpReplyOf reads a reply with: the flow step, its API, its reading. */
                                                                                                      
 
@@ -4958,8 +5194,8 @@ function withOut(job     , out     )      {
 }
 
 /** [job] reading a reply as `legacyTagsOut` builds it, on the current model
-    (#405): its output a List, a before-Read-as text set that reads the reply as
-    the old `preamble` did, and an after-Read-as items set that cleans and gates
+    (#405): its output a List, a Pre-format text set that reads the reply as
+    the old `preamble` did, and a Post-format items set that cleans and gates
     it. The filters are `legacyTagsOut`'s, placed as private sets -- what the
     version-15 upgrade builds for a legacy list job, for a test to build
     directly. */
@@ -4978,7 +5214,7 @@ const filterStepOf = (job         , stage             )
 
 /** The filter-set links a job's Responses stage carries for [stage], in
     document order (#339, #405): read from that stage's filters step, or none.
-    Defaults to the after-Read-as (items) stage, the one that was there before. */
+    Defaults to the Post-format (items) stage, the one that was there before. */
 function filterSetsOf(job         , stage              = "items")                  {
   return (filterStepOf(job, stage)?.filterSets ?? []).slice();
 }
@@ -4998,10 +5234,10 @@ function withFilterSets(job     , links                          , stage
 const linkFilters = (link               , resolve                                                          )           =>
   (link.own ?? (link.set && resolve ? resolve(link.set) : null))?.filters || [];
 
-/** A job's after-Read-as (items) Responses as an ordered modifier list for a
+/** A job's Post-format (items) Responses as an ordered modifier list for a
     run (#339): each modifier step as it is, and each items filter-set link as a
     synthetic modifier that applies the set's filters where the link sits. The
-    before-Read-as (text) filters are not modifiers -- `beforeFilters` gives
+    Pre-format (text) filters are not modifiers -- `beforeFilters` gives
     them, and a run applies them to the raw reply before it is read. [resolve]
     gives a Library link's body. */
 function stageModifiers(job         , resolve                                                          )             {
@@ -5016,7 +5252,7 @@ function stageModifiers(job         , resolve
   return out;
 }
 
-/** A job's before-Read-as (text) filters for a run (#405), in document order:
+/** A job's Pre-format (text) filters for a run (#405), in document order:
     the filters of every link on its `text` filters step, which a run applies to
     the raw reply before the kind reads it into items. [resolve] gives a Library
     link's body, as `stageModifiers` does. */
@@ -5067,11 +5303,11 @@ STEP_TYPES.job = {
     }
     const twice = steps.find((st, x) => !STEP_TYPES[st.type] .many && steps.findIndex(o => o.type === st.type) !== x);
     if (twice) return void bad.push(`${at} has two ${STEP_TYPES[twice.type] .label ?? twice.type} steps`);
-    // A `filters` step is `many`, but only one per stage: a before-Read-as and
-    // an after-Read-as set at most (#405).
+    // A `filters` step is `many`, but only one per stage: a Pre-format and
+    // a Post-format set at most (#405).
     const twoFilters = steps.find((st, x) => st.type === "filters"
       && steps.findIndex(o => o.type === "filters" && o.stage === st.stage) !== x);
-    if (twoFilters) return void bad.push(`${at} has two ${twoFilters.stage === "text" ? "before Read as" : "after Read as"} filter steps`);
+    if (twoFilters) return void bad.push(`${at} has two ${twoFilters.stage === "text" ? "Pre-format" : "Post-format"} filter steps`);
     if (steps.some((st, x) => x > 0 && placeOf(st) < placeOf(steps[x - 1]))) {
       return void bad.push(`${at}: steps are its Content, then its Responses, each in order`);
     }
@@ -5173,10 +5409,16 @@ function versionProblem(doc         )                {
     rules, as a run with no graded eval parsed. */
                              
                                                                 
-                                                                    
+                                                                          
                                                                          
-                                                              
+                                                                          
+                                            
                                                    
+                                                                        
+                                                                           
+                                                                            
+                                             
+                                                           
  
 
 /**
@@ -5227,8 +5469,10 @@ function columnsOf(doc           )
 function profileRefs(doc           )       {
   const cut = (r         ) => (isObj(r) && isStr(r.id) ? { id: r.id, name: isStr(r.name) ? r.name : "" } : r);
   for (const { column, steps } of columnsOf(doc)) {
-    if ("profile" in column) column.profile = cut(column.profile);
-    for (const st of steps) if (st.profile != null) st.profile = cut(st.profile);
+    for (const f of ["connection", "profile"]) {
+      if (f in column) column[f] = cut(column[f]);
+      for (const st of steps) if (st[f] != null) st[f] = cut(st[f]);
+    }
   }
 }
 
@@ -5238,7 +5482,40 @@ const cutRefs = (doc           )            => { profileRefs(doc); return doc; }
 /** Whether any profile reference in a pipeline holds more than { id, name }. */
 function fatProfileRef(doc         )          {
   const fat = (r         ) => isObj(r) && Object.keys(r).some(k => k !== "id" && k !== "name");
-  return isObj(doc) && columnsOf(doc).some(({ column, steps }) => fat(column.profile) || steps.some(st => fat(st.profile)));
+  return isObj(doc) && columnsOf(doc).some(({ column, steps }) => fat(column.profile) || fat(column.connection)
+    || steps.some(st => fat(st.profile) || fat(st.connection)));
+}
+
+/**
+ * Version 15 to 16: a Target profile is an AI Connection now, keeping the
+ * profile's id, and -- where the profile set settings -- the Connection
+ * Profile split from it ([ctx]'s `connectionSplit`), so each target and step
+ * asks what it asked. A run document carries each profile resolved, under
+ * its id (`runAnswer` reads it so), so it names the connection alone, as
+ * does a reader that cannot say what was split. Idempotent: a target that
+ * names a connection already is left as it is.
+ */
+function answersFromProfiles(doc           , ctx            )            {
+  doc.version = PIPELINE_VERSION;
+  const split = (ref         )             => (isObj(doc.profiles) || !isObj(ref) || !isStr(ref.id) ? null
+    : ctx.connectionSplit?.(ref.id) ?? null);
+  if (!Array.isArray(doc.targets)) return doc;
+  doc.targets = doc.targets.map((t           ) => {
+    if (!isObj(t) || "connection" in t) return t;
+    const { id, name, profile = null, steps, ...rest } = t;
+    const p = split(profile);
+    const out            = { id, name, connection: profile, profile: p ? { id: p.id, name: p.name ?? "" } : null, steps, ...rest };
+    if (Array.isArray(steps)) {
+      out.steps = steps.map((st           ) => {
+        if (!isObj(st) || st.profile == null || "connection" in st) return st;
+        const { profile: own, ...more } = st;
+        const sp = split(own);
+        return { ...more, connection: own, ...(sp ? { profile: { id: sp.id, name: sp.name ?? "" } } : {}) };
+      });
+    }
+    return out;
+  });
+  return doc;
 }
 
 /** Version 5 to 6: the one test, or none, as a list. Its id is `t1`, so
@@ -5443,32 +5720,38 @@ function upgradePipeline   (doc   , ctx             = {})    {
     }
     return localSteps(ownBodiesNow(out), ctx)     ;
   }
-  if (!isObj(doc) || ![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14].includes(doc.version          )) return doc;
+  if (!isObj(doc) || ![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16].includes(doc.version          )) return doc;
+  // Every version reads as 16 first, then as 17: its requests read by their
+  // job's HTTP API (requestsOnJobApi).
+  const seventeen = (d           )    => localSteps(ownBodiesNow(requestsOnJobApi(d)), ctx)     ;
+  if (doc.version === 16) return seventeen(cutRefs(clone(doc)             ));
+  // Every version reads as 15 first, then as 16: its Target profiles split
+  // into AI Connections and Connection Profiles (answersFromProfiles).
+  const sixteen = (fifteen           )    => seventeen(answersFromProfiles(fifteen, ctx));
+  if (doc.version === 15) return sixteen(cutRefs(clone(doc)             ));
   // Versions 13 and 14 read as 15 by migrating a job's cleaning modifier steps
-  // and its List `preamble` setting into before/after-Read-as filter sets
+  // and its List `preamble` setting into Pre-/Post-format filter sets
   // (#339, #405). A version-14 document already moved its Drop items / Reject
   // into a (stageless) filters step; filtersFromCleaning stages it and folds in
   // the remaining Tidy / Remove duplicates / Keep first / Case.
-  if (doc.version === 13 || doc.version === 14) {
-    return localSteps(ownBodiesNow(filtersFromCleaning(clone(doc)             )), ctx)     ;
-  }
+  if (doc.version === 13 || doc.version === 14) return sixteen(filtersFromCleaning(clone(doc)             ));
   if (doc.version === 11 || doc.version === 12) {
-    return localSteps(ownBodiesNow(filtersFromCleaning(groupsOf(withoutCaseMetric(caseAsWritten(cutRefs(clone(doc)             )))))), ctx)     ;
+    return sixteen(filtersFromCleaning(groupsOf(withoutCaseMetric(caseAsWritten(cutRefs(clone(doc)             ))))));
   }
   // Every version before 10 reads as version 9 first, then as 10, then up
   // through 15. A version-10 document is cut as a current one was
   // (profileRefs); the earlier ones are cut on their way through nineOf.
   const ten = doc.version === 10 ? cutRefs(clone(doc)             ) : targetsFromScenarios(nineOf(clone(doc)             , ctx));
-  return localSteps(ownBodiesNow(filtersFromCleaning(groupsOf(withoutCaseMetric(caseAsWritten(evalsKey(ten)))))), ctx)     ;
+  return sixteen(filtersFromCleaning(groupsOf(withoutCaseMetric(caseAsWritten(evalsKey(ten))))));
 }
 
 /** [doc] with every job's cleaning modifier steps and its List `preamble`
     setting migrated into filter sets on `filters` steps, up to version 15
-    (#339, #405). The after-Read-as (items) filters are built by walking the
+    (#339, #405). The Post-format (items) filters are built by walking the
     Responses steps in document order -- each cleaning modifier its filters
     (`cleaningFilters`), each existing filters step's links in place, a private
     one's filters coalescing with adjacent modifier filters into one own set --
-    and the `preamble: true` setting becomes a before-Read-as (text) set of
+    and the `preamble: true` setting becomes a Pre-format (text) set of
     Remove thinking then Remove preamble. The steps take the place of the first
     of them, and the preamble setting is stripped.
 
@@ -5556,12 +5839,20 @@ function withoutCaseMetric(doc           )            {
     step then asks none, or names its own, keeps no profile either. The same
     document, untouched, when there is nothing to read so. */
 function localSteps(doc           , ctx            )            {
-  const typeOfProfile = ctx.profileType
-    ?? (isObj(doc.profiles) ? (id        ) => (isObj(doc.profiles[id]) ? doc.profiles[id].type : undefined) : null);
-  if (!typeOfProfile) return doc;
+  const run = isObj(doc.profiles);
+  if (!ctx.profileType && !run) return doc;
+  // A connection's type: [ctx]'s, by its id, or what a run carries for it.
+  const typeOfAnswer = (connection         , profile         )                     => {
+    if (!isObj(connection) || !isStr(connection.id)) return undefined;
+    if (ctx.profileType) return ctx.profileType(connection.id);
+    const conn = runAnswer(doc, answerKey(connection.id, isObj(profile) && isStr(profile.id) ? profile.id : null));
+    return isObj(conn) ? conn.type : undefined;
+  };
   const stands = new Map(Object.entries(STEP_TYPES).filter(([, e]) => e.slot === "target" && e.replaces).map(([type, e]) => [e.replaces , type]));
-  const as = (ref         ) => (isObj(ref) && isStr(ref.id) ? stands.get(typeOfProfile(ref.id) ?? "") : undefined);
-  const turns = (t           , st           ) => isObj(st) && STEP_TYPES[st.type]?.asks === "prompt" && as(st.profile ?? t.profile);
+  const as = (connection         , profile         ) => stands.get(typeOfAnswer(connection, profile) ?? "");
+  const ownsAnswer = (st           ) => st.connection != null || st.profile != null;
+  const turns = (t           , st           ) => isObj(st) && STEP_TYPES[st.type]?.asks === "prompt"
+    && (ownsAnswer(st) ? as(st.connection ?? t.connection, st.profile) : as(t.connection, t.profile));
   const targets              = Array.isArray(doc.targets) ? doc.targets : [];
   if (!targets.some(t => isObj(t) && Array.isArray(t.steps) && t.steps.some((st           ) => turns(t, st)))) return doc;
   const next = clone(doc)             ;
@@ -5571,9 +5862,43 @@ function localSteps(doc           , ctx            )            {
       const type = turns(t, st);
       return type ? { type, prompt: st.prompt, ...(st.from ? { from: st.from } : {}) } : st;
     });
-    // A run keeps the profile it ran as, so its report names it as it did.
-    if (!isObj(doc.profiles) && as(t.profile)
-        && t.steps.every((st           ) => isObj(st) && (STEP_TYPES[st.type]?.local || st.profile != null))) t.profile = null;
+    // A run keeps the connection it ran as, so its report names it as it did.
+    if (!run && as(t.connection, t.profile)
+        && t.steps.every((st           ) => isObj(st) && (STEP_TYPES[st.type]?.local || ownsAnswer(st)))) {
+      t.connection = null;
+      t.profile = null;
+    }
+  }
+  return next;
+}
+
+/**
+ * Version 16 to 17 (#477): a request step has no HTTP API of its own; its
+ * job's flow step says it. A step that named another -- Any endpoint over an
+ * Anthropic flow, say -- keeps its body as it would have sent it, read again
+ * by the job's (its words and fields as that API holds them). A request in a
+ * job with no flow step, which could never run, is a Prompt keeping its words.
+ */
+function requestsOnJobApi(next           )            {
+  next.version = PIPELINE_VERSION;
+  const jobs            = Array.isArray(next.jobs) ? next.jobs : [];
+  const step = (st           , k        )            => {
+    if (!isObj(st) || st.type !== "httpRequest") return st;
+    const { api: own, ...rest } = st;
+    const flow = isObj(jobs[k]) ? flowStepOf(jobs[k]       ) : null;
+    if (!flow) {
+      return { type: "prompt", prompt: rest.prompt,
+               ...Object.fromEntries(["connection", "profile", "from"].filter(f => rest[f] != null).map(f => [f, rest[f]])) };
+    }
+    const was = HTTP_APIS[own          ], now = HTTP_APIS[flow.api];
+    if (!was || !now || own === flow.api) return rest;
+    let body = rest.body;
+    try { body = was.place(rest.body, rest        ); } catch { /* words that never placed: the template stands */ }
+    const { system: _s, model: _m, settings: _t, prefill: _p, ...kept } = rest;
+    return { ...kept, body, ...now.cellOf(body) };
+  };
+  if (Array.isArray(next.targets)) {
+    next.targets = next.targets.map((t           ) => (isObj(t) && Array.isArray(t.steps) ? { ...t, steps: t.steps.map(step) } : t));
   }
   return next;
 }
@@ -5633,6 +5958,16 @@ function blankPipeline(opts
            jobs: [job], targets: [], evals: [], pass: { mode: "all" } };
 }
 
+/** What is wrong with how a target or a step [at] names whom it asks: each
+    reference as { id, name }, and a profile only over a connection. */
+function answerRefsProblems(o           , at        , bad          )       {
+  for (const [f, what] of [["connection", "AI Connection"], ["profile", "Connection Profile"]]         ) {
+    if (o[f] == null) continue;
+    if (!isRef(o[f])) bad.push(`${at} has to name its ${what} as { id, name }`);
+    else onlyFields(o[f], `${at}'s ${f}`, ["id", "name"], bad);
+  }
+}
+
 /**
  * Every reason [doc] cannot run, as sentences -- none when it can. The
  * reference lookups are [ctx]'s: `profiles(id)` and `sources(id)` answer with
@@ -5645,9 +5980,7 @@ function validatePipeline(input         , ctx          = {})           {
   const bad           = [];
   const run = doc.profiles !== undefined;
   const c                = { ...ctx, run };
-  if (run && !ctx.profiles) {
-    c.profiles = (id        ) => isObj(doc.profiles) && Object.hasOwn(doc.profiles, id) ? doc.profiles[id] : null;
-  }
+  if (run && !ctx.profiles) c.profiles = (key        ) => (runAnswer(doc, key)                        ) ?? null;
   onlyFields(doc, "the pipeline", run ? RUN_FIELDS : PIPELINE_FIELDS, bad);
   if (!isStr(doc.id) || !doc.id.trim()) bad.push("the pipeline has no id");
   if (doc.name != null && !isStr(doc.name)) bad.push("name has to be text");
@@ -5668,32 +6001,33 @@ function validatePipeline(input         , ctx          = {})           {
   targets.forEach((t, i) => {
     const at = targetLabel(doc, i);
     if (!isObj(t)) return void bad.push(`${at} has to be an object`);
-    onlyFields(t, at, ["id", "name", "profile", "steps"], bad);
+    onlyFields(t, at, ["id", "name", "connection", "profile", "steps"], bad);
     if (!isStr(t.id) || !t.id.trim()) bad.push(`${at} has no id`);
     else if (targets.findIndex((o) => isObj(o) && o.id === t.id) !== i) bad.push(`${at} has the id of another target`);
     if (t.name != null && !isStr(t.name)) bad.push(`${at}: name has to be text`);
-    if (t.profile != null && !isRef(t.profile)) bad.push(`${at} has to name its Target profile as { id, name }`);
-    else if (t.profile != null) onlyFields(t.profile, `${at}'s profile`, ["id", "name"], bad);
+    answerRefsProblems(t, at, bad);
     if (!Array.isArray(t.steps) || t.steps.length !== n) {
       bad.push(`${at} has ${Array.isArray(t.steps) ? t.steps.length : "no"} prompts for ${n} job${n === 1 ? "" : "s"}`);
       return;
     }
-    // A target with no profile of its own is one whose steps need none, or
-    // each name theirs.
-    if (t.profile == null && t.steps.some((st           ) => !(isObj(st) && STEP_TYPES[st.type]?.local) && !(isObj(st) && st.profile != null))) {
-      bad.push(`${at} has to name its Target profile as { id, name }`);
+    // A target with no connection of its own is one whose steps need none,
+    // or each name theirs; a profile needs a connection to be over.
+    const ownsOne = (st           ) => isObj(st) && st.connection != null;
+    if (t.connection == null && t.steps.some((st           ) => !(isObj(st) && STEP_TYPES[st.type]?.local) && !ownsOne(st))) {
+      bad.push(`${at} has to name its AI Connection as { id, name }`);
     }
     t.steps.forEach((st           , k        ) => {
       const where = `${at}, ${jobLabel(doc, k)}`;
       if (!isObj(st)) return void bad.push(`${where} has to be an object`);
       const entry = STEP_TYPES[st.type];
       if (entry?.slot !== "target") return void bad.push(`${where}: "${st.type}" is not something a target can send`);
-      if (entry.local && st.profile != null) return void bad.push(`${where}: ${entry.label} asks no profile`);
+      if (entry.local && (st.profile != null || st.connection != null)) return void bad.push(`${where}: ${entry.label} asks no connection`);
       if (k > 0 && entry.firstJobOnly) return void bad.push(`${where}: ${entry.firstJobOnly}`);
       onlyFields(st, where, entry.fields ?? [], bad);
-      entry.validate(st, c, bad, where);
-      if (st.profile != null && !isRef(st.profile)) bad.push(`${where} has to name its Target profile as { id, name }`);
-      else if (st.profile != null) onlyFields(st.profile, `${where}'s profile`, ["id", "name"], bad);
+      // A request is read and placed by its job's HTTP API.
+      const flow = entry.asks === "request" ? flowStepOf(doc.jobs[k]) : null;
+      entry.validate(flow ? { ...st, api: flow.api } : st, c, bad, where);
+      answerRefsProblems(st, where, bad);
       if (st.from != null && !isRef(st.from)) bad.push(`${where} has to name the prompt it was picked from as { id, name }`);
       // A request is a flow step's, rebuilt from its records, and its
       // template has no place for an image.
@@ -5703,13 +6037,16 @@ function validatePipeline(input         , ctx          = {})           {
   });
   if (bad.length) return bad;
 
-  // A reference that resolves to nothing, once per reference.
+  // A reference that resolves to nothing, once per reference: the part
+  // that is gone, where the lookups can say which.
   const missing = new Set        ();
-  const lookup = (ref     ) => {
-    const p = c.profiles ? c.profiles(ref.id) : {};
-    if (!p && !missing.has(ref.id)) {
-      missing.add(ref.id);
-      bad.push(`Target profile ${ref.name || ref.id} not found`);
+  const lookup = (a        ) => {
+    const key = answerKey(a.connection.id, a.profile?.id);
+    const p = c.profiles ? c.profiles(key) : {};
+    if (!p && !missing.has(key)) {
+      missing.add(key);
+      const gone = a.profile && c.connections?.(a.connection.id) ? a.profile : a.connection;
+      bad.push(`${gone === a.profile ? "Connection Profile" : "Connection"} ${gone.name || gone.id} not found`);
     }
     return p;
   };
@@ -5725,7 +6062,7 @@ function validatePipeline(input         , ctx          = {})           {
   // What target [i] asks in job [k]: Echo's own connection for a step
   // answered here, else its profile as the lookups hold it.
   const askedOf = (i        , k        ) => (targetEntryOf(doc, i, k)?.local ? localConnOf(targetEntryOf(doc, i, k))
-    : c.profiles ? c.profiles(targetProfileOf(doc, i, k) .id) : null);
+    : c.profiles ? c.profiles(targetAnswerKey(doc, i, k) ) : null);
   const itemsHaveText = !!content && !CONTENT_TYPES[content.type]?.bare;
   for (let k = 0; k < n; k++) {
     const i = targets.findIndex((_, i) => {
@@ -5746,7 +6083,7 @@ function validatePipeline(input         , ctx          = {})           {
   const nonText = (contentFiles || []).map(f => String((f                             )?.name ?? f))
     .find(n => !/\.(?:txt|md|csv)$/i.test(n));
   targets.forEach((_, i) => {
-    const conns = doc.jobs.map((_     , k        ) => (targetEntryOf(doc, i, k)?.local ? localConnOf(targetEntryOf(doc, i, k)) : lookup(targetProfileOf(doc, i, k) )));
+    const conns = doc.jobs.map((_     , k        ) => (targetEntryOf(doc, i, k)?.local ? localConnOf(targetEntryOf(doc, i, k)) : lookup(targetAnswerOf(doc, i, k) )));
     conns.forEach((p         , k        ) => {
       if (!local(p)) return;
       const entry = CONNECTION_TYPES[typeOf(p            )] ;
@@ -5764,6 +6101,15 @@ function validatePipeline(input         , ctx          = {})           {
       const type = CONNECTION_TYPES[typeOf(p            )];
       if (type && !(type.answers ?? ["prompt"]).includes(step.asks ?? "prompt")) {
         bad.push(`${n > 1 ? `${jobLabel(doc, k)}, ` : ""}${targetLabel(doc, i)}: ${step.label ?? "this step"} needs a profile that answers it, and ${type.label} does not`);
+        return;
+      }
+      // A request goes as the flow wrote it, so its connection has to speak
+      // the job's HTTP API; one the lab cannot tell (Any endpoint) passes.
+      const api = step.asks === "request" ? flowStepOf(doc.jobs[k])?.api : undefined;
+      const speaks = api && api !== "raw" && type?.speaks ? type.speaks(p            ) : null;
+      if (api && speaks && speaks !== api) {
+        const name = targetAnswerOf(doc, i, k)?.connection.name || type .label;
+        bad.push(`${n > 1 ? `${jobLabel(doc, k)}, ` : ""}${targetLabel(doc, i)}: ${name} can't send an ${HTTP_APIS[api]?.label ?? api} request`);
       }
     });
     // The model is the profile's unless the target's step carries it.
@@ -5771,8 +6117,8 @@ function validatePipeline(input         , ctx          = {})           {
       && targetEntryOf(doc, i, k)?.modelFrom !== "step" && !String(p.model || "").trim());
     if (bare >= 0) {
       bad.push(n > 1
-        ? `no model on the profile ${jobLabel(doc, bare)} of ${targetLabel(doc, i)} uses — manage profiles on the Setup tab`
-        : `no model on ${targetLabel(doc, i)}'s Target profile — manage profiles on the Setup tab`);
+        ? `no model on the connection ${jobLabel(doc, bare)} of ${targetLabel(doc, i)} uses — manage connections on the Setup tab`
+        : `no model on ${targetLabel(doc, i)}'s connection — manage connections on the Setup tab`);
     }
   });
   STEP_TYPES.evals .validate(doc.evals, c, bad, outOf(doc.jobs.at(-1)).kind, doc);
@@ -5841,15 +6187,22 @@ function pipelineWarnings(doc         , ctx          = {})           {
 /** A run document's profiles table: id → connection, keyless, spellable. */
 function profilesProblems(profiles         , bad          )       {
   if (!isObj(profiles)) return void bad.push("profiles has to be an object of id → connection");
+  // Two entries may share one connection, and so one key; two connections
+  // spelling one variable would hand one the other's key.
   const spelt = new Map                ();
   for (const [id, conn] of Object.entries(profiles)) {
-    if (!PROFILE_ID.test(id)) {
+    if (!ANSWER_KEY.test(id)) {
       bad.push(`profile id "${id}" has to be letters and digits, with at most one hyphen: its key comes from EVALSLAB_API_KEY_<ID>`);
       continue;
     }
-    const from = keyVar(id, isObj(conn) && isStr(conn.slug) ? conn.slug : null);
-    if (spelt.has(from)) bad.push(`profiles ${spelt.get(from)} and ${id} both take their key from $${from}`);
-    spelt.set(from, id);
+    if (isObj(conn) && conn.connection != null && !(isStr(conn.connection) && PROFILE_ID.test(conn.connection))) {
+      bad.push(`profile ${id}: connection has to be an AI Connection's id`);
+      continue;
+    }
+    const cid = answerConnectionId(id, isObj(conn) ? conn : null);
+    const from = keyVar(cid, isObj(conn) && isStr(conn.slug) ? conn.slug : null);
+    if (spelt.has(from) && spelt.get(from) !== cid) bad.push(`profiles ${spelt.get(from)} and ${cid} both take their key from $${from}`);
+    spelt.set(from, cid);
     const at = `profile ${id}`;
     if (!isObj(conn)) { bad.push(`${at} has to be an object`); continue; }
     connectionProblems(conn, at, from, bad);
@@ -5915,24 +6268,34 @@ function connectionProblems(conn                           , at        , from
   for (const why of CONNECTION_TYPES[type]?.settingsProblems?.(connectionSettings(conn)) ?? []) bad.push(`${at} ${why}`);
 }
 
-/** The profile ids a pipeline references, scenarios first, in order. */
+/** The AI Connection ids a pipeline asks -- each target's and step's, then
+    each grader's -- in order: the Target profile ids, before version 16. */
 function profileIds(doc                                                  )           {
-  const ids           = [];
-  for (const t of targetsOf(doc)) {
-    for (const ref of [t.profile, ...(Array.isArray(t.steps) ? t.steps : []).map(st => st?.profile)]                              ) {
-      if (ref?.id && !ids.includes(ref.id)) ids.push(ref.id);
-    }
-  }
+  return [...new Set(answerKeys(doc).map(k => answerOfKey(k).connection))];
+}
+
+/** Every answer key a pipeline asks, targets first, in order: each target's
+    and step's connection and profile, then each grader's bare id. What a run
+    carries one connection for. */
+function answerKeys(doc                                                  )           {
+  const keys           = [];
+  const add = (key                    ) => { if (key && !keys.includes(key)) keys.push(key); };
+  targetsOf(doc).forEach((t, i) => {
+    // The target's own, which History reads it by, then each step's.
+    if (isRef(t.connection)) add(answerKey(t.connection.id, isRef(t.profile) ? t.profile.id : null));
+    (Array.isArray(t.steps) ? t.steps : []).forEach((_, k) => add(targetAnswerKey(doc, i, k)));
+  });
   // Then the ones an eval asks (a grader), so a run carries them too.
   for (const t of evalsOf(doc)) {
-    for (const ref of EVAL_TYPES[t.type]?.profiles?.(t) ?? []) if (ref?.id && !ids.includes(ref.id)) ids.push(ref.id);
+    for (const ref of EVAL_TYPES[t.type]?.profiles?.(t) ?? []) if (ref?.id && !keys.includes(ref.id)) keys.push(ref.id);
   }
-  return ids;
+  return keys;
 }
 
 /**
  * The run document: [doc] plus what its references resolved to, once, at
- * submit. `ctx.profiles(id)` answers with a stored profile, `ctx.files` is
+ * submit. `ctx.profiles(key)` answers an answer key with what it resolves to
+ * (`answersOf`'s `resolve`), `ctx.files` is
  * the Source's file list as it reads now, `ctx.comment` is the run's own.
  */
 function resolvePipeline(doc          ,
@@ -5942,10 +6305,16 @@ function resolvePipeline(doc          ,
   // What the lab supplies an eval -- its grader -- before the profiles it
   // asks are carried.
   run.evals = (Array.isArray(run.evals) ? run.evals : []).map((t           ) => EVAL_TYPES[t?.type]?.resolve?.(t, ctx) ?? t);
+  // Each pair asked, resolved and frozen on its own: two targets sharing a
+  // connection under different profiles send different settings. The entry
+  // names the connection whose key it is sent with.
   run.profiles = {};
-  for (const id of profileIds(run)) {
-    const p = ctx.profiles?.(id);
-    if (p) run.profiles[id] = connectionOf(p           );
+  for (const key of answerKeys(run)) {
+    const p = ctx.profiles?.(key);
+    if (!p) continue;
+    const conn = connectionOf(p           );
+    const cid = isStr(p.id) && p.id ? p.id : answerOfKey(key).connection;
+    run.profiles[key] = { ...conn, connection: cid };
   }
   const content = contentOf(run)             ;
   if (content?.type === "source") content.files = CONTENT_TYPES.source .expand (content, ctx.files);
@@ -6008,13 +6377,14 @@ function pipelineToYaml(doc          , ctx
   return yaml.dump(out, { lineWidth: -1, noRefs: true });
 }
 
-/** Every Target profile reference in [doc] -- each target's, each of its
-    steps', each eval's grader -- replaced, in place, by [f] of it. */
+/** Every AI Connection reference in [doc] -- each target's, each of its
+    steps', each eval's grader -- replaced, in place, by [f] of it. A
+    Connection Profile is named by id and name, and left as it is. */
 function eachProfileRef(doc           , f                               )       {
   for (const t of targetsOf(doc)) {
-    if (t.profile) t.profile = f(t.profile);
+    if (t.connection) t.connection = f(t.connection);
     for (const st of Array.isArray(t.steps) ? t.steps : []) {
-      if (st?.profile) st.profile = f(st.profile);
+      if (st?.connection) st.connection = f(st.connection);
     }
   }
   for (const t of Array.isArray(doc.evals) ? doc.evals : []) {
@@ -6035,6 +6405,9 @@ function eachProfileRef(doc           , f                               )
  * stands.
  */
 function importPipeline(input         , ctx            = {})               {
+  // A version-15 file names its profiles by slug, which the upgrade cannot
+  // split (it needs this lab's id), so the split is asked again once remapped.
+  const preSplit = isObj(input) && typeof input.version === "number" && input.version < 16 && !isObj(input.profiles);
   // A file exported before version 2 still imports: it is upgraded, not refused.
   const doc = upgradePipeline(input, ctx);
   const v = versionProblem(doc);
@@ -6042,9 +6415,10 @@ function importPipeline(input         , ctx            = {})               {
   const profiles = ctx.profiles ?? [], sources = ctx.sources ?? [], groups = ctx.groups ?? [];
   const next = clone(doc)             ;
   const missing           = [], seen = new Set        ();
-  const lists = { profile: profiles, source: sources, group: groups };
+  const lists = { profile: profiles, connectionProfile: ctx.connectionProfiles ?? [], source: sources, group: groups };
   const words = {
-    profile: (ref                         ) => `Target profile ${ref.slug || ref.name || ref.id} not found`,
+    profile: (ref                         ) => `Connection ${ref.slug || ref.name || ref.id} not found`,
+    connectionProfile: (ref     ) => `Connection Profile ${ref.name || ref.id} not found`,
     source: (ref     ) => `Source ${ref.name || ref.id} not found`,
     group: (ref     ) => `Eval group ${ref.name || ref.id} not found`,
   };
@@ -6070,10 +6444,22 @@ function importPipeline(input         , ctx            = {})               {
   };
   const content = contentOf(next)             ;
   if (content?.type === "source") content.ref = remap(content.ref, "source");
+  const split = (connection         )             => {
+    const p = preSplit && isRef(connection) && profiles.some(x => x.id === connection.id) ? ctx.connectionSplit?.(connection.id) : null;
+    return p ? { id: p.id, name: p.name ?? "" } : null;
+  };
   for (const t of targetsOf(next)) {
-    if (t.profile) t.profile = remapProfile(t.profile);
+    // A profile is matched where the lab says which it holds.
+    if (t.connection) t.connection = remapProfile(t.connection);
+    if (isRef(t.profile) && ctx.connectionProfiles) t.profile = remap(t.profile, "connectionProfile");
+    else if (t.profile == null) t.profile = split(t.connection);
     for (const st of Array.isArray(t.steps) ? t.steps : []) {
-      if (st?.profile) st.profile = remapProfile(st.profile);
+      if (st?.connection) st.connection = remapProfile(st.connection);
+      if (isRef(st?.profile) && ctx.connectionProfiles) st.profile = remap(st.profile, "connectionProfile");
+      else if (isObj(st) && st.connection && st.profile == null) {
+        const sp = split(st.connection);
+        if (sp) st.profile = sp;
+      }
     }
   }
   for (const t of Array.isArray(next.evals) ? next.evals : []) {
@@ -6173,7 +6559,7 @@ function junitXml(suites                       , runner        )         {
 //
 // Export for CI writes a pipeline as files a repository keeps and
 // `evals-lab run` runs with no lab around it (docs/pipeline-yaml.md, "Export
-// for CI"): the pipeline's YAML, its Target profiles by slug, and each
+// for CI"): the pipeline's YAML, its connections resolved and keyed by slug, and each
 // dataset it grades against as the Library's export of it. The server adds
 // the plugins and, when asked, the Source's items, and zips the lot. Read
 // back, the files are the run document the page would have submitted, with
@@ -6196,28 +6582,38 @@ const BUNDLE_DATASET = /^datasets\/([a-z0-9]+(?:-[a-z0-9]+)*)\.json$/;
 
 /**
  * [doc] as a bundle's text files: `pipeline.yaml`, `profiles.yaml` and
- * `datasets/<slug>.json`. [ctx.profiles] is Setup's list -- keys and all,
- * none of which is written -- [ctx.grader] the lab's grader, written into
- * each eval that would have asked it, and [ctx.datasets] each graded
- * dataset by id, as `{ name, body }`. `{ error }` when a dataset or a
- * profile the pipeline names is not given, since a bundle without it runs
+ * `datasets/<slug>.json`. [ctx.connections] and [ctx.connectionProfiles]
+ * are Setup's -- keys and all, none of which is written -- or
+ * [ctx.profiles], Target profiles to split as the store was; [ctx.grader]
+ * the lab's grader, written into each eval that would have asked it, and
+ * [ctx.datasets] each graded dataset by id, as `{ name, body }`. Each
+ * connection asked is written resolved, under its answer key with the
+ * connection's slug for its id. `{ error }` when a dataset or a connection
+ * the pipeline names is not given, since a bundle without it runs
  * something else.
  */
-function exportBundle(doc          , ctx                                                       
+function exportBundle(doc          , ctx                                                                         
+                                                                                                                  
                                                                                                             = {}) 
                                                {
-  const profiles = withSlugs((ctx.profiles ?? [])                     );
+  const split = (ctx.profiles ?? []).map(splitProfile);
+  const profiles = withSlugs([...(ctx.connections ?? []), ...split.map(x => x.connection)]                          );
+  const answers = answersOf(profiles, [...(ctx.connectionProfiles ?? []), ...split.flatMap(x => (x.profile ? [x.profile] : []))]);
   // What the lab would supply at submit, written down: no lab supplies it later.
   const out = clone(doc)             ;
   out.evals = (Array.isArray(out.evals) ? out.evals : [])
     .map((t           ) => EVAL_TYPES[t?.type]?.resolve?.(t, { grader: ctx.grader ?? null,
       groups: Object.entries(ctx.datasets ?? {}).map(([id, d]) => ({ id, name: d.name, grader: d.body.grader ?? null })) }) ?? t);
   const table                           = {};
-  for (const id of profileIds(out)) {
-    const p = profiles.find(x => x.id === id);
-    if (!p) return { error: `Target profile ${id} not found` };
+  for (const key of answerKeys(out)) {
+    const at = answerOfKey(key);
+    const named = answers.connection(at.connection);
+    const p = answers.resolve(key);
+    if (!named) return { error: `Connection ${at.connection} not found` };
+    if (!p) return { error: `Connection Profile ${at.profile} not found` };
     const { slug, ...flat } = connectionSettings(connectionOf(p)                       );
-    table[slug          ] = flat;
+    // A profile answering on a connection of its own takes that one's key.
+    table[at.bare ? named.slug  : answerKey(named.slug , at.profile)] = slug === named.slug ? flat : { ...flat, slug };
   }
   const files              = {};
   const taken = new Set        (), written = new Set        ();
@@ -6264,7 +6660,7 @@ function bundleProblems(files             , keys                     = [])
   for (const [path, text] of Object.entries(files)) {
     for (const key of keys) {
       if (isStr(key) && key.trim().length >= 4 && text.includes(key.trim())) {
-        bad.push(`${path} holds a Target profile's key, and a key never leaves the lab`);
+        bad.push(`${path} holds a connection's key, and a key never leaves the lab`);
         break;
       }
     }
@@ -6294,14 +6690,23 @@ function readBundle(files             , ctx                                = {})
   if (!isObj(table)) return { error: `${BUNDLE_PROFILES} maps each profile's slug to its settings` };
   const keyed = bundleProblems(files);
   if (keyed.length) return { error: keyed[0]  };
-  const profiles                                       = [];
-  for (const [slug, p] of Object.entries(table)) {
-    if (!isSlug(slug)) return { error: `${BUNDLE_PROFILES}: ${JSON.stringify(slug)} is not a slug` };
-    if (!isObj(p)) return { error: `${BUNDLE_PROFILES}: ${slug} has to hold its settings` };
+  // Each entry under its answer key, the connection's slug for its id: a
+  // bundle from before version 16 keys each by its Target profile's slug.
+  const profiles                             = [];
+  const entries                          = {};
+  for (const [key, p] of Object.entries(table)) {
+    const at = answerOfKey(key);
+    if (!isSlug(at.connection) || (at.profile != null && !PROFILE_ID.test(at.profile))) {
+      return { error: `${BUNDLE_PROFILES}: ${JSON.stringify(key)} is not a slug` };
+    }
+    if (!isObj(p)) return { error: `${BUNDLE_PROFILES}: ${key} has to hold its settings` };
     if (!CONNECTION_TYPES[typeOf(p           )]) {
-      return { error: `${BUNDLE_PROFILES}: ${slug} is of type ${p.type}, which this lab does not have` };
+      return { error: `${BUNDLE_PROFILES}: ${key} is of type ${p.type}, which this lab does not have` };
     }
-    profiles.push({ ...p, id: slug, slug, name: isStr(p.name) && p.name ? p.name : slug });
+    const slug = isSlug(p.slug) ? p.slug : at.connection;
+    const name = isStr(p.name) && p.name ? p.name : slug;
+    entries[key] = { ...p, id: slug, slug, name };
+    if (!profiles.some(x => x.id === at.connection)) profiles.push({ id: at.connection, slug: at.connection, name: slug === at.connection ? name : at.connection });
   }
   // Each dataset by its name, which is what joins it to the eval naming it.
   const datasets                                        = [];
@@ -6334,6 +6739,8 @@ function readBundle(files             , ctx                                = {})
     if (!ref) continue;
     if (datasets.some(d => d.name === ref.name)) refs.push({ id: ref.id, name: ref.name });
   }
+  // A profile is named by the id the key holds it under; one the table
+  // lacks is a reference the run does not carry, and validation says so.
   const imported = importPipeline(raw, { profiles, groups: refs,
                                         sources: content?.type === "source" && isRef(content.ref) ? [content.ref] : [] });
   if ("error" in imported) return imported;
@@ -6342,7 +6749,7 @@ function readBundle(files             , ctx                                = {})
   for (const r of refs) byId[r.id] = datasets.find(d => d.name === r.name) .body;
   const caseItems = [...new Set(Object.values(byId).flatMap(b => gradedSetFrom(b                      ).filter(c => !c.todo).map(caseItem)).filter(Boolean))];
   const run = resolvePipeline(imported.doc, {
-    profiles: id => profiles.find(p => p.id === id) ?? null,
+    profiles: key => runAnswer({ profiles: entries }, key)                        ?? null,
     files: ctx.items ? [...ctx.items].sort() : caseItems,
   });
   const bad = validatePipeline(run, { groups: refs });
@@ -6361,24 +6768,28 @@ function stagesFor(run             , i        , resolveFilters
                                                                                {
   const stages = run.jobs.map((ch, k) => {
     const { kind, modifiers: _mods, ...settings } = outOf(ch);
-    // The modifiers a run applies, with each after-Read-as filter set a
-    // synthetic modifier where its link sits (#339), and the before-Read-as
+    // The modifiers a run applies, with each Post-format filter set a
+    // synthetic modifier where its link sits (#339), and the Pre-format
     // (text) filters applied to the raw reply before it is read (#405);
     // without a resolver, a Library link reads nothing, a private one its own.
     return { text: targetStepOf(run, i, k) .prompt, kind, withImage: sendsImage(ch),
              verbatim: !!targetEntryOf(run, i, k)?.verbatim, before: beforeFilters(ch, resolveFilters),
              modifiers: stageModifiers(ch, resolveFilters), settings };
   });
+  // Each named by the connection whose key it is sent with.
+  const asked = (key        , held                        ) => {
+    const { connection: _c, ...conn } = held || {}                       ;
+    return { id: answerConnectionId(key, held), ...conn };
+  };
   const connections = run.jobs.map((_, k) => {
     // A step answered here asks nothing: the profile a run made before it
     // kept is what it ran as, else Echo itself.
+    const key = targetAnswerKey(run, i, k);
     if (targetEntryOf(run, i, k)?.local) {
-      const id = targetProfileOf(run, i, k)?.id;
-      const held = id != null ? run.profiles?.[id] : undefined;
-      return held && CONNECTION_TYPES[held.type]?.local ? { id: id , ...held } : { id: "", ...localConnOf(targetEntryOf(run, i, k)) };
+      const held = key != null ? runAnswer(run, key) : undefined;
+      return held && CONNECTION_TYPES[held.type]?.local ? asked(key , held) : { id: "", ...localConnOf(targetEntryOf(run, i, k)) };
     }
-    const id = targetProfileOf(run, i, k) .id;
-    return { id, ...(run.profiles?.[id] || {}) };
+    return key != null ? asked(key, runAnswer(run, key)) : { id: "" };
   });
   // What a transport that builds its own request (an HTTP Request) builds
   // it from in each job, and this target's step there.
@@ -6388,11 +6799,16 @@ function stagesFor(run             , i        , resolveFilters
 
 /** The Setup profile scenario [i] of a run ran under, as History shows it: keyless. */
 function scenarioProfile(run             , i        )                                                          {
-  const id = targetsOf(run)[i]?.profile?.id;
+  // Read by the target: its own connection and profile, frozen at submit
+  // apart from any other target's that shares the connection.
+  const t = targetsOf(run)[i];
+  const key = isRef(t?.connection) ? answerKey(t.connection.id, isRef(t.profile) ? t.profile.id : null) : undefined;
   // A target that asks nothing ran as Echo.
-  if (id == null && targetEntryOf(run, i, 0)?.local) { const lc = localConnOf(targetEntryOf(run, i, 0)); return { id: "", name: lc.name, settings: { ...lc } }; }
-  const conn = id != null ? run.profiles?.[id] : null;
-  return conn ? { id: id , name: conn.name, settings: connectionSettings(conn                       ) } : null;
+  if (key == null && targetEntryOf(run, i, 0)?.local) { const lc = localConnOf(targetEntryOf(run, i, 0)); return { id: "", name: lc.name, settings: { ...lc } }; }
+  const held = key != null ? runAnswer(run, key) : undefined;
+  if (!held) return null;
+  const { connection: _c, ...conn } = held;
+  return { id: answerConnectionId(key , held), name: conn.name, settings: connectionSettings(conn                       ) };
 }
 
 /** The kind a run's result is read as: its last job's. */
@@ -6758,13 +7174,14 @@ export {
     PIPELINE_VERSION, DATASET_BODY_VERSION, STEP_TYPES, CONTENT_TYPES, OUTPUT_KINDS, MODIFIERS, EVAL_TYPES, LEGACY_TESTS, METRICS, readMetrics, metricSummary, metricCheck, itemScoresAsync, recordedReplyOf,
     SOURCE_TYPES, DEFAULT_SOURCE_TYPE, sourceTypeOf, WORKFLOW_PLATFORMS, platformOf, DYNAMIC_PROVIDERS, providerOf, WIZARDS, wizardProgress,
     registerKinds, defaultKind, jobDefaults, applyModifiers, keyVar, slugOf, uniqueSlug, isSlug, withSlugs, SLUG_MAX, connectionOf, addressOf, connectionSettings,
+    splitProfile, mergeAnswer, answerKey, answerOfKey, answersOf, runAnswer, answerConnectionId, connectionScoped,
     connectionRequest, connectionBase, connectionSend, connectionReply, connectionReplyProblem, connectionImage, connectionProblems,
 CONNECTION_FIELDS, SETTING_KEYS, OPTION_FIELDS, jobLabel, scenarioLabel, jobWords, versionProblem,
     contentOf, withContent, replyOf,
-    targetsOf, targetLetter, targetLabel, targetStepOf, targetEntryOf, jobTargetType, targetProfileOf, recordedTargetOf, withTarget,
-    tokensOf, withTokens, sendsImage, withImage, flowStepOf, readAsOf, outOf, withOut, slotEntry, SLOTS,
+    targetsOf, targetLetter, targetLabel, targetStepOf, targetEntryOf, jobTargetType, targetAnswerOf, targetAnswerKey, recordedTargetOf, withTarget,
+    tokensOf, withTokens, sendsImage, withImage, flowStepOf, requestStepOf, readAsOf, outOf, withOut, slotEntry, SLOTS,
     filterSetsOf, withFilterSets, stageModifiers, beforeFilters,
-    blankPipeline, upgradePipeline, fatProfileRef, newId, newEval, newLink, validatePipeline, resolvePipeline, pipelineOfRun, stagesFor, profileIds,
+    blankPipeline, upgradePipeline, fatProfileRef, newId, newEval, newLink, validatePipeline, resolvePipeline, pipelineOfRun, stagesFor, profileIds, answerKeys,
     scenarioProfile, lastKind, lastModifier, modifierSummary, itemScores, scenarioEvals, scenarioPasses, groupPass, overallVerdict, passVerdict, isSkipped, failedScore,
     evalLabel, evalsOf, evalsDataset, casesRef, groupOf, groupOfMetrics, pipelineWarnings, itemsFound, previewOf, isWholeRun, EVAL_FIELDS,
     pipelineToYaml, importPipeline, yamlToPipeline, exportBundle, readBundle, bundleProblems, junitXml,