micro-models-agent 0.7.9 → 0.8.0

package/dist/llm/openai-compat.js

@@ -0,0 +1,277 @@
+import { TokenCounter } from "./token-counter";
+import { t } from "../i18n/index";
+import { createRateLimiter } from "../modules/security/rate-limiter";
+export class OpenAICompatProvider {
+    model;
+    contextWindow;
+    config;
+    tokenCounter;
+    retryConfig;
+    rateLimiter;
+    constructor(config) {
+        this.config = config;
+        this.model = config.model;
+        this.contextWindow = config.contextWindow ?? 32768;
+        this.tokenCounter = new TokenCounter();
+        this.retryConfig = config.retry ?? {
+            maxRetries: 3,
+            baseDelay: 1000,
+            maxDelay: 30000,
+        };
+        this.rateLimiter = createRateLimiter(config.rateLimits);
+    }
+    async *chat(messages, tools) {
+        // Check rate limit before making request
+        if (!this.rateLimiter.canMakeRequest()) {
+            throw new Error(`Rate limit exceeded: ${this.rateLimiter.getConfig().maxRequestsPerMinute} requests per minute`);
+        }
+        // Record this request
+        this.rateLimiter.recordRequest();
+        const streamResult = this.doStream(messages, tools);
+        let hasToolCall = false;
+        let hasText = false;
+        let reasoningAcc = "";
+        for await (const chunk of streamResult) {
+            if (chunk.type === "tool_call")
+                hasToolCall = true;
+            if (chunk.type === "text")
+                hasText = true;
+            if (chunk.type === "reasoning" && chunk.content) {
+                reasoningAcc += chunk.content;
+            }
+            yield chunk;
+        }
+        if (!hasToolCall && !hasText) {
+            const fallback = await this.doNonStreaming(messages, tools);
+            for (const chunk of fallback) {
+                yield chunk;
+            }
+        }
+    }
+    async *doStream(messages, tools) {
+        const body = {
+            model: this.model,
+            messages,
+            stream: true,
+            max_tokens: this.config.maxCompletionTokens ?? 4096,
+        };
+        if (tools && tools.length > 0) {
+            body.tools = tools.map((t) => ({
+                type: "function",
+                function: {
+                    name: t.name,
+                    description: t.description,
+                    parameters: t.parameters,
+                },
+            }));
+            body.tool_choice = "auto";
+        }
+        const headers = {
+            "Content-Type": "application/json",
+        };
+        if (this.config.apiKey && this.config.apiKey !== "not-needed") {
+            headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+        }
+        const controller = new AbortController();
+        const totalTimeoutMs = 120000;
+        const timeoutId = setTimeout(() => controller.abort(), totalTimeoutMs);
+        const response = await this.fetchWithRetry(`${this.config.baseUrl}/chat/completions`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            clearTimeout(timeoutId);
+            const errorText = await response.text();
+            throw new Error(t("error.llm_api", {
+                status: response.status,
+                statusText: response.statusText,
+                errorText,
+            }));
+        }
+        const reader = response.body?.getReader();
+        if (!reader) {
+            clearTimeout(timeoutId);
+            throw new Error(t("error.no_response_body"));
+        }
+        const decoder = new TextDecoder();
+        let buffer = "";
+        const toolCallAccs = new Map();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || "";
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed || !trimmed.startsWith("data: "))
+                        continue;
+                    const data = trimmed.slice(6);
+                    if (data === "[DONE]")
+                        continue;
+                    try {
+                        const parsed = JSON.parse(data);
+                        const choice = parsed.choices?.[0];
+                        if (!choice)
+                            continue;
+                        const delta = choice.delta || {};
+                        const finishReason = choice.finish_reason;
+                        if (delta.reasoning_content) {
+                            yield { type: "reasoning", content: delta.reasoning_content };
+                        }
+                        if (delta.tool_calls) {
+                            for (const tc of delta.tool_calls) {
+                                const idx = tc.index ?? 0;
+                                if (!toolCallAccs.has(idx)) {
+                                    toolCallAccs.set(idx, { id: "", name: "", arguments: "" });
+                                }
+                                const acc = toolCallAccs.get(idx);
+                                if (tc.id)
+                                    acc.id = tc.id;
+                                if (tc.function?.name)
+                                    acc.name = tc.function.name;
+                                if (tc.function?.arguments) {
+                                    acc.arguments += tc.function.arguments;
+                                }
+                            }
+                        }
+                        if (delta.content) {
+                            yield { type: "text", content: delta.content };
+                        }
+                        if (finishReason === "tool_calls" && toolCallAccs.size > 0) {
+                            for (const [, acc] of toolCallAccs) {
+                                if (acc.name) {
+                                    yield {
+                                        type: "tool_call",
+                                        toolCall: {
+                                            id: acc.id,
+                                            name: acc.name,
+                                            arguments: acc.arguments || "{}",
+                                        },
+                                    };
+                                }
+                            }
+                            toolCallAccs.clear();
+                        }
+                    }
+                    catch {
+                        // Skip malformed JSON lines
+                    }
+                }
+            }
+        }
+        finally {
+            clearTimeout(timeoutId);
+            reader.releaseLock();
+        }
+    }
+    async doNonStreaming(messages, tools) {
+        const body = {
+            model: this.model,
+            messages,
+            stream: false,
+            max_tokens: this.config.maxCompletionTokens ?? 4096,
+        };
+        if (tools && tools.length > 0) {
+            body.tools = tools.map((t) => ({
+                type: "function",
+                function: {
+                    name: t.name,
+                    description: t.description,
+                    parameters: t.parameters,
+                },
+            }));
+            body.tool_choice = "auto";
+        }
+        const headers = {
+            "Content-Type": "application/json",
+        };
+        if (this.config.apiKey && this.config.apiKey !== "not-needed") {
+            headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+        }
+        try {
+            const response = await this.fetchWithRetry(`${this.config.baseUrl}/chat/completions`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(body),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                console.error("[doNonStreaming] HTTP error:", response.status, errorText.slice(0, 500));
+                return [];
+            }
+            const data = await response.json();
+            const choice = data.choices?.[0];
+            if (!choice) {
+                console.error("[doNonStreaming] No choices in response");
+                return [];
+            }
+            const msg = choice.message || {};
+            const chunks = [];
+            if (msg.reasoning_content) {
+                chunks.push({ type: "reasoning", content: msg.reasoning_content });
+            }
+            if (msg.content) {
+                chunks.push({ type: "text", content: msg.content });
+            }
+            if (msg.tool_calls) {
+                for (const tc of msg.tool_calls) {
+                    chunks.push({
+                        type: "tool_call",
+                        toolCall: {
+                            id: tc.id || "",
+                            name: tc.function?.name || "",
+                            arguments: tc.function?.arguments || "{}",
+                        },
+                    });
+                }
+            }
+            console.error("[doNonStreaming] chunks:", chunks.length, "tool_calls:", msg.tool_calls?.length, "content len:", msg.content?.length);
+            if (chunks.length === 0) {
+                console.error("[doNonStreaming] Empty response: no content, no tool_calls, no reasoning");
+            }
+            return chunks;
+        }
+        catch (err) {
+            console.error("[doNonStreaming] Fetch error:", err instanceof Error ? err.message : String(err));
+            return [];
+        }
+    }
+    countTokens(text) {
+        return this.tokenCounter.count(text);
+    }
+    async fetchWithRetry(url, init) {
+        const { maxRetries, baseDelay, maxDelay } = this.retryConfig;
+        let lastError = null;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                const response = await fetch(url, init);
+                if (!this.isRetryable(response.status))
+                    return response;
+                lastError = new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            catch (err) {
+                if (err.name === "AbortError") {
+                    throw err;
+                }
+                lastError = err;
+            }
+            if (attempt < maxRetries) {
+                const delay = Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
+                const jitter = Math.random() * baseDelay * 0.1;
+                await this.sleep(delay + jitter);
+            }
+        }
+        throw lastError ?? new Error(t("error.llm_retries"));
+    }
+    isRetryable(status) {
+        return status === 429 || status >= 500;
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}

