c0de-agent 0.0.0 → 1.1.0

package/dist/tools/builtin/task.js

@@ -0,0 +1,100 @@
+/**
+ * task 工具：按 agent 类型派发子 agent。
+ *
+ * 两种形态：单任务（subagent_type + prompt）或批量并行（subagent_type + context + tasks[]）。
+ * 依赖反转：实际子 agent 运行由 host（core loop 的 runSubAgent）通过 ctx.runSubAgent 执行。
+ * permission: auto（子 agent 是隔离 session，不扩宽父权限）。
+ */
+export const taskTool = {
+    name: 'task',
+    description: 'Launch specialized sub-agents to handle delegated tasks. Specify subagent_type to select a specialist (e.g. researcher for read-only investigation, coder for implementation, reviewer for code review). Launch multiple agents concurrently by using the batch form with tasks[]. The sub-agent runs in an isolated session with its own context. When done, the sub-agent returns its result via the yield tool.',
+    parameters: {
+        type: 'object',
+        properties: {
+            subagent_type: {
+                type: 'string',
+                description: "The specialist agent type (e.g. researcher, coder, reviewer). Defaults to 'general'.",
+            },
+            description: { type: 'string', description: 'Short label for the task (display only).' },
+            prompt: { type: 'string', description: 'Self-contained assignment (single-task mode).' },
+            model: { type: 'string', description: 'Optional model override.' },
+            background: { type: 'boolean', description: 'Run in background (default false).' },
+            context: { type: 'string', description: 'Shared context (batch mode).' },
+            tasks: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: {
+                        description: { type: 'string' },
+                        role: { type: 'string', description: 'Specialist role for this sub-task.' },
+                        assignment: { type: 'string' },
+                    },
+                },
+                description: 'Parallel sub-tasks (batch mode).',
+            },
+        },
+        required: ['prompt'],
+        anyOf: [{ required: ['prompt'] }, { required: ['context', 'tasks'] }],
+    },
+    permission: 'auto',
+    execute: async (input, ctx) => {
+        if (!ctx.runSubAgent) {
+            return {
+                _tag: 'error',
+                error: 'task tool unavailable: no sub-agent runner is wired into this context',
+            };
+        }
+        const inp = input;
+        // 批量模式
+        if ('tasks' in inp && Array.isArray(inp.tasks) && inp.tasks.length > 0) {
+            const agentType = inp.subagent_type ?? 'general';
+            const results = [];
+            for (const item of inp.tasks) {
+                const req = {
+                    agentType,
+                    prompt: item.assignment,
+                    ...(item.description ? { description: item.description } : {}),
+                    ...(item.role ? { role: item.role } : {}),
+                    ...(inp.context ? { context: inp.context } : {}),
+                };
+                const res = await ctx.runSubAgent(req);
+                if (res._tag === 'error') {
+                    return { _tag: 'error', error: `Sub-agent failed: ${res.error}` };
+                }
+                const label = item.description ?? item.role ?? 'task';
+                if (res._tag === 'running') {
+                    results.push(`[${label}] background started (jobId: ${res.jobId})`);
+                }
+                else {
+                    results.push(`[${label}] ${res.output}`);
+                }
+            }
+            return { _tag: 'success', output: results.join('\n\n') };
+        }
+        // 单任务模式
+        const single = inp;
+        const req = {
+            agentType: single.subagent_type ?? 'general',
+            prompt: single.prompt,
+            ...(single.description ? { description: single.description } : {}),
+            ...(single.model ? { model: single.model } : {}),
+            ...(single.background ? { background: true } : {}),
+        };
+        const result = await ctx.runSubAgent(req);
+        if (result._tag === 'error') {
+            return { _tag: 'error', error: `Sub-agent failed: ${result.error}` };
+        }
+        if (result._tag === 'running') {
+            return {
+                _tag: 'success',
+                output: `Background task started (jobId: ${result.jobId}). You will be notified on completion.`,
+                metadata: { sessionId: result.sessionId, background: true, jobId: result.jobId },
+            };
+        }
+        return {
+            _tag: 'success',
+            output: result.output,
+            metadata: { sessionId: result.sessionId, ...(result.data ? { data: result.data } : {}) },
+        };
+    },
+};

