blun-king-cli 9.1.587 → 9.1.588

package/bin/programmatic-tool-runtime.mjs

@@ -1,627 +0,0 @@
-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/provider-idle-timeout-policy.cjs

@@ -1,14 +0,0 @@
-"use strict";
-
-const DEFAULT_PROVIDER_IDLE_TIMEOUT_MS = 120 * 1000;
-
-function resolveProviderIdleTimeoutMs(configuredSeconds) {
-  return configuredSeconds === undefined
-    ? DEFAULT_PROVIDER_IDLE_TIMEOUT_MS
-    : configuredSeconds * 1000;
-}
-
-module.exports = {
-  DEFAULT_PROVIDER_IDLE_TIMEOUT_MS,
-  resolveProviderIdleTimeoutMs,
-};

package/bin/provider-model-refresh-deadline.cjs

@@ -1,53 +0,0 @@
-'use strict';
-
-const DEFAULT_PROVIDER_MODEL_READ_TIMEOUT_MS = 10_000;
-
-function providerModelRefreshAbortError(timedOut = false, cause) {
-  const error = new Error(timedOut ? 'Model catalog refresh timed out.' : 'Model catalog refresh was cancelled.', { cause });
-  error.code = timedOut ? 'PROVIDER_MODEL_REFRESH_TIMEOUT' : 'PROVIDER_MODEL_REFRESH_ABORTED';
-  return error;
-}
-
-function isProviderModelReadInterrupted(error) {
-  return error?.code === 'PROVIDER_MODEL_REFRESH_TIMEOUT' || error?.code === 'PROVIDER_MODEL_REFRESH_ABORTED';
-}
-
-// Bound only remote reads. The caller must await any config commit it has started.
-function withProviderModelReadDeadline(operation, options = {}) {
-  const { signal, timeoutMs = DEFAULT_PROVIDER_MODEL_READ_TIMEOUT_MS } = options;
-  if (signal?.aborted) return Promise.reject(providerModelRefreshAbortError(false, signal.reason));
-  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2_147_483_647) {
-    return Promise.reject(new RangeError('Invalid provider model read timeout.'));
-  }
-  const controller = new AbortController();
-  return new Promise((resolve, reject) => {
-    let settled = false;
-    let timer;
-    const finish = (complete, value) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      signal?.removeEventListener('abort', onAbort);
-      complete(value);
-    };
-    const abort = (timedOut) => {
-      const error = providerModelRefreshAbortError(timedOut, signal?.reason);
-      controller.abort(error);
-      finish(reject, error);
-    };
-    const onAbort = () => abort(false);
-    signal?.addEventListener('abort', onAbort, { once: true });
-    timer = setTimeout(() => abort(true), timeoutMs);
-    if (signal?.aborted) onAbort();
-    Promise.resolve().then(() => {
-      controller.signal.throwIfAborted();
-      return operation(controller.signal);
-    }).then(
-      (value) => controller.signal.aborted ? finish(reject, controller.signal.reason) : finish(resolve, value),
-      (error) => finish(reject, error),
-    );
-  });
-}
-
-module.exports = { DEFAULT_PROVIDER_MODEL_READ_TIMEOUT_MS, providerModelRefreshAbortError,
-  isProviderModelReadInterrupted, withProviderModelReadDeadline };