micro-models-agent 0.19.1 → 0.19.2

package/dist/modules/browser/session.js

@@ -1,287 +0,0 @@
-import { chromium } from 'playwright';
-import { extractInteractiveElements, formatSnapshot } from './snapshot';
-import { buildClickScript, buildTypeScript, buildScrollScript, buildIndexInjectionScript } from './actions';
-import { CookieStore } from './cookie-store';
-import { t } from '../../i18n/index';
-export class BrowserActionTracker {
-    history = [];
-    threshold;
-    constructor(threshold = 3) {
-        this.threshold = threshold;
-    }
-    record(action, args, url) {
-        this.history.push({ action, args, url });
-        if (this.history.length < this.threshold)
-            return null;
-        const recent = this.history.slice(-this.threshold);
-        const allSame = recent.every(h => h.action === recent[0].action &&
-            h.url === recent[0].url &&
-            JSON.stringify(h.args) === JSON.stringify(recent[0].args));
-        if (allSame) {
-            return t('browser.repeated_action', { action, threshold: this.threshold });
-        }
-        return null;
-    }
-    reset() {
-        this.history = [];
-    }
-}
-export class BrowserSession {
-    browser = null;
-    context = null;
-    page = null;
-    config;
-    cookieStore;
-    state = { isOpen: false, url: null, title: null, elementCount: 0 };
-    actionTracker = new BrowserActionTracker(3);
-    constructor(config) {
-        this.config = config;
-        this.cookieStore = new CookieStore(config.cookieDir);
-    }
-    getState() {
-        return { ...this.state };
-    }
-    async execute(action, args) {
-        try {
-            let result;
-            switch (action) {
-                case 'open':
-                    result = await this.open(String(args.url || ''));
-                    break;
-                case 'click':
-                    result = await this.click(Number(args.target));
-                    break;
-                case 'type':
-                    result = await this.type(Number(args.target), String(args.text || ''));
-                    break;
-                case 'scroll':
-                    result = await this.scroll(String(args.direction || 'down'));
-                    break;
-                case 'back':
-                    result = await this.back();
-                    break;
-                case 'forward':
-                    result = await this.forward();
-                    break;
-                case 'screenshot':
-                    result = await this.screenshot();
-                    break;
-                case 'snapshot':
-                    result = await this.snapshot();
-                    break;
-                case 'close':
-                    result = await this.close();
-                    break;
-                case 'wait':
-                    result = await this.wait(Number(args.ms || 1000));
-                    break;
-                default: return { success: false, output: t('browser.unknown_action', { action }) };
-            }
-            if (action !== 'open') {
-                const warning = this.actionTracker.record(action, args, this.page?.url() || '');
-                if (warning && result.success) {
-                    result.output = result.output + '\n\n⚠️ ' + warning;
-                }
-            }
-            return result;
-        }
-        catch (err) {
-            return { success: false, output: t('browser.error', { message: err.message }) };
-        }
-    }
-    async ensurePage() {
-        if (!this.page) {
-            return { success: false, output: t('browser.no_page') };
-        }
-        return null;
-    }
-    async launch() {
-        if (this.browser)
-            return;
-        this.browser = await chromium.launch({ headless: this.config.headless });
-        this.context = await this.browser.newContext({
-            viewport: { width: this.config.viewportWidth, height: this.config.viewportHeight },
-        });
-        const savedCookies = await this.cookieStore.load();
-        if (savedCookies.length > 0) {
-            await this.context.addCookies(savedCookies.map(c => ({
-                ...c,
-                sameSite: c.sameSite,
-            })));
-        }
-        this.page = await this.context.newPage();
-        this.page.setDefaultTimeout(this.config.navigationTimeout);
-    }
-    async saveCookies() {
-        if (!this.context)
-            return;
-        const cookies = await this.context.cookies();
-        await this.cookieStore.save(cookies);
-    }
-    async takeSnapshot() {
-        if (!this.page)
-            return 'No page open.';
-        await this.page.evaluate(buildIndexInjectionScript());
-        const html = await this.page.content();
-        const url = this.page.url();
-        const title = await this.page.title();
-        const allElements = extractInteractiveElements(html, this.config.maxElements + 5);
-        const truncated = allElements.length > this.config.maxElements;
-        const elements = allElements.slice(0, this.config.maxElements);
-        this.state = {
-            isOpen: true,
-            url,
-            title,
-            elementCount: elements.length,
-        };
-        return formatSnapshot({ url, title, elements, truncated });
-    }
-    async open(url) {
-        if (!url)
-            return { success: false, output: t('browser.url_required') };
-        if (!url.startsWith('http://') && !url.startsWith('https://')) {
-            url = 'https://' + url;
-        }
-        await this.launch();
-        if (!this.page)
-            return { success: false, output: t('browser.create_page_failed') };
-        this.actionTracker.reset();
-        try {
-            await this.page.goto(url, { waitUntil: 'domcontentloaded', timeout: this.config.navigationTimeout });
-        }
-        catch (err) {
-            return { success: false, output: t('browser.nav_failed', { message: err.message }) };
-        }
-        const snapshot = await this.takeSnapshot();
-        await this.saveCookies();
-        return { success: true, output: snapshot };
-    }
-    async click(target) {
-        const err = await this.ensurePage();
-        if (err)
-            return err;
-        if (!this.page)
-            return { success: false, output: 'No page' };
-        if (!target || target < 1) {
-            return { success: false, output: t('browser.invalid_target') };
-        }
-        try {
-            const script = buildClickScript(target);
-            await this.page.evaluate(script);
-            await this.page.waitForLoadState('domcontentloaded', { timeout: 5000 }).catch(() => { });
-            await new Promise(r => setTimeout(r, 500));
-            const snapshot = await this.takeSnapshot();
-            await this.saveCookies();
-            return { success: true, output: snapshot };
-        }
-        catch (err) {
-            return { success: false, output: t('browser.click_failed', { message: err.message }) };
-        }
-    }
-    async type(target, text) {
-        const err = await this.ensurePage();
-        if (err)
-            return err;
-        if (!this.page)
-            return { success: false, output: 'No page' };
-        if (!target || target < 1) {
-            return { success: false, output: t('browser.invalid_target_short') };
-        }
-        if (!text) {
-            return { success: false, output: t('browser.text_required') };
-        }
-        try {
-            const script = buildTypeScript(target, text);
-            await this.page.evaluate(script);
-            const snapshot = await this.takeSnapshot();
-            return { success: true, output: snapshot };
-        }
-        catch (err) {
-            return { success: false, output: t('browser.type_failed', { message: err.message }) };
-        }
-    }
-    async scroll(direction) {
-        const err = await this.ensurePage();
-        if (err)
-            return err;
-        if (!this.page)
-            return { success: false, output: 'No page' };
-        const dir = direction;
-        if (!['up', 'down', 'top', 'bottom'].includes(dir)) {
-            return { success: false, output: t('browser.direction_invalid') };
-        }
-        try {
-            await this.page.evaluate(buildScrollScript(dir));
-            await new Promise(r => setTimeout(r, 300));
-            const snapshot = await this.takeSnapshot();
-            return { success: true, output: snapshot };
-        }
-        catch (err) {
-            return { success: false, output: t('browser.scroll_failed', { message: err.message }) };
-        }
-    }
-    async back() {
-        const err = await this.ensurePage();
-        if (err)
-            return err;
-        if (!this.page)
-            return { success: false, output: 'No page' };
-        await this.page.goBack({ waitUntil: 'domcontentloaded', timeout: this.config.navigationTimeout }).catch(() => { });
-        await new Promise(r => setTimeout(r, 300));
-        const snapshot = await this.takeSnapshot();
-        return { success: true, output: snapshot };
-    }
-    async forward() {
-        const err = await this.ensurePage();
-        if (err)
-            return err;
-        if (!this.page)
-            return { success: false, output: 'No page' };
-        await this.page.goForward({ waitUntil: 'domcontentloaded', timeout: this.config.navigationTimeout }).catch(() => { });
-        await new Promise(r => setTimeout(r, 300));
-        const snapshot = await this.takeSnapshot();
-        return { success: true, output: snapshot };
-    }
-    async screenshot() {
-        const err = await this.ensurePage();
-        if (err)
-            return err;
-        if (!this.page)
-            return { success: false, output: 'No page' };
-        const buffer = await this.page.screenshot({ type: 'png', fullPage: false });
-        const snapshot = await this.takeSnapshot();
-        return { success: true, output: snapshot, screenshot: buffer };
-    }
-    async snapshot() {
-        const err = await this.ensurePage();
-        if (err)
-            return err;
-        const snap = await this.takeSnapshot();
-        return { success: true, output: snap };
-    }
-    async wait(ms) {
-        const err = await this.ensurePage();
-        if (err)
-            return err;
-        await new Promise(r => setTimeout(r, Math.min(ms, 10000)));
-        const snapshot = await this.takeSnapshot();
-        return { success: true, output: snapshot };
-    }
-    async close() {
-        await this.saveCookies();
-        if (this.page) {
-            await this.page.close().catch(() => { });
-            this.page = null;
-        }
-        if (this.context) {
-            await this.context.close().catch(() => { });
-            this.context = null;
-        }
-        if (this.browser) {
-            await this.browser.close().catch(() => { });
-            this.browser = null;
-        }
-        this.state = { isOpen: false, url: null, title: null, elementCount: 0 };
-        return { success: true, output: t('browser.closed') };
-    }
-}