package/dist/tools/builtin/write.d.ts

@@ -0,0 +1,6 @@
+import type { ToolDef } from '../../shared/types/tool.js';
+/**
+ * write tool: create or overwrite a file.
+ * Permission: ask (modifies filesystem).
+ */
+export declare const writeTool: ToolDef;

package/dist/tools/builtin/write.js

@@ -0,0 +1,36 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { safeResolve } from '../../shared/utils/path.js';
+/**
+ * write tool: create or overwrite a file.
+ * Permission: ask (modifies filesystem).
+ */
+export const writeTool = {
+    name: 'write',
+    description: 'Create or overwrite a file with the given content. Creates parent directories.',
+    parameters: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'File path (relative to cwd or absolute).' },
+            content: { type: 'string', description: 'Content to write.' },
+        },
+        required: ['path', 'content'],
+    },
+    permission: 'ask',
+    execute: async (input, ctx) => {
+        const { path, content } = input;
+        const fullPath = safeResolve(ctx.cwd, path);
+        if (fullPath === null) {
+            return { _tag: 'error', error: `Path "${path}" escapes the working directory` };
+        }
+        try {
+            await mkdir(dirname(fullPath), { recursive: true });
+            await writeFile(fullPath, content, 'utf-8');
+            return { _tag: 'success', output: `Wrote ${content.length} bytes to ${path}` };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { _tag: 'error', error: `Failed to write "${path}": ${message}` };
+        }
+    },
+};

package/dist/tools/builtin/yield.d.ts

@@ -0,0 +1,9 @@
+import type { ToolDef } from '../../shared/types/tool.js';
+/**
+ * yield 工具：子 agent 专用，提交结构化最终结果。
+ *
+ * 这是子 agent 返回结果的唯一方式。调用后，runSubAgent 的 collectYield
+ * 回调收集结果，子 agent loop 检测到 yield 后优雅终止。
+ * 主 agent 不注册此工具。permission: auto（纯结果收集，不改外部状态）。
+ */
+export declare const yieldTool: ToolDef;

package/dist/tools/builtin/yield.js

@@ -0,0 +1,40 @@
+/**
+ * yield 工具：子 agent 专用，提交结构化最终结果。
+ *
+ * 这是子 agent 返回结果的唯一方式。调用后，runSubAgent 的 collectYield
+ * 回调收集结果，子 agent loop 检测到 yield 后优雅终止。
+ * 主 agent 不注册此工具。permission: auto（纯结果收集，不改外部状态）。
+ */
+export const yieldTool = {
+    name: 'yield',
+    description: 'Submit your final structured result. This is the ONLY way to return a result from a sub-agent task. Call this once when your work is complete.',
+    parameters: {
+        type: 'object',
+        properties: {
+            data: {
+                type: 'object',
+                description: 'Your structured result. Must match the outputSchema if the agent declared one.',
+            },
+            type: {
+                type: 'string',
+                description: 'Optional section label for incremental yields.',
+            },
+            status: {
+                type: 'string',
+                enum: ['success', 'aborted'],
+                description: 'Outcome status. Use "aborted" if blocked.',
+            },
+            error: {
+                type: 'string',
+                description: 'If blocked (status=aborted), describe what you tried and the exact blocker.',
+            },
+        },
+        required: ['data'],
+    },
+    permission: 'auto',
+    execute: async (input, ctx) => {
+        const { data } = input;
+        ctx.collectYield?.(data);
+        return { _tag: 'success', output: 'Result submitted.' };
+    },
+};

package/dist/tools/executor.d.ts

