mu-coding 0.15.0 → 0.16.1

package/src/config/index.ts

@@ -1,199 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import type { ProviderConfig } from 'mu-core';
-import type { ThemeConfig } from '../tui/theme/types';
-
-// ─── XDG Path Helpers ─────────────────────────────────────────────────────────
-//
-// Path resolution lives alongside config because the config module owns the
-// "where do mu's files live?" question end-to-end (config.json, SYSTEM.md,
-// sessions, plugin caches). Resolved lazily so tests can stub the env after
-// module import; production callers pay only one `process.env` lookup per call.
-
-const HOME = homedir();
-
-export function getConfigDir(): string {
-  return process.env.XDG_CONFIG_HOME ? join(process.env.XDG_CONFIG_HOME, 'mu') : join(HOME, '.config', 'mu');
-}
-
-export function getDataDir(): string {
-  return process.env.XDG_DATA_HOME ? join(process.env.XDG_DATA_HOME, 'mu') : join(HOME, '.local', 'share', 'mu');
-}
-
-export function getCacheDir(): string {
-  return process.env.XDG_CACHE_HOME ? join(process.env.XDG_CACHE_HOME, 'mu') : join(HOME, '.cache', 'mu');
-}
-
-export function getPluginsDir(): string {
-  return join(getConfigDir(), 'plugins');
-}
-
-// ─── npm: specifier parsing ───────────────────────────────────────────────────
-//
-// Plugin specifiers stored in `config.plugins` use the form `npm:<bare>` where
-// `<bare>` is a bun/npm package spec — possibly versioned (`foo@1.2.3`,
-// `@scope/foo@^1.0.0`). Multiple call sites need to split this consistently:
-// `mu install`/`mu uninstall` use it for canonicalization & version stripping;
-// the runtime plugin loader uses it to resolve from
-// `~/.local/share/mu/node_modules/<name>`. Centralized here so the rules
-// can never drift between install-time and load-time.
-
-/**
- * Parsed npm specifier: package name (always present, scope preserved) and an
- * optional install-time version range. Examples:
- *
- *   foo               → { name: "foo" }
- *   foo@1.2.3         → { name: "foo",         version: "1.2.3" }
- *   @scope/foo        → { name: "@scope/foo" }
- *   @scope/foo@^1.0.0 → { name: "@scope/foo",  version: "^1.0.0" }
- */
-export interface ParsedNpmSpec {
-  name: string;
-  version?: string;
-}
-
-/** Strip the leading `@` for scoped names before searching for the version `@`. */
-export function parseBareNpmSpec(bare: string): ParsedNpmSpec {
-  const scoped = bare.startsWith('@');
-  const at = bare.indexOf('@', scoped ? 1 : 0);
-  if (at === -1) return { name: bare };
-  return { name: bare.slice(0, at), version: bare.slice(at + 1) };
-}
-
-/**
- * Canonical form stored in `config.plugins`: `npm:<package-name>` with the
- * version stripped, so `npm:foo@1.2.3` and `npm:foo` deduplicate correctly.
- */
-export function canonicalNpmSpecifier(bare: string): string {
-  return `npm:${parseBareNpmSpec(bare).name}`;
-}
-
-export interface AppConfig extends ProviderConfig {
-  plugins?: Array<string | { name: string; config?: Record<string, unknown> }>;
-  /**
-   * Optional per-leaf overrides on top of the built-in theme. See
-   * `tui/theme/types.ts` for the available sections and color leaves.
-   */
-  theme?: ThemeConfig;
-}
-
-/**
- * Keys that `loadConfig`/`saveConfig` know how to materialize from `AppConfig`.
- * Used as an allow-list when seeding a fresh config.json. On `saveConfig` we
- * preserve every key already present in the file so users can keep custom
- * fields (or fields added by future versions) without losing them on round-trip.
- */
-const CONFIG_FILE_KEYS = [
-  'baseUrl',
-  'model',
-  'maxTokens',
-  'temperature',
-  'streamTimeoutMs',
-  'plugins',
-  'theme',
-] as const;
-
-function configPath(): string {
-  return join(getConfigDir(), 'config.json');
-}
-
-function systemPromptPath(): string {
-  return join(getConfigDir(), 'SYSTEM.md');
-}
-
-/**
- * Path to the SYSTEM.md bundled with mu-coding. Used as the lowest-priority
- * fallback when no user override is configured. Resolved from this module's
- * location so it works both from `src/` (dev via bun) and any compiled layout
- * that preserves the `prompts/` sibling of `src/` or `dist/`.
- */
-function bundledSystemPromptPath(): string {
-  const here = dirname(fileURLToPath(import.meta.url));
-  // src/config/index.ts → ../../prompts/SYSTEM.md
-  // dist/config/index.js → ../../prompts/SYSTEM.md
-  return join(here, '..', '..', 'prompts', 'SYSTEM.md');
-}
-
-function tryRead(path: string): string | undefined {
-  try {
-    return readFileSync(path, 'utf-8').trim() || undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-function tryParseJson(text: string | undefined): Partial<AppConfig> {
-  if (!text) {
-    return {};
-  }
-  try {
-    return JSON.parse(text);
-  } catch {
-    return {};
-  }
-}
-
-function envInt(key: string): number | undefined {
-  const v = process.env[key];
-  if (!v) {
-    return undefined;
-  }
-  const n = Number.parseInt(v, 10);
-  return Number.isNaN(n) ? undefined : n;
-}
-
-function envFloat(key: string): number | undefined {
-  const v = process.env[key];
-  if (!v) {
-    return undefined;
-  }
-  const n = Number.parseFloat(v);
-  return Number.isNaN(n) ? undefined : n;
-}
-
-export function loadConfig(cliModel?: string): AppConfig {
-  const path = configPath();
-  const file = tryParseJson(tryRead(path));
-
-  const config: AppConfig = {
-    baseUrl: process.env.MU_BASE_URL || file.baseUrl || 'http://localhost:8080/v1',
-    model: cliModel || process.env.MU_MODEL || file.model,
-    maxTokens: envInt('MU_MAX_TOKENS') ?? file.maxTokens ?? 4096,
-    temperature: envFloat('MU_TEMPERATURE') ?? file.temperature ?? 0.7,
-    streamTimeoutMs: envInt('MU_STREAM_TIMEOUT') ?? file.streamTimeoutMs ?? 60_000,
-    systemPrompt: tryRead(systemPromptPath()) || tryRead(bundledSystemPromptPath()),
-    plugins: file.plugins,
-    theme: file.theme,
-  };
-
-  if (!existsSync(path)) {
-    mkdirSync(getConfigDir(), { recursive: true });
-    const fileConfig = Object.fromEntries(
-      CONFIG_FILE_KEYS.filter((k) => file[k] !== undefined).map((k) => [k, file[k]]),
-    ) as Partial<AppConfig>;
-    writeFileSync(path, JSON.stringify(fileConfig, null, 2), 'utf-8');
-  }
-
-  return config;
-}
-
-/**
- * Persist `updates` to config.json, preserving any keys (known or unknown)
- * that are already present in the file. Only `undefined` values are stripped.
- */
-export function saveConfig(updates: Partial<AppConfig>): void {
-  const path = configPath();
-  const file = tryParseJson(tryRead(path)) as Record<string, unknown>;
-  const merged: Record<string, unknown> = { ...file };
-  for (const [key, value] of Object.entries(updates)) {
-    if (value === undefined) {
-      delete merged[key];
-    } else {
-      merged[key] = value;
-    }
-  }
-  mkdirSync(getConfigDir(), { recursive: true });
-  writeFileSync(path, JSON.stringify(merged, null, 2), 'utf-8');
-}

package/src/plugin.ts

@@ -1,124 +0,0 @@
-/**
- * mu-coding plugin — packages the TUI channel + coding tools into a single
- * plugin. The standalone `mu` binary uses this as its primary surface
- * (registered by `createRegistry`) and any generic host (Arya, future web
- * app) can opt in to the coding tools by including it in its plugin list.
- *
- * The factory takes a `CodingPluginConfig` rather than reading values from
- * `PluginContext` because the TUI layer needs the **concrete**
- * `PluginRegistry` (it subscribes to renderer / shortcut / status changes
- * via methods that are not part of the read-only `PluginRegistryView`).
- * `ctx.registry` only exposes the View; the host wires the concrete
- * registry in after constructing it.
- */
-
-import type { ApprovalGateway, SubagentRunRegistry } from 'mu-agents';
-import type { ChatMessage, Plugin, PluginContext, PluginRegistry } from 'mu-core';
-import type { ShutdownFn } from './app/shutdown';
-import type { AppConfig } from './config/index';
-import { createCodingToolsPlugin } from './runtime/codingTools/index';
-import type { SessionPathHolder } from './runtime/createRegistry';
-import { createFileMentionProvider } from './runtime/fileMentionProvider';
-import type { HostMessageBus } from './runtime/messageBus';
-import { createTuiChannel } from './tui/channel/tuiChannel';
-import { createInkApprovalChannel } from './tui/plugins/InkApprovalChannel';
-import type { InkUIService } from './tui/plugins/InkUIService';
-
-export interface CodingPluginConfig {
-  appConfig: AppConfig;
-  initialMessages?: ChatMessage[];
-  messageBus: HostMessageBus;
-  uiService: InkUIService;
-  shutdown: ShutdownFn;
-  /**
-   * Mutable holder updated by the TUI's session persistence hook so other
-   * plugins (mu-agents) can read the current parent session path when
-   * dispatching subagents. `undefined` until the React tree mounts.
-   */
-  sessionPathHolder?: SessionPathHolder;
-  /**
-   * Concrete `PluginRegistry` instance used by the TUI to subscribe to
-   * renderers / shortcuts / status segments. Required because `ctx.registry`
-   * (the read-only View) does not expose those subscription methods.
-   */
-  registry: PluginRegistry;
-}
-
-interface AgentPluginShape {
-  approvalGateway?: ApprovalGateway;
-  runs?: SubagentRunRegistry;
-}
-
-export function createCodingPlugin(config: CodingPluginConfig): Plugin {
-  // Coding tools are an inner plugin; we delegate via the registered tools
-  // list rather than a recursive register call so a single Plugin object
-  // is returned (matches the SDK's expected factory shape).
-  const inner = createCodingToolsPlugin();
-
-  // Captured at activation time so deactivate can clean up both registrations.
-  let unregisterTuiChannel: (() => void) | null = null;
-  let unregisterApprovalChannel: (() => void) | null = null;
-  let unregisterFileMentions: (() => void) | null = null;
-
-  return {
-    name: 'mu-coding',
-    version: '0.5.0',
-    tools: inner.tools,
-    systemPrompt: inner.systemPrompt,
-    activate(ctx: PluginContext) {
-      // Forward inner plugin's activate (captures cwd for tool path resolution).
-      inner.activate?.(ctx);
-
-      // Register the TUI channel so other code can stop it gracefully via
-      // ctx.channels.stopAll(). The TUI subscribes to the concrete registry
-      // (passed in via config), not the narrow context-exposed view.
-      // Resolve the live mu-agents handle so the TUI can subscribe to the
-      // subagent run registry (browser panel + live header). Looked up
-      // loosely so coding still works in setups that disabled the agent
-      // plugin — the TUI then renders a fallback header without the live
-      // subagent navigation surfaces.
-      const agentPlugin = ctx.getPlugin?.<Plugin & AgentPluginShape>('mu-agents');
-
-      unregisterTuiChannel =
-        ctx.channels?.register(
-          createTuiChannel({
-            config: config.appConfig,
-            initialMessages: config.initialMessages,
-            registry: config.registry,
-            messageBus: config.messageBus,
-            uiService: config.uiService,
-            shutdown: config.shutdown,
-            sessionPathHolder: config.sessionPathHolder,
-            subagentRuns: agentPlugin?.runs,
-          }),
-        ) ?? null;
-
-      // Register a file completion provider on `@`. Sits alongside the
-      // mu-agents `@`-provider — useMentionPicker concatenates results from
-      // every provider matching a trigger, grouped by category in the UI.
-      // When the user types `@foo`, agents that match by name appear first;
-      // files matching by basename/path follow.
-      if (ctx.registerMentionProvider) {
-        unregisterFileMentions = ctx.registerMentionProvider('@', createFileMentionProvider(ctx.cwd));
-      }
-
-      // Register the Ink approval channel against mu-agents' gateway when
-      // it's available (the lookup above already resolved `agentPlugin`).
-      if (agentPlugin?.approvalGateway) {
-        unregisterApprovalChannel = agentPlugin.approvalGateway.registerChannel(
-          'tui',
-          createInkApprovalChannel(config.uiService),
-        );
-      }
-    },
-    deactivate() {
-      unregisterApprovalChannel?.();
-      unregisterApprovalChannel = null;
-      unregisterFileMentions?.();
-      unregisterFileMentions = null;
-      unregisterTuiChannel?.();
-      unregisterTuiChannel = null;
-      inner.deactivate?.();
-    },
-  };
-}

package/src/runtime/codingTools/bash.ts

@@ -1,114 +0,0 @@
-import { spawn } from 'node:child_process';
-import type { PluginTool, ToolExecutorResult } from 'mu-core';
-
-function executeBash(command: string, cwd: string, signal?: AbortSignal): Promise<ToolExecutorResult> {
-  return new Promise((resolve) => {
-    const proc = spawn('bash', ['-c', command], {
-      stdio: ['pipe', 'pipe', 'pipe'],
-      detached: true,
-      cwd,
-    });
-
-    let stdout = '';
-    let stderr = '';
-
-    proc.stdout.on('data', (data: Buffer) => {
-      try {
-        stdout += data.toString('utf-8');
-      } catch {
-        // skip binary data
-      }
-    });
-    proc.stderr.on('data', (data: Buffer) => {
-      try {
-        stderr += data.toString('utf-8');
-      } catch {
-        // skip binary data
-      }
-    });
-
-    const onAbort = () => {
-      const pid = proc.pid;
-      if (pid) {
-        try {
-          process.kill(-pid, 'SIGTERM');
-        } catch {
-          proc.kill('SIGTERM');
-        }
-        setTimeout(() => {
-          if (!proc.killed) {
-            try {
-              process.kill(-pid, 'SIGKILL');
-            } catch {
-              proc.kill('SIGKILL');
-            }
-          }
-        }, 500);
-      }
-    };
-
-    if (signal) {
-      if (signal.aborted) {
-        onAbort();
-        return;
-      }
-      signal.addEventListener('abort', onAbort, { once: true });
-    }
-
-    proc.on('close', (code) => {
-      signal?.removeEventListener('abort', onAbort);
-      const output = [stdout, stderr]
-        .map((s) => s.trim())
-        .filter(Boolean)
-        .join('\n');
-      if (signal?.aborted) {
-        resolve({ content: 'Aborted', error: true });
-        return;
-      }
-      if (code !== 0 && !output) {
-        resolve({ content: `Error: Process exited with code ${code}`, error: true });
-        return;
-      }
-      // Non-zero exit with output: treat as error so the LLM sees it as such,
-      // but preserve stdout/stderr in the content.
-      resolve({ content: output || '(no output)', error: code !== 0 });
-    });
-
-    proc.on('error', (err) => {
-      signal?.removeEventListener('abort', onAbort);
-      resolve({ content: `Error: ${err.message}`, error: true });
-    });
-  });
-}
-
-export function createBashTool(getCwd: () => string): PluginTool {
-  return {
-    definition: {
-      type: 'function',
-      function: {
-        name: 'bash',
-        description:
-          'Run a shell command via bash in the project cwd. Returns stdout+stderr; non-zero exit is an error.',
-        parameters: {
-          type: 'object',
-          properties: {
-            cmd: { type: 'string' },
-          },
-          required: ['cmd'],
-          additionalProperties: false,
-        },
-      },
-    },
-    display: {
-      verb: 'running',
-      kind: 'shell',
-      fields: { command: 'cmd' },
-    },
-    permission: {
-      matchKey: (args) => args.cmd as string | undefined,
-    },
-    execute(args, signal) {
-      return executeBash(args.cmd as string, getCwd(), signal);
-    },
-  };
-}

package/src/runtime/codingTools/edit-file.ts

@@ -1,60 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import type { PluginTool, ToolExecutorResult } from 'mu-core';
-import { sanitizePath } from './utils';
-
-export function createEditFileTool(getCwd: () => string): PluginTool {
-  return {
-    definition: {
-      type: 'function',
-      function: {
-        name: 'edit',
-        description: 'Replace an exact substring in an existing file.',
-        parameters: {
-          type: 'object',
-          properties: {
-            path: { type: 'string' },
-            from: {
-              type: 'string',
-              description:
-                'Must occur exactly once in the file \u2014 include surrounding context to disambiguate. Whitespace must match exactly.',
-            },
-            to: { type: 'string' },
-          },
-          required: ['path', 'from', 'to'],
-          additionalProperties: false,
-        },
-      },
-    },
-    display: {
-      verb: 'editing',
-      kind: 'diff',
-      fields: { path: 'path', from: 'from', to: 'to' },
-    },
-    permission: {
-      matchKey: (args) => args.path as string | undefined,
-    },
-    execute(args): ToolExecutorResult {
-      const path = sanitizePath(args.path as string, getCwd());
-      const oldString = args.from as string;
-      const newString = args.to as string;
-
-      if (!existsSync(path)) {
-        return { content: `Error: File not found: ${path}`, error: true };
-      }
-      try {
-        const content = readFileSync(path, 'utf-8');
-        const count = content.split(oldString).length - 1;
-        if (count === 0) {
-          return { content: 'Error: "from" not found in file', error: true };
-        }
-        if (count > 1) {
-          return { content: `Error: "from" found ${count} times, must be unique`, error: true };
-        }
-        writeFileSync(path, content.replace(oldString, newString), 'utf-8');
-        return { content: `File edited: ${path}` };
-      } catch (err) {
-        return { content: `Error: ${err instanceof Error ? err.message : 'Unknown error'}`, error: true };
-      }
-    },
-  };
-}

package/src/runtime/codingTools/index.ts

@@ -1,39 +0,0 @@
-/**
- * mu-coding's filesystem + shell tools, packaged as a plugin. Replaces the
- * legacy `createBuiltinPlugin` that lived in mu-core. Tools declare a
- * `permission.matchKey` so agent definitions can authorise them via globs.
- */
-
-import type { Plugin } from 'mu-core';
-import { createBashTool } from './bash';
-import { createEditFileTool } from './edit-file';
-import { createReadFileTool } from './read-file';
-import { createWriteFileTool } from './write-file';
-
-export function createCodingToolsPlugin(): Plugin {
-  let pluginCwd: string | undefined;
-  const getCwd = (): string => pluginCwd ?? process.cwd();
-
-  return {
-    name: 'mu-coding-tools',
-    version: '0.5.0',
-    tools: [
-      createReadFileTool(getCwd),
-      createWriteFileTool(getCwd),
-      createEditFileTool(getCwd),
-      createBashTool(getCwd),
-    ],
-    systemPrompt: [
-      'File & shell tools:',
-      '- Prefer `read` over `cat`/`sed`; pass `start`/`end` for large files.',
-      '- Use `edit` for surgical changes; include enough context in `from` to be unique. One `edit` call per change site.',
-      '- Use `write` only for new files or full rewrites.',
-      '- Use `bash` for ops without a dedicated tool (ls, rg, build, tests). Avoid using it to read or rewrite files.',
-    ].join('\n'),
-    activate(ctx) {
-      pluginCwd = ctx.cwd;
-    },
-  };
-}
-
-export { createBashTool, createEditFileTool, createReadFileTool, createWriteFileTool };

package/src/runtime/codingTools/read-file.ts

@@ -1,83 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import type { PluginTool } from 'mu-core';
-import { sanitizePath } from './utils';
-
-function executeReadFileSingle(rawPath: string, cwd: string, start?: number, end?: number): string {
-  const path = sanitizePath(rawPath, cwd);
-  if (!existsSync(path)) {
-    return `Error: File not found: ${path}`;
-  }
-  try {
-    const content = readFileSync(path, 'utf-8');
-    const allLines = content.split('\n');
-    const totalLines = allLines.length;
-
-    const startLine = Math.max(1, start ?? 1);
-    const endLine = end ?? totalLines;
-    const clampedStart = Math.min(startLine, totalLines);
-    const clampedEnd = Math.min(endLine, totalLines);
-
-    if (clampedStart > clampedEnd) {
-      return `Error: start (${startLine}) > end (${endLine})`;
-    }
-
-    const lines = allLines.slice(clampedStart - 1, clampedEnd);
-    const numbered = lines.map((line, i) => `${String(clampedStart + i).padStart(4)} │ ${line}`).join('\n');
-    const rangeLabel = start ? ` (lines ${clampedStart}-${clampedEnd})` : '';
-    const header = `── ${path}${rangeLabel} (${lines.length} lines) ──`;
-    return `${header}\n${numbered}`;
-  } catch (err) {
-    return `Error: ${err instanceof Error ? err.message : 'Unknown error'}`;
-  }
-}
-
-export function createReadFileTool(getCwd: () => string): PluginTool {
-  return {
-    definition: {
-      type: 'function',
-      function: {
-        name: 'read',
-        description: 'Read text file(s) with line numbers. `path` may be a single path or array.',
-        parameters: {
-          type: 'object',
-          properties: {
-            path: { type: ['string', 'array'], items: { type: 'string' } },
-            start: { type: 'integer', description: '1-indexed first line, inclusive.' },
-            end: { type: 'integer', description: '1-indexed last line, inclusive.' },
-          },
-          required: ['path'],
-          additionalProperties: false,
-        },
-      },
-    },
-    display: {
-      verb: 'reading',
-      kind: 'file-read',
-      fields: { path: 'path', start: 'start', end: 'end' },
-    },
-    permission: {
-      matchKey: (args) => {
-        const p = args.path;
-        if (typeof p === 'string') return p;
-        if (Array.isArray(p)) return p[0] as string | undefined;
-        return undefined;
-      },
-    },
-    execute(args) {
-      const paths = Array.isArray(args.path) ? (args.path as string[]) : [args.path as string];
-      const start = args.start as number | undefined;
-      const end = args.end as number | undefined;
-      const cwd = getCwd();
-
-      if (paths.length === 1) {
-        return executeReadFileSingle(paths[0], cwd, start, end);
-      }
-
-      const results: string[] = [];
-      for (const path of paths) {
-        results.push(executeReadFileSingle(path, cwd, start, end));
-      }
-      return results.join('\n\n');
-    },
-  };
-}

package/src/runtime/codingTools/utils.ts

@@ -1,21 +0,0 @@
-import { isAbsolute, resolve } from 'node:path';
-
-/**
- * Sanitize a file path from LLM arguments.
- * Local models often wrap paths in extra quotes or add whitespace.
- *
- * When `cwd` is supplied, relative paths are resolved against it instead of
- * `process.cwd()` — this lets the agent operate on a different working
- * directory than the host process (the host passes its `PluginContext.cwd`
- * into the builtin plugin factory at activation time).
- */
-export function sanitizePath(raw: string, cwd?: string): string {
-  let p = raw.trim();
-  if ((p.startsWith('"') && p.endsWith('"')) || (p.startsWith("'") && p.endsWith("'"))) {
-    p = p.slice(1, -1).trim();
-  }
-  if (cwd && !isAbsolute(p)) {
-    return resolve(cwd, p);
-  }
-  return p;
-}

package/src/runtime/codingTools/write-file.ts

@@ -1,42 +0,0 @@
-import { writeFileSync } from 'node:fs';
-import type { PluginTool } from 'mu-core';
-import { sanitizePath } from './utils';
-
-export function createWriteFileTool(getCwd: () => string): PluginTool {
-  return {
-    definition: {
-      type: 'function',
-      function: {
-        name: 'write',
-        description: 'Create or overwrite a file. Use `edit` for partial changes to existing files.',
-        parameters: {
-          type: 'object',
-          properties: {
-            path: { type: 'string' },
-            content: { type: 'string' },
-          },
-          required: ['path', 'content'],
-          additionalProperties: false,
-        },
-      },
-    },
-    display: {
-      verb: 'writing',
-      kind: 'file-write',
-      fields: { path: 'path', content: 'content' },
-    },
-    permission: {
-      matchKey: (args) => args.path as string | undefined,
-    },
-    execute(args) {
-      const path = sanitizePath(args.path as string, getCwd());
-      const content = args.content as string;
-      try {
-        writeFileSync(path, content, 'utf-8');
-        return { content: `File written: ${path}` };
-      } catch (err) {
-        return { content: `Error: ${err instanceof Error ? err.message : 'Unknown error'}`, error: true };
-      }
-    },
-  };
-}