@opencoven/coven-code 0.0.1

package/src/tools/builtin/finder.mjs

@@ -0,0 +1,73 @@
+import { resolvePermissionDecision } from '../../commands/permissions.mjs';
+import { runPluginEventHandlers } from '../../plugins/discover.mjs';
+import { listThreads, threadSearchText } from '../../threads/store.mjs';
+import { isToolDisabled } from '../toolbox.mjs';
+import {
+  applyToolCallDecision,
+  createToolUseID,
+  permissionDeniedOutput,
+  pluginTextToolRunResult,
+  pluginToolCallEvent,
+  pluginToolResultEvent,
+  pluginToolUseBlock,
+  toolCallDecisionToolRun,
+  validateToolCallDecision,
+} from './runtime.mjs';
+
+export const TOOL_NAME = 'finder';
+
+export async function executePromptFinderToolRequest(request, parsed = {}, plugins = { handlers: {} }, threadId = '', toolName = TOOL_NAME) {
+  if (isToolDisabled(toolName, 'built-in', parsed)) return { output: `Tool disabled: ${toolName}` };
+  request = { ...request, flags: normalizeFinderInput(request.flags) };
+  if (!request.flags.query) return { output: `${toolName} requires --query` };
+  const toolUseID = createToolUseID();
+  const callDecision = await runPluginEventHandlers(
+    plugins.handlers['tool.call'],
+    pluginToolCallEvent(toolName, request.flags, threadId, toolUseID),
+    validateToolCallDecision,
+  );
+  const callResult = applyToolCallDecision(toolName, request, callDecision);
+  if (callResult.output) return toolCallDecisionToolRun(toolName, request.flags, toolUseID, callResult);
+  request = { ...callResult.request, flags: normalizeFinderInput(callResult.request.flags) };
+  const decision = resolvePermissionDecision(toolName, request.flags, parsed, { threadId });
+  if (!parsed.dangerouslyAllowAll && decision.action !== 'allow') {
+    return {
+      output: permissionDeniedOutput(toolName, decision),
+      permissionDenials: [{ tool: toolName, action: decision.action, reason: 'permission' }],
+    };
+  }
+  const output = findThreadsBuiltin(request.flags.query, request.flags.limit);
+  const resultDecision = await runPluginEventHandlers(
+    plugins.handlers['tool.result'],
+    pluginToolResultEvent(toolName, request.flags, 'done', output, threadId, toolUseID),
+  );
+  return {
+    ...pluginTextToolRunResult(resultDecision, output),
+    toolUse: pluginToolUseBlock(toolName, request.flags, toolUseID),
+  };
+}
+
+function normalizeFinderInput(input = {}) {
+  const query = input.query ?? input.q ?? input.search ?? input.task ?? input.file;
+  const limit = Number.parseInt(String(input.limit ?? input.count ?? 10), 10);
+  return {
+    ...input,
+    query: query ? String(query) : '',
+    limit: Number.isFinite(limit) && limit > 0 ? Math.min(limit, 50) : 10,
+  };
+}
+
+function findThreadsBuiltin(query, limit = 10) {
+  const normalizedQuery = query.toLowerCase();
+  const rows = listThreads()
+    .filter((thread) => threadSearchText(thread).toLowerCase().includes(normalizedQuery))
+    .slice(0, limit)
+    .map((thread) => [
+      thread.id,
+      thread.archived ? 'archived' : 'active',
+      thread.visibility ?? 'private',
+      thread.labels?.length ? thread.labels.join(',') : '-',
+      thread.title,
+    ].join('\t'));
+  return rows.length ? rows.join('\n') : `No threads found for ${query}`;
+}

package/src/tools/builtin/glob.mjs