@@ -0,0 +1,9 @@
+import type { ToolContext, ToolResult } from '../shared/types/tool.js';
+import type { PermissionChecker, ToolRegistry } from './types.js';
+/**
+ * Execute a tool by name with full pipeline:
+ * find tool → validate input → check permission → execute → truncate output.
+ *
+ * Returns the ToolResult. Never throws — all errors become { _tag: 'error' }.
+ */
+export declare function executeTool(registry: ToolRegistry, name: string, input: unknown, ctx: ToolContext, permissionChecker: PermissionChecker): Promise<ToolResult>;

package/dist/tools/executor.js

@@ -0,0 +1,54 @@
+import { getTool } from './registry.js';
+import { truncateOutput } from './truncate.js';
+import { validateInput } from './validate.js';
+/**
+ * Execute a tool by name with full pipeline:
+ * find tool → validate input → check permission → execute → truncate output.
+ *
+ * Returns the ToolResult. Never throws — all errors become { _tag: 'error' }.
+ */
+export async function executeTool(registry, name, input, ctx, permissionChecker) {
+    // 0. Check abort signal
+    if (ctx.abort.aborted) {
+        return { _tag: 'error', error: 'Operation aborted before execution' };
+    }
+    // 1. Find tool
+    const tool = getTool(registry, name, { config: {}, cwd: ctx.cwd });
+    if (!tool) {
+        return { _tag: 'error', error: `Tool not found: ${name}` };
+    }
+    // 2. Validate input against JSON Schema
+    const validation = validateInput(tool.parameters, input);
+    if (!validation.valid) {
+        return { _tag: 'error', error: `Invalid input for "${name}": ${validation.error}` };
+    }
+    // 3. Check permission
+    const permission = await permissionChecker.check(tool, input, ctx);
+    if (permission._tag === 'deny') {
+        return { _tag: 'error', error: `Permission denied: ${permission.reason}` };
+    }
+    if (permission._tag === 'ask') {
+        return { _tag: 'permission_required', reason: permission.reason };
+    }
+    // 4. Execute
+    try {
+        const result = await tool.execute(input, ctx);
+        // 5. Truncate large output
+        if (result._tag === 'success') {
+            const truncated = truncateOutput(result.output);
+            if (truncated.truncated) {
+                return {
+                    _tag: 'truncated',
+                    output: truncated.output,
+                    truncated: true,
+                    totalLines: truncated.totalLines,
+                };
+            }
+        }
+        return result;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { _tag: 'error', error: `Tool "${name}" failed: ${message}` };
+    }
+}

package/dist/tools/hashline/index.d.ts

@@ -0,0 +1,2 @@
+export type { ApplyResult, ParsedPatch, PatchOp } from './patch.js';
+export { applyPatch, computeHash, parsePatch } from './patch.js';

package/dist/tools/hashline/index.js

@@ -0,0 +1,3 @@
+// hashline 补丁语言（spec §16）：内容哈希锚定的行级补丁。
+// BLK 语法块操作待 AST 工具后续迭代。
+export { applyPatch, computeHash, parsePatch } from './patch.js';

package/dist/tools/hashline/patch.d.ts

@@ -0,0 +1,48 @@
+type PatchOp = {
+    _tag: 'SWAP';
+    start: number;
+    end: number;
+    content: string;
+} | {
+    _tag: 'DEL';
+    start: number;
+    end: number;
+} | {
+    _tag: 'INS_PRE';
+    line: number;
+    content: string;
+} | {
+    _tag: 'INS_POST';
+    line: number;
+    content: string;
+} | {
+    _tag: 'INS_HEAD';
+    content: string;
+} | {
+    _tag: 'INS_TAIL';
+    content: string;
+};
+type ParsedPatch = {
+    path: string;
+    hash: string;
+    operations: PatchOp[];
+};
+type ApplyResult = {
+    _tag: 'success';
+    content: string;
+} | {
+    _tag: 'hash_mismatch';
+    expected: string;
+    actual: string;
+} | {
+    _tag: 'line_not_found';
+    operation: PatchOp;
+};
+/** 4 位 hex 内容哈希（sha256 取前 4 位）。与 session 快照哈希算法同源。 */
+declare function computeHash(content: string): string;
+/** 解析补丁文本为一个或多个 ParsedPatch（按 `[path#hash]` 头分块）。 */
+declare function parsePatch(input: string): ParsedPatch[];
+/** 应用一个补丁到文件内容。先校验哈希，再按锚点降序应用操作。 */
+declare function applyPatch(file: string, patch: ParsedPatch): ApplyResult;
+export type { ApplyResult, ParsedPatch, PatchOp };
+export { applyPatch, computeHash, parsePatch };

