@andorra-labs/code 0.0.0-stage → 0.1.5

package/dist/src/tool-result-filter.js

@@ -0,0 +1,447 @@
+/**
+ * Deterministic filtering of bulky tool results before they enter the model-visible conversation.
+ *
+ * A test run, a compiler, a long listing, a search or a progress-heavy command can return
+ * thousands of lines of which the coding model needs a few: the failures, the diagnostics, the
+ * counts and the exit status. This module parses what it can recognize and keeps verbatim
+ * excerpts of what matters; it never writes a summary of its own, so no sentence here can turn
+ * untrusted output into an instruction. Every filtered result says what was omitted and names the
+ * artifact holding the complete original, which the model expands by reference and range.
+ *
+ * What is never filtered: source reads, patch hunks and skill or memory content (those tools are
+ * not candidates at all), tool errors other than a non-zero exit status (the error text is the
+ * evidence), small outputs (nothing to gain), and formats this module does not recognize (the
+ * existing clip and pressure-driven compaction remain the fallbacks). Filtering runs once, at
+ * insertion; it never rewrites an older conversation prefix.
+ * @module tool-result-filter
+ */
+import { canonicalToolName } from './tool-names.js';
+const SHELL_TOOLS = new Set(['Bash', 'PowerShell', 'NativeExec', 'AsyncProcess', 'PowerShellFast', 'ShellMetrics', 'shell', 'bash', 'powershell', 'qa.test', 'qa.fast', 'qa.deep', 'qa.terminal', 'qa.status']);
+const SEARCH_TOOLS = new Set(['Grep', 'grep', 'search_files']);
+const LISTING_TOOLS = new Set(['Glob', 'find', 'ls', 'list_files']);
+/** A shell command that prints source or a patch is a read, whatever its size. */
+const SOURCE_COMMAND = /codegraph|Get-Content|\bcat\b|\bsed\b|\btype\b|\bhead\b|\btail\b|\bless\b|\bmore\b|read[_-]?file|readFile|\.read_text\b|\bgit(?:\.exe)?\b[^\r\n;|&]*\b(?:diff|show|log\s+-p)\b/i;
+const EXIT_HEADER = /^(Tool error: )?Exit code: (-?\d+|[A-Z]+)\r?\n/;
+/** The shipped Bash tool appends the status instead: `<output>\nCommand exited with code N`, wrapped in `Tool error: `. */
+const EXIT_FOOTER = /\n?Command exited with code (-?\d+)\s*$/;
+const MAX_FAILURE_BLOCK_LINES = 40;
+const MAX_HEAD_LINES = 6;
+const MAX_TAIL_LINES = 12;
+const TEST_PASS = /^\s*(?:ok \d+ -|✔|✓|√|PASS(?:ED)?\b|test .* \.\.\. ok$|--- PASS|\[\s*PASS\s*\]|·|\s+✓)/;
+// pytest names each failure with an underscore-delimited section header and groups the sections
+// under an `= FAILURES =` (or `= ERRORS =`) banner; the sections hold the assertions and
+// tracebacks, and dropping them leaves only the bottom `FAILED ...` summary lines. The same
+// underscore shape also frames pytest's `Captured stdout/stderr` evidence blocks, which belong to
+// the failure they follow, not to a failure of their own.
+const TEST_FAIL = /^\s*(?:not ok \d+|✖|✗|×|FAIL(?:ED)?\b|test .* \.\.\. FAILED$|--- FAIL|\[\s*FAIL\s*\]|ERROR\b|panicked at|AssertionError|Error:|(?![^\n]*\b[Cc]aptured\b)_{8,}\s+\S.*\s+_{8,}$)/;
+const TEST_SUMMARY = /^\s*(?:# (?:tests|pass|fail|skipped|todo|cancelled|duration_ms)|ℹ (?:tests|suites|pass|fail|cancelled|skipped|todo|duration_ms)|Tests?:\s|Test Files\s|Test Suites:|=+ .*(?:passed|failed|error).* =+$|=+\s*FAIL(?:URES|ED)\s*=+$|=+\s*ERRORS\s*=+$|test result:|ok\s+\S+\s+[\d.]+s$|FAIL\s+\S+\s+[\d.]+s$|\d+ passing|\d+ failing|\d+ pending|Ran \d+ tests?)/;
+// pytest prefixes its assertion explanations with `E `, which must never end a failure block.
+const DIAGNOSTIC = /^\s*(?:at |File "|-->|\s*\d+ \||caused by|Caused by|stack:|expected|actual|Expected|Received|\+ |- |diff:|AssertionError|TypeError|ReferenceError|SyntaxError|RangeError|Error\b|E\s)/;
+const COMPILER_ERROR = /(?:\berror\b\s*(?:TS\d+|\[E\d+\]|C\d+|CS\d+)?:?|\bwarning\b\s*(?:C\d+|CS\d+)?:|\(\d+,\d+\): (?:error|warning)|^\S+:\d+:\d+:\s*(?:error|warning)|^error\[|^warning: |^error: )/;
+const COMPILER_SUMMARY = /^(?:Found \d+ errors?|\d+ errors? generated|error: could not compile|warning: .* generated \d+ warnings?|Build (?:succeeded|FAILED)|Compilation (?:succeeded|failed)|\s*\d+ Warning\(s\)|\s*\d+ Error\(s\))/;
+const PROGRESS = /(?:\[=+>?\s*\]|\d{1,3}%|█|░|\.{10,}|(?:Receiving|Resolving|Compressing|Counting|Unpacking|Downloading|Compiling|Building|Bundling)\b.*\d)/;
+const SEARCH_LINE = /^([^\s:][^:\n]{0,400}?):(\d+)(?::|-)/;
+/** Which family of output a tool is expected to produce, or undefined when it must not be filtered. */
+export function toolResultFilterCandidate(toolName, args) {
+    const canonical = canonicalToolName(toolName);
+    if (SHELL_TOOLS.has(canonical) || SHELL_TOOLS.has(toolName)) {
+        const command = typeof args?.command === 'string' ? args.command : typeof args?.script === 'string' ? args.script : '';
+        return SOURCE_COMMAND.test(command) ? undefined : 'shell';
+    }
+    if (SEARCH_TOOLS.has(canonical) || SEARCH_TOOLS.has(toolName))
+        return 'search';
+    if (LISTING_TOOLS.has(canonical) || LISTING_TOOLS.has(toolName))
+        return 'listing';
+    return undefined;
+}
+/** Collapse runs of lines that differ only in digits, percentages or carriage-return redraws. */
+function collapseProgress(lines) {
+    const out = [];
+    let collapsed = 0;
+    const shape = (line) => line.replace(/\r.*$/, '').replace(/\d+(?:\.\d+)?%?/g, '#').replace(/[=>█░.]{3,}/g, '~').trim();
+    let lastShape = '', run = 0;
+    for (const raw of lines) {
+        const line = raw.includes('\r') ? raw.slice(raw.lastIndexOf('\r') + 1) : raw;
+        const current = shape(line);
+        if (current && current === lastShape && PROGRESS.test(line)) {
+            run++;
+            collapsed++;
+            continue;
+        }
+        if (run > 0)
+            out.push(`[${run} similar progress lines omitted]`);
+        run = 0;
+        lastShape = current;
+        out.push(line);
+    }
+    if (run > 0)
+        out.push(`[${run} similar progress lines omitted]`);
+    return { lines: out, collapsed };
+}
+function keepTestReport(lines) {
+    let pass = 0, fail = 0, summary = 0;
+    const kept = new Map();
+    const keep = (index, anchor = false) => { if (index >= 0 && index < lines.length && !kept.has(index))
+        kept.set(index, { index, line: lines[index], ...(anchor ? { anchor: true } : {}) }); };
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index];
+        if (TEST_SUMMARY.test(line)) {
+            summary++;
+            keep(index, true);
+            continue;
+        }
+        if (TEST_FAIL.test(line)) {
+            fail++;
+            keep(index, true);
+            // Preceding diagnostic context (a warning or a console line) that explains the failure.
+            for (let offset = 1; offset <= 3 && index - offset >= 0; offset++) {
+                const previous = lines[index - offset];
+                if (!previous.trim() || TEST_PASS.test(previous))
+                    break;
+                if (/warn|deprecat|error|console\./i.test(previous))
+                    keep(index - offset);
+            }
+            // The failure's own block: assertion, diff and stack frames up to the next test line. The
+            // block's lines are consumed here so an assertion inside it is not counted as a second failure.
+            let consumed = 0;
+            for (let offset = 1; offset <= MAX_FAILURE_BLOCK_LINES && index + offset < lines.length; offset++) {
+                const next = lines[index + offset];
+                if (TEST_PASS.test(next) || TEST_SUMMARY.test(next) || (TEST_FAIL.test(next) && !DIAGNOSTIC.test(next)))
+                    break;
+                keep(index + offset);
+                consumed = offset;
+            }
+            index += consumed;
+            continue;
+        }
+        if (TEST_PASS.test(line)) {
+            pass++;
+            continue;
+        }
+        if (/\bwarn(?:ing)?\b/i.test(line) && !PROGRESS.test(line))
+            keep(index);
+    }
+    if (pass + fail < 5 && summary === 0)
+        return undefined;
+    for (let index = 0; index < Math.min(MAX_HEAD_LINES, lines.length); index++)
+        if (lines[index].trim())
+            keep(index);
+    for (let index = Math.max(0, lines.length - MAX_TAIL_LINES); index < lines.length; index++)
+        if (lines[index].trim())
+            keep(index);
+    return { kept: [...kept.values()].sort((a, b) => a.index - b.index), facts: { passLines: pass, failLines: fail, summaryLines: summary } };
+}
+function keepCompiler(lines) {
+    let errors = 0, warnings = 0;
+    const kept = new Map();
+    const keep = (index, anchor = false) => { if (index >= 0 && index < lines.length && !kept.has(index))
+        kept.set(index, { index, line: lines[index], ...(anchor ? { anchor: true } : {}) }); };
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index];
+        if (COMPILER_SUMMARY.test(line)) {
+            keep(index, true);
+            continue;
+        }
+        if (!COMPILER_ERROR.test(line))
+            continue;
+        if (/\berror\b/i.test(line))
+            errors++;
+        else
+            warnings++;
+        keep(index, true);
+        for (let offset = 1; offset <= 4 && index + offset < lines.length; offset++) {
+            const next = lines[index + offset];
+            if (COMPILER_ERROR.test(next) || !next.trim())
+                break;
+            keep(index + offset);
+        }
+    }
+    if (errors + warnings === 0)
+        return undefined;
+    for (let index = 0; index < Math.min(MAX_HEAD_LINES, lines.length); index++)
+        if (lines[index].trim())
+            keep(index);
+    for (let index = Math.max(0, lines.length - MAX_TAIL_LINES); index < lines.length; index++)
+        if (lines[index].trim())
+            keep(index);
+    return { kept: [...kept.values()].sort((a, b) => a.index - b.index), facts: { errorLines: errors, warningLines: warnings } };
+}
+function keepSearch(lines, maxPerFile = 12, maxFiles = 40) {
+    const perFile = new Map();
+    const kept = [];
+    const notes = [];
+    let matches = 0;
+    for (const [index, line] of lines.entries()) {
+        const match = SEARCH_LINE.exec(line);
+        if (!match) {
+            if (line.trim() && kept.length < 400)
+                kept.push({ index, line });
+            continue;
+        }
+        matches++;
+        const file = match[1];
+        const seen = perFile.get(file) ?? 0;
+        perFile.set(file, seen + 1);
+        if (perFile.size > maxFiles)
+            continue;
+        if (seen < maxPerFile)
+            kept.push({ index, line });
+    }
+    if (matches < 20)
+        return undefined;
+    let omittedFiles = 0;
+    for (const [file, count] of [...perFile].slice(0, maxFiles))
+        if (count > maxPerFile)
+            notes.push(`${file}: ${count - maxPerFile} more matches omitted`);
+    if (perFile.size > maxFiles)
+        omittedFiles = perFile.size - maxFiles;
+    if (omittedFiles)
+        notes.push(`${omittedFiles} more files with matches omitted`);
+    return { kept, facts: { matches, files: perFile.size, omittedFiles }, notes };
+}
+function keepListing(lines, head = 120, tail = 10) {
+    const entries = lines.filter(line => line.trim());
+    if (entries.length < head + tail + 20)
+        return undefined;
+    const kept = [];
+    for (const [index, line] of lines.entries()) {
+        if (!line.trim())
+            continue;
+        if (kept.length < head)
+            kept.push({ index, line });
+        else if (index >= lines.length - tail)
+            kept.push({ index, line });
+    }
+    return { kept, facts: { entries: entries.length } };
+}
+function render(kept, total) {
+    const parts = [];
+    let previous = -1, omitted = 0;
+    for (const { index, line } of kept) {
+        const gap = index - previous - 1;
+        if (gap > 0) {
+            parts.push(`[${gap} lines omitted]`);
+            omitted += gap;
+        }
+        parts.push(line);
+        previous = index;
+    }
+    const trailing = total - previous - 1;
+    if (trailing > 0) {
+        parts.push(`[${trailing} lines omitted]`);
+        omitted += trailing;
+    }
+    return { text: parts.join('\n'), omitted };
+}
+/** No kept line may be longer than this; the rest of it is named by its length and lives in the archive. */
+const MAX_LINE_CHARS = 1_000;
+/** Slack under the bound for the newline before the trailer and the omitted-count digits it may grow by. */
+const RENDER_SLACK = 40;
+function clipLine(line) {
+    return line.length <= MAX_LINE_CHARS ? line : `${line.slice(0, MAX_LINE_CHARS)} …[${line.length - MAX_LINE_CHARS} more characters of this line omitted]`;
+}
+/**
+ * Fit the kept lines into the character bound as they will be rendered, gap markers included:
+ * every line is clipped first, so one oversized line cannot carry the excerpt past the bound on its
+ * own, then what shrinks is whole runs of a block's own lines, so head and tail survive and no
+ * failure or error heading is dropped or torn from its evidence. Formats without headings (a
+ * search, a listing, progress) drop single middle lines as before. When only headings remain and
+ * they still do not fit, the over-bound excerpt is returned and the caller declines filtering
+ * rather than dropping failures the original kept.
+ */
+function fit(kept, total, maxChars) {
+    let items = kept.map(item => item.line.length > MAX_LINE_CHARS ? { ...item, line: clipLine(item.line) } : item);
+    let rendered = render(items, total);
+    if (!items.some(item => item.anchor)) {
+        while (rendered.text.length > maxChars && items.length > 2) {
+            items.splice(Math.floor(items.length / 2), 1);
+            rendered = render(items, total);
+        }
+        return rendered;
+    }
+    while (rendered.text.length > maxChars) {
+        const runs = [];
+        let run = [];
+        items.forEach((item, position) => {
+            if (item.anchor) {
+                if (run.length)
+                    runs.push(run);
+                run = [];
+            }
+            else
+                run.push(position);
+        });
+        if (run.length)
+            runs.push(run);
+        const middle = runs[Math.floor(runs.length / 2)];
+        if (!middle || items.length - middle.length < 2)
+            break;
+        const dropped = new Set(middle);
+        items = items.filter((_, position) => !dropped.has(position));
+        rendered = render(items, total);
+    }
+    return rendered;
+}
+/** Parse and reduce one tool result. The original is never modified; the caller stores it. */
+export function filterToolResult(input) {
+    const originalChars = input.output.length;
+    const unchanged = (reason, lines = 0) => ({ output: input.output, filtered: false, reason, originalChars, keptChars: originalChars, originalLines: lines, omittedLines: 0, facts: {} });
+    const candidate = toolResultFilterCandidate(input.toolName, input.args);
+    if (!candidate)
+        return unchanged('protected_tool');
+    if (originalChars <= input.thresholdChars)
+        return unchanged('below_threshold');
+    // A non-zero exit is an outcome whose body is still a report; any other error is the evidence.
+    const header = EXIT_HEADER.exec(input.output);
+    const footer = header ? null : EXIT_FOOTER.exec(input.output);
+    if (input.isError && !header && !footer)
+        return unchanged('error_output');
+    // The status stays pinned where the tool put it: a header at the top, a footer right after the
+    // excerpt; the `Tool error: ` wrapper stays at the top either way.
+    const pinned = header ? header[0] : input.output.startsWith('Tool error: ') ? 'Tool error: ' : '';
+    const pinnedTail = footer ? `${footer[0].trim()}\n` : '';
+    const body = input.output.slice(pinned.length, footer ? footer.index : undefined);
+    // CRLF endings are line endings, not redraws: the trailing carriage return comes off here so the
+    // progress collapser only sees the carriage returns a redraw actually wrote inside a line.
+    const rawLines = body.split('\n').map(line => line.endsWith('\r') ? line.slice(0, -1) : line);
+    const maxKept = input.maxKeptChars ?? 8000;
+    let format;
+    let kept;
+    let facts = {};
+    let notes = [];
+    let lines = rawLines;
+    if (candidate === 'shell') {
+        const collapsed = collapseProgress(rawLines);
+        lines = collapsed.lines;
+        const tests = keepTestReport(lines);
+        if (tests) {
+            format = 'test-report';
+            kept = tests.kept;
+            facts = tests.facts;
+        }
+        else {
+            const compiler = keepCompiler(lines);
+            if (compiler) {
+                format = 'compiler';
+                kept = compiler.kept;
+                facts = compiler.facts;
+            }
+            else if (collapsed.collapsed > 0 && collapsed.collapsed >= rawLines.length * 0.25) {
+                format = 'progress';
+                kept = lines.map((line, index) => ({ index, line }));
+                facts = { progressLinesCollapsed: collapsed.collapsed };
+            }
+        }
+        if (format && collapsed.collapsed > 0)
+            facts.progressLinesCollapsed = collapsed.collapsed;
+    }
+    else if (candidate === 'search') {
+        const search = keepSearch(rawLines);
+        if (search) {
+            format = 'search';
+            kept = search.kept;
+            facts = search.facts;
+            notes = search.notes;
+        }
+    }
+    else {
+        const listing = keepListing(rawLines);
+        if (listing) {
+            format = 'listing';
+            kept = listing.kept;
+            facts = listing.facts;
+        }
+    }
+    if (!format || !kept)
+        return unchanged('unknown_format', rawLines.length);
+    const factsLine = Object.entries(facts).map(([key, value]) => `${key}=${value}`).join(' ');
+    const trailerFor = (omitted) => [
+        `[Tool output filtered (${format}): ${omitted} of ${lines.length} lines omitted; ${factsLine}.`,
+        ...notes.map(note => ` ${note}.`),
+        input.reference ? ` Complete original: ${input.reference} (use expand_tool_output with ref, offset and limit).]` : ' Complete original not retained.]',
+    ].join('');
+    // The trailer is part of what the model sees, so the lines get what the bound leaves after it;
+    // two clipped lines are the least that still reads as an excerpt.
+    const lineBudget = Math.max(2 * (MAX_LINE_CHARS + 80), maxKept - trailerFor(lines.length).length - pinned.length - pinnedTail.length - RENDER_SLACK);
+    const rendered = fit(kept, lines.length, lineBudget);
+    const output = `${pinned}${rendered.text}\n${pinnedTail}${trailerFor(rendered.omitted)}`;
+    if (output.length > originalChars * 0.8)
+        return unchanged('no_benefit', rawLines.length);
+    // The excerpt the runtime inserts must stay under the bound with its trailer, or the later clip
+    // would cut the summary and the reference the model needs to expand the rest; a bound too small
+    // for even the least excerpt declines rather than overflowing.
+    if (output.length > maxKept)
+        return unchanged('no_benefit', rawLines.length);
+    return { output, filtered: true, reason: 'filtered', format, originalChars, keptChars: output.length, originalLines: rawLines.length, omittedLines: rendered.omitted, facts };
+}
+/**
+ * The runtime-owned store of complete originals for one invocation.
+ *
+ * References are opaque and scoped to the invocation that created them: another run, node or
+ * invocation cannot name them, and a range request is bounded so an expansion is a deliberate,
+ * accounted read rather than the original flooding back into context.
+ */
+export class ToolOutputArchive {
+    scope;
+    maxBytes;
+    persist;
+    entries = new Map();
+    persisted = new Map();
+    bytes = 0;
+    constructor(scope, maxBytes = 16 * 1024 * 1024, persist) {
+        this.scope = scope;
+        this.maxBytes = maxBytes;
+        this.persist = persist;
+    }
+    async put(content) {
+        const size = Buffer.byteLength(content);
+        if (this.bytes + size > this.maxBytes)
+            return undefined;
+        const ref = `tool-output://${this.scope}/${this.entries.size + 1}`;
+        this.entries.set(ref, content);
+        this.bytes += size;
+        try {
+            const stored = await this.persist?.(ref, content);
+            if (typeof stored === 'string')
+                this.persisted.set(ref, stored);
+        }
+        catch { /* The in-memory copy still serves expansion. */ }
+        return ref;
+    }
+    has(ref) { return typeof ref === 'string' && this.entries.has(ref); }
+    read(ref, offset = 0, limit = 8000) {
+        const value = this.entries.get(ref);
+        if (value === undefined)
+            throw new Error('Tool output reference is outside this invocation');
+        const end = Math.min(value.length, offset + limit);
+        return { content: value.slice(offset, end), totalChars: value.length, offset, ...(end < value.length ? { nextOffset: end } : {}) };
+    }
+    size() { return this.entries.size; }
+    /** The references that reached durable storage, by the artifact holding each: what a checkpoint records. */
+    exportPersisted() { return Object.fromEntries(this.persisted); }
+    /**
+     * Re-admit a stopped attempt's references from the artifacts its checkpoint named. Only
+     * `tool-output://` references are accepted, an artifact that cannot be loaded is skipped, and the
+     * byte budget still applies. Returns how many references serve again.
+     */
+    async import(mapping, load) {
+        let restored = 0;
+        for (const [ref, artifactRef] of Object.entries(mapping)) {
+            if (!ref.startsWith('tool-output://') || typeof artifactRef !== 'string' || this.entries.has(ref))
+                continue;
+            const content = await load(artifactRef);
+            if (content === undefined)
+                continue;
+            const size = Buffer.byteLength(content);
+            if (this.bytes + size > this.maxBytes)
+                break;
+            this.entries.set(ref, content);
+            this.persisted.set(ref, artifactRef);
+            this.bytes += size;
+            restored += 1;
+        }
+        return restored;
+    }
+}
+export const EXPAND_TOOL_OUTPUT = 'expand_tool_output';
+export const EXPAND_MAX_CHARS = 8000;