@@ -0,0 +1,74 @@
+import path from 'node:path';
+import { resolvePermissionDecision } from '../../commands/permissions.mjs';
+import { runPluginEventHandlers } from '../../plugins/discover.mjs';
+import { globToRegex, walkFiles } from '../../util/glob.mjs';
+import { isToolDisabled } from '../toolbox.mjs';
+import {
+  applyToolCallDecision,
+  createToolUseID,
+  permissionDeniedOutput,
+  pluginTextToolRunResult,
+  pluginToolCallEvent,
+  pluginToolResultEvent,
+  pluginToolUseBlock,
+  relativeToolPath,
+  toolCallDecisionToolRun,
+  validateToolCallDecision,
+} from './runtime.mjs';
+
+export const TOOL_NAME = 'glob';
+
+export async function executePromptGlobToolRequest(request, parsed = {}, plugins = { handlers: {} }, threadId = '') {
+  if (isToolDisabled(TOOL_NAME, 'built-in', parsed)) return { output: `Tool disabled: ${TOOL_NAME}` };
+  request = { ...request, flags: normalizeGlobInput(request.flags) };
+  if (!request.flags.pattern) return { output: 'glob requires --pattern' };
+  const toolUseID = createToolUseID();
+  const callDecision = await runPluginEventHandlers(
+    plugins.handlers['tool.call'],
+    pluginToolCallEvent(TOOL_NAME, request.flags, threadId, toolUseID),
+    validateToolCallDecision,
+  );
+  const callResult = applyToolCallDecision(TOOL_NAME, request, callDecision);
+  if (callResult.output) return toolCallDecisionToolRun(TOOL_NAME, request.flags, toolUseID, callResult);
+  request = { ...callResult.request, flags: normalizeGlobInput(callResult.request.flags) };
+  const decision = resolvePermissionDecision(TOOL_NAME, request.flags, parsed, { threadId });
+  if (!parsed.dangerouslyAllowAll && decision.action !== 'allow') {
+    return {
+      output: permissionDeniedOutput(TOOL_NAME, decision),
+      permissionDenials: [{ tool: TOOL_NAME, action: decision.action, reason: 'permission' }],
+    };
+  }
+  const output = globBuiltinFiles(request.flags.pattern, request.flags.path);
+  const resultDecision = await runPluginEventHandlers(
+    plugins.handlers['tool.result'],
+    pluginToolResultEvent(TOOL_NAME, request.flags, 'done', output, threadId, toolUseID),
+  );
+  return {
+    ...pluginTextToolRunResult(resultDecision, output),
+    toolUse: pluginToolUseBlock(TOOL_NAME, request.flags, toolUseID),
+  };
+}
+
+function normalizeGlobInput(input = {}) {
+  const pattern = input.pattern ?? input.glob ?? input.query;
+  const searchPath = input.path ?? input.dir ?? input.cwd ?? '.';
+  return {
+    ...input,
+    pattern: pattern ? String(pattern) : '',
+    path: searchPath ? String(searchPath) : '.',
+  };
+}
+
+function globBuiltinFiles(pattern, searchPath = '.') {
+  const root = path.isAbsolute(searchPath) ? searchPath : path.resolve(process.cwd(), searchPath);
+  const absolutePattern = path.isAbsolute(pattern) ? path.normalize(pattern) : path.normalize(path.join(root, pattern));
+  const matchers = [globToRegex(absolutePattern)];
+  if (!path.isAbsolute(pattern) && pattern.startsWith('**/')) {
+    matchers.push(globToRegex(path.normalize(path.join(root, pattern.slice('**/'.length)))));
+  }
+  return walkFiles(root)
+    .filter((filePath) => matchers.some((matcher) => matcher.test(path.normalize(filePath))))
+    .map(relativeToolPath)
+    .sort()
+    .join('\n');
+}

package/src/tools/builtin/grep.mjs

