@7n/test 0.11.1 → 0.11.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [0.11.2] - 2026-07-04
+
+### Fixed
+
+- 🤖 fix(core): кап runtime-probe виходів (shape-summary + tmp-cwd) і bounded backoff на omlx memory-guard замість миттєвого падіння
+
 ## [0.11.1] - 2026-07-04
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@7n/test",
-  "version": "0.11.1",
+  "version": "0.11.2",
   "description": "CLI-утиліта @7n/test",
   "keywords": [
     "7n",

package/src/lib/pi-client.mjs

@@ -9,11 +9,15 @@
  * Both retry transient connection failures (e.g. a shared local model server
  * that's momentarily busy under concurrent load) with exponential backoff
  * instead of failing the caller's file on the first hiccup. A memory-guard
- * rejection (the shared machine can't fit the prompt in RAM) is not
- * retryable — retrying against a fixed RAM ceiling can't succeed, so it
- * prints the request body to stdout and terminates the process instead.
+ * rejection gets its own longer bounded backoff: oMLX обслуговує один промпт
+ * одночасно, тож відмова зазвичай відображає залишкову пам'ять попереднього
+ * запиту, яку сервер вивільняє сам за десятки секунд. Лише після
+ * `N_PI_MEMORY_RETRY_ATTEMPTS` невдач тіло запиту друкується в stdout і
+ * помилка прокидається як термінальна (виклики-власники процесу мають дати
+ * їй впасти, не ковтати як звичайну per-file помилку).
  */
 import { createAgentSession, SessionManager, ModelRegistry, AuthStorage } from '@earendil-works/pi-coding-agent'
+import { randomInt } from 'node:crypto'
 import { env } from 'node:process'
 import { setTimeout as sleep } from 'node:timers/promises'
 
@@ -33,43 +37,96 @@ export const MEMORY_ERROR_RE = /memory guard|memory limit|prefill would require/
 const MAX_ATTEMPTS = Number(env.N_PI_RETRY_ATTEMPTS) || 4
 const BASE_DELAY_MS = Number(env.N_PI_RETRY_DELAY_MS) || 1500
 const MAX_DELAY_MS = 15_000
+/** Скільки разів пробуємо промпт, відкинутий memory guard (включно з першою спробою). */
+const MEMORY_MAX_ATTEMPTS = Number(env.N_PI_MEMORY_RETRY_ATTEMPTS) || 3
+/** Базова затримка перед повтором після memory-guard відмови (експоненційно: 15s → 30s → …). */
+const MEMORY_BASE_DELAY_MS = Number(env.N_PI_MEMORY_RETRY_DELAY_MS) || 15_000
+const MEMORY_MAX_DELAY_MS = 60_000
 
 /**
- * Prints the request body that triggered a memory-guard rejection to stdout
- * and throws — there's no RAM to retry into. Callers that own the process
- * lifecycle (CLI entrypoints) must let this propagate uncaught instead of
- * swallowing it like a normal per-file error, so the process exits instead
- * of quietly continuing against a RAM ceiling that won't change.
- * @param {Error} error the memory-guard error thrown by the model server
- * @param {string} requestBody prompt sent to the model
- * @returns {never} always throws
+ * Витягує структуровані поля oMLX-помилки з тексту повідомлення, якщо тіло
+ * 400 (`omlx_code`/`estimated_bytes`/`limit_bytes`) потрапило в message.
+ * `estimated_bytes`/`limit_bytes` — байти GPU/Metal-пам'яті сервера,
+ * ТІЛЬКИ для діагностики й логів (не «скільки символів промпту зрізати»).
+ * @param {string} message текст помилки від SDK/сервера
+ * @returns {{omlxCode?: string, estimatedBytes?: number, limitBytes?: number} | null} знайдені поля або `null`
+ */
+function parseOmlxErrorDetails(message) {
+  const code = /"(?:omlx_)?code"\s*:\s*"([^"]+)"/.exec(message)?.[1]
+  const estimated = /"estimated_bytes"\s*:\s*(\d+)/.exec(message)?.[1]
+  const limit = /"limit_bytes"\s*:\s*(\d+)/.exec(message)?.[1]
+  if (!code && !estimated && !limit) return null
+  const details = {}
+  if (code) details.omlxCode = code
+  if (estimated) details.estimatedBytes = Number(estimated)
+  if (limit) details.limitBytes = Number(limit)
+  return details
+}
+
+/**
+ * Розпізнає memory-guard відмову і збагачує помилку структурованими полями
+ * (`omlxCode`, `estimatedBytes`, `limitBytes`), коли вони доступні в message.
+ * @param {Error} error помилка з виклику моделі
+ * @returns {boolean} `true`, якщо це memory-guard відмова
+ */
+function isMemoryGuardError(error) {
+  const details = parseOmlxErrorDetails(error.message ?? '')
+  if (details) Object.assign(error, details)
+  return error.omlxCode === 'prefill_memory_exceeded' || MEMORY_ERROR_RE.test(error.message ?? '')
+}
+
+/**
+ * Термінальний вихід після вичерпання memory-retry: друкує тіло запиту в
+ * stdout (лише тут — не на проміжних спробах) і кидає помилку далі,
+ * зберігаючи структуровані поля й оригінал у `cause`. Виклики-власники
+ * процесу (CLI) мають дати їй впасти, не ковтати як per-file помилку.
+ * @param {Error} error memory-guard помилка останньої спроби
+ * @param {string} requestBody промпт, надісланий моделі
+ * @returns {never} завжди кидає
  */
 function failOnMemoryGuard(error, requestBody) {
   console.log('--- omlx memory-guard: тіло запиту ---')
   console.log(requestBody)
   console.log(`✗ omlx memory-guard: ${error.message}`)
-  throw new Error(`omlx memory-guard: ${error.message}`)
+  const wrapped = new Error(`omlx memory-guard: ${error.message}`, { cause: error })
+  for (const key of ['omlxCode', 'estimatedBytes', 'limitBytes']) {
+    if (error[key] !== undefined) wrapped[key] = error[key]
+  }
+  throw wrapped
 }
 
 /**
  * Retries `fn` with exponential backoff + jitter when it throws a transient
  * connection-ish error (shared local model server busy/restarting); other
  * errors (auth, malformed request) are re-thrown immediately. A memory-guard
- * rejection throws via `failOnMemoryGuard` instead of retrying — see its docs.
+ * rejection has its own bounded schedule (`MEMORY_MAX_ATTEMPTS` спроб,
+ * затримки від `MEMORY_BASE_DELAY_MS` експоненційно): одно-слотова черга
+ * oMLX вивільняє залишкову пам'ять попереднього запиту сама, тож повтор
+ * того самого промпту після паузи легітимний. Після вичерпання —
+ * `failOnMemoryGuard` (друк тіла + термінальний throw).
  * @template T
  * @param {() => Promise<T>} fn operation to retry
- * @param {string} requestBody prompt sent to the model, printed if a memory-guard error terminates the process
+ * @param {string} requestBody prompt sent to the model, printed if a memory-guard error exhausts its retries
  * @returns {Promise<T>} result of the first successful attempt
  */
 async function withRetry(fn, requestBody) {
-  for (let attempt = 1; ; attempt++) {
+  let memoryAttempts = 0
+  let connAttempts = 0
+  for (;;) {
     try {
       return await fn()
     } catch (error) {
-      if (MEMORY_ERROR_RE.test(error.message ?? '')) failOnMemoryGuard(error, requestBody)
-      if (attempt >= MAX_ATTEMPTS || !RETRYABLE_ERROR_RE.test(error.message ?? '')) throw error
-      const delay = Math.min(BASE_DELAY_MS * 2 ** (attempt - 1), MAX_DELAY_MS)
-      const jitter = delay * (0.5 + Math.random() * 0.5)
+      if (isMemoryGuardError(error)) {
+        memoryAttempts++
+        if (memoryAttempts >= MEMORY_MAX_ATTEMPTS) failOnMemoryGuard(error, requestBody)
+        const delay = Math.min(MEMORY_BASE_DELAY_MS * 2 ** (memoryAttempts - 1), MEMORY_MAX_DELAY_MS)
+        await sleep(delay * (0.5 + randomInt(5000) / 10000))
+        continue
+      }
+      connAttempts++
+      if (connAttempts >= MAX_ATTEMPTS || !RETRYABLE_ERROR_RE.test(error.message ?? '')) throw error
+      const delay = Math.min(BASE_DELAY_MS * 2 ** (connAttempts - 1), MAX_DELAY_MS)
+      const jitter = delay * (0.5 + randomInt(5000) / 10000)
       await sleep(jitter)
     }
   }

package/src/lib/runtime-probe.mjs

@@ -9,10 +9,26 @@
  * 4. probeHelpers — extracts non-exported helper functions from source and calls them
  *    with generic param combos to reveal their actual output shapes.
  */
-import { readFileSync } from 'node:fs'
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs'
 import { spawnSync } from 'node:child_process'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
 
 const PROBE_TIMEOUT_MS = 10_000
+/**
+ * Кап на серіалізований probe-вихід (символів). Довший вихід замінюється
+ * shape-summary — стислим описом форми замість значення: гігантський дамп
+ * (напр. функція, що читає файл проєкту) інакше роздуває LLM-промпт до
+ * сотень тисяч символів і впирається в memory guard моделі, а обрізаний
+ * JSON модель копіює в expected як сміття.
+ */
+const PROBE_OUTPUT_MAX_CHARS = 600
+/** Максимум probe-рядків на один export — багато середніх виходів теж не мають роздувати промпт. */
+const PROBE_MAX_ENTRIES_PER_EXPORT = 12
+/** Глибина рекурсії shape-summary. */
+const SHAPE_MAX_DEPTH = 4
+/** Скільки ключів об'єкта показує shape-summary до «…». */
+const SHAPE_MAX_KEYS = 8
 
 /** Generic argument combos to try when probing async/fetch functions. */
 const FETCH_ARG_COMBOS = [
@@ -70,6 +86,97 @@ const PROBE_INPUTS = [
   ['42', '42']
 ]
 
+/**
+ * Рекурсивно описує форму значення без самих даних.
+ * @param {unknown} value розпарсене JSON-значення
+ * @param {number} [depth] залишкова глибина рекурсії; за замовчуванням `SHAPE_MAX_DEPTH`
+ * @returns {string} стислий опис форми, напр. `Array(34) of {file: string, mutants: Array(12)}`
+ */
+export function describeShape(value, depth = SHAPE_MAX_DEPTH) {
+  if (value === null) return 'null'
+  if (Array.isArray(value)) {
+    if (value.length === 0) return 'Array(0)'
+    if (depth <= 0) return `Array(${value.length})`
+    return `Array(${value.length}) of ${describeShape(value[0], depth - 1)}`
+  }
+  const type = typeof value
+  if (type === 'object') {
+    const keys = Object.keys(value)
+    if (depth <= 0 || keys.length === 0) return 'Object'
+    const shown = keys.slice(0, SHAPE_MAX_KEYS)
+    const inner =
+      depth > 1 ? shown.map(k => `${k}: ${describeShape(value[k], depth - 1)}`).join(', ') : shown.join(', ')
+    return `{${inner}${keys.length > shown.length ? ', …' : ''}}`
+  }
+  if (type === 'string') return 'string'
+  return type
+}
+
+/**
+ * Обмежує серіалізований probe-вихід: до `PROBE_OUTPUT_MAX_CHARS` — без змін,
+ * довший — shape-summary замість значення (модель бачить структуру для
+ * asserts на форму, але не тягне дамп у промпт і не копіює його в expected).
+ * @param {string} serialized JSON-серіалізований вихід probe
+ * @returns {string} оригінал або `[shape-summary, ~N chars] <форма>`
+ */
+export function capProbeOutput(serialized) {
+  if (typeof serialized !== 'string' || serialized.length <= PROBE_OUTPUT_MAX_CHARS) return serialized
+  let shape
+  try {
+    shape = describeShape(JSON.parse(serialized))
+  } catch {
+    shape = 'string'
+  }
+  const summary = `[shape-summary, ~${serialized.length} chars] ${shape}`
+  return summary.length > PROBE_OUTPUT_MAX_CHARS ? `${summary.slice(0, PROBE_OUTPUT_MAX_CHARS - 1)}…` : summary
+}
+
+/**
+ * Застосовує кап виходів і ліміт кількості рядків до результатів `probeModule`.
+ * @param {Record<string, Array<{input: string, output: string}> | {constant: string}>} results сирі результати з дочірнього процесу
+ * @returns {typeof results} результати з capped-виходами
+ */
+function capModuleResults(results) {
+  const capped = {}
+  for (const [name, section] of Object.entries(results)) {
+    if (Array.isArray(section)) {
+      capped[name] = section
+        .slice(0, PROBE_MAX_ENTRIES_PER_EXPORT)
+        .map(entry => ({ ...entry, output: capProbeOutput(entry.output) }))
+    } else if (section && typeof section === 'object' && 'constant' in section) {
+      capped[name] = { constant: capProbeOutput(section.constant) }
+    } else {
+      capped[name] = section
+    }
+  }
+  return capped
+}
+
+/**
+ * Запускає node з probe-скриптом у порожній тимчасовій cwd: відносні
+ * I/O-читання probe-ованих функцій (напр. `readFile('COVERAGE.md')` при
+ * порожньому аргументі шляху) не бачать файлів проєкту — вихід
+ * детермінований між машинами і не може випадково затягнути великий
+ * файл репозиторію у LLM-промпт.
+ * @param {string} script код для виконання
+ * @param {number} [timeout] ліміт очікування в мс; за замовчуванням `PROBE_TIMEOUT_MS`
+ * @returns {import('node:child_process').SpawnSyncReturns<string>} результат spawnSync
+ */
+function spawnProbe(script, timeout = PROBE_TIMEOUT_MS) {
+  const cwd = mkdtempSync(join(tmpdir(), 'n-probe-'))
+  try {
+    return spawnSync('node', ['--input-type=module'], {
+      input: script,
+      encoding: 'utf8',
+      timeout,
+      env: { ...process.env },
+      cwd
+    })
+  } finally {
+    rmSync(cwd, { recursive: true, force: true })
+  }
+}
+
 /**
  * Пробує експорти модуля у дочірньому процесі й повертає фактичні виходи.
  * @param {string} absFilePath абсолютний шлях до джерела модуля
@@ -122,18 +229,13 @@ for (const name of names) {
 process.stdout.write(JSON.stringify(results))
 `
 
-  const proc = spawnSync('node', ['--input-type=module'], {
-    input: script,
-    encoding: 'utf8',
-    timeout: PROBE_TIMEOUT_MS,
-    env: { ...process.env }
-  })
+  const proc = spawnProbe(script)
 
   if (!proc.stdout) return {}
   try {
     const parsed = JSON.parse(proc.stdout)
     if (parsed.__importError) return {}
-    return parsed
+    return capModuleResults(parsed)
   } catch {
     return {}
   }
@@ -150,12 +252,7 @@ process.stdout.write(JSON.stringify(results))
  * @returns {Record<string, unknown> | null} розпарсений JSON або `null` при помилці
  */
 function runProbeScript(script, timeout = PROBE_TIMEOUT_MS) {
-  const proc = spawnSync('node', ['--input-type=module'], {
-    input: script,
-    encoding: 'utf8',
-    timeout,
-    env: { ...process.env }
-  })
+  const proc = spawnProbe(script, timeout)
   if (!proc.stdout) return null
   try {
     const parsed = JSON.parse(proc.stdout)
@@ -211,6 +308,33 @@ process.stdout.write(JSON.stringify(results))
   return runProbeScript(script) ?? {}
 }
 
+/**
+ * Застосовує кап до результатів `probeHelpers`: завеликий `result`
+ * замінюється shape-summary рядком, кількість комбо на helper обмежується.
+ * @param {Record<string, Array<{params: Record<string, unknown>, result: unknown}>>} results сирі результати helper-probe
+ * @returns {typeof results} результати з capped-виходами
+ */
+function capHelperResults(results) {
+  const capped = {}
+  for (const [name, entries] of Object.entries(results)) {
+    if (!Array.isArray(entries)) {
+      capped[name] = entries
+      continue
+    }
+    capped[name] = entries.slice(0, PROBE_MAX_ENTRIES_PER_EXPORT).map(entry => {
+      let serialized
+      try {
+        serialized = JSON.stringify(entry.result)
+      } catch {
+        return entry
+      }
+      if (typeof serialized !== 'string' || serialized.length <= PROBE_OUTPUT_MAX_CHARS) return entry
+      return { ...entry, result: capProbeOutput(serialized) }
+    })
+  }
+  return capped
+}
+
 // ---------------------------------------------------------------------------
 // Probe 3: time-variant detection
 // ---------------------------------------------------------------------------
@@ -386,5 +510,5 @@ for (const name of ${names}) {
 }
 process.stdout.write(JSON.stringify(results))
 `
-  return runProbeScript(script) ?? {}
+  return capHelperResults(runProbeScript(script) ?? {})
 }