audrey 1.0.0 → 1.0.2

package/benchmarks/perf-snapshot.js

@@ -157,8 +157,8 @@ function parseArgs(argv = process.argv.slice(2)) {
     if (token === '--sizes' && argv[i + 1]) {
       args.sizes = argv[++i]
         .split(',')
-        .map((s) => Number.parseInt(s.trim(), 10))
-        .filter((n) => Number.isFinite(n) && n > 0);
+        .map(s => Number.parseInt(s.trim(), 10))
+        .filter(n => Number.isFinite(n) && n > 0);
     } else if (token === '--recall-runs' && argv[i + 1]) {
       args.recallRuns = Number.parseInt(argv[++i], 10);
     } else if (token === '--out' && argv[i + 1]) {
@@ -180,7 +180,7 @@ async function runOneSize({ size, recallRuns }) {
   });
 
   const queueProcessingTimes = [];
-  audrey.on('post-encode-complete', (event) => {
+  audrey.on('post-encode-complete', event => {
     queueProcessingTimes.push(event.processing_ms);
   });
 
@@ -223,7 +223,10 @@ async function runOneSize({ size, recallRuns }) {
   }
 }
 
-export async function runPerfSnapshot({ sizes = DEFAULT_SIZES, recallRuns = DEFAULT_RECALL_RUNS } = {}) {
+export async function runPerfSnapshot({
+  sizes = DEFAULT_SIZES,
+  recallRuns = DEFAULT_RECALL_RUNS,
+} = {}) {
   const startedAt = Date.now();
   const sized = [];
   for (const size of sizes) {
@@ -265,11 +268,11 @@ export function formatMarkdownTable(snapshot) {
   lines.push(
     `Node ${snapshot.machine.node} · ${snapshot.machine.cpuCount}x ${snapshot.machine.cpuModel} · ${snapshot.machine.memoryGb} GB RAM`,
   );
+  lines.push(`Generated ${snapshot.generatedAt}${snapshot.gitSha ? ` (${snapshot.gitSha})` : ''}`);
+  lines.push('');
   lines.push(
-    `Generated ${snapshot.generatedAt}${snapshot.gitSha ? ` (${snapshot.gitSha})` : ''}`,
+    '| Corpus size | Encode p50 (ms) | Encode p95 (ms) | Recall p50 (ms) | Recall p95 (ms) | Recall p99 (ms) |',
   );
-  lines.push('');
-  lines.push('| Corpus size | Encode p50 (ms) | Encode p95 (ms) | Recall p50 (ms) | Recall p95 (ms) | Recall p99 (ms) |');
   lines.push('|---|---|---|---|---|---|');
   for (const row of snapshot.sizes) {
     lines.push(
@@ -287,7 +290,7 @@ export function formatMarkdownTable(snapshot) {
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
   const args = parseArgs();
   runPerfSnapshot({ sizes: args.sizes, recallRuns: args.recallRuns })
-    .then((snapshot) => {
+    .then(snapshot => {
       if (args.out) {
         writeFileSync(args.out, JSON.stringify(snapshot, null, 2) + '\n');
       }
@@ -297,7 +300,7 @@ if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
         process.stdout.write(formatMarkdownTable(snapshot) + '\n');
       }
     })
-    .catch((err) => {
+    .catch(err => {
       console.error('[audrey] perf snapshot failed:', err);
       process.exit(1);
     });

package/benchmarks/perf.bench.js

@@ -136,16 +136,24 @@ export async function runPerfBenchmark({
     };
 
     if (queueProcessingTimes.length !== runs) {
-      throw new Error(`expected ${runs} post-encode queue events, got ${queueProcessingTimes.length}`);
+      throw new Error(
+        `expected ${runs} post-encode queue events, got ${queueProcessingTimes.length}`,
+      );
     }
 
     assertBudget('encode response p95', result.encode_response_ms.p95, budgets.encodeResponseP95Ms);
     assertBudget('hybrid recall p95', result.hybrid_recall_ms.p95, budgets.hybridRecallP95Ms);
-    assertBudget('queue processing p50', result.queue_processing_ms.p50, budgets.queueProcessingP50Ms);
-
-    out(`Audrey perf gate passed: encode p95=${result.encode_response_ms.p95}ms, `
-      + `hybrid recall p95=${result.hybrid_recall_ms.p95}ms, `
-      + `queue p50=${result.queue_processing_ms.p50}ms`);
+    assertBudget(
+      'queue processing p50',
+      result.queue_processing_ms.p50,
+      budgets.queueProcessingP50Ms,
+    );
+
+    out(
+      `Audrey perf gate passed: encode p95=${result.encode_response_ms.p95}ms, ` +
+        `hybrid recall p95=${result.hybrid_recall_ms.p95}ms, ` +
+        `queue p50=${result.queue_processing_ms.p50}ms`,
+    );
     return result;
   } finally {
     audrey.close();

package/benchmarks/public-paths.mjs

@@ -34,15 +34,19 @@ export function publicCommand(command = []) {
 export function publicArtifactValue(value) {
   if (Array.isArray(value)) return value.map(item => publicArtifactValue(item));
   if (value && typeof value === 'object') {
-    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, publicArtifactValue(item)]));
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [key, publicArtifactValue(item)]),
+    );
   }
   return publicPath(value);
 }
 
 export function containsLocalPath(text) {
-  return WINDOWS_DRIVE_PATTERN.test(text)
-    || EXTENDED_PATH_PATTERN.test(text)
-    || FILE_URL_PATTERN.test(text);
+  return (
+    WINDOWS_DRIVE_PATTERN.test(text) ||
+    EXTENDED_PATH_PATTERN.test(text) ||
+    FILE_URL_PATTERN.test(text)
+  );
 }
 
 export function findLocalPathLeaks(value, path = '$') {
@@ -53,7 +57,9 @@ export function findLocalPathLeaks(value, path = '$') {
     return value.flatMap((item, index) => findLocalPathLeaks(item, `${path}[${index}]`));
   }
   if (value && typeof value === 'object') {
-    return Object.entries(value).flatMap(([key, item]) => findLocalPathLeaks(item, `${path}.${key}`));
+    return Object.entries(value).flatMap(([key, item]) =>
+      findLocalPathLeaks(item, `${path}.${key}`),
+    );
   }
   return [];
 }

package/benchmarks/reference-results.js

@@ -44,27 +44,32 @@ export const PUBLISHED_LEADERBOARD = [
 export const MEMORY_TRENDS = [
   {
     title: 'Memory is moving from flat retrieval to typed systems',
-    summary: 'Recent work treats episodic, semantic, procedural, and graph memory as separate but cooperating layers.',
+    summary:
+      'Recent work treats episodic, semantic, procedural, and graph memory as separate but cooperating layers.',
     source: 'https://arxiv.org/abs/2507.03724',
   },
   {
     title: 'Benchmarks now emphasize multi-session realism',
-    summary: 'LongMemEval and LoCoMo push memory systems toward temporal updates, abstraction, and cross-session reasoning instead of single-turn fact recall.',
+    summary:
+      'LongMemEval and LoCoMo push memory systems toward temporal updates, abstraction, and cross-session reasoning instead of single-turn fact recall.',
     source: 'https://arxiv.org/abs/2410.10813',
   },
   {
     title: 'Context engineering is now competing with retrieval-first designs',
-    summary: 'Letta argues filesystem and memory-block approaches can outperform simpler retrieval-only memory on realistic long-horizon tasks.',
+    summary:
+      'Letta argues filesystem and memory-block approaches can outperform simpler retrieval-only memory on realistic long-horizon tasks.',
     source: 'https://www.letta.com/blog/memory-blocks',
   },
   {
     title: 'Production teams care about latency and token footprint, not just recall quality',
-    summary: 'Mem0 frames memory as a cost and latency optimization surface in addition to a personalization surface.',
+    summary:
+      'Mem0 frames memory as a cost and latency optimization surface in addition to a personalization surface.',
     source: 'https://arxiv.org/abs/2504.19413',
   },
   {
     title: 'Temporal and multimodal memory are becoming table stakes',
-    summary: 'MIRIX and Graphiti both model time and state change explicitly instead of assuming memories stay forever true.',
+    summary:
+      'MIRIX and Graphiti both model time and state change explicitly instead of assuming memories stay forever true.',
     source: 'https://arxiv.org/abs/2507.07957',
   },
 ];

package/benchmarks/report.js

@@ -38,25 +38,29 @@ function renderBarChart({ title, rows, valueSuffix = '%', maxValue = 100 }) {
   const barWidth = Math.max(32, Math.floor(plotWidth / Math.max(rows.length, 1)) - 18);
   const gap = rows.length > 1 ? (plotWidth - barWidth * rows.length) / (rows.length - 1) : 0;
 
-  const bars = rows.map((row, index) => {
-    const value = Math.max(0, Math.min(maxValue, row.value));
-    const barHeight = (value / maxValue) * plotHeight;
-    const x = margin.left + index * (barWidth + gap);
-    const y = margin.top + plotHeight - barHeight;
-    return `
+  const bars = rows
+    .map((row, index) => {
+      const value = Math.max(0, Math.min(maxValue, row.value));
+      const barHeight = (value / maxValue) * plotHeight;
+      const x = margin.left + index * (barWidth + gap);
+      const y = margin.top + plotHeight - barHeight;
+      return `
       <rect x="${x}" y="${y}" width="${barWidth}" height="${barHeight}" rx="8" fill="${chartBarColor(row.label)}" />
       <text x="${x + barWidth / 2}" y="${y - 10}" text-anchor="middle" font-size="15" fill="${PALETTE.accent}">${value.toFixed(1)}${valueSuffix}</text>
       <text x="${x + barWidth / 2}" y="${height - 42}" text-anchor="middle" font-size="14" fill="${PALETTE.muted}">${escapeHtml(row.label)}</text>
     `;
-  }).join('\n');
+    })
+    .join('\n');
 
-  const grid = [0, 25, 50, 75, 100].map(tick => {
-    const y = margin.top + plotHeight - (tick / maxValue) * plotHeight;
-    return `
+  const grid = [0, 25, 50, 75, 100]
+    .map(tick => {
+      const y = margin.top + plotHeight - (tick / maxValue) * plotHeight;
+      return `
       <line x1="${margin.left}" y1="${y}" x2="${width - margin.right}" y2="${y}" stroke="${PALETTE.border}" stroke-dasharray="4 4" />
       <text x="${margin.left - 10}" y="${y + 5}" text-anchor="end" font-size="13" fill="${PALETTE.muted}">${tick}${valueSuffix}</text>
     `;
-  }).join('\n');
+    })
+    .join('\n');
 
   return `<?xml version="1.0" encoding="UTF-8"?>
 <svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}" role="img" aria-label="${escapeHtml(title)}">
@@ -68,39 +72,53 @@ function renderBarChart({ title, rows, valueSuffix = '%', maxValue = 100 }) {
 }
 
 function renderTrendList(trends) {
-  return trends.map(trend => `
+  return trends
+    .map(
+      trend => `
     <li>
       <strong>${escapeHtml(trend.title)}</strong><br />
       ${escapeHtml(trend.summary)}<br />
       <a href="${trend.source}">${escapeHtml(trend.source)}</a>
     </li>
-  `).join('\n');
+  `,
+    )
+    .join('\n');
 }
 
 function renderCaseRows(localCases) {
-  return localCases.map(caseResult => `
+  return localCases
+    .map(
+      caseResult => `
     <tr>
       <td>${escapeHtml(caseResult.title)}</td>
       <td>${escapeHtml(caseResult.suite)}</td>
       <td>${escapeHtml(caseResult.family)}</td>
-      ${caseResult.results.map(result => {
-        const bg = result.passed ? '#ecfdf5' : result.score >= 0.5 ? '#fff7ed' : '#fef2f2';
-        const fg = result.passed ? '#065f46' : result.score >= 0.5 ? '#9a3412' : '#991b1b';
-        return `<td style="background:${bg};color:${fg}">${result.score.toFixed(2)}<br /><span style="font-size:12px">${escapeHtml(result.summary)}</span></td>`;
-      }).join('')}
+      ${caseResult.results
+        .map(result => {
+          const bg = result.passed ? '#ecfdf5' : result.score >= 0.5 ? '#fff7ed' : '#fef2f2';
+          const fg = result.passed ? '#065f46' : result.score >= 0.5 ? '#9a3412' : '#991b1b';
+          return `<td style="background:${bg};color:${fg}">${result.score.toFixed(2)}<br /><span style="font-size:12px">${escapeHtml(result.summary)}</span></td>`;
+        })
+        .join('')}
     </tr>
-  `).join('\n');
+  `,
+    )
+    .join('\n');
 }
 
 function renderSuiteSections(suiteCharts) {
   if (suiteCharts.length === 0) return '';
-  return suiteCharts.map(chart => `
+  return suiteCharts
+    .map(
+      chart => `
     <section class="callout">
       <h2>${escapeHtml(chart.title)}</h2>
       <p>${escapeHtml(chart.description)}</p>
       <img src="./${escapeHtml(chart.fileName)}" alt="${escapeHtml(chart.title)} chart" />
     </section>
-  `).join('\n');
+  `,
+    )
+    .join('\n');
 }
 
 export function writeBenchmarkArtifacts({
@@ -114,9 +132,10 @@ export function writeBenchmarkArtifacts({
 }) {
   mkdirSync(outputDir, { recursive: true });
 
-  const localChartTitle = summary.local?.overall_scope === 'comparable_suites'
-    ? 'Audrey vs Comparable Local Memory Baselines'
-    : 'Selected Audrey Regression Suite';
+  const localChartTitle =
+    summary.local?.overall_scope === 'comparable_suites'
+      ? 'Audrey vs Comparable Local Memory Baselines'
+      : 'Selected Audrey Regression Suite';
   const localChart = renderBarChart({
     title: localChartTitle,
     rows: localOverall.map(row => ({ label: row.system, value: row.scorePercent })),
@@ -162,8 +181,10 @@ export function writeBenchmarkArtifacts({
         operationsReadmeChart,
         renderBarChart({
           title: 'Audrey Memory Operations Benchmark',
-          rows: (localSuites.find(suite => suite.id === 'operations')?.overall || [])
-            .map(row => ({ label: row.system, value: row.scorePercent })),
+          rows: (localSuites.find(suite => suite.id === 'operations')?.overall || []).map(row => ({
+            label: row.system,
+            value: row.scorePercent,
+          })),
         }),
         'utf8',
       );

package/benchmarks/run-external-guardbench.mjs

@@ -3,31 +3,46 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { basename, dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { writeGuardBenchConformanceCard } from './create-conformance-card.mjs';
-import { computeGuardBenchArtifactHashes, validateGuardBenchArtifacts } from './validate-guardbench-artifacts.mjs';
+import {
+  computeGuardBenchArtifactHashes,
+  validateGuardBenchArtifacts,
+} from './validate-guardbench-artifacts.mjs';
 import { publicArtifactValue } from './public-paths.mjs';
 
 const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 const KNOWN_ADAPTERS = new Map([
-  ['mem0', {
-    name: 'mem0-platform',
-    path: 'benchmarks/adapters/mem0-platform.mjs',
-    requiredEnv: ['MEM0_API_KEY'],
-  }],
-  ['mem0-platform', {
-    name: 'mem0-platform',
-    path: 'benchmarks/adapters/mem0-platform.mjs',
-    requiredEnv: ['MEM0_API_KEY'],
-  }],
-  ['zep', {
-    name: 'zep-cloud',
-    path: 'benchmarks/adapters/zep-cloud.mjs',
-    requiredEnv: ['ZEP_API_KEY'],
-  }],
-  ['zep-cloud', {
-    name: 'zep-cloud',
-    path: 'benchmarks/adapters/zep-cloud.mjs',
-    requiredEnv: ['ZEP_API_KEY'],
-  }],
+  [
+    'mem0',
+    {
+      name: 'mem0-platform',
+      path: 'benchmarks/adapters/mem0-platform.mjs',
+      requiredEnv: ['MEM0_API_KEY'],
+    },
+  ],
+  [
+    'mem0-platform',
+    {
+      name: 'mem0-platform',
+      path: 'benchmarks/adapters/mem0-platform.mjs',
+      requiredEnv: ['MEM0_API_KEY'],
+    },
+  ],
+  [
+    'zep',
+    {
+      name: 'zep-cloud',
+      path: 'benchmarks/adapters/zep-cloud.mjs',
+      requiredEnv: ['ZEP_API_KEY'],
+    },
+  ],
+  [
+    'zep-cloud',
+    {
+      name: 'zep-cloud',
+      path: 'benchmarks/adapters/zep-cloud.mjs',
+      requiredEnv: ['ZEP_API_KEY'],
+    },
+  ],
 ]);
 
 export function parseExternalArgs(argv = process.argv.slice(2)) {
@@ -127,13 +142,19 @@ export function evaluateAdapterConformance(summary, adapterName) {
     .filter(row => row.system === resolvedAdapterName);
 
   if (adapterRows.length !== expectedScenarios) {
-    failures.push(`Adapter ${resolvedAdapterName} returned ${adapterRows.length}/${expectedScenarios} scenario rows`);
+    failures.push(
+      `Adapter ${resolvedAdapterName} returned ${adapterRows.length}/${expectedScenarios} scenario rows`,
+    );
   }
   if (systemSummary && systemSummary.scenarios !== expectedScenarios) {
-    failures.push(`Adapter ${resolvedAdapterName} system summary has ${systemSummary.scenarios}/${expectedScenarios} scenarios`);
+    failures.push(
+      `Adapter ${resolvedAdapterName} system summary has ${systemSummary.scenarios}/${expectedScenarios} scenarios`,
+    );
   }
   if (systemSummary && systemSummary.redactionLeaks !== 0) {
-    failures.push(`Adapter ${resolvedAdapterName} leaked ${systemSummary.redactionLeaks} seeded secret(s) in decision output`);
+    failures.push(
+      `Adapter ${resolvedAdapterName} leaked ${systemSummary.redactionLeaks} seeded secret(s) in decision output`,
+    );
   }
   if (adapterRows.some(row => row.external !== true)) {
     failures.push(`Adapter ${resolvedAdapterName} rows are not marked external`);
@@ -270,7 +291,8 @@ async function main() {
   const card = child.status === 0 ? writeGuardBenchConformanceCard({ dir: run.outDir }) : null;
   console.log(`External GuardBench metadata: ${metadataPath}`);
   if (card) console.log(`External GuardBench conformance card: ${card.path}`);
-  process.exitCode = child.status === 0 && validation.ok && adapterConformance.ok ? 0 : (child.status ?? 1);
+  process.exitCode =
+    child.status === 0 && validation.ok && adapterConformance.ok ? 0 : (child.status ?? 1);
 }
 
 if (process.argv[1] && process.argv[1].endsWith('run-external-guardbench.mjs')) {