klyro 0.1.1

package/dist/tools/fs/list-dir.js

@@ -0,0 +1,72 @@
+/**
+ * list_directory — list entries inside a directory.
+ *
+ * Refuses paths outside cwd. Skips node_modules and .git by default.
+ */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { z } from 'zod';
+import { defineTool } from '../types.js';
+import { resolveAndFollowSymlinks } from '../../policy/path-guard.js';
+import { TOOL_ERROR_CODES, safe } from '../normalize.js';
+const DEFAULT_SKIP = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.turbo', 'coverage']);
+const InputSchema = z.object({
+    path: z.string().min(1).default('.').describe('Directory path relative to cwd. Defaults to cwd.'),
+    maxDepth: z.number().int().min(1).max(5).optional().describe('How deep to recurse (default: 1 = top level only).'),
+    skip: z.array(z.string()).optional().describe('Directory names to skip (default: node_modules, .git, etc.)'),
+});
+export const listDirTool = defineTool({
+    name: 'list_directory',
+    description: 'List entries inside a directory. Skips node_modules, .git, and common build dirs by default.',
+    inputSchema: InputSchema,
+    execute: async (input, ctx) => {
+        return safe(async () => {
+            const { resolved } = await resolveAndFollowSymlinks(ctx.cwd, input.path);
+            const stat = await fs.stat(resolved);
+            if (!stat.isDirectory()) {
+                return {
+                    ok: false,
+                    error: { code: TOOL_ERROR_CODES.INVALID_INPUT, message: `Not a directory: ${input.path}` },
+                };
+            }
+            const skip = new Set([...DEFAULT_SKIP, ...(input.skip ?? [])]);
+            const maxDepth = input.maxDepth ?? 1;
+            const entries = [];
+            await walk(resolved, resolved, 0, maxDepth, skip, entries);
+            return { path: input.path, entries };
+        });
+    },
+});
+async function walk(root, dir, depth, maxDepth, skip, out) {
+    const names = await fs.readdir(dir).catch(() => []);
+    for (const name of names) {
+        if (skip.has(name))
+            continue;
+        if (name.startsWith('.') && name !== '.' && name !== '..')
+            continue;
+        const full = path.join(dir, name);
+        let entry;
+        try {
+            const s = await fs.lstat(full);
+            if (s.isSymbolicLink()) {
+                entry = { name: path.relative(root, full), type: 'symlink', size: s.size };
+            }
+            else if (s.isDirectory()) {
+                entry = { name: path.relative(root, full), type: 'directory', size: s.size };
+            }
+            else if (s.isFile()) {
+                entry = { name: path.relative(root, full), type: 'file', size: s.size };
+            }
+            else {
+                entry = { name: path.relative(root, full), type: 'other', size: s.size };
+            }
+        }
+        catch {
+            continue;
+        }
+        out.push(entry);
+        if (entry.type === 'directory' && depth + 1 < maxDepth) {
+            await walk(root, full, depth + 1, maxDepth, skip, out);
+        }
+    }
+}

package/dist/tools/fs/read-file.d.ts

