micro-models-agent 2.16.1 → 2.17.2

package/dist/tools/question.js

@@ -1,288 +0,0 @@
-/** Тул вопросов юзеру: меню, memory pre-check, батч-cap, сессионные ответы. */
-import { t } from "../i18n/index";
-import { askUser } from "./user-input";
-import { MemoryStore } from "../modules/memory/store";
-import { globalMemoryDir } from "../config/paths";
-const DESCRIPTION = `Use this tool when you need to ask the user questions during execution. This allows you to:
-1. Gather user preferences or requirements
-2. Clarify ambiguous instructions
-3. Get decisions on implementation choices as you work
-4. Offer choices to the user about what direction to take.
-
-Usage notes:
-- When "custom" is enabled (default), a "Type your own answer" option is added automatically; don't include "Other" or catch-all options
-- Answers are returned as arrays of labels; set "multiple": true to allow selecting more than one
-- If you recommend a specific option, make that the first option in the list and add "(Recommended)" at the end of the label
-- Execution blocks until the user answers every question
-- Omit "options" for a free-text question
-- Never ask choice questions as a plain-text list in your reply — always call
-  this tool (it renders interactive buttons and blocks until answered).
-  When the user asks for a Q&A session with options, use this tool for every
-  question, not chat text
-- Before asking, the tool checks agent memory itself: questions memory
-  already answers are skipped (reported back, not asked) — never ask what
-  is already known
-- Answers live only in the current session; nothing is written to memory.
-  Call "remember" separately to persist something, and only when asked to
-- At most 3 unknown questions are asked per call; keep batches small`;
-/** Проверяет форму опции (label + description — строки). */
-function isOption(val) {
-    if (!val || typeof val !== "object")
-        return false;
-    const opt = val;
-    return typeof opt.label === "string" && typeof opt.description === "string";
-}
-/** Нормализует args в спеки (массив + legacy `{ question }`). Битые — пропуск. */
-function normalizeQuestions(args) {
-    const raw = args.questions;
-    if (Array.isArray(raw)) {
-        const specs = [];
-        for (const item of raw) {
-            if (!item || typeof item !== "object")
-                continue;
-            const q = item;
-            if (typeof q.question !== "string" || !q.question.trim())
-                continue;
-            const options = Array.isArray(q.options) ? q.options.filter(isOption) : undefined;
-            // Явно данный массив опций без валидных записей — malformed вызов:
-            // вопрос пропустить, а не висеть на stdin.
-            if (Array.isArray(q.options) && options.length === 0)
-                continue;
-            specs.push({
-                question: q.question,
-                header: typeof q.header === "string" ? q.header : undefined,
-                options,
-                multiple: q.multiple === true,
-                custom: q.custom === false ? false : undefined,
-            });
-        }
-        return specs;
-    }
-    // Legacy-формат: { question: "..." } — plain free-text вопрос.
-    if (typeof args.question === "string" && args.question.trim()) {
-        return [{ question: args.question }];
-    }
-    return [];
-}
-/** Максимум незнакомых вопросов за вызов — большие батчи малые модели теряют. */
-export const MAX_QUESTIONS_PER_CALL = 3;
-/** Токенный bound memory pre-check: хиты репортятся повопросно. */
-const MAX_MEMORY_HITS = 2;
-const MAX_HIT_CHARS = 200;
-/**
- * Делит спеки на известные памяти (репорт, не спрашивать) и незнакомые.
- * Чистая через инжектируемый lookup — тесты не трогают реальный memory dir.
- */
-export function splitByMemory(specs, lookup) {
-    const known = [];
-    const unknown = [];
-    for (const spec of specs) {
-        const hits = lookup(spec);
-        if (hits.length > 0)
-            known.push({ spec, hits });
-        else
-            unknown.push(spec);
-    }
-    return { known, unknown };
-}
-/**
- * Значимые слова текста: lowercase, unicode-разбивка, длина ≥ 4. Короче
- * ("тип", "для", "что") — шум для overlap-мэтчинга.
- */
-export function extractKeywords(...texts) {
-    const out = new Set();
-    for (const text of texts) {
-        if (!text)
-            continue;
-        for (const word of text.toLowerCase().split(/[^\p{L}\p{N}]+/u)) {
-            if (word.length >= 4)
-                out.add(word);
-        }
-    }
-    return [...out];
-}
-/**
- * Строка памяти считается ответом, только если делит со вопросом не меньше
- * стольких distinct keywords. Одно общее слово ("какой", "город") — обычно
- * совпадение: пропуск на нём ответил бы из stale-данных вместо вопроса.
- * Precision важнее recall: промах просто спросит.
- */
-const MIN_KEYWORD_OVERLAP = 2;
-/**
- * Keyword-overlap поиск по памяти через инжектируемый покейвордный поиск.
- * Чистая — прод-обвязка (`lookupMemory`) передаёт `MemoryStore.search`.
- */
-export function collectMemoryHits(searchOne, spec) {
-    const keywords = extractKeywords(spec.question, spec.header, ...(spec.options ?? []).flatMap((o) => [o.label, o.description]));
-    if (keywords.length === 0)
-        return [];
-    const lines = new Map();
-    for (const kw of keywords) {
-        let hits;
-        try {
-            hits = searchOne(kw);
-        }
-        catch {
-            continue;
-        }
-        for (const r of hits) {
-            const key = `${r.file}\n${r.match}`;
-            let entry = lines.get(key);
-            if (!entry) {
-                entry = { text: `[${r.file}] ${r.match}`, matched: new Set() };
-                lines.set(key, entry);
-            }
-            entry.matched.add(kw);
-        }
-    }
-    return [...lines.values()]
-        .filter((e) => e.matched.size >= MIN_KEYWORD_OVERLAP)
-        .slice(0, MAX_MEMORY_HITS)
-        .map((e) => e.text.slice(0, MAX_HIT_CHARS));
-}
-/**
- * Fail-open поиск по памяти: нечитаемая/отсутствующая память вопрос не блокирует.
- * Возврат — короткие `file: match`-сниппеты, токенно ограниченные.
- */
-function lookupMemory(spec) {
-    try {
-        const store = new MemoryStore(globalMemoryDir());
-        return collectMemoryHits((kw) => store.search(kw), spec);
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Тестовый шов: `memorySearch` на контексте стабит memory pre-check (тот же
- * override-паттерн, что `ToolContext.agentFactory` — моки Bun-модулей глобальны
- * на процесс, plain vi.mock тут не годится).
- */
-function resolveSearch(ctx) {
-    const stub = ctx
-        .memorySearch;
-    return typeof stub === "function" ? stub : lookupMemory;
-}
-/** Тул вопросов: выбор/мультивыбор/free-text, memory pre-check, батч-cap 3. */
-export const questionTool = {
-    name: "question",
-    icon: "❓",
-    description: DESCRIPTION,
-    tags: ["core"],
-    // Интерактивные тулы переживают сужение тегов: спросить модель должна уметь
-    // всегда, при любом типе задачи (P5 auto-narrowing).
-    alwaysOn: true,
-    interactive: true,
-    parameters: {
-        type: "object",
-        properties: {
-            questions: {
-                type: "array",
-                description: "Questions to ask",
-                items: {
-                    type: "object",
-                    properties: {
-                        question: { type: "string", description: "Complete question" },
-                        header: {
-                            type: "string",
-                            description: "Very short label (max 30 chars)",
-                        },
-                        options: {
-                            type: "array",
-                            description: "Available choices; omit for a free-text question",
-                            items: {
-                                type: "object",
-                                properties: {
-                                    label: {
-                                        type: "string",
-                                        description: "Display text (1-5 words, concise)",
-                                    },
-                                    description: {
-                                        type: "string",
-                                        description: "Explanation of choice",
-                                    },
-                                },
-                                required: ["label", "description"],
-                            },
-                        },
-                        multiple: {
-                            type: "boolean",
-                            description: "Allow selecting multiple choices",
-                        },
-                        custom: {
-                            type: "boolean",
-                            description: "Allow typing a custom answer (default: true)",
-                        },
-                    },
-                    required: ["question"],
-                },
-            },
-            question: {
-                type: "string",
-                description: "Legacy single free-text question",
-            },
-        },
-    },
-    handler: async (ctx, args) => {
-        if (ctx.exitOnComplete) {
-            return { success: false, output: t("tool.interactive_disabled") };
-        }
-        const questions = normalizeQuestions(args);
-        if (questions.length === 0) {
-            return { success: false, output: t("tool.question.no_questions") };
-        }
-        // Memory pre-check: известное памяти не спрашивать. Известные вопросы —
-        // репорт, не опрос. В память ничего не пишется: ответы живут только в сессии
-        // (persist — отдельным "remember" по просьбе).
-        const { known, unknown } = splitByMemory(questions, resolveSearch(ctx));
-        // Батч-cap: не больше MAX_QUESTIONS_PER_CALL за раз, остаток — пометкой,
-        // чтобы модель довызвала, а не потеряла вопросы молча.
-        const truncated = unknown.length - MAX_QUESTIONS_PER_CALL;
-        const toAsk = truncated > 0 ? unknown.slice(0, MAX_QUESTIONS_PER_CALL) : unknown;
-        const answers = [];
-        for (let i = 0; i < toAsk.length; i++) {
-            const q = toAsk[i];
-            const progress = toAsk.length > 1
-                ? t("tool.question.progress", {
-                    current: i + 1,
-                    total: questions.length,
-                })
-                : undefined;
-            answers.push(await askUser(q.question, {
-                header: q.header,
-                options: q.options,
-                multiple: q.multiple,
-                custom: q.custom,
-                progress,
-            }, ctx.promptIO));
-        }
-        const parts = [];
-        if (toAsk.length > 0) {
-            const formatted = toAsk
-                .map((q, i) => `"${q.question}"="${answers[i].length ? answers[i].join(", ") : t("tool.question.unanswered")}"`)
-                .join(", ");
-            parts.push(t("tool.question.answered", { formatted }));
-        }
-        else {
-            parts.push(t("tool.question.memory_only"));
-        }
-        if (known.length > 0) {
-            const formatted = known
-                .map((k) => `"${k.spec.question}"="${k.hits.join("; ")}"`)
-                .join(", ");
-            parts.push(t("tool.question.memory_known", { formatted }));
-        }
-        parts.push(t("tool.question.session_only"));
-        if (truncated > 0) {
-            parts.push(t("tool.question.batch_truncated", {
-                shown: MAX_QUESTIONS_PER_CALL,
-                total: unknown.length,
-            }));
-        }
-        // display:"" гасит UI-эхо (tool-batch предпочитает display и пропускает
-        // пустые): модели — полный output в role:"tool", чату — только блок вопроса
-        // с ↳-ответами. Текст output — model-facing директивы (сессия/память/батч),
-        // не контент юзера: и verbose идёт через tool_end, не meta.
-        return { success: true, output: parts.join(" "), display: "" };
-    },
-};

package/dist/tools/read-file.js

@@ -1,200 +0,0 @@
-/** Тул чтения файла: постранично, со стримингом больших файлов. */
-import { readFileSync, existsSync, statSync, openSync, readSync, closeSync } from "fs";
-import { extname } from "path";
-import { t } from "../i18n/index";
-import { isPathInScope } from "../modules/security/path-validator";
-import { DEFAULT_SECURITY_CONFIG } from "../config/security";
-import { logSecurityBlock } from "../modules/security/audit-log";
-import { safeResolvePath } from "./path-utils";
-import { errMsg } from "../utils";
-/**
- * Строк на вызов read_file по умолчанию. Намеренно больше MAX_PREVIEW_LINES
- * (15): дефолт 15 заставлял модель делать 10–17 вызовов на файл, что заливало
- * контекст и дёргало компакцию каждые 15 итераций (наблюдено: 96 вызовов
- * read_file, 11 компакций за ~20 мин со сносом задачи). 300 строк покрывают
- * типичный файл за один вызов, вывод всё равно ограничен.
- */
-const DEFAULT_LIMIT = 300;
-/** Жёсткий потолок явного `limit` (тул исключён из усечения по бюджету). */
-const MAX_READ_LIMIT = 2000;
-/**
- * Файлы крупнее — через ограниченный стриминг вместо readFileSync (который
- * грузит весь файл в память ради пары сотен строк).
- */
-const LARGE_FILE_BYTES = 1024 * 1024;
-const STREAM_CHUNK = 256 * 1024;
-/**
- * Ограниченное построчное чтение больших файлов: стримит чанками, собирает
- * только окно [offset, offset+limit), остаток переводов строк считает сырым
- * (без декода) для total. Память ограничена при любом размере файла.
- */
-function readLineSlice(path, offset, limit) {
-    const fd = openSync(path, "r");
-    try {
-        const buf = Buffer.alloc(STREAM_CHUNK);
-        let pos = 0;
-        let carry = "";
-        let lineNumber = 1;
-        let total = 0;
-        const collected = [];
-        const endLine = offset + limit; // exclusive
-        while (true) {
-            const bytes = readSync(fd, buf, 0, STREAM_CHUNK, pos);
-            if (bytes === 0)
-                break;
-            pos += bytes;
-            const chunk = carry + buf.toString("utf-8", 0, bytes);
-            const parts = chunk.split("\n");
-            carry = parts.pop() ?? "";
-            for (const line of parts) {
-                total++;
-                if (lineNumber >= offset && lineNumber < endLine)
-                    collected.push(line);
-                lineNumber++;
-            }
-            if (lineNumber >= endLine && collected.length >= limit) {
-                // Окно собрано — остаток переводов строк считаем без декодирования.
-                const rest = [];
-                while (true) {
-                    const n = readSync(fd, buf, 0, STREAM_CHUNK, pos);
-                    if (n === 0)
-                        break;
-                    pos += n;
-                    rest.push(Buffer.from(buf.subarray(0, n)));
-                }
-                const tail = Buffer.concat([...rest, Buffer.from(carry, "utf-8")]);
-                for (let i = 0; i < tail.length; i++)
-                    if (tail[i] === 0x0a)
-                        total++;
-                // Плюс финальная строка без перевода — только если файл им не
-                // кончается, иначе посчитаем фантомную пустую строку.
-                if (tail.length > 0 && tail[tail.length - 1] !== 0x0a)
-                    total++;
-                return { selected: collected.join("\n"), total };
-            }
-        }
-        if (carry.length > 0 || total === 0) {
-            total++;
-            if (lineNumber >= offset && lineNumber < endLine)
-                collected.push(carry);
-        }
-        return { selected: collected.join("\n"), total };
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-/** Читает файл постранично (offset/limit); кешируемый, с cap вывода. */
-export const readFileTool = {
-    name: "read_file",
-    icon: "👀",
-    description: `Read a file from the filesystem. Reads up to ${DEFAULT_LIMIT} lines at a time by default; use offset to page through large files.`,
-    tags: ["file", "code"],
-    boundedOutput: true,
-    cacheable: true,
-    parameters: {
-        type: "object",
-        properties: {
-            path: { type: "string", description: "File path to read" },
-            offset: {
-                type: "number",
-                description: `Starting line (1-indexed). Use offset=<next> from a truncated result to continue reading.`,
-            },
-            limit: {
-                type: "number",
-                description: `Number of lines to read (default ${DEFAULT_LIMIT})`,
-            },
-        },
-        required: ["path"],
-    },
-    handler: async (ctx, args) => {
-        const path = String(args.path);
-        const resolved = safeResolvePath(ctx.baseDir, path);
-        const securityPaths = ctx.config?.security?.paths || DEFAULT_SECURITY_CONFIG.paths;
-        const scopeCheck = isPathInScope(ctx.baseDir, resolved, ctx.scope, securityPaths);
-        if (!scopeCheck.allowed) {
-            logSecurityBlock(ctx.sessionId || undefined, "file_read", scopeCheck.reason || "Path not allowed", path);
-            return {
-                success: false,
-                output: t("file.path_not_allowed", {
-                    path: `${path} — ${scopeCheck.reason}`,
-                }),
-            };
-        }
-        if (!existsSync(resolved)) {
-            // Для относительных путей показываем, КУДА резолвилось: голое
-            // "not found" не даёт модели отличить baseDir от cwd.
-            const output = resolved !== path
-                ? t("file.notfound_resolved", {
-                    path,
-                    resolved,
-                })
-                : t("file.notfound", { path });
-            return { success: false, output };
-        }
-        // Кламп обоих: `offset: 0` давал slice(-1, end) с ПОСЛЕДНЕЙ строкой, а
-        // безграничный `limit` (тул вне усечения по бюджету) тянул бы целый
-        // большой файл в контекст.
-        const offset = Math.max(1, typeof args.offset === "number" ? Math.floor(args.offset) : 1);
-        const limit = Math.min(MAX_READ_LIMIT, Math.max(1, typeof args.limit === "number" ? Math.floor(args.limit) : DEFAULT_LIMIT));
-        let lines;
-        let total;
-        let selected;
-        try {
-            if (statSync(resolved).size > LARGE_FILE_BYTES) {
-                const slice = readLineSlice(resolved, offset, limit);
-                total = slice.total;
-                selected = slice.selected;
-            }
-            else {
-                const content = readFileSync(resolved, "utf-8");
-                lines = content.split("\n");
-                // Файл с финальным переводом даёт фантомный пустой элемент — снять,
-                // чтобы счёт строк совпал со стриминг-путем.
-                if (lines.length > 1 && lines[lines.length - 1] === "")
-                    lines.pop();
-                total = lines.length;
-                const end = Math.min(offset - 1 + limit, total);
-                selected = lines.slice(offset - 1, end).join("\n");
-            }
-        }
-        catch (err) {
-            // Файл мог исчезнуть между existsSync и чтением (TOCTOU) или оказаться
-            // директорией — возвращаем понятную ошибку, а не голый throw.
-            return {
-                success: false,
-                output: t("file.read_failed", { path, error: errMsg(err) }),
-            };
-        }
-        const end = Math.min(offset - 1 + limit, total);
-        const ext = extname(resolved) || "(no extension)";
-        const header = t("file.read_header", {
-            path,
-            ext,
-            total: String(total),
-            from: String(offset),
-            to: String(end),
-        });
-        const truncated = end < total
-            ? t("file.read_truncated", {
-                remaining: String(total - end),
-                next: String(end + 1),
-            })
-            : "";
-        // Компактный display: заголовок уже показывает путь, доп. инфо (диапазон)
-        // нужна только частичному чтению. Полное чтение — пусто, карточка в 2 строки.
-        const fullRead = offset === 1 && end >= total;
-        const display = fullRead
-            ? ""
-            : t("file.read_range", {
-                from: String(offset),
-                to: String(end),
-                total: String(total),
-            });
-        return {
-            success: true,
-            output: `${header}\n${selected}${truncated}`,
-            display,
-        };
-    },
-};

package/dist/tools/recall.js

@@ -1,124 +0,0 @@
-/** Тул чтения межсессионной памяти (поиск, категории, всё целиком). */
-import { t } from "../i18n/index";
-import { MemoryStore } from "../modules/memory/store";
-import { globalMemoryDir } from "../config/paths";
-/** Категории памяти. */
-const CATEGORIES = ["preferences", "conventions", "decisions", "errors", "facts"];
-/** Читает/ищет по памяти. Параметры: query (full-text), category (опционально). */
-export const recallTool = {
-    name: "recall",
-    icon: "💾",
-    description: "Recall stored information from memory. Search across preferences, facts, conventions, decisions, errors.",
-    tags: ["memory"],
-    parameters: {
-        type: "object",
-        properties: {
-            query: {
-                type: "string",
-                description: "Search query (full-text search across all memory)",
-            },
-            category: {
-                type: "string",
-                description: "Limit to specific category: preferences, conventions, decisions, errors, facts",
-                enum: CATEGORIES,
-            },
-        },
-    },
-    handler: async (_ctx, args) => {
-        const query = args.query ? String(args.query) : "";
-        const category = args.category ? String(args.category) : "";
-        const memoryDir = globalMemoryDir();
-        const store = new MemoryStore(memoryDir);
-        try {
-            // Без запроса и категории — показать всё.
-            if (!query && !category) {
-                return { success: true, output: formatAll(store) };
-            }
-            // Только категория — показать её.
-            if (!query && category) {
-                return { success: true, output: formatCategory(store, category) };
-            }
-            // Запрос с опциональной категорией — поиск.
-            if (category) {
-                const results = searchCategory(store, category, query);
-                if (results.length === 0) {
-                    return { success: true, output: t("tool.recall.empty", { query }) };
-                }
-                return {
-                    success: true,
-                    output: t("tool.recall.search_results", { category, results: results.join("\n") }),
-                };
-            }
-            // Запрос по всем категориям.
-            const results = store.search(query);
-            if (results.length === 0) {
-                return { success: true, output: t("tool.recall.empty", { query }) };
-            }
-            const formatted = results.map((r) => `[${r.file}] ${r.match}`).join("\n");
-            return {
-                success: true,
-                output: t("tool.recall.search_results", { category: "all", results: formatted }),
-            };
-        }
-        catch (err) {
-            // Чтение отсутствующей/битой категории — ошибка, а не пустой успех.
-            return { success: false, output: t("tool.memory_error", { error: String(err) }) };
-        }
-    },
-};
-/** Форматирует всю память (преференсы + последние 5 записей категорий). */
-function formatAll(store) {
-    const parts = [];
-    const prefs = store.getPreferences();
-    if (Object.keys(prefs).length > 0) {
-        parts.push("Preferences:");
-        for (const [k, v] of Object.entries(prefs)) {
-            parts.push(`  ${k} = ${v}`);
-        }
-    }
-    for (const cat of ["facts", "conventions", "decisions", "errors"]) {
-        const content = store.read(cat);
-        const entries = content.split("\n").filter((l) => l.startsWith("- "));
-        if (entries.length > 0) {
-            parts.push(`\n${cat.charAt(0).toUpperCase() + cat.slice(1)} (last 5):`);
-            for (const e of entries.slice(-5)) {
-                parts.push(`  ${e}`);
-            }
-        }
-    }
-    return parts.length > 0 ? parts.join("\n") : t("tool.recall.no_memory");
-}
-/** Форматирует одну категорию. */
-function formatCategory(store, category) {
-    if (category === "preferences") {
-        const prefs = store.getPreferences();
-        if (Object.keys(prefs).length === 0)
-            return t("tool.recall.no_memory");
-        const lines = ["Preferences:"];
-        for (const [k, v] of Object.entries(prefs)) {
-            lines.push(`  ${k} = ${v}`);
-        }
-        return lines.join("\n");
-    }
-    const content = store.read(category);
-    const entries = content.split("\n").filter((l) => l.startsWith("- "));
-    if (entries.length === 0)
-        return t("tool.recall.no_memory");
-    return `${category.charAt(0).toUpperCase() + category.slice(1)} (${entries.length} entries):\n${entries.join("\n")}`;
-}
-/** Ищет запрос внутри категории (регистронезависимо). */
-function searchCategory(store, category, query) {
-    if (category === "preferences") {
-        const prefs = store.getPreferences();
-        const lower = query.toLowerCase();
-        return Object.entries(prefs)
-            .filter(([k, v]) => k.toLowerCase().includes(lower) || v.toLowerCase().includes(lower))
-            .map(([k, v]) => `  ${k} = ${v}`);
-    }
-    const content = store.read(category);
-    const lower = query.toLowerCase();
-    return content
-        .split("\n")
-        .filter((l) => l.startsWith("- ") && l.toLowerCase().includes(lower))
-        .map((l) => `  ${l}`);
-}

package/dist/tools/registry.js

@@ -1,48 +0,0 @@
-export class ToolRegistry {
-    tools = new Map();
-    register(tool) {
-        if (this.tools.has(tool.name)) {
-            throw new Error(`Tool already registered: ${tool.name}`);
-        }
-        this.tools.set(tool.name, tool);
-    }
-    get(name) {
-        return this.tools.get(name);
-    }
-    has(name) {
-        return this.tools.has(name);
-    }
-    /** Тулы по именам (отсортированы). */
-    list() {
-        return Array.from(this.tools.keys()).sort();
-    }
-    /** Все зарегистрированные определения. */
-    getAll() {
-        return Array.from(this.tools.values());
-    }
-    /** Подмножество с любым из тегов (без alwaysOn). */
-    getByTags(tags) {
-        return this.getAll().filter((t) => {
-            if (!t.tags || t.tags.length === 0)
-                return false;
-            return tags.some((tag) => t.tags.includes(tag));
-        });
-    }
-    /**
-     * Тулы для LLM: всегда `alwaysOn`, плюс совпавшие по тегам. Без тегов —
-     * все (backward-compatible). Дубликаты исключены объединением по имени.
-     */
-    getAllForLLM(tags) {
-        const all = this.getAll();
-        const tagSet = new Set(tags ?? []);
-        const selected = tagSet.size === 0
-            ? all
-            : all.filter((t) => t.alwaysOn || (t.tags?.some((tag) => tagSet.has(tag))));
-        return selected.map((t) => ({
-            name: t.name,
-            description: t.description,
-            parameters: t.parameters,
-            boundedOutput: t.boundedOutput,
-        }));
-    }
-}