@@ -0,0 +1,82 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { resolvePermissionDecision } from '../../commands/permissions.mjs';
+import { runPluginEventHandlers } from '../../plugins/discover.mjs';
+import { walkFiles } from '../../util/glob.mjs';
+import { isToolDisabled } from '../toolbox.mjs';
+import {
+  applyToolCallDecision,
+  createToolUseID,
+  permissionDeniedOutput,
+  pluginTextToolRunResult,
+  pluginToolCallEvent,
+  pluginToolResultEvent,
+  pluginToolUseBlock,
+  relativeToolPath,
+  toolCallDecisionToolRun,
+  validateToolCallDecision,
+} from './runtime.mjs';
+
+export const TOOL_NAME = 'Grep';
+
+export async function executePromptGrepToolRequest(request, parsed = {}, plugins = { handlers: {} }, threadId = '') {
+  if (isToolDisabled(TOOL_NAME, 'built-in', parsed)) return { output: `Tool disabled: ${TOOL_NAME}` };
+  request = { ...request, flags: normalizeGrepInput(request.flags) };
+  if (!request.flags.pattern) return { output: 'Grep requires --pattern' };
+  const toolUseID = createToolUseID();
+  const callDecision = await runPluginEventHandlers(
+    plugins.handlers['tool.call'],
+    pluginToolCallEvent(TOOL_NAME, request.flags, threadId, toolUseID),
+    validateToolCallDecision,
+  );
+  const callResult = applyToolCallDecision(TOOL_NAME, request, callDecision);
+  if (callResult.output) return toolCallDecisionToolRun(TOOL_NAME, request.flags, toolUseID, callResult);
+  request = { ...callResult.request, flags: normalizeGrepInput(callResult.request.flags) };
+  const decision = resolvePermissionDecision(TOOL_NAME, request.flags, parsed, { threadId });
+  if (!parsed.dangerouslyAllowAll && decision.action !== 'allow') {
+    return {
+      output: permissionDeniedOutput(TOOL_NAME, decision),
+      permissionDenials: [{ tool: TOOL_NAME, action: decision.action, reason: 'permission' }],
+    };
+  }
+  const output = grepBuiltinFiles(request.flags.pattern, request.flags.path);
+  const resultDecision = await runPluginEventHandlers(
+    plugins.handlers['tool.result'],
+    pluginToolResultEvent(TOOL_NAME, request.flags, 'done', output, threadId, toolUseID),
+  );
+  return {
+    ...pluginTextToolRunResult(resultDecision, output),
+    toolUse: pluginToolUseBlock(TOOL_NAME, request.flags, toolUseID),
+  };
+}
+
+function normalizeGrepInput(input = {}) {
+  const pattern = input.pattern ?? input.regex ?? input.query;
+  const searchPath = input.path ?? input.dir ?? input.cwd ?? '.';
+  return {
+    ...input,
+    pattern: pattern ? String(pattern) : '',
+    path: searchPath ? String(searchPath) : '.',
+  };
+}
+
+function grepBuiltinFiles(pattern, searchPath = '.') {
+  const root = path.isAbsolute(searchPath) ? searchPath : path.resolve(process.cwd(), searchPath);
+  const files = walkFiles(root).sort();
+  const re = new RegExp(pattern);
+  const matches = [];
+  for (const filePath of files) {
+    let content = '';
+    try {
+      content = readFileSync(filePath, 'utf8');
+    } catch {
+      continue;
+    }
+    const lines = content.split(/\r?\n/);
+    for (let index = 0; index < lines.length; index += 1) {
+      if (!re.test(lines[index])) continue;
+      matches.push(`${relativeToolPath(filePath)}:${index + 1}:${lines[index]}`);
+    }
+  }
+  return matches.join('\n');
+}

package/src/tools/builtin/index.mjs

