@librechat/agents 3.1.77 → 3.1.78

package/src/scripts/local_engine.ts

@@ -0,0 +1,166 @@
+/**
+ * src/scripts/local_engine.ts
+ *
+ * Live end-to-end exercise of the local execution engine. Spins up a
+ * temporary workspace, points an agent at it via
+ * `toolExecution: { engine: 'local' }`, and asks the model to do a
+ * small coding task that exercises `write_file`, `read_file`,
+ * `edit_file`, `bash`, and `list_directory`. After the run, dumps the
+ * workspace contents so you can verify the tools actually mutated
+ * disk.
+ *
+ * Run with: `npm run local`
+ */
+import { config } from 'dotenv';
+config();
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { mkdtemp, readdir, readFile, rm } from 'fs/promises';
+import { HumanMessage } from '@langchain/core/messages';
+import type { BaseMessage } from '@langchain/core/messages';
+import type * as t from '@/types';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
+import { ToolEndHandler, ModelEndHandler } from '@/events';
+import { getLLMConfig } from '@/utils/llmConfig';
+import { getArgs } from '@/scripts/args';
+import { GraphEvents } from '@/common';
+import { Run } from '@/run';
+
+const conversationHistory: BaseMessage[] = [];
+
+async function main(): Promise<void> {
+  const { userName, provider } = await getArgs();
+  const cwd = await mkdtemp(join(tmpdir(), 'lc-local-engine-'));
+  console.log(`[local_engine] workspace: ${cwd}`);
+
+  const { contentParts, aggregateContent } = createContentAggregator();
+  const customHandlers = {
+    [GraphEvents.TOOL_END]: new ToolEndHandler(),
+    [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+    [GraphEvents.ON_RUN_STEP_COMPLETED]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_COMPLETED,
+        data: t.StreamEventData
+      ): void => {
+        console.log('====== ON_RUN_STEP_COMPLETED ======');
+        const cast = data as unknown as { result: t.ToolEndEvent };
+        const tc = (cast.result as { tool_call?: { name?: string } } | undefined)
+          ?.tool_call;
+        console.log(`tool=${tc?.name ?? '<unknown>'}`);
+        aggregateContent({ event, data: cast });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP,
+        data: t.StreamEventData
+      ): void => {
+        aggregateContent({ event, data: data as t.RunStep });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_DELTA,
+        data: t.StreamEventData
+      ): void => {
+        aggregateContent({ event, data: data as t.RunStepDeltaEvent });
+      },
+    },
+    [GraphEvents.ON_MESSAGE_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_MESSAGE_DELTA,
+        data: t.StreamEventData
+      ): void => {
+        aggregateContent({ event, data: data as t.MessageDeltaEvent });
+      },
+    },
+    [GraphEvents.TOOL_START]: {
+      handle: (_event: string, data: t.StreamEventData): void => {
+        const obj = data as unknown as { name?: string; input?: unknown };
+        console.log(
+          `====== TOOL_START tool=${obj.name ?? '?'} input=${JSON.stringify(
+            obj.input
+          )} ======`
+        );
+      },
+    },
+  };
+
+  const llmConfig = getLLMConfig(provider);
+
+  const runConfig: t.RunConfig = {
+    runId: 'local-engine-1',
+    graphConfig: {
+      type: 'standard',
+      llmConfig,
+      instructions:
+        'You are a friendly AI coding assistant with access to local file and shell tools. ' +
+        'Always operate inside the configured working directory and prefer the smallest tool ' +
+        'that gets the job done (read_file before grep, write_file before bash heredocs, etc.). ' +
+        `Address the user by their name (${userName}).`,
+    },
+    toolExecution: {
+      engine: 'local',
+      local: {
+        cwd,
+        // Sandbox is opt-in; leave off for this baseline script. The engine
+        // logs a one-time warning when it runs without sandboxing.
+        bashAst: 'auto',
+        timeoutMs: 30_000,
+      },
+    },
+    returnContent: true,
+    skipCleanup: true,
+    customHandlers,
+  };
+  const run = await Run.create<t.IState>(runConfig);
+
+  const streamConfig = {
+    configurable: { provider, thread_id: 'local-engine-thread-1' },
+    streamMode: 'values',
+    version: 'v2' as const,
+  };
+
+  const userMessage = new HumanMessage(
+    `Hi, I'm ${userName}. In the current working directory, please do the following step by step:\n\n` +
+      '1. Create a file called `greet.py` with a tiny Python function `greet(name)` that returns "Hello, <name>!".\n' +
+      '2. Use `bash` to run `python3 -c "from greet import greet; print(greet(\\"world\\"))"` and confirm it prints "Hello, world!".\n' +
+      '3. Use `edit_file` to change the greeting to "Hi, <name>!" (only that one literal change).\n' +
+      '4. Re-run the same bash command and confirm the new output.\n' +
+      '5. Use `list_directory` to show what files exist now.\n\n' +
+      'Before exiting, briefly summarise the steps you took.'
+  );
+  conversationHistory.push(userMessage);
+
+  console.log('====== USER ======\n' + userMessage.content + '\n');
+  await run.processStream({ messages: conversationHistory }, streamConfig);
+  const finalMessages = run.getRunMessages();
+  if (finalMessages) {
+    conversationHistory.push(...finalMessages);
+  }
+
+  console.log('\n====== FINAL CONTENT PARTS ======');
+  console.dir(contentParts, { depth: null });
+
+  console.log('\n====== WORKSPACE ON DISK ======');
+  const entries = await readdir(cwd, { withFileTypes: true });
+  for (const e of entries) {
+    if (!e.isFile()) continue;
+    const path = join(cwd, e.name);
+    const body = await readFile(path, 'utf8').catch(() => '<binary>');
+    console.log(`--- ${e.name} ---\n${body}\n`);
+  }
+
+  await rm(cwd, { recursive: true, force: true });
+}
+
+process.on('unhandledRejection', (reason) => {
+  console.error('Unhandled Rejection:', reason);
+  process.exit(1);
+});
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/src/scripts/local_engine_checkpointer.ts

