micro-models-agent 0.63.0 → 1.1.0

package/dist/llm/orchestrator.js

@@ -1,15 +1,8 @@
-import { createProvider } from "../modules/providers/create";
+import { ProviderManager } from "../modules/providers/manager";
+import { FallbackProvider } from "../modules/providers/fallback";
 import { jsonrepair } from "jsonrepair";
-const PLAN_SYSTEM_PROMPT = `You are a planning assistant for an agent system with multiple expert sub-agents.
-Break down the user's task into subtasks that can be executed by different expert agents.
-
-Available experts and their tool tags:
-- code: file operations, code editing, shell commands
-- research: web search, web fetch, web browse, history search
-- browser: browser automation, screenshots
-- vision: browser + file reading for visual tasks
-
-Rules:
+import { parseChunks } from "./response";
+const PLAN_SYSTEM_PROMPT_RULES = `Rules:
 1. Each subtask must have an expert_tag from the available experts.
 2. Use depends_on for ordering when subtask B reads what subtask A writes.
 3. Independent subtasks should NOT depend on each other (they run in parallel).
@@ -39,6 +32,40 @@ Respond with a JSON object only (no markdown fences):
     "refs": []
   }
 }`;
+const PLAN_SYSTEM_PROMPT = `You are a planning assistant for an agent system with multiple expert sub-agents.
+Break down the user's task into subtasks that can be executed by different expert agents.
+
+Available experts and their tool tags:
+- code: file operations, code editing, shell commands
+- research: web search, web fetch, web browse, history search
+- browser: browser automation, screenshots
+- vision: browser + file reading for visual tasks
+
+${PLAN_SYSTEM_PROMPT_RULES}`;
+/**
+ * Render the planner system prompt from the configured experts instead of the
+ * hardcoded code/research/browser/vision list, so user-defined experts
+ * (config.experts) are visible to the Router. Experts without a description
+ * fall back to their tool_tags. Empty/missing registry → legacy hardcoded
+ * prompt (back-compat for direct OrchestratorClient usage in tests).
+ */
+export function buildPlanSystemPrompt(experts) {
+    if (!experts || Object.keys(experts).length === 0) {
+        return PLAN_SYSTEM_PROMPT;
+    }
+    const lines = Object.entries(experts).map(([tag, cfg]) => {
+        const desc = cfg.description ||
+            (cfg.tool_tags?.length ? `tools: ${cfg.tool_tags.join(", ")}` : "general purpose");
+        return `- ${tag}: ${desc}`;
+    });
+    return `You are a planning assistant for an agent system with multiple expert sub-agents.
+Break down the user's task into subtasks that can be executed by different expert agents.
+
+Available experts and their tool tags:
+${lines.join("\n")}
+
+${PLAN_SYSTEM_PROMPT_RULES}`;
+}
 const VERIFY_SYSTEM_PROMPT = `You are a verification and merge assistant for an agent system with multiple expert sub-agents.
 You receive the original plan, the results from each subtask, and any verification errors.
 Your job is to determine if the overall task was completed successfully or if re-planning is needed.