package/dist/tools/hashline/patch.js

@@ -0,0 +1,201 @@
+import { createHash } from 'node:crypto';
+// ── computeHash ──────────────────────────────────────────
+/** 4 位 hex 内容哈希（sha256 取前 4 位）。与 session 快照哈希算法同源。 */
+function computeHash(content) {
+    return createHash('sha256').update(content).digest('hex').slice(0, 4);
+}
+// ── parsePatch ───────────────────────────────────────────
+const HEADER_RE = /^\[(.+?)#([0-9a-fA-F]+)\]\s*$/;
+/** 解析一个 `[path#hash]` 块内的操作序列。lines 为该块头之后的行。 */
+function parseOps(lines) {
+    const ops = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (!line || line.trim() === '') {
+            i++;
+            continue;
+        }
+        const tokens = line.split(/\s+/);
+        const head = tokens[0];
+        if (!head)
+            throw new Error('hashline: empty operation line');
+        // 收集到下一个分隔符 `---`（或块尾）的内容行
+        const collectContent = () => {
+            const body = [];
+            let j = i + 1;
+            while (j < lines.length && lines[j] !== '---') {
+                body.push(lines[j] ?? '');
+                j++;
+            }
+            return { content: body.join('\n'), next: j + 1 };
+        };
+        // 无内容体（DEL）也吃掉到 `---`
+        const skipToSeparator = () => {
+            let j = i + 1;
+            while (j < lines.length && lines[j] !== '---')
+                j++;
+            return j + 1;
+        };
+        if (head === 'SWAP') {
+            const [s, e] = parseRange(tokens[1]);
+            const { content, next } = collectContent();
+            ops.push({ _tag: 'SWAP', start: s, end: e ?? s, content });
+            i = next;
+        }
+        else if (head === 'DEL') {
+            const [s, e] = parseRange(tokens[1]);
+            ops.push({ _tag: 'DEL', start: s, end: e ?? s });
+            i = skipToSeparator();
+        }
+        else if (head === 'INS.PRE') {
+            const { content, next } = collectContent();
+            ops.push({ _tag: 'INS_PRE', line: Number(tokens[1]), content });
+            i = next;
+        }
+        else if (head === 'INS.POST') {
+            const { content, next } = collectContent();
+            ops.push({ _tag: 'INS_POST', line: Number(tokens[1]), content });
+            i = next;
+        }
+        else if (head === 'INS.HEAD') {
+            const { content, next } = collectContent();
+            ops.push({ _tag: 'INS_HEAD', content });
+            i = next;
+        }
+        else if (head === 'INS.TAIL') {
+            const { content, next } = collectContent();
+            ops.push({ _tag: 'INS_TAIL', content });
+            i = next;
+        }
+        else {
+            throw new Error(`hashline: unknown operation "${head}"`);
+        }
+    }
+    return ops;
+}
+/** 解析 `start` 或 `start-end`，返回 [start, end?]（1-indexed）。 */
+function parseRange(spec) {
+    if (!spec)
+        throw new Error('hashline: missing line range');
+    if (spec.includes('-')) {
+        const [a, b] = spec.split('-');
+        return [Number(a), Number(b)];
+    }
+    return [Number(spec), undefined];
+}
+/** 解析补丁文本为一个或多个 ParsedPatch（按 `[path#hash]` 头分块）。 */
+function parsePatch(input) {
+    const lines = input.split('\n');
+    const patches = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (!line || line.trim() === '') {
+            i++;
+            continue;
+        }
+        const m = HEADER_RE.exec(line);
+        if (!m)
+            throw new Error(`hashline: malformed header "${line}"`);
+        const path = m[1] ?? '';
+        const hash = m[2] ?? '';
+        const block = lines.slice(i + 1);
+        const endIdx = block.indexOf(''); // 块以空行或文件尾分隔（其实下一头才分隔）
+        // 操作持续到下一个头或文件尾：找到下一个 HEADER_RE 匹配行
+        let nextHead = block.length;
+        for (let k = 0; k < block.length; k++) {
+            if (HEADER_RE.test((block[k] ?? '').trim())) {
+                nextHead = k;
+                break;
+            }
+        }
+        void endIdx;
+        const opsLines = block.slice(0, nextHead);
+        patches.push({ path, hash, operations: parseOps(opsLines) });
+        i = i + 1 + nextHead;
+    }
+    return patches;
+}
+// ── applyPatch ───────────────────────────────────────────
+/** 每个操作基于原文件的"锚点行号"，用于排序使从后往前应用。 */
+function anchor(op, lineCount) {
+    switch (op._tag) {
+        case 'SWAP':
+        case 'DEL':
+            return op.start;
+        case 'INS_PRE':
+            return op.line;
+        case 'INS_POST':
+            return op.line + 1;
+        case 'INS_HEAD':
+            return 1;
+        case 'INS_TAIL':
+            return lineCount + 1;
+    }
+}
+/** 校验操作的行号范围是否落在 [1, lineCount]。 */
+function inBounds(op, lineCount) {
+    switch (op._tag) {
+        case 'SWAP':
+        case 'DEL':
+            return op.start >= 1 && op.end <= lineCount && op.start <= op.end;
+        case 'INS_PRE':
+        case 'INS_POST':
+            return op.line >= 1 && op.line <= lineCount;
+        case 'INS_HEAD':
+        case 'INS_TAIL':
+            return true;
+    }
+}
+/** 应用一个补丁到文件内容。先校验哈希，再按锚点降序应用操作。 */
+function applyPatch(file, patch) {
+    const actual = computeHash(file);
+    if (actual !== patch.hash) {
+        return { _tag: 'hash_mismatch', expected: patch.hash, actual };
+    }
+    // 末尾换行保留策略：按 \n 拆分，末尾空串代表文件以换行结尾。
+    const hadTrailingNewline = file.endsWith('\n');
+    const src = hadTrailingNewline ? file.slice(0, -1) : file;
+    const lines = src.split('\n');
+    const lineCount = lines.length;
+    // 先全部校验范围，任一越界即 line_not_found（保持原文件不变）
+    for (const op of patch.operations) {
+        if (!inBounds(op, lineCount)) {
+            return { _tag: 'line_not_found', operation: op };
+        }
+    }
+    // 按锚点降序应用：高行号先改，低行号锚点不受影响
+    const ordered = [...patch.operations].sort((a, b) => {
+        const lineCountFinal = lineCount;
+        return anchor(b, lineCountFinal) - anchor(a, lineCountFinal);
+    });
+    for (const op of ordered) {
+        const contentLines = 'content' in op && op.content !== '' ? op.content.split('\n') : [];
+        switch (op._tag) {
+            case 'SWAP':
+                lines.splice(op.start - 1, op.end - op.start + 1, ...contentLines);
+                break;
+            case 'DEL':
+                lines.splice(op.start - 1, op.end - op.start + 1);
+                break;
+            case 'INS_PRE':
+                lines.splice(op.line - 1, 0, ...contentLines);
+                break;
+            case 'INS_POST':
+                lines.splice(op.line, 0, ...contentLines);
+                break;
+            case 'INS_HEAD':
+                lines.unshift(...contentLines);
+                break;
+            case 'INS_TAIL':
+                lines.push(...contentLines);
+                break;
+        }
+    }
+    let result = lines.join('\n');
+    if (hadTrailingNewline)
+        result += '\n';
+    return { _tag: 'success', content: result };
+}
+export { applyPatch, computeHash, parsePatch };