@@ -0,0 +1,66 @@
+/**
+ * read_file — read a file (or a slice of it) from the workspace.
+ *
+ * Inputs:
+ *   - path: required, relative to cwd or absolute
+ *   - startLine / endLine: optional 1-indexed inclusive window
+ *   - maxBytes: optional cap (default 1 MiB)
+ *
+ * Behavior:
+ *   - Refuses to read outside cwd
+ *   - Refuses files > maxBytes unless line window keeps it small
+ *   - On missing file returns NOT_FOUND, not throw
+ *   - UTF-8 decode with a single TextDecoder
+ */
+import { z } from 'zod';
+declare const InputSchema: z.ZodObject<{
+    path: z.ZodString;
+    startLine: z.ZodOptional<z.ZodNumber>;
+    endLine: z.ZodOptional<z.ZodNumber>;
+    maxBytes: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export interface ReadFileOutput {
+    path: string;
+    totalLines: number;
+    lines: string[];
+    bytesRead: number;
+    truncated: boolean;
+}
+export declare const readFileTool: import("../types.js").Tool<{
+    path: string;
+    startLine?: number | undefined;
+    endLine?: number | undefined;
+    maxBytes?: number | undefined;
+}, {
+    readonly ok: false;
+    readonly error: {
+        readonly code: "INVALID_INPUT";
+        readonly message: `Not a regular file: ${string}`;
+    };
+    path?: undefined;
+    totalLines?: undefined;
+    lines?: undefined;
+    bytesRead?: undefined;
+    truncated?: undefined;
+} | {
+    readonly ok: false;
+    readonly error: {
+        readonly code: "INVALID_INPUT";
+        readonly message: `File too large (${number} bytes). Use startLine/endLine or raise maxBytes.`;
+    };
+    path?: undefined;
+    totalLines?: undefined;
+    lines?: undefined;
+    bytesRead?: undefined;
+    truncated?: undefined;
+} | {
+    path: string;
+    totalLines: number;
+    lines: string[];
+    bytesRead: number;
+    truncated: boolean;
+    readonly ok?: undefined;
+    readonly error?: undefined;
+}>;
+export type ReadFileInput = z.infer<typeof InputSchema>;
+export {};

package/dist/tools/fs/read-file.js

@@ -0,0 +1,75 @@
+/**
+ * read_file — read a file (or a slice of it) from the workspace.
+ *
+ * Inputs:
+ *   - path: required, relative to cwd or absolute
+ *   - startLine / endLine: optional 1-indexed inclusive window
+ *   - maxBytes: optional cap (default 1 MiB)
+ *
+ * Behavior:
+ *   - Refuses to read outside cwd
+ *   - Refuses files > maxBytes unless line window keeps it small
+ *   - On missing file returns NOT_FOUND, not throw
+ *   - UTF-8 decode with a single TextDecoder
+ */
+import * as fs from 'node:fs/promises';
+import { z } from 'zod';
+import { defineTool } from '../types.js';
+import { resolveAndFollowSymlinks } from '../../policy/path-guard.js';
+import { TOOL_ERROR_CODES, safe } from '../normalize.js';
+const InputSchema = z.object({
+    path: z.string().min(1).describe('Path relative to cwd, or absolute path inside cwd'),
+    startLine: z.number().int().min(1).optional().describe('1-indexed inclusive start line'),
+    endLine: z.number().int().min(1).optional().describe('1-indexed inclusive end line'),
+    maxBytes: z.number().int().min(1).max(16 * 1024 * 1024).optional().describe('Max bytes to read (default 1 MiB)'),
+});
+const DEFAULT_MAX_BYTES = 1024 * 1024; // 1 MiB
+export const readFileTool = defineTool({
+    name: 'read_file',
+    description: 'Read a file from the workspace. Returns the lines and total line count. Use startLine/endLine to read a slice without pulling the whole file.',
+    inputSchema: InputSchema,
+    execute: async (input, ctx) => {
+        return safe(async () => {
+            const { resolved } = await resolveAndFollowSymlinks(ctx.cwd, input.path);
+            const maxBytes = input.maxBytes ?? DEFAULT_MAX_BYTES;
+            const stat = await fs.stat(resolved);
+            if (!stat.isFile()) {
+                return {
+                    ok: false,
+                    error: { code: TOOL_ERROR_CODES.INVALID_INPUT, message: `Not a regular file: ${input.path}` },
+                };
+            }
+            if (stat.size > maxBytes * 4 && !input.startLine && !input.endLine) {
+                return {
+                    ok: false,
+                    error: {
+                        code: TOOL_ERROR_CODES.INVALID_INPUT,
+                        message: `File too large (${stat.size} bytes). Use startLine/endLine or raise maxBytes.`,
+                    },
+                };
+            }
+            const fh = await fs.open(resolved, 'r');
+            try {
+                const buf = Buffer.alloc(Math.min(maxBytes, stat.size));
+                const { bytesRead } = await fh.read(buf, 0, buf.length, 0);
+                const text = new TextDecoder('utf-8').decode(buf.subarray(0, bytesRead));
+                const allLines = text.split(/\r\n|\r|\n/);
+                const truncated = bytesRead < stat.size;
+                const totalLines = truncated ? -1 : allLines.length;
+                const lines = input.startLine !== undefined || input.endLine !== undefined
+                    ? allLines.slice((input.startLine ?? 1) - 1, input.endLine ?? allLines.length)
+                    : allLines;
+                return {
+                    path: input.path,
+                    totalLines,
+                    lines,
+                    bytesRead,
+                    truncated,
+                };
+            }
+            finally {
+                await fh.close().catch(() => undefined);
+            }
+        });
+    },
+});

package/dist/tools/fs/write-file.d.ts

@@ -0,0 +1,24 @@
+/**
+ * write_file — write content to a file in the workspace.
+ *
+ * Atomic write via tmp + rename. Refuses paths outside cwd. Creates parent
+ * directories if needed.
+ */
+import { z } from 'zod';
+declare const InputSchema: z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strip>;
+export interface WriteFileOutput {
+    path: string;
+    bytesWritten: number;
+}
+export declare const writeFileTool: import("../types.js").Tool<{
+    path: string;
+    content: string;
+}, {
+    path: string;
+    bytesWritten: number;
+}>;
+export type WriteFileInput = z.infer<typeof InputSchema>;
+export {};

package/dist/tools/fs/write-file.js

@@ -0,0 +1,48 @@
+/**
+ * write_file — write content to a file in the workspace.
+ *
+ * Atomic write via tmp + rename. Refuses paths outside cwd. Creates parent
+ * directories if needed.
+ */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
+import { z } from 'zod';
+import { defineTool } from '../types.js';
+import { resolveWithinCwd } from '../../policy/path-guard.js';
+import { safe } from '../normalize.js';
+const InputSchema = z.object({
+    path: z.string().min(1).describe('Path relative to cwd or absolute (must be inside cwd)'),
+    content: z.string().describe('File content. Use empty string to truncate.'),
+});
+export const writeFileTool = defineTool({
+    name: 'write_file',
+    description: 'Write content to a file. Atomic: writes to a temp file then renames. Creates parent directories as needed.',
+    inputSchema: InputSchema,
+    execute: async (input, ctx) => {
+        return safe(async () => {
+            const { resolved } = resolveWithinCwd(ctx.cwd, input.path);
+            const parent = path.dirname(resolved);
+            await fs.mkdir(parent, { recursive: true });
+            const suffix = crypto.randomBytes(8).toString('hex');
+            const tmp = path.join(parent, `.klyro-write-${process.pid}-${suffix}.tmp`);
+            const data = Buffer.from(input.content, 'utf-8');
+            const fh = await fs.open(tmp, 'w');
+            try {
+                await fh.writeFile(data);
+                await fh.sync();
+            }
+            finally {
+                await fh.close().catch(() => undefined);
+            }
+            try {
+                await fs.rename(tmp, resolved);
+            }
+            catch (err) {
+                await fs.unlink(tmp).catch(() => undefined);
+                throw err;
+            }
+            return { path: input.path, bytesWritten: data.byteLength };
+        });
+    },
+});

package/dist/tools/git/git-diff.d.ts

@@ -0,0 +1,35 @@
+/**
+ * git_diff — show unstaged (`git diff`) or staged (`git diff --cached`)
+ * changes plus a compact per-file stat. Read-only.
+ */
+import { z } from 'zod';
+declare const InputSchema: z.ZodObject<{
+    staged: z.ZodOptional<z.ZodBoolean>;
+    path: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export interface GitDiffOutput {
+    diff: string;
+    stat: string;
+    patchedFiles: string[];
+}
+export declare const gitDiffTool: import("../types.js").Tool<{
+    staged?: boolean | undefined;
+    path?: string | undefined;
+}, {
+    readonly ok: false;
+    readonly error: {
+        readonly code: "IO_ERROR";
+        readonly message: `git diff failed: ${string}`;
+    };
+    diff?: undefined;
+    stat?: undefined;
+    patchedFiles?: undefined;
+} | {
+    diff: string;
+    stat: string;
+    patchedFiles: string[];
+    readonly ok?: undefined;
+    readonly error?: undefined;
+}>;
+export type GitDiffInput = z.infer<typeof InputSchema>;
+export {};

package/dist/tools/git/git-diff.js

@@ -0,0 +1,68 @@
+/**
+ * git_diff — show unstaged (`git diff`) or staged (`git diff --cached`)
+ * changes plus a compact per-file stat. Read-only.
+ */
+import { spawn } from 'node:child_process';
+import { z } from 'zod';
+import { defineTool } from '../types.js';
+import { safe, TOOL_ERROR_CODES } from '../normalize.js';
+const InputSchema = z.object({
+    staged: z.boolean().optional().describe('Show staged changes instead of unstaged (default false)'),
+    path: z.string().optional().describe('Limit to a specific path'),
+});
+function run(args, cwd, timeoutMs = 15_000) {
+    return new Promise((resolve) => {
+        const child = spawn('git', args, { cwd, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true, shell: false });
+        const out = [];
+        const err = [];
+        const timer = setTimeout(() => { try {
+            child.kill('SIGKILL');
+        }
+        catch { /* noop */ } }, timeoutMs);
+        child.stdout.on('data', (b) => out.push(b));
+        child.stderr.on('data', (b) => err.push(b));
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            resolve({ code: code ?? 1, out: Buffer.concat(out).toString('utf-8'), err: Buffer.concat(err).toString('utf-8') });
+        });
+    });
+}
+export const gitDiffTool = defineTool({
+    name: 'git_diff',
+    description: 'Show the unified diff of working-tree changes (unstaged by default) or staged changes. Read-only. Returns the diff text, a per-file stat, and the list of changed file paths.',
+    inputSchema: InputSchema,
+    execute: async (input, ctx) => {
+        return safe(async () => {
+            const base = input.staged ? ['diff', '--cached'] : ['diff'];
+            const args = [...base, '--no-color'];
+            if (input.path)
+                args.push('--', input.path);
+            const diff = await run(args, ctx.cwd);
+            if (diff.code !== 0) {
+                return {
+                    ok: false,
+                    error: { code: TOOL_ERROR_CODES.IO_ERROR, message: `git diff failed: ${diff.err.trim() || diff.out.trim()}` },
+                };
+            }
+            const statArgs = [...base, '--stat', '--no-color'];
+            if (input.path)
+                statArgs.push('--', input.path);
+            const stat = await run(statArgs, ctx.cwd);
+            // Parse changed file paths from `diff --git a/... b/...` lines.
+            const patchedFiles = [];
+            const newline = /\r?\n/;
+            const re = /^diff --git a\/(.*?) b\/(.*\S)\s*$/;
+            for (const line of diff.out.split(newline)) {
+                const m = re.exec(line);
+                const target = m?.[2];
+                if (target)
+                    patchedFiles.push(target.replace(/\/$/, ''));
+            }
+            return {
+                diff: diff.out.trim(),
+                stat: stat.out.trim(),
+                patchedFiles,
+            };
+        });
+    },
+});