package/dist/src/tool-schema-compatibility.d.ts

@@ -0,0 +1,2 @@
+/** Returns true when the full validator authoritatively checked an extended contract. */
+export declare function validateExtendedToolSchema(schema: Record<string, unknown>, input: unknown): boolean;

package/dist/src/tool-schema-compatibility.js

@@ -0,0 +1,42 @@
+import { Compile } from 'typebox/compile';
+const nativeKeywords = new Set(['type', 'const', 'enum', 'properties', 'required', 'additionalProperties', 'items', 'oneOf', 'minimum', 'maximum', 'minItems', 'maxItems', 'minLength', 'maxLength', 'title', 'description', 'default', 'examples', '$schema', '$id']);
+function needsExtendedValidation(schema) {
+    if (!schema || typeof schema !== 'object')
+        return typeof schema === 'boolean';
+    if (Array.isArray(schema))
+        return schema.some(needsExtendedValidation);
+    const node = schema;
+    if (Object.keys(node).some(key => !nativeKeywords.has(key)))
+        return true;
+    // Native values use identity equality; JSON Schema compares objects/arrays structurally.
+    const composite = (value) => value !== null && typeof value === 'object';
+    if (composite(node.const) || (Array.isArray(node.enum) && node.enum.some(composite)))
+        return true;
+    // Draft tuple items are positional schemas, not one homogeneous item schema.
+    if (Array.isArray(node.items))
+        return true;
+    // Native oneOf returns before applying siblings. Preserve external contracts.
+    if (node.oneOf && Object.keys(node).some(key => !['oneOf', 'title', 'description', 'default', 'examples'].includes(key)))
+        return true;
+    if (node.additionalProperties && typeof node.additionalProperties === 'object')
+        return true;
+    return Object.values((node.properties ?? {})).some(needsExtendedValidation)
+        || (node.items !== undefined && needsExtendedValidation(node.items))
+        || (Array.isArray(node.oneOf) && node.oneOf.some(needsExtendedValidation));
+}
+const validators = new WeakMap();
+/** Returns true when the full validator authoritatively checked an extended contract. */
+export function validateExtendedToolSchema(schema, input) {
+    if (!needsExtendedValidation(schema))
+        return false;
+    let validator = validators.get(schema);
+    if (!validator) {
+        validator = Compile(schema);
+        validators.set(schema, validator);
+    }
+    if (!validator.Check(input)) {
+        const errors = [...validator.Errors(input)].slice(0, 10);
+        throw new Error('Tool input failed extended JSON Schema constraints: ' + errors.map(error => `${error.instancePath || '$'} ${error.message}`).join('; '));
+    }
+    return true;
+}

package/dist/src/tools.d.ts

@@ -0,0 +1,3 @@
+import type { Tool, ToolContext } from './types.js';
+export declare function authorize(name: string, args: Record<string, unknown>, context: ToolContext): Promise<void>;
+export declare function createTools(): Tool[];