micro-models-agent 2.16.1 → 2.17.2

package/dist/core/agent/tool-batch.js

@@ -1,312 +0,0 @@
-/** Исполнитель пакета тулов: жизненный цикл вызовов за итерацию. */
-import { pc } from "../../ui/colors";
-import { t } from "../../i18n/index";
-import { summarizeToolArgs, truncateToolOutput, toolFailureSummary, isExecutableScriptPath, } from "./tool-output";
-import { queueToolImages } from "./tool-images";
-import { errMsg } from "../../utils";
-import { MAX_CONSECUTIVE_TOOL_FAILURES, MIN_REPEATED_TOOL_FAILURES, MAX_CONSECUTIVE_FAILED_BATCHES, HARD_STOP_FAILED_BATCHES } from "./constants";
-/**
- * Выполнение пакета тулов, полученных от модели за одну итерацию.
- *
- * Отвечает за весь жизненный цикл тула:
- * - запись assistant-сообщения с tool_calls в контекст и session log;
- * - plugin-хуки (onToolCall, onToolStart, onToolEnd, onMeta);
- * - событий UI (onTool start/end), вывод display/diff;
- * - усечение результата под бюджет и запись role:"tool" сообщения;
- * - синтез "[interrupted]" результатов для тулов без ответа (иначе
- *   OpenAI-совместимые бэкенды отклоняют историю HTTP 400);
- * - учёт неудач (последовательные + общие по тулам) и запись правил в память;
- * - инъекцию <system-summary> с результатами и статусом плана.
- *
- * Не знает о структуре цикла — возвращает флаг `interrupted`, решение о
- * `break`/`continue` принимает вызывающий цикл.
- */
-export class ToolBatchExecutor {
-    deps;
-    constructor(deps) {
-        this.deps = deps;
-    }
-    /**
-     * Выполняет пакет tool_calls одной итерации (контекст, UI, учёт неудач).
-     * @param state состояние цикла; @param toolCalls вызовы от модели;
-     * @param boundedToolNames тулы с собственным лимитом вывода;
-     * @param textContent/reasoningContent/input тексты хода;
-     * @returns флаг прерывания по shutdown.
-     */
-    async execute(state, toolCalls, boundedToolNames, textContent, reasoningContent, input, onTool, onMeta, slog) {
-        const { config, pluginManager, contextManager, logger } = this.deps;
-        const iteration = state.iteration;
-        slog?.logAssistant(textContent || "", reasoningContent, toolCalls, iteration);
-        contextManager.addMessage({
-            role: "assistant",
-            content: textContent || "",
-            tool_calls: toolCalls.map((tc) => ({
-                id: tc.id,
-                type: "function",
-                function: {
-                    name: tc.name,
-                    arguments: JSON.stringify(tc.arguments),
-                },
-            })),
-        });
-        const answeredToolCallIds = new Set();
-        // OpenAI-совместимые бэкенды (Jinja-шаблоны llama.cpp) отклоняют HTTP 400
-        // любую историю, где assistant(tool_calls) не завершён role:"tool"
-        // результатами для каждого call id — прерывание на середине пакета не
-        // должно оставлять висящую пару.
-        const synthesizePendingToolResults = () => {
-            for (const call of toolCalls) {
-                if (answeredToolCallIds.has(call.id))
-                    continue;
-                logger.debug(`Interrupted before tool ${call.name} (${call.id}) returned a result — synthesizing tool message`);
-                contextManager.addMessage({
-                    role: "tool",
-                    content: "[interrupted]",
-                    name: call.name,
-                    tool_call_id: call.id,
-                    success: false,
-                    arguments: call.arguments,
-                });
-            }
-        };
-        const summaries = [];
-        let anyToolFailed = false;
-        let batchHasSuccess = false;
-        // Информационные read-only тулы, чей "фейл" — ожидаемое поведение
-        // (file_info "Not found" после delete_file) — исключены из учёта неудач.
-        const infoTools = new Set(["file_info"]);
-        // Флаг блока безопасности действует в пределах текущего пакета вызовов:
-        // иначе старый блок влиял бы на nudge через десятки итераций.
-        state.sawSecurityBlock = false;
-        for (const call of toolCalls) {
-            this.deps.setScope();
-            const startTime = Date.now();
-            pluginManager.runOnToolCall({
-                toolName: call.name,
-                args: call.arguments,
-            });
-            pluginManager.runOnToolStart({ iteration, logger, contextManager }, { id: call.id, name: call.name, arguments: call.arguments });
-            const toolIcon = this.deps.toolExecutor.getRegistry().get(call.name)?.icon;
-            onTool?.({ type: "start", tool: call.name, args: call.arguments, icon: toolIcon });
-            slog?.logToolCall(call, iteration);
-            const tokensBeforeTool = contextManager.getEstimatedTokens();
-            // Снимок стоимости ДО тула: рендеру нужна стоимость именно этого вызова
-            // (subagent/mcp/pipeline тратят токены), а не накопленная за сессию.
-            const costBeforeTool = this.deps.costTracker.total;
-            let result;
-            try {
-                result = await this.deps.toolExecutor.execute(call, this.deps.getAbortSignal());
-            }
-            catch (err) {
-                // Abort во время тула должен распространяться, чтобы сессия завершилась
-                // чисто. Любой ДРУГОЙ throw (баг тула/плагина, сбежавший из executor)
-                // не должен убивать сессию — деградируем до failed-результата.
-                if (err instanceof Error && err.name === "AbortError") {
-                    synthesizePendingToolResults();
-                    throw err;
-                }
-                logger.diagnostic("warn", `Tool ${call.name} threw: ${errMsg(err)}`);
-                result = {
-                    success: false,
-                    output: `${t("error.prefix")}${errMsg(err)}`,
-                    toolCallId: call.id,
-                };
-            }
-            // Прерывание во время тула: сессия уже завершается, останавливаемся
-            // сразу — без рендера, логов и обновления контекста для результата,
-            // который никто не увидит.
-            if (this.deps.isShutdownRequested())
-                break;
-            const duration = Date.now() - startTime;
-            if (!result.success && !result.blocked && !infoTools.has(call.name))
-                anyToolFailed = true;
-            if (result.success)
-                batchHasSuccess = true;
-            if (result.success && call.name === "plan") {
-                const action = String(call.arguments.action ?? "");
-                if (action === "create" || action === "re-plan")
-                    state.iterPlanCreated = true;
-            }
-            if (result.success && call.arguments.path) {
-                const filePath = String(call.arguments.path);
-                if (call.name === "write_file" || call.name === "edit_file") {
-                    this.deps.hallucinationDetector.getConsistencyCheck().trackCreatedFile(filePath);
-                }
-                else if (call.name === "delete_file") {
-                    this.deps.hallucinationDetector.getConsistencyCheck().trackDeletedFile(filePath);
-                }
-            }
-            pluginManager.runOnToolEnd({ iteration, logger, contextManager }, { id: call.id, name: call.name, arguments: call.arguments }, result, duration);
-            // Проверка наличия, а не истинности: read_file возвращает display ""
-            // на полном чтении (заголовок уже показывает путь) — фолбэк на пустую
-            // строку вывалил бы всё содержимое файла в REPL.
-            // kind="tool": тела тулов model-facing, в quiet-чатах скрываются
-            // (статусы контекста/компакции идут с kind по умолчанию и всегда видны).
-            const TOOL_META = "tool";
-            if (result.display !== undefined) {
-                if (result.display.length > 0) {
-                    onMeta?.(`\n${result.display}\n`, TOOL_META);
-                }
-            }
-            else if (result.success) {
-                const metaOut = pluginManager.runOnMeta({ iteration, logger, contextManager }, result.output);
-                onMeta?.(`\n${pc.dim(metaOut)}\n`, TOOL_META);
-            }
-            else {
-                // Упавший тул: `output` — model-facing (хинты, recovery-директивы,
-                // «Do NOT …»). Пользователю нужна спокойная суть — первая строка,
-                // а не инструкции для агента. Мягкие гарды — варнинги, не ошибки.
-                const failure = toolFailureSummary(result.output);
-                const metaOut = failure.text
-                    ? pluginManager.runOnMeta({ iteration, logger, contextManager }, failure.text)
-                    : "";
-                if (metaOut) {
-                    const color = failure.severity === "warn" ? pc.yellow : pc.red;
-                    const glyph = failure.severity === "warn" ? "⚠" : "✗";
-                    onMeta?.(`\n${color(`${glyph} ${metaOut}`)}\n`, TOOL_META);
-                }
-            }
-            if (result.diff) {
-                onMeta?.(`\n${result.diff}\n`, TOOL_META);
-            }
-            const currentTokens = contextManager.getEstimatedTokens();
-            const budget = contextManager.getBudget();
-            const truncatedOutput = truncateToolOutput(result.output, budget, currentTokens, boundedToolNames.has(call.name));
-            contextManager.addMessage({
-                role: "tool",
-                content: truncatedOutput,
-                name: call.name,
-                tool_call_id: call.id,
-                success: result.success,
-                blocked: result.blocked,
-                arguments: call.arguments,
-            });
-            answeredToolCallIds.add(call.id);
-            // Изображения тула (browser screenshot и т.п.) встают в очередь и
-            // прицепятся к следующему user-сообщению — обычно к <system-summary>
-            // в конце этого же batch'а. В role:"tool" строку base64 не пишем.
-            queueToolImages(contextManager, result.images);
-            const tokensAfterTool = contextManager.getEstimatedTokens();
-            const costAfterTool = this.deps.costTracker.total;
-            onTool?.({
-                type: "end",
-                tool: call.name,
-                args: call.arguments,
-                duration,
-                error: !result.success,
-                output: typeof result.output === "string" ? result.output : undefined,
-                ctxDelta: tokensAfterTool - tokensBeforeTool,
-                costUsd: costBeforeTool !== undefined && costAfterTool !== undefined
-                    ? costAfterTool - costBeforeTool
-                    : undefined,
-            });
-            summaries.push(`[Tool: ${call.name}${summarizeToolArgs(call.arguments)} → ${truncatedOutput.slice(0, 200)}]`);
-            // Видели блок безопасности? Запоминаем для эвристики скрипта-обёртки.
-            if (typeof result.output === "string" && result.output.includes("[SECURITY BLOCKED]")) {
-                state.sawSecurityBlock = true;
-            }
-            // Скрипт-обход: после блока безопасности запись shell-скрипта
-            // (.bat/.cmd/.sh/.ps1) почти всегда — попытка обойти заблокированный
-            // оператор; nudge один раз, обобщённо (без привязки к тулу/языку).
-            if (state.sawSecurityBlock &&
-                !state.scriptWorkaroundNudged &&
-                call.name === "write_file" &&
-                typeof call.arguments.path === "string" &&
-                isExecutableScriptPath(call.arguments.path)) {
-                state.scriptWorkaroundNudged = true;
-                summaries.push(t("exec.script_workaround_nudge"));
-            }
-            if (config.session.autoSave) {
-                slog?.logToolResult(call, result, duration, iteration);
-            }
-            this.deps.compactionService.compactAfterTool(state);
-            // Учёт общих неудач (НЕ только подряд идущих): тул, который стабильно
-            // падает между успехами других тулов, всё равно учится (наблюдалось:
-            // LSP spawn npx ENOENT упал 8x за сессию, ни разу подряд — и не дошёл
-            // до памяти по пути "5 подряд неудач").
-            if (!result.success && !result.blocked && !infoTools.has(call.name)) {
-                const key = call.name;
-                const prev = state.toolFailureCounts.get(key) ?? { count: 0, error: "" };
-                prev.count++;
-                prev.error = String(result.output ?? "").slice(0, 200);
-                state.toolFailureCounts.set(key, prev);
-                if (prev.count >= MIN_REPEATED_TOOL_FAILURES && !state.memoryRuleRecorded.has(key)) {
-                    state.memoryRuleRecorded.add(key);
-                    const memStore = this.deps.memoryStore;
-                    if (memStore) {
-                        memStore.appendRule("errors", `Tool ${key} failed ${prev.count}x (${prev.error})`, `Repeated ${key} failures suggest a systemic problem (config, environment, or a broken tool), not a one-off`, "Check the error message, verify the tool's dependencies are installed/configured, and consider a different tool");
-                        logger.diagnostic("warn", `Recorded repeated ${key} failures to memory (${prev.count}x)`);
-                    }
-                }
-            }
-        }
-        if (this.deps.isShutdownRequested()) {
-            synthesizePendingToolResults();
-            return { interrupted: true };
-        }
-        // Последовательные неудачи: recovery-сообщение + правило в память.
-        if (anyToolFailed) {
-            state.consecutiveToolFailures++;
-            state.consecutiveToolSuccesses = 0;
-        }
-        else {
-            state.consecutiveToolFailures = 0;
-            state.consecutiveToolSuccesses++;
-        }
-        if (state.consecutiveToolFailures >= MAX_CONSECUTIVE_TOOL_FAILURES) {
-            const recoveryMsg = t("exec.consecutive_failures_recovery", {
-                count: state.consecutiveToolFailures,
-            });
-            logger.diagnostic("warn", `Consecutive tool failures: ${state.consecutiveToolFailures}`);
-            const taskSnippet = input.length > 200 ? `${input.slice(0, 200)}...` : input;
-            const taskReminder = t("exec.task_reminder", { task: taskSnippet });
-            contextManager.addMessage({
-                role: "user",
-                content: `<system-summary>${recoveryMsg}\n${taskReminder}</system-summary>`,
-            });
-            const memStore = this.deps.memoryStore;
-            if (memStore) {
-                memStore.appendRule("errors", `${state.consecutiveToolFailures} consecutive tool failures`, "Multiple tools failing suggests environment or configuration issue", "Check dependencies, verify file paths, try write_file directly instead of shell commands");
-            }
-        }
-        // Honest-stop полностью провальных пакетов: каждый вызов пакета — неудача
-        // или tool-level блок (в отличие от consecutiveToolFailures выше, блоки
-        // ВХОДЯТ в учёт — перебор вариантов заблокированной команды это та же
-        // петля). Смешанные пакеты и успехи сбрасывают стрик: связка
-        // «упал → поправил → упал» (дебаг) под него не попадает.
-        // Plugin-level блоки (result.blocked, guard-rails) нейтральны по контракту
-        // ToolResult.blocked — не успех и не неудача.
-        if (anyToolFailed && !batchHasSuccess) {
-            state.consecutiveFailedBatches++;
-        }
-        else if (batchHasSuccess) {
-            state.consecutiveFailedBatches = 0;
-            state.honestStopNudged = false;
-        }
-        if (state.consecutiveFailedBatches >= MAX_CONSECUTIVE_FAILED_BATCHES &&
-            !state.honestStopNudged) {
-            state.honestStopNudged = true;
-            logger.diagnostic("warn", `Consecutive failed tool batches: ${state.consecutiveFailedBatches} — honest-stop directive`);
-            contextManager.addMessage({
-                role: "user",
-                content: `<system-summary>${t("exec.honest_stop", { count: state.consecutiveFailedBatches })}</system-summary>`,
-            });
-        }
-        if (state.consecutiveFailedBatches >= HARD_STOP_FAILED_BATCHES) {
-            state.retryLoopStopped = true;
-            logger.diagnostic("warn", `Retry loop hard-stopped after ${state.consecutiveFailedBatches} consecutive failed batches`);
-            return { interrupted: true };
-        }
-        // Статусная строка плана после каждого пакета тулов. Заменяет динамический
-        // plan-блок, который жил в system prompt (удалён ради KV-cache — план
-        // меняется каждую итерацию).
-        const planLine = this.deps.planSummary?.();
-        if (planLine)
-            summaries.push(planLine);
-        contextManager.addMessage({
-            role: "user",
-            content: `<system-summary>${summaries.join("\n")}</system-summary>`,
-        });
-        return { interrupted: false };
-    }
-}