@@ -0,0 +1,205 @@
+/**
+ * src/scripts/local_engine_checkpointer.ts
+ *
+ * Live demonstration of the file checkpointer. We:
+ *
+ *   1. Build the local-coding-tool bundle ourselves with
+ *      `createLocalCodingToolBundle({ fileCheckpointing: true })` so we
+ *      can keep a handle on the checkpointer.
+ *   2. Pass those tools to the run as `graphConfig.tools`. We do NOT
+ *      use `toolExecution.engine: 'local'` here — that path auto-binds
+ *      its own internal tools without exposing a checkpointer back to
+ *      us. The point is to show how a host wires checkpointing on top
+ *      of the local tools when it cares about rewind.
+ *   3. Seed two files with known contents.
+ *   4. Ask the model to MUTATE both via `edit_file` / `write_file`.
+ *   5. Verify the contents changed on disk.
+ *   6. Call `checkpointer.rewind()` and verify the original contents
+ *      came back.
+ *
+ * Run with: `npm run local:checkpointer`
+ */
+import { config } from 'dotenv';
+config();
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { mkdtemp, readFile, rm, writeFile } from 'fs/promises';
+import { HumanMessage } from '@langchain/core/messages';
+import type { BaseMessage } from '@langchain/core/messages';
+import type * as t from '@/types';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
+import { ToolEndHandler, ModelEndHandler } from '@/events';
+import { createLocalCodingToolBundle } from '@/tools/local';
+import { getLLMConfig } from '@/utils/llmConfig';
+import { getArgs } from '@/scripts/args';
+import { GraphEvents } from '@/common';
+import { Run } from '@/run';
+
+const conversationHistory: BaseMessage[] = [];
+
+const FILE_A = 'config.json';
+const FILE_B = 'README.md';
+const ORIGINAL_A = '{\n  "version": "1.0.0",\n  "name": "demo"\n}\n';
+const ORIGINAL_B = '# Demo\n\nThis README is intentionally tiny.\n';
+
+async function main(): Promise<void> {
+  const { userName, provider } = await getArgs();
+  const cwd = await mkdtemp(join(tmpdir(), 'lc-local-cp-'));
+  console.log(`[local_engine_checkpointer] workspace: ${cwd}`);
+
+  await writeFile(join(cwd, FILE_A), ORIGINAL_A, 'utf8');
+  await writeFile(join(cwd, FILE_B), ORIGINAL_B, 'utf8');
+
+  // Build the local-engine tool bundle with file checkpointing on so
+  // we can call `bundle.checkpointer.rewind()` after the run.
+  const bundle = createLocalCodingToolBundle({
+    cwd,
+    fileCheckpointing: true,
+    timeoutMs: 30_000,
+  });
+  if (bundle.checkpointer == null) {
+    throw new Error(
+      'expected bundle.checkpointer to be defined when fileCheckpointing is true'
+    );
+  }
+
+  const { contentParts, aggregateContent } = createContentAggregator();
+  const customHandlers = {
+    [GraphEvents.TOOL_END]: new ToolEndHandler(),
+    [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+    // Forward ON_RUN_STEP so the aggregator's stepMap is seeded
+    // before ON_RUN_STEP_COMPLETED arrives — without this the
+    // aggregator logs "No run step or runId found for completed step
+    // event" once per tool call (issue #142).
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP,
+        data: t.StreamEventData
+      ): void => {
+        aggregateContent({ event, data: data as t.RunStep });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP_COMPLETED]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_COMPLETED,
+        data: t.StreamEventData
+      ): void => {
+        const cast = data as unknown as { result: t.ToolEndEvent };
+        const tc = (cast.result as { tool_call?: { name?: string } } | undefined)
+          ?.tool_call;
+        console.log(`====== ON_RUN_STEP_COMPLETED tool=${tc?.name ?? '?'} ======`);
+        aggregateContent({ event, data: cast });
+      },
+    },
+    [GraphEvents.ON_MESSAGE_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_MESSAGE_DELTA,
+        data: t.StreamEventData
+      ): void => {
+        aggregateContent({ event, data: data as t.MessageDeltaEvent });
+      },
+    },
+    [GraphEvents.TOOL_START]: {
+      handle: (_event: string, data: t.StreamEventData): void => {
+        const obj = data as unknown as { name?: string; input?: unknown };
+        console.log(
+          `====== TOOL_START tool=${obj.name ?? '?'} input=${JSON.stringify(
+            obj.input
+          )} ======`
+        );
+      },
+    },
+  };
+
+  const llmConfig = getLLMConfig(provider);
+
+  const runConfig: t.RunConfig = {
+    runId: 'local-engine-cp-1',
+    graphConfig: {
+      type: 'standard',
+      llmConfig,
+      tools: bundle.tools,
+      instructions:
+        'You are a coding assistant with local file tools. Make exactly the changes ' +
+        'the user asks for, no more. Use `edit_file` for single-line literal ' +
+        'replacements and `write_file` for full overwrites.',
+    },
+    returnContent: true,
+    skipCleanup: true,
+    customHandlers,
+  };
+  const run = await Run.create<t.IState>(runConfig);
+
+  const streamConfig = {
+    configurable: { provider, thread_id: 'local-engine-cp-thread-1' },
+    streamMode: 'values',
+    version: 'v2' as const,
+  };
+
+  const userMessage = new HumanMessage(
+    `Hi ${userName}. Please do exactly the following:\n\n` +
+      `1. Use \`edit_file\` on \`${FILE_A}\` to replace \`"version": "1.0.0"\` with \`"version": "2.0.0"\`.\n` +
+      `2. Use \`write_file\` on \`${FILE_B}\` to overwrite it with the contents:\n` +
+      '   "# Demo\\n\\nThis README has been overwritten by the agent.\\n"\n\n' +
+      'Confirm both changes succeeded. Do not touch any other files.'
+  );
+  conversationHistory.push(userMessage);
+  console.log('====== USER ======\n' + userMessage.content + '\n');
+
+  await run.processStream({ messages: conversationHistory }, streamConfig);
+  const finalMessages = run.getRunMessages();
+  if (finalMessages) {
+    conversationHistory.push(...finalMessages);
+  }
+
+  console.log('\n====== FINAL CONTENT PARTS ======');
+  console.dir(contentParts, { depth: null });
+
+  // After the run: verify the agent actually changed the files.
+  const afterA = await readFile(join(cwd, FILE_A), 'utf8');
+  const afterB = await readFile(join(cwd, FILE_B), 'utf8');
+  console.log('\n====== AFTER AGENT EDITS ======');
+  console.log(`--- ${FILE_A} ---\n${afterA}`);
+  console.log(`--- ${FILE_B} ---\n${afterB}`);
+
+  const aChanged = afterA !== ORIGINAL_A;
+  const bChanged = afterB !== ORIGINAL_B;
+  console.log(`changed ${FILE_A}: ${aChanged}`);
+  console.log(`changed ${FILE_B}: ${bChanged}`);
+
+  console.log('\n====== CAPTURED CHECKPOINTS ======');
+  console.log(bundle.checkpointer.capturedPaths());
+
+  // Now rewind and verify originals come back.
+  const restoredCount = await bundle.checkpointer.rewind();
+  console.log(`\n====== AFTER REWIND (restored ${restoredCount} files) ======`);
+  const rewoundA = await readFile(join(cwd, FILE_A), 'utf8');
+  const rewoundB = await readFile(join(cwd, FILE_B), 'utf8');
+  console.log(`--- ${FILE_A} ---\n${rewoundA}`);
+  console.log(`--- ${FILE_B} ---\n${rewoundB}`);
+
+  const aBack = rewoundA === ORIGINAL_A;
+  const bBack = rewoundB === ORIGINAL_B;
+  console.log(`${FILE_A} restored to original: ${aBack}`);
+  console.log(`${FILE_B} restored to original: ${bBack}`);
+
+  if (!(aBack && bBack)) {
+    console.error('\n[checkpointer] rewind did not restore both files (BUG)');
+    process.exitCode = 1;
+  } else {
+    console.log('\n[checkpointer] all files restored to pre-run state ✔');
+  }
+
+  await rm(cwd, { recursive: true, force: true });
+}
+
+process.on('unhandledRejection', (reason) => {
+  console.error('Unhandled Rejection:', reason);
+  process.exit(1);
+});
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/src/scripts/local_engine_compile.ts