package/dist/tools/git/git-status.d.ts

@@ -0,0 +1,29 @@
+/**
+ * git_status — one or two commands that both read the repo:
+ *   - `git status --porcelain --untracked-files=all`
+ *   - `git log -n 10 --oneline` for recent history
+ * The agent needs working-tree state AND recent history to plan edits.
+ */
+import { z } from 'zod';
+declare const InputSchema: z.ZodObject<{
+    showLog: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export interface GitStatusOutput {
+    porcelain: string;
+    recentCommits?: string;
+    branch?: string;
+}
+export declare const gitStatusTool: import("../types.js").Tool<{
+    showLog?: boolean | undefined;
+}, GitStatusOutput | {
+    readonly ok: false;
+    readonly error: {
+        readonly code: "NOT_A_GIT_REPO";
+        readonly message: string;
+        readonly details: {
+            readonly code: number;
+        };
+    };
+}>;
+export type GitStatusInput = z.infer<typeof InputSchema>;
+export {};

package/dist/tools/git/git-status.js

@@ -0,0 +1,57 @@
+/**
+ * git_status — one or two commands that both read the repo:
+ *   - `git status --porcelain --untracked-files=all`
+ *   - `git log -n 10 --oneline` for recent history
+ * The agent needs working-tree state AND recent history to plan edits.
+ */
+import { spawn } from 'node:child_process';
+import { z } from 'zod';
+import { defineTool } from '../types.js';
+import { safe } from '../normalize.js';
+const InputSchema = z.object({
+    showLog: z.boolean().optional().describe('Also include the last 10 commit messages (default true)'),
+});
+function run(args, cwd, timeoutMs = 15_000) {
+    return new Promise((resolve) => {
+        const child = spawn('git', args, { cwd, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true, shell: false });
+        const out = [];
+        const err = [];
+        const timer = setTimeout(() => { try {
+            child.kill('SIGKILL');
+        }
+        catch { /* noop */ } }, timeoutMs);
+        child.stdout.on('data', (b) => out.push(b));
+        child.stderr.on('data', (b) => err.push(b));
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            resolve({ code: code ?? 1, out: Buffer.concat(out).toString('utf-8'), err: Buffer.concat(err).toString('utf-8') });
+        });
+    });
+}
+export const gitStatusTool = defineTool({
+    name: 'git_status',
+    description: 'Show working-tree status (porcelain) and, optionally, the last 10 commit messages and current branch. Read-only.',
+    inputSchema: InputSchema,
+    execute: async (input, ctx) => {
+        return safe(async () => {
+            const status = await run(['status', '--porcelain', '--untracked-files=all'], ctx.cwd);
+            if (status.code !== 0) {
+                // Not a git repo or git unavailable
+                return {
+                    ok: false,
+                    error: { code: 'NOT_A_GIT_REPO', message: status.err.trim() || 'git status failed', details: { code: status.code } },
+                };
+            }
+            const result = { porcelain: status.out || '(clean)' };
+            const branch = await run(['branch', '--show-current'], ctx.cwd);
+            if (branch.code === 0 && branch.out.trim())
+                result.branch = branch.out.trim();
+            if (input.showLog !== false) {
+                const log = await run(['log', '-n', '10', '--oneline', '--no-show-signature'], ctx.cwd);
+                if (log.code === 0 && log.out.trim())
+                    result.recentCommits = log.out.trim();
+            }
+            return result;
+        });
+    },
+});