package/dist/llm/orchestrator.js

@@ -0,0 +1,194 @@
+import { OpenAICompatProvider } from './openai-compat';
+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:
+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).
+4. allowed_files is for files the subtask will CREATE or MODIFY.
+5. read_only_files is for files the subtask needs to READ only.
+6. File paths should be relative to the workspace root.
+7. Do NOT use keyword matching to determine task type. Instead, analyze the actual nature of the task.
+
+Respond with a JSON object only (no markdown fences):
+{
+  "title": "Plan title",
+  "subtasks": [
+    {
+      "id": "task-1",
+      "description": "Clear description",
+      "expert_tag": "code",
+      "allowed_files": ["src/file.ts"],
+      "read_only_files": [],
+      "depends_on": [],
+      "input_from": [],
+      "expected_output": "What this subtask produces",
+      "success_criteria": ["criterion 1", "criterion 2"]
+    }
+  ],
+  "shared_context": {
+    "rules": ["rule 1"],
+    "refs": []
+  }
+}`;
+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.
+
+Respond with JSON only:
+- If successful: {"type": "final", "finalAnswer": "summary of results", "explanation": "details"}
+- 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.`;
+export class OrchestratorClient {
+    config;
+    provider = null;
+    replanCycle = 0;
+    constructor(config, defaultProvider) {
+        this.config = config;
+        if (config.model) {
+            if (config.provider) {
+                this.provider = new OpenAICompatProvider({
+                    model: config.model,
+                    baseUrl: config.provider.baseUrl || 'http://localhost:1234/v1',
+                    apiKey: config.provider.apiKey,
+                    retry: config.retry,
+                });
+            }
+            else if (defaultProvider) {
+                this.provider = defaultProvider;
+            }
+            else {
+                this.provider = new OpenAICompatProvider({
+                    model: config.model,
+                    baseUrl: 'http://localhost:1234/v1',
+                    retry: config.retry,
+                });
+            }
+        }
+    }
+    isEnabled() {
+        return this.provider !== null;
+    }
+    getReplanCycle() {
+        return this.replanCycle;
+    }
+    async chat(messages) {
+        if (!this.provider)
+            throw new Error('Orchestrator not enabled');
+        const chunks = [];
+        for await (const chunk of this.provider.chat(messages)) {
+            chunks.push(chunk);
+        }
+        return chunks
+            .filter((c) => c.type === 'text')
+            .map((c) => c.content)
+            .join('');
+    }
+    parseJSON(text) {
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            try {
+                const repaired = jsonrepair(text);
+                return JSON.parse(repaired);
+            }
+            catch {
+                const jsonMatch = text.match(/\{[\s\S]*\}/);
+                if (jsonMatch) {
+                    try {
+                        const repaired = jsonrepair(jsonMatch[0]);
+                        return JSON.parse(repaired);
+                    }
+                    catch { /* fall through */ }
+                }
+                return null;
+            }
+        }
+    }
+    async plan(userPrompt, _context) {
+        if (!this.provider)
+            return { error: 'Orchestrator not enabled — no orchestrator model configured' };
+        const messages = [
+            { role: 'system', content: PLAN_SYSTEM_PROMPT },
+            { role: 'user', content: userPrompt },
+        ];
+        const text = await this.chat(messages);
+        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) {
+        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 parsed = this.parseJSON(text);
+        if (parsed && parsed.type) {
+            return parsed;
+        }
+        return {
+            type: 'final',
+            finalAnswer: input.results.map(r => r.summary).join('\n'),
+            explanation: 'Failed to parse verifier output, returning collected results.',
+        };
+    }
+    async createPlan(task) {
+        if (!this.provider)
+            throw new Error('Orchestrator not enabled');
+        const messages = [
+            {
+                role: 'system',
+                content: 'You are a planning assistant. Break down tasks into steps. Respond with JSON only: {"steps": ["step 1", "step 2", ...]}',
+            },
+            { role: 'user', content: task },
+        ];
+        const text = await this.chat(messages);
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return { steps: [task] };
+        }
+    }
+    async resolveConflict(context) {
+        if (!this.provider)
+            throw new Error('Orchestrator not enabled');
+        const messages = [
+            {
+                role: 'system',
+                content: 'You are a conflict resolution assistant. Analyze the situation and recommend the best path forward.',
+            },
+            { role: 'user', content: context },
+        ];
+        let result = '';
+        for await (const chunk of this.provider.chat(messages)) {
+            if (chunk.type === 'text' && chunk.content)
+                result += chunk.content;
+        }
+        return result;
+    }
+}

