blun-king-cli 9.1.587 → 9.1.588

package/bin/durable-task-resume-store.cjs

@@ -1,88 +0,0 @@
-'use strict';
-
-const fs = require('node:fs/promises');
-const path = require('node:path');
-const {
-  TASK_ID_PATTERN,
-  contractError,
-  isResumeIntent,
-} = require('./durable-task-resume-policy.cjs');
-
-class DurableTaskResumeStore {
-  constructor(sessionDir) {
-    if (typeof sessionDir !== 'string' || sessionDir.length === 0) {
-      throw contractError('session directory is required', 'persistence');
-    }
-    this.directory = path.join(sessionDir, 'task-resume-intents');
-    this.intents = new Map();
-  }
-
-  fileFor(sourceTaskId) {
-    if (!TASK_ID_PATTERN.test(sourceTaskId)) throw contractError('source task ID is invalid');
-    return path.join(this.directory, `${sourceTaskId}.json`);
-  }
-
-  async load() {
-    this.intents.clear();
-    let names;
-    try {
-      names = await fs.readdir(this.directory);
-    } catch (error) {
-      if (error && error.code === 'ENOENT') return;
-      throw error;
-    }
-    for (const name of names) {
-      if (!name.endsWith('.json')) continue;
-      const sourceTaskId = name.slice(0, -5);
-      if (!TASK_ID_PATTERN.test(sourceTaskId)) continue;
-      try {
-        const intent = JSON.parse(await fs.readFile(this.fileFor(sourceTaskId), 'utf8'));
-        if (isResumeIntent(intent) && intent.sourceTaskId === sourceTaskId) {
-          this.intents.set(sourceTaskId, intent);
-        }
-      } catch {}
-    }
-  }
-
-  getBySourceTaskId(sourceTaskId) {
-    const intent = this.intents.get(sourceTaskId);
-    return intent === undefined ? undefined : { ...intent };
-  }
-
-  list() {
-    return [...this.intents.values()].map((intent) => ({ ...intent }));
-  }
-
-  startupRecoveryPlan() {
-    return [];
-  }
-
-  async write(intent) {
-    if (!isResumeIntent(intent)) throw contractError('resume intent is invalid', 'persistence');
-    await fs.mkdir(this.directory, { recursive: true, mode: 0o700 });
-    const target = this.fileFor(intent.sourceTaskId);
-    const temporary = `${target}.tmp-${process.pid}-${Date.now().toString(36)}`;
-    try {
-      const handle = await fs.open(temporary, 'wx', 0o600);
-      try {
-        await handle.writeFile(JSON.stringify(intent, null, 2), 'utf8');
-        await handle.sync();
-      } finally {
-        await handle.close();
-      }
-      await fs.rename(temporary, target);
-    } catch (error) {
-      await fs.rm(temporary, { force: true }).catch(() => {});
-      throw error;
-    }
-    this.intents.set(intent.sourceTaskId, { ...intent });
-  }
-
-  async markStarted(sourceTaskId, startedAt) {
-    const intent = this.intents.get(sourceTaskId);
-    if (!intent) throw contractError('prepared resume intent not found', 'persistence');
-    await this.write({ ...intent, status: 'started', startedAt });
-  }
-}
-
-module.exports = { DurableTaskResumeStore };

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