@@ -0,0 +1,83 @@
+import { loadPlugins } from '../../plugins/discover.mjs';
+import { parseToolUseArgs } from '../toolbox.mjs';
+import { splitShellWords } from '../../util/shell.mjs';
+import { executePromptBashToolRequest } from './bash.mjs';
+import { executePromptCreateFileToolRequest } from './create-file.mjs';
+import { executePromptEditFileToolRequest } from './edit-file.mjs';
+import { executePromptFinderToolRequest } from './finder.mjs';
+import { executePromptGlobToolRequest } from './glob.mjs';
+import { executePromptGrepToolRequest } from './grep.mjs';
+import { executePromptLibrarianToolRequest } from './librarian.mjs';
+import { executePromptLookAtToolRequest } from './look-at.mjs';
+import { executePromptMcpToolRequest } from './mcp.mjs';
+import { executePromptMermaidToolRequest } from './mermaid.mjs';
+import { executePromptOracleToolRequest } from './oracle.mjs';
+import { executePromptPainterToolRequest } from './painter.mjs';
+import { executePromptPluginToolRequest } from './plugin-tool.mjs';
+import { executePromptReadMcpResourceToolRequest } from './read-mcp-resource.mjs';
+import { executePromptReadToolRequest } from './read.mjs';
+import { executePromptReadWebPageToolRequest } from './read-web-page.mjs';
+import { executePromptTaskToolRequest } from './task.mjs';
+import { executePromptToolboxToolRequest } from './toolbox-tool.mjs';
+import { executePromptUndoEditToolRequest } from './undo-edit.mjs';
+import { executePromptWebSearchToolRequest } from './web-search.mjs';
+
+const BUILTIN_DISPATCH = new Map([
+  ['Bash', (request, stdin, parsed, plugins, threadId) =>
+    executePromptBashToolRequest(request, stdin, parsed, plugins, threadId)],
+  ['Read', (request, _stdin, parsed, plugins, threadId) =>
+    executePromptReadToolRequest(request, parsed, plugins, threadId)],
+  ['Grep', (request, _stdin, parsed, plugins, threadId) =>
+    executePromptGrepToolRequest(request, parsed, plugins, threadId)],
+  ['glob', (request, _stdin, parsed, plugins, threadId) =>
+    executePromptGlobToolRequest(request, parsed, plugins, threadId)],
+  ['create_file', (request, _stdin, parsed, plugins, threadId) =>
+    executePromptCreateFileToolRequest(request, parsed, plugins, threadId)],
+  ['edit_file', (request, _stdin, parsed, plugins, threadId) =>
+    executePromptEditFileToolRequest(request, parsed, plugins, threadId)],
+  ['undo_edit', (request, _stdin, parsed, plugins, threadId) =>
+    executePromptUndoEditToolRequest(request, parsed, plugins, threadId)],
+  ['Task', (request, _stdin, parsed, plugins, threadId) =>
+    executePromptTaskToolRequest(request, parsed, plugins, threadId)],
+  ['oracle', (request, _stdin, parsed, plugins, threadId) =>
+    executePromptOracleToolRequest(request, parsed, plugins, threadId)],
+  ['librarian', (request, _stdin, parsed, plugins, threadId) =>
+    executePromptLibrarianToolRequest(request, parsed, plugins, threadId)],
+  ['painter', (request, _stdin, parsed, plugins, threadId) =>
+    executePromptPainterToolRequest(request, parsed, plugins, threadId)],
+  ['mermaid', (request, _stdin, parsed, plugins, threadId) =>
+    executePromptMermaidToolRequest(request, parsed, plugins, threadId)],
+  ['look_at', (request, _stdin, parsed, plugins, threadId) =>
+    executePromptLookAtToolRequest(request, parsed, plugins, threadId)],
+  ['web_search', (request, _stdin, parsed, plugins, threadId) =>
+    executePromptWebSearchToolRequest(request, parsed, plugins, threadId)],
+  ['read_web_page', (request, _stdin, parsed, plugins, threadId) =>
+    executePromptReadWebPageToolRequest(request, parsed, plugins, threadId)],
+  ['find_thread', (request, _stdin, parsed, plugins, threadId) =>
+    executePromptFinderToolRequest(request, parsed, plugins, threadId, 'find_thread')],
+  ['finder', (request, _stdin, parsed, plugins, threadId) =>
+    executePromptFinderToolRequest(request, parsed, plugins, threadId)],
+  ['read_mcp_resource', (request, _stdin, parsed, plugins, threadId) =>
+    executePromptReadMcpResourceToolRequest(request, parsed, plugins, threadId)],
+]);
+
+export async function executePromptToolRequest(prompt, stdin, threadId, parsed = {}, plugins) {
+  const request = parsePromptToolRequest(prompt);
+  if (!request) return undefined;
+  const resolvedPlugins = plugins ?? await loadPlugins(process.cwd());
+  if (request.toolName.startsWith('mcp__')) {
+    return executePromptMcpToolRequest(request, parsed, threadId, resolvedPlugins);
+  }
+  const builtin = BUILTIN_DISPATCH.get(request.toolName);
+  if (builtin) return builtin(request, stdin, parsed, resolvedPlugins, threadId);
+  const pluginTool = resolvedPlugins.tools.find((entry) => entry.name === request.toolName);
+  if (pluginTool) return executePromptPluginToolRequest(pluginTool, request, parsed, resolvedPlugins, threadId);
+  return executePromptToolboxToolRequest(request, stdin, parsed, resolvedPlugins, threadId);
+}
+
+export function parsePromptToolRequest(prompt) {
+  const match = prompt.match(/\b(?:use|run|call)\s+([A-Za-z0-9_-]+(?:__[A-Za-z0-9_-]+)?)([^\r\n]*)/i);
+  if (!match) return undefined;
+  const useArgs = parseToolUseArgs([match[1], ...splitShellWords(match[2] ?? '')]);
+  return { toolName: useArgs.toolName, flags: useArgs.flags };
+}