package/dist/tools/normalize.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Normalize any thrown value or system error into a ToolResult error.
+ * Centralizing this means tools can `throw` and the harness sees structured
+ * errors without each tool hand-coding the shape.
+ */
+import type { ToolResult } from './types.js';
+/** Standard tool error codes. Tools may add their own. */
+export declare const TOOL_ERROR_CODES: {
+    readonly NOT_FOUND: "NOT_FOUND";
+    readonly PERMISSION_DENIED: "PERMISSION_DENIED";
+    readonly INVALID_INPUT: "INVALID_INPUT";
+    readonly IO_ERROR: "IO_ERROR";
+    readonly TIMEOUT: "TIMEOUT";
+    readonly ABORTED: "ABORTED";
+    readonly PATH_ESCAPE: "PATH_ESCAPE";
+    readonly COMMAND_DENIED: "COMMAND_DENIED";
+    readonly COMMAND_NOT_FOUND: "COMMAND_NOT_FOUND";
+    readonly EXIT_NONZERO: "EXIT_NONZERO";
+    readonly INTERNAL: "INTERNAL";
+};
+export type ToolErrorCode = (typeof TOOL_ERROR_CODES)[keyof typeof TOOL_ERROR_CODES] | string;
+export declare function toToolError(err: unknown, fallbackCode?: ToolErrorCode): {
+    code: ToolErrorCode;
+    message: string;
+    details?: unknown;
+};
+/** Convenience: wrap a function in try/catch and return a ToolResult.
+ *  If the function returns a ToolResult (already-shaped), it is passed through
+ *  unwrapped. Otherwise the function's return value becomes `value` on success.
+ */
+export declare function safe<T>(fn: () => Promise<T>): Promise<ToolResult<T>>;