package/dist/core/agent/tool-images.js

@@ -1,18 +0,0 @@
-/**
- * Ставит изображения, произведённые тулом, в очередь pending-изображений
- * контекста. Они прикрепятся к следующему user-сообщению (обычно это
- * `<system-summary>` с итогами пакета тулов в конце batch'а) — так картинка
- * доходит до модели как валидный image-part, а не как base64-текст в
- * `role:"tool"` (который и не портируем, и усекается бюджетом).
- *
- * Намеренно не складывает изображения в промежуточные tool-сообщения:
- * вставка user-сообщения между результатами одного assistant(tool_calls)
- * нарушает порядок, требуемый Jinja-шаблонами (см. architecture.md).
- */
-export function queueToolImages(sink, images) {
-    if (!sink || !images || images.length === 0)
-        return;
-    for (const image of images) {
-        sink.addPendingImage(image);
-    }
-}

package/dist/core/agent/tool-output.js

@@ -1,116 +0,0 @@
-/** Утилиты вывода тулов: лимиты, усечение, сводки ошибок. */
-import { t } from "../../i18n/index";
-import { TOOL_RESULT_MAX_TOKENS_RATIO, TOOL_RESULT_ABSOLUTE_MAX_CHARS, TOOL_ARGS_SUMMARY_MAX_CHARS, TOOL_ARG_VALUE_MAX_CHARS, } from "./constants";
-/**
- * Макс. число символов результата тула при заданном остатке бюджета и
- * признаке того, что тул сам ограничивает свой вывод.
- *
- * Тулы с `boundedOutput` (например, read_file с лимитом строк) НИКОГДА не
- * усекаются бюджетом — почти полный контекст раньше резал их до ~2K символов,
- * и модель верила, что файлы обрезаны, перечитывая их бесконечно.
- */
-export function toolOutputCharLimit(remainingBudget, historyBudget, bounded) {
-    if (bounded)
-        return Number.MAX_SAFE_INTEGER;
-    const maxCharsByRatio = Math.floor(historyBudget * TOOL_RESULT_MAX_TOKENS_RATIO * 2);
-    return Math.min(remainingBudget, maxCharsByRatio, TOOL_RESULT_ABSOLUTE_MAX_CHARS);
-}
-/** Усечение вывода тула под бюджет с честной пометкой о потере. */
-export function truncateToolOutput(output, budget, currentTokens, bounded) {
-    const remainingBudget = Math.max(0, budget.history - currentTokens);
-    const maxChars = toolOutputCharLimit(remainingBudget, budget.history, bounded);
-    if (output.length <= maxChars)
-        return output;
-    const truncated = output.slice(0, maxChars);
-    const removedChars = output.length - maxChars;
-    return `${truncated}\n\n${t("tool.truncated", { tokens: Math.ceil(removedChars / 2) })}`;
-}
-/**
- * Компактная сигнатура аргументов тула для <system-summary>.
- *
- * Длинные строковые значения (content/new_string/text/…) сворачиваются до
- * `…(N chars)`: их полный текст уже есть в assistant-сообщении с tool_calls
- * и в role:"tool" результате, поэтому дублировать тело в сводке не нужно.
- * Короткие скаляры (path/command/pattern/url) сохраняются как есть.
- * Реализация не привязана к конкретным тулам — правило общее для любых args.
- */
-export function summarizeToolArgs(args) {
-    if (args === undefined || args === null)
-        return "";
-    if (typeof args !== "object") {
-        const s = String(args);
-        return s ? ` (${s.slice(0, TOOL_ARGS_SUMMARY_MAX_CHARS)})` : "";
-    }
-    const parts = [];
-    for (const [key, value] of Object.entries(args)) {
-        let rendered;
-        if (typeof value === "string") {
-            rendered =
-                value.length > TOOL_ARG_VALUE_MAX_CHARS
-                    ? `${key}:…(${value.length} chars)`
-                    : `${key}:${value}`;
-        }
-        else {
-            let json;
-            try {
-                json = JSON.stringify(value);
-            }
-            catch {
-                json = String(value);
-            }
-            rendered =
-                json && json.length > TOOL_ARG_VALUE_MAX_CHARS ? `${key}:…` : `${key}:${json}`;
-        }
-        parts.push(rendered);
-        if (parts.join(", ").length > TOOL_ARGS_SUMMARY_MAX_CHARS)
-            break;
-    }
-    const s = parts.join(", ");
-    if (!s)
-        return "";
-    if (s.length <= TOOL_ARGS_SUMMARY_MAX_CHARS)
-        return ` (${s})`;
-    return ` (${s.slice(0, TOOL_ARGS_SUMMARY_MAX_CHARS)}…(${s.length} chars total))`;
-}
-/**
- * Является ли путь исполняемым shell-скриптом (обёрткой). Обобщённо, без
- * привязки к языку проекта: используется, чтобы заметить попытку обойти
- * security-блокировку через свежесозданный скрипт.
- */
-export function isExecutableScriptPath(filePath) {
-    return /\.[a-z0-9]+$/i.test(filePath) && /\.(bat|cmd|sh|bash|ps1|zsh|fish)$/i.test(filePath);
-}
-/**
- * Компактная пользовательская строка для упавшего тула.
- *
- * Полный `result.output` — это model-facing текст: хвост с Hint / recovery /
- * "Do NOT …" инструкциями. В чат он попадать не должен: пользователю нужна
- * суть ошибки (первая непустая строка), обрезанная по длине.
- */
-export function compactToolError(output, max = 200) {
-    const text = String(output ?? "");
-    for (const line of text.split("\n")) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            continue;
-        return trimmed.length > max ? `${trimmed.slice(0, max - 1)}…` : trimmed;
-    }
-    return "";
-}
-/**
- * Превращает model-facing падение тула в спокойную локализованную сводку.
- *
- * Отказы security/protected-path — мягкие гарды (агент должен спросить
- * пользователя), поэтому рисуются варнингом, а сырые маркеры
- * `[SECURITY BLOCKED]` / `[PROTECTED PATH]` в чат не попадают.
- */
-export function toolFailureSummary(output, max = 200) {
-    const text = String(output ?? "");
-    if (text.includes("[SECURITY BLOCKED]")) {
-        return { text: t("tool.ui.security_blocked"), severity: "warn" };
-    }
-    if (text.includes("[PROTECTED PATH]")) {
-        return { text: t("tool.ui.protected_path"), severity: "warn" };
-    }
-    return { text: compactToolError(text, max), severity: "error" };
-}