package/src/tools/builtin/librarian.mjs

@@ -0,0 +1,97 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { resolvePermissionDecision } from '../../commands/permissions.mjs';
+import { runPluginEventHandlers } from '../../plugins/discover.mjs';
+import { walkFiles } from '../../util/glob.mjs';
+import { isToolDisabled } from '../toolbox.mjs';
+import {
+  applyToolCallDecision,
+  createToolUseID,
+  permissionDeniedOutput,
+  pluginTextToolRunResult,
+  pluginToolCallEvent,
+  pluginToolResultEvent,
+  pluginToolUseBlock,
+  toolCallDecisionToolRun,
+  validateToolCallDecision,
+} from './runtime.mjs';
+
+export const TOOL_NAME = 'librarian';
+
+export async function executePromptLibrarianToolRequest(request, parsed = {}, plugins = { handlers: {} }, threadId = '') {
+  if (isToolDisabled(TOOL_NAME, 'built-in', parsed)) return { output: `Tool disabled: ${TOOL_NAME}` };
+  request = { ...request, flags: normalizeLibrarianInput(request.flags) };
+  if (!request.flags.query) return { output: 'librarian requires --query' };
+  const toolUseID = createToolUseID();
+  const callDecision = await runPluginEventHandlers(
+    plugins.handlers['tool.call'],
+    pluginToolCallEvent(TOOL_NAME, request.flags, threadId, toolUseID),
+    validateToolCallDecision,
+  );
+  const callResult = applyToolCallDecision(TOOL_NAME, request, callDecision);
+  if (callResult.output) return toolCallDecisionToolRun(TOOL_NAME, request.flags, toolUseID, callResult);
+  request = { ...callResult.request, flags: normalizeLibrarianInput(callResult.request.flags) };
+  const decision = resolvePermissionDecision(TOOL_NAME, request.flags, parsed, { threadId });
+  if (!parsed.dangerouslyAllowAll && decision.action !== 'allow') {
+    return {
+      output: permissionDeniedOutput(TOOL_NAME, decision),
+      permissionDenials: [{ tool: TOOL_NAME, action: decision.action, reason: 'permission' }],
+    };
+  }
+  const output = searchWorkspaceForLibrarian(request.flags);
+  const resultDecision = await runPluginEventHandlers(
+    plugins.handlers['tool.result'],
+    pluginToolResultEvent(TOOL_NAME, request.flags, 'done', output, threadId, toolUseID),
+  );
+  return {
+    ...pluginTextToolRunResult(resultDecision, output),
+    toolUse: pluginToolUseBlock(TOOL_NAME, request.flags, toolUseID),
+  };
+}
+
+function normalizeLibrarianInput(input = {}) {
+  const query = input.query ?? input.q ?? input.prompt ?? input.question ?? input.topic;
+  const limit = Number.parseInt(String(input.limit ?? 5), 10);
+  return {
+    ...input,
+    query: query ? String(query) : '',
+    limit: Number.isFinite(limit) && limit > 0 ? Math.min(limit, 20) : 5,
+  };
+}
+
+function searchWorkspaceForLibrarian(input) {
+  const matches = findWorkspaceTextMatches(input.query, input.limit);
+  return [
+    `Librarian search: ${input.query}`,
+    'scope: current workspace',
+    'matches:',
+    ...(matches.length ? matches.map(formatLibrarianMatch) : ['- no local matches found']),
+  ].join('\n');
+}
+
+function findWorkspaceTextMatches(query, limit) {
+  const needle = query.toLowerCase();
+  const root = process.cwd();
+  return walkFiles(root)
+    .map((filePath) => path.relative(root, filePath))
+    .filter((relativePath) => !relativePath.split(path.sep).some((part) => part === '.git' || part === 'node_modules'))
+    .sort()
+    .flatMap((relativePath) => {
+      let text;
+      try {
+        text = readFileSync(path.join(root, relativePath), 'utf8');
+      } catch {
+        return [];
+      }
+      return text.split(/\r?\n/).flatMap((line, index) => (
+        line.toLowerCase().includes(needle)
+          ? [{ path: relativePath, line: index + 1, text: line.trim() }]
+          : []
+      ));
+    })
+    .slice(0, limit);
+}
+
+function formatLibrarianMatch(match) {
+  return `- ${match.path}:${match.line}: ${match.text}`;
+}