@@ -0,0 +1,263 @@
+/**
+ * src/scripts/local_engine_compile.ts
+ *
+ * Live demonstration of the cheap typecheck integration shipped as
+ * an alternative to full LSP:
+ *
+ *   1. Post-edit syntax check (`local.postEditSyntaxCheck: 'auto'`)
+ *      runs `node --check` after every edit_file / write_file on
+ *      `.js`/`.mjs` files — the model sees the parse error in the
+ *      tool result and self-corrects on the next turn.
+ *
+ *   2. `compile_check` tool runs the project's standard typecheck
+ *      command (auto-detected from project markers, or supplied via
+ *      the `command` arg) and surfaces the result.
+ *
+ * The script seeds a tiny package.json + tsconfig + index.ts in a
+ * temp dir, then asks the model to:
+ *   (a) `write_file` an intentionally broken `index.js`,
+ *   (b) call `compile_check` to see the error,
+ *   (c) fix the file via `edit_file`,
+ *   (d) call `compile_check` again to confirm green.
+ *
+ * Run with: `npm run local:compile`
+ */
+import { config } from 'dotenv';
+config();
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { mkdtemp, rm, symlink, writeFile } from 'fs/promises';
+import { resolve } from 'path';
+import { HumanMessage, ToolMessage } from '@langchain/core/messages';
+import type { BaseMessage } from '@langchain/core/messages';
+import type * as t from '@/types';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
+import { ToolEndHandler, ModelEndHandler } from '@/events';
+import { getLLMConfig } from '@/utils/llmConfig';
+import { getArgs } from '@/scripts/args';
+import { GraphEvents } from '@/common';
+import { Run } from '@/run';
+
+const conversationHistory: BaseMessage[] = [];
+
+async function main(): Promise<void> {
+  const { userName, provider } = await getArgs();
+  const cwd = await mkdtemp(join(tmpdir(), 'lc-local-compile-'));
+  console.log(`[local_engine_compile] workspace: ${cwd}`);
+
+  // Seed a tiny TypeScript project so `compile_check` can actually
+  // resolve a real toolchain (tsc). We include a healthy index.ts
+  // baseline; the LLM will be asked to add a broken file alongside.
+  await writeFile(
+    join(cwd, 'tsconfig.json'),
+    JSON.stringify(
+      {
+        compilerOptions: {
+          target: 'ES2020',
+          module: 'commonjs',
+          strict: true,
+          noEmit: true,
+          skipLibCheck: true,
+        },
+        include: ['*.ts'],
+      },
+      null,
+      2
+    ),
+    'utf8'
+  );
+  await writeFile(
+    join(cwd, 'index.ts'),
+    'export function add(a: number, b: number): number {\n  return a + b;\n}\n',
+    'utf8'
+  );
+
+  // Make tsc available in the temp workspace by symlinking the
+  // surrounding repo's node_modules. This avoids a slow first-run
+  // npm install while the model waits, and lets `npx --no-install
+  // tsc` resolve typescript instantly. `process.cwd()` is the
+  // package root when running via `npm run`. We fall back
+  // gracefully on platforms where the symlink isn't possible.
+  const repoNodeModules = resolve(process.cwd(), 'node_modules');
+  try {
+    await symlink(repoNodeModules, join(cwd, 'node_modules'), 'dir');
+  } catch (err) {
+    console.warn(
+      '[local_engine_compile] could not symlink node_modules:',
+      (err as Error).message
+    );
+  }
+  await writeFile(
+    join(cwd, 'package.json'),
+    JSON.stringify({ name: 'lc-local-compile-demo', private: true }, null, 2),
+    'utf8'
+  );
+
+  const { aggregateContent } = createContentAggregator();
+  const customHandlers = {
+    [GraphEvents.TOOL_END]: new ToolEndHandler(),
+    [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+    // Forward ON_RUN_STEP so the aggregator's stepMap is seeded
+    // before ON_RUN_STEP_COMPLETED arrives — without this the
+    // aggregator logs "No run step or runId found for completed step
+    // event" once per tool call (issue #142).
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (event: GraphEvents.ON_RUN_STEP, data: t.StreamEventData): void => {
+        aggregateContent({ event, data: data as t.RunStep });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP_COMPLETED]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_COMPLETED,
+        data: t.StreamEventData
+      ): void => {
+        aggregateContent({
+          event,
+          data: data as unknown as { result: t.ToolEndEvent },
+        });
+      },
+    },
+    [GraphEvents.TOOL_START]: {
+      handle: (_event: string, data: t.StreamEventData): void => {
+        const obj = data as unknown as { name?: string; input?: unknown };
+        const inputStr = JSON.stringify(obj.input);
+        console.log(
+          `====== TOOL_START tool=${obj.name ?? '?'} input=${
+            inputStr.length > 200 ? inputStr.slice(0, 200) + '…' : inputStr
+          } ======`
+        );
+      },
+    },
+  };
+
+  const llmConfig = getLLMConfig(provider);
+
+  const runConfig: t.RunConfig = {
+    runId: 'local-engine-compile-1',
+    graphConfig: {
+      type: 'standard',
+      llmConfig,
+      instructions:
+        `You are ${userName}'s coding assistant. The host has wired a ` +
+        'post-edit syntax check (you will see `[syntax-check warning ...]` blocks ' +
+        'in tool results) and the `compile_check` tool. Use them to verify your ' +
+        'edits. When a syntax check warns you of an error, FIX IT before doing ' +
+        'anything else. Keep responses tight.',
+    },
+    toolExecution: {
+      engine: 'local',
+      local: {
+        cwd,
+        postEditSyntaxCheck: 'auto',
+        timeoutMs: 30_000,
+      },
+    },
+    returnContent: true,
+    skipCleanup: true,
+    customHandlers,
+  };
+  const run = await Run.create<t.IState>(runConfig);
+
+  const streamConfig = {
+    configurable: { provider, thread_id: 'local-engine-compile-thread-1' },
+    streamMode: 'values',
+    version: 'v2' as const,
+  };
+
+  const userMessage = new HumanMessage(
+    `Hi ${userName}. Here's the workflow. The workspace is a tiny TypeScript project (tsconfig.json + index.ts).\n\n` +
+      '1. First, exercise the post-edit syntax check. Use `write_file` to create `broken.js` with EXACTLY this content (it is intentionally broken):\n' +
+      '```\n' +
+      'function broken(a,) {\n' +
+      '  return a +;\n' +
+      '}\n' +
+      '```\n' +
+      '2. After the write, the post-edit syntax check should warn you with `[syntax-check warning ...]`. Read the warning carefully and fix the file via `edit_file` or `write_file`. The smallest valid fix is fine.\n\n' +
+      '3. Now exercise `compile_check`. Use `write_file` to create `broken.ts` with EXACTLY this content (it has a TYPE error, not a syntax error — `tsc` will catch it):\n' +
+      '```\n' +
+      'export const x: number = "not a number";\n' +
+      '```\n' +
+      '4. Call `compile_check` (no args). Anthropic\'s tsc should fail with a type error.\n' +
+      '5. Fix the type error in `broken.ts` (e.g. change the literal to a number) via `edit_file`.\n' +
+      '6. Call `compile_check` again to confirm green.\n\n' +
+      'Tell me what each `compile_check` call reported. Be concise.'
+  );
+  conversationHistory.push(userMessage);
+  console.log('====== USER ======\n' + userMessage.content + '\n');
+
+  await run.processStream({ messages: conversationHistory }, streamConfig);
+  const finalMessages = run.getRunMessages();
+  if (finalMessages) {
+    conversationHistory.push(...finalMessages);
+  }
+
+  let sawSyntaxWarning = false;
+  let compileCheckCalls = 0;
+  let compileCheckFailedAtLeastOnce = false;
+  let compileCheckPassedAtLeastOnce = false;
+  console.log('\n====== TOOL MESSAGES IN HISTORY ======');
+  for (const msg of conversationHistory) {
+    if (msg instanceof ToolMessage) {
+      const content =
+        typeof msg.content === 'string'
+          ? msg.content
+          : JSON.stringify(msg.content);
+      const head = content.slice(0, 240);
+      console.log(`- ${msg.name}: ${head.replace(/\n/g, ' ⏎ ')}`);
+      if (content.includes('[syntax-check')) sawSyntaxWarning = true;
+      if (msg.name === 'compile_check') {
+        compileCheckCalls += 1;
+        if (content.includes('PASSED')) compileCheckPassedAtLeastOnce = true;
+        if (content.includes('FAILED')) compileCheckFailedAtLeastOnce = true;
+      }
+    }
+  }
+
+  console.log('\n====== ASSISTANT FINAL TEXT ======');
+  const lastAssistant = [...conversationHistory]
+    .reverse()
+    .find((m) => m._getType() === 'ai');
+  if (lastAssistant) {
+    const c = lastAssistant.content;
+    console.log(
+      typeof c === 'string'
+        ? c
+        : Array.isArray(c)
+          ? c
+            .map((b) => ('text' in b ? b.text : `<${b.type}>`))
+            .join(' ')
+          : JSON.stringify(c)
+    );
+  }
+
+  console.log('\n====== ASSERTIONS ======');
+  console.log(
+    `post-edit syntax-check warning observed: ${sawSyntaxWarning} ${
+      sawSyntaxWarning ? '✔' : '✖'
+    }`
+  );
+  console.log(
+    `compile_check called ${compileCheckCalls} time(s); FAILED-then-PASSED cycle observed: ${
+      compileCheckFailedAtLeastOnce && compileCheckPassedAtLeastOnce
+    } ${compileCheckFailedAtLeastOnce && compileCheckPassedAtLeastOnce ? '✔' : '✖'}`
+  );
+
+  if (
+    !sawSyntaxWarning ||
+    !(compileCheckFailedAtLeastOnce && compileCheckPassedAtLeastOnce)
+  ) {
+    process.exitCode = 1;
+  }
+  await rm(cwd, { recursive: true, force: true });
+}
+
+process.on('unhandledRejection', (reason) => {
+  console.error('Unhandled Rejection:', reason);
+  process.exit(1);
+});
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});