@lampdotdev/lamp 0.36.2-nightly.43 → 0.36.2-nightly.44

package/cli/ai.mjs

@@ -9,8 +9,8 @@ import { accessSync, closeSync, constants, fstatSync, mkdtempSync, openSync, rea
 import { tmpdir } from "node:os";
 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, IMAGE_MODELS, OpenRouterTrouble, chat as openRouterChat, image as openRouterImage, text as openRouterText } from "./openrouter.mjs";
+import { afterStream, chatBody, decidePrompt, planPrompt, planSchema, readDecision, readMessage, readPlan, readStep, stepReader } from "./app-ai.mjs";
+import { DEFAULT_MODEL, IMAGE_MODELS, OpenRouterTrouble, chat as openRouterChat, chatStream as openRouterChatStream, image as openRouterImage, text as openRouterText } from "./openrouter.mjs";
 
 
 /**
@@ -57,9 +57,10 @@ export class EngineTrouble extends Error {
  * request itself: to Claude Code in its input, to Codex as attachments, never through a tool that reads files.
  * Lamp's app runs it this way too (`engineAnswer` in calls.mjs, `AppAI.viaEngine`), naming the program (`tool`) and
  * what it needs set (`env`); on its own lamp finds the person's own on the PATH. `spent` hears what a call through
- * OpenRouter cost; one through the person's own sign-in costs nothing through Lamp.
+ * OpenRouter cost; one through the person's own sign-in costs nothing through Lamp. `onPartial` hears the answer to a
+ * `schema` as it's written, the JSON so far, where the engine says it as it goes (Claude Code; Codex says it at the end).
  */