package/src/tools/builtin/look-at.mjs

@@ -0,0 +1,92 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { resolvePermissionDecision } from '../../commands/permissions.mjs';
+import { runPluginEventHandlers } from '../../plugins/discover.mjs';
+import { detectImageMediaType } from '../../util/media.mjs';
+import { isToolDisabled } from '../toolbox.mjs';
+import {
+  applyToolCallDecision,
+  createToolUseID,
+  permissionDeniedOutput,
+  pluginTextToolRunResult,
+  pluginToolCallEvent,
+  pluginToolResultEvent,
+  pluginToolUseBlock,
+  toolCallDecisionToolRun,
+  validateToolCallDecision,
+} from './runtime.mjs';
+
+export const TOOL_NAME = 'look_at';
+
+export async function executePromptLookAtToolRequest(request, parsed = {}, plugins = { handlers: {} }, threadId = '') {
+  if (isToolDisabled(TOOL_NAME, 'built-in', parsed)) return { output: `Tool disabled: ${TOOL_NAME}` };
+  request = { ...request, flags: normalizeLookAtInput(request.flags) };
+  if (!request.flags.path) return { output: 'look_at requires --path' };
+  const toolUseID = createToolUseID();
+  const callDecision = await runPluginEventHandlers(
+    plugins.handlers['tool.call'],
+    pluginToolCallEvent(TOOL_NAME, request.flags, threadId, toolUseID),
+    validateToolCallDecision,
+  );
+  const callResult = applyToolCallDecision(TOOL_NAME, request, callDecision);
+  if (callResult.output) return toolCallDecisionToolRun(TOOL_NAME, request.flags, toolUseID, callResult);
+  request = { ...callResult.request, flags: normalizeLookAtInput(callResult.request.flags) };
+  const decision = resolvePermissionDecision(TOOL_NAME, request.flags, parsed, { threadId });
+  if (!parsed.dangerouslyAllowAll && decision.action !== 'allow') {
+    return {
+      output: permissionDeniedOutput(TOOL_NAME, decision),
+      permissionDenials: [{ tool: TOOL_NAME, action: decision.action, reason: 'permission' }],
+    };
+  }
+  const output = inspectLookAtMedia(request.flags);
+  const resultDecision = await runPluginEventHandlers(
+    plugins.handlers['tool.result'],
+    pluginToolResultEvent(TOOL_NAME, request.flags, 'done', output, threadId, toolUseID),
+  );
+  return {
+    ...pluginTextToolRunResult(resultDecision, output),
+    toolUse: pluginToolUseBlock(TOOL_NAME, request.flags, toolUseID),
+  };
+}
+
+function normalizeLookAtInput(input = {}) {
+  const source = input.path ?? input.file ?? input.image ?? input.pdf ?? input.url;
+  const goal = input.goal ?? input.prompt ?? input.instructions ?? input.question ?? '';
+  return {
+    ...input,
+    path: source ? String(source) : '',
+    goal: String(goal),
+  };
+}
+
+function inspectLookAtMedia(input) {
+  try {
+    const resolved = resolveLookAtPath(input.path);
+    const raw = readFileSync(resolved);
+    return formatLookAtMediaResult(input.path, raw, input.goal);
+  } catch (error) {
+    return `Unable to look at ${input.path}: ${error.message}`;
+  }
+}
+
+function resolveLookAtPath(source) {
+  if (source.startsWith('file://')) return fileURLToPath(source);
+  return path.resolve(process.cwd(), source);
+}
+
+function formatLookAtMediaResult(source, raw, goal) {
+  return [
+    `Looked at: ${source}`,
+    `media_type: ${detectLookAtMediaType(raw)}`,
+    `bytes: ${raw.length}`,
+    `goal: ${goal || '(none)'}`,
+  ].join('\n');
+}
+
+function detectLookAtMediaType(raw) {
+  const imageType = detectImageMediaType(raw);
+  if (imageType) return imageType;
+  if (raw.subarray(0, 5).toString('ascii') === '%PDF-') return 'application/pdf';
+  return 'application/octet-stream';
+}

package/src/tools/builtin/mcp.mjs

