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

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

@@ -75,7 +75,7 @@ needs Lamp (for AI, `LampAI.status`'s `reason`), never an error or an empty scre
 
 `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). 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). 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:

package/cli/app-ai.mjs

@@ -14,7 +14,7 @@
 // (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 = 256 * 1024, MAX_CHOICES = 4, MAX_CHOICE = 24;
+export const MAX_TOOLS = 24, MAX_CALLS = 8, MAX_STEPS = 4, 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;
@@ -66,7 +66,7 @@ function parseArg(raw, path) {
  * steps, route, seconds, final}`, 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 256 KB.");
+  if (Buffer.byteLength(text) > MAX_BODY) throw new Refused(413, "A step can carry at most 2 MB.");
   let body;
   try { body = JSON.parse(text); } catch {}
   if (!body || typeof body !== "object" || Array.isArray(body)) throw new Refused(400, "A step needs a JSON object.");

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

@@ -521,16 +521,33 @@
   // 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.
   var ACT_LIMITS = { steps: 4, writes: 6 };
+  // 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.
+  var ACT_RESULT = 32768, ACT_RESULT_MAX = 262144;
+  // What a turn's reads give back in all, which every later step carries again: kept under what a step may carry
+  // (`MAX_BODY` in lamp's app-ai.mjs), with room for the request, the tools and the steps' own words.
+  var ACT_TURN_RESULTS = 1200000;
   var ACT_STEP_SECONDS = 600;
   var actRan = {};      // turn id -> call key -> the result a write gave, while this copy of the page is open
   function actId() { return 't' + Date.now().toString(36) + Math.random().toString(36).slice(2, 8); }
   function isList(v) { return Object.prototype.toString.call(v) === '[object Array]'; }
-  /** At most 4 KB of a result goes back to the model, cut with a note. */
-  function actValue(value) {
+  /** A text's size in UTF-8 bytes, as a step is measured where it's checked. */
+  function utf8Bytes(text) { try { return unescape(encodeURIComponent(text)).length; } catch (e) { return text.length * 3; } }
+  /** At most `max` bytes of a result go back to the model, as it's sent (UTF-8, its cut wrapper included), cut with a note. */
+  function actValue(value, max) {
     var json = jsonState(value === undefined ? null : value), text;
     try { text = JSON.stringify(json); } catch (e) { return { note: 'The result couldn\'t be read.' }; }
-    if (text && text.length > 4096) return { cut: text.slice(0, 4000), note: 'Cut short: ask for less.' };
-    return json;
+    if (!text || utf8Bytes(text) <= max) return json;
+    // The cut is JSON inside JSON, so its quotes are escaped again: shrink it until the whole wrapper fits.
+    var cut = text.slice(0, max);
+    for (var i = 0; i < 24; i++) {
+      var wrapped = { cut: cut, note: 'Cut short: ask for less.' };
+      var size = utf8Bytes(JSON.stringify(wrapped));
+      if (size <= max) return wrapped;
+      cut = cut.slice(0, Math.max(0, Math.floor(cut.length * max / size) - 16));
+    }
+    return { note: 'Cut short: ask for less.' };
   }
   /** The page's own check of a call before it runs: a tool it declared, its arguments an object with nothing
    *  undeclared and nothing required missing. Lamp has checked the shapes; this is what the page itself can hold to. */
@@ -552,6 +569,15 @@
       limits[k] = Math.max(1, Math.min(asked, ACT_LIMITS[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
+      ? Math.min(Math.max(1024, Math.floor(o.limits.result)), ACT_RESULT_MAX) : ACT_RESULT;
+    // Each result takes from the turn's allowance, so later reads get less rather than the step growing past it.
+    var resultsLeft = ACT_TURN_RESULTS;
+    function sized(value) {
+      var kept = actValue(value, Math.max(1024, Math.min(resultMax, resultsLeft)));
+      try { resultsLeft = Math.max(0, resultsLeft - utf8Bytes(JSON.stringify(kept))); } catch (e) {}
+      return kept;
+    }
     var id = o.turn || actId();
     if (!actRan[id]) {
       var kept = Object.keys(actRan);
@@ -601,7 +627,7 @@
         }).then(function (value) {
           if (value === NOT_RUN) return;
           out.reads.push({ name: c.name, args: c.args });
-          results[c.id] = { id: c.id, ok: true, value: actValue(value) };
+          results[c.id] = { id: c.id, ok: true, value: sized(value) };
         }, function (e) { results[c.id] = { id: c.id, ok: false, error: refused(e) }; });
       })).then(function () {
         var stopped = null;
@@ -638,7 +664,7 @@
             var running;
             try { running = Promise.resolve(tool.run(c.args, call)); } catch (e) { running = Promise.reject(e); }
             return running.then(function (value) {
-              var kept = actValue(value);
+              var kept = sized(value);
               ran[key] = kept;
               var entry = { name: c.name, args: c.args, result: value };
               if (value && typeof value === 'object' && value.partly) entry.partly = String(value.partly);

package/cli/lamps/lamp.js

@@ -521,16 +521,33 @@
   // 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.
   var ACT_LIMITS = { steps: 4, writes: 6 };
+  // 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.
+  var ACT_RESULT = 32768, ACT_RESULT_MAX = 262144;
+  // What a turn's reads give back in all, which every later step carries again: kept under what a step may carry
+  // (`MAX_BODY` in lamp's app-ai.mjs), with room for the request, the tools and the steps' own words.
+  var ACT_TURN_RESULTS = 1200000;
   var ACT_STEP_SECONDS = 600;
   var actRan = {};      // turn id -> call key -> the result a write gave, while this copy of the page is open
   function actId() { return 't' + Date.now().toString(36) + Math.random().toString(36).slice(2, 8); }
   function isList(v) { return Object.prototype.toString.call(v) === '[object Array]'; }
-  /** At most 4 KB of a result goes back to the model, cut with a note. */
-  function actValue(value) {
+  /** A text's size in UTF-8 bytes, as a step is measured where it's checked. */
+  function utf8Bytes(text) { try { return unescape(encodeURIComponent(text)).length; } catch (e) { return text.length * 3; } }
+  /** At most `max` bytes of a result go back to the model, as it's sent (UTF-8, its cut wrapper included), cut with a note. */
+  function actValue(value, max) {
     var json = jsonState(value === undefined ? null : value), text;
     try { text = JSON.stringify(json); } catch (e) { return { note: 'The result couldn\'t be read.' }; }
-    if (text && text.length > 4096) return { cut: text.slice(0, 4000), note: 'Cut short: ask for less.' };
-    return json;
+    if (!text || utf8Bytes(text) <= max) return json;
+    // The cut is JSON inside JSON, so its quotes are escaped again: shrink it until the whole wrapper fits.
+    var cut = text.slice(0, max);
+    for (var i = 0; i < 24; i++) {
+      var wrapped = { cut: cut, note: 'Cut short: ask for less.' };
+      var size = utf8Bytes(JSON.stringify(wrapped));
+      if (size <= max) return wrapped;
+      cut = cut.slice(0, Math.max(0, Math.floor(cut.length * max / size) - 16));
+    }
+    return { note: 'Cut short: ask for less.' };
   }
   /** The page's own check of a call before it runs: a tool it declared, its arguments an object with nothing
    *  undeclared and nothing required missing. Lamp has checked the shapes; this is what the page itself can hold to. */
@@ -552,6 +569,15 @@
       limits[k] = Math.max(1, Math.min(asked, ACT_LIMITS[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
+      ? Math.min(Math.max(1024, Math.floor(o.limits.result)), ACT_RESULT_MAX) : ACT_RESULT;
+    // Each result takes from the turn's allowance, so later reads get less rather than the step growing past it.
+    var resultsLeft = ACT_TURN_RESULTS;
+    function sized(value) {
+      var kept = actValue(value, Math.max(1024, Math.min(resultMax, resultsLeft)));
+      try { resultsLeft = Math.max(0, resultsLeft - utf8Bytes(JSON.stringify(kept))); } catch (e) {}
+      return kept;
+    }
     var id = o.turn || actId();
     if (!actRan[id]) {
       var kept = Object.keys(actRan);
@@ -601,7 +627,7 @@
         }).then(function (value) {
           if (value === NOT_RUN) return;
           out.reads.push({ name: c.name, args: c.args });
-          results[c.id] = { id: c.id, ok: true, value: actValue(value) };
+          results[c.id] = { id: c.id, ok: true, value: sized(value) };
         }, function (e) { results[c.id] = { id: c.id, ok: false, error: refused(e) }; });
       })).then(function () {
         var stopped = null;
@@ -638,7 +664,7 @@
             var running;
             try { running = Promise.resolve(tool.run(c.args, call)); } catch (e) { running = Promise.reject(e); }
             return running.then(function (value) {
-              var kept = actValue(value);
+              var kept = sized(value);
               ran[key] = kept;
               var entry = { name: c.name, args: c.args, result: value };
               if (value && typeof value === 'object' && value.partly) entry.partly = String(value.partly);

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

@@ -1 +1 @@
-{"instance":"99F1CF1A-EC7E-4440-8F31-0B2D19F376A5","platform":"mac","name":"Zqx App Name","exe":"ZqxAppName"}
+{"exe":"ZqxAppName","name":"Zqx App Name","platform":"mac","instance":"10DC6CFC-3873-414E-B724-6AA904DC37A0"}

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

@@ -12017,6 +12017,9 @@
             let request: String
             var answers: [(question: String, answer: String)] = []
             var writes = 0
+            /// What its reads may still give back in all: every later step carries them again, under what a step may
+            /// carry (`MAX_BODY` in lamp's app-ai.mjs).
+            var resultsLeft = 1_200_000
         }
         private var operation: Operation?
         /// Each change's result by its key, so the same change asked again gets it without running again.
@@ -12028,14 +12031,19 @@
         private let send: ([String: Any], TimeInterval) async throws -> [String: Any]
         /// The longest a request may take, when the app wants a quick answer; nil for no limit.
         let seconds: Double?
+        /// 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
 
         /// `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).
         /// `send` stands in for Lamp in a test; leave it out.
-        init(about: String = "", tools: [LampActTool], seconds: Double? = nil,
+        init(about: String = "", tools: [LampActTool], seconds: Double? = nil, resultBytes: Int? = 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.send = send ?? { body, timeout in try await LampAI.post("/ai/act", body, timeout: timeout) }
         }
 
@@ -12192,7 +12200,9 @@
                 onStep(.reading(tool.name))
                 do {
                     let value = try await tool.perform(args(call), callInfo(call, key: ""))
-                    results[id] = ["id": id, "ok": true, "value": Self.cut(value)]
+                    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)]
                 }
@@ -12251,13 +12261,21 @@
 
         private static func words(_ error: Error) -> String { (error as? LampAI.Failure)?.message ?? error.localizedDescription }
 
-        /// At most 4 KB of a read goes back to the AI, cut with a note.
-        private static func cut(_ value: Any) -> Any {
+        /// At most `max` bytes of a read go back to the AI, cut with a note.
+        private static func cut(_ value: Any, max: Int) -> Any {
             guard JSONSerialization.isValidJSONObject([value]), let data = try? JSONSerialization.data(withJSONObject: [value]) else {
                 return ["note": "The result couldn't be read."]
             }
-            guard data.count > 4096 else { return value }
-            return ["cut": String(String(decoding: data, as: UTF8.self).prefix(4000)), "note": "Cut short: ask for less."]
+            guard data.count > max else { return value }
+            // The cut is JSON inside JSON, so its quotes are escaped again: shrink it until the whole wrapper fits.
+            var cut = String(decoding: data.prefix(max), as: UTF8.self)
+            for _ in 0..<24 {
+                let wrapped: [String: Any] = ["cut": cut, "note": "Cut short: ask for less."]
+                let size = (try? JSONSerialization.data(withJSONObject: [wrapped]))?.count ?? Int.max
+                if size <= max { return wrapped }
+                cut = String(cut.prefix(Swift.max(0, cut.count * max / Swift.max(size, 1) - 16)))
+            }
+            return ["note": "Cut short: ask for less."]
         }
 
         private static func canonical(_ value: Any) -> String {

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

@@ -521,16 +521,33 @@
   // 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.
   var ACT_LIMITS = { steps: 4, writes: 6 };
+  // 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.
+  var ACT_RESULT = 32768, ACT_RESULT_MAX = 262144;
+  // What a turn's reads give back in all, which every later step carries again: kept under what a step may carry
+  // (`MAX_BODY` in lamp's app-ai.mjs), with room for the request, the tools and the steps' own words.
+  var ACT_TURN_RESULTS = 1200000;
   var ACT_STEP_SECONDS = 600;
   var actRan = {};      // turn id -> call key -> the result a write gave, while this copy of the page is open
   function actId() { return 't' + Date.now().toString(36) + Math.random().toString(36).slice(2, 8); }
   function isList(v) { return Object.prototype.toString.call(v) === '[object Array]'; }
-  /** At most 4 KB of a result goes back to the model, cut with a note. */
-  function actValue(value) {
+  /** A text's size in UTF-8 bytes, as a step is measured where it's checked. */
+  function utf8Bytes(text) { try { return unescape(encodeURIComponent(text)).length; } catch (e) { return text.length * 3; } }
+  /** At most `max` bytes of a result go back to the model, as it's sent (UTF-8, its cut wrapper included), cut with a note. */
+  function actValue(value, max) {
     var json = jsonState(value === undefined ? null : value), text;
     try { text = JSON.stringify(json); } catch (e) { return { note: 'The result couldn\'t be read.' }; }
-    if (text && text.length > 4096) return { cut: text.slice(0, 4000), note: 'Cut short: ask for less.' };
-    return json;
+    if (!text || utf8Bytes(text) <= max) return json;
+    // The cut is JSON inside JSON, so its quotes are escaped again: shrink it until the whole wrapper fits.
+    var cut = text.slice(0, max);
+    for (var i = 0; i < 24; i++) {
+      var wrapped = { cut: cut, note: 'Cut short: ask for less.' };
+      var size = utf8Bytes(JSON.stringify(wrapped));
+      if (size <= max) return wrapped;
+      cut = cut.slice(0, Math.max(0, Math.floor(cut.length * max / size) - 16));
+    }
+    return { note: 'Cut short: ask for less.' };
   }
   /** The page's own check of a call before it runs: a tool it declared, its arguments an object with nothing
    *  undeclared and nothing required missing. Lamp has checked the shapes; this is what the page itself can hold to. */
@@ -552,6 +569,15 @@
       limits[k] = Math.max(1, Math.min(asked, ACT_LIMITS[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
+      ? Math.min(Math.max(1024, Math.floor(o.limits.result)), ACT_RESULT_MAX) : ACT_RESULT;
+    // Each result takes from the turn's allowance, so later reads get less rather than the step growing past it.
+    var resultsLeft = ACT_TURN_RESULTS;
+    function sized(value) {
+      var kept = actValue(value, Math.max(1024, Math.min(resultMax, resultsLeft)));
+      try { resultsLeft = Math.max(0, resultsLeft - utf8Bytes(JSON.stringify(kept))); } catch (e) {}
+      return kept;
+    }
     var id = o.turn || actId();
     if (!actRan[id]) {
       var kept = Object.keys(actRan);
@@ -601,7 +627,7 @@
         }).then(function (value) {
           if (value === NOT_RUN) return;
           out.reads.push({ name: c.name, args: c.args });
-          results[c.id] = { id: c.id, ok: true, value: actValue(value) };
+          results[c.id] = { id: c.id, ok: true, value: sized(value) };
         }, function (e) { results[c.id] = { id: c.id, ok: false, error: refused(e) }; });
       })).then(function () {
         var stopped = null;
@@ -638,7 +664,7 @@
             var running;
             try { running = Promise.resolve(tool.run(c.args, call)); } catch (e) { running = Promise.reject(e); }
             return running.then(function (value) {
-              var kept = actValue(value);
+              var kept = sized(value);
               ran[key] = kept;
               var entry = { name: c.name, args: c.args, result: value };
               if (value && typeof value === 'object' && value.partly) entry.partly = String(value.partly);

package/cli/local-ai.mjs

@@ -21,7 +21,7 @@ import { answer as answerAI, engine } from "./ai.mjs";
 /** The port lamp.js on a shared page asks (`LOCAL_AI` there): one, fixed, since the page can't be told another. */
 export const LOCAL_AI_PORT = 47423;
 const PLAY_HOST = "play.lamp.dev";
-const MOST = 2_000_000, AT_ONCE = 3, ASKING_FOR = 120_000;
+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 keptFile = () => join(process.env.LAMP_DEV_HOME || join(homedir(), ".lamp", "dev"), "shared-pages-ai.json");

package/package.json

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