@lampdotdev/lamp 0.36.2-nightly.32 → 0.36.2-nightly.36

package/README.md

@@ -26,7 +26,7 @@ Mac app, `projectOf`), or any folder with an `index.html`; without one, the fold
 | `lamp use key w 2` | Tries it as a person would, then looks: `click`, `type`, `key` (several at once with `w+d`), `drag`, `scroll`, `wait`, and in a game on Lamp's runtime `stick` and `button`, which hold Lamp's own controller as Lamp's app does (`window.__lampDrive`) and give it back when the person plays. Several moves with `then` between them go one after another, with one look at the end. |
 | `lamp reload [--fresh]` | Opens the page again from its files, a game from where the player is, or with `--fresh` from its beginning (`window.lampFreshStart`). |
 | `lamp stop` | Stops running it. |
-| `lamp share --words "…"` | Puts the page on lamp.dev: anyone with the link plays it there and can send an idea. Again, it sends the page as it is now to the same link. What the folder's `.lampignore` names stays out (`cli/ignore.mjs`: gitignore's simpler half, one pattern a line, `*`, `?`, `**`, a trailing `/` for a folder, no `!`; the app's own file counts for a page in Web/ too), so a page whose data is too big for a link shares from its own folder. The app's icon goes with it (`iconOf`: a square `icon.png` or `apple-touch-icon.png` beside the page, a PNG its index.html names as its icon, or Lamp's `.lamp/icon.png`, made 512 pixels a side when bigger), for its page and the browser's tab. The copies on the site it took changes from (`lamp take`'s credits, and the ones Lamp's app brought in, `.lamp/pulled-in.json`; `takenLinksOf`) go as `with`, so its page says "with changes from" them. |
+| `lamp share --words "…"` | Puts the page on lamp.dev: anyone with the link plays it there and can send an idea. Again, it sends the page as it is now to the same link. What the folder's `.lampignore` names stays out (`cli/ignore.mjs`: gitignore's simpler half, one pattern a line, `*`, `?`, `**`, a trailing `/` for a folder, no `!`; the app's own file counts for a page in Web/ too; Lamp's app follows it when it shares, `LampIgnore`), so a page whose data is too big for a link shares from its own folder. The app's icon goes with it (`iconOf`: a square `icon.png` or `apple-touch-icon.png` beside the page, a PNG its index.html names as its icon, or Lamp's `.lamp/icon.png`, made 512 pixels a side when bigger), for its page and the browser's tab. The copies on the site it took changes from (`lamp take`'s credits, and the ones Lamp's app brought in, `.lamp/pulled-in.json`; `takenLinksOf`) go as `with`, so its page says "with changes from" them. |
 | `lamp share` (a page of Lamp's) | A web app or game in a Lamp's own folder is lamp's to share like any other page, Lamp open or not, to the link that Lamp keeps for it: lamp takes the link from the Lamp's `Wish Links.json` (by the app's instance id in `.lamp/meta.json`, `lampsKeptLink`) the first time, and tells it what went after each share or `unshare` (`keepInLamp`), so its Share Link card shows the link as it is. `ideas` and `unshare` take the link the same way. |
 | `lamp share` (any other app of Lamp's) | For a folder in Lamp's own (or a link to one) that lamp doesn't share as a page, shared by Lamp's app over its socket (`share_link`, `OutsideWork`): its Share Link card filled as it fills itself (`WishLinkCards.prepare`: the link's last words, the questions and what's new Lamp writes, the app's file, the GitHub release) and shared without its window, with `--line`, `--by`, `--asks`, `--notes`, `--no-file`, `--no-github`, `--put-on-github` in place of the card's own, and `--preview` to see it first. The link's secret stays in Lamp. Which Lamp is the one whose folder it is (`lampOwning`), or the one it was given to (`lamp open --in-lamp`, `givenTo`); any other folder is lamp's to share, whatever Lamp is running, and so is a given folder when its Lamp is too old to share for lamp. |
 | `lamp ideas [in <n> \| dismiss <n> \| reply <n> \| done <n> \| email <address\|off>] [note]` | The ideas people playing the link have sent and what's been said since, saying what became of one, and answering whoever sent it. |

package/Resources/skills/app-ai/SKILL.md

@@ -73,7 +73,8 @@ back, the route's time), cancellation, questions back and the receipts. An app t
 request raises `steps:` (up to 40) and `writes:` (up to 320) on its session. Where the person might want another AI for
 the app's asking, `await LampAI.models()` lists what their setup can answer it with: a small Picker beside the Ask
 button with only the `available` ones and `defaultID` chosen, left out when there's one or none, its id passed as
-`model:` to `ask` and the session.
+`model:` to `ask` and the session. Each choice shows its `model` (the model's short name, or `name` when an older Lamp
+sends none), in a `Section` per `via?.name` only when more than one is available, with `name` as its `.help`.
 
 ```swift
 struct Rename: Decodable { let id: String; let name: String }

package/Resources/skills/web-app/SKILL.md

@@ -108,7 +108,9 @@ whichever AI the person set up for apps' text, so don't tie it to voice: typing
   that both fit.
 - Where the person might want another AI for the app's asking, `LampAI.models()` lists what their setup can answer it
   with: a small picker beside the Ask button with only the `available` ones and `default` chosen, left out when
-  there's one or none; the chosen id goes as `model` to `act` and `ask`. Keep the choice with the app's saved things,
+  there's one or none; the chosen id goes as `model` to `act` and `ask`. Each option shows the model's short `model`
+  (`name` when an older Lamp sends no `model`), with `name` as its `title`, under an `<optgroup>` per `via.name` only
+  when the available ones come through more than one; keep the list's order. Keep the choice with the app's saved things,
   and go back to `default` when it's no longer listed. On a page shared on lamp.dev it answers `connect: true` until
   the person connects, as `status` does.
 

package/cli/ai.mjs

@@ -4,10 +4,10 @@
 // same code (app-ai.mjs, which Lamp's app has do it too), so a page can't tell which answered it. Pictures and
 // hearing need Lamp's app: asked here, they say so.
 
-import { spawn, execFileSync } from "node:child_process";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { spawn } from "node:child_process";
+import { accessSync, constants, mkdtempSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { delimiter, join } from "node:path";
 import { randomBytes } from "node:crypto";
 import { chatBody, decidePrompt, planPrompt, planSchema, readDecision, readMessage, readPlan, readStep } from "./app-ai.mjs";
 import { DEFAULT_MODEL, OpenRouterTrouble, chat as openRouterChat, text as openRouterText } from "./openrouter.mjs";
@@ -18,11 +18,26 @@ import { DEFAULT_MODEL, OpenRouterTrouble, chat as openRouterChat, text as openR
  * the person's key in OPENROUTER_API_KEY.
  */
 export function engine() {
+  return engines()[0] ?? null;
+}
+
+/** Every engine that can answer here, what answers first: only `LAMP_AI`'s when it's set. */
+export function engines() {
   const wanted = process.env.LAMP_AI;
-  for (const name of wanted ? [wanted] : ["claude", "codex", "openrouter"]) {
-    if (name === "openrouter") { if (process.env.OPENROUTER_API_KEY) return name; continue; }
-    if (name !== "claude" && name !== "codex") continue;
-    try { execFileSync("/usr/bin/which", [name], { stdio: ["ignore", "pipe", "ignore"] }); return name; } catch {}
+  return (wanted ? [wanted] : ["claude", "codex", "openrouter"]).filter((name) => {
+    if (name === "openrouter") return !!process.env.OPENROUTER_API_KEY;
+    if (name !== "claude" && name !== "codex") return false;
+    return !!onPath(name);
+  });
+}
+
+/** Where a program is on the PATH this process has now, looked up here rather than by asking `which`, whose answer
+ *  can differ from this process's own PATH under Bun. */
+function onPath(name) {
+  for (const folder of String(process.env.PATH || "").split(delimiter)) {
+    if (!folder) continue;
+    const path = join(folder, name);
+    try { accessSync(path, constants.X_OK); if (statSync(path).isFile()) return path; } catch {}
   }
   return null;
 }
@@ -88,7 +103,7 @@ export function complete({ system, prompt, schema, seconds = 60, which = engine(
   const childEnv = { ...process.env, ...env };
   delete childEnv.BUN_BE_BUN;
   return new Promise((resolve, reject) => {
-    const child = spawn(tool || which, args, { cwd: folder, env: childEnv, detached: true, stdio: [input ? "pipe" : "ignore", "pipe", "pipe"] });
+    const child = spawn(tool || onPath(which) || which, args, { cwd: folder, env: childEnv, detached: true, stdio: [input ? "pipe" : "ignore", "pipe", "pipe"] });
     let text = "", trouble = null, rest = "", said = "";
     // The whole group, since an engine may leave a child holding its output.
     const stop = (kind, words) => { if (!trouble) trouble = new EngineTrouble(kind, words); try { process.kill(-child.pid, "SIGKILL"); } catch { child.kill("SIGKILL"); } };
@@ -176,19 +191,32 @@ const APP_MODELS = [
 /** Codex's models aren't known here without running it, so it's offered as one choice, by the id Lamp's app gives it then. */
 const CODEX = "engine:codex";
 
-/** One of the listed models by an id a page sent, Lamp's app's sign-in ids ("engine:claude:opus") included. */
-const listed = (asked) => APP_MODELS.find((m) => m.id === String(asked || "").replace(/^engine:claude:/, ""));
+/** How a page names a model through each engine, as Lamp's app does (`TextRoute.appID`), and what answers it
+ *  (`via`). A bare id ("opus") is that model through the engine that answers first. */
+const PREFIX = { claude: "engine:claude:", codex: CODEX, openrouter: "openrouter:" };
+const via = (which) => ({ id: which === "claude" ? "claude-code" : which, name: named(which) });
+
+/** One of the listed models by its bare id. */
+const listed = (asked) => APP_MODELS.find((m) => m.id === String(asked || ""));
+
+/** A model `LAMP_AI_MODEL` names that isn't one of Lamp's: what a page naming none gets from the engine that answers
+ *  first, so it's listed too. */
+function unlisted() {
+  const wanted = process.env.LAMP_AI_MODEL || "";
+  return wanted && !APP_MODELS.some((m) => m.id === wanted || m.openRouter === wanted) ? wanted : "";
+}
 
-/** The model's id a page gets when it names none: `LAMP_AI_MODEL` when it names a listed one, else Sonnet, as Lamp's app
- *  answers apps (never Haiku unasked). */
+/** The model's id a page gets when it names none: `LAMP_AI_MODEL` when it names one, else Sonnet, as Lamp's app
+ *  answers apps (never Haiku unasked), through the engine that answers first. */
 function defaultId(which) {
   if (which === "codex") return CODEX;
   const wanted = process.env.LAMP_AI_MODEL || "";
-  return (APP_MODELS.find((m) => m.id === wanted || m.openRouter === wanted) ?? listed("sonnet")).id;
+  const model = unlisted() || (APP_MODELS.find((m) => m.id === wanted || m.openRouter === wanted) ?? listed("sonnet")).id;
+  return PREFIX[which] + model;
 }
 
-/** What `complete` is told to run for the model a page named: an unknown one is answered as one that named none, never
- *  refused. A `LAMP_AI_MODEL` that isn't listed still answers what names none, as before. */
+/** What `complete` is told to run on `which` for a bare model id: an unknown one is answered as one that named none,
+ *  never refused. A `LAMP_AI_MODEL` that isn't listed still answers what names none, as before. */
 export function modelFor(which, asked) {
   const model = listed(asked);
   if (which === "codex") return process.env.LAMP_AI_MODEL || "";
@@ -197,19 +225,46 @@ export function modelFor(which, asked) {
   return which === "openrouter" ? DEFAULT_MODEL : "sonnet";
 }
 
-/** `/ai/models`: what a page can offer to choose from here, asked of nothing. */
-export function models() {
-  const which = engine();
-  if (!which) return { models: [], default: null, reason: missing };
-  if (which === "codex") return { models: [{ id: CODEX, name: "ChatGPT's default model via Codex", available: true }], default: CODEX };
-  const listedHere = APP_MODELS.map((m) => ({ id: m.id, name: `${m.name} via ${named(which)}`, available: true }));
-  // A model LAMP_AI_MODEL names that isn't one of Lamp's is what a page naming none gets: it's offered too, as the
-  // default, so choosing the default answers the same as choosing nothing.
-  const wanted = process.env.LAMP_AI_MODEL || "";
-  if (wanted && !APP_MODELS.some((m) => m.id === wanted || m.openRouter === wanted)) {
-    return { models: [{ id: wanted, name: `${wanted} via ${named(which)}`, available: true }, ...listedHere], default: wanted };
+/** The engine and model a page's `model` goes to (`ask` and `act`): an id with its engine ("engine:claude:opus",
+ *  "openrouter:opus", "engine:codex") is that engine when it can answer here; a bare id ("opus") is that model through
+ *  the engine that answers first. One that can't answer is answered as one that named none, never refused: a model
+ *  this doesn't list included, and any Codex model but its default, since Codex's own list isn't known here.
+ *  `here` is the engines the page may use (`enginesFor`). */
+export function routeFor(asked, here = engines()) {
+  const first = here[0] ?? null;
+  const id = String(asked || "");
+  for (const which of here) {
+    if (which === "codex") {
+      if (id === CODEX) return { which, model: which === first ? process.env.LAMP_AI_MODEL || "" : "" };
+      continue;
+    }
+    if (!id.startsWith(PREFIX[which])) continue;
+    const model = id.slice(PREFIX[which].length);
+    if (listed(model)) return { which, model: modelFor(which, model) };
+    if (which === first && model === unlisted()) return { which, model };
+    break;
   }
-  return { models: listedHere, default: defaultId(which) };
+  const bare = id.includes(":") ? "" : id;
+  return { which: first, model: first ? modelFor(first, bare) : "" };
+}
+
+/** The engines a request may use: every one here for the person's own page (`lamp dev`), only the one that answers
+ *  first for a page shared on lamp.dev (`page`, from `serveLocalAI`), the one the person was asked to let it use. */
+export const enginesFor = (page) => (page ? engines().slice(0, 1) : engines());
+
+/** `/ai/models`: what a page can offer to choose from here, asked of nothing. The engine that answers first comes
+ *  first, then the others, each with its most capable model first. */
+export function models(here = engines()) {
+  if (!here.length) return { models: [], default: null, reason: missing };
+  const list = here.flatMap((which) => {
+    if (which === "codex") return [{ id: CODEX, name: "ChatGPT's default model via Codex", model: "ChatGPT's default model", via: via(which), available: true }];
+    const one = (id, model) => ({ id: PREFIX[which] + id, name: `${model} via ${named(which)}`, model, via: via(which), available: true });
+    // A model LAMP_AI_MODEL names that isn't one of Lamp's is what a page naming none gets: it's offered too, first,
+    // so choosing the default answers the same as choosing nothing.
+    const extra = which === here[0] && unlisted() ? [one(unlisted(), unlisted())] : [];
+    return [...extra, ...APP_MODELS.map((m) => one(m.id, m.name))];
+  });
+  return { models: list, default: defaultId(here[0]) };
 }
 
 /**
@@ -221,13 +276,13 @@ const GUARD_SECONDS = 600;
 const secondsFor = (body) => (typeof body?.seconds === "number" && body.seconds > 0 ? Math.min(body.seconds, GUARD_SECONDS) : GUARD_SECONDS);
 
 /** `/ai`: a text answer, or JSON when asked for it. */
-export async function ask(body) {
+export async function ask(body, here = engines()) {
   const prompt = typeof body?.prompt === "string" ? body.prompt.trim() : "";
   if (!prompt) return [400, { error: "Missing prompt." }];
   let system = typeof body.system === "string" ? body.system : "";
   if (body.json) system += (system ? "\n\n" : "") + "Answer with JSON only, nothing around it.";
-  const which = engine();
-  try { return [200, { text: await complete({ system, prompt, images: body.images, which, model: modelFor(which, body.model), seconds: secondsFor(body) }) }]; }
+  const { which, model } = routeFor(body.model, here);
+  try { return [200, { text: await complete({ system, prompt, images: body.images, which, model, seconds: secondsFor(body) }) }]; }
   catch (error) { return [502, { error: error.message }]; }
 }
 
@@ -249,12 +304,14 @@ export async function decide(body) {
 // MARK: Actions (`LampAI.act`)
 
 /** `/ai/act`: one step of the page's agent loop, told and checked as Lamp's app does it (app-ai.mjs). */
-export async function act(body) {
-  const which = engine();
-  if (body?.probe === true) return [200, { act: !!which, route: which || "", why: which ? "" : missing }];
-  if (!which) return [501, { error: missing }];
+export async function act(body, here = engines()) {
+  const first = here[0] ?? null;
+  if (body?.probe === true) return [200, { act: !!first, route: first || "", why: first ? "" : missing }];
+  if (!first) return [501, { error: missing }];
   let r;
   try { r = readStep(JSON.stringify(body ?? null)); } catch (refused) { return [refused.status ?? 400, { error: refused.message }]; }
+  // The model the page named, through its own engine when that can answer here; else what answers first.
+  const { which, model } = routeFor(r.model, here);
   // A step's guard against a call that has stopped answering, as Lamp's app gives it (`AppAct.turnSeconds`).
   const seconds = 600;
   const deadline = Date.now() + Math.min(r.seconds, seconds) * 1000;
@@ -266,11 +323,11 @@ export async function act(body) {
     let read;
     try {
       if (which === "openrouter") {
-        const body = chatBody(r, tag, retry, modelFor(which, r.model));
+        const body = chatBody(r, tag, retry, model);
         read = readMessage((await openRouterChat({ key: process.env.OPENROUTER_API_KEY, body, seconds: left })).message, r);
       } else {
         const { system, prompt } = planPrompt(r, tag, retry);
-        read = readPlan(await complete({ system, prompt, schema: planSchema(r), seconds: left, which, model: modelFor(which, r.model) }), r);
+        read = readPlan(await complete({ system, prompt, schema: planSchema(r), seconds: left, which, model }), r);
       }
     } catch (error) {
       const words = error?.reply?.error?.message || error.message;
@@ -284,11 +341,11 @@ export async function act(body) {
 }
 
 /** A page's AI request, by its route, as Lamp's app answers it: [status, JSON]. */
-export async function answer(path, body) {
+export async function answer(path, body, page) {
   if (path === "/ai/status") return [200, status()];
-  if (path === "/ai/models") return [200, models()];
-  if (path === "/ai") return ask(body);
-  if (path === "/ai/act") return act(body);
+  if (path === "/ai/models") return [200, models(enginesFor(page))];
+  if (path === "/ai") return ask(body, enginesFor(page));
+  if (path === "/ai/act") return act(body, enginesFor(page));
   if (path === "/ai/decide") return decide(body);
   if (path === "/ai/hear") return body?.probe === true ? [200, { hear: false, why: "Hearing needs Lamp's app." }] : [501, { error: "Hearing needs Lamp's app: open the app in Lamp." }];
   if (path === "/ai/image") return [501, { error: "Pictures need Lamp's app: open the app in Lamp.", needs: "pictures" }];

package/cli/calls.mjs

@@ -25,7 +25,7 @@ import { Away, OffNetwork, Refused, Rejected, Runner, StillWorking, answersOn, b
 import { adbCommand, connectTo, deviceListing, deviceProperties, displaySizeOf, dumpIn, installApk, installTools, launchApp, makeEmulator, pairWith, processIn, processOf,
   rowsOf, saveState, screenItems, screenshotOf, tellApp, toolsThere, useLamps } from "./android.mjs";
 import { accountFor, keepAccount } from "./share.mjs";
-import { Unreachable, accountName, askAccount, ideasOf, latestOf, pageUp, makerOf, publishLink, removeFile, removeIdea, removeLink, replyIdea, sendFile } from "./link.mjs";
+import { Unreachable, accountName, askAccount, copiesOf, ideasOf, latestOf, pageUp, makerOf, publishLink, removeFile, removeIdea, removeLink, replyIdea, sendFile } from "./link.mjs";
 import { defaultRoute, homeNetwork, neighbours, samsungAt, subnetOn, tvsIn } from "./network.mjs";
 import { PUBLISHER, identityName, keptSigner, namesOf, packageOf, versionAfter } from "./msix.mjs";
 import { tile } from "./png.mjs";
@@ -211,7 +211,14 @@ export const CALLS = {
 
   /** What a followed link has now, asked with nothing of the person's; `latest` null when it can't be asked or is gone. */
   async linkLatest(given) {
-    return { latest: await latestOf({ site: siteOf(given), id: text(given, "id") }) };
+    // By the link's id, or by its maker's username and its name there (`lamp.dev/<user>/<app>`).
+    const named = typeof given?.user === "string" && typeof given?.app === "string";
+    return { latest: await latestOf(named ? { site: siteOf(given), user: given.user, app: given.app } : { site: siteOf(given), id: text(given, "id") }) };
+  },
+
+  /** The copies people shared of a link, newest first, as its page lists them: asked with nothing of the person's. */
+  async linkCopies(given) {
+    return { copies: await copiesOf({ site: siteOf(given), id: text(given, "id") }) };
   },
 
   /** The link's file (or with `page`, its playable page), from a file of Lamp's at `file`, sent in parts. */

package/cli/ignore.mjs

@@ -3,6 +3,8 @@
 // from elsewhere when it isn't there). The patterns are gitignore's simpler half: one a line, `#` for a note, `*`, `?` and
 // `**`, a trailing `/` for a folder, a leading `/` (or any `/` inside) for a path from the folder's top, and otherwise a
 // name matched at any depth. Nothing starting with `!`: what's left out stays out.
+// Lamp's app shares the same folders and reads them by these rules too (`LampIgnore`, which a test holds to this file):
+// a change here is made there in the same change.
 
 import { readFileSync } from "node:fs";
 import { join, relative, sep } from "node:path";

package/cli/lamps/lamp-for-games.js

@@ -857,18 +857,34 @@
     /** Whether this kind of AI can answer now, as `status` says. */
     isAvailable: function (capability) { return LampAI.status(capability).then(function (s) { return s.available; }); },
 
-    /** The models the person's setup can answer this app with now, asked of no model: { models: [{ id, name,
-     *  available, reason }], default, reason, help, connect }. `default` is the id that answers when a call names no
-     *  `model`; the ids are what `ask` and `act` take as `model`, and one that can't answer when it's sent is
-     *  answered as no choice, never refused. With none to offer, `models` is empty and `reason` says why; on a page
-     *  shared on lamp.dev that hasn't reached this computer yet it asks nothing and answers `connect: true`, as
-     *  `status` does: ask again once `connect` has. Keep the person's choice with the app's saved things, and go back
-     *  to `default` when it's no longer listed as available.
+    /** The models the person's setup can answer this app with now, asked of no model: { models: [{ id, name, model,
+     *  via: { id, name }, available, reason }], default, reason, help, connect }. `name` says the model with what
+     *  answers it ("Claude Sonnet via Claude Code"); `model` is the model's own short name ("Claude Sonnet") and `via`
+     *  what answers it ("claude-code" / "Claude Code", "codex" / "Codex", "openrouter" / "OpenRouter"), both left out
+     *  by an older Lamp. They come with what answers when a call names no `model` first, then by what else answers,
+     *  each with its most capable model first. Every id is the model through one harness: "engine:claude:opus",
+     *  "openrouter:opus", "engine:codex"; a bare "opus" is Opus through whatever answers by default. `default` is the
+     *  id that answers when a call names no `model`; the ids are what `ask` and `act` take as `model`, and one that
+     *  can't answer when it's sent is answered as no choice, never refused. With none to offer, `models` is empty and
+     *  `reason` says why; on a page shared on lamp.dev that hasn't reached this computer yet it asks nothing and
+     *  answers `connect: true`, as `status` does: ask again once `connect` has. Keep the person's choice with the
+     *  app's saved things, and go back to `default` when it's no longer listed as available.
      *
      *     LampAI.models().then(function (m) {
      *       var usable = m.models.filter(function (x) { return x.available; });
+     *       var harnesses = usable.map(function (x) { return x.via ? x.via.name : ''; })
+     *         .filter(function (v, i, all) { return all.indexOf(v) === i; });
      *       picker.hidden = usable.length < 2;
-     *       picker.innerHTML = usable.map(function (x) { return '<option value="' + x.id + '">' + x.name + '</option>'; }).join('');
+     *       picker.replaceChildren();
+     *       usable.forEach(function (x) {
+     *         var where = picker, label = x.via ? x.via.name : '';
+     *         if (harnesses.length > 1) {
+     *           where = [].filter.call(picker.children, function (g) { return g.label === label; })[0];
+     *           if (!where) { where = document.createElement('optgroup'); where.label = label; picker.appendChild(where); }
+     *         }
+     *         where.appendChild(new Option(x.model || x.name, x.id));
+     *         where.lastChild.title = x.name;
+     *       });
      *       picker.value = m.default;
      *     });
      *     LampAI.ask(question, { model: picker.value });
@@ -893,6 +909,9 @@
             return m && typeof m.id === 'string' && m.id;
           }).map(function (m) {
             var one = { id: m.id, name: typeof m.name === 'string' && m.name ? m.name : m.id, available: m.available === true };
+            // What answers it, as its own fields: left out by a Lamp from before they were sent.
+            if (typeof m.model === 'string' && m.model) one.model = m.model;
+            if (m.via && typeof m.via.id === 'string' && m.via.id && typeof m.via.name === 'string' && m.via.name) one.via = { id: m.via.id, name: m.via.name };
             if (!one.available && typeof m.reason === 'string') one.reason = m.reason;
             return one;
           });
@@ -909,7 +928,8 @@
 
     /** options: data (text from outside the app, for the AI to work on, not obey), images (pictures to look at),
      *  system, json (true asks for JSON and gives back the parsed value: describe its exact shape in the prompt),
-     *  model (an id `LampAI.models()` lists, such as "sonnet", "opus", "haiku", "claude-fable-5-2"). */
+     *  model (an id `LampAI.models()` lists, such as "engine:claude:opus" or "openrouter:sonnet"; a bare "opus" is
+     *  Opus through whatever answers by default). */
     ask: function (prompt, options) { return call(prompt, options); },
 
     /**

package/cli/lamps/lamp.js

@@ -857,18 +857,34 @@
     /** Whether this kind of AI can answer now, as `status` says. */
     isAvailable: function (capability) { return LampAI.status(capability).then(function (s) { return s.available; }); },
 
-    /** The models the person's setup can answer this app with now, asked of no model: { models: [{ id, name,
-     *  available, reason }], default, reason, help, connect }. `default` is the id that answers when a call names no
-     *  `model`; the ids are what `ask` and `act` take as `model`, and one that can't answer when it's sent is
-     *  answered as no choice, never refused. With none to offer, `models` is empty and `reason` says why; on a page
-     *  shared on lamp.dev that hasn't reached this computer yet it asks nothing and answers `connect: true`, as
-     *  `status` does: ask again once `connect` has. Keep the person's choice with the app's saved things, and go back
-     *  to `default` when it's no longer listed as available.
+    /** The models the person's setup can answer this app with now, asked of no model: { models: [{ id, name, model,
+     *  via: { id, name }, available, reason }], default, reason, help, connect }. `name` says the model with what
+     *  answers it ("Claude Sonnet via Claude Code"); `model` is the model's own short name ("Claude Sonnet") and `via`
+     *  what answers it ("claude-code" / "Claude Code", "codex" / "Codex", "openrouter" / "OpenRouter"), both left out
+     *  by an older Lamp. They come with what answers when a call names no `model` first, then by what else answers,
+     *  each with its most capable model first. Every id is the model through one harness: "engine:claude:opus",
+     *  "openrouter:opus", "engine:codex"; a bare "opus" is Opus through whatever answers by default. `default` is the
+     *  id that answers when a call names no `model`; the ids are what `ask` and `act` take as `model`, and one that
+     *  can't answer when it's sent is answered as no choice, never refused. With none to offer, `models` is empty and
+     *  `reason` says why; on a page shared on lamp.dev that hasn't reached this computer yet it asks nothing and
+     *  answers `connect: true`, as `status` does: ask again once `connect` has. Keep the person's choice with the
+     *  app's saved things, and go back to `default` when it's no longer listed as available.
      *
      *     LampAI.models().then(function (m) {
      *       var usable = m.models.filter(function (x) { return x.available; });
+     *       var harnesses = usable.map(function (x) { return x.via ? x.via.name : ''; })
+     *         .filter(function (v, i, all) { return all.indexOf(v) === i; });
      *       picker.hidden = usable.length < 2;
-     *       picker.innerHTML = usable.map(function (x) { return '<option value="' + x.id + '">' + x.name + '</option>'; }).join('');
+     *       picker.replaceChildren();
+     *       usable.forEach(function (x) {
+     *         var where = picker, label = x.via ? x.via.name : '';
+     *         if (harnesses.length > 1) {
+     *           where = [].filter.call(picker.children, function (g) { return g.label === label; })[0];
+     *           if (!where) { where = document.createElement('optgroup'); where.label = label; picker.appendChild(where); }
+     *         }
+     *         where.appendChild(new Option(x.model || x.name, x.id));
+     *         where.lastChild.title = x.name;
+     *       });
      *       picker.value = m.default;
      *     });
      *     LampAI.ask(question, { model: picker.value });
@@ -893,6 +909,9 @@
             return m && typeof m.id === 'string' && m.id;
           }).map(function (m) {
             var one = { id: m.id, name: typeof m.name === 'string' && m.name ? m.name : m.id, available: m.available === true };
+            // What answers it, as its own fields: left out by a Lamp from before they were sent.
+            if (typeof m.model === 'string' && m.model) one.model = m.model;
+            if (m.via && typeof m.via.id === 'string' && m.via.id && typeof m.via.name === 'string' && m.via.name) one.via = { id: m.via.id, name: m.via.name };
             if (!one.available && typeof m.reason === 'string') one.reason = m.reason;
             return one;
           });
@@ -909,7 +928,8 @@
 
     /** options: data (text from outside the app, for the AI to work on, not obey), images (pictures to look at),
      *  system, json (true asks for JSON and gives back the parsed value: describe its exact shape in the prompt),
-     *  model (an id `LampAI.models()` lists, such as "sonnet", "opus", "haiku", "claude-fable-5-2"). */
+     *  model (an id `LampAI.models()` lists, such as "engine:claude:opus" or "openrouter:sonnet"; a bare "opus" is
+     *  Opus through whatever answers by default). */
     ask: function (prompt, options) { return call(prompt, options); },
 
     /**

package/cli/lamps/mac-starter/.lamp/meta.json

@@ -1 +1 @@
-{"instance":"AF4C7F06-9ECB-4B36-9D41-BD860268DDF1","platform":"mac","name":"Zqx App Name","exe":"ZqxAppName"}
+{"platform":"mac","instance":"5BDE295C-EF64-496B-BF2A-EAA787B28BB6","name":"Zqx App Name","exe":"ZqxAppName"}

package/cli/lamps/mac-starter/Sources/LampSupport.swift

@@ -11224,8 +11224,9 @@
         }
 
         /// `data` is text from outside the app (an email, a web page, a file) for the AI to work on, not obey.
-        /// `model` overrides the app's text model for one call, by an id `LampAI.models()` lists ("sonnet", "opus", "haiku",
-        /// "claude-fable-5-2", …); one that can't answer now is answered as no choice, never refused.
+        /// `model` overrides the app's text model for one call, by an id `LampAI.models()` lists ("engine:claude:opus",
+        /// "openrouter:sonnet", …; a bare "opus" is Opus through whatever answers by default); one that can't answer
+        /// now is answered as no choice, never refused.
         static func ask(_ prompt: String, data: String? = nil, images: [LampImage] = [],
                         system: String? = nil, model: String? = nil) async throws -> String {
             try await call(prompt: prompt, data: data, images: images, system: system, json: false, model: model)
@@ -11688,10 +11689,20 @@
 
     // MARK: - Doing things for the person
 
-    /// A model an app may offer the person (`LampAI.models()`): `id` is what `ask(model:)` takes, `name` what to show.
+    /// A model an app may offer the person (`LampAI.models()`): `id` is what `ask(model:)` takes, `name` the model with
+    /// what answers it ("Claude Sonnet via Claude Code").
     struct LampAIModel: Identifiable, Equatable {
+        /// What answers a model: `id` is "claude-code", "codex" or "openrouter", `name` what to show ("Claude Code").
+        struct Via: Equatable {
+            let id: String
+            let name: String
+        }
         let id: String
         let name: String
+        /// The model's own short name ("Claude Sonnet"); nil from a Lamp from before it was sent, so show `name` then.
+        var model: String? = nil
+        /// What answers it; nil from a Lamp from before it was sent.
+        var via: Via? = nil
         /// Whether it can answer now; one that can't isn't worth offering.
         let available: Bool
         /// Why it can't, when it can't.
@@ -11765,12 +11776,18 @@
         }
 
         /// The models the person's setup can answer this app with now, asked of no model, so it's cheap to call as a
-        /// view appears. The ids are what `ask(model:)` and `LampActSession(model:)` take. Keep the person's choice with
-        /// the app's saved things, and go back to `defaultID` when it's no longer listed as available.
+        /// view appears. The ids are what `ask(model:)` and `LampActSession(model:)` take, each the model through one
+        /// harness ("engine:claude:opus", "openrouter:opus", "engine:codex"; a bare "opus" is Opus through whatever
+        /// answers by default). They come with what answers a call naming no model first, then by what else answers,
+        /// each with its most capable model first. Show `model` (the model's own short name) in a picker, under `via`'s
+        /// name when more than one harness is available, and `name` where `model` is nil (an older Lamp). Keep the
+        /// person's choice with the app's saved things, and go back to `defaultID` when it's no longer listed as available.
         ///
         ///     let choices = await LampAI.models()
         ///     if choices.available.count > 1 {
-        ///         Picker("AI", selection: $model) { ForEach(choices.available) { Text($0.name).tag(Optional($0.id)) } }
+        ///         Picker("AI", selection: $model) {
+        ///             ForEach(choices.available) { Text($0.model ?? $0.name).help($0.name).tag(Optional($0.id)) }
+        ///         }
         ///     }
         ///     // model starts as choices.defaultID; then: try await LampAI.ask(question, model: model)
         static func models() async -> LampAIModels {
@@ -11784,8 +11801,13 @@
             let models = (reply["models"] as? [[String: Any]] ?? []).compactMap { m -> LampAIModel? in
                 guard let id = m["id"] as? String, !id.isEmpty else { return nil }
                 let available = m["available"] as? Bool ?? false
-                return LampAIModel(id: id, name: (m["name"] as? String).flatMap { $0.isEmpty ? nil : $0 } ?? id, available: available,
-                                   reason: available ? nil : m["reason"] as? String)
+                let via = (m["via"] as? [String: Any]).flatMap { v -> LampAIModel.Via? in
+                    guard let id = v["id"] as? String, !id.isEmpty, let name = v["name"] as? String, !name.isEmpty else { return nil }
+                    return LampAIModel.Via(id: id, name: name)
+                }
+                return LampAIModel(id: id, name: (m["name"] as? String).flatMap { $0.isEmpty ? nil : $0 } ?? id,
+                                   model: (m["model"] as? String).flatMap { $0.isEmpty ? nil : $0 }, via: via,
+                                   available: available, reason: available ? nil : m["reason"] as? String)
             }
             let fallback = reply["default"] as? String
             return LampAIModels(models: models, defaultID: models.contains { $0.id == fallback && $0.available } ? fallback : nil,

package/cli/lamps/web-starter/lamp.js

@@ -857,18 +857,34 @@
     /** Whether this kind of AI can answer now, as `status` says. */
     isAvailable: function (capability) { return LampAI.status(capability).then(function (s) { return s.available; }); },
 
-    /** The models the person's setup can answer this app with now, asked of no model: { models: [{ id, name,
-     *  available, reason }], default, reason, help, connect }. `default` is the id that answers when a call names no
-     *  `model`; the ids are what `ask` and `act` take as `model`, and one that can't answer when it's sent is
-     *  answered as no choice, never refused. With none to offer, `models` is empty and `reason` says why; on a page
-     *  shared on lamp.dev that hasn't reached this computer yet it asks nothing and answers `connect: true`, as
-     *  `status` does: ask again once `connect` has. Keep the person's choice with the app's saved things, and go back
-     *  to `default` when it's no longer listed as available.
+    /** The models the person's setup can answer this app with now, asked of no model: { models: [{ id, name, model,
+     *  via: { id, name }, available, reason }], default, reason, help, connect }. `name` says the model with what
+     *  answers it ("Claude Sonnet via Claude Code"); `model` is the model's own short name ("Claude Sonnet") and `via`
+     *  what answers it ("claude-code" / "Claude Code", "codex" / "Codex", "openrouter" / "OpenRouter"), both left out
+     *  by an older Lamp. They come with what answers when a call names no `model` first, then by what else answers,
+     *  each with its most capable model first. Every id is the model through one harness: "engine:claude:opus",
+     *  "openrouter:opus", "engine:codex"; a bare "opus" is Opus through whatever answers by default. `default` is the
+     *  id that answers when a call names no `model`; the ids are what `ask` and `act` take as `model`, and one that
+     *  can't answer when it's sent is answered as no choice, never refused. With none to offer, `models` is empty and
+     *  `reason` says why; on a page shared on lamp.dev that hasn't reached this computer yet it asks nothing and
+     *  answers `connect: true`, as `status` does: ask again once `connect` has. Keep the person's choice with the
+     *  app's saved things, and go back to `default` when it's no longer listed as available.
      *
      *     LampAI.models().then(function (m) {
      *       var usable = m.models.filter(function (x) { return x.available; });
+     *       var harnesses = usable.map(function (x) { return x.via ? x.via.name : ''; })
+     *         .filter(function (v, i, all) { return all.indexOf(v) === i; });
      *       picker.hidden = usable.length < 2;
-     *       picker.innerHTML = usable.map(function (x) { return '<option value="' + x.id + '">' + x.name + '</option>'; }).join('');
+     *       picker.replaceChildren();
+     *       usable.forEach(function (x) {
+     *         var where = picker, label = x.via ? x.via.name : '';
+     *         if (harnesses.length > 1) {
+     *           where = [].filter.call(picker.children, function (g) { return g.label === label; })[0];
+     *           if (!where) { where = document.createElement('optgroup'); where.label = label; picker.appendChild(where); }
+     *         }
+     *         where.appendChild(new Option(x.model || x.name, x.id));
+     *         where.lastChild.title = x.name;
+     *       });
      *       picker.value = m.default;
      *     });
      *     LampAI.ask(question, { model: picker.value });
@@ -893,6 +909,9 @@
             return m && typeof m.id === 'string' && m.id;
           }).map(function (m) {
             var one = { id: m.id, name: typeof m.name === 'string' && m.name ? m.name : m.id, available: m.available === true };
+            // What answers it, as its own fields: left out by a Lamp from before they were sent.
+            if (typeof m.model === 'string' && m.model) one.model = m.model;
+            if (m.via && typeof m.via.id === 'string' && m.via.id && typeof m.via.name === 'string' && m.via.name) one.via = { id: m.via.id, name: m.via.name };
             if (!one.available && typeof m.reason === 'string') one.reason = m.reason;
             return one;
           });
@@ -909,7 +928,8 @@
 
     /** options: data (text from outside the app, for the AI to work on, not obey), images (pictures to look at),
      *  system, json (true asks for JSON and gives back the parsed value: describe its exact shape in the prompt),
-     *  model (an id `LampAI.models()` lists, such as "sonnet", "opus", "haiku", "claude-fable-5-2"). */
+     *  model (an id `LampAI.models()` lists, such as "engine:claude:opus" or "openrouter:sonnet"; a bare "opus" is
+     *  Opus through whatever answers by default). */
     ask: function (prompt, options) { return call(prompt, options); },
 
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lampdotdev/lamp",
-  "version": "0.36.2-nightly.32",
+  "version": "0.36.2-nightly.36",
   "description": "Runs a web app or game from its folder and puts each saved change into the open page.",
   "type": "module",
   "bin": {