blun-king-cli 9.1.536 → 9.1.561

package/bin/programmatic-tool-runtime.mjs

@@ -16,8 +16,24 @@ const DEFAULT_LIMITS = Object.freeze({
   maxToolArgumentChars: 32_768,
   maxToolResultChars: 131_072,
   maxToolCalls: 64,
+  maxConsoleChars: 4_096,
+  maxConsoleRecords: 128,
+  maxConsoleArgs: 16,
+  maxConsoleRecordChars: 1_024,
+  maxConsoleDepth: 4,
+  maxConsoleEntries: 64,
 });
 
+const CONSOLE_LIMIT_NAMES = Object.freeze([
+  'maxConsoleChars',
+  'maxConsoleRecords',
+  'maxConsoleArgs',
+  'maxConsoleRecordChars',
+  'maxConsoleDepth',
+  'maxConsoleEntries',
+]);
+const CONSOLE_TRUNCATION_MARKER = '...[truncated]';
+
 let callSequence = 0;
 
 export function createProgrammaticToolRuntime(options) {
@@ -48,6 +64,7 @@ export function createProgrammaticToolRuntime(options) {
       let callCount = 0;
       let module;
       let context;
+      const consoleCapture = createConsoleCapture();
       emit({ type: 'interpreter.started', toolCount: allowedTools.length });
 
       try {
@@ -60,6 +77,16 @@ export function createProgrammaticToolRuntime(options) {
         runtime.setInterruptHandler(() => (
           controller.signal.aborted || shouldInterruptAfterDeadline(guestDeadline)()
         ));
+        const consoleBridgeName = '__blun_ptc_console';
+        const consoleBridge = context.newFunction(consoleBridgeName, (levelHandle, textHandle, truncatedHandle) => {
+          const level = context.getString(levelHandle);
+          const text = context.getString(textHandle);
+          const truncated = context.getNumber(truncatedHandle) === 1;
+          captureConsoleRecord(consoleCapture, { level, text, truncated }, limits);
+          return context.undefined;
+        });
+        context.setProp(context.global, consoleBridgeName, consoleBridge);
+        consoleBridge.dispose();
         for (const [index, tool] of allowedTools.entries()) {
           const bridgeName = `__blun_ptc_${index}`;
           const bridge = context.newAsyncifiedFunction(bridgeName, async (rawHandle) => {
@@ -123,7 +150,7 @@ export function createProgrammaticToolRuntime(options) {
           bridge.dispose();
         }
 
-        evaluateBootstrap(context, renderBootstrap(allowedTools, initialStateJson));
+        evaluateBootstrap(context, renderBootstrap(allowedTools, initialStateJson, limits));
         const evaluated = await context.evalCodeAsync(renderProgram(code), 'blun-ptc.js');
         if (evaluated.error) {
           const dumped = context.dump(evaluated.error);
@@ -142,16 +169,30 @@ export function createProgrammaticToolRuntime(options) {
         if (stateJson.length > limits.maxStateChars) {
           throw new Error(`state exceeds ${limits.maxStateChars} characters`);
         }
-        const outcome = { result: payload.result, state: payload.state, callCount };
-        emit({ type: 'interpreter.completed', callCount, durationMs: Date.now() - startedAt });
+        const legacyOutcome = { result: payload.result, state: payload.state, callCount };
+        const fittedConsole = fitConsoleToBudget(legacyOutcome, consoleCapture, limits.maxOutputChars);
+        const outcome = fittedConsole ? { ...legacyOutcome, console: fittedConsole } : legacyOutcome;
+        emit({
+          type: 'interpreter.completed',
+          callCount,
+          durationMs: Date.now() - startedAt,
+          ...consoleEventMetadata(fittedConsole ?? consoleCapture),
+        });
         return outcome;
       } catch (error) {
         const normalized = normalizeExecutionError(error, controller.signal);
+        const fittedConsole = fitConsoleToBudget(
+          { error: normalized.message },
+          consoleCapture,
+          limits.maxOutputChars,
+        );
+        if (fittedConsole) attachProgrammaticConsole(normalized, fittedConsole);
         emit({
           type: 'interpreter.failed',
           callCount,
           durationMs: Date.now() - startedAt,
           error: normalized.message,
+          ...consoleEventMetadata(fittedConsole ?? consoleCapture),
         });
         throw normalized;
       } finally {
@@ -185,6 +226,11 @@ function normalizeLimits(value = {}) {
   for (const [name, number] of Object.entries(limits)) {
     if (!Number.isSafeInteger(number) || number <= 0) throw new Error(`${name} must be a positive integer`);
   }
+  for (const name of CONSOLE_LIMIT_NAMES) {
+    if (limits[name] > DEFAULT_LIMITS[name]) {
+      throw new Error(`${name} cannot exceed ${DEFAULT_LIMITS[name]}`);
+    }
+  }
   return Object.freeze(limits);
 }
 
@@ -205,7 +251,7 @@ function jsonStringify(value, label) {
   }
 }
 
-function renderBootstrap(tools, stateJson) {
+function renderBootstrap(tools, stateJson, limits) {
   const entries = tools.map((tool, index) => {
     const bridge = `globalThis.__blun_ptc_${index}`;
     return `${JSON.stringify(tool.alias)}: (() => { const call = ${bridge}; delete ${bridge}; return (args = {}) => { const envelope = JSON.parse(call(JSON.stringify(args))); if (!envelope.ok) throw new Error(envelope.error); return envelope.value; }; })()`;
@@ -213,6 +259,183 @@ function renderBootstrap(tools, stateJson) {
   return `
     globalThis.state = JSON.parse(${JSON.stringify(stateJson)});
     globalThis.tools = Object.freeze({ ${entries.join(',')} });
+    (() => {
+      "use strict";
+      const bridge = globalThis.__blun_ptc_console;
+      delete globalThis.__blun_ptc_console;
+      const ownKeys = Reflect.ownKeys;
+      const apply = Reflect.apply;
+      const getDescriptor = Object.getOwnPropertyDescriptor;
+      const getPrototype = Object.getPrototypeOf;
+      const isArray = Array.isArray;
+      const isNaNNumber = Number.isNaN;
+      const isSame = Object.is;
+      const primitiveString = String;
+      const primitiveNumber = Number;
+      const minimum = Math.min;
+      const arraySort = Array.prototype.sort;
+      const arrayJoin = Array.prototype.join;
+      const stringCharCodeAt = String.prototype.charCodeAt;
+      const stringSlice = String.prototype.slice;
+      const numberToString = Number.prototype.toString;
+      const errorPrototype = Error.prototype;
+      const objectPrototype = Object.prototype;
+      const maxArgs = ${limits.maxConsoleArgs};
+      const maxRecordChars = ${limits.maxConsoleRecordChars};
+      const maxDepth = ${limits.maxConsoleDepth};
+      const maxEntries = ${limits.maxConsoleEntries};
+
+      const escapeText = (value) => {
+        let output = "";
+        for (let index = 0; index < value.length; index += 1) {
+          const code = apply(stringCharCodeAt, value, [index]);
+          if (code === 10) output += "\\\\n";
+          else if (code === 13) output += "\\\\r";
+          else if (code === 9) output += "\\\\t";
+          else if (code < 32 || code === 127) {
+            const hex = apply(numberToString, code, [16]);
+            output += "\\\\x" + (hex.length < 2 ? "0" + hex : hex);
+          }
+          else output += value[index];
+        }
+        return output;
+      };
+      const quote = (value) => {
+        const escaped = escapeText(value);
+        let output = '"';
+        for (let index = 0; index < escaped.length; index += 1) {
+          const character = escaped[index];
+          output += character === "\\\\" ? "\\\\\\\\" : character === '"' ? '\\\\"' : character;
+        }
+        return output + '"';
+      };
+      const isIndexKey = (key) => {
+        if (typeof key !== "string" || key.length === 0) return false;
+        for (let index = 0; index < key.length; index += 1) {
+          const code = apply(stringCharCodeAt, key, [index]);
+          if (code < 48 || code > 57) return false;
+        }
+        return true;
+      };
+      const keyText = (key) => typeof key === "string" ? quote(key) : "[Symbol]";
+      const markerForAccessor = (descriptor) => descriptor.get && descriptor.set
+        ? "[Getter/Setter]"
+        : descriptor.get ? "[Getter]" : "[Setter]";
+      const isErrorObject = (value) => {
+        let prototype;
+        try { prototype = getPrototype(value); } catch { return false; }
+        for (let depth = 0; prototype && depth < 8; depth += 1) {
+          if (prototype === errorPrototype) return true;
+          try { prototype = getPrototype(prototype); } catch { return false; }
+        }
+        return false;
+      };
+      const dataProperty = (value, key, fallback) => {
+        let current = value;
+        for (let depth = 0; current && depth < 8; depth += 1) {
+          try {
+            const descriptor = getDescriptor(current, key);
+            if (descriptor) return "value" in descriptor ? descriptor.value : fallback;
+            current = getPrototype(current);
+          } catch {
+            return fallback;
+          }
+        }
+        return fallback;
+      };
+      const format = (value, depth, ancestors, nested) => {
+        if (value === null) return "null";
+        const type = typeof value;
+        if (type === "string") return nested ? quote(value) : escapeText(value);
+        if (type === "undefined") return "undefined";
+        if (type === "boolean") return value ? "true" : "false";
+        if (type === "number") {
+          if (isNaNNumber(value)) return "NaN";
+          if (value === Infinity) return "Infinity";
+          if (value === -Infinity) return "-Infinity";
+          if (isSame(value, -0)) return "-0";
+          return primitiveString(value);
+        }
+        if (type === "bigint") return primitiveString(value) + "n";
+        if (type === "symbol") return "[Symbol]";
+        if (type === "function") return "[Function]";
+        for (let index = 0; index < ancestors.length; index += 1) {
+          if (ancestors[index] === value) return "[Circular]";
+        }
+        if (depth >= maxDepth) return "[MaxDepth]";
+        const nextAncestors = [];
+        for (let index = 0; index < ancestors.length; index += 1) nextAncestors[index] = ancestors[index];
+        nextAncestors[ancestors.length] = value;
+        if (isErrorObject(value)) {
+          const rawName = dataProperty(value, "name", "Error");
+          const rawMessage = dataProperty(value, "message", "");
+          const name = typeof rawName === "string" ? escapeText(rawName) : "Error";
+          const message = typeof rawMessage === "string" ? escapeText(rawMessage) : "";
+          return message ? name + ": " + message : name;
+        }
+        let prototype;
+        try { prototype = getPrototype(value); } catch { return "[Object]"; }
+        const array = isArray(value);
+        if (!array && prototype !== objectPrototype && prototype !== null) return "[Object]";
+        let keys;
+        try { keys = ownKeys(value); } catch { return "[Object]"; }
+        apply(arraySort, keys, [(left, right) => {
+          if (array && isIndexKey(left) && isIndexKey(right)) return primitiveNumber(left) - primitiveNumber(right);
+          const a = typeof left === "string" ? "0:" + left : "1:";
+          const b = typeof right === "string" ? "0:" + right : "1:";
+          return a < b ? -1 : a > b ? 1 : 0;
+        }]);
+        const parts = [];
+        const visibleKeys = [];
+        for (let index = 0; index < keys.length; index += 1) {
+          if (!array || keys[index] !== "length") visibleKeys[visibleKeys.length] = keys[index];
+        }
+        const retained = minimum(visibleKeys.length, maxEntries);
+        for (let index = 0; index < retained; index += 1) {
+          const key = visibleKeys[index];
+          let descriptor;
+          try { descriptor = getDescriptor(value, key); } catch {
+            parts[parts.length] = keyText(key) + ": [Unavailable]";
+            continue;
+          }
+          const formatted = descriptor && "value" in descriptor
+            ? format(descriptor.value, depth + 1, nextAncestors, true)
+            : markerForAccessor(descriptor || {});
+          parts[parts.length] = array && isIndexKey(key)
+            ? formatted
+            : keyText(key) + ": " + formatted;
+        }
+        if (visibleKeys.length > retained) parts[parts.length] = "[+" + (visibleKeys.length - retained) + " entries]";
+        return (array ? "[" : "{") + apply(arrayJoin, parts, [", "]) + (array ? "]" : "}");
+      };
+      const emit = (level, values) => {
+        const retained = minimum(values.length, maxArgs);
+        const parts = [];
+        for (let index = 0; index < retained; index += 1) {
+          parts[parts.length] = format(values[index], 0, [], false);
+        }
+        let truncated = values.length > retained;
+        if (truncated) parts[parts.length] = "[+" + (values.length - retained) + " args]";
+        let text = apply(arrayJoin, parts, [" "]);
+        if (text.length > maxRecordChars) {
+          text = apply(stringSlice, text, [0, maxRecordChars]);
+          truncated = true;
+        }
+        bridge(level, text, truncated ? 1 : 0);
+      };
+      const makeMethod = (level) => Object.freeze((...values) => emit(level, values));
+      const consoleObject = Object.freeze({
+        log: makeMethod("log"),
+        warn: makeMethod("warn"),
+        error: makeMethod("error"),
+      });
+      Object.defineProperty(globalThis, "console", {
+        value: consoleObject,
+        writable: false,
+        configurable: false,
+        enumerable: false,
+      });
+    })();
     delete globalThis.process;
     delete globalThis.require;
     delete globalThis.fetch;
@@ -228,6 +451,109 @@ function renderProgram(code) {
   return `JSON.stringify({ result: (() => { "use strict"; ${code}\n})(), state: globalThis.state })`;
 }
 
+function createConsoleCapture() {
+  return {
+    called: false,
+    records: [],
+    chars: 0,
+    truncated: false,
+    droppedRecords: 0,
+    markerAdded: false,
+  };
+}
+
+function captureConsoleRecord(capture, record, limits) {
+  capture.called = true;
+  const level = record.level;
+  if (level !== 'log' && level !== 'warn' && level !== 'error') {
+    capture.truncated = true;
+    capture.droppedRecords += 1;
+    markConsoleTruncated(capture, limits, 'log');
+    return;
+  }
+  if (capture.records.length >= limits.maxConsoleRecords || capture.chars >= limits.maxConsoleChars) {
+    capture.truncated = true;
+    capture.droppedRecords += 1;
+    markConsoleTruncated(capture, limits, level);
+    return;
+  }
+  let text = record.text.slice(0, limits.maxConsoleRecordChars);
+  let truncated = record.truncated || record.text.length > text.length;
+  const remaining = limits.maxConsoleChars - capture.chars;
+  if (text.length > remaining) {
+    text = text.slice(0, remaining);
+    truncated = true;
+  }
+  if (text.length === 0 && record.text.length > 0) {
+    capture.truncated = true;
+    capture.droppedRecords += 1;
+    markConsoleTruncated(capture, limits, level);
+    return;
+  }
+  capture.records.push({ level, text });
+  capture.chars += text.length;
+  if (truncated) {
+    capture.truncated = true;
+    markConsoleTruncated(capture, limits, level);
+  }
+}
+
+function markConsoleTruncated(capture, limits, level) {
+  if (capture.markerAdded) return;
+  const marker = CONSOLE_TRUNCATION_MARKER;
+  let record = capture.records.at(-1);
+  if (!record && capture.records.length < limits.maxConsoleRecords && limits.maxConsoleChars >= marker.length) {
+    record = { level, text: '' };
+    capture.records.push(record);
+  }
+  if (!record) return;
+  const previousLength = record.text.length;
+  const availableForRecord = Math.min(limits.maxConsoleRecordChars, limits.maxConsoleChars - (capture.chars - previousLength));
+  if (availableForRecord < marker.length) return;
+  record.text = record.text.slice(0, availableForRecord - marker.length) + marker;
+  capture.chars += record.text.length - previousLength;
+  capture.markerAdded = true;
+}
+
+function fitConsoleToBudget(base, capture, maxOutputChars) {
+  if (!capture.called) return undefined;
+  if (JSON.stringify(base).length >= maxOutputChars) return undefined;
+  const fitted = {
+    records: capture.records.map((record) => ({ ...record })),
+    truncated: capture.truncated,
+    droppedRecords: capture.droppedRecords,
+  };
+  const fits = () => JSON.stringify({ ...base, console: fitted }).length <= maxOutputChars;
+  while (!fits() && fitted.records.length > 0) {
+    const removed = fitted.records.pop();
+    fitted.droppedRecords += 1;
+    fitted.truncated = true;
+    if (removed?.text?.includes(CONSOLE_TRUNCATION_MARKER)) {
+      const last = fitted.records.at(-1);
+      if (last) last.text = last.text.slice(0, Math.max(0, last.text.length - CONSOLE_TRUNCATION_MARKER.length)) + CONSOLE_TRUNCATION_MARKER;
+    }
+  }
+  return fits() ? fitted : undefined;
+}
+
+function consoleEventMetadata(consoleValue) {
+  const records = Array.isArray(consoleValue?.records) ? consoleValue.records : [];
+  return {
+    consoleRecordCount: records.length,
+    consoleChars: records.reduce((total, record) => total + String(record.text ?? '').length, 0),
+    consoleTruncated: consoleValue?.truncated === true,
+  };
+}
+
+function attachProgrammaticConsole(error, consoleValue) {
+  Object.defineProperty(error, 'programmaticConsole', {
+    value: consoleValue,
+    enumerable: false,
+    configurable: false,
+    writable: false,
+  });
+}
+
 function evaluateBootstrap(context, source) {
   const result = context.evalCode(source, 'blun-ptc-bootstrap.js');
   if (result.error) {

package/bin/read-continuation-policy.cjs

@@ -1,7 +1,35 @@
 "use strict";
 
-const READ_LINE_CAP = 1000;
-const READ_MODEL_VISIBLE_BYTES = 10 * 1024;
+const READ_PRESSURE_RATIO = 0.75;
+const READ_PRESSURE_CHUNK_BYTES = 10 * 1024;
+const READ_PRESSURE_LINE_CAP = 1000;
+const READ_ESTIMATED_BYTES_PER_TOKEN = 4;
+
+function availableReadContextTokens(input = {}) {
+  const contextTokens = Number(input.contextTokens);
+  const maxContextTokens = Number(input.maxContextTokens);
+  if (!Number.isFinite(contextTokens) || contextTokens < 0) return undefined;
+  if (!Number.isFinite(maxContextTokens) || maxContextTokens <= 0) return undefined;
+
+  const pressureTokens = Math.floor(maxContextTokens * READ_PRESSURE_RATIO);
+  return Math.max(0, pressureTokens - contextTokens);
+}
+
+function readModelVisibleBytes(input = {}) {
+  const availableTokens = availableReadContextTokens(input);
+  if (availableTokens === undefined) return READ_PRESSURE_CHUNK_BYTES;
+  const availableBytes = Math.min(
+    Number.MAX_SAFE_INTEGER,
+    availableTokens * READ_ESTIMATED_BYTES_PER_TOKEN,
+  );
+  return Math.max(READ_PRESSURE_CHUNK_BYTES, availableBytes);
+}
+
+function readModelVisibleLines(input = {}) {
+  const availableTokens = availableReadContextTokens(input);
+  if (availableTokens === undefined) return READ_PRESSURE_LINE_CAP;
+  return Math.max(READ_PRESSURE_LINE_CAP, availableTokens);
+}
 
 function readContinuationNotice(input) {
   if (!Number.isSafeInteger(input.lineOffset) || input.lineOffset < 1) return undefined;
@@ -10,7 +38,7 @@ function readContinuationNotice(input) {
     if (!Number.isSafeInteger(input.renderedLineCount) || input.renderedLineCount < 1) return undefined;
     readLines = input.renderedLineCount;
   } else if (input?.maxLinesReached === true) {
-    if (!Number.isSafeInteger(input.effectiveLimit) || input.effectiveLimit < READ_LINE_CAP) return undefined;
+    if (!Number.isSafeInteger(input.effectiveLimit) || input.effectiveLimit < input.maxLines) return undefined;
     readLines = input.effectiveLimit;
   } else {
     return undefined;
@@ -22,7 +50,10 @@ function readContinuationNotice(input) {
 }
 
 module.exports = {
-  READ_LINE_CAP,
-  READ_MODEL_VISIBLE_BYTES,
+  READ_PRESSURE_RATIO,
+  READ_PRESSURE_CHUNK_BYTES,
+  READ_PRESSURE_LINE_CAP,
+  readModelVisibleBytes,
+  readModelVisibleLines,
   readContinuationNotice,
 };

package/bin/retry-checkpoint-policy.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+async function persistRetrySchedule(input = {}) {
+  const { dispatchRetrying, flush, event, signal } = input;
+  if (typeof dispatchRetrying !== 'function') throw new TypeError('persistRetrySchedule requires dispatchRetrying');
+  if (typeof flush !== 'function') throw new TypeError('persistRetrySchedule requires flush');
+  signal?.throwIfAborted?.();
+  await dispatchRetrying(event);
+  await flush();
+  signal?.throwIfAborted?.();
+}
+
+module.exports = { persistRetrySchedule };