@@ -48,52 +75,77 @@ Respond with JSON only:
 - If re-plan needed: {"type": "replan", "plan": {updated MoEPlan}, "explanation": "why re-plan is needed"}
 
 Max 3 re-plan cycles. After 3 cycles, return partial result.`;
+const SCOPE_DECISION_SYSTEM_PROMPT = `You are the router of a multi-expert agent system. A sub-agent could not finish its task because it lacked access to files outside its assigned scope.
+Decide what to do with its scope request:
+- "approve" — grant access ONLY to files it justifies; keep write grants minimal.
+- "reject" — when the request is unjustified, excessive, or another subtask owns those files.
+
+Respond with JSON only (no markdown fences):
+{"action": "approve", "write": ["file1"], "read": ["file2"]}
+or
+{"action": "reject", "explanation": "why"}`;
+const DEFAULT_BASE_URL = "http://localhost:1234/v1";
+/** Fallback context window when neither the provider entry nor the config sets one. */
+const DEFAULT_ORCH_CONTEXT_WINDOW = 32768;
 export class OrchestratorClient {
     config;
     provider = null;
-    replanCycle = 0;
-    constructor(config, defaultProvider) {
+    getSessionId;
+    constructor(config, defaultProvider, opts) {
         this.config = config;
-        if (config.model) {
-            if (config.provider) {
-                this.provider = createProvider(config.provider.type ?? "openai-compat", {
-                    model: config.model,
-                    baseUrl: config.provider.baseUrl || "http://localhost:1234/v1",
-                    apiKey: config.provider.apiKey,
-                    contextWindow: 32768,
-                    retry: config.retry,
-                });
-            }
-            else if (defaultProvider) {
-                this.provider = defaultProvider;
-            }
-            else {
-                this.provider = createProvider("openai-compat", {
-                    model: config.model,
-                    baseUrl: "http://localhost:1234/v1",
-                    contextWindow: 32768,
-                    retry: config.retry,
-                });
-            }
+        this.getSessionId = opts?.getSessionId;
+        if (!config.model)
+            return;
+        if (config.provider) {
+            this.provider = this.buildManagedProvider(config);
+        }
+        else if (defaultProvider) {
+            this.provider = defaultProvider;
         }
+        else {
+            this.provider = this.buildManagedProvider({
+                ...config,
+                provider: { type: "openai-compat", baseUrl: DEFAULT_BASE_URL },
+            });
+        }
+    }
+    /**
+     * Build the orchestrator provider through ProviderManager so per-entry
+     * contextWindow/retry/rateLimits and failover entries are honored
+     * (legacy {type,baseUrl,apiKey} configs are normalized by the manager).
+     * Previously the provider was built directly with a hardcoded 32768 window
+     * and no retry/rate-limit/failover support at all.
+     */
+    buildManagedProvider(config) {
+        const providerCfg = config.provider;
+        const manager = new ProviderManager({ ...providerCfg, baseUrl: providerCfg.baseUrl || DEFAULT_BASE_URL }, {
+            contextWindow: config.contextWindow ?? DEFAULT_ORCH_CONTEXT_WINDOW,
+            retry: config.retry,
+            rateLimits: config.rateLimits,
+            getSessionId: this.getSessionId,
+            logger: config.logger,
+        });
+        manager.setModel(config.model);
+        let provider = manager.active;
+        if (providerCfg.fallback && manager.listNames().length > 1) {
+            provider = new FallbackProvider(manager, (from, to, error) => {
+                config.logger?.warn(`orchestrator provider failover: ${from} -> ${to} (${error.message.slice(0, 120)})`);
+            });
+        }
+        return provider;
     }
     isEnabled() {
         return this.provider !== null;
     }
-    getReplanCycle() {
-        return this.replanCycle;
-    }
-    async chat(messages) {
+    async chat(messages, signal) {
         if (!this.provider)
             throw new Error("Orchestrator not enabled");
         const chunks = [];
-        for await (const chunk of this.provider.chat(messages)) {
+        for await (const chunk of this.provider.chat(messages, undefined, signal)) {
             chunks.push(chunk);
         }
-        return chunks
-            .filter((c) => c.type === "text")
-            .map((c) => c.content)
-            .join("");
+        const parsed = parseChunks(chunks);
+        return parsed.type === "text" ? parsed.content : "";
     }
     parseJSON(text) {
         try {
@@ -119,39 +171,29 @@ export class OrchestratorClient {
             }
         }
     }
-    async plan(userPrompt, _context) {
+    async plan(userPrompt, _context, signal) {
         if (!this.provider)
             return { error: "Orchestrator not enabled — no orchestrator model configured" };
         const messages = [
-            { role: "system", content: PLAN_SYSTEM_PROMPT },
+            { role: "system", content: buildPlanSystemPrompt(this.config.experts) },
             { role: "user", content: userPrompt },
         ];
-        const text = await this.chat(messages);
+        const text = await this.chat(messages, signal);
         const parsed = this.parseJSON(text);
         if (parsed && parsed.subtasks && parsed.subtasks.length > 0) {
             return { plan: parsed, raw: text };
         }
         return { error: `Failed to parse plan from LLM output. Raw: ${text.slice(0, 500)}` };
     }
-    async verifyAndMerge(input) {
+    async verifyAndMerge(input, signal) {
         if (!this.provider)
             return { type: "final", finalAnswer: input.results.map((r) => r.summary).join("\n") };
-        this.replanCycle++;
-        if (this.replanCycle > 3) {
-            return {
-                type: "final",
-                finalAnswer: input.results
-                    .map((r) => `${r.subtaskId}: ${r.success ? "OK" : "FAIL"} — ${r.summary}`)
-                    .join("\n"),
-                explanation: "Max re-plan cycles (3) reached. Returning partial results.",
-            };
-        }
         const context = JSON.stringify(input, null, 2);
         const messages = [
             { role: "system", content: VERIFY_SYSTEM_PROMPT },
             { role: "user", content: context },
         ];
-        const text = await this.chat(messages);
+        const text = await this.chat(messages, signal);
         const parsed = this.parseJSON(text);
         if (parsed && parsed.type) {
             return parsed;
@@ -162,6 +204,38 @@ export class OrchestratorClient {
             explanation: "Failed to parse verifier output, returning collected results.",
         };
     }
+    /**
+     * Router decision on a sub-agent's scope request. Defaults to reject on any
+     * parse failure — scope must never expand silently.
+     */
+    async resolveScopeRequest(subtaskId, request, signal) {
+        if (!this.provider)
+            return { action: "reject", explanation: "orchestrator not enabled" };
+        const messages = [
+            { role: "system", content: SCOPE_DECISION_SYSTEM_PROMPT },
+            {
+                role: "user",
+                content: JSON.stringify({ subtaskId, request }, null, 2),
+            },
+        ];
+        const text = await this.chat(messages, signal);
+        const parsed = this.parseJSON(text);
+        if (parsed && parsed.action === "approve") {
+            const write = Array.isArray(parsed.write) ? parsed.write.map(String) : [];
+            const read = Array.isArray(parsed.read) ? parsed.read.map(String) : [];
+            // An approve without any concrete files is meaningless — treat as reject.
+            if (write.length === 0 && read.length === 0) {
+                return { action: "reject", explanation: "approve carried no files" };
+            }
+            return { action: "approve", write, read };
+        }
+        return {
+            action: "reject",
+            explanation: parsed?.action === "reject"
+                ? parsed.explanation
+                : `unparseable router decision: ${text.slice(0, 200)}`,
+        };
+    }
     async createPlan(task) {
         if (!this.provider)
             throw new Error("Orchestrator not enabled");
@@ -173,12 +247,10 @@ export class OrchestratorClient {
             { role: "user", content: task },
         ];
         const text = await this.chat(messages);
-        try {
-            return JSON.parse(text);
-        }
-        catch {
-            return { steps: [task] };
-        }
+        const parsed = this.parseJSON(text);
+        if (parsed)
+            return parsed;
+        return { steps: [task] };
     }
     async resolveConflict(context) {
         if (!this.provider)
@@ -190,11 +262,11 @@ export class OrchestratorClient {
             },
             { role: "user", content: context },
         ];
-        let result = "";
+        const chunks = [];
         for await (const chunk of this.provider.chat(messages)) {
-            if (chunk.type === "text" && chunk.content)
-                result += chunk.content;
+            chunks.push(chunk);
         }
-        return result;
+        const parsed = parseChunks(chunks);
+        return parsed.type === "text" ? parsed.content : "";
     }
 }

package/dist/llm/provider-budget.js

@@ -0,0 +1,68 @@
+// src/llm/provider-budget
+/**
+ * Запрос баланса/расхода у провайдера. Поддерживается только OpenRouter —
+ * единственный, кто отдаёт эти данные по API-ключу. Zen/Go баланс не
+ * возвращают (только веб-дашборд), поэтому для них честно `unsupported`.
+ */
+const DEFAULT_TIMEOUT_MS = 5000;
+/** Приводит значение к конечному числу; иначе undefined. */
+function num(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+/** GET JSON с Bearer-авторизацией; не-2xx превращает в ошибку. */
+async function getJson(url, apiKey, timeoutMs) {
+    const response = await fetch(url, {
+        headers: { Authorization: `Bearer ${apiKey}` },
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+    }
+    return response.json();
+}
+/**
+ * Запрашивает бюджет у провайдера. Никогда не бросает: любые сбои возвращаются
+ * как `reason: "error"` (и логируются), чтобы вызывающая команда показала
+ * причину, а не падала.
+ */
+export async function fetchProviderBudget(provider, baseUrl, apiKey, options) {
+    if (provider !== "openrouter") {
+        options.log("debug", `budget: provider "${provider}" does not expose an API balance`);
+        return { budget: null, reason: "unsupported" };
+    }
+    if (!apiKey) {
+        options.log("debug", "budget: no api key configured");
+        return { budget: null, reason: "no-key" };
+    }
+    const base = baseUrl.replace(/\/$/, "");
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    try {
+        const keyBody = (await getJson(`${base}/key`, apiKey, timeoutMs));
+        const data = keyBody?.data ?? {};
+        const budget = { provider, source: "openrouter" };
+        budget.keyLabel = typeof data.label === "string" ? data.label : undefined;
+        budget.keyUsageUsd = num(data.usage);
+        budget.keyLimitUsd = num(data.limit);
+        budget.keyRemainingUsd = num(data.limit_remaining);
+        budget.isFreeTier = typeof data.is_free_tier === "boolean" ? data.is_free_tier : undefined;
+        // /credits требует management key; при отказе продолжаем с данными ключа.
+        try {
+            const creditsBody = (await getJson(`${base}/credits`, apiKey, timeoutMs));
+            const c = creditsBody?.data ?? {};
+            budget.totalCreditsUsd = num(c.total_credits);
+            budget.totalUsageUsd = num(c.total_usage);
+            if (budget.totalCreditsUsd !== undefined && budget.totalUsageUsd !== undefined) {
+                budget.balanceUsd = budget.totalCreditsUsd - budget.totalUsageUsd;
+            }
+        }
+        catch (creditsErr) {
+            options.log("debug", `budget: /credits unavailable (${creditsErr instanceof Error ? creditsErr.message : String(creditsErr)})`);
+        }
+        return { budget, reason: "ok" };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        options.log("warn", `budget: request failed (${message})`);
+        return { budget: null, reason: "error", error: message };
+    }
+}

package/dist/llm/provider.js

@@ -1,4 +1,3 @@
-// src/llm/provider.ts
 /** Helper: extract plain text from message content (for token counting, logging, etc.) */
 export function getMessageText(content) {
     if (typeof content === "string")

package/dist/llm/stream-state.js

@@ -0,0 +1,26 @@
+export class StreamState {
+    sawDone = false;
+    sawText = false;
+    /** tool_call начал накапливаться — сервер закоммитился на ответ. */
+    sawToolCallStart = false;
+    parsedChunks = 0;
+    /** Не-SSE строки (Ollama NDJSON, комментарии, keep-alive) — для диагностики. */
+    nonDataLines = 0;
+    nonDataSamples = [];
+    /** Провайдер прислал {"error": ...} уже после старта генерации. */
+    midStreamError = null;
+    usage;
+    lastFinishReason;
+    /** Снимок для debug-лога по завершении стрима. */
+    snapshot() {
+        return {
+            sawDone: this.sawDone,
+            lastFinishReason: this.lastFinishReason ?? null,
+            sawText: this.sawText,
+            sawToolCallStart: this.sawToolCallStart,
+            parsedChunks: this.parsedChunks,
+            nonDataLines: this.nonDataLines,
+            nonDataSamples: this.nonDataLines > 0 ? this.nonDataSamples : undefined,
+        };
+    }
+}

package/dist/llm/token-counter.js

@@ -1,6 +1,34 @@
 // src/llm/token-counter.ts
 import { encodingForModel, getEncoding } from "js-tiktoken";
 import { getMessageText } from "./provider";
+/**
+ * Script-aware token ESTIMATE (cheap, no full tokenization). Cheap enough for
+ * every hand-built PromptBlock; used at block-build time where the exact
+ * TokenCounter may not be in scope. Measured on cl100k_base: Latin AND
+ * Cyrillic both encode at ~3.3-5 chars/token (the old flat len/4 was actually
+ * close for Cyrillic — the "cyr ≈ /2" assumption was wrong); CJK/Hangul are
+ * the real outliers at ~1-1.5 tokens/char, so they get /1.5. Within ±30% of
+ * tiktoken for Russian text.
+ */
+export function estimateTokens(text) {
+    if (!text)
+        return 0;
+    let cjk = 0;
+    let rest = 0;
+    for (const ch of text) {
+        const code = ch.codePointAt(0);
+        if ((code >= 0x3000 && code <= 0x9fff) || // CJK unified + symbols
+            (code >= 0xac00 && code <= 0xd7af) || // Hangul syllables
+            (code >= 0xff00 && code <= 0xffef) // fullwidth forms
+        ) {
+            cjk++;
+        }
+        else {
+            rest++;
+        }
+    }
+    return Math.ceil(cjk / 1.5 + rest / 4);
+}
 export class TokenCounter {
     encoder;
     constructor(model = "gpt-4o") {

package/dist/logger/app-logger.js

@@ -2,26 +2,19 @@ import { appendFileSync, mkdirSync, existsSync } from "fs";
 import { join } from "path";
 import { sanitizeLogMessage } from "../modules/security/data-sanitizer";
 import { FileLogWriter } from "./file-log";
-import pc from "picocolors";
+import { defaultOutputBus } from "../output";
 const LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
-const LEVEL_COLORS = {
-    debug: (s) => pc.dim(s),
-    info: (s) => s,
-    warn: (s) => pc.yellow(s),
-    error: (s) => pc.red(s),
-};
-function isColorEnabled() {
-    return !process.env.NO_COLOR && !process.env.CI && process.stdout.isTTY === true;
-}
 export class Logger {
     level;
     prefix;
     logDir = null;
     sessionDir = null;
     fileLog;
-    constructor(level = "info", prefix = "") {
+    sink;
+    constructor(level = "info", prefix = "", sink = defaultOutputBus) {
         this.level = level;
         this.prefix = prefix;
+        this.sink = sink;
         this.fileLog = new FileLogWriter();
     }
     setLevel(level) {
@@ -74,7 +67,7 @@ export class Logger {
         this.fileLog.logREPL(tag, sanitizeLogMessage(content));
     }
     child(prefix) {
-        const childLogger = new Logger(this.level, this.prefix ? `${this.prefix}:${prefix}` : prefix);
+        const childLogger = new Logger(this.level, this.prefix ? `${this.prefix}:${prefix}` : prefix, this.sink);
         if (this.logDir)
             childLogger.setLogDir(this.logDir);
         if (this.sessionDir)
@@ -100,10 +93,14 @@ export class Logger {
         const sanitizedMsg = sanitizeLogMessage(msg);
         const sanitizedMeta = meta ? this.sanitizeMeta(meta) : undefined;
         const ts = new Date().toISOString();
-        const prefix = this.prefix ? ` [${this.prefix}]` : "";
         const metaStr = sanitizedMeta ? ` ${JSON.stringify(sanitizedMeta)}` : "";
-        const line = `[${level.toUpperCase()}]${prefix} ${ts} — ${sanitizedMsg}${metaStr}`;
-        console.log(isColorEnabled() ? LEVEL_COLORS[level](line) : line);
+        const line = `${sanitizedMsg}${metaStr}`;
+        try {
+            this.sink.emit({ level, source: this.prefix || "mma", kind: "log", text: line });
+        }
+        catch {
+            /* terminal output is best-effort; file logging below must still run */
+        }
         // Legacy v1 behavior: also append to the tagged `.log` file (session or daily).
         this.fileLog.log(level.toUpperCase(), this.prefix || "MMA", `${ts} — ${sanitizedMsg}${metaStr}`);
         const logTarget = this.sessionDir ?? this.logDir;