@lampdotdev/lamp 0.36.2-nightly.26 → 0.36.2-nightly.28

package/README.md

@@ -18,7 +18,7 @@ Mac app, `projectOf`), or any folder with an `index.html`; without one, the fold
 | `lamp new <folder> [--name "Its Name"] [--web \| --mac]` | Makes a new web game's folder from Lamp's starting files, or with `--web` a new web app's, or with `--mac` a new Mac app in Swift. |
 | `lamp init [--update]` | Puts Lamp's game runtime beside a page that's already there, changing none of the page's own files. `--update` writes again the Lamp files the folder has (`lamp.js` too), adding the game's only to a page that's a game already. |
 | `lamp unpack <file.lampapp> [folder]` | Unpacks a Lamp app file into a new folder beside it, named for it. A file carries none of Lamp's own files: a page gets them beside it as it's unpacked (the runtime for a game, lamp.js, the libraries its import map names), and a Mac app gets Package.swift, build.sh and LampSupport.swift from Lamp's starting files as it's first built (`writeMacStarter`), where it has none. One with a widget, a share extension or a 3D scene is left to Lamp's app, which writes the files they're built with. |
-| `lamp export [--to file] [--anyway]` | Makes the app's Lamp app file as Lamp's Share… does (`Sharing.export`, followed by `cli/lampapp.mjs`): its own files as its kind travels, Assets/, APP.md, what it declares, its credits with the app added to the chain, the licenses they name, its icon's design and lamp-app.json, never Lamp's own files, nor what the folder's `.lampignore` names. Refused when a license its credits name is gone or something in it is shaped like a key; `--anyway` sends work its credits give no license for. The shapes of keys, the names a license goes by and the sizes another Lamp opens are in `Resources/share-rules.json`, which Lamp's app reads too (`ShareRules`). |
+| `lamp export [--to file] [--anyway]` | Makes the app's Lamp app file as Lamp's Share… does (`Sharing.export`, followed by `cli/lampapp.mjs`): its own files as its kind travels, Assets/, APP.md, what it declares, its credits with the app added to the chain, the licenses they name, its icon's design and lamp-app.json, never Lamp's own files, nor what the folder's `.lampignore` names. Refused when a license its credits name is gone or something in it is shaped like a key; `--anyway` sends work its credits give no license for, and lamp keeps that the person agreed (in its state), so it asks again only for work new to the app. A source credited `"live": true` (fetched while the app runs, nothing of it in the app) is never asked about. The shapes of keys, the names a license goes by and the sizes another Lamp opens are in `Resources/share-rules.json`, which Lamp's app reads too (`ShareRules`). |
 | `lamp dev [--open] [--lan] [--port N]` | Runs the page and says how each change went. Each save goes into every open copy of it, with the card Lamp's app puts on an app taking a change (`page.js`, left out of lamp's pictures; `lamp changing "<words>"` says on it what's changing). `--open` opens a window for it; `--lan` lets other devices on the network open it. |
 | `lamp open` | Shows the page in a window, running it in the background if it isn't running, and returns at once. |
 | `lamp open --in-lamp` | Gives a Mac app to Lamp's app (`cli/outside.mjs`), over the socket the person's own coding agent uses (`OutsideServer`, `OutsideWork`): `open_project` takes the folder on, with Lamp's review the first time, and from then on `look`, `reload` and `dev` call `apply_change`, so a change goes into the open app as Lamp's app puts it there (`LiveReload`) and its outcome is said: live, held, reopened, not_built, crashed. `use` calls `use_app`, in plain sight in the app Lamp's app has open, and `stop` calls `close_app`. A folder Lamp's app no longer has (its refusal says `taken_on: false`) is lamp's own again, said once. `lamp open --here` has lamp run its own copy again. `LAMP_APP` names another Lamp by its bundle id (a Lamp Dev instance). A Mac app `lamp new --mac` makes has the `lamp-app.json` Lamp's app takes a folder on by. |

package/Resources/GameKit/apple/LampPage.swift