package/dist/modules/browser/snapshot.js

@@ -1,114 +0,0 @@
-import { t } from '../../i18n/index';
-function inferRole(tag, type) {
-    const t = tag.toLowerCase();
-    if (t === 'a')
-        return 'link';
-    if (t === 'button')
-        return 'button';
-    if (t === 'input') {
-        const inputType = type?.toLowerCase();
-        if (inputType === 'submit' || inputType === 'button')
-            return 'button';
-        if (inputType === 'checkbox')
-            return 'checkbox';
-        if (inputType === 'radio')
-            return 'radio';
-        return 'textbox';
-    }
-    if (t === 'textarea')
-        return 'textbox';
-    if (t === 'select')
-        return 'combobox';
-    return 'widget';
-}
-function getName(tag, attrs, html, matchIndex) {
-    const fromAttr = (attrs['aria-label'] ||
-        attrs['placeholder'] ||
-        attrs['title'] ||
-        attrs['alt'] ||
-        attrs['value'] ||
-        attrs['name'] ||
-        '');
-    if (fromAttr)
-        return fromAttr;
-    const afterTag = html.slice(matchIndex);
-    const closeIdx = afterTag.indexOf('>');
-    if (closeIdx === -1)
-        return '';
-    const afterOpen = afterTag.slice(closeIdx + 1);
-    const endTag = `</${tag}>`;
-    const endIdx = afterOpen.indexOf(endTag);
-    if (endIdx === -1)
-        return '';
-    const text = afterOpen.slice(0, endIdx).replace(/<[^>]+>/g, '').trim();
-    return text.slice(0, 50);
-}
-export function extractInteractiveElements(html, maxElements = 30) {
-    const elements = [];
-    const tagRegex = /<(a|button|input|textarea|select|div|span)([^>]*)>/gi;
-    let match;
-    while ((match = tagRegex.exec(html)) !== null) {
-        if (elements.length >= maxElements)
-            break;
-        const tag = match[1].toLowerCase();
-        const attrStr = match[2];
-        const attrs = {};
-        const attrRegex = /(\w[\w-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|(\S+)))?/g;
-        let attrMatch;
-        while ((attrMatch = attrRegex.exec(attrStr)) !== null) {
-            attrs[attrMatch[1].toLowerCase()] = attrMatch[2] ?? attrMatch[3] ?? attrMatch[4] ?? '';
-        }
-        if (attrs['style']?.includes('display:none') || attrs['style']?.includes('display: none'))
-            continue;
-        if (attrs['hidden'] !== undefined)
-            continue;
-        if (attrs['aria-hidden'] === 'true')
-            continue;
-        if (tag === 'input' && attrs['type'] === 'hidden')
-            continue;
-        const role = attrs['role'] || inferRole(tag, attrs['type']);
-        const isInteractive = [
-            'a', 'button', 'input', 'textarea', 'select',
-        ].includes(tag) || attrs['role'] !== undefined;
-        if (!isInteractive)
-            continue;
-        if (tag === 'a' && !attrs['href'])
-            continue;
-        const name = getName(tag, attrs, html, match.index);
-        elements.push({
-            index: elements.length + 1,
-            tag,
-            role,
-            name,
-            value: attrs['value'],
-            href: attrs['href'],
-            visible: true,
-        });
-    }
-    return elements;
-}
-export function formatSnapshot(snapshot) {
-    const lines = [];
-    lines.push(`Page: "${snapshot.title}"`);
-    lines.push(`URL: ${snapshot.url}`);
-    lines.push('');
-    if (snapshot.elements.length === 0 && !snapshot.truncated) {
-        lines.push(t('browser.no_elements'));
-        return lines.join('\n');
-    }
-    for (const el of snapshot.elements) {
-        let line = `[${el.index}] ${el.role}`;
-        if (el.name)
-            line += ` "${el.name}"`;
-        if (el.href)
-            line += ` → ${el.href}`;
-        if (el.value)
-            line += ` = "${el.value}"`;
-        lines.push(line);
-    }
-    if (snapshot.truncated) {
-        lines.push('');
-        lines.push(t('browser.more_elements'));
-    }
-    return lines.join('\n');
-}

