micro-models-agent 0.28.9 → 0.29.0

package/dist/core/agent.js

@@ -0,0 +1,461 @@
+import { t } from "../i18n/index";
+import { pc } from "../ui/colors";
+import { PromptBuilder } from "./prompt-builder";
+import { processRegistry } from "../modules/processes";
+import { SessionLogger } from "./session-logger";
+import { runWithMoE } from "./agent-moe";
+const TOOL_RESULT_MAX_TOKENS_RATIO = 0.3;
+const TOOL_RESULT_ABSOLUTE_MAX_CHARS = 15000;
+export class Agent {
+    deps;
+    systemPromptAdded = false;
+    shutdownRequested = false;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /** Expose context manager for REPL image attachment and other direct access. */
+    get contextManager() {
+        return this.deps.contextManager;
+    }
+    setScope() {
+        if (this.deps.scope) {
+            this.deps.toolExecutor.setScope(this.deps.scope);
+        }
+    }
+    buildSystemPrompt() {
+        const systemBudget = Math.floor(this.deps.config.contextWindow *
+            this.deps.config.contextBudget.systemPrompt);
+        const builder = new PromptBuilder(systemBudget);
+        builder.addBlocks(this.deps.promptBlocks);
+        const dynamic = this.deps.getDynamicPromptBlocks?.() ?? [];
+        if (dynamic.length > 0) {
+            builder.addBlocks(dynamic);
+        }
+        const pluginBlocks = (this.deps.pluginManager.runOnBuildPrompt?.() ?? [])
+            .filter((s) => Boolean(s && s.trim() !== ""))
+            .map((content) => ({
+            content,
+            priority: "low",
+            essential: false,
+            estimatedTokens: this.deps.llmProvider.countTokens(content),
+        }));
+        if (pluginBlocks.length > 0) {
+            builder.addBlocks(pluginBlocks);
+        }
+        return builder.build();
+    }
+    refreshSystemPrompt() {
+        const { prompt } = this.buildSystemPrompt();
+        const current = this.deps.contextManager
+            .getActiveHistory()
+            .find((m) => m.role === "system");
+        if (!current || current.content !== prompt) {
+            this.deps.contextManager.updateSystemPrompt?.(prompt);
+        }
+    }
+    truncateToolOutput(output, budget, currentTokens) {
+        const remainingBudget = budget.history - currentTokens;
+        const maxCharsByBudget = Math.floor(remainingBudget * 0.5 * 2);
+        const maxCharsByRatio = Math.floor(budget.history * TOOL_RESULT_MAX_TOKENS_RATIO * 2);
+        const maxChars = Math.min(maxCharsByBudget, maxCharsByRatio, TOOL_RESULT_ABSOLUTE_MAX_CHARS);
+        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) })}`);
+    }
+    emitPhase(iteration, phase, onPhase) {
+        this.deps.pluginManager.runOnPhase?.({ iteration, logger: this.deps.logger }, phase);
+        onPhase?.(phase);
+    }
+    async run(input, onChunk, onMeta, onTool, onPhase) {
+        this.setScope();
+        const { config, llmProvider, toolExecutor, pluginManager, contextManager, logger, sessionManager, } = this.deps;
+        const slog = new SessionLogger(sessionManager);
+        if (sessionManager && !sessionManager.getActive()) {
+            sessionManager.create();
+            logger.debug(`Session started: ${sessionManager.getActive()}`);
+        }
+        if (!this.systemPromptAdded &&
+            !contextManager.getActiveHistory().some((m) => m.role === "system")) {
+            const { prompt: systemPrompt, excluded } = this.buildSystemPrompt();
+            contextManager.addMessage({ role: "system", content: systemPrompt });
+            this.systemPromptAdded = true;
+            slog.logSystem(systemPrompt.slice(0, 2000));
+            if (excluded.length > 0) {
+                slog.logSystem(`[Excluded prompt blocks: ${excluded.length}]`);
+            }
+            pluginManager.runOnSessionStart({
+                logger,
+                sessionManager: sessionManager?.getActiveMeta(),
+            });
+        }
+        contextManager.addMessage({ role: "user", content: input });
+        slog.logUser(input);
+        if (config.moe?.enabled) {
+            return runWithMoE({
+                config,
+                llmProvider,
+                toolExecutor,
+                logger,
+                baseDir: this.deps.baseDir,
+            }, input, () => this.executeSingleAgentLoop(input, onChunk, onMeta, onTool, onPhase), { onMeta, onTool, onPhase });
+        }
+        return this.executeSingleAgentLoop(input, onChunk, onMeta, onTool, onPhase);
+    }
+    async executeSingleAgentLoop(input, onChunk, onMeta, onTool, onPhase) {
+        const { config, llmProvider, toolExecutor, pluginManager, contextManager, hallucinationDetector, logger, sessionManager, } = this.deps;
+        const slog = new SessionLogger(sessionManager);
+        let iteration = 0;
+        let lastText = "";
+        let hallucinationRetries = 0;
+        let lastToolSignature = "";
+        let apiPromptTokens = 0;
+        let apiCompletionTokens = 0;
+        const MAX_HALLUCINATION_RETRIES = 3;
+        let consecutiveToolFailures = 0;
+        const MAX_CONSECUTIVE_TOOL_FAILURES = 5;
+        while (iteration < config.maxToolIterations && !this.shutdownRequested) {
+            iteration++;
+            pluginManager.runOnBeforeThink({
+                iteration,
+                logger,
+                lastUserMessage: input,
+                contextManager,
+                onMeta,
+            });
+            if (contextManager.needsCompaction()) {
+                contextManager.compact();
+                logger.debug("Context compacted");
+                slog.logCompaction(`regular compaction, iteration ${iteration}`, iteration);
+            }
+            const currentTokens = contextManager.getEstimatedTokens();
+            const budget = contextManager.getBudget();
+            if (currentTokens > budget.history) {
+                contextManager.compact();
+                logger.warn(`Context overflow (${currentTokens} > ${budget.history}), forced compaction`);
+                slog.logCompaction(`forced compaction (${currentTokens} > ${budget.history}), iteration ${iteration}`, iteration, currentTokens, budget.history);
+            }
+            this.refreshSystemPrompt();
+            const history = contextManager.getActiveHistory();
+            const allTools = toolExecutor.getToolDefinitions(this.deps.toolTags);
+            slog.logToolDefs(allTools.length, allTools.map((t) => t.name), iteration);
+            let textContent = "";
+            let reasoningContent = "";
+            const toolCalls = [];
+            let sawToolCall = false;
+            let emittedReasoning = false;
+            const textChunks = [];
+            this.emitPhase(iteration, "thinking", onPhase);
+            try {
+                for await (const chunk of llmProvider.chat(history, allTools)) {
+                    if (chunk.type === "text" && chunk.content) {
+                        if (emittedReasoning && !textContent) {
+                            onMeta?.("\n\n");
+                        }
+                        textContent += chunk.content;
+                        textChunks.push(chunk.content);
+                    }
+                    if (chunk.type === "reasoning" && chunk.content) {
+                        reasoningContent += chunk.content;
+                        if (config.showReasoning) {
+                            const metaOut = pluginManager.runOnMeta({ iteration, logger }, chunk.content);
+                            if (metaOut) {
+                                onMeta?.(pc.dim(metaOut));
+                            }
+                            emittedReasoning = true;
+                        }
+                    }
+                    if (chunk.type === "tool_call" && chunk.toolCall) {
+                        sawToolCall = true;
+                        let parsedArgs;
+                        try {
+                            parsedArgs = JSON.parse(chunk.toolCall.arguments);
+                        }
+                        catch {
+                            parsedArgs = {};
+                        }
+                        toolCalls.push({
+                            id: chunk.toolCall.id,
+                            name: chunk.toolCall.name,
+                            arguments: parsedArgs,
+                        });
+                    }
+                    if (chunk.type === "done" && chunk.usage) {
+                        apiPromptTokens += chunk.usage.promptTokens;
+                        apiCompletionTokens += chunk.usage.completionTokens;
+                    }
+                }
+            }
+            catch (err) {
+                logger.error(`LLM call failed: ${err.message}`);
+                slog.logError(err.message);
+                pluginManager.runOnError({ iteration, logger }, err);
+                return {
+                    success: false,
+                    text: lastText,
+                    error: t("error.llm", { message: err.message }),
+                    iterationCount: iteration,
+                };
+            }
+            finally {
+                this.emitPhase(iteration, "done", onPhase);
+            }
+            // Display buffered text only if no tool call in this response.
+            // When a tool call is present, text is just the model describing
+            // its tool call (e.g. raw JSON args) — suppress it.
+            if (!sawToolCall && textChunks.length > 0) {
+                for (const chunk of textChunks) {
+                    const textOut = pluginManager.runOnText({ iteration, logger }, chunk);
+                    onChunk?.(textOut);
+                }
+            }
+            let llmResponse = null;
+            if (sawToolCall) {
+                llmResponse = { type: "tool_call", calls: toolCalls };
+            }
+            else if (textContent) {
+                llmResponse = { type: "text", content: textContent };
+            }
+            else if (reasoningContent) {
+                llmResponse = { type: "reasoning", content: reasoningContent };
+            }
+            pluginManager.runOnAfterThink({ iteration, logger }, llmResponse);
+            if (this.deps.exitOnComplete && sawToolCall) {
+                const signature = toolCalls
+                    .map((tc) => `${tc.name}:${JSON.stringify(tc.arguments)}`)
+                    .join("|");
+                if (signature && signature === lastToolSignature) {
+                    logger.debug("Exit-on-complete: repeated identical tool call, stopping");
+                    break;
+                }
+                lastToolSignature = signature;
+            }
+            if (sawToolCall) {
+                slog.logAssistant(textContent || "", reasoningContent, toolCalls, iteration);
+            }
+            if (sawToolCall) {
+                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 summaries = [];
+                let anyToolFailed = false;
+                for (const call of toolCalls) {
+                    this.setScope();
+                    const startTime = Date.now();
+                    pluginManager.runOnToolCall({
+                        toolName: call.name,
+                        args: call.arguments,
+                    });
+                    pluginManager.runOnToolStart({ iteration, logger }, { id: call.id, name: call.name, arguments: call.arguments });
+                    onTool?.({ type: "start", tool: call.name, args: call.arguments });
+                    slog.logToolCall(call, iteration);
+                    const result = await toolExecutor.execute(call);
+                    const duration = Date.now() - startTime;
+                    if (!result.success)
+                        anyToolFailed = true;
+                    pluginManager.runOnToolEnd({ iteration, logger }, { id: call.id, name: call.name, arguments: call.arguments }, result, duration);
+                    if (result.display) {
+                        onMeta?.("\n" + result.display + "\n");
+                    }
+                    const metaOut = pluginManager.runOnMeta({ iteration, logger }, result.output);
+                    onMeta?.("\n" + pc.dim(metaOut) + "\n");
+                    if (result.diff) {
+                        onMeta?.("\n" + result.diff + "\n");
+                    }
+                    onTool?.({
+                        type: "end",
+                        tool: call.name,
+                        args: call.arguments,
+                        duration,
+                        error: !result.success,
+                    });
+                    const currentTokens = contextManager.getEstimatedTokens();
+                    const budget = contextManager.getBudget();
+                    const truncatedOutput = this.truncateToolOutput(result.output, budget, currentTokens);
+                    contextManager.addMessage({
+                        role: "tool",
+                        content: truncatedOutput,
+                        name: call.name,
+                        tool_call_id: call.id,
+                    });
+                    summaries.push(`[Tool: ${call.name} (${JSON.stringify(call.arguments)}) → ${truncatedOutput.slice(0, 200)}]`);
+                    if (config.session.autoSave) {
+                        slog.logToolResult(call, result, duration, iteration);
+                    }
+                    if (contextManager.needsCompaction()) {
+                        contextManager.compact();
+                        logger.debug("Context compacted after tool result");
+                    }
+                }
+                if (anyToolFailed) {
+                    consecutiveToolFailures++;
+                }
+                else {
+                    consecutiveToolFailures = 0;
+                }
+                if (consecutiveToolFailures >= MAX_CONSECUTIVE_TOOL_FAILURES) {
+                    const recoveryMsg = t("exec.consecutive_failures_recovery", { count: consecutiveToolFailures });
+                    logger.warn(`Consecutive tool failures: ${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>`,
+                    });
+                }
+                contextManager.addMessage({
+                    role: "user",
+                    content: `<system-summary>${summaries.join("\n")}</system-summary>`,
+                });
+                continue;
+            }
+            const hallucinationResult = hallucinationDetector.validate(textContent);
+            if (hallucinationResult.status === "block") {
+                logger.warn(`Response blocked: ${hallucinationResult.reason}`);
+                return {
+                    success: false,
+                    text: lastText,
+                    error: t("error.response_blocked", {
+                        reason: hallucinationResult.reason || "",
+                    }),
+                    iterationCount: iteration,
+                };
+            }
+            if (hallucinationResult.status === "warn") {
+                logger.warn(`Hallucination warning: ${hallucinationResult.reason}`);
+                const warnPrefix = t("hall.uncertainty_prefix");
+                if (onChunk) {
+                    onChunk(warnPrefix);
+                }
+                lastText = warnPrefix + lastText;
+            }
+            if (hallucinationResult.status === "retry") {
+                if (this.deps.exitOnComplete) {
+                    logger.debug("Exit-on-complete: stopping on first response");
+                    break;
+                }
+                if (hallucinationRetries >= MAX_HALLUCINATION_RETRIES) {
+                    logger.warn(`Hallucination retries exhausted (${MAX_HALLUCINATION_RETRIES}), returning error`);
+                    return {
+                        success: false,
+                        text: lastText,
+                        error: t("error.response_blocked", {
+                            reason: t("hall.max_retries_exhausted"),
+                        }),
+                        iterationCount: iteration,
+                    };
+                }
+                hallucinationRetries++;
+                logger.warn(`Hallucination retry (${hallucinationRetries}/${MAX_HALLUCINATION_RETRIES}): ${hallucinationResult.reason}`);
+                if (textContent) {
+                    contextManager.addMessage({
+                        role: "assistant",
+                        content: textContent,
+                    });
+                }
+                contextManager.addMessage({
+                    role: "user",
+                    content: `<system-summary>[Retry context: ${hallucinationResult.reason}. Original task: "${input}". You must either call a needed tool or provide a substantive response. Empty replies are not allowed.]</system-summary>`,
+                });
+                continue;
+            }
+            if (textContent) {
+                contextManager.addMessage({ role: "assistant", content: textContent });
+                slog.saveAssistantMessage(textContent);
+                slog.logAssistant(textContent, reasoningContent, undefined, iteration);
+            }
+            lastText = textContent;
+            if (!sawToolCall) {
+                if (this.deps.finalAudit) {
+                    const audit = await this.deps.finalAudit();
+                    if (audit && !audit.passed) {
+                        logger.warn(`Final audit incomplete: ${audit.summary}`);
+                        const steps = audit.pendingSteps.slice(0, 5).join("; ") || "—";
+                        contextManager.addMessage({
+                            role: "user",
+                            content: `<system-summary>${t("exec.audit_incomplete", {
+                                summary: audit.summary,
+                                steps,
+                            })}</system-summary>`,
+                        });
+                        slog.logAudit(audit.summary, iteration);
+                        if (iteration >= config.maxToolIterations - 1) {
+                            break;
+                        }
+                        continue;
+                    }
+                }
+                break;
+            }
+        }
+        const tokensUsed = contextManager.getEstimatedTokens();
+        const budget = contextManager.getBudget();
+        if (iteration >= config.maxToolIterations) {
+            return {
+                success: false,
+                text: lastText,
+                error: t("error.max_iters", { max: config.maxToolIterations }),
+                iterationCount: iteration,
+                contextUsed: tokensUsed,
+                contextLimit: budget.history,
+                promptTokens: apiPromptTokens,
+                completionTokens: apiCompletionTokens,
+                totalTokens: apiPromptTokens + apiCompletionTokens,
+            };
+        }
+        return {
+            success: true,
+            text: lastText,
+            iterationCount: iteration,
+            contextUsed: tokensUsed,
+            contextLimit: budget.history,
+            promptTokens: apiPromptTokens,
+            completionTokens: apiCompletionTokens,
+            totalTokens: apiPromptTokens + apiCompletionTokens,
+        };
+    }
+    clearContext() {
+        this.deps.contextManager.clear();
+        this.systemPromptAdded = false;
+    }
+    setContext(messages) {
+        const { contextManager } = this.deps;
+        contextManager.clear();
+        const { prompt: systemPrompt } = this.buildSystemPrompt();
+        contextManager.addMessage({ role: "system", content: systemPrompt });
+        this.systemPromptAdded = true;
+        for (const msg of messages) {
+            if (msg.role === "system")
+                continue;
+            contextManager.addMessage({
+                role: msg.role,
+                content: msg.content,
+                name: msg.name,
+            });
+        }
+    }
+    shutdown() {
+        this.shutdownRequested = true;
+        const { pluginManager, logger, sessionManager, contextManager } = this.deps;
+        contextManager.onCompact = null;
+        const killed = processRegistry.killAll();
+        if (killed > 0) {
+            logger.info(`Killed ${killed} background process(es) on shutdown`);
+        }
+        pluginManager.runOnSessionEnd({
+            logger,
+            sessionManager: sessionManager?.getActiveMeta(),
+        });
+    }
+}