@@ -0,0 +1,51 @@
+import { resolvePermissionDecision } from '../../commands/permissions.mjs';
+import { listConfiguredMcpServers } from '../../mcp/discover.mjs';
+import { callMcpTool, isMcpToolIncluded, parseMcpToolName } from '../../mcp/probe.mjs';
+import { runPluginEventHandlers } from '../../plugins/discover.mjs';
+import { isToolDisabled } from '../toolbox.mjs';
+import {
+  applyToolCallDecision,
+  createToolUseID,
+  permissionDeniedOutput,
+  pluginTextToolRunResult,
+  pluginToolCallEvent,
+  pluginToolResultEvent,
+  pluginToolUseBlock,
+  toolCallDecisionToolRun,
+  validateToolCallDecision,
+} from './runtime.mjs';
+
+export async function executePromptMcpToolRequest(request, parsed = {}, threadId = '', plugins = { handlers: {} }) {
+  const parsedName = parseMcpToolName(request.toolName);
+  if (!parsedName) return { output: `Unknown tool: ${request.toolName}` };
+  if (isToolDisabled(request.toolName, 'local-mcp', parsed)) return { output: `Tool disabled: ${request.toolName}` };
+  const toolUseID = createToolUseID();
+  const callDecision = await runPluginEventHandlers(
+    plugins.handlers['tool.call'],
+    pluginToolCallEvent(request.toolName, request.flags, threadId, toolUseID),
+    validateToolCallDecision,
+  );
+  const callResult = applyToolCallDecision(request.toolName, request, callDecision);
+  if (callResult.output) return toolCallDecisionToolRun(request.toolName, request.flags, toolUseID, callResult);
+  request = callResult.request;
+  const decision = resolvePermissionDecision(request.toolName, request.flags, parsed, { threadId });
+  if (!parsed.dangerouslyAllowAll && decision.action !== 'allow') {
+    return {
+      output: permissionDeniedOutput(request.toolName, decision),
+      permissionDenials: [{ tool: request.toolName, action: decision.action, reason: 'permission' }],
+    };
+  }
+  const server = listConfiguredMcpServers(parsed)
+    .find((entry) => entry.name === parsedName.serverName && entry.status === 'approved');
+  if (!server) return { output: `Unknown MCP server: ${parsedName.serverName}` };
+  if (!isMcpToolIncluded(server.config, parsedName.toolName)) return { output: `Tool not available: ${request.toolName}` };
+  const output = await callMcpTool(server.config, parsedName.toolName, request.flags, server.name);
+  const resultDecision = await runPluginEventHandlers(
+    plugins.handlers['tool.result'],
+    pluginToolResultEvent(request.toolName, request.flags, 'done', output, threadId, toolUseID),
+  );
+  return {
+    ...pluginTextToolRunResult(resultDecision, output),
+    toolUse: pluginToolUseBlock(request.toolName, request.flags, toolUseID),
+  };
+}

package/src/tools/builtin/mermaid.mjs

@@ -0,0 +1,59 @@
+import { resolvePermissionDecision } from '../../commands/permissions.mjs';
+import { runPluginEventHandlers } from '../../plugins/discover.mjs';
+import { isToolDisabled } from '../toolbox.mjs';
+import {
+  applyToolCallDecision,
+  createToolUseID,
+  permissionDeniedOutput,
+  pluginTextToolRunResult,
+  pluginToolCallEvent,
+  pluginToolResultEvent,
+  pluginToolUseBlock,
+  toolCallDecisionToolRun,
+  validateToolCallDecision,
+} from './runtime.mjs';
+
+export const TOOL_NAME = 'mermaid';
+
+export async function executePromptMermaidToolRequest(request, parsed = {}, plugins = { handlers: {} }, threadId = '') {
+  if (isToolDisabled(TOOL_NAME, 'built-in', parsed)) return { output: `Tool disabled: ${TOOL_NAME}` };
+  request = { ...request, flags: normalizeMermaidInput(request.flags) };
+  if (!request.flags.code) return { output: 'mermaid requires --code' };
+  const toolUseID = createToolUseID();
+  const callDecision = await runPluginEventHandlers(
+    plugins.handlers['tool.call'],
+    pluginToolCallEvent(TOOL_NAME, request.flags, threadId, toolUseID),
+    validateToolCallDecision,
+  );
+  const callResult = applyToolCallDecision(TOOL_NAME, request, callDecision);
+  if (callResult.output) return toolCallDecisionToolRun(TOOL_NAME, request.flags, toolUseID, callResult);
+  request = { ...callResult.request, flags: normalizeMermaidInput(callResult.request.flags) };
+  const decision = resolvePermissionDecision(TOOL_NAME, request.flags, parsed, { threadId });
+  if (!parsed.dangerouslyAllowAll && decision.action !== 'allow') {
+    return {
+      output: permissionDeniedOutput(TOOL_NAME, decision),
+      permissionDenials: [{ tool: TOOL_NAME, action: decision.action, reason: 'permission' }],
+    };
+  }
+  const output = mermaidOutput(request.flags.code);
+  const resultDecision = await runPluginEventHandlers(
+    plugins.handlers['tool.result'],
+    pluginToolResultEvent(TOOL_NAME, request.flags, 'done', output, threadId, toolUseID),
+  );
+  return {
+    ...pluginTextToolRunResult(resultDecision, output),
+    toolUse: pluginToolUseBlock(TOOL_NAME, request.flags, toolUseID),
+  };
+}
+
+function normalizeMermaidInput(input = {}) {
+  const code = input.code ?? input.diagram ?? input.mermaid ?? input.source;
+  return {
+    ...input,
+    code: code ? String(code) : '',
+  };
+}
+
+function mermaidOutput(code) {
+  return `\`\`\`mermaid\n${String(code).trim()}\n\`\`\``;
+}

