micro-models-agent 0.28.9 → 0.29.0

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,10 @@
+// src/llm/provider.ts
+/** Helper: extract plain text from message content (for token counting, logging, etc.) */
+export function getMessageText(content) {
+    if (typeof content === "string")
+        return content;
+    return content
+        .filter((p) => p.type === "text")
+        .map((p) => p.text)
+        .join("");
+}

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,39 @@
+// src/llm/token-counter.ts
+import { encodingForModel, getEncoding } from "js-tiktoken";
+import { getMessageText } from "./provider";
+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;
+            const text = getMessageText(msg.content);
+            total += this.count(text);
+            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';