@@ -1,540 +0,0 @@
-'use strict';
-
-const {createHash} = require('node:crypto');
-
-const EDITABLE_TOOL_ALLOWLIST = Object.freeze([
-  'Bash',
-  'Read',
-  'Write',
-  'Edit',
-  'Glob',
-  'Grep',
-  'FetchURL',
-]);
-const EDITABLE_TOOL_ALLOWSET = new Set(EDITABLE_TOOL_ALLOWLIST);
-const DANGEROUS_KEYS = new Set(['__proto__', 'prototype', 'constructor']);
-const APPROVAL_RESPONSE_FIELDS = new Set([
-  'decision',
-  'scope',
-  'feedback',
-  'selected_label',
-  'edited_tool_input',
-  'edited_tool_input_json',
-]);
-const DECISIONS = new Set(['approved', 'rejected', 'cancelled', 'edited']);
-const DEFAULT_LIMITS = Object.freeze({
-  maxBytes: 65_536,
-  maxDepth: 16,
-  maxProperties: 256,
-  maxCollectionItems: 512,
-  maxDecodedStringChars: 32_768,
-  maxChangedFields: 32,
-});
-
-class EditableToolApprovalError extends Error {
-  constructor(code, message) {
-    super(message);
-    this.name = 'EditableToolApprovalError';
-    this.code = code;
-  }
-}
-
-function fail(code, message) {
-  throw new EditableToolApprovalError(code, message);
-}
-
-function resolveLimits(overrides = {}) {
-  if (overrides === null || typeof overrides !== 'object' || Array.isArray(overrides)) {
-    fail('EDITED_INPUT_LIMITS_INVALID', 'Edited input limits must be an object.');
-  }
-  const limits = {...DEFAULT_LIMITS};
-  for (const key of Object.keys(overrides)) {
-    if (!Object.hasOwn(DEFAULT_LIMITS, key)) {
-      fail('EDITED_INPUT_LIMITS_INVALID', `Unknown edited input limit: ${key}`);
-    }
-    const value = overrides[key];
-    if (!Number.isSafeInteger(value) || value < 0) {
-      fail('EDITED_INPUT_LIMITS_INVALID', `Edited input limit ${key} must be a non-negative safe integer.`);
-    }
-    if (value > DEFAULT_LIMITS[key]) {
-      fail('EDITED_INPUT_LIMIT_WIDENING_FORBIDDEN', `Edited input limit ${key} cannot exceed its production default.`);
-    }
-    limits[key] = value;
-  }
-  return limits;
-}
-
-function isEditableToolApprovalEligible(toolName) {
-  return typeof toolName === 'string' && EDITABLE_TOOL_ALLOWSET.has(toolName);
-}
-
-function validateUnicodeScalarString(value) {
-  for (let index = 0; index < value.length; index += 1) {
-    const code = value.charCodeAt(index);
-    if (code >= 0xd800 && code <= 0xdbff) {
-      const next = value.charCodeAt(index + 1);
-      if (!(next >= 0xdc00 && next <= 0xdfff)) {
-        fail('EDITED_INPUT_INVALID_UNICODE', 'Edited input contains an unpaired high surrogate.');
-      }
-      index += 1;
-    } else if (code >= 0xdc00 && code <= 0xdfff) {
-      fail('EDITED_INPUT_INVALID_UNICODE', 'Edited input contains an unpaired low surrogate.');
-    }
-  }
-}
-
-function createCounters(limits) {
-  return {
-    limits,
-    properties: 0,
-    collectionItems: 0,
-    decodedStringChars: 0,
-  };
-}
-
-function countString(counters, value) {
-  validateUnicodeScalarString(value);
-  counters.decodedStringChars += value.length;
-  if (counters.decodedStringChars > counters.limits.maxDecodedStringChars) {
-    fail('EDITED_INPUT_STRING_LIMIT', 'Edited input exceeds the decoded string limit.');
-  }
-}
-
-function countProperty(counters) {
-  counters.properties += 1;
-  counters.collectionItems += 1;
-  if (counters.properties > counters.limits.maxProperties) {
-    fail('EDITED_INPUT_PROPERTIES_LIMIT', 'Edited input exceeds the property limit.');
-  }
-  if (counters.collectionItems > counters.limits.maxCollectionItems) {
-    fail('EDITED_INPUT_COLLECTION_LIMIT', 'Edited input exceeds the collection item limit.');
-  }
-}
-
-function countArrayItem(counters) {
-  counters.collectionItems += 1;
-  if (counters.collectionItems > counters.limits.maxCollectionItems) {
-    fail('EDITED_INPUT_COLLECTION_LIMIT', 'Edited input exceeds the collection item limit.');
-  }
-}
-
-function assertDepth(counters, depth) {
-  if (depth > counters.limits.maxDepth) {
-    fail('EDITED_INPUT_DEPTH_LIMIT', 'Edited input exceeds the nesting depth limit.');
-  }
-}
-
-function parseEditedToolInputJson(rawJson, limitOverrides) {
-  if (typeof rawJson !== 'string') {
-    fail('EDITED_INPUT_INVALID_JSON', 'Edited tool input must be supplied as JSON text.');
-  }
-  const limits = resolveLimits(limitOverrides);
-  if (Buffer.byteLength(rawJson, 'utf8') > limits.maxBytes) {
-    fail('EDITED_INPUT_BYTES_LIMIT', 'Edited input exceeds the raw byte limit.');
-  }
-
-  const counters = createCounters(limits);
-  let cursor = 0;
-
-  function skipWhitespace() {
-    while (cursor < rawJson.length && /[\u0009\u000a\u000d\u0020]/.test(rawJson[cursor])) cursor += 1;
-  }
-
-  function parseString() {
-    if (rawJson[cursor] !== '"') fail('EDITED_INPUT_INVALID_JSON', 'Expected a JSON string.');
-    cursor += 1;
-    let output = '';
-    while (cursor < rawJson.length) {
-      const char = rawJson[cursor];
-      cursor += 1;
-      if (char === '"') {
-        countString(counters, output);
-        return output;
-      }
-      if (char === '\\') {
-        if (cursor >= rawJson.length) fail('EDITED_INPUT_INVALID_JSON', 'Unterminated JSON escape.');
-        const escape = rawJson[cursor];
-        cursor += 1;
-        const simple = {'"': '"', '\\': '\\', '/': '/', b: '\b', f: '\f', n: '\n', r: '\r', t: '\t'};
-        if (Object.hasOwn(simple, escape)) {
-          output += simple[escape];
-          continue;
-        }
-        if (escape !== 'u') fail('EDITED_INPUT_INVALID_JSON', 'Invalid JSON escape.');
-        const hex = rawJson.slice(cursor, cursor + 4);
-        if (!/^[0-9a-fA-F]{4}$/.test(hex)) fail('EDITED_INPUT_INVALID_JSON', 'Invalid JSON Unicode escape.');
-        cursor += 4;
-        const code = Number.parseInt(hex, 16);
-        if (code >= 0xd800 && code <= 0xdbff) {
-          if (rawJson.slice(cursor, cursor + 2) !== '\\u') {
-            fail('EDITED_INPUT_INVALID_UNICODE', 'Unpaired high surrogate in JSON escape.');
-          }
-          const lowHex = rawJson.slice(cursor + 2, cursor + 6);
-          if (!/^[0-9a-fA-F]{4}$/.test(lowHex)) fail('EDITED_INPUT_INVALID_JSON', 'Invalid low surrogate escape.');
-          const low = Number.parseInt(lowHex, 16);
-          if (!(low >= 0xdc00 && low <= 0xdfff)) {
-            fail('EDITED_INPUT_INVALID_UNICODE', 'Unpaired high surrogate in JSON escape.');
-          }
-          cursor += 6;
-          output += String.fromCodePoint(0x10000 + ((code - 0xd800) << 10) + (low - 0xdc00));
-        } else if (code >= 0xdc00 && code <= 0xdfff) {
-          fail('EDITED_INPUT_INVALID_UNICODE', 'Unpaired low surrogate in JSON escape.');
-        } else {
-          output += String.fromCharCode(code);
-        }
-        continue;
-      }
-      const code = char.charCodeAt(0);
-      if (code < 0x20) fail('EDITED_INPUT_INVALID_JSON', 'Unescaped control character in JSON string.');
-      if (code >= 0xd800 && code <= 0xdbff) {
-        const next = rawJson.charCodeAt(cursor);
-        if (!(next >= 0xdc00 && next <= 0xdfff)) {
-          fail('EDITED_INPUT_INVALID_UNICODE', 'Unpaired high surrogate in JSON string.');
-        }
-        output += char + rawJson[cursor];
-        cursor += 1;
-      } else if (code >= 0xdc00 && code <= 0xdfff) {
-        fail('EDITED_INPUT_INVALID_UNICODE', 'Unpaired low surrogate in JSON string.');
-      } else {
-        output += char;
-      }
-    }
-    fail('EDITED_INPUT_INVALID_JSON', 'Unterminated JSON string.');
-  }
-
-  function parseNumber() {
-    const remainder = rawJson.slice(cursor);
-    const match = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/.exec(remainder);
-    if (!match) fail('EDITED_INPUT_INVALID_JSON', 'Invalid JSON number.');
-    cursor += match[0].length;
-    const value = Number(match[0]);
-    if (!Number.isFinite(value)) fail('EDITED_INPUT_NONFINITE_NUMBER', 'Edited input number must be finite.');
-    return value;
-  }
-
-  function parseArray(depth) {
-    assertDepth(counters, depth);
-    cursor += 1;
-    const output = [];
-    skipWhitespace();
-    if (rawJson[cursor] === ']') {
-      cursor += 1;
-      Object.setPrototypeOf(output, null);
-      return Object.freeze(output);
-    }
-    while (true) {
-      countArrayItem(counters);
-      output[output.length] = parseValue(depth + 1);
-      skipWhitespace();
-      if (rawJson[cursor] === ']') {
-        cursor += 1;
-        Object.setPrototypeOf(output, null);
-        return Object.freeze(output);
-      }
-      if (rawJson[cursor] !== ',') fail('EDITED_INPUT_INVALID_JSON', 'Expected comma or array end.');
-      cursor += 1;
-      skipWhitespace();
-    }
-  }
-
-  function parseObject(depth) {
-    assertDepth(counters, depth);
-    cursor += 1;
-    const output = Object.create(null);
-    const keys = new Set();
-    skipWhitespace();
-    if (rawJson[cursor] === '}') {
-      cursor += 1;
-      return Object.freeze(output);
-    }
-    while (true) {
-      if (rawJson[cursor] !== '"') fail('EDITED_INPUT_INVALID_JSON', 'Expected an object key.');
-      const key = parseString();
-      if (DANGEROUS_KEYS.has(key)) fail('EDITED_INPUT_DANGEROUS_KEY', `Dangerous edited input key: ${key}`);
-      if (keys.has(key)) fail('EDITED_INPUT_DUPLICATE_KEY', `Duplicate edited input key: ${key}`);
-      keys.add(key);
-      countProperty(counters);
-      skipWhitespace();
-      if (rawJson[cursor] !== ':') fail('EDITED_INPUT_INVALID_JSON', 'Expected colon after object key.');
-      cursor += 1;
-      output[key] = parseValue(depth + 1);
-      skipWhitespace();
-      if (rawJson[cursor] === '}') {
-        cursor += 1;
-        return Object.freeze(output);
-      }
-      if (rawJson[cursor] !== ',') fail('EDITED_INPUT_INVALID_JSON', 'Expected comma or object end.');
-      cursor += 1;
-      skipWhitespace();
-    }
-  }
-
-  function parseValue(depth) {
-    skipWhitespace();
-    const char = rawJson[cursor];
-    if (char === '{') return parseObject(depth);
-    if (char === '[') return parseArray(depth);
-    if (char === '"') return parseString();
-    if (char === '-' || (char >= '0' && char <= '9')) return parseNumber();
-    if (rawJson.startsWith('true', cursor)) {
-      cursor += 4;
-      return true;
-    }
-    if (rawJson.startsWith('false', cursor)) {
-      cursor += 5;
-      return false;
-    }
-    if (rawJson.startsWith('null', cursor)) {
-      cursor += 4;
-      return null;
-    }
-    fail('EDITED_INPUT_INVALID_JSON', 'Invalid JSON value.');
-  }
-
-  skipWhitespace();
-  const value = parseValue(1);
-  skipWhitespace();
-  if (cursor !== rawJson.length) fail('EDITED_INPUT_TRAILING_CONTENT', 'Edited input has trailing content.');
-  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
-    fail('EDITED_INPUT_OBJECT_REQUIRED', 'Edited tool input must be a top-level JSON object.');
-  }
-  return value;
-}
-
-function validateEditedToolInputObject(input, limitOverrides) {
-  const limits = resolveLimits(limitOverrides);
-  const counters = createCounters(limits);
-
-  function clone(value, depth) {
-    if (value === null || typeof value === 'boolean') return value;
-    if (typeof value === 'string') {
-      countString(counters, value);
-      return value;
-    }
-    if (typeof value === 'number') {
-      if (!Number.isFinite(value)) fail('EDITED_INPUT_NONFINITE_NUMBER', 'Edited input number must be finite.');
-      return value;
-    }
-    if (value === undefined) fail('EDITED_INPUT_UNDEFINED_REJECTED', 'Undefined is not valid edited JSON input.');
-    if (typeof value === 'function' || typeof value === 'bigint') {
-      fail('EDITED_INPUT_EXECUTABLE_REJECTED', 'Executable or non-JSON values are forbidden in edited input.');
-    }
-    if (typeof value === 'symbol') fail('EDITED_INPUT_SYMBOL_REJECTED', 'Symbols are forbidden in edited input.');
-
-    assertDepth(counters, depth);
-    const symbols = Object.getOwnPropertySymbols(value);
-    if (symbols.length > 0) fail('EDITED_INPUT_SYMBOL_REJECTED', 'Symbol keys are forbidden in edited input.');
-    const descriptors = Object.getOwnPropertyDescriptors(value);
-
-    if (Array.isArray(value)) {
-      const prototype = Object.getPrototypeOf(value);
-      if (prototype !== Array.prototype && prototype !== null) {
-        fail('EDITED_INPUT_PROTOTYPE_REJECTED', 'Foreign array prototypes are forbidden in edited input.');
-      }
-      const output = [];
-      for (const key of Reflect.ownKeys(descriptors)) {
-        if (key === 'length') continue;
-        if (typeof key !== 'string' || !/^(?:0|[1-9]\d*)$/.test(key) || Number(key) >= value.length) {
-          fail('EDITED_INPUT_ARRAY_PROPERTY_REJECTED', 'Non-index array properties are forbidden in edited input.');
-        }
-      }
-      for (let index = 0; index < value.length; index += 1) {
-        const descriptor = descriptors[String(index)];
-        if (!descriptor) fail('EDITED_INPUT_ARRAY_HOLE_REJECTED', 'Sparse arrays are forbidden in edited input.');
-        if (!Object.hasOwn(descriptor, 'value')) {
-          fail('EDITED_INPUT_ACCESSOR_REJECTED', 'Accessors are forbidden in edited input.');
-        }
-        countArrayItem(counters);
-        output[index] = clone(descriptor.value, depth + 1);
-      }
-      Object.setPrototypeOf(output, null);
-      return Object.freeze(output);
-    }
-
-    const prototype = Object.getPrototypeOf(value);
-    if (prototype !== Object.prototype && prototype !== null) {
-      fail('EDITED_INPUT_PROTOTYPE_REJECTED', 'Foreign object prototypes are forbidden in edited input.');
-    }
-    const output = Object.create(null);
-    for (const key of Reflect.ownKeys(descriptors)) {
-      if (typeof key !== 'string') fail('EDITED_INPUT_SYMBOL_REJECTED', 'Symbol keys are forbidden in edited input.');
-      if (DANGEROUS_KEYS.has(key)) fail('EDITED_INPUT_DANGEROUS_KEY', `Dangerous edited input key: ${key}`);
-      const descriptor = descriptors[key];
-      if (!Object.hasOwn(descriptor, 'value')) {
-        fail('EDITED_INPUT_ACCESSOR_REJECTED', 'Accessors are forbidden in edited input.');
-      }
-      if (!descriptor.enumerable) {
-        fail('EDITED_INPUT_NONENUMERABLE_REJECTED', 'Non-enumerable properties are forbidden in edited input.');
-      }
-      countString(counters, key);
-      countProperty(counters);
-      output[key] = clone(descriptor.value, depth + 1);
-    }
-    return Object.freeze(output);
-  }
-
-  if (input === null || typeof input !== 'object' || Array.isArray(input)) {
-    fail('EDITED_INPUT_OBJECT_REQUIRED', 'Edited tool input must be a top-level object.');
-  }
-  const output = clone(input, 1);
-  if (Buffer.byteLength(canonicalValueJson(output), 'utf8') > limits.maxBytes) {
-    fail('EDITED_INPUT_BYTES_LIMIT', 'Edited input exceeds the canonical byte limit.');
-  }
-  return output;
-}
-
-function readApprovalResponse(response) {
-  if (response === null || typeof response !== 'object' || Array.isArray(response)) {
-    fail('EDITED_APPROVAL_RESPONSE_INVALID', 'Approval response must be an object.');
-  }
-  const prototype = Object.getPrototypeOf(response);
-  if (prototype !== Object.prototype && prototype !== null) {
-    fail('EDITED_APPROVAL_RESPONSE_INVALID', 'Approval response must have a plain prototype.');
-  }
-  if (Object.getOwnPropertySymbols(response).length > 0) {
-    fail('EDITED_APPROVAL_UNKNOWN_FIELD', 'Approval response symbol fields are forbidden.');
-  }
-  const descriptors = Object.getOwnPropertyDescriptors(response);
-  const values = Object.create(null);
-  for (const key of Object.keys(descriptors)) {
-    if (!APPROVAL_RESPONSE_FIELDS.has(key)) {
-      fail('EDITED_APPROVAL_UNKNOWN_FIELD', `Unknown approval response field: ${key}`);
-    }
-    const descriptor = descriptors[key];
-    if (!Object.hasOwn(descriptor, 'value')) {
-      fail('EDITED_APPROVAL_RESPONSE_INVALID', 'Approval response accessors are forbidden.');
-    }
-    values[key] = descriptor.value;
-  }
-  return {descriptors, values};
-}
-
-function validateEditedApprovalDecision({response, toolName, editCount, limits} = {}) {
-  const {descriptors, values} = readApprovalResponse(response);
-  if (!DECISIONS.has(values.decision)) {
-    fail('EDITED_APPROVAL_DECISION_INVALID', 'Unknown approval decision.');
-  }
-  if (!Number.isSafeInteger(editCount) || editCount < 0) {
-    fail('EDITED_APPROVAL_EDIT_COUNT_INVALID', 'Edit count must be a non-negative safe integer.');
-  }
-  const hasObjectInput = Object.hasOwn(descriptors, 'edited_tool_input');
-  const hasJsonInput = Object.hasOwn(descriptors, 'edited_tool_input_json');
-
-  if (values.decision !== 'edited') {
-    if (hasObjectInput || hasJsonInput) {
-      fail('EDITED_APPROVAL_INPUT_FORBIDDEN', 'Edited tool input is only valid for an edited decision.');
-    }
-    return Object.freeze({
-      decision: values.decision,
-      ...(Object.hasOwn(descriptors, 'scope') ? {scope: values.scope} : {}),
-      ...(Object.hasOwn(descriptors, 'feedback') ? {feedback: values.feedback} : {}),
-      ...(Object.hasOwn(descriptors, 'selected_label') ? {selectedLabel: values.selected_label} : {}),
-    });
-  }
-
-  if (!isEditableToolApprovalEligible(toolName)) {
-    fail('EDITED_APPROVAL_TOOL_INELIGIBLE', `Tool ${String(toolName)} does not allow edited approval.`);
-  }
-  if (editCount !== 0) fail('EDITED_APPROVAL_ALREADY_EDITED', 'A tool call may be edited at most once.');
-  if (Object.hasOwn(descriptors, 'scope')) {
-    fail('EDITED_APPROVAL_SCOPE_FORBIDDEN', 'Edited approval cannot create session scope.');
-  }
-  if (hasObjectInput === hasJsonInput) {
-    fail('EDITED_APPROVAL_INPUT_REQUIRED', 'Edited approval requires exactly one edited input representation.');
-  }
-  const editedToolInput = hasJsonInput
-    ? parseEditedToolInputJson(values.edited_tool_input_json, limits)
-    : validateEditedToolInputObject(values.edited_tool_input, limits);
-  return Object.freeze({decision: 'edited', editedToolInput});
-}
-
-function canonicalEditedToolInputJson(input) {
-  const safeInput = validateEditedToolInputObject(input);
-  function encode(value) {
-    if (value === null) return 'null';
-    if (typeof value === 'string' || typeof value === 'boolean' || typeof value === 'number') {
-      return JSON.stringify(value);
-    }
-    if (Array.isArray(value)) return `[${Array.from(value, encode).join(',')}]`;
-    const keys = Object.keys(value).sort();
-    return `{${keys.map((key) => `${JSON.stringify(key)}:${encode(value[key])}`).join(',')}}`;
-  }
-  return encode(safeInput);
-}
-
-function hashEditedToolInput(input) {
-  return createHash('sha256').update(canonicalEditedToolInputJson(input), 'utf8').digest('hex');
-}
-
-function changedTopLevelFields(originalArgs, editedArgs) {
-  const keys = new Set([...Object.keys(originalArgs), ...Object.keys(editedArgs)]);
-  const changed = [];
-  for (const key of keys) {
-    const originalHas = Object.hasOwn(originalArgs, key);
-    const editedHas = Object.hasOwn(editedArgs, key);
-    if (originalHas !== editedHas) {
-      changed.push(key);
-      continue;
-    }
-    const originalValue = originalArgs[key];
-    const editedValue = editedArgs[key];
-    const originalJson = canonicalValueJson(originalValue);
-    const editedJson = canonicalValueJson(editedValue);
-    if (originalJson !== editedJson) changed.push(key);
-  }
-  return changed.sort();
-}
-
-function canonicalValueJson(value) {
-  if (value === null) return 'null';
-  if (typeof value === 'string' || typeof value === 'boolean' || typeof value === 'number') return JSON.stringify(value);
-  if (Array.isArray(value)) return `[${Array.from(value, canonicalValueJson).join(',')}]`;
-  const keys = Object.keys(value).sort();
-  return `{${keys.map((key) => `${JSON.stringify(key)}:${canonicalValueJson(value[key])}`).join(',')}}`;
-}
-
-function buildApprovalEditedEvent({
-  turnId,
-  toolCallId,
-  toolName,
-  originalArgs,
-  editedArgs,
-  maxChangedFields = DEFAULT_LIMITS.maxChangedFields,
-} = {}) {
-  if (!Number.isSafeInteger(turnId) || turnId < 0 || typeof toolCallId !== 'string' || toolCallId.length === 0 || toolCallId.length > 512) {
-    fail('EDITED_EVENT_IDENTITY_INVALID', 'Approval edited event identity is invalid.');
-  }
-  if (!isEditableToolApprovalEligible(toolName)) {
-    fail('EDITED_APPROVAL_TOOL_INELIGIBLE', `Tool ${String(toolName)} does not allow edited approval.`);
-  }
-  if (!Number.isSafeInteger(maxChangedFields) || maxChangedFields < 0 || maxChangedFields > DEFAULT_LIMITS.maxChangedFields) {
-    fail('EDITED_EVENT_CHANGED_FIELDS_LIMIT_INVALID', 'Changed-field limit is invalid.');
-  }
-  const safeOriginal = validateEditedToolInputObject(originalArgs);
-  const safeEdited = validateEditedToolInputObject(editedArgs);
-  const allChangedFields = changedTopLevelFields(safeOriginal, safeEdited);
-  const changedFields = Object.freeze(allChangedFields.slice(0, maxChangedFields));
-  return Object.freeze({
-    type: 'permission.approval_edited',
-    turnId,
-    toolCallId,
-    toolName,
-    originalArgsSha256: hashEditedToolInput(safeOriginal),
-    editedArgsSha256: hashEditedToolInput(safeEdited),
-    changedFields,
-    ...(allChangedFields.length > changedFields.length ? {changedFieldsTruncated: true} : {}),
-  });
-}
-
-module.exports = Object.freeze({
-  DEFAULT_LIMITS,
-  EDITABLE_TOOL_ALLOWLIST,
-  EditableToolApprovalError,
-  buildApprovalEditedEvent,
-  canonicalEditedToolInputJson,
-  hashEditedToolInput,
-  isEditableToolApprovalEligible,
-  parseEditedToolInputJson,
-  validateEditedApprovalDecision,
-  validateEditedToolInputObject,
-});