package/dist/tools/index.d.ts

@@ -0,0 +1,30 @@
+export type { JSONSchema } from '../shared/types/base.js';
+export type { ChatTool } from '../shared/types/llm.js';
+export type { ToolContext, ToolDef, ToolExecutor, ToolMode, ToolPermission, ToolResult, } from '../shared/types/tool.js';
+export { bashTool } from './builtin/bash.js';
+export { dapTools } from './builtin/dap.js';
+export { editTool } from './builtin/edit.js';
+export { globTool, globToRegex } from './builtin/glob.js';
+export { grepTool } from './builtin/grep.js';
+export { readTool } from './builtin/read.js';
+export { createDefaultURLRegistry, createFileResolver, createSkillResolver, } from './builtin/resolvers.js';
+export { taskTool } from './builtin/task.js';
+export { writeTool } from './builtin/write.js';
+export { yieldTool } from './builtin/yield.js';
+export { executeTool } from './executor.js';
+export { autoAllowChecker, createPermissionChecker } from './permission.js';
+export { createToolRegistry, getTool, getToolSchemas, listTools, registerTool, registerToolFactory, } from './registry.js';
+export { DEFAULT_TRUNCATE_OPTIONS, truncateOutput } from './truncate.js';
+export type { BashInput, EditInput, GlobInput, GrepInput, GrepMatch, PermissionChecker, PermissionResult, ReadInput, ToolFactory, ToolFactoryContext, ToolRegistry, TruncateOptions, TruncateResult, ValidationResult, WriteInput, } from './types.js';
+export { validateInput } from './validate.js';
+export { formatForLLM, resolveProvider, runWebSearch } from './websearch/index.js';
+export type { WebSearchProvider, WebSearchProviderId, WebSearchResponse, WebSearchSource, } from './websearch/types.js';
+export { createWebSearchTool } from './websearch/websearch.js';
+import type { Config } from '../shared/types/config.js';
+/**
+ * Create a registry pre-loaded with all builtin tools:
+ * read, write, edit, glob, grep, bash, task, websearch, and the debug_* set.
+ *
+ * @param config 可选配置；websearch 工具按 config.websearch 构造。省略时用 DEFAULT_CONFIG。
+ */
+export declare function createDefaultRegistry(config?: Config): import("./types.js").ToolRegistry;