@@ -100,7 +100,7 @@ import UIKit
 /// The page's way to Lamp: only the routes LampAI uses, and where phones join a game (`Lamp.controllers`), with the
 /// app's own token.
 final class LampPageGateway: NSObject, WKScriptMessageHandlerWithReply {
-    private static let routes: Set<String> = ["/ai", "/ai/status", "/ai/image", "/ai/decide", "/ai/act", "/ai/hear", "/app/controller"]
+    private static let routes: Set<String> = ["/ai", "/ai/status", "/ai/models", "/ai/image", "/ai/decide", "/ai/act", "/ai/hear", "/app/controller"]
     private let scheme: String
     init(scheme: String) { self.scheme = scheme }
 

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

@@ -69,7 +69,11 @@ create or edit pictures, use `LampAI.makeImage(...)`, `LampAI.editImage(...)` or
 things up and writes that change them, each a few lines over the app's data and its ordinary commands. The AI proposes
 calls, Lamp checks their shapes, the app's `check` says whether that exact change is allowed now, and its `run` makes it
 and returns a receipt. Lamp keeps the loop, its limits (4 AI steps between questions, 6 changes a request, 3 questions
-back, the route's time), cancellation, questions back and the receipts.
+back, the route's time), cancellation, questions back and the receipts. An app that builds something real in one
+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.
 
 ```swift
 struct Rename: Decodable { let id: String; let name: String }

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

@@ -71,11 +71,18 @@ So every feature that leans on Lamp keeps the app usable without it, going by wh
 for everything AI would do, example content where the person's own things would be, and a short line where something
 needs Lamp (for AI, `LampAI.status`'s `reason`), never an error or an empty screen.
 
+Credit a live source the app fetches as it runs (a transit feed, a map service, an open-data API) in credits.json's
+`upstream` with `"live": true`: nothing of it is in the app, so sharing passes none of it on, and it isn't asked about
+as work with no license. Work copied into the app (code, models, pictures, a data file saved from a feed) is never
+`live`, and its license is asked about before it's shared.
+
 ## Doing things for the person
 
 `LampAI.act(request, { about, context, tools, history, onStep })` runs a short loop: the AI picks calls among the
 app's tools, the page runs them, the AI sees the results, until it replies (at most 4 AI calls and 6 writes a
-turn, and no time limit unless the app sets one with `limits: { seconds }`, for a feature that should answer quickly; each read gives the AI up to 32 KB of its result, and an app whose state is bigger raises it with `limits: { result }`, up to 256 KB, rather than having the AI page through it). It works with
+turn, and no time limit unless the app sets one with `limits: { seconds }`, for a feature that should answer quickly; each read gives the AI up to 32 KB of its result, and an app whose state is bigger raises it with `limits: { result }`, up to 256 KB, rather than having the AI page through it). An app that builds something real in one request (a model of many pieces, a week's plan) raises
+`limits: { steps, writes }`, up to 40 steps and 320 writes; a tool that takes a list of items makes each write go
+further. It works with
 whichever AI the person set up for apps' text, so don't tie it to voice: typing works wherever `act` does. Its comment in lamp.js has the shapes. This is the one recipe for it:
 
 - Show the feature where `LampAI.status('act')` says it's available, and keep the app's own buttons for everything:
@@ -99,6 +106,11 @@ whichever AI the person set up for apps' text, so don't tie it to voice: typing
   is hidden.
 - `about` says what the app is and its rules for asking back: which person, which day and time, which of two things
   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,
+  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.
 
 Saying it instead of typing it: where the app around the page has a microphone (`LampVoice.status()`, which never
 prompts: the Mac, iPhone and iPad, Android and Android TV, a TV remote's microphone included) and Lamp can transcribe

package/cli/ai.mjs

@@ -1,6 +1,6 @@
 // The AI a page asks for with LampAI (lamp.js), answered by lamp itself for the pages it serves, with the person's own
 // Claude Code or Codex on this Mac: their subscription, through the program they signed in to, never a key in the page.
-// The same routes and answers Lamp's app gives (`/ai/status`, `/ai`, `/ai/act`, `/ai/decide`), told and checked by the
+// The same routes and answers Lamp's app gives (`/ai/status`, `/ai/models`, `/ai`, `/ai/act`, `/ai/decide`), told and checked by the
 // 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.
 
@@ -163,13 +163,63 @@ export function status() {
   };
 }
 
+// MARK: Models (`LampAI.models`, and `model` on `ask` and `act`)
+
+/** The models a page may name here, by Lamp's ids for them (`AppAI.anthropicModels` in Lamp's app, the same strings), with
+ *  what OpenRouter calls each. Claude Code takes the ids as they are. */
+const APP_MODELS = [
+  { id: "claude-fable-5-2", name: "Claude Fable", openRouter: "anthropic/claude-fable-5.2" },
+  { id: "opus", name: "Claude Opus", openRouter: "anthropic/claude-opus-5.5" },
+  { id: "sonnet", name: "Claude Sonnet", openRouter: DEFAULT_MODEL },
+  { id: "haiku", name: "Claude Haiku", openRouter: "anthropic/claude-haiku-5.5" },
+];
+/** 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:/, ""));
+
+/** 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). */
+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;
+}
+
+/** 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. */
+export function modelFor(which, asked) {
+  const model = listed(asked);
+  if (which === "codex") return process.env.LAMP_AI_MODEL || "";
+  if (model) return which === "openrouter" ? model.openRouter : model.id;
+  if (process.env.LAMP_AI_MODEL) return process.env.LAMP_AI_MODEL;
+  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 };
+  }
+  return { models: listedHere, default: defaultId(which) };
+}
+
 /** `/ai`: a text answer, or JSON when asked for it. */
 export async function ask(body) {
   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.";
-  try { return [200, { text: await complete({ system, prompt, images: body.images }) }]; }
+  const which = engine();
+  try { return [200, { text: await complete({ system, prompt, images: body.images, which, model: modelFor(which, body.model) }) }]; }
   catch (error) { return [502, { error: error.message }]; }
 }
 
@@ -208,11 +258,11 @@ export async function act(body) {
     let read;
     try {
       if (which === "openrouter") {
-        const body = chatBody(r, tag, retry, process.env.LAMP_AI_MODEL || DEFAULT_MODEL);
+        const body = chatBody(r, tag, retry, modelFor(which, r.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 }), r);
+        read = readPlan(await complete({ system, prompt, schema: planSchema(r), seconds: left, which, model: modelFor(which, r.model) }), r);
       }
     } catch (error) {
       const words = error?.reply?.error?.message || error.message;
@@ -228,6 +278,7 @@ 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) {
   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/decide") return decide(body);

package/cli/app-ai.mjs

@@ -7,14 +7,17 @@
 // the whole turn so far (the request, the tools, every earlier call and its result) and gets back either the calls to
 // make next or the reply. Nothing is kept between steps. What a step can hold on its own is checked here: the tools'
 // shapes, the calls the model hands back (checked against them, at most `MAX_CALLS`), the call ids, and that a turn
-// with `MAX_STEPS - 1` steps behind it is asked for a reply only. Limits across the turn (writes, time, cancel) are the
-// page's.
+// with `MAX_STEPS - 1` steps behind it is asked for a reply only. A turn's own step limit is the page's (4 unless the app
+// raises it, up to `MAX_STEPS`), which it keeps by sending `final` on its last step; so are its writes, time and cancel.
 //
 // Every route is asked one of two ways and read into the same calls-or-reply: a chat with OpenAI-style tools
 // (OpenRouter: `chatBody`, `readMessage`), or one prompt whose answer must fit the step's JSON shape (Claude Code, Codex:
 // `planPrompt`, `planSchema`, `readPlan`).
 
-export const MAX_TOOLS = 24, MAX_CALLS = 8, MAX_STEPS = 4, MAX_BODY = 2 * 1024 * 1024, MAX_CHOICES = 4, MAX_CHOICE = 24;
+// `MAX_STEPS` is the most steps an app may raise a turn to (`ACT_LIMITS_MAX` in lamp.js, `LampActSession.mostSteps`):
+// room to build something real a few calls at a time, while a turn that goes round in circles still ends. The most
+// writes follows from it, since each step holds at most `MAX_CALLS`.
+export const MAX_TOOLS = 24, MAX_CALLS = 8, MAX_STEPS = 40, MAX_BODY = 2 * 1024 * 1024, MAX_CHOICES = 4, MAX_CHOICE = 24;
 /** The longest a step may take, whatever its route, before its call is taken to have stopped answering (`ACT_STEP_SECONDS`
  *  in lamp.js, `AppAct.turnSeconds`). A turn has no time of its own unless the app gives it one. */
 export const MAX_TURN_SECONDS = 600;
@@ -63,7 +66,7 @@ function parseArg(raw, path) {
 
 /**
  * A step as the page sent it (its JSON text), checked and put in order: `{request, about, now, context?, tools, history,
- * steps, route, seconds, final}`, each tool's `args` as [name, shape] pairs by name. Throws `Refused`.
+ * steps, route, seconds, final, model?}`, each tool's `args` as [name, shape] pairs by name. Throws `Refused`.
  */
 export function readStep(text) {
   if (Buffer.byteLength(text) > MAX_BODY) throw new Refused(413, "A step can carry at most 2 MB.");
@@ -112,6 +115,8 @@ export function readStep(text) {
     tools, history, steps, route: typeof body.route === "string" ? body.route : null, seconds: Math.max(1, Math.min(seconds, MAX_TURN_SECONDS)),
     final: body.final === true || rawSteps.length >= MAX_STEPS - 1 };
   if ("context" in body) step.context = body.context;
+  // The model the app asked for (an id `LampAI.models` lists): the answering side takes it when it can, else its default.
+  if (typeof body.model === "string" && body.model) step.model = body.model;
   return step;
 }
 

package/cli/lampapp.mjs

@@ -232,9 +232,22 @@ export function exportApp(given, { anyway = false, link = null } = {}) {
     const gone = terms(source).find((path) => !existsSync(join(app, path)));
     if (gone) throw new Problem(`${name} can't be shared: the license of ${source.name} is missing from it. Put ${gone} back.`);
   }
-  const unlicensed = upstream.filter((source) => noLicense(source.license));
-  if (unlicensed.length && !anyway) {
-    throw new Problem(`${name} uses work that came with no license (${unlicensed.map((source) => source.author ? `${source.name} by ${source.author}` : source.name).join(", ")}). Ask the person whether they're comfortable sharing it; --anyway shares it all the same.`);
+  // Work in the app that came with no license: the person is asked once, as Lamp's Share Link asks (`ShareCheck`), and
+  // again only when the app takes in more. What it only fetches as it runs (`live`) isn't passed on, so it isn't asked of.
+  const unlicensed = upstream.filter((source) => noLicense(source.license) && source.live !== true);
+  const named = (source) => (source.author ? `${source.name} by ${source.author}` : source.name);
+  // Agreed to by the work itself, as Lamp keeps it (`ShareCheck.fingerprint`): its name, address and commit, so another
+  // work under the same name is asked about again.
+  const work = (source) => [source.name, source.url ?? "", source.commit ?? ""].join("\u001f");
+  const agreedFile = join(stateOf(folder), "unlicensed-agreed.json");
+  let agreed = [];
+  try { agreed = JSON.parse(readFileSync(agreedFile, "utf8")); } catch {}
+  const asking = unlicensed.filter((source) => !agreed.includes(work(source)));
+  if (asking.length && !anyway) {
+    throw new Problem(`${name} uses work that came with no license (${asking.map(named).join(", ")}). Ask the person whether they're comfortable sharing it; --anyway shares it, and it isn't asked again for these.`);
+  }
+  if (anyway && asking.length) {
+    try { mkdirSync(stateOf(folder), { recursive: true }); writeFileSync(agreedFile, JSON.stringify([...new Set([...agreed, ...unlicensed.map(work)])].sort(), null, 2)); } catch {}
   }
 
   const files = new Map(), from = (path) => readFileSync(join(app, path));

package/cli/lamps/android-host/LampPageGateway.kt

@@ -11,7 +11,7 @@ import org.json.JSONObject
 import kotlin.concurrent.thread
 
 object LampPageGateway {
-    private val routes = setOf("/ai", "/ai/status", "/ai/image", "/ai/decide", "/ai/act", "/ai/hear")
+    private val routes = setOf("/ai", "/ai/status", "/ai/models", "/ai/image", "/ai/decide", "/ai/act", "/ai/hear")
 
     /** Answers the page at `origin`, the page's own, in its main frame: no other page or frame reaches Lamp. */
     fun attach(web: WebView, origin: String) {

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

@@ -285,7 +285,7 @@
       });
     }
     var kept = read('nearby.token', null);
-    var done = path === '/ai/status' || (body && body.probe === true) ? go(kept) : (kept ? Promise.resolve(kept) : allow()).then(function (t) {
+    var done = path === '/ai/status' || path === '/ai/models' || (body && body.probe === true) ? go(kept) : (kept ? Promise.resolve(kept) : allow()).then(function (t) {
       return go(t).then(function (answer) {
         if (answer.status !== 401) return answer;
         // Taken back on the computer: ask once more.
@@ -519,8 +519,12 @@
 
   // A turn has no time limit of its own: a real answer is never cut off, however long the model takes. Each step is
   // given ACT_STEP_SECONDS, which only a call that has stopped answering reaches. An app that wants a quicker turn
-  // asks for one (`limits: { seconds }`); steps and writes it may only lower.
+  // asks for one (`limits: { seconds }`). Steps and writes are few unless the app says otherwise, so a request that
+  // goes wrong ends soon and changes little; an app that builds something real raises them (`limits: { steps,
+  // writes }`) up to ACT_LIMITS_MAX: 40 steps, as many as Lamp takes in one turn (`MAX_STEPS` in lamp's app-ai.mjs),
+  // and as many writes as 40 steps of 8 calls can hold.
   var ACT_LIMITS = { steps: 4, writes: 6 };
+  var ACT_LIMITS_MAX = { steps: 40, writes: 320 };
   // How much of one read goes back to the model: room for a real app's state (a 184-piece model, a week's calendar)
   // in one step, since paging through it costs steps a turn needs for its work. An app with more raises it
   // (`limits: { result }`), up to ACT_RESULT_MAX.
@@ -565,8 +569,8 @@
     var o = options || {}, tools = o.tools || {};
     var limits = {};
     ['steps', 'writes'].forEach(function (k) {
-      var asked = o.limits && typeof o.limits[k] === 'number' ? o.limits[k] : ACT_LIMITS[k];
-      limits[k] = Math.max(1, Math.min(asked, ACT_LIMITS[k]));
+      var asked = o.limits && typeof o.limits[k] === 'number' && o.limits[k] > 0 ? Math.floor(o.limits[k]) : ACT_LIMITS[k];
+      limits[k] = Math.max(1, Math.min(asked, ACT_LIMITS_MAX[k]));
     });
     var asked = o.limits && typeof o.limits.seconds === 'number' && o.limits.seconds > 0 ? o.limits.seconds : null;
     var resultMax = o.limits && typeof o.limits.result === 'number' && o.limits.result > 0
@@ -651,7 +655,8 @@
           if (bad) return fail(bad);
           var key = 'k' + hash(id + '|' + c.name + '|' + canonical(c.args));
           // The same change asked again in this turn gets its first result, and doesn't run again.
-          if (ran.hasOwnProperty(key)) { results[c.id] = { id: c.id, ok: true, repeat: true, value: ran[key] }; return next(i + 1); }
+          // Its result is in an earlier step, which every request carries: pointed to, not sent again.
+          if (ran.hasOwnProperty(key)) { results[c.id] = { id: c.id, ok: true, repeat: true, value: { note: 'Already done in this request: its result is in an earlier step.' } }; return next(i + 1); }
           if (writes >= limits.writes) return fail('Over this turn\'s limit of ' + limits.writes + ' changes.');
           var call = { turn: id, key: key, step: step, id: c.id };
           return Promise.resolve().then(function () { return tool.check ? tool.check(c.args, call) : null; }).then(function (problem) {
@@ -788,6 +793,11 @@
    * `connect: true`: show a small "Connect AI" button beside its reason that calls `LampAI.connect(capability)` with
    * the same kind of AI (`connect('pictures')` for pictures), and use what that gives as `status`'s answer. Never
    * call `connect()` as the page loads.
+   *
+   * Which AI answers is the person's choice in Lamp. An app may offer them another for its own asking: `LampAI.models()`
+   * lists what their setup can answer it with now. Show a small picker beside the app's Ask button with only the
+   * available ones and `default` chosen, and send the chosen id as `model` to `ask` and `act`. Leave the picker out
+   * when there's one or none to choose from.
    */
   var LampAI = {
     Failure: Failure,
@@ -841,15 +851,70 @@
     /** 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.
+     *
+     *     LampAI.models().then(function (m) {
+     *       var usable = m.models.filter(function (x) { return x.available; });
+     *       picker.hidden = usable.length < 2;
+     *       picker.innerHTML = usable.map(function (x) { return '<option value="' + x.id + '">' + x.name + '</option>'; }).join('');
+     *       picker.value = m.default;
+     *     });
+     *     LampAI.ask(question, { model: picker.value });
+     */
+    models: function () {
+      var none = function (reason, help) {
+        var said = { models: [], default: null, reason: reason || 'AI isn\'t set up for this here.' };
+        if (help) said.help = help;
+        return said;
+      };
+      if (!bridge && shared()) {
+        return nearbyAllowed().then(function (allowed) {
+          if (allowed) return listed();
+          if (safari()) return none(SAFARI_AI, AI_HELP);
+          return { models: [], default: null, connect: true, reason: 'Connect to the AI on this computer to use this.', help: AI_HELP };
+        });
+      }
+      return listed();
+      function listed() {
+        return post('/ai/models', {}, 10000).then(function (reply) {
+          var models = (isList(reply.models) ? reply.models : []).filter(function (m) {
+            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 };
+            if (!one.available && typeof m.reason === 'string') one.reason = m.reason;
+            return one;
+          });
+          var fallback = models.filter(function (m) { return m.available && m.id === reply.default; })[0];
+          if (!models.length) return none(reply.reason);
+          return { models: models, default: fallback ? fallback.id : null, reason: '' };
+        }, function (e) {
+          // A Lamp from before models were listed doesn't know the route.
+          var words = e && e.message;
+          return none(/^Not found\.?$/.test(words || '') ? 'Choosing the AI needs a newer Lamp.' : words, e && e.help);
+        });
+      }
+    },
+
     /** 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 (Lamp's id: "sonnet", "opus", "haiku", "claude-fable-5-2"). */
+     *  model (an id `LampAI.models()` lists, such as "sonnet", "opus", "haiku", "claude-fable-5-2"). */
     ask: function (prompt, options) { return call(prompt, options); },
 
     /**
      * Does what the person asks, in their own words, with the app's own reads and writes: the model picks calls,
-     * the page runs them, the model sees what happened, until it replies (at most 4 model calls and 6 writes a turn,
-     * with no time limit unless the app sets one with `limits: { seconds }`; Cancel ends it at once). Check `LampAI.isAvailable('act')` first; keep the app's buttons for everything.
+     * the page runs them, the model sees what happened, until it replies; Cancel ends it at once. Check
+     * `LampAI.isAvailable('act')` first; keep the app's buttons for everything. A turn takes at most 4 model calls
+     * and 6 writes and has no time limit; `limits` changes that for an app that needs it: `steps` (up to 40) and
+     * `writes` (up to 320) for one that builds something real in a turn, many changes at a time, `seconds` for a
+     * feature that should answer quickly, and `result` (bytes, 32 KB unless raised, up to 256 KB) for how much of a
+     * read the model sees. A limit that isn't a positive number keeps its default. `model` names which AI answers,
+     * as `ask`'s does; the whole turn stays on it.
      *
      *     var turn = LampAI.act('Add milk', {
      *       about: 'A family dashboard: the calendar, chores and the shopping list.',
@@ -862,6 +927,8 @@
      *                       run: function (args, call) { return add(args, call.key); } }
      *       },
      *       history: [{ said: 'Who did it?', heard: 'Maya' }],             // the last 3 exchanges, kept by the app
+     *       limits: { steps: 20, writes: 200 },                            // optional: see above
+     *       model: picker.value,                                           // optional: an id from LampAI.models()
      *       onStep: function (s) { … }                                     // { kind, name, args[, result] }
      *     });
      *     turn.result.then(function (r) { r.reply; r.ask; r.choices; r.done; r.failed; r.skipped; r.stopped; });

package/cli/lamps/lamp.js

@@ -285,7 +285,7 @@
       });
     }
     var kept = read('nearby.token', null);
-    var done = path === '/ai/status' || (body && body.probe === true) ? go(kept) : (kept ? Promise.resolve(kept) : allow()).then(function (t) {
+    var done = path === '/ai/status' || path === '/ai/models' || (body && body.probe === true) ? go(kept) : (kept ? Promise.resolve(kept) : allow()).then(function (t) {
       return go(t).then(function (answer) {
         if (answer.status !== 401) return answer;
         // Taken back on the computer: ask once more.
@@ -519,8 +519,12 @@
 
   // A turn has no time limit of its own: a real answer is never cut off, however long the model takes. Each step is
   // given ACT_STEP_SECONDS, which only a call that has stopped answering reaches. An app that wants a quicker turn
-  // asks for one (`limits: { seconds }`); steps and writes it may only lower.
+  // asks for one (`limits: { seconds }`). Steps and writes are few unless the app says otherwise, so a request that
+  // goes wrong ends soon and changes little; an app that builds something real raises them (`limits: { steps,
+  // writes }`) up to ACT_LIMITS_MAX: 40 steps, as many as Lamp takes in one turn (`MAX_STEPS` in lamp's app-ai.mjs),
+  // and as many writes as 40 steps of 8 calls can hold.
   var ACT_LIMITS = { steps: 4, writes: 6 };
+  var ACT_LIMITS_MAX = { steps: 40, writes: 320 };
   // How much of one read goes back to the model: room for a real app's state (a 184-piece model, a week's calendar)
   // in one step, since paging through it costs steps a turn needs for its work. An app with more raises it
   // (`limits: { result }`), up to ACT_RESULT_MAX.
@@ -565,8 +569,8 @@
     var o = options || {}, tools = o.tools || {};
     var limits = {};
     ['steps', 'writes'].forEach(function (k) {
-      var asked = o.limits && typeof o.limits[k] === 'number' ? o.limits[k] : ACT_LIMITS[k];
-      limits[k] = Math.max(1, Math.min(asked, ACT_LIMITS[k]));
+      var asked = o.limits && typeof o.limits[k] === 'number' && o.limits[k] > 0 ? Math.floor(o.limits[k]) : ACT_LIMITS[k];
+      limits[k] = Math.max(1, Math.min(asked, ACT_LIMITS_MAX[k]));
     });
     var asked = o.limits && typeof o.limits.seconds === 'number' && o.limits.seconds > 0 ? o.limits.seconds : null;
     var resultMax = o.limits && typeof o.limits.result === 'number' && o.limits.result > 0
@@ -651,7 +655,8 @@
           if (bad) return fail(bad);
           var key = 'k' + hash(id + '|' + c.name + '|' + canonical(c.args));
           // The same change asked again in this turn gets its first result, and doesn't run again.
-          if (ran.hasOwnProperty(key)) { results[c.id] = { id: c.id, ok: true, repeat: true, value: ran[key] }; return next(i + 1); }
+          // Its result is in an earlier step, which every request carries: pointed to, not sent again.
+          if (ran.hasOwnProperty(key)) { results[c.id] = { id: c.id, ok: true, repeat: true, value: { note: 'Already done in this request: its result is in an earlier step.' } }; return next(i + 1); }
           if (writes >= limits.writes) return fail('Over this turn\'s limit of ' + limits.writes + ' changes.');
           var call = { turn: id, key: key, step: step, id: c.id };
           return Promise.resolve().then(function () { return tool.check ? tool.check(c.args, call) : null; }).then(function (problem) {
@@ -788,6 +793,11 @@
    * `connect: true`: show a small "Connect AI" button beside its reason that calls `LampAI.connect(capability)` with
    * the same kind of AI (`connect('pictures')` for pictures), and use what that gives as `status`'s answer. Never
    * call `connect()` as the page loads.
+   *
+   * Which AI answers is the person's choice in Lamp. An app may offer them another for its own asking: `LampAI.models()`
+   * lists what their setup can answer it with now. Show a small picker beside the app's Ask button with only the
+   * available ones and `default` chosen, and send the chosen id as `model` to `ask` and `act`. Leave the picker out
+   * when there's one or none to choose from.
    */
   var LampAI = {
     Failure: Failure,
@@ -841,15 +851,70 @@
     /** 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.
+     *
+     *     LampAI.models().then(function (m) {
+     *       var usable = m.models.filter(function (x) { return x.available; });
+     *       picker.hidden = usable.length < 2;
+     *       picker.innerHTML = usable.map(function (x) { return '<option value="' + x.id + '">' + x.name + '</option>'; }).join('');
+     *       picker.value = m.default;
+     *     });
+     *     LampAI.ask(question, { model: picker.value });
+     */
+    models: function () {
+      var none = function (reason, help) {
+        var said = { models: [], default: null, reason: reason || 'AI isn\'t set up for this here.' };
+        if (help) said.help = help;
+        return said;
+      };
+      if (!bridge && shared()) {
+        return nearbyAllowed().then(function (allowed) {
+          if (allowed) return listed();
+          if (safari()) return none(SAFARI_AI, AI_HELP);
+          return { models: [], default: null, connect: true, reason: 'Connect to the AI on this computer to use this.', help: AI_HELP };
+        });
+      }
+      return listed();
+      function listed() {
+        return post('/ai/models', {}, 10000).then(function (reply) {
+          var models = (isList(reply.models) ? reply.models : []).filter(function (m) {
+            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 };
+            if (!one.available && typeof m.reason === 'string') one.reason = m.reason;
+            return one;
+          });
+          var fallback = models.filter(function (m) { return m.available && m.id === reply.default; })[0];
+          if (!models.length) return none(reply.reason);
+          return { models: models, default: fallback ? fallback.id : null, reason: '' };
+        }, function (e) {
+          // A Lamp from before models were listed doesn't know the route.
+          var words = e && e.message;
+          return none(/^Not found\.?$/.test(words || '') ? 'Choosing the AI needs a newer Lamp.' : words, e && e.help);
+        });
+      }
+    },
+
     /** 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 (Lamp's id: "sonnet", "opus", "haiku", "claude-fable-5-2"). */
+     *  model (an id `LampAI.models()` lists, such as "sonnet", "opus", "haiku", "claude-fable-5-2"). */
     ask: function (prompt, options) { return call(prompt, options); },
 
     /**
      * Does what the person asks, in their own words, with the app's own reads and writes: the model picks calls,
-     * the page runs them, the model sees what happened, until it replies (at most 4 model calls and 6 writes a turn,
-     * with no time limit unless the app sets one with `limits: { seconds }`; Cancel ends it at once). Check `LampAI.isAvailable('act')` first; keep the app's buttons for everything.
+     * the page runs them, the model sees what happened, until it replies; Cancel ends it at once. Check
+     * `LampAI.isAvailable('act')` first; keep the app's buttons for everything. A turn takes at most 4 model calls
+     * and 6 writes and has no time limit; `limits` changes that for an app that needs it: `steps` (up to 40) and
+     * `writes` (up to 320) for one that builds something real in a turn, many changes at a time, `seconds` for a
+     * feature that should answer quickly, and `result` (bytes, 32 KB unless raised, up to 256 KB) for how much of a
+     * read the model sees. A limit that isn't a positive number keeps its default. `model` names which AI answers,
+     * as `ask`'s does; the whole turn stays on it.
      *
      *     var turn = LampAI.act('Add milk', {
      *       about: 'A family dashboard: the calendar, chores and the shopping list.',
@@ -862,6 +927,8 @@
      *                       run: function (args, call) { return add(args, call.key); } }
      *       },
      *       history: [{ said: 'Who did it?', heard: 'Maya' }],             // the last 3 exchanges, kept by the app
+     *       limits: { steps: 20, writes: 200 },                            // optional: see above
+     *       model: picker.value,                                           // optional: an id from LampAI.models()
      *       onStep: function (s) { … }                                     // { kind, name, args[, result] }
      *     });
      *     turn.result.then(function (r) { r.reply; r.ask; r.choices; r.done; r.failed; r.skipped; r.stopped; });

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

@@ -1 +1 @@
-{"exe":"ZqxAppName","name":"Zqx App Name","platform":"mac","instance":"10DC6CFC-3873-414E-B724-6AA904DC37A0"}
+{"name":"Zqx App Name","instance":"FE98C883-9417-425A-8B4A-689C3EB7CC0A","exe":"ZqxAppName","platform":"mac"}

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

@@ -202,6 +202,10 @@
             if path == "/ai/act" {
                 throw LampAI.Failure(message: "Couldn't reach Lamp, and asking the app to do things needs it. Try again on the same Wi‑Fi as the Mac.")
             }
+            // Away, the phone answers with the one model it carries: nothing to choose among.
+            if path == "/ai/models" {
+                return ["models": [Any](), "reason": "Choosing the AI needs Lamp: use the app on the same Wi‑Fi as the Mac."]
+            }
             fputs("LampAI \(path): Lamp isn't reachable, using the key kept on this phone\n", stderr)
             switch path {
             case "/ai":
@@ -11197,6 +11201,11 @@
     /// To have the app do what the person asks in their own words, give `LampAI.act` (or a `LampActSession`) the app's
     /// own reads and checked writes: the AI chooses among them, the app checks and runs each, and the result says what
     /// was done from the tools' receipts.
+    ///
+    /// Which AI answers is the person's choice in Lamp. An app may offer them another for its own asking:
+    /// `await LampAI.models()` lists what their setup can answer it with now. Show a small Picker beside the app's Ask
+    /// button with only the `available` ones and `defaultID` chosen, and pass the chosen id as `model:` to `ask` and to a
+    /// `LampActSession`. Leave the picker out when there's one or none to choose from.
     enum LampAI {
         struct Failure: LocalizedError {
             let message: String
@@ -11215,7 +11224,8 @@
         }
 
         /// `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 Lamp's id ("sonnet", "opus", "haiku", "claude-fable-5-2").
+        /// `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.
         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)
@@ -11677,6 +11687,27 @@
 
     // 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.
+    struct LampAIModel: Identifiable, Equatable {
+        let id: String
+        let name: String
+        /// Whether it can answer now; one that can't isn't worth offering.
+        let available: Bool
+        /// Why it can't, when it can't.
+        let reason: String?
+    }
+
+    /// What the person's setup can answer an app with now (`LampAI.models()`).
+    struct LampAIModels {
+        var models: [LampAIModel] = []
+        /// The one that answers a call naming no model; nil when nothing can answer.
+        var defaultID: String?
+        /// Why there's nothing to choose from, when there isn't.
+        var reason: String?
+        /// The ones to show in a picker.
+        var available: [LampAIModel] { models.filter(\.available) }
+    }
+
     /// How one kind of AI stands for this app now, as Lamp sees it (`LampAI.status`).
     struct LampAIStatus {
         /// Where the AI works out its answer, for telling the person where their words go. A Claude Code or Codex
@@ -11732,12 +11763,41 @@
             }
         }
 
+        /// 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.
+        ///
+        ///     let choices = await LampAI.models()
+        ///     if choices.available.count > 1 {
+        ///         Picker("AI", selection: $model) { ForEach(choices.available) { Text($0.name).tag(Optional($0.id)) } }
+        ///     }
+        ///     // model starts as choices.defaultID; then: try await LampAI.ask(question, model: model)
+        static func models() async -> LampAIModels {
+            let reply: [String: Any]
+            do { reply = try await post("/ai/models", [:], timeout: 10) } catch {
+                // A Lamp from before models were listed doesn't know the route.
+                let words = (error as? Failure)?.message ?? ""
+                return LampAIModels(reason: words.hasPrefix("Not found") ? "Choosing the AI needs a newer Lamp."
+                                    : (words.isEmpty ? "Lamp isn't open, or can't be reached from here." : words))
+            }
+            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 fallback = reply["default"] as? String
+            return LampAIModels(models: models, defaultID: models.contains { $0.id == fallback && $0.available } ? fallback : nil,
+                                reason: models.isEmpty ? (reply["reason"] as? String ?? "AI isn't set up in Lamp yet.") : nil)
+        }
+
         /// The person asks the app to do something in their own words, and the app's own tools do it: a few reads and
         /// checked writes over its data, chosen by the AI, run by the app. `LampActSession` has the details; this starts a
         /// request in `session`, or in a session of its own when there's none to keep (no questions back can be answered then).
+        /// `model` is for that session of its own, as `LampActSession(model:)` takes it.
         @MainActor static func act(request: String, about: String = "", context: (any Encodable)? = nil, tools: [LampActTool],
-                                   session: LampActSession? = nil, onStep: ((LampActStep) -> Void)? = nil) -> LampActTurn {
-            (session ?? LampActSession(about: about, tools: tools)).ask(request, context: context, onStep: onStep)
+                                   session: LampActSession? = nil, model: String? = nil, onStep: ((LampActStep) -> Void)? = nil) -> LampActTurn {
+            (session ?? LampActSession(about: about, tools: tools, model: model)).ask(request, context: context, onStep: onStep)
         }
 
         fileprivate static var actPresent: String { present }
@@ -11993,13 +12053,22 @@
     /// its `run` makes it. Reads run first, then changes one at a time, each checked right before it runs; a change that
     /// fails skips the rest of that step. The same change asked twice in a request runs once. A request may take 4 AI
     /// steps between questions, 6 changes in all and 3 questions back, with no time limit unless the app sets one
-    /// (`seconds:`): a real answer is never cut off. Each step stops only when a call has stopped answering
-    /// (`stepSeconds`). Asking something new, cancelling or closing ends it.
+    /// (`seconds:`): a real answer is never cut off. An app that builds something real in one request raises `steps:`
+    /// (up to 40) and `writes:` (up to 320); a value that isn't positive keeps the default. `model:` names which AI
+    /// answers, an id from `LampAI.models()`. Each step stops only when a call has stopped answering (`stepSeconds`).
+    /// Asking something new, cancelling or closing ends it.
     @MainActor final class LampActSession {
+        /// A request's steps and changes unless the app raises them: few, so a request that goes wrong ends soon and
+        /// changes little.
         static let maxSteps = 4
         static let maxWrites = 6
+        /// The most an app may raise them to: as many steps as Lamp takes in one turn (`MAX_STEPS` in lamp's app-ai.mjs),
+        /// and as many changes as that many steps of 8 calls can hold (`ACT_LIMITS_MAX` in lamp.js).
+        static let mostSteps = 40
+        static let mostWrites = 320
         static let maxQuestions = 3
         /// What a session keeps of its changes; past this it stops taking changes and says so, rather than forget them.
+        /// A session whose requests may make more keeps ten requests' worth (`receiptLimit`).
         static let maxReceipts = 60
         /// How long one step may take before its call is taken to have stopped answering.
         static let stepSeconds: Double = 600
@@ -12034,16 +12103,28 @@
         /// How much of one read goes back to the AI, in bytes: room for an app's real state in one step, since paging
         /// through it costs steps a request needs for its work.
         let resultBytes: Int
+        /// The AI steps a request may take between questions, and the changes it may make in all.
+        let stepLimit: Int
+        let writeLimit: Int
+        /// Which AI answers, by an id `LampAI.models()` lists; nil for the app's own.
+        let model: String?
+        private var receiptLimit: Int { max(Self.maxReceipts, writeLimit * 10) }
 
         /// `seconds` limits each request's time, for a feature that should answer quickly; leave it out for no limit.
         /// `resultBytes` raises how much of a read the AI sees (32 KB unless given, 256 KB at most).
+        /// `steps` and `writes` raise a request's AI steps (4 unless given, 40 at most) and changes (6, 320 at most).
+        /// `model` names which AI answers, an id from `LampAI.models()`; leave it out for the app's own.
         /// `send` stands in for Lamp in a test; leave it out.
         init(about: String = "", tools: [LampActTool], seconds: Double? = nil, resultBytes: Int? = nil,
+             steps: Int? = nil, writes: Int? = nil, model: String? = nil,
              send: (([String: Any], TimeInterval) async throws -> [String: Any])? = nil) {
             self.about = about
             self.tools = tools
             self.seconds = seconds.map { max(1, $0) }
             self.resultBytes = min(max(resultBytes ?? 32_768, 1024), 262_144)
+            self.stepLimit = min(steps.flatMap { $0 > 0 ? $0 : nil } ?? Self.maxSteps, Self.mostSteps)
+            self.writeLimit = min(writes.flatMap { $0 > 0 ? $0 : nil } ?? Self.maxWrites, Self.mostWrites)
+            self.model = model.flatMap { $0.isEmpty ? nil : $0 }
             self.send = send ?? { body, timeout in try await LampAI.post("/ai/act", body, timeout: timeout) }
         }
 
@@ -12127,7 +12208,8 @@
                                            "tools": tools.map(\.declared), "steps": steps, "seconds": Int(left)]
                 if let context { body["context"] = context }
                 if let route { body["route"] = route }
-                if steps.count >= Self.maxSteps - 1 { body["final"] = true }
+                if let model { body["model"] = model }
+                if steps.count >= stepLimit - 1 { body["final"] = true }
                 onStep(.thinking)
                 let answer: [String: Any]
                 do { answer = try await send(body, left) } catch {
@@ -12154,7 +12236,7 @@
                         return results[id] ?? ["id": id, "ok": false, "skipped": "Not run."]
                     }])
                     if out.stopped != nil { break }
-                    if steps.count >= Self.maxSteps { out.stopped = .steps; break }
+                    if steps.count >= stepLimit { out.stopped = .steps; break }
                     continue
                 }
                 out.reply = answer["reply"] as? String ?? ""
@@ -12220,18 +12302,19 @@
                 if let stopped { miss(stopped, skipped: true); continue }
                 if let bad = tool.problem(given) { miss(bad); continue }
                 let key = Self.prefix(op) + Self.hash(tool.name + "|" + Self.canonical(given))
-                // The same change asked again in this request gets its first result, and doesn't run again: one that
+                // The same change asked again in this request is pointed to its first result, and doesn't run again: one that
                 // failed while it ran may have done part of it, so it isn't tried again by itself either.
                 if let kept = ran[key] {
                     if let failed = kept as? [String: Any], let reason = failed["failedWhileRunning"] as? String {
                         miss("Already tried in this request, and it didn't go through: \(reason)")
                     } else {
-                        results[id] = ["id": id, "ok": true, "repeat": true, "value": kept]
+                        // Its result is in an earlier step, which every request carries: pointed to, not sent again.
+                        results[id] = ["id": id, "ok": true, "repeat": true, "value": ["note": "Already done in this request: its result is in an earlier step."]]
                     }
                     continue
                 }
-                if op.writes >= Self.maxWrites { miss("Over this request's limit of \(Self.maxWrites) changes."); out.stopped = .limit; out.error = "That's more changes than one request can make. Ask for the rest separately."; return results }
-                if receipts.count >= Self.maxReceipts { miss("This conversation has made as many changes as it can keep track of."); out.stopped = .limit; out.error = "Close this and start again to make more changes."; return results }
+                if op.writes >= writeLimit { miss("Over this request's limit of \(writeLimit) changes."); out.stopped = .limit; out.error = "That's more changes than one request can make. Ask for the rest separately."; return results }
+                if receipts.count >= receiptLimit { miss("This conversation has made as many changes as it can keep track of."); out.stopped = .limit; out.error = "Close this and start again to make more changes."; return results }
                 let info = callInfo(call, key: key)
                 let problem: String?
                 do { problem = try await tool.check?(given, info) } catch { problem = Self.words(error) }
@@ -12245,11 +12328,15 @@
                     // Done is done, even if the turn was cancelled while it ran: it's kept and shown.
                     var value = receipt.details.filter { JSONSerialization.isValidJSONObject([$0.value]) }
                     value["summary"] = receipt.summary
-                    ran[key] = value
+                    // What the AI is shown of it draws on the request's allowance as a read does, since every later
+                    // step carries it again; the receipt keeps it whole for the app.
+                    let shown = Self.cut(value, max: Swift.max(1024, Swift.min(resultBytes, op.resultsLeft)))
+                    op.resultsLeft = Swift.max(0, op.resultsLeft - ((try? JSONSerialization.data(withJSONObject: [shown]))?.count ?? 0))
+                    ran[key] = shown
                     let done = LampActDone(tool: tool.name, key: key, receipt: receipt)
                     out.done.append(done)
                     receipts.append(done)
-                    results[id] = ["id": id, "ok": true, "value": value]
+                    results[id] = ["id": id, "ok": true, "value": shown]
                     onStep(.changed(done))
                 } catch {
                     ran[key] = ["failedWhileRunning": Self.words(error)]

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

@@ -285,7 +285,7 @@
       });
     }
     var kept = read('nearby.token', null);
-    var done = path === '/ai/status' || (body && body.probe === true) ? go(kept) : (kept ? Promise.resolve(kept) : allow()).then(function (t) {
+    var done = path === '/ai/status' || path === '/ai/models' || (body && body.probe === true) ? go(kept) : (kept ? Promise.resolve(kept) : allow()).then(function (t) {
       return go(t).then(function (answer) {
         if (answer.status !== 401) return answer;
         // Taken back on the computer: ask once more.
@@ -519,8 +519,12 @@
 
   // A turn has no time limit of its own: a real answer is never cut off, however long the model takes. Each step is
   // given ACT_STEP_SECONDS, which only a call that has stopped answering reaches. An app that wants a quicker turn
-  // asks for one (`limits: { seconds }`); steps and writes it may only lower.
+  // asks for one (`limits: { seconds }`). Steps and writes are few unless the app says otherwise, so a request that
+  // goes wrong ends soon and changes little; an app that builds something real raises them (`limits: { steps,
+  // writes }`) up to ACT_LIMITS_MAX: 40 steps, as many as Lamp takes in one turn (`MAX_STEPS` in lamp's app-ai.mjs),
+  // and as many writes as 40 steps of 8 calls can hold.
   var ACT_LIMITS = { steps: 4, writes: 6 };
+  var ACT_LIMITS_MAX = { steps: 40, writes: 320 };
   // How much of one read goes back to the model: room for a real app's state (a 184-piece model, a week's calendar)
   // in one step, since paging through it costs steps a turn needs for its work. An app with more raises it
   // (`limits: { result }`), up to ACT_RESULT_MAX.
@@ -565,8 +569,8 @@
     var o = options || {}, tools = o.tools || {};
     var limits = {};
     ['steps', 'writes'].forEach(function (k) {
-      var asked = o.limits && typeof o.limits[k] === 'number' ? o.limits[k] : ACT_LIMITS[k];
-      limits[k] = Math.max(1, Math.min(asked, ACT_LIMITS[k]));
+      var asked = o.limits && typeof o.limits[k] === 'number' && o.limits[k] > 0 ? Math.floor(o.limits[k]) : ACT_LIMITS[k];
+      limits[k] = Math.max(1, Math.min(asked, ACT_LIMITS_MAX[k]));
     });
     var asked = o.limits && typeof o.limits.seconds === 'number' && o.limits.seconds > 0 ? o.limits.seconds : null;
     var resultMax = o.limits && typeof o.limits.result === 'number' && o.limits.result > 0
@@ -651,7 +655,8 @@
           if (bad) return fail(bad);
           var key = 'k' + hash(id + '|' + c.name + '|' + canonical(c.args));
           // The same change asked again in this turn gets its first result, and doesn't run again.
-          if (ran.hasOwnProperty(key)) { results[c.id] = { id: c.id, ok: true, repeat: true, value: ran[key] }; return next(i + 1); }
+          // Its result is in an earlier step, which every request carries: pointed to, not sent again.
+          if (ran.hasOwnProperty(key)) { results[c.id] = { id: c.id, ok: true, repeat: true, value: { note: 'Already done in this request: its result is in an earlier step.' } }; return next(i + 1); }
           if (writes >= limits.writes) return fail('Over this turn\'s limit of ' + limits.writes + ' changes.');
           var call = { turn: id, key: key, step: step, id: c.id };
           return Promise.resolve().then(function () { return tool.check ? tool.check(c.args, call) : null; }).then(function (problem) {
@@ -788,6 +793,11 @@
    * `connect: true`: show a small "Connect AI" button beside its reason that calls `LampAI.connect(capability)` with
    * the same kind of AI (`connect('pictures')` for pictures), and use what that gives as `status`'s answer. Never
    * call `connect()` as the page loads.
+   *
+   * Which AI answers is the person's choice in Lamp. An app may offer them another for its own asking: `LampAI.models()`
+   * lists what their setup can answer it with now. Show a small picker beside the app's Ask button with only the
+   * available ones and `default` chosen, and send the chosen id as `model` to `ask` and `act`. Leave the picker out
+   * when there's one or none to choose from.
    */
   var LampAI = {
     Failure: Failure,
@@ -841,15 +851,70 @@
     /** 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.
+     *
+     *     LampAI.models().then(function (m) {
+     *       var usable = m.models.filter(function (x) { return x.available; });
+     *       picker.hidden = usable.length < 2;
+     *       picker.innerHTML = usable.map(function (x) { return '<option value="' + x.id + '">' + x.name + '</option>'; }).join('');
+     *       picker.value = m.default;
+     *     });
+     *     LampAI.ask(question, { model: picker.value });
+     */
+    models: function () {
+      var none = function (reason, help) {
+        var said = { models: [], default: null, reason: reason || 'AI isn\'t set up for this here.' };
+        if (help) said.help = help;
+        return said;
+      };
+      if (!bridge && shared()) {
+        return nearbyAllowed().then(function (allowed) {
+          if (allowed) return listed();
+          if (safari()) return none(SAFARI_AI, AI_HELP);
+          return { models: [], default: null, connect: true, reason: 'Connect to the AI on this computer to use this.', help: AI_HELP };
+        });
+      }
+      return listed();
+      function listed() {
+        return post('/ai/models', {}, 10000).then(function (reply) {
+          var models = (isList(reply.models) ? reply.models : []).filter(function (m) {
+            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 };
+            if (!one.available && typeof m.reason === 'string') one.reason = m.reason;
+            return one;
+          });
+          var fallback = models.filter(function (m) { return m.available && m.id === reply.default; })[0];
+          if (!models.length) return none(reply.reason);
+          return { models: models, default: fallback ? fallback.id : null, reason: '' };
+        }, function (e) {
+          // A Lamp from before models were listed doesn't know the route.
+          var words = e && e.message;
+          return none(/^Not found\.?$/.test(words || '') ? 'Choosing the AI needs a newer Lamp.' : words, e && e.help);
+        });
+      }
+    },
+
     /** 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 (Lamp's id: "sonnet", "opus", "haiku", "claude-fable-5-2"). */
+     *  model (an id `LampAI.models()` lists, such as "sonnet", "opus", "haiku", "claude-fable-5-2"). */
     ask: function (prompt, options) { return call(prompt, options); },
 
     /**
      * Does what the person asks, in their own words, with the app's own reads and writes: the model picks calls,
-     * the page runs them, the model sees what happened, until it replies (at most 4 model calls and 6 writes a turn,
-     * with no time limit unless the app sets one with `limits: { seconds }`; Cancel ends it at once). Check `LampAI.isAvailable('act')` first; keep the app's buttons for everything.
+     * the page runs them, the model sees what happened, until it replies; Cancel ends it at once. Check
+     * `LampAI.isAvailable('act')` first; keep the app's buttons for everything. A turn takes at most 4 model calls
+     * and 6 writes and has no time limit; `limits` changes that for an app that needs it: `steps` (up to 40) and
+     * `writes` (up to 320) for one that builds something real in a turn, many changes at a time, `seconds` for a
+     * feature that should answer quickly, and `result` (bytes, 32 KB unless raised, up to 256 KB) for how much of a
+     * read the model sees. A limit that isn't a positive number keeps its default. `model` names which AI answers,
+     * as `ask`'s does; the whole turn stays on it.
      *
      *     var turn = LampAI.act('Add milk', {
      *       about: 'A family dashboard: the calendar, chores and the shopping list.',
@@ -862,6 +927,8 @@
      *                       run: function (args, call) { return add(args, call.key); } }
      *       },
      *       history: [{ said: 'Who did it?', heard: 'Maya' }],             // the last 3 exchanges, kept by the app
+     *       limits: { steps: 20, writes: 200 },                            // optional: see above
+     *       model: picker.value,                                           // optional: an id from LampAI.models()
      *       onStep: function (s) { … }                                     // { kind, name, args[, result] }
      *     });
      *     turn.result.then(function (r) { r.reply; r.ask; r.choices; r.done; r.failed; r.skipped; r.stopped; });

package/cli/local-ai.mjs

@@ -7,7 +7,7 @@
 // the request and a page can't change, so an approval is for one link's page: the first time it asks, the person is
 // asked in the terminal, and the page is given a token it keeps and sends from then on. Nothing else is answered:
 // another site, another link's page, or a request naming this computer by another name (a site that rebinds its own
-// name to 127.0.0.1) is refused. Whether there's an AI here (`/ai/status` and the probes) is answered without one, so a
+// name to 127.0.0.1) is refused. Whether there's an AI here (`/ai/status`, `/ai/models` and the probes) is answered without one, so a
 // page can say what it can do before anyone is asked.
 
 import { createServer } from "node:http";
@@ -22,7 +22,7 @@ import { answer as answerAI, engine } from "./ai.mjs";
 export const LOCAL_AI_PORT = 47423;
 const PLAY_HOST = "play.lamp.dev";
 const MOST = 4_000_000, AT_ONCE = 3, ASKING_FOR = 120_000;
-const ROUTES = new Set(["/ai/status", "/ai", "/ai/act", "/ai/decide", "/ai/hear", "/ai/image"]);
+const ROUTES = new Set(["/ai/status", "/ai/models", "/ai", "/ai/act", "/ai/decide", "/ai/hear", "/ai/image"]);
 
 const keptFile = () => join(process.env.LAMP_DEV_HOME || join(homedir(), ".lamp", "dev"), "shared-pages-ai.json");
 
@@ -153,9 +153,10 @@ export async function serveLocalAI({ port = LOCAL_AI_PORT, ask = askInTerminal()
     }
     if (!ROUTES.has(url.pathname)) return reply(404, { error: "Not found." });
     // What there is to answer with, asked before anyone is let in: only the routes whose probe asks no model.
-    const asksNothing = url.pathname === "/ai/status" || (body?.probe === true && (url.pathname === "/ai/act" || url.pathname === "/ai/hear"));
+    const listing = url.pathname === "/ai/status" || url.pathname === "/ai/models";
+    const asksNothing = listing || (body?.probe === true && (url.pathname === "/ai/act" || url.pathname === "/ai/hear"));
     if (asksNothing) {
-      const [status, answered] = await answer(url.pathname, url.pathname === "/ai/status" ? {} : { probe: true }, { id });
+      const [status, answered] = await answer(url.pathname, listing ? {} : { probe: true }, { id });
       return reply(status, answered);
     }
     const kept = allowed()[origin];

package/package.json

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