blun-king-cli 9.1.527 → 9.1.550

package/bin/editable-tool-approval-runtime.cjs

@@ -0,0 +1,99 @@
+'use strict';
+
+const {
+  canonicalEditedToolInputJson,
+  validateEditedToolInputObject,
+} = require('./editable-tool-approval-policy.cjs');
+
+class EditableToolReprepareError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = 'EditableToolReprepareError';
+    this.code = code;
+  }
+}
+
+function fail(code, message) {
+  throw new EditableToolReprepareError(code, message);
+}
+
+function buildEditedToolCallPlan({
+  step,
+  call,
+  editedArgs,
+  editCount,
+  preflightToolCall,
+} = {}) {
+  if (editCount !== 0) {
+    fail('EDITED_REPREPARE_ALREADY_EDITED', 'A tool call may be edited at most once.');
+  }
+  if (call?.kind !== 'runnable' || call.toolCall === null || typeof call.toolCall !== 'object' || typeof call.toolCall.id !== 'string' || typeof call.toolCall.name !== 'string') {
+    fail('EDITED_REPREPARE_CALL_INVALID', 'Only a runnable tool call can be re-prepared.');
+  }
+  if (!Array.isArray(step?.toolCalls) || typeof preflightToolCall !== 'function') {
+    fail('EDITED_REPREPARE_CONTEXT_INVALID', 'Edited re-preparation requires the active ordered tool-call list and preflight function.');
+  }
+
+  const matchingIndexes = [];
+  for (let index = 0; index < step.toolCalls.length; index += 1) {
+    if (step.toolCalls[index]?.id === call.toolCall.id) matchingIndexes.push(index);
+  }
+  if (matchingIndexes.length === 0) {
+    fail('EDITED_REPREPARE_IDENTITY_MISSING', 'The edited tool call is absent from the active ordered call list.');
+  }
+  if (matchingIndexes.length !== 1) {
+    fail('EDITED_REPREPARE_IDENTITY_AMBIGUOUS', 'The edited tool-call ID is not unique in the active call list.');
+  }
+  const position = matchingIndexes[0];
+  if (step.toolCalls[position] !== call.toolCall || call.toolName !== call.toolCall.name) {
+    fail('EDITED_REPREPARE_IDENTITY_CHANGED', 'The active tool-call identity changed before re-preparation.');
+  }
+
+  const safeEditedArgs = validateEditedToolInputObject(editedArgs);
+  const patchedToolCall = Object.freeze({
+    ...call.toolCall,
+    id: call.toolCall.id,
+    name: call.toolCall.name,
+    arguments: canonicalEditedToolInputJson(safeEditedArgs),
+  });
+  const patchedToolCalls = step.toolCalls.slice();
+  patchedToolCalls[position] = patchedToolCall;
+  const editedStep = {
+    ...step,
+    toolCalls: Object.freeze(patchedToolCalls),
+  };
+  const repreflight = preflightToolCall(editedStep, patchedToolCall);
+  if (repreflight === null || typeof repreflight !== 'object') {
+    fail('EDITED_REPREPARE_PREFLIGHT_INVALID', 'Edited tool preflight returned no result.');
+  }
+  if (repreflight.toolCall?.id !== call.toolCall.id || repreflight.toolCall?.name !== call.toolCall.name || repreflight.toolName !== call.toolName) {
+    fail('EDITED_REPREPARE_IDENTITY_CHANGED', 'Edited preflight changed the immutable tool identity.');
+  }
+  if (repreflight.kind === 'rejected') {
+    return Object.freeze({
+      kind: 'rejected',
+      step: editedStep,
+      call: repreflight,
+      editCount: 1,
+      output: repreflight.output,
+    });
+  }
+  if (repreflight.kind !== 'runnable') {
+    fail('EDITED_REPREPARE_PREFLIGHT_INVALID', 'Edited preflight returned an unsupported call state.');
+  }
+  if (repreflight.tool !== call.tool) {
+    fail('EDITED_REPREPARE_REGISTRY_CHANGED', 'The authoritative tool registry entry changed during edited approval.');
+  }
+  return Object.freeze({
+    kind: 'runnable',
+    step: editedStep,
+    call: repreflight,
+    editCount: 1,
+  });
+}
+
+module.exports = Object.freeze({
+  EditableToolReprepareError,
+  buildEditedToolCallPlan,
+});
+