-export function complete({ system, prompt, schema, seconds = 60, which = engine(), tool, env = {}, model = process.env.LAMP_AI_MODEL || "", images = [], signal, spent } = {}) {
+export function complete({ system, prompt, schema, seconds = 60, which = engine(), tool, env = {}, model = process.env.LAMP_AI_MODEL || "", images = [], signal, spent, onPartial } = {}) {
   if (which === "openrouter") return viaOpenRouter({ system, prompt, schema, seconds, model, images, signal, spent });
   if (which !== "claude" && which !== "codex") return Promise.reject(new EngineTrouble("missing", missing));
   const folder = mkdtempSync(join(tmpdir(), "lamp-ai-"));
@@ -73,6 +74,7 @@ export function complete({ system, prompt, schema, seconds = 60, which = engine(
       "--strict-mcp-config", "--disable-slash-commands", "--tools", "", "--system-prompt", sayer];
     if (model) args.push("--model", model);
     if (schema) args.push("--json-schema", JSON.stringify(schema));
+    if (schema && onPartial) args.push("--include-partial-messages");
     if (pictures.length) {
       args.push("--input-format", "stream-json");
       const content = [{ type: "text", text: prompt }, ...pictures.map((image) => ({ type: "image",
@@ -105,7 +107,7 @@ export function complete({ system, prompt, schema, seconds = 60, which = engine(
   delete childEnv.BUN_BE_BUN;
   return new Promise((resolve, reject) => {
     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 = "";
+    let text = "", trouble = null, rest = "", said = "", partial = "";
     // 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"); } };
     const timer = setTimeout(() => stop("timeout", `${named(which)} took too long to answer.`), Math.max(1, seconds) * 1000);
@@ -119,6 +121,16 @@ export function complete({ system, prompt, schema, seconds = 60, which = engine(
         else if (codexFailure(event)) trouble ??= new EngineTrouble("failed", codexFailure(event));
         return;
       }
+      // The schema's answer as it's written: its JSON, a piece at a time.
+      if (event.type === "stream_event" && onPartial) {
+        const inner = event.event ?? {};
+        if (inner.type === "content_block_start") partial = "";
+        else if (inner.type === "content_block_delta" && inner.delta?.type === "input_json_delta" && typeof inner.delta.partial_json === "string") {
+          partial += inner.delta.partial_json;
+          try { onPartial(partial); } catch {}
+        }
+        return;
+      }
       if (event.type !== "result") return;
       if (event.is_error) trouble ??= new EngineTrouble("failed", String(event.result || "Claude Code couldn't answer."));
       else if (schema && event.structured_output !== undefined) text = JSON.stringify(event.structured_output);
@@ -366,8 +378,29 @@ 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). */
+// A step being streamed (`stream` on lamp.js's act), by its id: its calls so far, and its answer once it's done. The page
+// asks for what's new (`follow`) until it has the answer; a step nobody follows for a few minutes is let go.
+const live = new Map();
+const FOLLOW_WAIT = 50_000;
+
+/** What a streamed step has that the page hasn't (`have` calls): waits for something new, or the end, a while at most. */
+async function following(id, have) {
+  const step = live.get(id);
+  if (!step) return [404, { error: "This step is over." }];
+  step.seen = Date.now();
+  if (step.calls.length <= have && !step.done) {
+    await new Promise((woken) => { const timer = setTimeout(woken, FOLLOW_WAIT); step.waiting.add(() => { clearTimeout(timer); woken(); }); });
+  }
+  const calls = step.calls.slice(have);
+  if (!step.done) return [200, { stream: id, more: true, calls }];
+  live.delete(id);
+  const [status, json] = step.done;
+  return [status, { ...json, stream: id, more: false, calls: [...calls, ...(Array.isArray(json.calls) ? json.calls : [])] }];
+}
+
 export async function act(body, here = engines()) {
   const first = here[0] ?? null;
+  if (typeof body?.follow === "string") return following(body.follow, Math.max(0, Math.floor(Number(body.have)) || 0));
   if (body?.probe === true) {
     // A key OpenRouter refuses can't answer a step, as `/ai/status` says too.
     const refused = first === "openrouter" ? await keyProblem() : null;
@@ -382,21 +415,44 @@ export async function act(body, here = engines()) {
   const seconds = 600;
   const deadline = Date.now() + Math.min(r.seconds, seconds) * 1000;
   const tag = "outside-text-" + randomBytes(4).toString("hex");
+  // Streamed: each call goes to the page as soon as it's whole, and the page follows the step for the rest.
+  if (body?.stream === true) {
+    const id = "st" + randomBytes(6).toString("hex");
+    const step = { calls: [], done: null, waiting: new Set(), seen: Date.now() };
+    const wake = () => { for (const woken of step.waiting) woken(); step.waiting.clear(); };
+    live.set(id, step);
+    for (const [other, kept] of live) if (Date.now() - kept.seen > 5 * 60_000) live.delete(other);
+    runStep(r, { which, model, tag, deadline, seconds, release: (call) => { step.calls.push(call); wake(); } })
+      .then((done) => { step.done = done; wake(); });
+    return following(id, 0);
+  }
+  return runStep(r, { which, model, tag, deadline, seconds });
+}
+
+/** A step asked of its route, asked again once when its answer can't be used: [status, json]. With `release`, calls go
+ *  out as they're written, and once one has gone the answer isn't asked again. */
+async function runStep(r, { which, model, tag, deadline, seconds, release }) {
   let retry = null, cost = 0;
   for (let attempt = 0; attempt < 2; attempt++) {
     const left = (deadline - Date.now()) / 1000;
     if (left < 1) return [504, { error: "This step ran out of time.", cost }];
     let read;
+    const reader = release ? stepReader(r, release) : null;
     try {
       if (which === "openrouter") {
         const body = chatBody(r, tag, retry, model);
-        const answered = await openRouterChat({ key: process.env.OPENROUTER_API_KEY, body, seconds: left });
+        const answered = reader
+          ? await openRouterChatStream({ key: process.env.OPENROUTER_API_KEY, body, seconds: left, onCall: (name, args) => reader.call(name, args) })
+          : await openRouterChat({ key: process.env.OPENROUTER_API_KEY, body, seconds: left });
         cost += answered.cost;
         read = readMessage(answered.message, r);
       } else {
         const { system, prompt, images } = planPrompt(r, tag, retry);
-        read = readPlan(await complete({ system, prompt, images, schema: planSchema(r), seconds: left, which, model }), r);
+        const text = await complete({ system, prompt, images, schema: planSchema(r), seconds: left, which, model, onPartial: reader ? (so) => reader.planned(so) : undefined });
+        reader?.planned(text);
+        read = readPlan(text, r);
       }
+      if (reader) read = afterStream(reader, read);
     } catch (error) {
       cost += Number(error?.cost) || 0;
       const words = error instanceof OpenRouterTrouble && error.kind === "refused" ? openRouterWords(error) : error?.reply?.error?.message || error.message;

package/cli/app-ai.mjs

@@ -315,12 +315,102 @@ export function readPlan(text, r) {
   return readMessage({ tool_calls: [{ function: { name: REPLY, arguments: JSON.stringify(args) } }] }, r);
 }
 
+// MARK: Calls as they're written
+
+/**
+ * The calls finished so far in an answer in `planSchema`'s shape that's still being written: each element of its `calls`
+ * whose closing brace has come, parsed, in order. What's after them (an element half written, the reply) waits.
+ */
+export function plannedCalls(text) {
+  const found = [];
+  const key = text.search(/"calls"\s*:\s*\[/);
+  if (key < 0) return found;
+  let i = text.indexOf("[", key) + 1, depth = 0, start = -1, inString = false, escaped = false;
+  for (; i < text.length; i++) {
+    const c = text[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (c === "\\") escaped = true;
+      else if (c === '"') inString = false;
+      continue;
+    }
+    if (c === '"') inString = true;
+    else if (c === "{" || c === "[") { if (depth === 0) start = i; depth++; }
+    else if (c === "}" || c === "]") {
+      if (depth === 0) break;
+      depth--;
+      if (depth === 0 && start >= 0) {
+        try { found.push(JSON.parse(text.slice(start, i + 1))); } catch { break; }
+        start = -1;
+      }
+    }
+  }
+  return found;
+}
+
+/**
+ * Reads a step's calls one at a time as the model writes them (`stream` on `LampAI.act`), with the checks `readMessage`
+ * gives a whole answer: `release` gets each call that fits as soon as it's whole, with the id it would have had. One that
+ * doesn't fit is held, with why (`problem`), until one that fits comes after it, which it goes before, in its place, as
+ * a call that failed: the page never runs it, and a change that failed stops the changes after it. One left held at the
+ * end goes last when calls were released (`afterStream`), or, when none was, the whole answer is read and asked again
+ * as before. Calls past `MAX_CALLS` are left out.
+ */
+export function stepReader(r, release) {
+  const step = r.steps.length + 1;
+  let given = 0, seen = 0;
+  const reader = {
+    released: 0,
+    held: [],
+    /** One whole call, `args` its arguments as an object or as the JSON text the model wrote. */
+    call(name, raw) {
+      if (name === REPLY) return;
+      const id = `s${step}c${++given}`;
+      let args = raw;
+      if (typeof raw === "string") { try { args = JSON.parse(raw || "{}"); } catch { args = undefined; } }
+      const hold = (problem) => reader.held.push({ id, name: String(name), args: args && typeof args === "object" && !Array.isArray(args) ? args : {}, problem });
+      // Past the most a step holds, a call is left out: the AI sees what ran, and writes the rest next.
+      if (given > MAX_CALLS) return;
+      if (typeof name !== "string") return hold("A call had no name.");
+      if (!args || typeof args !== "object" || Array.isArray(args)) return hold(`${name}'s arguments weren't a JSON object.`);
+      if (r.final) return hold("Only `reply` is possible now.");
+      const tool = r.tools.find((t) => t.name === name);
+      if (!tool) return hold(`There's no tool called ${name}.`);
+      const bad = toolProblem(tool, args);
+      if (bad) return hold(bad);
+      reader.released++;
+      for (const held of reader.held.splice(0)) release(held);
+      release({ id, name, args });
+    },
+    /** The answer in `planSchema`'s shape as written so far: calls finished since last time are read. An optional
+     *  argument left null is left out, as `readPlan` leaves it. */
+    planned(text) {
+      const found = plannedCalls(text);
+      for (const call of found.slice(seen)) {
+        const args = call?.args && typeof call.args === "object" && !Array.isArray(call.args) ? Object.fromEntries(Object.entries(call.args).filter(([, v]) => v !== null)) : call?.args;
+        reader.call(call?.name, args);
+      }
+      seen = found.length;
+    },
+  };
+  return reader;
+}
+
+/**
+ * A streamed step's answer once the model is done: when calls were released, only what's left (the calls that didn't
+ * fit, as failures); else the whole answer read as before (`read`, from `readMessage` or `readPlan`).
+ */
+export function afterStream(reader, read) {
+  if (!reader.released) return read;
+  return { answer: { calls: reader.held.map((c) => ({ id: c.id, name: c.name, args: c.args, problem: c.problem })) } };
+}
+
 // MARK: What the model is told
 
 const RULES = `You act for the person inside this app, only through its tools.
 - Use a tool to look something up before acting on it, and use ids exactly as the tools gave them. Never invent an id.
 - Change only what the person asked for. When the request is unclear (which one, who, what day or time), ask back in the reply instead of guessing.
-- Several look-ups can go in one answer. Changes run one after another, each checked right before it runs; a change that fails stops the ones after it in that answer.
+- Several calls can go in one answer, and they run in the order you write them: look-ups side by side run together, changes run one after another, each checked right before it runs, and a change that fails stops the changes after it in that answer. A look-up after a change sees it.
 - Never say something was done unless its result says it was. If something failed or was skipped, say so.
 - When the request is met, or you need to ask, finish with \`reply\`: one or two short sentences that can be spoken aloud, no lists, no emoji, no markdown. Set \`ask\` to true only when the reply is a question for the person.
 - When your question has a few short answers (yes or no, which of two or three), give them in \`choices\`: two to four, each a word or a few, plain text, in the order to offer them. Leave \`choices\` out when any answer could do.`;

package/cli/calls.mjs

@@ -32,7 +32,7 @@ import { tile } from "./png.mjs";
 import { Problem } from "./state.mjs";
 import { allowed as pagesAllowed, forgetPage, serveLocalAI } from "./local-ai.mjs";
 import { EngineTrouble, complete } from "./ai.mjs";
-import { OpenRouterTrouble, chat as openRouterChat, decide as openRouterDecide, image as openRouterImage, text as openRouterText } from "./openrouter.mjs";
+import { OpenRouterTrouble, chat as openRouterChat, chatStream as openRouterChatStream, decide as openRouterDecide, image as openRouterImage, text as openRouterText } from "./openrouter.mjs";
 
 /** OpenRouter's answer, or what kept it from one, as Lamp's app reads it. */
 async function openRouter(asking) {
@@ -41,7 +41,7 @@ async function openRouter(asking) {
     return { trouble: { kind: error.kind, message: error.message, status: error.status, reply: error.reply, cost: error.cost } };
   }
 }
-import { Refused as StepRefused, chatBody, decidePrompt, planPrompt, planSchema, readDecision, readMessage, readPlan, readStep } from "./app-ai.mjs";
+import { Refused as StepRefused, afterStream, chatBody, decidePrompt, planPrompt, planSchema, readDecision, readMessage, readPlan, readStep, stepReader } from "./app-ai.mjs";
 
 // Pages shared on lamp.dev asking for their AI, answered by Lamp's app (`sharedPages`): what each is waiting on from it.
 const sharedPagesWaiting = new Map();
@@ -383,9 +383,17 @@ export const CALLS = {
       model: text(given, "model"), json: given.json === true, schema: given.schema ?? undefined, seconds: seconds(given.seconds, 600, 600), signal: stopped }));
   },
 
-  /** One chat completion from OpenRouter, its request as `body` (`actAsk`'s): `{message, cost}`, or `{trouble}`. */
-  async openRouterChat(given, { stopped } = {}) {
-    return openRouter(() => openRouterChat({ key: text(given, "key"), body: given.body ?? {}, seconds: seconds(given.seconds, 60, 600), signal: stopped }));
+  /**
+   * One chat completion from OpenRouter, its request as `body` (`actAsk`'s): `{message, cost}`, or `{trouble}`. With the
+   * act `step` it's for, streamed: each call that fits is an event `{call}` as soon as it's whole, and the answer says
+   * what was `released` and what was `held` (`stepReader`), for `actRead`.
+   */
+  async openRouterChat(given, { stopped, event = () => {} } = {}) {
+    const asked = { key: text(given, "key"), body: given.body ?? {}, seconds: seconds(given.seconds, 60, 600), signal: stopped };
+    if (!given.step) return openRouter(() => openRouterChat(asked));
+    const reader = stepReader(given.step, (call) => event({ call }));
+    const done = await openRouter(() => openRouterChatStream({ ...asked, onCall: (name, args) => reader.call(name, args) }));
+    return done.trouble ? { ...done, released: reader.released } : { ...done, released: reader.released, held: reader.held };
   },
 
   /** Decisions from OpenRouter's decision model (`AppAI.decide`): `key`, `model`, `state`, `questions`. `{answers, cost}` or `{trouble}`. */
@@ -405,14 +413,19 @@ export const CALLS = {
    * the program Lamp chose (`tool`) and what it needs set (`env`), `system`, `prompt`, optional `schema`, `model`,
    * `images` and `seconds`. `{text}`, or `{trouble: {kind, message}}`; stopping the call stops the engine.
    */
-  async engineAnswer(given, { stopped } = {}) {
+  async engineAnswer(given, { stopped, event = () => {} } = {}) {
+    // With the act `step` it answers, streamed as `openRouterChat` streams it.
+    const reader = given.step ? stepReader(given.step, (call) => event({ call })) : null;
     try {
-      return { text: await complete({ which: text(given, "engine"), tool: typeof given.tool === "string" && given.tool ? given.tool : undefined,
+      const answer = await complete({ which: text(given, "engine"), tool: typeof given.tool === "string" && given.tool ? given.tool : undefined,
         env: given.env && typeof given.env === "object" ? given.env : {}, system: typeof given.system === "string" ? given.system : "",
         prompt: text(given, "prompt"), schema: given.schema ?? undefined, model: typeof given.model === "string" ? given.model : "",
-        images: Array.isArray(given.images) ? given.images : [], seconds: seconds(given.seconds, 600, 600), signal: stopped }) };
+        images: Array.isArray(given.images) ? given.images : [], seconds: seconds(given.seconds, 600, 600), signal: stopped,
+        onPartial: reader ? (so) => reader.planned(so) : undefined });
+      reader?.planned(answer);
+      return reader ? { text: answer, released: reader.released, held: reader.held } : { text: answer };
     } catch (error) {
-      if (error instanceof EngineTrouble) return { trouble: { kind: error.kind, message: error.message } };
+      if (error instanceof EngineTrouble) return { trouble: { kind: error.kind, message: error.message }, ...(reader ? { released: reader.released } : {}) };
       throw error;
     }
   },
@@ -438,9 +451,12 @@ export const CALLS = {
     return { ...planPrompt(step, tag, retry), schema: planSchema(step) };
   },
 
-  /** A step's answer read and checked: `message` from a chat with tools, or `plan`'s text. `{answer}` or `{problem}`. */
+  /** A step's answer read and checked: `message` from a chat with tools, or `plan`'s text. `{answer}` or `{problem}`; for a
+   *  streamed one, with what was `released` and `held`, only the held calls, as failures. */
   async actRead(given) {
-    return given.message !== undefined ? readMessage(given.message, given.step) : readPlan(String(given.plan ?? ""), given.step);
+    const read = given.message !== undefined ? readMessage(given.message, given.step) : readPlan(String(given.plan ?? ""), given.step);
+    // A streamed answer (`released` calls went out already): only what was held is left.
+    return Number(given.released) > 0 ? afterStream({ released: Number(given.released), held: Array.isArray(given.held) ? given.held : [] }, read) : read;
   },
 
   /** A decision asked of a text model: `{system, prompt, schema}`. */

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

@@ -711,17 +711,20 @@
 
     // Reads run together; then the writes, one after another, each checked right before it runs. A write that
     // fails stops the writes after it in this step, which the model hears were skipped.
-    function runCalls(calls, step) {
-      var results = {}, reads = [], changes = [];
-      calls.forEach(function (c) { (tools[c.name] && tools[c.name].reads ? reads : changes).push(c); });
-      return Promise.all(reads.map(function (c) {
+    // A step's calls, run as they come (`stream`) and in the order the AI wrote them: reads side by side run together,
+    // a write waits for every call before it, and a read after a write sees it. A write that fails skips the writes
+    // after it in the step. A call Lamp held back as not fitting (`problem`) isn't run: the AI hears why, and a change of
+    // that kind fails in its place.
+    function stepRunner(step) {
+      var results = {}, chain = Promise.resolve(), reading = [], stopped = null;
+      function read(c) {
         if (late()) return null;
         var tool = tools[c.name], bad = actProblem(tool, c.name, c.args);
         if (bad) { results[c.id] = { id: c.id, ok: false, error: bad }; return null; }
         tell({ kind: 'read', name: c.name, args: c.args });
         var NOT_RUN = {};
         return Promise.resolve().then(function () {
-          // Reads start together, but each one only while there's time: an earlier one can be slow.
+          // Each read starts only while there's time: an earlier one can be slow.
           return late() ? NOT_RUN : tool.run(c.args, { turn: id, step: step, id: c.id });
         }).then(function (value) {
           if (value === NOT_RUN) return;
@@ -731,60 +734,69 @@
             if (p.pictures) results[c.id].pictures = p.pictures;
           });
         }, function (e) { results[c.id] = { id: c.id, ok: false, error: refused(e) }; });
-      })).then(function () {
-        var stopped = null;
-        function next(i) {
-          if (i >= changes.length) return results;
-          var c = changes[i], tool = tools[c.name];
-          function skip(reason) {
-            out.skipped.push({ name: c.name, args: c.args, reason: reason });
-            results[c.id] = { id: c.id, ok: false, skipped: reason };
-            return next(i + 1);
-          }
-          function fail(reason) {
-            out.failed.push({ name: c.name, args: c.args, reason: reason });
-            results[c.id] = { id: c.id, ok: false, error: reason };
-            stopped = stopped || 'An earlier change in this step didn\'t go through.';
-            return next(i + 1);
-          }
-          if (late()) return results;
-          if (stopped) return skip(stopped);
-          var bad = actProblem(tool, c.name, c.args);
-          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.
-          // 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) {
-            if (problem) return fail(String(problem));
-            // Cancel and the time are looked at again right before the change, never in the middle of it.
-            if (late()) return results;
-            tell({ kind: 'write', name: c.name, args: c.args });
-            if (late()) return results;
-            writes++;
-            var running;
-            try { running = Promise.resolve(tool.run(c.args, call)); } catch (e) { running = Promise.reject(e); }
-            return running.then(function (value) {
-              // The change is done: it's recorded now, whatever happens to its pictures after.
-              ran[key] = { note: 'Done.' };
-              var entry = { name: c.name, args: c.args, result: value };
-              if (value && typeof value === 'object' && value.partly) entry.partly = String(value.partly);
-              out.done.push(entry);
-              tell({ kind: 'write', name: c.name, args: c.args, result: value });
-              return pictured(value).then(function (p) { return { p: p }; });
-            }).then(function (got) {
-              var kept = sized(got.p.value);
+      }
+      function write(c) {
+        var tool = tools[c.name];
+        function skip(reason) {
+          out.skipped.push({ name: c.name, args: c.args, reason: reason });
+          results[c.id] = { id: c.id, ok: false, skipped: reason };
+        }
+        function fail(reason) {
+          out.failed.push({ name: c.name, args: c.args, reason: reason });
+          results[c.id] = { id: c.id, ok: false, error: reason };
+          stopped = stopped || 'An earlier change in this step didn\'t go through.';
+        }
+        if (late()) return;
+        if (stopped) return skip(stopped);
+        // A change Lamp held back as not fitting failed, in its place.
+        if (typeof c.problem === 'string') return fail(c.problem);
+        var bad = actProblem(tool, c.name, c.args);
+        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.
+        // 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; }
+        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) {
+          if (problem) return fail(String(problem));
+          // Cancel and the time are looked at again right before the change, never in the middle of it.
+          if (late()) return;
+          tell({ kind: 'write', name: c.name, args: c.args });
+          if (late()) return;
+          writes++;
+          var running;
+          try { running = Promise.resolve(tool.run(c.args, call)); } catch (e) { running = Promise.reject(e); }
+          return running.then(function (value) {
+            // The change is done: it's recorded now, whatever happens to its pictures after.
+            ran[key] = { note: 'Done.' };
+            var entry = { name: c.name, args: c.args, result: value };
+            if (value && typeof value === 'object' && value.partly) entry.partly = String(value.partly);
+            out.done.push(entry);
+            tell({ kind: 'write', name: c.name, args: c.args, result: value });
+            return pictured(value).then(function (p) {
+              var kept = sized(p.value);
               ran[key] = kept;
               results[c.id] = { id: c.id, ok: true, value: kept };
-              if (got.p.pictures) results[c.id].pictures = got.p.pictures;
-              return next(i + 1);
-            }, function (e) { return fail(refused(e)); });
-          }, function (e) { return fail(refused(e)); });
-        }
-        return next(0);
-      });
+              if (p.pictures) results[c.id].pictures = p.pictures;
+            });
+          }, function (e) { fail(refused(e)); });
+        }, function (e) { fail(refused(e)); });
+      }
+      return {
+        add: function (c) {
+          if (typeof c.problem === 'string' && tools[c.name] && tools[c.name].reads) { results[c.id] = { id: c.id, ok: false, error: c.problem }; return; }
+          if (tools[c.name] && tools[c.name].reads) {
+            var going = chain.then(function () { return read(c); });
+            reading.push(going);
+          } else {
+            var before = [chain].concat(reading);
+            reading = [];
+            chain = Promise.all(before).then(function () { return write(c); });
+          }
+        },
+        finish: function () { return Promise.all([chain].concat(reading)).then(function () { return results; }); }
+      };
     }
 
     function step() {
@@ -799,19 +811,29 @@
       if (route) body.route = route;
       if (steps.length >= limits.steps - 1) body.final = true;
       if (o.model) body.model = o.model;
-      post('/ai/act', body, stepTime, Date.now() + stepTime).then(function (answer) {
+      // Streamed: each call comes as soon as the AI has written it, and runs then; the page follows the step for the
+      // rest. A Lamp from before streaming answers the whole step at once, which runs the same way.
+      body.stream = true;
+      var n = steps.length + 1, calls = [], ids = {}, runner = stepRunner(n), until = Date.now() + stepTime;
+      function heard(answer) {
         // What the step cost through a key, paid for whether or not its answer still runs.
         if (typeof answer.cost === 'number' && answer.cost > 0) out.cost += answer.cost;
         // Cancelled, out of time or already over: an answer that comes late runs nothing.
         if (late()) return;
         route = answer.route || route;
-        if (answer.calls && answer.calls.length) {
-          var calls = answer.calls, n = steps.length + 1, ids = {};
-          for (var i = 0; i < calls.length; i++) {
-            if (ids[calls[i].id]) return stop('error', 'The AI gave two calls the same id.');
-            ids[calls[i].id] = true;
-          }
-          return runCalls(calls, n).then(function (results) {
+        var given = answer.calls || [];
+        for (var i = 0; i < given.length; i++) {
+          if (ids[given[i].id]) return stop('error', 'The AI gave two calls the same id.');
+          ids[given[i].id] = true;
+          calls.push(given[i]);
+          runner.add(given[i]);
+        }
+        if (answer.more === true && typeof answer.stream === 'string') {
+          var have = calls.length;
+          return post('/ai/act', { follow: answer.stream, have: have }, Math.max(1000, until - Date.now()), until).then(heard, failed);
+        }
+        if (calls.length) {
+          return runner.finish().then(function (results) {
             if (late()) return;
             steps.push({ calls: calls, results: calls.map(function (c) { return results[c.id] || { id: c.id, ok: false, skipped: 'Not run.' }; }) });
             if (steps.length >= limits.steps) return stop('steps');
@@ -826,11 +848,13 @@
           return typeof c === 'string' && c.trim() && c.length <= 24 && !/[<>*_`#\[\]{}|\\\n\r\t]/.test(c);
         }) ? offered.map(function (c) { return c.trim(); }) : [];
         stop(null);
-      }, function (e) {
+      }
+      function failed(e) {
         if (e && typeof e.cost === 'number' && e.cost > 0) out.cost += e.cost;
         var message = refused(e);
         stop(/reach Lamp|Lamp isn't|wasn't put here|put it on this device/.test(message) ? 'unreachable' : 'error', message);
-      });
+      }
+      post('/ai/act', body, stepTime, until).then(heard, failed);
     }
     step();
     return { id: id, result: result, cancel: function () { stop('cancelled'); } };
@@ -1065,10 +1089,12 @@
      *     turn.cancel();
      *
      * An argument's shape is { type: 'string' | 'integer' | 'number' | 'boolean' | 'date' | 'datetime' | 'list',
-     * oneOf: [strings], min, max, optional, about, of (a list's item) }. A tool with `reads: true` changes nothing;
-     * reads in one step run together. Writes run one after another, each with its `check` right before it: a write
-     * that fails stops the writes after it in that step (`skipped`). Cancel and the time stop the turn between
-     * calls, never in the middle of a write; an answer that comes after runs nothing.
+     * oneOf: [strings], min, max, optional, about, of (a list's item) }. A tool with `reads: true` changes nothing.
+     * Each call runs as soon as the AI has written it, before the rest of its answer has come, so a build shows as
+     * it's made; calls run in the order the AI wrote them. Reads side by side run together; a write waits for the
+     * calls before it, with its `check` right before it, and a read after it sees it. A write that fails stops the
+     * writes after it in that step (`skipped`). Cancel and the time stop the turn between calls, never in the middle
+     * of a write; an answer that comes after runs nothing.
      *
      * Say what happened from `done`, `failed` and `skipped`, never from `reply`: they're what the page ran. A question
      * back (`ask`) may come with `choices`, two to four short answers to offer as buttons; with none, any answer goes.

package/cli/lamps/lamp.js

@@ -711,17 +711,20 @@
 
     // Reads run together; then the writes, one after another, each checked right before it runs. A write that
     // fails stops the writes after it in this step, which the model hears were skipped.
-    function runCalls(calls, step) {
-      var results = {}, reads = [], changes = [];
-      calls.forEach(function (c) { (tools[c.name] && tools[c.name].reads ? reads : changes).push(c); });
-      return Promise.all(reads.map(function (c) {
+    // A step's calls, run as they come (`stream`) and in the order the AI wrote them: reads side by side run together,
+    // a write waits for every call before it, and a read after a write sees it. A write that fails skips the writes
+    // after it in the step. A call Lamp held back as not fitting (`problem`) isn't run: the AI hears why, and a change of
+    // that kind fails in its place.
+    function stepRunner(step) {
+      var results = {}, chain = Promise.resolve(), reading = [], stopped = null;
+      function read(c) {
         if (late()) return null;
         var tool = tools[c.name], bad = actProblem(tool, c.name, c.args);
         if (bad) { results[c.id] = { id: c.id, ok: false, error: bad }; return null; }
         tell({ kind: 'read', name: c.name, args: c.args });
         var NOT_RUN = {};
         return Promise.resolve().then(function () {
-          // Reads start together, but each one only while there's time: an earlier one can be slow.
+          // Each read starts only while there's time: an earlier one can be slow.
           return late() ? NOT_RUN : tool.run(c.args, { turn: id, step: step, id: c.id });
         }).then(function (value) {
           if (value === NOT_RUN) return;
@@ -731,60 +734,69 @@
             if (p.pictures) results[c.id].pictures = p.pictures;
           });
         }, function (e) { results[c.id] = { id: c.id, ok: false, error: refused(e) }; });
-      })).then(function () {
-        var stopped = null;
-        function next(i) {
-          if (i >= changes.length) return results;
-          var c = changes[i], tool = tools[c.name];
-          function skip(reason) {
-            out.skipped.push({ name: c.name, args: c.args, reason: reason });
-            results[c.id] = { id: c.id, ok: false, skipped: reason };
-            return next(i + 1);
-          }
-          function fail(reason) {
-            out.failed.push({ name: c.name, args: c.args, reason: reason });
-            results[c.id] = { id: c.id, ok: false, error: reason };
-            stopped = stopped || 'An earlier change in this step didn\'t go through.';
-            return next(i + 1);
-          }
-          if (late()) return results;
-          if (stopped) return skip(stopped);
-          var bad = actProblem(tool, c.name, c.args);
-          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.
-          // 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) {
-            if (problem) return fail(String(problem));
-            // Cancel and the time are looked at again right before the change, never in the middle of it.
-            if (late()) return results;
-            tell({ kind: 'write', name: c.name, args: c.args });
-            if (late()) return results;
-            writes++;
-            var running;
-            try { running = Promise.resolve(tool.run(c.args, call)); } catch (e) { running = Promise.reject(e); }
-            return running.then(function (value) {
-              // The change is done: it's recorded now, whatever happens to its pictures after.
-              ran[key] = { note: 'Done.' };
-              var entry = { name: c.name, args: c.args, result: value };
-              if (value && typeof value === 'object' && value.partly) entry.partly = String(value.partly);
-              out.done.push(entry);
-              tell({ kind: 'write', name: c.name, args: c.args, result: value });
-              return pictured(value).then(function (p) { return { p: p }; });
-            }).then(function (got) {
-              var kept = sized(got.p.value);
+      }
+      function write(c) {
+        var tool = tools[c.name];
+        function skip(reason) {
+          out.skipped.push({ name: c.name, args: c.args, reason: reason });
+          results[c.id] = { id: c.id, ok: false, skipped: reason };
+        }
+        function fail(reason) {
+          out.failed.push({ name: c.name, args: c.args, reason: reason });
+          results[c.id] = { id: c.id, ok: false, error: reason };
+          stopped = stopped || 'An earlier change in this step didn\'t go through.';
+        }
+        if (late()) return;
+        if (stopped) return skip(stopped);
+        // A change Lamp held back as not fitting failed, in its place.
+        if (typeof c.problem === 'string') return fail(c.problem);
+        var bad = actProblem(tool, c.name, c.args);
+        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.
+        // 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; }
+        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) {
+          if (problem) return fail(String(problem));
+          // Cancel and the time are looked at again right before the change, never in the middle of it.
+          if (late()) return;
+          tell({ kind: 'write', name: c.name, args: c.args });
+          if (late()) return;
+          writes++;
+          var running;
+          try { running = Promise.resolve(tool.run(c.args, call)); } catch (e) { running = Promise.reject(e); }
+          return running.then(function (value) {
+            // The change is done: it's recorded now, whatever happens to its pictures after.
+            ran[key] = { note: 'Done.' };
+            var entry = { name: c.name, args: c.args, result: value };
+            if (value && typeof value === 'object' && value.partly) entry.partly = String(value.partly);
+            out.done.push(entry);
+            tell({ kind: 'write', name: c.name, args: c.args, result: value });
+            return pictured(value).then(function (p) {
+              var kept = sized(p.value);
               ran[key] = kept;
               results[c.id] = { id: c.id, ok: true, value: kept };
-              if (got.p.pictures) results[c.id].pictures = got.p.pictures;
-              return next(i + 1);
-            }, function (e) { return fail(refused(e)); });
-          }, function (e) { return fail(refused(e)); });
-        }
-        return next(0);
-      });
+              if (p.pictures) results[c.id].pictures = p.pictures;
+            });
+          }, function (e) { fail(refused(e)); });
+        }, function (e) { fail(refused(e)); });
+      }
+      return {
+        add: function (c) {
+          if (typeof c.problem === 'string' && tools[c.name] && tools[c.name].reads) { results[c.id] = { id: c.id, ok: false, error: c.problem }; return; }
+          if (tools[c.name] && tools[c.name].reads) {
+            var going = chain.then(function () { return read(c); });
+            reading.push(going);
+          } else {
+            var before = [chain].concat(reading);
+            reading = [];
+            chain = Promise.all(before).then(function () { return write(c); });
+          }
+        },
+        finish: function () { return Promise.all([chain].concat(reading)).then(function () { return results; }); }
+      };
     }
 
     function step() {
@@ -799,19 +811,29 @@
       if (route) body.route = route;
       if (steps.length >= limits.steps - 1) body.final = true;
       if (o.model) body.model = o.model;
-      post('/ai/act', body, stepTime, Date.now() + stepTime).then(function (answer) {
+      // Streamed: each call comes as soon as the AI has written it, and runs then; the page follows the step for the
+      // rest. A Lamp from before streaming answers the whole step at once, which runs the same way.
+      body.stream = true;
+      var n = steps.length + 1, calls = [], ids = {}, runner = stepRunner(n), until = Date.now() + stepTime;
+      function heard(answer) {
         // What the step cost through a key, paid for whether or not its answer still runs.
         if (typeof answer.cost === 'number' && answer.cost > 0) out.cost += answer.cost;
         // Cancelled, out of time or already over: an answer that comes late runs nothing.
         if (late()) return;
         route = answer.route || route;
-        if (answer.calls && answer.calls.length) {
-          var calls = answer.calls, n = steps.length + 1, ids = {};
-          for (var i = 0; i < calls.length; i++) {
-            if (ids[calls[i].id]) return stop('error', 'The AI gave two calls the same id.');
-            ids[calls[i].id] = true;
-          }
-          return runCalls(calls, n).then(function (results) {
+        var given = answer.calls || [];
+        for (var i = 0; i < given.length; i++) {
+          if (ids[given[i].id]) return stop('error', 'The AI gave two calls the same id.');
+          ids[given[i].id] = true;
+          calls.push(given[i]);
+          runner.add(given[i]);
+        }
+        if (answer.more === true && typeof answer.stream === 'string') {
+          var have = calls.length;
+          return post('/ai/act', { follow: answer.stream, have: have }, Math.max(1000, until - Date.now()), until).then(heard, failed);
+        }
+        if (calls.length) {
+          return runner.finish().then(function (results) {
             if (late()) return;
             steps.push({ calls: calls, results: calls.map(function (c) { return results[c.id] || { id: c.id, ok: false, skipped: 'Not run.' }; }) });
             if (steps.length >= limits.steps) return stop('steps');
@@ -826,11 +848,13 @@
           return typeof c === 'string' && c.trim() && c.length <= 24 && !/[<>*_`#\[\]{}|\\\n\r\t]/.test(c);
         }) ? offered.map(function (c) { return c.trim(); }) : [];
         stop(null);
-      }, function (e) {
+      }
+      function failed(e) {
         if (e && typeof e.cost === 'number' && e.cost > 0) out.cost += e.cost;
         var message = refused(e);
         stop(/reach Lamp|Lamp isn't|wasn't put here|put it on this device/.test(message) ? 'unreachable' : 'error', message);
-      });
+      }
+      post('/ai/act', body, stepTime, until).then(heard, failed);
     }
     step();
     return { id: id, result: result, cancel: function () { stop('cancelled'); } };
@@ -1065,10 +1089,12 @@
      *     turn.cancel();
      *
      * An argument's shape is { type: 'string' | 'integer' | 'number' | 'boolean' | 'date' | 'datetime' | 'list',
-     * oneOf: [strings], min, max, optional, about, of (a list's item) }. A tool with `reads: true` changes nothing;
-     * reads in one step run together. Writes run one after another, each with its `check` right before it: a write
-     * that fails stops the writes after it in that step (`skipped`). Cancel and the time stop the turn between
-     * calls, never in the middle of a write; an answer that comes after runs nothing.
+     * oneOf: [strings], min, max, optional, about, of (a list's item) }. A tool with `reads: true` changes nothing.
+     * Each call runs as soon as the AI has written it, before the rest of its answer has come, so a build shows as
+     * it's made; calls run in the order the AI wrote them. Reads side by side run together; a write waits for the
+     * calls before it, with its `check` right before it, and a read after it sees it. A write that fails stops the
+     * writes after it in that step (`skipped`). Cancel and the time stop the turn between calls, never in the middle
+     * of a write; an answer that comes after runs nothing.
      *
      * Say what happened from `done`, `failed` and `skipped`, never from `reply`: they're what the page ran. A question
      * back (`ask`) may come with `choices`, two to four short answers to offer as buttons; with none, any answer goes.

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

@@ -1 +1 @@
-{"exe":"ZqxAppName","platform":"mac","instance":"B2538EDF-E84E-4703-8A9C-65006F6279AA","name":"Zqx App Name"}
+{"name":"Zqx App Name","exe":"ZqxAppName","platform":"mac","instance":"15F847FE-ACF1-4030-9204-0E3DC6630322"}

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

@@ -12297,23 +12297,25 @@
             func callInfo(_ call: [String: Any], key: String) -> LampActCall {
                 LampActCall(key: key, id: call["id"] as! String, request: op.request, deadline: deadline)
             }
-            for call in calls where tool(call)?.reads != false {
-                let id = call["id"] as! String
-                if let stop = over() { out.stopped = stop; return results }
-                guard let tool = tool(call) else { results[id] = ["id": id, "ok": false, "error": "There's no tool called \(call["name"] as? String ?? "")."]; continue }
-                if let bad = tool.problem(args(call)) { results[id] = ["id": id, "ok": false, "error": bad]; continue }
-                onStep(.reading(tool.name))
-                do {
-                    let value = try await tool.perform(args(call), callInfo(call, key: ""))
-                    let kept = Self.cut(value, max: max(1024, min(resultBytes, op.resultsLeft)))
-                    op.resultsLeft = max(0, op.resultsLeft - ((try? JSONSerialization.data(withJSONObject: [kept]))?.count ?? 0))
-                    results[id] = ["id": id, "ok": true, "value": kept]
-                } catch {
-                    results[id] = ["id": id, "ok": false, "error": Self.words(error)]
-                }
-            }
+            // In the order the AI wrote them, so a read after a change sees it (the rule it's given, cli/app-ai.mjs).
             var stopped: String?
-            for call in calls where tool(call)?.reads == false {
+            for call in calls {
+                if tool(call)?.reads != false {
+                    let id = call["id"] as! String
+                    if let stop = over() { out.stopped = stop; return results }
+                    guard let tool = tool(call) else { results[id] = ["id": id, "ok": false, "error": "There's no tool called \(call["name"] as? String ?? "")."]; continue }
+                    if let bad = tool.problem(args(call)) { results[id] = ["id": id, "ok": false, "error": bad]; continue }
+                    onStep(.reading(tool.name))
+                    do {
+                        let value = try await tool.perform(args(call), callInfo(call, key: ""))
+                        let kept = Self.cut(value, max: max(1024, min(resultBytes, op.resultsLeft)))
+                        op.resultsLeft = max(0, op.resultsLeft - ((try? JSONSerialization.data(withJSONObject: [kept]))?.count ?? 0))
+                        results[id] = ["id": id, "ok": true, "value": kept]
+                    } catch {
+                        results[id] = ["id": id, "ok": false, "error": Self.words(error)]
+                    }
+                    continue
+                }
                 let id = call["id"] as! String, tool = tool(call)!, given = args(call)
                 func miss(_ reason: String, skipped: Bool = false, partly: Bool = false) {
                     let entry = LampActMiss(tool: tool.name, reason: reason, partly: partly)

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

@@ -711,17 +711,20 @@
 
     // Reads run together; then the writes, one after another, each checked right before it runs. A write that
     // fails stops the writes after it in this step, which the model hears were skipped.
-    function runCalls(calls, step) {
-      var results = {}, reads = [], changes = [];
-      calls.forEach(function (c) { (tools[c.name] && tools[c.name].reads ? reads : changes).push(c); });
-      return Promise.all(reads.map(function (c) {
+    // A step's calls, run as they come (`stream`) and in the order the AI wrote them: reads side by side run together,
+    // a write waits for every call before it, and a read after a write sees it. A write that fails skips the writes
+    // after it in the step. A call Lamp held back as not fitting (`problem`) isn't run: the AI hears why, and a change of
+    // that kind fails in its place.
+    function stepRunner(step) {
+      var results = {}, chain = Promise.resolve(), reading = [], stopped = null;
+      function read(c) {
         if (late()) return null;
         var tool = tools[c.name], bad = actProblem(tool, c.name, c.args);
         if (bad) { results[c.id] = { id: c.id, ok: false, error: bad }; return null; }
         tell({ kind: 'read', name: c.name, args: c.args });
         var NOT_RUN = {};
         return Promise.resolve().then(function () {
-          // Reads start together, but each one only while there's time: an earlier one can be slow.
+          // Each read starts only while there's time: an earlier one can be slow.
           return late() ? NOT_RUN : tool.run(c.args, { turn: id, step: step, id: c.id });
         }).then(function (value) {
           if (value === NOT_RUN) return;
@@ -731,60 +734,69 @@
             if (p.pictures) results[c.id].pictures = p.pictures;
           });
         }, function (e) { results[c.id] = { id: c.id, ok: false, error: refused(e) }; });
-      })).then(function () {
-        var stopped = null;
-        function next(i) {
-          if (i >= changes.length) return results;
-          var c = changes[i], tool = tools[c.name];
-          function skip(reason) {
-            out.skipped.push({ name: c.name, args: c.args, reason: reason });
-            results[c.id] = { id: c.id, ok: false, skipped: reason };
-            return next(i + 1);
-          }
-          function fail(reason) {
-            out.failed.push({ name: c.name, args: c.args, reason: reason });
-            results[c.id] = { id: c.id, ok: false, error: reason };
-            stopped = stopped || 'An earlier change in this step didn\'t go through.';
-            return next(i + 1);
-          }
-          if (late()) return results;
-          if (stopped) return skip(stopped);
-          var bad = actProblem(tool, c.name, c.args);
-          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.
-          // 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) {
-            if (problem) return fail(String(problem));
-            // Cancel and the time are looked at again right before the change, never in the middle of it.
-            if (late()) return results;
-            tell({ kind: 'write', name: c.name, args: c.args });
-            if (late()) return results;
-            writes++;
-            var running;
-            try { running = Promise.resolve(tool.run(c.args, call)); } catch (e) { running = Promise.reject(e); }
-            return running.then(function (value) {
-              // The change is done: it's recorded now, whatever happens to its pictures after.
-              ran[key] = { note: 'Done.' };
-              var entry = { name: c.name, args: c.args, result: value };
-              if (value && typeof value === 'object' && value.partly) entry.partly = String(value.partly);
-              out.done.push(entry);
-              tell({ kind: 'write', name: c.name, args: c.args, result: value });
-              return pictured(value).then(function (p) { return { p: p }; });
-            }).then(function (got) {
-              var kept = sized(got.p.value);
+      }
+      function write(c) {
+        var tool = tools[c.name];
+        function skip(reason) {
+          out.skipped.push({ name: c.name, args: c.args, reason: reason });
+          results[c.id] = { id: c.id, ok: false, skipped: reason };
+        }
+        function fail(reason) {
+          out.failed.push({ name: c.name, args: c.args, reason: reason });
+          results[c.id] = { id: c.id, ok: false, error: reason };
+          stopped = stopped || 'An earlier change in this step didn\'t go through.';
+        }
+        if (late()) return;
+        if (stopped) return skip(stopped);
+        // A change Lamp held back as not fitting failed, in its place.
+        if (typeof c.problem === 'string') return fail(c.problem);
+        var bad = actProblem(tool, c.name, c.args);
+        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.
+        // 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; }
+        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) {
+          if (problem) return fail(String(problem));
+          // Cancel and the time are looked at again right before the change, never in the middle of it.
+          if (late()) return;
+          tell({ kind: 'write', name: c.name, args: c.args });
+          if (late()) return;
+          writes++;
+          var running;
+          try { running = Promise.resolve(tool.run(c.args, call)); } catch (e) { running = Promise.reject(e); }
+          return running.then(function (value) {
+            // The change is done: it's recorded now, whatever happens to its pictures after.
+            ran[key] = { note: 'Done.' };
+            var entry = { name: c.name, args: c.args, result: value };
+            if (value && typeof value === 'object' && value.partly) entry.partly = String(value.partly);
+            out.done.push(entry);
+            tell({ kind: 'write', name: c.name, args: c.args, result: value });
+            return pictured(value).then(function (p) {
+              var kept = sized(p.value);
               ran[key] = kept;
               results[c.id] = { id: c.id, ok: true, value: kept };
-              if (got.p.pictures) results[c.id].pictures = got.p.pictures;
-              return next(i + 1);
-            }, function (e) { return fail(refused(e)); });
-          }, function (e) { return fail(refused(e)); });
-        }
-        return next(0);
-      });
+              if (p.pictures) results[c.id].pictures = p.pictures;
+            });
+          }, function (e) { fail(refused(e)); });
+        }, function (e) { fail(refused(e)); });
+      }
+      return {
+        add: function (c) {
+          if (typeof c.problem === 'string' && tools[c.name] && tools[c.name].reads) { results[c.id] = { id: c.id, ok: false, error: c.problem }; return; }
+          if (tools[c.name] && tools[c.name].reads) {
+            var going = chain.then(function () { return read(c); });
+            reading.push(going);
+          } else {
+            var before = [chain].concat(reading);
+            reading = [];
+            chain = Promise.all(before).then(function () { return write(c); });
+          }
+        },
+        finish: function () { return Promise.all([chain].concat(reading)).then(function () { return results; }); }
+      };
     }
 
     function step() {
@@ -799,19 +811,29 @@
       if (route) body.route = route;
       if (steps.length >= limits.steps - 1) body.final = true;
       if (o.model) body.model = o.model;
-      post('/ai/act', body, stepTime, Date.now() + stepTime).then(function (answer) {
+      // Streamed: each call comes as soon as the AI has written it, and runs then; the page follows the step for the
+      // rest. A Lamp from before streaming answers the whole step at once, which runs the same way.
+      body.stream = true;
+      var n = steps.length + 1, calls = [], ids = {}, runner = stepRunner(n), until = Date.now() + stepTime;
+      function heard(answer) {
         // What the step cost through a key, paid for whether or not its answer still runs.
         if (typeof answer.cost === 'number' && answer.cost > 0) out.cost += answer.cost;
         // Cancelled, out of time or already over: an answer that comes late runs nothing.
         if (late()) return;
         route = answer.route || route;
-        if (answer.calls && answer.calls.length) {
-          var calls = answer.calls, n = steps.length + 1, ids = {};
-          for (var i = 0; i < calls.length; i++) {
-            if (ids[calls[i].id]) return stop('error', 'The AI gave two calls the same id.');
-            ids[calls[i].id] = true;
-          }
-          return runCalls(calls, n).then(function (results) {
+        var given = answer.calls || [];
+        for (var i = 0; i < given.length; i++) {
+          if (ids[given[i].id]) return stop('error', 'The AI gave two calls the same id.');
+          ids[given[i].id] = true;
+          calls.push(given[i]);
+          runner.add(given[i]);
+        }
+        if (answer.more === true && typeof answer.stream === 'string') {
+          var have = calls.length;
+          return post('/ai/act', { follow: answer.stream, have: have }, Math.max(1000, until - Date.now()), until).then(heard, failed);
+        }
+        if (calls.length) {
+          return runner.finish().then(function (results) {
             if (late()) return;
             steps.push({ calls: calls, results: calls.map(function (c) { return results[c.id] || { id: c.id, ok: false, skipped: 'Not run.' }; }) });
             if (steps.length >= limits.steps) return stop('steps');
@@ -826,11 +848,13 @@
           return typeof c === 'string' && c.trim() && c.length <= 24 && !/[<>*_`#\[\]{}|\\\n\r\t]/.test(c);
         }) ? offered.map(function (c) { return c.trim(); }) : [];
         stop(null);
-      }, function (e) {
+      }
+      function failed(e) {
         if (e && typeof e.cost === 'number' && e.cost > 0) out.cost += e.cost;
         var message = refused(e);
         stop(/reach Lamp|Lamp isn't|wasn't put here|put it on this device/.test(message) ? 'unreachable' : 'error', message);
-      });
+      }
+      post('/ai/act', body, stepTime, until).then(heard, failed);
     }
     step();
     return { id: id, result: result, cancel: function () { stop('cancelled'); } };
@@ -1065,10 +1089,12 @@
      *     turn.cancel();
      *
      * An argument's shape is { type: 'string' | 'integer' | 'number' | 'boolean' | 'date' | 'datetime' | 'list',
-     * oneOf: [strings], min, max, optional, about, of (a list's item) }. A tool with `reads: true` changes nothing;
-     * reads in one step run together. Writes run one after another, each with its `check` right before it: a write
-     * that fails stops the writes after it in that step (`skipped`). Cancel and the time stop the turn between
-     * calls, never in the middle of a write; an answer that comes after runs nothing.
+     * oneOf: [strings], min, max, optional, about, of (a list's item) }. A tool with `reads: true` changes nothing.
+     * Each call runs as soon as the AI has written it, before the rest of its answer has come, so a build shows as
+     * it's made; calls run in the order the AI wrote them. Reads side by side run together; a write waits for the
+     * calls before it, with its `check` right before it, and a read after it sees it. A write that fails stops the
+     * writes after it in that step (`skipped`). Cancel and the time stop the turn between calls, never in the middle
+     * of a write; an answer that comes after runs nothing.
      *
      * Say what happened from `done`, `failed` and `skipped`, never from `reply`: they're what the page ran. A question
      * back (`ask`) may come with `choices`, two to four short answers to offer as buttons; with none, any answer goes.

package/cli/openrouter.mjs

@@ -81,6 +81,84 @@ export async function chat({ key, body, seconds = 120, signal, fetcher = fetch }
   throw new OpenRouterTrouble("refused", "The AI didn't answer.", { cost });
 }
 
+/**
+ * One chat completion streamed (`stream` on `LampAI.act`): `onCall(name, argumentsText)` hears each tool call, in order,
+ * as soon as its arguments are whole (they read as a JSON object, which can't go on after its closing brace), or when the
+ * answer ends. Providers may send several calls' pieces interleaved, so a later call starting says nothing. Resolves as `chat` does,
+ * `{message, cost}`, the whole message. Asked once: a provider's filter cutting it off is `filtered`, since calls may
+ * already have gone to the page.
+ */
+export async function chatStream({ key, body, seconds = 120, signal, fetcher = fetch, onCall = () => {} }) {
+  const timeout = AbortSignal.timeout(Math.max(1000, Math.floor(seconds * 1000)));
+  let answer;
+  try {
+    answer = await fetcher(ENDPOINT, { method: "POST", body: JSON.stringify({ ...body, stream: true }),
+      headers: { Authorization: `Bearer ${key || ""}`, "Content-Type": "application/json", "X-Title": "Lamp" },
+      signal: signal ? AbortSignal.any([signal, timeout]) : timeout });
+  } catch (error) {
+    if (signal?.aborted) throw new OpenRouterTrouble("stopped", "Stopped.");
+    if (error?.name === "TimeoutError") throw new OpenRouterTrouble("timeout", "This ran out of time.");
+    throw new OpenRouterTrouble("refused", "Couldn't reach OpenRouter.");
+  }
+  if (answer.status !== 200 || !answer.body) {
+    let reply = {};
+    try { reply = await answer.json(); } catch {}
+    throw new OpenRouterTrouble("refused", "OpenRouter didn't answer.", { status: answer.status, reply });
+  }
+  const calls = [], told = new Set();
+  let content = "", cost = 0, finish = null, rest = "";
+  const whole = (call) => { try { const args = JSON.parse(call.function.arguments); return !!call.function.name && !!args && typeof args === "object" && !Array.isArray(args); } catch { return false; } };
+  // In order: a call waits for every one before it, so they run as they were written.
+  const tell = (all = false) => {
+    for (let i = told.size; i < calls.length; i++) {
+      if (!calls[i] || (!all && !whole(calls[i]))) return;
+      told.add(i);
+      onCall(calls[i].function.name, calls[i].function.arguments);
+    }
+  };
+  const take = (line) => {
+    if (!line.startsWith("data:")) return;
+    const data = line.slice(5).trim();
+    if (!data || data === "[DONE]") return;
+    let chunk;
+    try { chunk = JSON.parse(data); } catch { return; }
+    if (chunk.usage) cost += Number(chunk.usage.cost) || 0;
+    if (chunk.error) throw new OpenRouterTrouble("refused", "OpenRouter didn't answer.", { status: Number(chunk.error.code) || 0, reply: { error: chunk.error }, cost });
+    const choice = Array.isArray(chunk.choices) ? chunk.choices[0] : null;
+    if (!choice) return;
+    if (choice.finish_reason) finish = choice.finish_reason;
+    const delta = choice.delta ?? {};
+    if (typeof delta.content === "string") content += delta.content;
+    for (const part of Array.isArray(delta.tool_calls) ? delta.tool_calls : []) {
+      const i = Number.isInteger(part.index) ? part.index : calls.length;
+      if (!calls[i]) calls[i] = { id: part.id || `call_${i}`, type: "function", function: { name: "", arguments: "" } };
+      if (part.id) calls[i].id = part.id;
+      if (part.function?.name) calls[i].function.name += part.function.name;
+      if (part.function?.arguments) calls[i].function.arguments += part.function.arguments;
+    }
+    tell();
+  };
+  try {
+    const decoder = new TextDecoder();
+    for await (const bytes of answer.body) {
+      rest += decoder.decode(bytes, { stream: true });
+      const lines = rest.split("\n");
+      rest = lines.pop();
+      for (const line of lines) take(line.trim());
+    }
+    if (rest.trim()) take(rest.trim());
+  } catch (error) {
+    if (error instanceof OpenRouterTrouble) throw error;
+    if (signal?.aborted) throw new OpenRouterTrouble("stopped", "Stopped.", { cost });
+    if (error?.name === "TimeoutError" || timeout.aborted) throw new OpenRouterTrouble("timeout", "This ran out of time.", { cost });
+    throw new OpenRouterTrouble("refused", "OpenRouter stopped answering.", { cost });
+  }
+  if (finish === "content_filter") throw new OpenRouterTrouble("filtered", FILTERED, { cost });
+  tell(true);
+  const message = { content, ...(calls.length ? { tool_calls: calls.filter(Boolean) } : {}) };
+  return { message, cost };
+}
+
 /** A text answer: `{text, cost}`. */
 export async function text(given) {
   const { message, cost } = await chat({ ...given, body: textBody(given) });

package/package.json

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