package/dist/tools/index.js

@@ -0,0 +1,55 @@
+// Tools package: tool registry, executor, validation, truncation, and builtin tools.
+export { bashTool } from './builtin/bash.js';
+export { dapTools } from './builtin/dap.js';
+export { editTool } from './builtin/edit.js';
+export { globTool, globToRegex } from './builtin/glob.js';
+export { grepTool } from './builtin/grep.js';
+export { readTool } from './builtin/read.js';
+// ── Builtin tools ───────────────────────────────────────────
+export { createDefaultURLRegistry, createFileResolver, createSkillResolver, } from './builtin/resolvers.js';
+export { taskTool } from './builtin/task.js';
+export { writeTool } from './builtin/write.js';
+export { yieldTool } from './builtin/yield.js';
+export { executeTool } from './executor.js';
+export { autoAllowChecker, createPermissionChecker } from './permission.js';
+// ── Framework ───────────────────────────────────────────────
+export { createToolRegistry, getTool, getToolSchemas, listTools, registerTool, registerToolFactory, } from './registry.js';
+export { DEFAULT_TRUNCATE_OPTIONS, truncateOutput } from './truncate.js';
+export { validateInput } from './validate.js';
+// ── Websearch ───────────────────────────────────────────────
+export { formatForLLM, resolveProvider, runWebSearch } from './websearch/index.js';
+export { createWebSearchTool } from './websearch/websearch.js';
+// ── Default registry ────────────────────────────────────────
+import { DEFAULT_CONFIG } from '../core/config.js';
+import { bashTool } from './builtin/bash.js';
+import { dapTools } from './builtin/dap.js';
+import { editTool } from './builtin/edit.js';
+import { globTool } from './builtin/glob.js';
+import { grepTool } from './builtin/grep.js';
+import { readTool } from './builtin/read.js';
+import { taskTool } from './builtin/task.js';
+import { writeTool } from './builtin/write.js';
+import { yieldTool } from './builtin/yield.js';
+import { createToolRegistry, registerTool } from './registry.js';
+import { createWebSearchTool } from './websearch/websearch.js';
+/**
+ * Create a registry pre-loaded with all builtin tools:
+ * read, write, edit, glob, grep, bash, task, websearch, and the debug_* set.
+ *
+ * @param config 可选配置；websearch 工具按 config.websearch 构造。省略时用 DEFAULT_CONFIG。
+ */
+export function createDefaultRegistry(config = DEFAULT_CONFIG) {
+    const reg = createToolRegistry();
+    registerTool(reg, readTool);
+    registerTool(reg, writeTool);
+    registerTool(reg, editTool);
+    registerTool(reg, globTool);
+    registerTool(reg, grepTool);
+    registerTool(reg, bashTool);
+    registerTool(reg, taskTool);
+    registerTool(reg, yieldTool);
+    registerTool(reg, createWebSearchTool(config.websearch));
+    for (const tool of dapTools)
+        registerTool(reg, tool);
+    return reg;
+}

