shmakk 1.1.0

package/src/system-prompt.js

@@ -0,0 +1,261 @@
+// System prompt builder for the agent.
+//
+// Builds the massive structured system prompt from the current workspace
+// state, context profile, skill, and workspace index hints.
+
+function buildSystemPrompt({
+  roots,
+  rootList,
+  indexHint,
+  activeSkillText,
+  maxDiscoveryCallsPerRound,
+  runtimeProfile,
+}) {
+  return `You are an expert AI coding assistant running inside shmakk.
+
+You have access to the user's workspace at:
+${roots[0]}${roots.length > 1 ? `
+
+Additional allowed roots:
+${roots.slice(1).join('\\n')}` : ''}
+
+You can inspect files, edit files, create files/directories, run commands, search the web, and fetch URLs using the available tools.
+
+Your primary objective is to solve the user's coding task correctly by using the actual workspace state, not assumptions.
+
+Core Principles:
+1. Verify before answering.
+   - For questions about existing code, inspect the relevant files before giving conclusions.
+   - Never invent file names, APIs, project structure, dependencies, or behavior.
+
+2. Use tools directly.
+   - When a tool is needed, call it.
+   - Do not ask the user to run commands, inspect files, or make edits manually unless a required tool is unavailable.
+
+3. Make minimal safe changes.
+   - For existing files, prefer precise targeted edits.
+   - For new files, write complete working implementations.
+   - Preserve the project's existing style, architecture, naming, and conventions.
+
+4. Keep the user informed, but do not over-explain.
+   - Before the first tool call in a multi-step task, state the immediate action in one short sentence.
+   - After tool results, summarize findings or changes concisely.
+   - Do not include unrelated prose around tool calls.
+
+5. Protect the workspace.
+   - Do not delete files, overwrite large sections, rename public APIs, change schemas, run destructive commands, or perform broad refactors without explicit user confirmation.
+   - Never expose secrets, credentials, tokens, private keys, environment values, or sensitive paths.
+
+Tool Call Format:
+- If native tool calls are available, use native tool calls only.
+- If native tool calls are not available, output only this exact JSON shape and no prose:
+
+{"shmakk_actions":[{"tool":"tool_name","args":{...}}]}
+
+- Do not use XML tool calls.
+- Do not mix JSON tool calls with explanatory text.
+- Do not wrap JSON tool calls in markdown fences.
+- Do not emit invalid JSON.
+- Do not include comments inside JSON.
+
+Available Tools:
+- list_dir: list files/directories
+- read_file: read file contents
+- write_file: create or overwrite a file
+- make_dir: create a directory
+- run: execute shell commands
+- web_search: search the web
+- fetch_url: fetch a URL
+
+Path Rules:
+- Always use relative paths resolved against ${roots[0]}.
+- File operations are confined to:
+${rootList}
+- Never access files outside the allowed roots.
+- Prefer project-relative paths such as "src/index.js", not absolute paths.
+
+Exploration Rules (strict token discipline):
+- Start with targeted, shallow exploration only.
+- Never read full files by default.
+- First, identify 1-3 likely files; do not scan broad directories unless required.
+- Prefer compact reads before any full-file read.
+- Default read order for large files/code:
+  1. read_file(mode="imports")
+  2. read_file(mode="exports")
+  3. read_file(mode="symbol", query="...")
+  4. read_file(mode="grep", query="...")
+  5. read_file(mode="head" or mode="tail")
+  6. read_file(mode="full") only if still necessary and only once per target file.
+- If enough evidence is already gathered, stop reading and act.
+- Do not re-read unchanged files unless the previous read was insufficient.
+- Before modifying code, inspect only minimal nearby context needed for a safe edit.
+- Hard limit: at most ${maxDiscoveryCallsPerRound} discovery calls per round (read/list/search/fetch) unless you already switched to action calls.
+
+Dependency Files:
+When relevant, check project dependency/config files such as:
+- package.json
+- pnpm-lock.yaml
+- yarn.lock
+- package-lock.json
+- tsconfig.json
+- vite.config.*
+- next.config.*
+- requirements.txt
+- pyproject.toml
+- Cargo.toml
+- go.mod
+- Dockerfile
+- docker-compose.yml
+- README.md
+
+Workflow: Existing Code Questions
+1. List relevant directories.
+2. Read relevant files.
+3. Analyze based on actual code.
+4. Answer with specific file references and concise reasoning.
+
+Workflow: New Feature Implementation
+1. Inspect project structure.
+2. Find similar existing implementations.
+3. Check dependencies and conventions.
+4. Create needed directories.
+5. Write complete implementation.
+6. Add or update tests when appropriate.
+7. Run the smallest relevant verification command.
+8. Summarize what changed and how it was verified.
+
+Workflow: Code Modification
+1. Read the target file and nearby related files.
+2. Identify the minimal safe change.
+3. Apply the change.
+4. Run relevant formatting, typecheck, tests, or diagnostics when available.
+5. Summarize changed files and verification results.
+
+Workflow: Debugging
+1. Inspect the reported error, logs, or failing behavior.
+2. Read relevant source files.
+3. Reproduce the issue when feasible.
+4. Identify the root cause.
+5. Apply the smallest fix.
+6. Verify with a focused command.
+7. Explain the cause and fix briefly.
+
+Workflow: Refactoring
+1. Inspect current implementation thoroughly.
+2. Identify dependencies and public interfaces.
+3. Propose the refactor if it is broad or risky.
+4. Make incremental changes only after confirmation when required.
+5. Preserve existing behavior.
+6. Run tests or checks afterward.
+
+Editing Rules:
+- Preserve formatting style unless the project clearly uses a formatter.
+- Do not rewrite entire files unless necessary.
+- Do not introduce new dependencies unless necessary.
+- Do not change unrelated code.
+- Do not remove comments unless they are wrong or obsolete.
+- Do not silently change public behavior.
+- Keep error handling explicit and appropriate for the language/framework.
+
+Testing and Verification:
+- Prefer the smallest relevant check first.
+- Use existing scripts when available, such as:
+  - npm test
+  - npm run test
+  - npm run typecheck
+  - npm run lint
+  - pnpm test
+  - pytest
+  - cargo test
+  - go test ./...
+- If verification fails, inspect the failure and fix if it is within scope.
+- If verification cannot be run, explain why.
+
+Command Safety:
+Never run destructive or high-risk commands without explicit confirmation, including:
+- rm -rf
+- git reset --hard
+- git clean
+- force pushes
+- database migrations that mutate data
+- commands that delete, encrypt, overwrite, or mass-modify files
+- commands that install global packages
+- commands that expose secrets
+
+Git Rules:
+- Do not create commits unless the user asks.
+- Do not switch branches unless the user asks.
+- Do not discard user changes.
+- Before risky edits, check current file state if needed.
+
+Security Rules:
+- Treat .env files, credentials, API keys, private keys, tokens, and secrets as sensitive.
+- Do not print secret values.
+- Do not write secrets into source code.
+- Use environment variables or existing secret-management patterns.
+- Validate untrusted input.
+- Avoid unsafe eval, shell injection, SQL injection, path traversal, XSS, SSRF, insecure randomness, and overly broad permissions.
+
+Web Usage:
+- Use web_search or fetch_url for current documentation, dependency behavior, APIs, error messages, or recently changed tooling.
+- Prefer official documentation and primary sources.
+- Do not browse when the answer is fully determined by the local codebase.
+
+Response Style:
+- Be concise.
+- Be specific.
+- Mention files changed.
+- Mention commands run and whether they passed.
+- If uncertain, say what is unknown and what evidence is missing.
+- Do not claim success unless the tool results support it.
+
+After Tool Completion:
+Provide a concise final summary with:
+1. What was inspected or changed
+2. Verification performed
+3. Any remaining caveats or next steps
+
+Examples:
+
+Correct fallback JSON tool call:
+{"shmakk_actions":[{"tool":"list_dir","args":{"path":"src"}}]}
+
+Correct fallback JSON tool call:
+{"shmakk_actions":[{"tool":"read_file","args":{"path":"package.json"}}]}
+
+Correct fallback JSON tool call:
+{"shmakk_actions":[{"tool":"run","args":{"cmd":"npm test"}}]}
+
+Incorrect:
+I will check the src directory:
+{"shmakk_actions":[{"tool":"list_dir","args":{"path":"src"}}]}
+
+Incorrect:
+\`\`\`json
+{"shmakk_actions":[{"tool":"list_dir","args":{"path":"src"}}]}
+\`\`\`
+
+Incorrect:
+Can you run npm test for me?
+
+Incorrect:
+I assume this is a React project.
+
+Remember:
+- Inspect first.
+- Use tools directly.
+- Prefer minimal edits.
+- Verify when possible.
+- Use only native tool calls or the exact JSON fallback.
+
+Final rule:
+Never output XML, markdown, or prose when calling a tool.
+Use native tool calls if available.
+Otherwise output only:
+{"shmakk_actions":[{"tool":"tool_name","args":{...}}]}
+${indexHint}
+${activeSkillText ? `\n\n${activeSkillText}` : ''}
+`;
+}
+
+module.exports = { buildSystemPrompt };

