blun-king-cli 9.1.527 → 9.1.550

package/bin/programmatic-tool-runtime.mjs

@@ -0,0 +1,627 @@
+import {
+  RELEASE_ASYNC,
+  newQuickJSAsyncWASMModule,
+  shouldInterruptAfterDeadline,
+} from 'quickjs-emscripten';
+
+const IDENTIFIER_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/u;
+const DEFAULT_LIMITS = Object.freeze({
+  memoryBytes: 16 * 1024 * 1024,
+  stackBytes: 512 * 1024,
+  timeoutMs: 120_000,
+  guestExecutionMs: 3_000,
+  maxCodeChars: 32_000,
+  maxStateChars: 65_536,
+  maxOutputChars: 65_536,
+  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) {
+  if (typeof options?.invokeTool !== 'function') {
+    throw new TypeError('invokeTool must be a function');
+  }
+  const allowedTools = normalizeAllowedTools(options.allowedTools);
+  const limits = normalizeLimits(options.limits);
+  const emit = typeof options.onEvent === 'function' ? options.onEvent : () => {};
+
+  return {
+    async run(input) {
+      const code = String(input?.code ?? '');
+      if (code.length > limits.maxCodeChars) {
+        throw new Error(`program exceeds ${limits.maxCodeChars} characters`);
+      }
+      const initialState = normalizeJsonObject(input?.state ?? {}, 'state');
+      const initialStateJson = JSON.stringify(initialState);
+      if (initialStateJson.length > limits.maxStateChars) {
+        throw new Error(`state exceeds ${limits.maxStateChars} characters`);
+      }
+
+      const startedAt = Date.now();
+      const wallDeadline = startedAt + limits.timeoutMs;
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(new Error('execution deadline exceeded')), limits.timeoutMs);
+      const detachOuterAbort = forwardAbort(input?.signal, controller);
+      let callCount = 0;
+      let module;
+      let context;
+      const consoleCapture = createConsoleCapture();
+      emit({ type: 'interpreter.started', toolCount: allowedTools.length });
+
+      try {
+        module = await newQuickJSAsyncWASMModule(RELEASE_ASYNC);
+        context = module.newContext();
+        const runtime = context.runtime;
+        let guestDeadline = Date.now() + limits.guestExecutionMs;
+        runtime.setMemoryLimit(limits.memoryBytes);
+        runtime.setMaxStackSize(limits.stackBytes);
+        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) => {
+            if (callCount >= limits.maxToolCalls) {
+              return context.newString(errorEnvelope(`tool-call limit of ${limits.maxToolCalls} exceeded`));
+            }
+            const raw = rawHandle === undefined ? '{}' : context.getString(rawHandle);
+            if (raw.length > limits.maxToolArgumentChars) {
+              return context.newString(errorEnvelope(`tool arguments exceed ${limits.maxToolArgumentChars} characters`));
+            }
+            let args;
+            try {
+              args = normalizeJsonObject(JSON.parse(raw), 'tool arguments');
+            } catch (error) {
+              return context.newString(errorEnvelope(errorMessage(error)));
+            }
+            callCount += 1;
+            const callId = nextCallId(tool.name);
+            emit({
+              type: 'interpreter.tool_call',
+              callId,
+              toolName: tool.name,
+              args,
+            });
+            try {
+              const hostStartedAt = Date.now();
+              let value;
+              try {
+                value = await raceHostCall(
+                  options.invokeTool({ name: tool.name, args, callId, signal: controller.signal }),
+                  controller.signal,
+                  wallDeadline,
+                );
+              } finally {
+                guestDeadline += Date.now() - hostStartedAt;
+              }
+              const valueJson = jsonStringify(value, `tool ${tool.name} result`);
+              if (valueJson.length > limits.maxToolResultChars) {
+                throw new Error(`tool result exceeds ${limits.maxToolResultChars} characters`);
+              }
+              emit({
+                type: 'interpreter.tool_result',
+                callId,
+                toolName: tool.name,
+                isError: false,
+              });
+              return context.newString(JSON.stringify({ ok: true, value }));
+            } catch (error) {
+              const message = errorMessage(error);
+              emit({
+                type: 'interpreter.tool_result',
+                callId,
+                toolName: tool.name,
+                isError: true,
+                error: message,
+              });
+              return context.newString(errorEnvelope(message));
+            }
+          });
+          context.setProp(context.global, bridgeName, bridge);
+          bridge.dispose();
+        }
+
+        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);
+          evaluated.error.dispose();
+          throw guestError(dumped, controller.signal, guestDeadline);
+        }
+        runtime.setMemoryLimit(-1);
+        const payloadJson = context.getString(evaluated.value);
+        evaluated.value.dispose();
+        const payload = JSON.parse(payloadJson);
+        const resultJson = jsonStringify(payload.result, 'result');
+        const stateJson = jsonStringify(payload.state, 'state');
+        if (resultJson.length > limits.maxOutputChars) {
+          throw new Error(`result exceeds ${limits.maxOutputChars} characters`);
+        }
+        if (stateJson.length > limits.maxStateChars) {
+          throw new Error(`state exceeds ${limits.maxStateChars} characters`);
+        }
+        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 {
+        clearTimeout(timeout);
+        detachOuterAbort();
+        context?.dispose();
+      }
+    },
+  };
+}
+
+function normalizeAllowedTools(value) {
+  if (!Array.isArray(value)) throw new TypeError('allowedTools must be an array');
+  const names = new Set();
+  const aliases = new Set();
+  return value.map((entry) => {
+    const name = String(entry?.name ?? '').trim();
+    const alias = String(entry?.alias ?? '').trim();
+    if (!name) throw new Error('tool name must not be empty');
+    if (!IDENTIFIER_RE.test(alias)) throw new Error(`${alias || '[empty]'} is not a valid JavaScript identifier`);
+    if (names.has(name)) throw new Error(`duplicate tool name: ${name}`);
+    if (aliases.has(alias)) throw new Error(`duplicate tool alias: ${alias}`);
+    names.add(name);
+    aliases.add(alias);
+    return Object.freeze({ name, alias });
+  });
+}
+
+function normalizeLimits(value = {}) {
+  const limits = { ...DEFAULT_LIMITS, ...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);
+}
+
+function normalizeJsonObject(value, label) {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error(`${label} must be a JSON object`);
+  }
+  return JSON.parse(jsonStringify(value, label));
+}
+
+function jsonStringify(value, label) {
+  try {
+    const result = JSON.stringify(value);
+    if (result === undefined) throw new Error(`${label} is not JSON serializable`);
+    return result;
+  } catch (error) {
+    throw new Error(`${label} is not JSON serializable: ${errorMessage(error)}`);
+  }
+}
+
+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; }; })()`;
+  });
+  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;
+    delete globalThis.Date;
+    delete globalThis.performance;
+    delete globalThis.eval;
+    delete globalThis.Function;
+    undefined;
+  `;
+}
+
+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) {
+    const dumped = context.dump(result.error);
+    result.error.dispose();
+    throw new Error(`interpreter bootstrap failed: ${errorMessage(dumped)}`);
+  }
+  result.value.dispose();
+}
+
+function errorEnvelope(message) {
+  return JSON.stringify({ ok: false, error: String(message) });
+}
+
+function nextCallId(toolName) {
+  callSequence += 1;
+  return `ptc_${toolName.replace(/[^A-Za-z0-9_]/gu, '_')}_${callSequence}`;
+}
+
+function forwardAbort(signal, controller) {
+  if (!signal) return () => {};
+  const onAbort = () => controller.abort(signal.reason);
+  if (signal.aborted) onAbort();
+  else signal.addEventListener('abort', onAbort, { once: true });
+  return () => signal.removeEventListener('abort', onAbort);
+}
+
+async function raceHostCall(value, signal, deadline) {
+  if (signal.aborted) throw signal.reason ?? new Error('program aborted');
+  const remaining = Math.max(0, deadline - Date.now());
+  let timer;
+  let onAbort;
+  const blocked = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error('execution deadline exceeded')), remaining);
+    onAbort = () => reject(signal.reason ?? new Error('program aborted'));
+    signal.addEventListener('abort', onAbort, { once: true });
+  });
+  try {
+    return await Promise.race([Promise.resolve(value), blocked]);
+  } finally {
+    clearTimeout(timer);
+    signal.removeEventListener('abort', onAbort);
+  }
+}
+
+function guestError(value, signal, deadline) {
+  if (signal.aborted) return abortReason(signal);
+  if (Date.now() >= deadline || value?.message === 'interrupted') {
+    return new Error('execution deadline exceeded');
+  }
+  return new Error(value?.message ?? errorMessage(value));
+}
+
+function normalizeExecutionError(error, signal) {
+  if (signal.aborted) return abortReason(signal);
+  if (errorMessage(error).includes('interrupted')) {
+    return new Error('guest execution deadline exceeded');
+  }
+  return error instanceof Error ? error : new Error(errorMessage(error));
+}
+
+function abortReason(signal) {
+  if (signal.reason instanceof Error) return signal.reason;
+  return new Error(signal.reason === undefined ? 'program aborted' : String(signal.reason));
+}
+
+function errorMessage(error) {
+  if (error instanceof Error) return error.message;
+  if (error && typeof error === 'object' && typeof error.message === 'string') return error.message;
+  return String(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,
 };