package/dist/tools/permission.d.ts

@@ -0,0 +1,13 @@
+import type { PermissionChecker } from './types.js';
+/** Permission checker configuration. */
+type PermissionConfig = {
+    /** Tool names that are always allowed, regardless of their declared permission. */
+    alwaysAllow?: string[];
+    /** Tool names that are always denied, regardless of their declared permission. */
+    alwaysDeny?: string[];
+};
+/** Default checker: allows auto, asks for ask, denies deny. No persistent state. */
+export declare const autoAllowChecker: PermissionChecker;
+/** Create a permission checker with configurable allow/deny lists. */
+export declare function createPermissionChecker(config: PermissionConfig): PermissionChecker;
+export {};

package/dist/tools/permission.js

@@ -0,0 +1,39 @@
+import { randomUUID } from 'node:crypto';
+function checkPermission(tool, _input) {
+    switch (tool.permission) {
+        case 'auto':
+            return { _tag: 'allow' };
+        case 'deny':
+            return { _tag: 'deny', reason: `Tool "${tool.name}" is disabled` };
+        case 'ask':
+            return {
+                _tag: 'ask',
+                reason: `Tool "${tool.name}" requires confirmation`,
+                toolCallId: randomUUID(),
+            };
+    }
+}
+/** Default checker: allows auto, asks for ask, denies deny. No persistent state. */
+export const autoAllowChecker = {
+    check: async (_tool, _input, _ctx) => {
+        return checkPermission(_tool, _input);
+    },
+    confirm: (_toolCallId, _approved) => { },
+};
+/** Create a permission checker with configurable allow/deny lists. */
+export function createPermissionChecker(config) {
+    const allowSet = new Set(config.alwaysAllow ?? []);
+    const denySet = new Set(config.alwaysDeny ?? []);
+    return {
+        check: async (tool, _input, _ctx) => {
+            if (denySet.has(tool.name)) {
+                return { _tag: 'deny', reason: `Tool "${tool.name}" is disabled by configuration` };
+            }
+            if (allowSet.has(tool.name)) {
+                return { _tag: 'allow' };
+            }
+            return checkPermission(tool, _input);
+        },
+        confirm: (_toolCallId, _approved) => { },
+    };
+}