package/bin/empty-response-retry-policy.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+const EMPTY_LENGTH_EFFORT_DOWNGRADE = Object.freeze({
+  max: 'high',
+  xhigh: 'high',
+  high: 'low',
+  medium: 'low',
+  low: 'off',
+  minimal: 'off',
+});
+
+function nextThinkingEffortForExhaustedEmpty(input = {}) {
+  const budget = Number(input.maxCompletionTokens);
+  const completion = Number(input.completionTokens);
+  if (
+    input.emptyResponseKind !== 'length'
+    || !Number.isFinite(budget)
+    || budget <= 0
+    || !Number.isFinite(completion)
+    || completion < budget
+  ) return undefined;
+
+  return EMPTY_LENGTH_EFFORT_DOWNGRADE[String(input.thinkingEffort || '').toLowerCase()];
+}
+
+module.exports = {
+  EMPTY_LENGTH_EFFORT_DOWNGRADE,
+  nextThinkingEffortForExhaustedEmpty,
+};

package/bin/history-offload-pressure-policy.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+const HISTORY_OFFLOAD_MIN_MESSAGES = 64;
+const HISTORY_OFFLOAD_MIN_CHARS = 1_000_000;
+
+function messageTextChars(message) {
+  if (!Array.isArray(message?.content)) return 0;
+  return message.content.reduce((total, part) => (
+    total + (part?.type === 'text' && typeof part.text === 'string' ? part.text.length : 0)
+  ), 0);
+}
+
+function historyTextChars(messages) {
+  if (!Array.isArray(messages)) return 0;
+  return messages.reduce((total, message) => total + messageTextChars(message), 0);
+}
+
+function hasHistoricalOffloadPressure(options = {}) {
+  const historyLength = Number(options.historyLength);
+  const historyChars = Number(options.historyChars);
+  return Number.isSafeInteger(historyLength)
+    && Number.isSafeInteger(historyChars)
+    && historyLength >= HISTORY_OFFLOAD_MIN_MESSAGES
+    && historyChars >= HISTORY_OFFLOAD_MIN_CHARS;
+}
+
+module.exports = {
+  HISTORY_OFFLOAD_MIN_CHARS,
+  HISTORY_OFFLOAD_MIN_MESSAGES,
+  hasHistoricalOffloadPressure,
+  historyTextChars,
+  messageTextChars,
+};

package/bin/html-to-research-markdown.cjs