package/src/tools/builtin/oracle.mjs

@@ -0,0 +1,56 @@
+import { localAgentResponse } from '../../agent/local.mjs';
+import { resolvePermissionDecision } from '../../commands/permissions.mjs';
+import { runPluginEventHandlers } from '../../plugins/discover.mjs';
+import { isToolDisabled } from '../toolbox.mjs';
+import {
+  applyToolCallDecision,
+  createToolUseID,
+  permissionDeniedOutput,
+  pluginTextToolRunResult,
+  pluginToolCallEvent,
+  pluginToolResultEvent,
+  pluginToolUseBlock,
+  toolCallDecisionToolRun,
+  validateToolCallDecision,
+} from './runtime.mjs';
+
+export const TOOL_NAME = 'oracle';
+
+export async function executePromptOracleToolRequest(request, parsed = {}, plugins = { handlers: {} }, threadId = '') {
+  if (isToolDisabled(TOOL_NAME, 'built-in', parsed)) return { output: `Tool disabled: ${TOOL_NAME}` };
+  request = { ...request, flags: normalizeOracleInput(request.flags) };
+  if (!request.flags.prompt) return { output: 'oracle requires --prompt' };
+  const toolUseID = createToolUseID();
+  const callDecision = await runPluginEventHandlers(
+    plugins.handlers['tool.call'],
+    pluginToolCallEvent(TOOL_NAME, request.flags, threadId, toolUseID),
+    validateToolCallDecision,
+  );
+  const callResult = applyToolCallDecision(TOOL_NAME, request, callDecision);
+  if (callResult.output) return toolCallDecisionToolRun(TOOL_NAME, request.flags, toolUseID, callResult);
+  request = { ...callResult.request, flags: normalizeOracleInput(callResult.request.flags) };
+  const decision = resolvePermissionDecision(TOOL_NAME, request.flags, parsed, { threadId });
+  if (!parsed.dangerouslyAllowAll && decision.action !== 'allow') {
+    return {
+      output: permissionDeniedOutput(TOOL_NAME, decision),
+      permissionDenials: [{ tool: TOOL_NAME, action: decision.action, reason: 'permission' }],
+    };
+  }
+  const output = `Oracle: ${localAgentResponse(request.flags.prompt, '')}`;
+  const resultDecision = await runPluginEventHandlers(
+    plugins.handlers['tool.result'],
+    pluginToolResultEvent(TOOL_NAME, request.flags, 'done', output, threadId, toolUseID),
+  );
+  return {
+    ...pluginTextToolRunResult(resultDecision, output),
+    toolUse: pluginToolUseBlock(TOOL_NAME, request.flags, toolUseID),
+  };
+}
+
+function normalizeOracleInput(input = {}) {
+  const prompt = input.prompt ?? input.question ?? input.query ?? input.message;
+  return {
+    ...input,
+    prompt: prompt ? String(prompt) : '',
+  };
+}