@modelprofile.com/flexharness 10.12.0 → 10.14.0

package/dist_ts/classes.toolcatalog.js

@@ -0,0 +1,1398 @@
+import * as plugins from './plugins.js';
+import { FlexHarnessValidationError } from './errors.js';
+import { FLEX_CODE_MODE_TOOL_NAME, FLEX_TOOL_CATALOG_LIMITS as limits, FLEX_TOOL_CATALOG_TOOL_NAMES as toolNames, } from './interfaces.js';
+import { SchemaDeclarationWriter, countOf, docBlock, indentLines, isIdentifier, isSchemaRecord, } from './utils.schemadeclarations.js';
+import { normalizeToolCatalogOptions } from './utils.harnessoptions.js';
+import { validateUtf8String } from './utils.validation.js';
+const aiSchemaSymbol = Symbol.for('vercel.ai.schema');
+const methodPathPattern = /^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*$/;
+const typeNamePattern = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/** Words a declaration cannot use as a function, namespace or type name. */
+const reservedWords = new Set([
+    'await', 'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'default', 'delete', 'do',
+    'else', 'enum', 'export', 'extends', 'false', 'finally', 'for', 'function', 'if', 'implements', 'import',
+    'in', 'instanceof', 'interface', 'let', 'new', 'null', 'package', 'private', 'protected', 'public',
+    'return', 'static', 'super', 'switch', 'this', 'throw', 'true', 'try', 'typeof', 'var', 'void', 'while',
+    'with', 'yield',
+]);
+const controlPattern = /[\u0000-\u001f\u007f]/;
+const definitionRefPattern = /^#\/(\$defs|definitions)\/([^/]+)$/;
+const declaredTypesHeader = '// Declares types: ';
+const identifierScanPattern = /[A-Za-z_$][A-Za-z0-9_$]*/g;
+const methodKeys = new Set([
+    'method', 'summary', 'description', 'tags', 'examples', 'inputSchema', 'outputSchema', 'declaration', 'run', 'onCall',
+]);
+const catalogKeys = new Set(['methods', 'types', 'onProposals']);
+const typeKeys = new Set(['name', 'description', 'schema', 'declaration']);
+const stopWords = new Set([
+    'a', 'an', 'and', 'are', 'all', 'as', 'be', 'by', 'for', 'from', 'get', 'i', 'in', 'is', 'it', 'me', 'my',
+    'of', 'on', 'or', 'that', 'the', 'this', 'to', 'with',
+]);
+const fieldWeights = { name: 3, namespace: 1.5, summary: 2, tags: 2, description: 1 };
+const bm25K1 = 1.2;
+const bm25B = 0.75;
+const coreCache = new WeakMap();
+const isPlainObject = (value) => typeof value === 'object'
+    && value !== null
+    && !Array.isArray(value)
+    && [Object.prototype, null].includes(Object.getPrototypeOf(value));
+const compareCodePoints = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+const stableStringify = (value) => {
+    if (Array.isArray(value))
+        return `[${value.map(stableStringify).join(',')}]`;
+    if (isSchemaRecord(value)) {
+        return `{${Object.keys(value).sort(compareCodePoints)
+            .map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+    }
+    return JSON.stringify(value) ?? 'null';
+};
+const deepFreeze = (value) => {
+    if (typeof value === 'object' && value !== null && !Object.isFrozen(value)) {
+        Object.freeze(value);
+        for (const child of Object.values(value))
+            deepFreeze(child);
+    }
+    return value;
+};
+const decodePointerToken = (token) => {
+    let decoded = token;
+    try {
+        decoded = decodeURI(token);
+    }
+    catch {
+        decoded = token;
+    }
+    return decoded.replace(/~1/g, '/').replace(/~0/g, '~');
+};
+const pointerTokens = (pointer) => pointer.replace(/^#/, '').split('/').slice(1).map(decodePointerToken);
+/** Resolves a local JSON pointer against `root`, following `$ref` tokens of keyword locations. */
+const resolvePointer = (root, pointer) => {
+    let node = root;
+    for (const token of pointerTokens(pointer)) {
+        if (token === '$ref' && isSchemaRecord(node) && typeof node.$ref === 'string') {
+            node = node.$ref.startsWith('#') ? resolvePointer(root, node.$ref) : undefined;
+            continue;
+        }
+        if (Array.isArray(node))
+            node = node[Number(token)];
+        else if (isSchemaRecord(node))
+            node = Object.prototype.hasOwnProperty.call(node, token) ? node[token] : undefined;
+        else
+            return undefined;
+    }
+    return node;
+};
+const collectRefs = (node, refs) => {
+    if (Array.isArray(node)) {
+        for (const child of node)
+            collectRefs(child, refs);
+        return;
+    }
+    if (!isSchemaRecord(node))
+        return;
+    for (const [key, child] of Object.entries(node)) {
+        if (key === '$ref' && typeof child === 'string')
+            refs.add(child);
+        else if (key !== 'const' && key !== 'enum' && key !== 'default' && key !== 'examples')
+            collectRefs(child, refs);
+    }
+};
+const schemaDraft = (root) => {
+    const declared = isSchemaRecord(root) && typeof root.$schema === 'string' ? root.$schema : '';
+    if (declared.includes('draft-04'))
+        return '4';
+    if (declared.includes('draft-06') || declared.includes('draft-07'))
+        return '7';
+    if (declared.includes('2019-09'))
+        return '2019-09';
+    return '2020-12';
+};
+const withoutDraft = (schema) => {
+    if (!isSchemaRecord(schema) || schema.$schema === undefined)
+        return schema;
+    const { $schema: _draft, ...rest } = schema;
+    return rest;
+};
+const stem = (word) => {
+    if (word.length > 4 && word.endsWith('ies'))
+        return `${word.slice(0, -3)}y`;
+    if (word.length > 3 && word.endsWith('s') && !word.endsWith('ss'))
+        return word.slice(0, -1);
+    return word;
+};
+const searchTerms = (text) => text
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+    .toLowerCase()
+    .split(/[^\p{L}\p{N}]+/u)
+    .filter(Boolean)
+    .map(stem);
+const editDistance = (left, right, limit) => {
+    if (Math.abs(left.length - right.length) > limit)
+        return limit + 1;
+    let previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+    for (let row = 1; row <= left.length; row++) {
+        const current = [row];
+        let best = row;
+        for (let column = 1; column <= right.length; column++) {
+            const cost = left[row - 1] === right[column - 1] ? 0 : 1;
+            current[column] = Math.min(previous[column] + 1, current[column - 1] + 1, previous[column - 1] + cost);
+            best = Math.min(best, current[column]);
+        }
+        if (best > limit)
+            return limit + 1;
+        previous = current;
+    }
+    return previous[right.length];
+};
+const closeMatches = (wanted, candidates, count = 3) => {
+    const normalized = wanted.toLowerCase();
+    const limit = Math.max(2, Math.floor(normalized.length / 3));
+    const scored = [];
+    for (const candidate of candidates) {
+        const lower = candidate.toLowerCase();
+        const lastSegment = lower.slice(lower.lastIndexOf('.') + 1);
+        const distance = Math.min(editDistance(normalized, lower, limit), lower.includes(normalized) || normalized.includes(lastSegment) ? 1 : limit + 1);
+        if (distance <= limit)
+            scored.push({ name: candidate, distance });
+    }
+    return scored
+        .sort((left, right) => left.distance - right.distance || compareCodePoints(left.name, right.name))
+        .slice(0, count)
+        .map((entry) => entry.name);
+};
+const preview = (value) => {
+    if (value === undefined)
+        return 'missing';
+    let text;
+    try {
+        text = JSON.stringify(value) ?? String(value);
+    }
+    catch {
+        text = String(value);
+    }
+    return text.length > 80 ? `${text.slice(0, 77)}...` : text;
+};
+const paramsPath = (tokens) => tokens.reduce((path, token) => {
+    if (typeof token === 'number' || /^\d+$/.test(token))
+        return `${path}[${token}]`;
+    return isIdentifier(token) ? `${path}.${token}` : `${path}[${JSON.stringify(token)}]`;
+}, 'params');
+const valueAt = (value, tokens) => {
+    let node = value;
+    for (const token of tokens) {
+        if (Array.isArray(node))
+            node = node[Number(token)];
+        else if (isSchemaRecord(node))
+            node = Object.prototype.hasOwnProperty.call(node, token) ? node[String(token)] : undefined;
+        else
+            return undefined;
+    }
+    return node;
+};
+const compactType = (text) => {
+    const compact = text.replace(/\/\*\*[\s\S]*?\*\//g, '').replace(/\s+/g, ' ').trim();
+    return compact.length > 200 ? `${compact.slice(0, 197)}...` : compact;
+};
+const textOf = (value, label, options) => {
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new FlexHarnessValidationError(`${label} must be a non-empty string.`);
+    }
+    if (options.maxBytes !== undefined)
+        validateUtf8String(value, label, options.maxBytes, true);
+    if (options.maxCharacters !== undefined && [...value].length > options.maxCharacters) {
+        throw new FlexHarnessValidationError(`${label} must be at most ${options.maxCharacters} characters.`);
+    }
+    if (options.singleLine && controlPattern.test(value)) {
+        throw new FlexHarnessValidationError(`${label} must be one line without control characters.`);
+    }
+    return value;
+};
+const textListOf = (value, label, maxItems, options) => {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) || value.length > maxItems) {
+        throw new FlexHarnessValidationError(`${label} must be an array with at most ${maxItems} entries.`);
+    }
+    return value.map((entry, index) => textOf(entry, `${label}[${index}]`, options));
+};
+async function resolveCatalogSchema(schema, label) {
+    let json;
+    let validate;
+    if (typeof schema === 'function'
+        || (isSchemaRecord(schema) && (aiSchemaSymbol in schema || '~standard' in schema))) {
+        let resolved;
+        try {
+            resolved = plugins.asSchema(schema);
+            json = await resolved.jsonSchema;
+        }
+        catch (error) {
+            throw new FlexHarnessValidationError(`${label} cannot be converted to JSON Schema.`, { cause: error });
+        }
+        if (resolved.validate) {
+            const validator = resolved.validate;
+            validate = (value) => validator(value);
+        }
+    }
+    else if (isPlainObject(schema) || typeof schema === 'boolean') {
+        json = schema;
+    }
+    else {
+        throw new FlexHarnessValidationError(`${label} must be a JSON Schema object, or a zod, Standard Schema or AI SDK schema.`);
+    }
+    let copy;
+    try {
+        copy = structuredClone(json);
+    }
+    catch (error) {
+        throw new FlexHarnessValidationError(`${label} must be plain JSON.`, { cause: error });
+    }
+    if (!isSchemaRecord(copy) && typeof copy !== 'boolean') {
+        throw new FlexHarnessValidationError(`${label} must be a JSON Schema object.`);
+    }
+    validateUtf8String(JSON.stringify(copy), label, limits.maxSchemaBytes, true);
+    return { json: deepFreeze(copy), ...(validate ? { validate } : {}) };
+}
+class CatalogSearchIndex {
+    entries;
+    postings = new Map();
+    idf = new Map();
+    constructor(entries) {
+        this.entries = entries;
+        const fieldTexts = (entry) => ({
+            name: searchTerms(entry.name),
+            namespace: searchTerms(entry.namespace),
+            summary: searchTerms(entry.summary),
+            tags: entry.tags.flatMap(searchTerms),
+            description: searchTerms(entry.description ?? ''),
+        });
+        const documents = entries.map(fieldTexts);
+        const fields = Object.keys(fieldWeights);
+        const averageLength = Object.fromEntries(fields.map((field) => [
+            field,
+            Math.max(1, documents.reduce((sum, document) => sum + document[field].length, 0) / Math.max(1, documents.length)),
+        ]));
+        const documentFrequency = new Map();
+        documents.forEach((document, index) => {
+            const weights = new Map();
+            for (const field of fields) {
+                const frequencies = new Map();
+                for (const term of document[field])
+                    frequencies.set(term, (frequencies.get(term) ?? 0) + 1);
+                const norm = 1 - bm25B + bm25B * (document[field].length / averageLength[field]);
+                for (const [term, frequency] of frequencies) {
+                    weights.set(term, (weights.get(term) ?? 0) + fieldWeights[field] * frequency / norm);
+                }
+            }
+            for (const [term, weight] of weights) {
+                documentFrequency.set(term, (documentFrequency.get(term) ?? 0) + 1);
+                const postings = this.postings.get(term) ?? [];
+                postings.push({ index, weight });
+                this.postings.set(term, postings);
+            }
+        });
+        for (const [term, frequency] of documentFrequency) {
+            this.idf.set(term, Math.log(1 + (entries.length - frequency + 0.5) / (frequency + 0.5)));
+        }
+    }
+    /** Methods ranked by BM25 over name, namespace, summary, tags and description. */
+    search(query, accept) {
+        const allTerms = [...new Set(searchTerms(query))];
+        const meaningful = allTerms.filter((term) => !stopWords.has(term));
+        const terms = meaningful.length > 0 ? meaningful : allTerms;
+        const scores = new Map();
+        for (const term of terms) {
+            const idf = this.idf.get(term);
+            if (idf === undefined)
+                continue;
+            for (const { index, weight } of this.postings.get(term)) {
+                scores.set(index, (scores.get(index) ?? 0) + idf * weight * (bm25K1 + 1) / (weight + bm25K1));
+            }
+        }
+        const exact = query.trim().toLowerCase();
+        return [...scores.entries()]
+            .map(([index, score]) => {
+            const entry = this.entries[index];
+            const bonus = entry.path.toLowerCase() === exact || entry.name.toLowerCase() === exact ? 1000 : 0;
+            return { entry, score: score + bonus };
+        })
+            .filter(({ entry }) => accept(entry))
+            .sort((left, right) => right.score - left.score || compareCodePoints(left.entry.path, right.entry.path))
+            .map(({ entry }) => entry);
+    }
+}
+class FlexToolCatalogCore {
+    mode;
+    methods;
+    types;
+    onProposals;
+    renderedMethods = new Map();
+    renderedTypes = new Map();
+    validators = new Map();
+    selfContainedInputs = new Map();
+    index;
+    constructor(mode, methods, types, onProposals) {
+        this.mode = mode;
+        this.methods = methods;
+        this.types = types;
+        this.onProposals = onProposals;
+        this.index = new CatalogSearchIndex([...methods.values()]);
+    }
+    static async build(catalog, mode) {
+        if (!isPlainObject(catalog))
+            throw new FlexHarnessValidationError('A tool catalog must be a plain object.');
+        const unsupported = Object.keys(catalog).find((key) => !catalogKeys.has(key));
+        if (unsupported)
+            throw new FlexHarnessValidationError(`A tool catalog does not support "${unsupported}".`);
+        const onProposals = catalog.onProposals;
+        if (onProposals !== undefined && typeof onProposals !== 'function') {
+            throw new FlexHarnessValidationError('A tool catalog onProposals must be a function.');
+        }
+        if (!Array.isArray(catalog.methods) || catalog.methods.length > limits.maxMethods) {
+            throw new FlexHarnessValidationError(`Tool catalog methods must be an array with at most ${limits.maxMethods} entries.`);
+        }
+        if (catalog.types !== undefined && (!Array.isArray(catalog.types) || catalog.types.length > limits.maxTypes)) {
+            throw new FlexHarnessValidationError(`Tool catalog types must be an array with at most ${limits.maxTypes} entries.`);
+        }
+        const catalogTypes = new Map();
+        for (const [index, type] of (catalog.types ?? []).entries()) {
+            const entry = await FlexToolCatalogCore.normalizeType(type, `Tool catalog type ${index}`);
+            if (catalogTypes.has(entry.name)) {
+                throw new FlexHarnessValidationError(`Tool catalog type "${entry.name}" is defined twice.`);
+            }
+            catalogTypes.set(entry.name, entry);
+        }
+        const methodInputs = [];
+        for (const [index, method] of catalog.methods.entries()) {
+            methodInputs.push(await FlexToolCatalogCore.normalizeMethod(method, `Tool catalog method ${index}`));
+        }
+        methodInputs.sort((left, right) => compareCodePoints(left.path, right.path));
+        const paths = new Set();
+        for (const method of methodInputs) {
+            if (paths.has(method.path))
+                throw new FlexHarnessValidationError(`Tool catalog method "${method.path}" is defined twice.`);
+            paths.add(method.path);
+        }
+        for (const method of methodInputs) {
+            for (let end = method.path.indexOf('.'); end !== -1; end = method.path.indexOf('.', end + 1)) {
+                const namespace = method.path.slice(0, end);
+                if (paths.has(namespace)) {
+                    throw new FlexHarnessValidationError(`Tool catalog path "${namespace}" is both a method and a namespace.`);
+                }
+            }
+        }
+        const registry = new Map(catalogTypes);
+        const canonicalDefinitions = new Map();
+        const scopeOf = (root, label, requireSchemas) => {
+            const scope = { root, localNames: new Map() };
+            FlexToolCatalogCore.checkRefs(root, label, catalogTypes, requireSchemas);
+            if (!isSchemaRecord(root))
+                return scope;
+            for (const container of ['$defs', 'definitions']) {
+                const definitions = root[container];
+                if (!isSchemaRecord(definitions))
+                    continue;
+                for (const key of Object.keys(definitions).sort(compareCodePoints)) {
+                    if (!typeNamePattern.test(key) || reservedWords.has(key) || key.length > limits.maxIdentifierCharacters)
+                        continue;
+                    const definition = definitions[key];
+                    const canonical = stableStringify(definition);
+                    let name = key;
+                    for (let suffix = 2;; suffix++) {
+                        const existing = registry.get(name);
+                        if (!existing) {
+                            registry.set(name, { name, definition, scope });
+                            canonicalDefinitions.set(name, canonical);
+                            break;
+                        }
+                        if (existing.definition === undefined || canonicalDefinitions.get(name) === canonical)
+                            break;
+                        name = `${key}_${suffix}`;
+                    }
+                    scope.localNames.set(`${container}/${key}`, name);
+                }
+            }
+            return scope;
+        };
+        for (const type of catalogTypes.values()) {
+            if (!type.schema)
+                continue;
+            registry.set(type.name, { ...type, scope: scopeOf(type.schema.json, `Tool catalog type "${type.name}"`, true) });
+        }
+        const methods = new Map();
+        for (const method of methodInputs) {
+            methods.set(method.path, {
+                ...method,
+                inputScope: scopeOf(method.input.json, `Tool catalog method "${method.path}" inputSchema`, true),
+                ...(method.output
+                    ? { outputScope: scopeOf(method.output.json, `Tool catalog method "${method.path}" outputSchema`, false) }
+                    : {}),
+            });
+        }
+        const types = new Map([...registry.entries()].sort(([left], [right]) => compareCodePoints(left, right)));
+        return new FlexToolCatalogCore(mode, methods, types, onProposals === undefined
+            ? undefined
+            : (proposals, context) => onProposals.call(catalog, proposals, context));
+    }
+    static async normalizeType(value, label) {
+        if (!isPlainObject(value))
+            throw new FlexHarnessValidationError(`${label} must be a plain object.`);
+        const unsupported = Object.keys(value).find((key) => !typeKeys.has(key));
+        if (unsupported)
+            throw new FlexHarnessValidationError(`${label} does not support "${unsupported}".`);
+        const name = textOf(value.name, `${label} name`, { maxCharacters: limits.maxIdentifierCharacters, singleLine: true });
+        if (!typeNamePattern.test(name) || reservedWords.has(name)) {
+            throw new FlexHarnessValidationError(`${label} name must be an identifier that is not a reserved word.`);
+        }
+        if (value.schema === undefined && value.declaration === undefined) {
+            throw new FlexHarnessValidationError(`Tool catalog type "${name}" needs a schema or a declaration.`);
+        }
+        const description = value.description === undefined
+            ? undefined
+            : textOf(value.description, `Tool catalog type "${name}" description`, { maxBytes: limits.maxDescriptionBytes });
+        const declaration = value.declaration === undefined
+            ? undefined
+            : textOf(value.declaration, `Tool catalog type "${name}" declaration`, { maxBytes: limits.maxDeclarationBytes });
+        if (declaration !== undefined && !new RegExp(`\\b(?:interface|type|enum|class)\\s+${name}\\b`).test(declaration)) {
+            throw new FlexHarnessValidationError(`Tool catalog type "${name}" declaration must declare "${name}".`);
+        }
+        const schema = value.schema === undefined
+            ? undefined
+            : await resolveCatalogSchema(value.schema, `Tool catalog type "${name}" schema`);
+        if (schema && isSchemaRecord(schema.json) && (schema.json.$defs !== undefined || schema.json.definitions !== undefined)) {
+            throw new FlexHarnessValidationError(`Tool catalog type "${name}" schema must refer to other catalog types instead of defining $defs.`);
+        }
+        return {
+            name,
+            ...(description === undefined ? {} : { description }),
+            ...(declaration === undefined ? {} : { declaration }),
+            ...(schema === undefined ? {} : { schema }),
+        };
+    }
+    static async normalizeMethod(value, label) {
+        if (!isPlainObject(value))
+            throw new FlexHarnessValidationError(`${label} must be a plain object.`);
+        const unsupported = Object.keys(value).find((key) => !methodKeys.has(key));
+        if (unsupported)
+            throw new FlexHarnessValidationError(`${label} does not support "${unsupported}".`);
+        const path = textOf(value.method, `${label} method`, { maxCharacters: limits.maxMethodPathCharacters, singleLine: true });
+        const segments = path.split('.');
+        if (!methodPathPattern.test(path)
+            || segments.length > limits.maxMethodPathSegments
+            || segments.some((segment) => segment.length > limits.maxIdentifierCharacters)) {
+            throw new FlexHarnessValidationError(`${label} method "${path}" must be a dotted path of at most ${limits.maxMethodPathSegments} identifiers.`);
+        }
+        const reserved = segments.find((segment) => reservedWords.has(segment));
+        if (reserved) {
+            throw new FlexHarnessValidationError(`${label} method "${path}" uses the reserved word "${reserved}", which a declaration cannot name.`);
+        }
+        const methodLabel = `Tool catalog method "${path}"`;
+        const summary = textOf(value.summary, `${methodLabel} summary`, {
+            maxCharacters: limits.maxSummaryCharacters, singleLine: true,
+        }).trim();
+        const description = value.description === undefined
+            ? undefined
+            : textOf(value.description, `${methodLabel} description`, { maxBytes: limits.maxDescriptionBytes }).trim();
+        const tags = textListOf(value.tags, `${methodLabel} tags`, limits.maxTags, {
+            maxCharacters: limits.maxTagCharacters, singleLine: true,
+        });
+        const examples = textListOf(value.examples, `${methodLabel} examples`, limits.maxExamples, {
+            maxBytes: limits.maxExampleBytes,
+        });
+        const name = segments[segments.length - 1];
+        const declaration = value.declaration === undefined
+            ? undefined
+            : textOf(value.declaration, `${methodLabel} declaration`, { maxBytes: limits.maxDeclarationBytes });
+        if (declaration !== undefined && !new RegExp(`\\bfunction\\s+${name}\\s*[<(]`).test(declaration)) {
+            throw new FlexHarnessValidationError(`${methodLabel} declaration must declare "function ${name}(".`);
+        }
+        if (typeof value.run !== 'function')
+            throw new FlexHarnessValidationError(`${methodLabel} run must be a function.`);
+        if (value.onCall !== undefined && typeof value.onCall !== 'function') {
+            throw new FlexHarnessValidationError(`${methodLabel} onCall must be a function.`);
+        }
+        if (value.inputSchema === undefined)
+            throw new FlexHarnessValidationError(`${methodLabel} needs an inputSchema.`);
+        const input = await resolveCatalogSchema(value.inputSchema, `${methodLabel} inputSchema`);
+        const inputJson = input.json;
+        const describesObject = isSchemaRecord(inputJson) && (inputJson.type === 'object'
+            || (Array.isArray(inputJson.type) && inputJson.type.includes('object'))
+            || (inputJson.type === undefined && (inputJson.properties !== undefined || inputJson.$ref !== undefined
+                || inputJson.anyOf !== undefined || inputJson.oneOf !== undefined || inputJson.allOf !== undefined)));
+        if (!describesObject)
+            throw new FlexHarnessValidationError(`${methodLabel} inputSchema must describe an object.`);
+        const output = value.outputSchema === undefined
+            ? undefined
+            : await resolveCatalogSchema(value.outputSchema, `${methodLabel} outputSchema`);
+        const run = value.run;
+        const onCall = value.onCall;
+        return {
+            path,
+            namespace: segments.slice(0, -1).join('.'),
+            name,
+            summary,
+            ...(description ? { description } : {}),
+            tags: Object.freeze(tags),
+            examples: Object.freeze(examples),
+            input,
+            ...(output ? { output } : {}),
+            ...(declaration === undefined ? {} : { declaration }),
+            run: (params, context) => run.call(value, params, context),
+            ...(onCall === undefined ? {} : {
+                onCall: (params, context) => onCall.call(value, params, context),
+            }),
+        };
+    }
+    /** Every `$ref` must be local and resolve here or, as a definition reference, to a catalog type. */
+    static checkRefs(root, label, catalogTypes, requireSchemas) {
+        const refs = new Set();
+        collectRefs(root, refs);
+        const pending = [...refs];
+        const visited = new Set();
+        while (pending.length > 0) {
+            const ref = pending.pop();
+            if (visited.has(ref))
+                continue;
+            visited.add(ref);
+            if (!ref.startsWith('#'))
+                throw new FlexHarnessValidationError(`${label} has the non-local $ref "${ref}".`);
+            if (resolvePointer(root, ref) !== undefined)
+                continue;
+            const match = definitionRefPattern.exec(ref);
+            const type = match ? catalogTypes.get(decodePointerToken(match[2])) : undefined;
+            if (!type)
+                throw new FlexHarnessValidationError(`${label} has the unresolved $ref "${ref}".`);
+            if (!requireSchemas)
+                continue;
+            if (!type.schema) {
+                throw new FlexHarnessValidationError(`${label} refers to type "${type.name}", which has no schema to validate with.`);
+            }
+            const nested = new Set();
+            collectRefs(type.schema.json, nested);
+            pending.push(...nested);
+        }
+    }
+    scopeContext(scope) {
+        return {
+            namedType: (ref) => {
+                const match = definitionRefPattern.exec(ref);
+                if (!match)
+                    return undefined;
+                const key = decodePointerToken(match[2]);
+                const local = scope.localNames.get(`${match[1]}/${key}`);
+                if (local)
+                    return local;
+                if (resolvePointer(scope.root, ref) !== undefined)
+                    return undefined;
+                return this.types.has(key) ? key : undefined;
+            },
+            resolve: (ref) => {
+                const target = resolvePointer(scope.root, ref);
+                return isSchemaRecord(target) || typeof target === 'boolean' ? target : undefined;
+            },
+        };
+    }
+    renderType(name) {
+        const cached = this.renderedTypes.get(name);
+        if (cached)
+            return cached;
+        const type = this.types.get(name);
+        let rendered;
+        if (type.declaration !== undefined) {
+            rendered = { text: type.declaration.trim(), types: this.scanTypes(type.declaration, name) };
+        }
+        else {
+            const schema = type.definition ?? type.schema.json;
+            const writer = new SchemaDeclarationWriter(this.scopeContext(type.scope));
+            const text = writer.namedDeclaration(name, schema, type.description);
+            rendered = { text, types: writer.usedTypes.filter((used) => used !== name) };
+        }
+        this.renderedTypes.set(name, rendered);
+        return rendered;
+    }
+    renderMethod(entry) {
+        const cached = this.renderedMethods.get(entry.path);
+        if (cached)
+            return cached;
+        let rendered;
+        if (entry.declaration !== undefined) {
+            rendered = { text: entry.declaration.trim(), types: this.scanTypes(entry.declaration) };
+        }
+        else {
+            const inputWriter = new SchemaDeclarationWriter(this.scopeContext(entry.inputScope));
+            const members = inputWriter.objectMembers(entry.input.json);
+            const paramsType = inputWriter.type(entry.input.json, '', 0, members !== undefined);
+            const optional = inputWriter.hasNoRequiredProperties(entry.input.json) ? '?' : '';
+            const outputWriter = entry.output && entry.outputScope
+                ? new SchemaDeclarationWriter(this.scopeContext(entry.outputScope))
+                : undefined;
+            const resultType = outputWriter ? outputWriter.type(entry.output.json) : 'unknown';
+            const lines = [entry.summary];
+            if (entry.description && entry.description !== entry.summary)
+                lines.push('', ...entry.description.split('\n'));
+            for (const member of members ?? []) {
+                if (member.doc === undefined)
+                    continue;
+                const key = isIdentifier(member.name) ? `.${member.name}` : `[${JSON.stringify(member.name)}]`;
+                lines.push(`@param params${key} ${member.doc.replace(/\s*\n\s*/g, ' ')}`);
+            }
+            for (const example of entry.examples) {
+                lines.push(...(example.includes('\n') ? ['@example', ...example.split('\n')] : [`@example ${example}`]));
+            }
+            const signature = `function ${entry.name}(params${optional}: ${paramsType}): Promise<${resultType}>;`;
+            rendered = {
+                text: `${docBlock(lines.join('\n'), '')}${signature}`,
+                types: [...new Set([...inputWriter.usedTypes, ...(outputWriter?.usedTypes ?? [])])].sort(compareCodePoints),
+            };
+        }
+        this.renderedMethods.set(entry.path, rendered);
+        return rendered;
+    }
+    scanTypes(text, self) {
+        const found = new Set();
+        for (const match of text.matchAll(identifierScanPattern)) {
+            if (match[0] !== self && this.types.has(match[0]))
+                found.add(match[0]);
+        }
+        return [...found].sort(compareCodePoints);
+    }
+    /** `names` and every type they use, transitively, sorted. */
+    typeClosure(names, stop = new Set()) {
+        const result = new Set();
+        const pending = [...names];
+        while (pending.length > 0) {
+            const name = pending.pop();
+            if (result.has(name) || stop.has(name) || !this.types.has(name))
+                continue;
+            result.add(name);
+            pending.push(...this.renderType(name).types);
+        }
+        return [...result].sort(compareCodePoints);
+    }
+    /** The method's input schema with the catalog types it refers to added as definitions. */
+    selfContainedInput(entry) {
+        const cached = this.selfContainedInputs.get(entry.path);
+        if (cached !== undefined)
+            return cached;
+        const root = structuredClone(entry.input.json);
+        if (isSchemaRecord(root)) {
+            const pending = new Set();
+            collectRefs(root, pending);
+            const queue = [...pending];
+            while (queue.length > 0) {
+                const ref = queue.pop();
+                const match = definitionRefPattern.exec(ref);
+                if (!match || resolvePointer(root, ref) !== undefined)
+                    continue;
+                const type = this.types.get(decodePointerToken(match[2]));
+                if (!type?.schema)
+                    continue;
+                const container = (isSchemaRecord(root[match[1]]) ? root[match[1]] : (root[match[1]] = {}));
+                container[decodePointerToken(match[2])] = withoutDraft(structuredClone(type.schema.json));
+                const nested = new Set();
+                collectRefs(type.schema.json, nested);
+                queue.push(...nested);
+            }
+        }
+        deepFreeze(root);
+        this.selfContainedInputs.set(entry.path, root);
+        return root;
+    }
+    validator(entry) {
+        let validator = this.validators.get(entry.path);
+        if (!validator) {
+            const root = structuredClone(this.selfContainedInput(entry));
+            validator = new plugins.JsonSchemaValidator(root, schemaDraft(root), false);
+            this.validators.set(entry.path, validator);
+        }
+        return validator;
+    }
+}
+/**
+ * A tool catalog prepared for the model: search, TypeScript declarations, parameter validation and
+ * dispatch. FlexHarness builds one for every catalog a tool provider returns; it is public so a
+ * host can check what its catalog shows the model, and measure it, without running a session.
+ */
+export class FlexToolCatalog {
+    core;
+    admitted;
+    codeMode;
+    namespaceTree;
+    constructor(core, admitted, 
+    /** The limits of `run_code`; absent while code mode is off. */
+    codeMode) {
+        this.core = core;
+        this.admitted = admitted;
+        this.codeMode = codeMode;
+    }
+    /**
+     * Prepares `catalog`. Preparing the same object again returns the cached preparation, so a host
+     * that returns one catalog object for every run pays for it once.
+     */
+    static async create(catalog, options = {}) {
+        const normalized = normalizeToolCatalogOptions(options);
+        const mode = normalized.declarations;
+        if (typeof catalog !== 'object' || catalog === null) {
+            throw new FlexHarnessValidationError('A tool catalog must be a plain object.');
+        }
+        let byMode = coreCache.get(catalog);
+        if (!byMode) {
+            byMode = new Map();
+            coreCache.set(catalog, byMode);
+        }
+        let core = byMode.get(mode);
+        if (!core) {
+            core = FlexToolCatalogCore.build(catalog, mode);
+            byMode.set(mode, core);
+        }
+        return new FlexToolCatalog(await core, undefined, normalized.codeMode);
+    }
+    /** Every method path this catalog offers, sorted. */
+    get methods() {
+        return [...this.core.methods.keys()].filter((path) => this.isAdmitted(path));
+    }
+    /** Every named type, sorted. */
+    get types() {
+        return [...this.core.types.keys()];
+    }
+    /** The same catalog offering only `paths`. */
+    restrict(paths) {
+        const allowed = new Set(paths);
+        return new FlexToolCatalog(this.core, new Set([...this.core.methods.keys()].filter((path) => allowed.has(path) && this.isAdmitted(path))), this.codeMode);
+    }
+    has(path) {
+        return this.core.methods.has(path) && this.isAdmitted(path);
+    }
+    /**
+     * The built-in tools as the model sees them: the three catalog tools, and `run_code` in code
+     * mode. Their text depends only on the catalog and its options.
+     */
+    toolDefinitions() {
+        const typescript = this.core.mode === 'typescript';
+        const methodPath = { type: 'string', maxLength: limits.maxMethodPathCharacters };
+        return {
+            [toolNames.search]: {
+                description: [
+                    'Search the API catalog. Its methods are called with execute, not as tools. `query` ranks methods by',
+                    'name, summary and description; `namespace` (a dotted path) narrows the search or, without `query`, lists',
+                    `the namespace like ls. Read a method's ${typescript ? 'TypeScript declaration' : 'description and JSON Schema'}`,
+                    'with describe_tools before calling it.',
+                    this.topLevelLine(),
+                ].join(' '),
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        query: { type: 'string', maxLength: limits.maxQueryCharacters },
+                        namespace: methodPath,
+                        limit: { type: 'integer', minimum: 1, maximum: limits.maxSearchResults },
+                        offset: { type: 'integer', minimum: 0 },
+                    },
+                    additionalProperties: false,
+                },
+            },
+            [toolNames.describe]: {
+                description: typescript
+                    ? 'Return the TypeScript declarations of catalog methods (`methods`: dotted paths) and named types (`types`). '
+                        + 'A declaration comes with the named types it uses that this conversation has not declared yet.'
+                    : 'Return the description and JSON Schema of catalog methods (`methods`: dotted paths) and named types (`types`).',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        methods: { type: 'array', items: methodPath, maxItems: limits.maxDescribeMethods },
+                        types: {
+                            type: 'array',
+                            items: { type: 'string', maxLength: limits.maxIdentifierCharacters },
+                            maxItems: limits.maxDescribeTypes,
+                        },
+                    },
+                    additionalProperties: false,
+                },
+            },
+            [toolNames.execute]: {
+                description: 'Call a catalog method: `method` is its dotted path, `params` the parameter object of its '
+                    + 'declaration. Invalid params return an error naming each path, what was expected and what was given.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        method: { ...methodPath, minLength: 1 },
+                        params: { type: 'object' },
+                    },
+                    required: ['method'],
+                    additionalProperties: false,
+                },
+            },
+            ...(this.codeMode ? { [FLEX_CODE_MODE_TOOL_NAME]: this.codeToolDefinition(this.codeMode) } : {}),
+        };
+    }
+    codeToolDefinition(codeMode) {
+        return {
+            description: [
+                'Run a short TypeScript or JavaScript program against the catalog, for work that takes several calls:',
+                'loops, filters, joins. Call a method as `await api.<dotted path>(params)`, for example',
+                '`await api.banking.listMovements({ accountId })`, with the declarations describe_tools returns; a refused',
+                'call throws an `ApiError` whose `details` say why. `return` a JSON value: it and the `console.log` output',
+                'come back, nothing else does. No network, files, timers or imports;',
+                `at most ${codeMode.maxCalls} calls and ${Math.round(codeMode.wallMs / 1000)} seconds.`,
+            ].join(' '),
+            inputSchema: {
+                type: 'object',
+                properties: { code: { type: 'string', minLength: 1, maxLength: codeMode.maxSourceBytes } },
+                required: ['code'],
+                additionalProperties: false,
+            },
+        };
+    }
+    /** Hands proposed calls to the catalog's `onProposals` and returns what the model sees for them. */
+    async propose(proposals, context) {
+        if (!this.core.onProposals) {
+            throw new FlexHarnessValidationError(`Tool catalog method "${proposals[0]?.method}" proposed a call, but the catalog has no onProposals.`);
+        }
+        return await this.core.onProposals(proposals, context);
+    }
+    /** Search results or a namespace listing as text. */
+    search(input = {}) {
+        const limit = input.limit ?? limits.defaultSearchResults;
+        const offset = input.offset ?? 0;
+        if (!Number.isSafeInteger(limit) || limit < 1 || limit > limits.maxSearchResults) {
+            throw new FlexHarnessValidationError(`limit must be an integer from 1 through ${limits.maxSearchResults}.`);
+        }
+        if (!Number.isSafeInteger(offset) || offset < 0)
+            throw new FlexHarnessValidationError('offset must be a non-negative integer.');
+        const namespace = (input.namespace ?? '').trim().replace(/\.\*?$/, '');
+        const tree = this.tree();
+        if (namespace && !tree.has(namespace)) {
+            if (this.has(namespace)) {
+                return `${namespace} is a method, not a namespace; read it with describe_tools.`;
+            }
+            const suggestions = closeMatches(namespace, [...tree.keys()].filter(Boolean));
+            return [
+                `There is no namespace ${namespace}.${suggestions.length ? ` Did you mean ${suggestions.join(', ')}?` : ''}`,
+                this.topLevelLine(),
+            ].join('\n');
+        }
+        const query = (input.query ?? '').trim();
+        if (query) {
+            const prefix = namespace ? `${namespace}.` : '';
+            const matches = this.core.index.search(query, (entry) => this.isAdmitted(entry.path) && entry.path.startsWith(prefix));
+            if (matches.length === 0) {
+                return [`No methods match "${query}"${namespace ? ` in ${namespace}` : ''}.`, this.topLevelLine()].join('\n');
+            }
+            return this.page(matches.map((entry) => `${entry.path} - ${entry.summary}`), offset, limit, 'matches');
+        }
+        const node = tree.get(namespace);
+        const lines = [...node.children.entries()].map(([child, count]) => `${child}.* (${count} method${count === 1 ? '' : 's'})`);
+        const methodLines = node.methods.map((entry) => `${entry.path} - ${entry.summary}`);
+        if (methodLines.length === 0)
+            return lines.join('\n') || 'The catalog has no methods.';
+        return [...lines, this.page(methodLines, offset, limit, 'methods')].filter(Boolean).join('\n');
+    }
+    /**
+     * The declarations of `input.methods` and `input.types`. Method declarations bring the named
+     * types they use, minus `declaredTypes`, which a session already has.
+     */
+    describe(input, options = {}) {
+        const requestedMethods = [...new Set(input.methods ?? [])];
+        const requestedTypes = [...new Set(input.types ?? [])];
+        if (requestedMethods.length > limits.maxDescribeMethods || requestedTypes.length > limits.maxDescribeTypes) {
+            throw new FlexHarnessValidationError(`describe_tools takes at most ${limits.maxDescribeMethods} methods and ${limits.maxDescribeTypes} types.`);
+        }
+        const maxBytes = Math.min(options.maxBytes ?? limits.maxDescribeBytes, limits.maxDescribeBytes);
+        const entries = requestedMethods.filter((path) => this.has(path)).sort(compareCodePoints)
+            .map((path) => this.core.methods.get(path));
+        const unknownMethods = requestedMethods.filter((path) => !this.has(path)).sort(compareCodePoints);
+        const knownTypes = requestedTypes.filter((name) => this.core.types.has(name)).sort(compareCodePoints);
+        const unknownTypes = requestedTypes.filter((name) => !this.core.types.has(name)).sort(compareCodePoints);
+        const notes = [
+            ...unknownMethods.map((path) => {
+                const suggestions = closeMatches(path, this.methods);
+                return `Unknown method ${path}.${suggestions.length ? ` Did you mean ${suggestions.join(', ')}?` : ' Find methods with search_tools.'}`;
+            }),
+            ...unknownTypes.map((name) => {
+                const suggestions = closeMatches(name, this.core.types.keys());
+                return `Unknown type ${name}.${suggestions.length ? ` Did you mean ${suggestions.join(', ')}?` : ''}`;
+            }),
+        ];
+        if (requestedMethods.length === 0 && requestedTypes.length === 0) {
+            notes.push('Pass methods (dotted paths) or types to describe.');
+        }
+        return this.core.mode === 'json-schema'
+            ? this.describeJson(entries, knownTypes, notes, maxBytes)
+            : this.describeTypescript(entries, knownTypes, notes, new Set(options.declaredTypes ?? []), maxBytes);
+    }
+    /** The named types `describe_tools` results in `messages` declared. */
+    declaredTypesIn(messages) {
+        const declared = new Set();
+        for (const message of messages ?? []) {
+            if (message.role !== 'tool' || !Array.isArray(message.content))
+                continue;
+            for (const part of message.content) {
+                if (part.type !== 'tool-result' || part.toolName !== toolNames.describe)
+                    continue;
+                const output = part.output;
+                if (output.type !== 'text' || typeof output.value !== 'string' || !output.value.startsWith(declaredTypesHeader))
+                    continue;
+                const lineEnd = output.value.indexOf('\n');
+                const header = output.value.slice(declaredTypesHeader.length, lineEnd === -1 ? undefined : lineEnd);
+                for (const name of header.split(', '))
+                    if (this.core.types.has(name))
+                        declared.add(name);
+            }
+        }
+        return declared;
+    }
+    /**
+     * Resolves and validates a call. A failure is the error `execute` reports to the model; success
+     * returns the run with the validated parameters. A schema validator that throws rejects.
+     */
+    async prepareCall(method, params) {
+        const path = typeof method === 'string' ? method : '';
+        if (!this.has(path)) {
+            const isNamespace = path !== '' && this.tree().has(path);
+            return {
+                success: false,
+                error: {
+                    error: 'unknown_method',
+                    method: path,
+                    didYouMean: isNamespace ? [] : closeMatches(path, this.methods),
+                    hint: isNamespace
+                        ? `${path} is a namespace; list it with search_tools({"namespace":"${path}"}).`
+                        : 'Find methods with search_tools.',
+                },
+            };
+        }
+        const entry = this.core.methods.get(path);
+        const value = params === undefined ? {} : params;
+        const issues = this.validateStructure(entry, value);
+        let validated = value;
+        if (issues.length === 0 && entry.input.validate) {
+            // A validator that throws failed itself; only a failure it reports is the model's to repair.
+            const result = await entry.input.validate(value);
+            if (result.success)
+                validated = result.value;
+            else
+                issues.push(...this.foreignIssues(result.error, value));
+        }
+        if (issues.length > 0) {
+            const listed = issues.slice(0, limits.maxParamIssues);
+            return {
+                success: false,
+                error: {
+                    error: 'invalid_params',
+                    method: path,
+                    issues: listed,
+                    ...(issues.length > listed.length ? { more: issues.length - listed.length } : {}),
+                    see: `describe_tools({"methods":["${path}"]})`,
+                },
+            };
+        }
+        return {
+            success: true,
+            method: path,
+            params: validated,
+            decide: async (context) => {
+                const decision = entry.onCall ? await entry.onCall(validated, context) : 'run';
+                if (decision === 'run' || decision === 'propose')
+                    return decision;
+                if (isSchemaRecord(decision)
+                    && Object.keys(decision).length === 1
+                    && typeof decision.deny === 'string'
+                    && decision.deny.trim()) {
+                    return { deny: decision.deny.slice(0, 2000) };
+                }
+                throw new FlexHarnessValidationError(`Tool catalog method "${path}" onCall returned an invalid decision.`);
+            },
+            run: (context) => entry.run(validated, context),
+        };
+    }
+    /** The real method and params of an `execute` input, when it names a method of this catalog. */
+    callTarget(input) {
+        if (!isSchemaRecord(input) || typeof input.method !== 'string' || !this.has(input.method))
+            return undefined;
+        return { method: input.method, params: input.params === undefined ? {} : input.params };
+    }
+    isAdmitted(path) {
+        return this.admitted === undefined || this.admitted.has(path);
+    }
+    tree() {
+        if (this.namespaceTree)
+            return this.namespaceTree;
+        const tree = new Map();
+        const node = (namespace) => {
+            let entry = tree.get(namespace);
+            if (!entry) {
+                entry = { methods: [], children: new Map() };
+                tree.set(namespace, entry);
+            }
+            return entry;
+        };
+        node('');
+        for (const entry of this.core.methods.values()) {
+            if (!this.isAdmitted(entry.path))
+                continue;
+            node(entry.namespace).methods.push(entry);
+            const segments = entry.path.split('.');
+            for (let depth = 1; depth < segments.length; depth++) {
+                const parent = segments.slice(0, depth - 1).join('.');
+                const child = segments.slice(0, depth).join('.');
+                const children = node(parent).children;
+                children.set(child, (children.get(child) ?? 0) + 1);
+                node(child);
+            }
+        }
+        for (const entry of tree.values()) {
+            entry.children = new Map([...entry.children.entries()].sort(([left], [right]) => compareCodePoints(left, right)));
+        }
+        this.namespaceTree = tree;
+        return tree;
+    }
+    topLevelLine() {
+        const root = this.tree().get('');
+        const namespaces = [...root.children.entries()];
+        const shown = namespaces.slice(0, 40).map(([name, count]) => `${name}.* (${count})`);
+        if (namespaces.length > shown.length)
+            shown.push(`${namespaces.length - shown.length} more namespaces`);
+        if (root.methods.length > 0) {
+            shown.push(namespaces.length > 0
+                ? `${root.methods.length} top-level method${root.methods.length === 1 ? '' : 's'}`
+                : `${root.methods.length} method${root.methods.length === 1 ? '' : 's'}`);
+        }
+        return `Top level: ${shown.join(', ') || 'no methods'}.`;
+    }
+    page(lines, offset, limit, noun) {
+        const shown = lines.slice(offset, offset + limit);
+        if (shown.length === 0)
+            return `No more ${noun}: there are ${lines.length}.`;
+        if (offset === 0 && shown.length === lines.length)
+            return shown.join('\n');
+        const end = offset + shown.length;
+        const more = end < lines.length ? `; pass offset ${end} for more` : '';
+        return [...shown, `Showing ${offset + 1}-${end} of ${lines.length} ${noun}${more}.`].join('\n');
+    }
+    describeTypescript(entries, requestedTypes, notes, declared, maxBytes) {
+        const included = [];
+        const omitted = [];
+        const alreadyDeclared = new Set([...declared].filter((name) => !requestedTypes.includes(name)));
+        let types = this.core.typeClosure(requestedTypes, alreadyDeclared);
+        const assemble = (methods, typeNames, skipped) => {
+            const used = new Set(methods.flatMap((entry) => this.core.typeClosure(this.core.renderMethod(entry).types)));
+            const earlier = [...used].filter((name) => declared.has(name) && !typeNames.includes(name)).sort(compareCodePoints);
+            const blocks = [];
+            if (typeNames.length)
+                blocks.push(`${declaredTypesHeader}${typeNames.join(', ')}`);
+            for (const name of typeNames)
+                blocks.push(this.core.renderType(name).text);
+            const byNamespace = new Map();
+            for (const entry of methods)
+                byNamespace.set(entry.namespace, [...(byNamespace.get(entry.namespace) ?? []), entry]);
+            for (const [namespace, members] of byNamespace) {
+                const texts = members.map((entry) => this.core.renderMethod(entry).text);
+                if (namespace)
+                    blocks.push(`declare namespace ${namespace} {\n${indentLines(texts.join('\n'), '  ')}\n}`);
+                else
+                    blocks.push(...texts.map(withDeclare));
+            }
+            const trailing = [
+                ...(earlier.length ? [`Declared earlier: ${earlier.join(', ')}; describe_tools({"types":[...]}) declares them again.`] : []),
+                ...notes,
+                ...(skipped.length ? [`Not included to stay within the size limit: ${skipped.join(', ')}; describe them in another call.`] : []),
+            ];
+            if (trailing.length)
+                blocks.push(trailing.map((note) => `// ${note}`).join('\n'));
+            return blocks.join('\n\n');
+        };
+        for (const entry of entries) {
+            const candidate = [...included, entry];
+            const candidateTypes = this.core.typeClosure([...requestedTypes, ...candidate.flatMap((method) => this.core.renderMethod(method).types)], alreadyDeclared);
+            const text = assemble(candidate, candidateTypes, entries.slice(candidate.length).map((method) => method.path));
+            if (Buffer.byteLength(JSON.stringify(text), 'utf8') > maxBytes && included.length > 0) {
+                omitted.push(...entries.slice(included.length).map((method) => method.path));
+                break;
+            }
+            included.push(entry);
+            types = candidateTypes;
+        }
+        const text = assemble(included, types, omitted);
+        return { output: text, declaredTypes: types };
+    }
+    describeJson(entries, requestedTypes, notes, maxBytes) {
+        const methods = [];
+        const omitted = [];
+        const typeSchemas = requestedTypes.flatMap((name) => {
+            const type = this.core.types.get(name);
+            const schema = type.definition ?? type.schema?.json;
+            return [{
+                    name,
+                    ...(type.description ? { description: type.description } : {}),
+                    ...(schema === undefined ? { declaration: type.declaration } : { schema: withoutDraft(schema) }),
+                }];
+        });
+        let size = Buffer.byteLength(JSON.stringify({ types: typeSchemas, notes }), 'utf8');
+        for (const entry of entries) {
+            const method = {
+                method: entry.path,
+                summary: entry.summary,
+                ...(entry.description ? { description: entry.description } : {}),
+                inputSchema: withoutDraft(this.core.selfContainedInput(entry)),
+                ...(entry.output ? { outputSchema: withoutDraft(entry.output.json) } : {}),
+                ...(entry.examples.length ? { examples: [...entry.examples] } : {}),
+            };
+            const bytes = Buffer.byteLength(JSON.stringify(method), 'utf8') + 1;
+            if (methods.length > 0 && size + bytes > maxBytes) {
+                omitted.push(...entries.slice(methods.length).map((skipped) => skipped.path));
+                break;
+            }
+            size += bytes;
+            methods.push(method);
+        }
+        return {
+            output: JSON.parse(JSON.stringify({
+                methods,
+                ...(typeSchemas.length ? { types: typeSchemas } : {}),
+                ...(notes.length ? { notes } : {}),
+                ...(omitted.length ? { omitted } : {}),
+            })),
+            declaredTypes: [],
+        };
+    }
+    /** Issues the method's JSON Schema finds in `value`. */
+    validateStructure(entry, value) {
+        const result = this.core.validator(entry).validate(value);
+        if (result.valid)
+            return [];
+        const root = this.core.selfContainedInput(entry);
+        const writer = new SchemaDeclarationWriter({
+            namedType: (ref) => {
+                const match = definitionRefPattern.exec(ref);
+                const key = match ? decodePointerToken(match[2]) : undefined;
+                return key && typeNamePattern.test(key) ? key : undefined;
+            },
+            resolve: (ref) => {
+                const target = resolvePointer(root, ref);
+                return isSchemaRecord(target) || typeof target === 'boolean' ? target : undefined;
+            },
+        });
+        const typeText = (schema) => isSchemaRecord(schema) || typeof schema === 'boolean' ? compactType(writer.type(schema)) : 'a value';
+        const issues = [];
+        const covered = [];
+        let container;
+        for (const unit of result.errors) {
+            if (covered.some((prefix) => unit.keywordLocation.startsWith(`${prefix}/`)))
+                continue;
+            const tokens = pointerTokens(unit.instanceLocation);
+            const path = paramsPath(tokens);
+            const got = preview(valueAt(value, tokens));
+            const schemaHere = resolvePointer(root, unit.keywordLocation);
+            const parent = resolvePointer(root, unit.keywordLocation.slice(0, unit.keywordLocation.lastIndexOf('/')));
+            switch (unit.keyword) {
+                case 'additionalProperties':
+                case 'unevaluatedProperties':
+                    container = unit;
+                    continue;
+                case 'properties':
+                case 'patternProperties':
+                case 'items':
+                case 'prefixItems':
+                case 'additionalItems':
+                case 'unevaluatedItems':
+                case 'allOf':
+                case '$ref':
+                case '$recursiveRef':
+                case '$dynamicRef':
+                case 'dependentSchemas':
+                case 'if':
+                case 'then':
+                case 'else':
+                    continue;
+                case 'false': {
+                    const name = tokens[tokens.length - 1] ?? '';
+                    const owner = container && unit.instanceLocation.startsWith(`${container.instanceLocation}/`)
+                        ? resolvePointer(root, container.keywordLocation.slice(0, container.keywordLocation.lastIndexOf('/')))
+                        : undefined;
+                    if (isSchemaRecord(owner)) {
+                        const declaredProperty = isSchemaRecord(owner.properties)
+                            && Object.prototype.hasOwnProperty.call(owner.properties, name);
+                        const matchesPattern = isSchemaRecord(owner.patternProperties)
+                            && Object.keys(owner.patternProperties).some((pattern) => {
+                                try {
+                                    return new RegExp(pattern, 'u').test(name);
+                                }
+                                catch {
+                                    return false;
+                                }
+                            });
+                        if (declaredProperty || matchesPattern)
+                            continue;
+                        const known = isSchemaRecord(owner.properties) ? Object.keys(owner.properties) : [];
+                        issues.push({
+                            path,
+                            expected: known.length
+                                ? `no such property; known properties: ${known.slice(0, 20).join(', ')}`
+                                : 'no such property',
+                            got,
+                        });
+                    }
+                    else {
+                        issues.push({ path, expected: 'no value', got });
+                    }
+                    continue;
+                }
+                case 'required': {
+                    const required = Array.isArray(schemaHere) ? schemaHere.filter((key) => typeof key === 'string') : [];
+                    const instance = valueAt(value, tokens);
+                    for (const key of required) {
+                        if (isSchemaRecord(instance) && Object.prototype.hasOwnProperty.call(instance, key))
+                            continue;
+                        const property = isSchemaRecord(parent) && isSchemaRecord(parent.properties) ? parent.properties[key] : undefined;
+                        issues.push({ path: paramsPath([...tokens, key]), expected: typeText(property), got: 'missing' });
+                    }
+                    continue;
+                }
+                case 'anyOf':
+                case 'oneOf':
+                case 'not':
+                    covered.push(unit.keywordLocation);
+                    issues.push({ path, expected: unit.keyword === 'not' ? `not ${typeText(schemaHere)}` : typeText(parent), got });
+                    continue;
+                case 'type':
+                    issues.push({
+                        path,
+                        expected: Array.isArray(schemaHere) ? schemaHere.join(' | ') : String(schemaHere),
+                        got,
+                    });
+                    continue;
+                case 'enum':
+                case 'const':
+                    issues.push({ path, expected: typeText(parent), got });
+                    continue;
+                case 'minimum':
+                case 'exclusiveMinimum':
+                case 'maximum':
+                case 'exclusiveMaximum':
+                case 'multipleOf':
+                case 'minLength':
+                case 'maxLength':
+                case 'minItems':
+                case 'maxItems':
+                case 'uniqueItems':
+                case 'pattern':
+                case 'format': {
+                    const constraint = new SchemaDeclarationWriter({ namedType: () => undefined, resolve: () => undefined });
+                    const text = isSchemaRecord(parent) ? compactType(constraint.type(parent)) : 'a value';
+                    const subset = isSchemaRecord(parent) ? { type: parent.type, [unit.keyword]: schemaHere } : {};
+                    const doc = Object.keys(subset).length ? constraintText(subset) : unit.error;
+                    issues.push({ path, expected: doc ? `${text} (${doc})` : text, got });
+                    continue;
+                }
+                default:
+                    issues.push({ path, expected: unit.error, got });
+            }
+        }
+        const seen = new Set();
+        return issues.filter((issue) => {
+            const key = `${issue.path}\u0000${issue.expected}`;
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        });
+    }
+    /** Issues reported by a zod, Standard Schema or AI SDK validator. */
+    foreignIssues(error, value) {
+        const source = error;
+        const list = Array.isArray(source.issues)
+            ? source.issues
+            : isSchemaRecord(source.cause) && Array.isArray(source.cause.issues)
+                ? source.cause.issues
+                : Array.isArray(source.cause) ? source.cause : undefined;
+        if (!list || list.length === 0)
+            return [{ path: 'params', expected: error.message || 'valid params', got: preview(value) }];
+        return list.map((issue) => {
+            const record = isSchemaRecord(issue) ? issue : {};
+            const tokens = (Array.isArray(record.path) ? record.path : []).map((segment) => {
+                const key = isSchemaRecord(segment) ? segment.key : segment;
+                return typeof key === 'number' ? key : String(key);
+            });
+            const expected = typeof record.expected === 'string'
+                ? record.expected
+                : typeof record.message === 'string' ? record.message : 'a valid value';
+            return { path: paramsPath(tokens), expected, got: preview(valueAt(value, tokens)) };
+        });
+    }
+}
+const constraintText = (subset) => {
+    const parts = [];
+    const value = (key) => subset[key];
+    if (typeof value('minimum') === 'number')
+        parts.push(`>= ${value('minimum')}`);
+    if (typeof value('exclusiveMinimum') === 'number')
+        parts.push(`> ${value('exclusiveMinimum')}`);
+    if (typeof value('maximum') === 'number')
+        parts.push(`<= ${value('maximum')}`);
+    if (typeof value('exclusiveMaximum') === 'number')
+        parts.push(`< ${value('exclusiveMaximum')}`);
+    if (typeof value('multipleOf') === 'number')
+        parts.push(`multiple of ${value('multipleOf')}`);
+    if (typeof value('minLength') === 'number')
+        parts.push(`at least ${countOf(value('minLength'), 'character')}`);
+    if (typeof value('maxLength') === 'number')
+        parts.push(`at most ${countOf(value('maxLength'), 'character')}`);
+    if (typeof value('minItems') === 'number')
+        parts.push(`at least ${countOf(value('minItems'), 'item')}`);
+    if (typeof value('maxItems') === 'number')
+        parts.push(`at most ${countOf(value('maxItems'), 'item')}`);
+    if (value('uniqueItems') === true)
+        parts.push('unique items');
+    if (typeof value('pattern') === 'string')
+        parts.push(`matching /${value('pattern')}/`);
+    if (typeof value('format') === 'string')
+        parts.push(`format ${value('format')}`);
+    return parts.join(', ');
+};
+/**
+ * While a run has a catalog, its tool names are reserved (`run_code` in code mode too), and a
+ * method path must differ from every tool name.
+ */
+export const assertNoCatalogCollisions = (catalog, tools) => {
+    const catalogToolNames = new Set([
+        ...Object.values(toolNames),
+        ...(catalog.codeMode ? [FLEX_CODE_MODE_TOOL_NAME] : []),
+    ]);
+    for (const name of catalogToolNames) {
+        if (Object.prototype.hasOwnProperty.call(tools, name)) {
+            throw new FlexHarnessValidationError(`Tool provider cannot define enabled built-in tool "${name}".`);
+        }
+    }
+    for (const path of catalog.methods) {
+        if (Object.prototype.hasOwnProperty.call(tools, path) || catalogToolNames.has(path) || path === 'invalid') {
+            throw new FlexHarnessValidationError(`Tool catalog method "${path}" has the name of a tool.`);
+        }
+    }
+};
+/**
+ * The AI SDK schema of a built-in catalog tool: the definition's JSON Schema, validated with it, so a
+ * malformed call goes back to the model like any other invalid tool input.
+ */
+export const catalogToolInputSchema = (definition) => {
+    const validator = new plugins.JsonSchemaValidator(structuredClone(definition.inputSchema), '2020-12', false);
+    return plugins.jsonSchema(definition.inputSchema, {
+        validate: (value) => {
+            const result = validator.validate(value);
+            if (result.valid)
+                return { success: true, value: value };
+            const message = result.errors
+                .filter((unit) => !['properties', 'items', 'additionalProperties'].includes(unit.keyword))
+                .map((unit) => `${unit.instanceLocation.replace(/^#/, '') || '/'}: ${unit.error}`)
+                .join(' ');
+            return { success: false, error: new Error(message || 'Invalid input.') };
+        },
+    });
+};
+/** A root-level method declaration gets `declare`, as a namespace member does not need it. */
+const withDeclare = (text) => {
+    const lines = text.split('\n');
+    const index = lines.findIndex((line) => /^(?:async\s+)?function\s/.test(line));
+    if (index !== -1)
+        lines[index] = `declare ${lines[index]}`;
+    return lines.join('\n');
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.toolcatalog.js","sourceRoot":"","sources":["../ts/classes.toolcatalog.ts"],"names":[],"mappings":"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"}