package/dist/llm/provider.js

@@ -0,0 +1,2 @@
+// src/llm/provider.ts
+export {};

package/dist/llm/response.js

@@ -0,0 +1,39 @@
+export function parseChunks(chunks) {
+    let text = '';
+    let reasoning;
+    const toolCalls = [];
+    let hasToolCalls = false;
+    for (const chunk of chunks) {
+        if (chunk.type === 'text' && chunk.content) {
+            text += chunk.content;
+        }
+        if (chunk.type === 'reasoning' && chunk.content) {
+            reasoning = (reasoning || '') + chunk.content;
+        }
+        if (chunk.type === 'tool_call' && chunk.toolCall) {
+            hasToolCalls = 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 (hasToolCalls) {
+        return { type: 'tool_call', calls: toolCalls, reasoning };
+    }
+    if (reasoning && !text) {
+        return { type: 'reasoning', content: reasoning };
+    }
+    if (!text && !reasoning) {
+        return { type: 'empty' };
+    }
+    return { type: 'text', content: text || '', reasoning };
+}

package/dist/llm/token-counter.js

@@ -0,0 +1,37 @@
+// src/llm/token-counter.ts
+import { encodingForModel, getEncoding } from "js-tiktoken";
+export class TokenCounter {
+    encoder;
+    constructor(model = "gpt-4o") {
+        try {
+            this.encoder = encodingForModel(model);
+        }
+        catch {
+            // Fallback to cl100k_base for unknown models
+            this.encoder = getEncoding("cl100k_base");
+        }
+    }
+    count(text) {
+        if (!text)
+            return 0;
+        return this.encoder.encode(text).length;
+    }
+    countMessages(messages) {
+        let total = 0;
+        for (const msg of messages) {
+            // ~4 tokens per message overhead (role, boundaries)
+            total += 4;
+            total += this.count(msg.content);
+            if (msg.role === "tool")
+                total += 2; // tool_call_id
+        }
+        total += 2; // assistant priming
+        return total;
+    }
+    encode(text) {
+        return this.encoder.encode(text);
+    }
+    decode(tokens) {
+        return this.encoder.decode(tokens);
+    }
+}

package/dist/llm/types.js

@@ -0,0 +1 @@
+export {};

package/dist/logger/app-logger.js

@@ -0,0 +1,76 @@
+import { appendFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { sanitizeLogMessage } from '../modules/security/data-sanitizer';
+const LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
+export class Logger {
+    level;
+    prefix;
+    logDir = null;
+    constructor(level = 'info', prefix = '') {
+        this.level = level;
+        this.prefix = prefix;
+    }
+    setLevel(level) {
+        this.level = level;
+    }
+    setLogDir(dir) {
+        this.logDir = dir;
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+    }
+    child(prefix) {
+        const childLogger = new Logger(this.level, this.prefix ? `${this.prefix}:${prefix}` : prefix);
+        if (this.logDir)
+            childLogger.setLogDir(this.logDir);
+        return childLogger;
+    }
+    debug(msg, meta) {
+        this.log('debug', msg, meta);
+    }
+    info(msg, meta) {
+        this.log('info', msg, meta);
+    }
+    warn(msg, meta) {
+        this.log('warn', msg, meta);
+    }
+    error(msg, meta) {
+        this.log('error', msg, meta);
+    }
+    log(level, msg, meta) {
+        if (LEVELS[level] < LEVELS[this.level])
+            return;
+        // Sanitize log message to remove sensitive data
+        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(line);
+        if (this.logDir) {
+            try {
+                appendFileSync(join(this.logDir, 'app.jsonl'), JSON.stringify({ level, ts, prefix: this.prefix, msg: sanitizedMsg, meta: sanitizedMeta ?? null }) + '\n', 'utf-8');
+            }
+            catch { /* file logging is best-effort */ }
+        }
+    }
+    /**
+     * Sanitize metadata object to remove sensitive data
+     */
+    sanitizeMeta(meta) {
+        const sanitized = {};
+        for (const [key, value] of Object.entries(meta)) {
+            if (typeof value === 'string') {
+                sanitized[key] = sanitizeLogMessage(value);
+            }
+            else if (typeof value === 'object' && value !== null) {
+                sanitized[key] = this.sanitizeMeta(value);
+            }
+            else {
+                sanitized[key] = value;
+            }
+        }
+        return sanitized;
+    }
+}

package/dist/logger/index.js

@@ -0,0 +1 @@
+export { Logger } from './app-logger';

package/dist/migration/backup.js

@@ -0,0 +1,45 @@
+import { copyFileSync, cpSync, existsSync, mkdirSync, readdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { t } from '../i18n/index';
+export class BackupManager {
+    configDir;
+    constructor(configDir) {
+        this.configDir = configDir;
+    }
+    backupConfig() {
+        const configPath = join(this.configDir, 'config.json');
+        if (!existsSync(configPath))
+            return;
+        const bakPath = join(this.configDir, 'config.json.bak');
+        copyFileSync(configPath, bakPath);
+    }
+    backupAll() {
+        const bakDir = this.configDir + '.bak';
+        if (existsSync(bakDir))
+            return;
+        if (existsSync(this.configDir)) {
+            cpSync(this.configDir, bakDir, { recursive: true });
+        }
+    }
+    writeFreshConfig(config) {
+        if (!existsSync(this.configDir)) {
+            mkdirSync(this.configDir, { recursive: true });
+        }
+        writeFileSync(join(this.configDir, 'config.json'), JSON.stringify(config, null, 2), 'utf-8');
+    }
+    getBackupSummary() {
+        const lines = [];
+        const bakConfig = join(this.configDir, 'config.json.bak');
+        const bakDir = this.configDir + '.bak';
+        if (existsSync(bakConfig)) {
+            lines.push(t('migration.config_bak'));
+        }
+        if (existsSync(bakDir)) {
+            const files = readdirSync(bakDir);
+            lines.push(t('migration.dir_bak', { count: files.length }));
+        }
+        return lines.length > 0
+            ? `${t('migration.migrated')}\n${lines.join('\n')}`
+            : t('migration.not_needed');
+    }
+}