package/dist/modules/browser/types.js

@@ -1,9 +0,0 @@
-export const DEFAULT_BROWSER_CONFIG = {
-    headless: true,
-    maxElements: 30,
-    screenshotMaxWidth: 1280,
-    cookieDir: '',
-    viewportWidth: 1280,
-    viewportHeight: 720,
-    navigationTimeout: 15000,
-};

package/dist/modules/context/index.js

@@ -1 +0,0 @@
-export { ContextManager } from './manager';

package/dist/modules/context/manager.js

@@ -1,240 +0,0 @@
-import { getMessageText } from "../../llm/provider";
-const COMPACTION_INTERVAL = 15;
-const KEEP_LAST_N = 6;
-export class ContextManager {
-    contextWindow;
-    messages = [];
-    compactedBlock = null;
-    iterationsSinceCompaction = 0;
-    budget;
-    compactionThreshold;
-    fileFacts = [];
-    decisionFacts = [];
-    errorFacts = [];
-    tokenCounter;
-    pendingImageParts = [];
-    onCompact = null;
-    constructor(contextWindow, contextBudget, tokenCounter) {
-        this.contextWindow = contextWindow;
-        this.compactionThreshold = contextBudget?.compactionThreshold ?? 0.75;
-        this.budget = this.calculateBudget(contextWindow, contextBudget);
-        this.tokenCounter = tokenCounter ?? null;
-    }
-    calculateBudget(window, contextBudget) {
-        if (contextBudget) {
-            const systemPrompt = Math.floor(window * contextBudget.systemPrompt);
-            const responseReserve = Math.floor(window * contextBudget.responseReserve);
-            const history = Math.max(0, window - systemPrompt - responseReserve);
-            return { systemPrompt, responseReserve, history };
-        }
-        // Fallback for backwards compatibility (tests, subagents without explicit budget)
-        return {
-            systemPrompt: Math.floor(window * 0.25),
-            responseReserve: Math.floor(window * 0.12),
-            history: Math.floor(window * 0.63),
-        };
-    }
-    getBudget() {
-        return { ...this.budget };
-    }
-    addMessage(msg) {
-        // Auto-attach pending images to the next user message
-        if (msg.role === "user" && this.pendingImageParts.length > 0) {
-            const textPart = {
-                type: "text",
-                text: typeof msg.content === "string" ? msg.content : getMessageText(msg.content),
-            };
-            msg = {
-                ...msg,
-                content: [textPart, ...this.pendingImageParts],
-            };
-            this.pendingImageParts = [];
-        }
-        this.messages.push(msg);
-        this.iterationsSinceCompaction++;
-    }
-    /**
-     * Queue an image part to be attached to the next user message.
-     */
-    addPendingImage(part) {
-        this.pendingImageParts.push(part);
-    }
-    /**
-     * Check if there are pending images waiting to be attached.
-     */
-    hasPendingImages() {
-        return this.pendingImageParts.length > 0;
-    }
-    /**
-     * Get pending image parts without clearing them.
-     */
-    getPendingImages() {
-        return [...this.pendingImageParts];
-    }
-    /**
-     * Clear pending images (e.g., if user sends a text-only message).
-     */
-    clearPendingImages() {
-        this.pendingImageParts = [];
-    }
-    getMessageCount() {
-        return this.messages.length;
-    }
-    estimateMessageTokens(m) {
-        const text = getMessageText(m.content);
-        if (this.tokenCounter) {
-            let t = this.tokenCounter.count(text);
-            // Image tokens: base64 ~130 tokens per 512x512 tile; rough estimate
-            if (Array.isArray(m.content)) {
-                for (const part of m.content) {
-                    if (part.type === "image_url" && part.image_url?.url) {
-                        const b64Len = part.image_url.url.includes(",")
-                            ? part.image_url.url.split(",")[1]?.length ?? 0
-                            : part.image_url.url.length;
-                        // ~130 tokens per 512 bytes of base64
-                        t += Math.ceil(b64Len / 512) * 130;
-                    }
-                }
-            }
-            if (m.tool_calls) {
-                for (const tc of m.tool_calls) {
-                    t += this.tokenCounter.count(tc.id);
-                    t += this.tokenCounter.count(tc.function.name);
-                    t += this.tokenCounter.count(tc.function.arguments);
-                    t += 4;
-                }
-            }
-            return t;
-        }
-        let t = Math.ceil(text.length / 2);
-        if (Array.isArray(m.content)) {
-            for (const part of m.content) {
-                if (part.type === "image_url" && part.image_url?.url) {
-                    const b64Len = part.image_url.url.includes(",")
-                        ? part.image_url.url.split(",")[1]?.length ?? 0
-                        : part.image_url.url.length;
-                    t += Math.ceil(b64Len / 512) * 130;
-                }
-            }
-        }
-        if (m.tool_calls) {
-            for (const tc of m.tool_calls) {
-                t += Math.ceil(tc.id.length / 2);
-                t += Math.ceil(tc.function.name.length / 2);
-                t += Math.ceil(tc.function.arguments.length / 2);
-                t += 4;
-            }
-        }
-        return t;
-    }
-    needsCompaction() {
-        if (this.iterationsSinceCompaction >= COMPACTION_INTERVAL)
-            return true;
-        const totalTokens = this.messages.reduce((sum, m) => sum + this.estimateMessageTokens(m), 0);
-        return totalTokens > this.budget.history * this.compactionThreshold;
-    }
-    compact() {
-        if (this.messages.length <= KEEP_LAST_N * 2)
-            return;
-        const cutoff = this.messages.length - KEEP_LAST_N * 2;
-        const oldTurns = this.messages.slice(0, cutoff);
-        const recentTurns = this.messages.slice(cutoff);
-        this.extractFacts(oldTurns);
-        const parts = [];
-        parts.push(`[Compressed: ${oldTurns.length} old turns removed]`);
-        if (this.fileFacts.length > 0) {
-            parts.push(`[Files: ${this.fileFacts.slice(-15).join("; ")}]`);
-        }
-        if (this.decisionFacts.length > 0) {
-            parts.push(`[Decisions: ${this.decisionFacts.slice(-5).join("; ")}]`);
-        }
-        if (this.errorFacts.length > 0) {
-            parts.push(`[Errors: ${this.errorFacts.slice(-3).join("; ")}]`);
-        }
-        this.compactedBlock = parts.join(" ");
-        const summary = {
-            role: "user",
-            content: `<system-summary>${this.compactedBlock}</system-summary>`,
-        };
-        const firstSystem = this.messages.find((m) => m.role === "system");
-        this.messages = [
-            ...(firstSystem ? [firstSystem] : []),
-            summary,
-            ...recentTurns,
-        ];
-        this.iterationsSinceCompaction = 0;
-        if (this.onCompact) {
-            this.onCompact(summary);
-        }
-    }
-    extractFacts(turns) {
-        const filePatterns = [
-            /(?:Created|Updated|Written|Deleted|Moved) ([\w./\\-]+\.[a-z]+)/gi,
-            /Файл (?:создан|обновлён|записан|удалён|перемещён):? ([\w./\\-]+\.[a-z]+)/gi,
-            /file (?:created|updated|written|deleted|moved):? ([\w./\\-]+\.[a-z]+)/gi,
-        ];
-        for (const msg of turns) {
-            const content = getMessageText(msg.content);
-            if (msg.role === "tool") {
-                for (const pattern of filePatterns) {
-                    for (const match of content.matchAll(pattern)) {
-                        this.fileFacts.push(match[1]);
-                    }
-                }
-                if (content.includes("Plan:") && content.includes("[")) {
-                    const planLine = content
-                        .split("\n")
-                        .find((line) => line.includes("Plan:"));
-                    if (planLine)
-                        this.decisionFacts.push(planLine.trim());
-                }
-            }
-            if (msg.role === "assistant") {
-                if (content.includes("decided:") || content.includes("decision:")) {
-                    const line = content
-                        .split("\n")
-                        .find((l) => l.includes("decided:") || l.includes("decision:"));
-                    if (line)
-                        this.decisionFacts.push(line.trim().slice(0, 200));
-                }
-            }
-            if (content.includes("Error:") ||
-                content.includes("failed") ||
-                content.includes("Ошибка:") ||
-                content.includes("не удалось")) {
-                const line = content
-                    .split("\n")
-                    .find((l) => l.includes("Error:") ||
-                    l.includes("failed") ||
-                    l.includes("Ошибка:") ||
-                    l.includes("не удалось"));
-                if (line)
-                    this.errorFacts.push(line.trim().slice(0, 250));
-            }
-        }
-    }
-    /**
-     * Replace the system prompt in place (keeps it first) or prepend a new one.
-     * Used to refresh dynamic prompt blocks (e.g. the plan checklist) mid-run.
-     */
-    updateSystemPrompt(content) {
-        const idx = this.messages.findIndex((m) => m.role === "system");
-        if (idx >= 0) {
-            this.messages[idx] = { ...this.messages[idx], content };
-        }
-        else {
-            this.messages.unshift({ role: "system", content });
-        }
-    }
-    getActiveHistory() {
-        return [...this.messages];
-    }
-    clear() {
-        this.messages = [];
-        this.compactedBlock = null;
-        this.iterationsSinceCompaction = 0;
-    }
-    getEstimatedTokens() {
-        return this.messages.reduce((sum, m) => sum + this.estimateMessageTokens(m), 0);
-    }
-}