package/dist/tools/normalize.js

@@ -0,0 +1,88 @@
+/**
+ * Normalize any thrown value or system error into a ToolResult error.
+ * Centralizing this means tools can `throw` and the harness sees structured
+ * errors without each tool hand-coding the shape.
+ */
+/** Standard tool error codes. Tools may add their own. */
+export const TOOL_ERROR_CODES = {
+    NOT_FOUND: 'NOT_FOUND',
+    PERMISSION_DENIED: 'PERMISSION_DENIED',
+    INVALID_INPUT: 'INVALID_INPUT',
+    IO_ERROR: 'IO_ERROR',
+    TIMEOUT: 'TIMEOUT',
+    ABORTED: 'ABORTED',
+    PATH_ESCAPE: 'PATH_ESCAPE',
+    COMMAND_DENIED: 'COMMAND_DENIED',
+    COMMAND_NOT_FOUND: 'COMMAND_NOT_FOUND',
+    EXIT_NONZERO: 'EXIT_NONZERO',
+    INTERNAL: 'INTERNAL',
+};
+export function toToolError(err, fallbackCode = TOOL_ERROR_CODES.INTERNAL) {
+    if (err === null || err === undefined) {
+        return { code: fallbackCode, message: 'Unknown error' };
+    }
+    if (err instanceof Error) {
+        // If the error already declares a tool-level `code` (e.g. PathGuardError),
+        // honor it instead of mapping through Node errno.
+        const maybeCode = err.code;
+        if (typeof maybeCode === 'string' && isToolErrorCode(maybeCode)) {
+            return { code: maybeCode, message: err.message };
+        }
+        if (typeof maybeCode === 'string') {
+            // Looks like a Node errno (e.g. 'ENOENT'); map it.
+            return {
+                code: mapNodeErrorCode(maybeCode),
+                message: err.message,
+                details: { syscall: err.syscall, path: err.path },
+            };
+        }
+        return { code: fallbackCode, message: err.message, details: err.stack };
+    }
+    return { code: fallbackCode, message: String(err) };
+}
+function isToolErrorCode(code) {
+    return Object.values(TOOL_ERROR_CODES).includes(code) || code === 'MATCH_NOT_FOUND' || code === 'MATCH_AMBIGUOUS' || code === 'UNKNOWN_TOOL' || code === 'INVALID_INPUT';
+}
+function mapNodeErrorCode(code) {
+    switch (code) {
+        case 'ENOENT':
+            return TOOL_ERROR_CODES.NOT_FOUND;
+        case 'EACCES':
+        case 'EPERM':
+            return TOOL_ERROR_CODES.PERMISSION_DENIED;
+        case 'EISDIR':
+        case 'ENOTDIR':
+            return TOOL_ERROR_CODES.IO_ERROR;
+        case 'ETIMEDOUT':
+        case 'ESOCKETTIMEDOUT':
+            return TOOL_ERROR_CODES.TIMEOUT;
+        case 'ECANCELED':
+        case 'ABORT_ERR':
+            return TOOL_ERROR_CODES.ABORTED;
+        default:
+            return TOOL_ERROR_CODES.IO_ERROR;
+    }
+}
+/** Convenience: wrap a function in try/catch and return a ToolResult.
+ *  If the function returns a ToolResult (already-shaped), it is passed through
+ *  unwrapped. Otherwise the function's return value becomes `value` on success.
+ */
+export async function safe(fn) {
+    try {
+        const result = await fn();
+        // Only pass through true tool-level errors: ok:false WITH an error
+        // object. Tools that return a value with an `ok` field of their own
+        // (e.g. VerifyOutput.ok = "did the verify command succeed") get
+        // wrapped so the harness sees ToolResult<T>, not a bare T.
+        if (result &&
+            typeof result === 'object' &&
+            result.ok === false &&
+            result.error) {
+            return result;
+        }
+        return { ok: true, value: result };
+    }
+    catch (err) {
+        return { ok: false, error: toToolError(err) };
+    }
+}

package/dist/tools/registry.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Tool registry — single source of truth for tools the model can use.
+ */
+import type { Tool, ToolContext, ToolResult } from './types.js';
+export declare class ToolRegistry {
+    private readonly tools;
+    register<TIn, TOut>(tool: Tool<TIn, TOut>): this;
+    get(name: string): Tool<unknown, unknown> | undefined;
+    list(): Tool<unknown, unknown>[];
+    /** Tools in OpenAI-style tool definition format. */
+    toOpenAITools(): Array<{
+        type: 'function';
+        function: {
+            name: string;
+            description: string;
+            parameters: unknown;
+        };
+    }>;
+    /** Cached JSON Schemas keyed by tool name (for adapter consumers). */
+    jsonSchemas(): Record<string, unknown>;
+    execute(name: string, rawInput: unknown, ctx: ToolContext): Promise<ToolResult<unknown>>;
+}
+export declare const builtinRegistry: () => ToolRegistry;