@@ -0,0 +1,146 @@
+'use strict';
+
+const { Readability } = require('@mozilla/readability');
+const { parseHTML } = require('linkedom');
+const TurndownService = require('turndown');
+const { tables } = require('turndown-plugin-gfm');
+
+const MAX_LINK_LENGTH = 2_048;
+const JUNK_SELECTORS = Object.freeze([
+  'script',
+  'style',
+  'noscript',
+  'nav',
+  'footer',
+  'header',
+  'aside',
+  'iframe',
+  'svg',
+  'form',
+  'button',
+  'input',
+  '[role="navigation"]',
+  '[role="banner"]',
+  '[role="contentinfo"]',
+  '[aria-hidden="true"]',
+  '[hidden]',
+]);
+
+function canonicalBaseUrl(value) {
+  const parsed = new URL(value);
+  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+    throw new Error('HTML-to-Markdown base URL must use http or https.');
+  }
+  return parsed.toString();
+}
+
+function safeResolvedLink(raw, baseUrl) {
+  if (typeof raw !== 'string' || raw.trim().length === 0) return null;
+  let resolved;
+  try {
+    resolved = new URL(raw, baseUrl);
+  } catch {
+    return null;
+  }
+  if (resolved.protocol !== 'http:' && resolved.protocol !== 'https:') return null;
+  const value = resolved.toString();
+  return value.length <= MAX_LINK_LENGTH ? value : null;
+}
+
+function removeAll(root, selector) {
+  for (const element of root.querySelectorAll(selector)) element.remove();
+}
+
+function sanitizeTree(root, baseUrl) {
+  for (const selector of JUNK_SELECTORS) removeAll(root, selector);
+
+  for (const element of root.querySelectorAll('[style]')) {
+    const style = element.getAttribute('style') ?? '';
+    if (/display\s*:\s*none|visibility\s*:\s*hidden/iu.test(style)) element.remove();
+  }
+
+  for (const selector of [
+    'sup.reference',
+    'sup.noprint',
+    '.reflist',
+    '.references',
+    '.refbegin',
+    '.catlinks',
+    '.mw-authority-control',
+  ]) removeAll(root, selector);
+
+  for (const anchor of root.querySelectorAll('a[href]')) {
+    const safe = safeResolvedLink(anchor.getAttribute('href'), baseUrl);
+    if (safe === null) anchor.removeAttribute('href');
+    else anchor.setAttribute('href', safe);
+  }
+
+  for (const image of root.querySelectorAll('img')) {
+    const alt = (image.getAttribute('alt') ?? '').trim();
+    if (alt.length > 0) image.replaceWith(image.ownerDocument.createTextNode(alt));
+    else image.remove();
+  }
+}
+
+function createMarkdownService() {
+  const service = new TurndownService({
+    headingStyle: 'atx',
+    codeBlockStyle: 'fenced',
+    bulletListMarker: '-',
+  });
+  service.use(tables);
+  service.remove(['script', 'style', 'noscript', 'iframe', 'svg']);
+  return service;
+}
+
+function withTitle(title, markdown) {
+  const cleanTitle = title.trim();
+  if (cleanTitle.length === 0) return markdown;
+  const titleHeading = `# ${cleanTitle}`;
+  if (markdown === titleHeading || markdown.startsWith(`${titleHeading}\n`)) return markdown;
+  return `${titleHeading}\n\n${markdown}`;
+}
+
+function renderRoot(root, title, safeBaseUrl) {
+  sanitizeTree(root, safeBaseUrl);
+  const fallback = (root.textContent ?? '').replace(/\s+/gu, ' ').trim();
+  let markdown = createMarkdownService().turndown(root.innerHTML).trim();
+  if (markdown.length === 0) markdown = fallback;
+  markdown = markdown.replace(/\n{4,}/gu, '\n\n\n').trim();
+  return withTitle(title, markdown);
+}
+
+function htmlToResearchMarkdown(html, baseUrl) {
+  if (typeof html !== 'string' || html.trim().length === 0) return '';
+  const safeBaseUrl = canonicalBaseUrl(baseUrl);
+  const primary = parseHTML(html);
+  try {
+    const article = new Readability(primary.document, { charThreshold: 0 }).parse();
+    if (article !== null && (article.content ?? '').trim().length > 0) {
+      const extracted = parseHTML(article.content);
+      const extractedRoot = extracted.document.querySelector('body');
+      if (extractedRoot !== null) {
+        const markdown = renderRoot(extractedRoot, article.title ?? '', safeBaseUrl);
+        if (markdown.length > 0) return markdown;
+      }
+    }
+  } catch {
+    // Keep the existing fail-open container fallback.
+  }
+
+  const { document } = parseHTML(html);
+  const title = (document.querySelector('title')?.textContent ?? '').trim();
+  const root = document.querySelector('article')
+    ?? document.querySelector('main')
+    ?? document.querySelector('[role="main"]')
+    ?? document.querySelector('body');
+  return root === null ? '' : renderRoot(root, title, safeBaseUrl);
+}
+
+module.exports = Object.freeze({
+  JUNK_SELECTORS,
+  MAX_LINK_LENGTH,
+  canonicalBaseUrl,
+  htmlToResearchMarkdown,
+  safeResolvedLink,
+});

package/bin/programmatic-context-isolation.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+const PROGRAMMATIC_WIRE_ONLY = 'programmatic_nested';
+
+function isNestedToolEvent(event) {
+  return event?.type === 'tool.call' || event?.type === 'tool.result';
+}
+
+function markProgrammaticNestedEvent(event) {
+  if (!isNestedToolEvent(event)) return event;
+  return {
+    ...event,
+    contextVisibility: PROGRAMMATIC_WIRE_ONLY,
+  };
+}
+
+function isWireOnlyProgrammaticEvent(event) {
+  return isNestedToolEvent(event) && event.contextVisibility === PROGRAMMATIC_WIRE_ONLY;
+}
+
+module.exports = {
+  PROGRAMMATIC_WIRE_ONLY,
+  isWireOnlyProgrammaticEvent,
+  markProgrammaticNestedEvent,
+};