package/src/tools.js

@@ -0,0 +1,386 @@
+// Tool definitions, classification, dispatch, and fallback parsing.
+// Extracted from agent.js. Depends on ./safety and ./web for run/search/fetch.
+
+const fs = require('fs');
+const path = require('path');
+const { execFile } = require('child_process');
+const { classifyRunCommand, isSecretPath } = require('./safety');
+const { webSearch, fetchUrl } = require('./web');
+
+const MAX_FILE_BYTES = 64 * 1024;
+
+// Resolve a path against a list of allowed roots. Returns the absolute
+// path if it lies inside any root, or null otherwise. The first root in
+// the list is used as the base for relative resolution.
+function within(roots, p) {
+  if (!roots || !roots.length) return null;
+  if (typeof p !== 'string' || !p.trim()) return null;
+  const base = path.resolve(roots[0]);
+  const abs = path.isAbsolute(p) ? path.resolve(p) : path.resolve(base, p);
+  for (const r of roots) {
+    const rr = path.resolve(r);
+    if (abs === rr || abs.startsWith(rr + path.sep)) return abs;
+  }
+  return null;
+}
+
+const TOOLS = [
+  { type: 'function', function: {
+    name: 'read_file',
+    description: 'Read a UTF-8 file inside the workspace. Supports compact partial reads.',
+    parameters: {
+      type: 'object',
+      required: ['path'],
+      properties: {
+        path: { type: 'string' },
+        mode: { type: 'string', enum: ['full', 'head', 'tail', 'grep', 'imports', 'exports', 'symbol'] },
+        max_lines: { type: 'number', minimum: 1, maximum: 400 },
+        query: { type: 'string' },
+      },
+    },
+  }},
+  { type: 'function', function: {
+    name: 'write_file',
+    description: 'Write or overwrite a UTF-8 file inside the workspace.',
+    parameters: { type: 'object', required: ['path', 'content'], properties: { path: { type: 'string' }, content: { type: 'string' } } },
+  }},
+  { type: 'function', function: {
+    name: 'edit_file',
+    description: 'Edit an existing UTF-8 file inside the workspace by replacing a specific string with a new string.',
+    parameters: {
+      type: 'object',
+      required: ['path', 'old_string', 'new_string'],
+      properties: {
+        path: { type: 'string' },
+        old_string: { type: 'string' },
+        new_string: { type: 'string' },
+      },
+    },
+  }},
+  { type: 'function', function: {
+    name: 'make_dir',
+    description: 'Create a directory inside the workspace, including parents.',
+    parameters: { type: 'object', required: ['path'], properties: { path: { type: 'string' } } },
+  }},
+  { type: 'function', function: {
+    name: 'list_dir',
+    description: 'List entries in a directory inside the workspace.',
+    parameters: { type: 'object', required: ['path'], properties: { path: { type: 'string' } } },
+  }},
+  { type: 'function', function: {
+    name: 'run',
+    description: 'Run a non-interactive shell command inside the workspace. Output is captured.',
+    parameters: { type: 'object', required: ['cmd'], properties: { cmd: { type: 'string' } } },
+  }},
+  { type: 'function', function: {
+    name: 'web_search',
+    description: 'Search the web for current information. Returns titles, URLs, and snippets.',
+    parameters: {
+      type: 'object',
+      required: ['query'],
+      properties: {
+        query: { type: 'string' },
+        max_results: { type: 'number', minimum: 1, maximum: 10 },
+      },
+    },
+  }},
+  { type: 'function', function: {
+    name: 'fetch_url',
+    description: 'Fetch text from an http(s) URL for source checking. Output is size-limited.',
+    parameters: { type: 'object', required: ['url'], properties: { url: { type: 'string' } } },
+  }},
+  { type: 'function', function: {
+    name: 'delete_file',
+    description: 'Delete a file inside the workspace. Always requires user confirmation.',
+    parameters: { type: 'object', required: ['path'], properties: { path: { type: 'string' } } },
+  }},
+];
+
+// Tool safety classification.
+// 'safe'      → auto mode runs it without asking; review mode asks with [Y/n]
+// 'unsafe'    → both modes ask, defaulting to No  ([y/N])
+// 'uncertain' → both modes ask, defaulting to No  ([y/N])
+function classifyTool(name, args) {
+  if (name === 'read_file' || name === 'list_dir') {
+    if (args.path && isSecretPath(args.path)) return 'unsafe';
+    return 'safe';
+  }
+  if (name === 'write_file') {
+    if (args.path && isSecretPath(args.path)) return 'unsafe';
+    return 'uncertain';
+  }
+  if (name === 'make_dir') {
+    if (args.path && isSecretPath(args.path)) return 'unsafe';
+    return 'safe';
+  }
+  if (name === 'delete_file') return 'unsafe'; // user wants delete to always prompt
+  if (name === 'run') return classifyRunCommand(args.cmd || '');
+  if (name === 'web_search' || name === 'fetch_url') return 'safe';
+  return 'uncertain';
+}
+
+function describeTool(name, args) {
+  if (name === 'read_file') return `read_file ${args.path}${args.mode ? ` [${args.mode}]` : ''}`;
+  if (name === 'list_dir') return `list_dir ${args.path || '.'}`;
+  if (name === 'write_file') return `write_file ${args.path} (${(args.content || '').length} bytes)`;
+  if (name === 'edit_file') return `edit_file ${args.path} (${(args.old_string || '').slice(0, 40)}…)`;
+  if (name === 'make_dir') return `make_dir ${args.path}`;
+  if (name === 'delete_file') return `delete_file ${args.path}`;
+  if (name === 'run') return `run: ${args.cmd}`;
+  if (name === 'web_search') return `web_search ${args.query}`;
+  if (name === 'fetch_url') return `fetch_url ${args.url}`;
+  return `${name} ${JSON.stringify(args).slice(0, 80)}`;
+}
+
+function runCmd(cwd, cmd, signal) {
+  return new Promise((resolve) => {
+    let removeAbortListener = null;
+    const child = execFile('/bin/sh', ['-c', cmd], { cwd, timeout: 15000, maxBuffer: 64 * 1024 },
+      (err, stdout, stderr) => {
+        if (removeAbortListener) removeAbortListener();
+        resolve({
+          exitCode: err ? (err.code || 1) : 0,
+          stdout: (stdout || '').toString().slice(-32000),
+          stderr: (stderr || '').toString().slice(-32000),
+          aborted: signal && signal.aborted ? true : undefined,
+        });
+      });
+    if (signal) {
+      const onAbort = () => { try { child.kill('SIGINT'); } catch {} setTimeout(() => { try { child.kill('SIGKILL'); } catch {} }, 500); };
+      if (signal.aborted) onAbort();
+      else {
+        signal.addEventListener('abort', onAbort, { once: true });
+        removeAbortListener = () => signal.removeEventListener('abort', onAbort);
+      }
+    }
+  });
+}
+
+async function dispatchTool(name, args, roots, confirmTool, signal) {
+  if (signal && signal.aborted) return { error: 'aborted' };
+  const safety = classifyTool(name, args);
+  if (confirmTool) {
+    const ok = await confirmTool({ name, args, safety, description: describeTool(name, args) });
+    if (!ok) return { error: 'user declined' };
+  }
+  if (signal && signal.aborted) return { error: 'aborted' };
+  if (name === 'read_file') {
+    const p = within(roots, args.path);
+    if (!p) return { error: 'path outside workspace' };
+    try {
+      const buf = fs.readFileSync(p);
+      const text = buf.slice(0, MAX_FILE_BYTES).toString('utf8');
+      const lines = text.split(/\r?\n/);
+      const mode = args.mode || 'full';
+      const maxLines = Math.max(1, Math.min(400, Number(args.max_lines) || 80));
+      if (mode === 'head') {
+        return { content: lines.slice(0, maxLines).join('\n'), mode, truncated: lines.length > maxLines };
+      }
+      if (mode === 'tail') {
+        return { content: lines.slice(-maxLines).join('\n'), mode, truncated: lines.length > maxLines };
+      }
+      if (mode === 'grep') {
+        const q = String(args.query || '').toLowerCase();
+        if (!q) return { error: 'query required for grep mode' };
+        const hits = [];
+        for (let i = 0; i < lines.length; i++) {
+          if (!lines[i].toLowerCase().includes(q)) continue;
+          const start = Math.max(0, i - 2);
+          const end = Math.min(lines.length, i + 3);
+          hits.push(lines.slice(start, end).join('\n'));
+          if (hits.length >= 5) break;
+        }
+        return { content: hits.join('\n---\n'), mode, truncated: hits.length >= 5 };
+      }
+      if (mode === 'imports') {
+        const out = lines.filter((line) => /\bimport\b|require\(/.test(line)).slice(0, maxLines).join('\n');
+        return { content: out, mode, truncated: out.split(/\r?\n/).length >= maxLines };
+      }
+      if (mode === 'exports') {
+        const out = lines.filter((line) => /\bexport\b|module\.exports/.test(line)).slice(0, maxLines).join('\n');
+        return { content: out, mode, truncated: out.split(/\r?\n/).length >= maxLines };
+      }
+      if (mode === 'symbol') {
+        const q = String(args.query || '').toLowerCase();
+        if (!q) return { error: 'query required for symbol mode' };
+        for (let i = 0; i < lines.length; i++) {
+          if (!lines[i].toLowerCase().includes(q)) continue;
+          const start = Math.max(0, i - 8);
+          const end = Math.min(lines.length, i + Math.max(12, maxLines));
+          return { content: lines.slice(start, end).join('\n'), mode, truncated: end < lines.length };
+        }
+        return { error: `symbol/query not found: ${args.query}` };
+      }
+      return { content: text, mode: 'full', truncated: buf.length > MAX_FILE_BYTES };
+    } catch (e) { return { error: String(e.message) }; }
+  }
+  if (name === 'list_dir') {
+    const p = within(roots, args.path || '.');
+    if (!p) return { error: 'path outside workspace' };
+    try {
+      const ents = fs.readdirSync(p, { withFileTypes: true })
+        .map((e) => ({ name: e.name, type: e.isDirectory() ? 'dir' : 'file' }));
+      return { entries: ents };
+    } catch (e) { return { error: String(e.message) }; }
+  }
+  if (name === 'write_file') {
+    const p = within(roots, args.path);
+    if (!p) return { error: 'path outside workspace' };
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, args.content ?? '');
+    return { ok: true };
+  }
+  if (name === 'edit_file') {
+    const p = within(roots, args.path);
+    if (!p) return { error: 'path outside workspace' };
+    try {
+      const content = fs.readFileSync(p, 'utf8');
+      const oldString = String(args.old_string ?? '');
+      const newString = String(args.new_string ?? '');
+      if (!oldString) return { error: 'old_string is required' };
+      const first = content.indexOf(oldString);
+      if (first === -1) return { error: 'old_string not found' };
+      const second = content.indexOf(oldString, first + oldString.length);
+      if (second !== -1) return { error: 'old_string is ambiguous; appears multiple times' };
+      const updated = content.slice(0, first) + newString + content.slice(first + oldString.length);
+      fs.writeFileSync(p, updated);
+      return { ok: true, replaced: 1 };
+    } catch (e) { return { error: String(e.message) }; }
+  }
+  if (name === 'make_dir') {
+    const p = within(roots, args.path);
+    if (!p) return { error: 'path outside workspace' };
+    fs.mkdirSync(p, { recursive: true });
+    return { ok: true };
+  }
+  if (name === 'delete_file') {
+    const p = within(roots, args.path);
+    if (!p) return { error: 'path outside workspace' };
+    try { fs.rmSync(p, { force: true }); return { ok: true }; }
+    catch (e) { return { error: String(e.message) }; }
+  }
+  if (name === 'run') {
+    // run from the first root as cwd
+    return await runCmd(roots[0], args.cmd, signal);
+  }
+  if (name === 'web_search') {
+    return await webSearch(args.query, args.max_results, signal);
+  }
+  if (name === 'fetch_url') {
+    return await fetchUrl(args.url, signal);
+  }
+  return { error: `unknown tool: ${name}` };
+}
+
+// ── Tool call normalization & budgeting ────────────────────────────────────
+
+function normalizeToolCalls(rawToolCalls, iter) {
+  const calls = [];
+  let seq = 0;
+  for (const tc of rawToolCalls || []) {
+    if (!tc || tc.type !== 'function') continue;
+    const name = String(tc.function?.name || '').trim();
+    if (!name) continue;
+    const id = String(tc.id || '').trim() || `tc_${iter}_${seq++}`;
+    const argsRaw = typeof tc.function?.arguments === 'string' ? tc.function.arguments : '';
+    calls.push({
+      id,
+      type: 'function',
+      function: {
+        name,
+        arguments: argsRaw || '{}',
+      },
+    });
+  }
+  return calls;
+}
+
+function applyRoundToolBudget(toolCalls, maxDiscoveryCalls) {
+  const discovery = new Set(['read_file', 'list_dir', 'web_search', 'fetch_url']);
+  const actionCalls = [];
+  const discoveryCalls = [];
+  for (const c of toolCalls) {
+    if (discovery.has(c.function?.name)) discoveryCalls.push(c);
+    else actionCalls.push(c);
+  }
+  // Progress-first bias: execute action calls first, then only a small discovery budget.
+  return [...actionCalls, ...discoveryCalls.slice(0, maxDiscoveryCalls)];
+}
+
+// ── Fallback action parsing (text-based tool calls) ─────────────────────────
+
+function stripJsonFence(s) {
+  const t = String(s || '').trim();
+  const m = /^```(?:json)?\s*([\s\S]*?)\s*```$/i.exec(t);
+  return m ? m[1].trim() : t;
+}
+
+function parseFallbackActions(content) {
+  const text = stripJsonFence(content);
+  if (!text) return [];
+
+  let obj = null;
+  try {
+    obj = JSON.parse(text);
+  } catch {
+    const start = text.indexOf('{');
+    const end = text.lastIndexOf('}');
+    if (start === -1 || end <= start) return [];
+    try { obj = JSON.parse(text.slice(start, end + 1)); } catch { return []; }
+  }
+
+  const rawActions = Array.isArray(obj?.shmakk_actions) ? obj.shmakk_actions : [];
+  const allowed = new Set(TOOLS.map((t) => t.function.name));
+  const actions = [];
+  for (const a of rawActions) {
+    const name = a?.tool || a?.name;
+    const args = a?.args && typeof a.args === 'object' ? a.args : {};
+    if (allowed.has(name)) actions.push({ name, args });
+  }
+  return actions;
+}
+
+function parseXmlFallbackActions(content) {
+  const text = String(content || '');
+  if (!text) return [];
+  const allowed = new Set(TOOLS.map((t) => t.function.name));
+  const actions = [];
+
+  const tcRe = /<tool_call>([\s\S]*?)<\/tool_call>/gi;
+  let m;
+  while ((m = tcRe.exec(text))) {
+    const block = m[1];
+    const fnMatch = /<function\s*=\s*([a-zA-Z0-9_]+)\s*>([\s\S]*?)<\/function>/i.exec(block);
+    if (!fnMatch) continue;
+    const name = fnMatch[1];
+    if (!allowed.has(name)) continue;
+    const body = fnMatch[2] || '';
+    const args = {};
+    const pRe = /<parameter\s*=\s*([a-zA-Z0-9_]+)\s*>([\s\S]*?)<\/parameter>/gi;
+    let p;
+    while ((p = pRe.exec(body))) {
+      const k = p[1];
+      const raw = (p[2] || '').trim();
+      if (/^(true|false)$/i.test(raw)) args[k] = /^true$/i.test(raw);
+      else if (/^-?\d+(?:\.\d+)?$/.test(raw)) args[k] = Number(raw);
+      else args[k] = raw;
+    }
+    actions.push({ name, args });
+  }
+
+  return actions;
+}
+
+module.exports = {
+  TOOLS,
+  classifyTool,
+  describeTool,
+  dispatchTool,
+  runCmd,
+  normalizeToolCalls,
+  applyRoundToolBudget,
+  within,
+  parseFallbackActions,
+  parseXmlFallbackActions,
+  stripJsonFence,
+};