package/dist/core/agent/tool-pairing.js

@@ -1,60 +0,0 @@
-/** Заглушка результата для незавершённого вызова. */
-export const UNRESOLVED_TOOL_RESULT = "[Result unavailable]";
-/**
- * Приводит историю к валидному позиционному спариванию `assistant(tool_calls)`
- * → непрерывный `tool`-блок. Не мутирует входные сообщения (кроме безопасного
- * клонирования при merge) — возвращает новый массив.
- * @param messages активная история; @returns нормализованная копия.
- */
-export function repairToolCallPairing(messages) {
-    const out = [];
-    let pending = [];
-    // Закрывает незавершённые вызовы стабами, сохраняя их порядок.
-    const closePending = () => {
-        for (const call of pending) {
-            out.push({
-                role: "tool",
-                name: call.name,
-                content: UNRESOLVED_TOOL_RESULT,
-                tool_call_id: call.id,
-                success: false,
-                blocked: true,
-            });
-        }
-        pending = [];
-    };
-    for (const msg of messages) {
-        if (msg.role === "assistant" && msg.tool_calls?.length) {
-            const last = out[out.length - 1];
-            if (last?.role === "assistant" && last.tool_calls?.length) {
-                // Подряд идущие assistant(tool_calls) — слить в один ход: провайдер
-                // видит второй assistant до ответов на первый и тоже падает.
-                const merged = {
-                    ...last,
-                    tool_calls: [...last.tool_calls, ...msg.tool_calls],
-                };
-                out[out.length - 1] = merged;
-                pending = merged.tool_calls.map((tc) => ({ id: tc.id, name: tc.function.name }));
-                continue;
-            }
-            closePending();
-            out.push(msg);
-            pending = msg.tool_calls.map((tc) => ({ id: tc.id, name: tc.function.name }));
-            continue;
-        }
-        if (msg.role === "tool" && msg.tool_call_id) {
-            if (pending.some((c) => c.id === msg.tool_call_id)) {
-                out.push(msg);
-                pending = pending.filter((c) => c.id !== msg.tool_call_id);
-            }
-            // Осиротевший tool (нет объявленного вызова) — отбросить.
-            continue;
-        }
-        // Любая другая роль (user/system/assistant без tool_calls) разрывает блок:
-        // незавершённые вызовы закрываем ПЕРЕД ней.
-        closePending();
-        out.push(msg);
-    }
-    closePending();
-    return out;
-}