micro-models-agent 2.10.0 → 2.12.0

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

@@ -1,5 +1,6 @@
+/** Утилиты вывода тулов: лимиты, усечение, сводки ошибок. */
 import { t } from "../../i18n/index";
-import { TOOL_RESULT_MAX_TOKENS_RATIO, TOOL_RESULT_ABSOLUTE_MAX_CHARS, TOOL_ARGS_SUMMARY_MAX_CHARS, } from "./constants";
+import { TOOL_RESULT_MAX_TOKENS_RATIO, TOOL_RESULT_ABSOLUTE_MAX_CHARS, TOOL_ARGS_SUMMARY_MAX_CHARS, TOOL_ARG_VALUE_MAX_CHARS, } from "./constants";
 /**
  * Макс. число символов результата тула при заданном остатке бюджета и
  * признаке того, что тул сам ограничивает свой вывод.
@@ -22,27 +23,63 @@ export function truncateToolOutput(output, budget, currentTokens, bounded) {
         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) })}`;
+    return `${truncated}\n\n${t("tool.truncated", { tokens: Math.ceil(removedChars / 2) })}`;
 }
 /**
- * JSON-сериализация аргументов тула для <system-summary>, ограниченная по
- * размеру. Большой аргумент (content у write_file) не должен дублироваться в
- * сводке поверх role:"tool" сообщения, которое уже несёт результат.
+ * Компактная сигнатура аргументов тула для <system-summary>.
+ *
+ * Длинные строковые значения (content/new_string/text/…) сворачиваются до
+ * `…(N chars)`: их полный текст уже есть в assistant-сообщении с tool_calls
+ * и в role:"tool" результате, поэтому дублировать тело в сводке не нужно.
+ * Короткие скаляры (path/command/pattern/url) сохраняются как есть.
+ * Реализация не привязана к конкретным тулам — правило общее для любых args.
  */
 export function summarizeToolArgs(args) {
-    let s;
-    try {
-        s = JSON.stringify(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)})` : "";
     }
-    catch {
-        s = String(args);
+    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;
     }
-    if (!s || s === "{}")
+    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);
+}
 /**
  * Компактная пользовательская строка для упавшего тула.
  *
@@ -60,3 +97,20 @@ export function compactToolError(output, max = 200) {
     }
     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

@@ -0,0 +1,60 @@
+/** Заглушка результата для незавершённого вызова. */
+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;
+}

package/dist/core/agent-moe.js

@@ -4,12 +4,13 @@ import { MoEExecutor } from "../modules/execution/moe-executor";
 import { StepVerifier } from "../modules/execution/verifier";
 import { newAbortError } from "../modules/execution/moe-executor";
 import { t } from "../i18n/index";
+/** Дефолтный лимит циклов re-plan MoE. */
 export const DEFAULT_MOE_MAX_REPLAN_CYCLES = 3;
 /**
- * Execute the MoE (Mixture of Experts) path: plan → validate → execute → verify,
- * with a re-plan loop driven by the orchestrator's verifyAndMerge decision.
- * Returns a fallback signal when MoE cannot proceed so the caller can fall
- * back to the single-agent loop.
+ * Исполняет MoE-путь (Mixture of Experts): план → валидация → исполнение →
+ * верификация, с re-plan циклом по решению verifyAndMerge оркестратора.
+ * Возвращает сигнал фолбэка, когда MoE не может продолжить: вызывающий
+ * откатывается в одиночный цикл агента.
  */
 export async function runWithMoE(deps, input, fallback, opts = {}) {
     const { config, llmProvider, logger, toolExecutor, baseDir } = deps;
@@ -19,8 +20,8 @@ export async function runWithMoE(deps, input, fallback, opts = {}) {
         if (signal?.aborted)
             throw newAbortError();
     };
-    // Orchestration one-liners are machine-facing: emit them to the chat only
-    // when the user opted into verbose UI (config.ui.verbose).
+    // Однострочники оркестрации — machine-facing: в чат только при
+    // включённом verbose UI (config.ui.verbose).
     const verbose = config.ui?.verbose === true;
     const status = (message) => {
         if (verbose)
@@ -40,17 +41,17 @@ export async function runWithMoE(deps, input, fallback, opts = {}) {
         }, llmProvider, { getSessionId: () => sessionId });
     }
     if (!orchestrator.isEnabled()) {
-        // Visible at default log level: a user who enabled moe.enabled must be
-        // able to tell why MoE never kicked in (missing orchestrator.model).
-        logger.warn("MoE enabled but no orchestrator model configured — falling back to single-agent. Set orchestrator.model to activate MoE.");
+        // Видно на дефолтном лог-уровне: включивший moe.enabled должен понимать,
+        // почему MoE не стартовал (нет orchestrator.model).
+        logger.warn(t("moe.no_orchestrator"));
         return fallback();
     }
-    status("🤖 Planning with MoE mode...\n");
+    status(t("moe.planning"));
     onPhase?.("thinking");
     const planResult = await orchestrator.plan(input, undefined, signal);
     onPhase?.("done");
     if ("error" in planResult) {
-        logger.warn(`MoE plan failed: ${planResult.error} — falling back to single-agent`);
+        logger.warn(t("moe.plan_failed", { error: planResult.error }));
         emit("moe_plan", { status: "error", error: planResult.error });
         return fallback();
     }
@@ -66,30 +67,30 @@ export async function runWithMoE(deps, input, fallback, opts = {}) {
     for (let cycle = 1; cycle <= maxCycles; cycle++) {
         ensureNotAborted();
         if (cycle > 1) {
-            status(t("moe.replan_started", { cycle, max: maxCycles }) + "\n");
+            status(`${t("moe.replan_started", { cycle, max: maxCycles })}\n`);
             emit("moe_replan", {
                 cycle,
                 title: currentPlan.title,
                 subtaskIds: currentPlan.subtasks.map((s) => s.id),
             });
         }
-        // Validate every plan before executing it — never trust an LLM-produced
-        // plan, including re-plans produced by verifyAndMerge.
+        // Валидируем каждый план до исполнения — LLM-плану не доверяем никогда,
+        // включая re-plan от verifyAndMerge.
         const validation = validatePlan(currentPlan, config);
         if (!validation.valid) {
             const applied = applyAutoFixes(currentPlan, validation.autoFixes);
             const retry = validatePlan(applied, config);
             if (!retry.valid) {
-                logger.warn(`MoE plan validation failed: ${retry.errors.join("; ")}`);
+                logger.diagnostic("warn", `MoE plan validation failed: ${retry.errors.join("; ")}`);
                 if (cycle === 1) {
-                    status(`⚠️ Plan validation failed. Falling back to single-agent mode.\n`);
+                    status(t("moe.plan_fallback"));
                     return fallback();
                 }
                 return partialFailure(mergedResults, retry.errors.join("; "));
             }
             currentPlan = applied;
             if (validation.autoFixes.length > 0) {
-                status(`🔧 Auto-fixed ${validation.autoFixes.length} plan issues.\n`);
+                status(t("moe.plan_autofixed", { count: String(validation.autoFixes.length) }));
             }
         }
         const executor = deps.executorOverride ??
@@ -106,20 +107,20 @@ export async function runWithMoE(deps, input, fallback, opts = {}) {
                 onScopeRequest: async (subtaskId, req) => {
                     const decision = await orchestrator.resolveScopeRequest(subtaskId, req, signal);
                     if (decision.action === "approve") {
-                        status(t("moe.scope_approved", {
+                        status(`${t("moe.scope_approved", {
                             subtask: subtaskId,
                             files: [...decision.write, ...decision.read].join(", "),
-                        }) + "\n");
+                        })}\n`);
                     }
                     else {
-                        status(t("moe.scope_rejected", { subtask: subtaskId }) + "\n");
+                        status(`${t("moe.scope_rejected", { subtask: subtaskId })}\n`);
                     }
                     return decision;
                 },
             });
-        status(t("moe.executing", { count: String(currentPlan.subtasks.length), cycle: String(cycle) }) + "\n");
-        // Selective re-plan (Plan 5.1): subtasks already successfully executed in
-        // an earlier cycle are carried over — only failed/new ones re-execute.
+        status(`${t("moe.executing", { count: String(currentPlan.subtasks.length), cycle: String(cycle) })}\n`);
+        // Селективный re-plan (Plan 5.1): успешные сабтаски прошлого цикла
+        // переносятся — переисполняются только упавшие/новые.
         const skipIds = new Set();
         const carriedResults = [];
         for (const s of currentPlan.subtasks) {
@@ -198,7 +199,7 @@ export async function runWithMoE(deps, input, fallback, opts = {}) {
             return buildFinalResult(mergedResults, verification.success, verifyResult);
         }
         if (!verifyResult.plan || !Array.isArray(verifyResult.plan.subtasks)) {
-            // Verifier asked for a re-plan but produced none usable — stop honestly.
+            // Верификатор просил re-plan, но годного не дал — останавливаемся честно.
             return partialFailure(mergedResults, verifyResult.explanation || "re-plan requested but no plan returned");
         }
         currentPlan = verifyResult.plan;