micro-models-agent 0.56.5 → 0.57.1

package/dist/llm/openai-compat.js

@@ -0,0 +1,497 @@
+import { TokenCounter } from "./token-counter";
+import { t } from "../i18n/index";
+import { createRateLimiter } from "../modules/security/rate-limiter";
+const REQUEST_TIMEOUT_MS = 120000;
+function buildRequestBody(opts) {
+    const body = {
+        model: opts.model,
+        messages: opts.messages,
+        stream: opts.stream,
+    };
+    if (opts.maxTokens !== undefined)
+        body.max_tokens = opts.maxTokens;
+    if (opts.reasoningEffort) {
+        body.reasoning_effort = opts.reasoningEffort;
+    }
+    if (opts.tools && opts.tools.length > 0) {
+        body.tools = opts.tools.map((t) => ({
+            type: "function",
+            function: {
+                name: t.name,
+                description: t.description,
+                parameters: t.parameters,
+            },
+        }));
+        body.tool_choice = "auto";
+    }
+    return body;
+}
+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,
+            maxStreamRetries: 2,
+            noDataTimeoutMs: 180000,
+        };
+        this.rateLimiter = createRateLimiter(config.rateLimits);
+    }
+    async *chat(messages, tools, signal, options) {
+        // 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, signal, options);
+        let hasToolCall = false;
+        let hasText = false;
+        for await (const chunk of streamResult) {
+            if (chunk.type === "tool_call")
+                hasToolCall = true;
+            if (chunk.type === "text")
+                hasText = true;
+            yield chunk;
+        }
+        if (!hasToolCall && !hasText) {
+            const fallback = await this.doNonStreaming(messages, tools, signal, options);
+            for (const chunk of fallback) {
+                yield chunk;
+            }
+        }
+    }
+    async *doStream(messages, tools, signal, options) {
+        const { baseDelay, maxDelay, maxStreamRetries, noDataTimeoutMs } = this.retryConfig;
+        const streamRetries = maxStreamRetries ?? 2;
+        const idleTimeoutMs = noDataTimeoutMs ?? 180000;
+        for (let attempt = 0;; attempt++) {
+            let emitted = false;
+            const onEmit = () => {
+                emitted = true;
+            };
+            try {
+                const sawDone = yield* this.streamOnce(messages, tools, signal, options, onEmit, idleTimeoutMs);
+                // Clean [DONE] or any partial content → deliver what we have.
+                if (sawDone || emitted)
+                    return;
+                // Stream closed before [DONE] with zero content → retryable truncation.
+                if (attempt >= streamRetries)
+                    return;
+            }
+            catch (err) {
+                if (err?.name === "AbortError" || err?.llmTerminal || signal?.aborted)
+                    throw err;
+                // Content was already delivered — a re-stream would duplicate chunks.
+                if (emitted || attempt >= streamRetries)
+                    throw err;
+                // Connection dropped before any content → retry the whole request.
+            }
+            const delay = Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
+            const jitter = Math.random() * baseDelay * 0.1;
+            await this.sleep(delay + jitter, signal);
+        }
+    }
+    async *streamOnce(messages, tools, signal, options, onEmit, idleTimeoutMs) {
+        const maxTokens = options?.maxTokens ?? this.config.maxCompletionTokens ?? 4096;
+        const body = buildRequestBody({
+            model: this.model,
+            messages,
+            tools,
+            stream: true,
+            maxTokens,
+            reasoningEffort: options?.reasoningEffort,
+        });
+        const { headers, abortSignal, cleanup, isTimeout, flagTimeout, controller } = this.buildRequestSetup(signal);
+        let response;
+        try {
+            response = await this.fetchWithRetry(`${this.config.baseUrl}/chat/completions`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(body),
+                signal: abortSignal,
+            });
+        }
+        catch (err) {
+            // Fetch-level failures are already HTTP-retried inside fetchWithRetry —
+            // don't double-retry them at the stream level.
+            if (err?.name === "AbortError")
+                throw err;
+            const wrapped = err instanceof Error ? err : new Error(String(err));
+            wrapped.llmTerminal = true;
+            throw wrapped;
+        }
+        if (!response.ok) {
+            cleanup();
+            const errorText = await response.text();
+            const err = new Error(t("error.llm_api", {
+                status: response.status,
+                statusText: response.statusText,
+                errorText,
+            }));
+            err.llmTerminal = true;
+            throw err;
+        }
+        const reader = response.body?.getReader();
+        if (!reader) {
+            cleanup();
+            throw new Error(t("error.no_response_body"));
+        }
+        const decoder = new TextDecoder();
+        let buffer = "";
+        const toolCallAccs = new Map();
+        // A tool_call started accumulating — the server committed to a response.
+        // If the stream stalls after this, the provider most likely buffers SSE
+        // instead of streaming argument deltas (seen with LM Studio).
+        let sawToolCallStart = false;
+        let usage;
+        let sawDone = false;
+        let lastFinishReason;
+        let sawText = false;
+        const readIdle = () => new Promise((resolve, reject) => {
+            const idleTimer = setTimeout(() => {
+                flagTimeout();
+                controller.abort();
+            }, idleTimeoutMs);
+            reader.read().then((result) => {
+                clearTimeout(idleTimer);
+                if (isTimeout())
+                    reject(new Error(t(sawToolCallStart ? "error.llm_stream_idle_toolcall" : "error.llm_stream_idle", { timeout: idleTimeoutMs })));
+                else
+                    resolve(result);
+            }, (err) => {
+                clearTimeout(idleTimer);
+                if (isTimeout())
+                    reject(new Error(t(sawToolCallStart ? "error.llm_stream_idle_toolcall" : "error.llm_stream_idle", { timeout: idleTimeoutMs })));
+                else
+                    reject(err);
+            });
+        });
+        try {
+            while (true) {
+                const { done, value } = await readIdle();
+                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]") {
+                        sawDone = true;
+                        continue;
+                    }
+                    try {
+                        const parsed = JSON.parse(data);
+                        const choice = parsed.choices?.[0];
+                        if (!choice) {
+                            // Usage comes in the last chunk with empty choices
+                            if (parsed.usage) {
+                                usage = {
+                                    promptTokens: parsed.usage.prompt_tokens ?? 0,
+                                    completionTokens: parsed.usage.completion_tokens ?? 0,
+                                    totalTokens: parsed.usage.total_tokens ?? 0,
+                                };
+                            }
+                            continue;
+                        }
+                        const delta = choice.delta || {};
+                        const finishReason = choice.finish_reason;
+                        if (finishReason)
+                            lastFinishReason = finishReason;
+                        if (delta.reasoning_content) {
+                            onEmit();
+                            yield { type: "reasoning", content: delta.reasoning_content };
+                        }
+                        if (delta.tool_calls) {
+                            sawToolCallStart = true;
+                            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) {
+                            onEmit();
+                            sawText = true;
+                            yield { type: "text", content: delta.content };
+                        }
+                        if (finishReason === "tool_calls" && toolCallAccs.size > 0) {
+                            for (const [, acc] of toolCallAccs) {
+                                if (acc.name) {
+                                    onEmit();
+                                    yield {
+                                        type: "tool_call",
+                                        toolCall: {
+                                            id: acc.id,
+                                            name: acc.name,
+                                            arguments: acc.arguments || "{}",
+                                        },
+                                    };
+                                }
+                            }
+                            toolCallAccs.clear();
+                        }
+                    }
+                    catch {
+                        // Skip malformed JSON lines
+                    }
+                }
+            }
+            if (usage) {
+                onEmit();
+                yield { type: "done", usage };
+            }
+            // finish_reason "length": the completion hit the token limit. An
+            // unfinished tool_call would otherwise be silently swallowed (tool_calls
+            // are only yielded on finish_reason "tool_calls") and surface as an
+            // empty response → blind hallucination retries. Surface the real cause.
+            if (lastFinishReason === "length") {
+                const truncatedToolCall = sawToolCallStart && toolCallAccs.size > 0;
+                if (truncatedToolCall || !sawText) {
+                    const err = new Error(t(truncatedToolCall ? "error.llm_truncated_toolcall" : "error.llm_truncated", {
+                        tokens: maxTokens,
+                    }));
+                    err.llmTerminal = true;
+                    // The provider is fine — the model just overran the completion
+                    // limit. The agent loop feeds this back so the model can adapt
+                    // (split the output) instead of the session dying.
+                    err.recoverableLlm = true;
+                    throw err;
+                }
+            }
+        }
+        finally {
+            cleanup();
+            reader.releaseLock();
+        }
+        return sawDone;
+    }
+    /** Shared request setup: auth headers + timeout/abort controller wiring. */
+    buildRequestSetup(signal) {
+        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();
+        let timedOut = false;
+        const timeoutId = setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+        }, REQUEST_TIMEOUT_MS);
+        const abortSignal = (() => {
+            if (!signal)
+                return controller.signal;
+            try {
+                return AbortSignal.any([controller.signal, signal]);
+            }
+            catch {
+                signal.addEventListener("abort", () => controller.abort(), {
+                    once: true,
+                });
+                return controller.signal;
+            }
+        })();
+        return {
+            headers,
+            abortSignal,
+            cleanup: () => clearTimeout(timeoutId),
+            isTimeout: () => timedOut,
+            flagTimeout: () => {
+                timedOut = true;
+            },
+            controller,
+        };
+    }
+    async doNonStreaming(messages, tools, signal, options) {
+        const body = buildRequestBody({
+            model: this.model,
+            messages,
+            tools,
+            stream: false,
+            maxTokens: options?.maxTokens ?? this.config.maxCompletionTokens ?? 4096,
+            reasoningEffort: options?.reasoningEffort,
+        });
+        const { headers, abortSignal, cleanup, isTimeout } = this.buildRequestSetup(signal);
+        try {
+            const response = await this.fetchWithRetry(`${this.config.baseUrl}/chat/completions`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(body),
+                signal: abortSignal,
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(t("error.llm_api", {
+                    status: response.status,
+                    statusText: response.statusText,
+                    errorText: errorText.slice(0, 500),
+                }));
+            }
+            const data = await response.json();
+            const choice = data.choices?.[0];
+            if (!choice) {
+                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 || "{}",
+                        },
+                    });
+                }
+            }
+            // Append usage from API response
+            if (data.usage) {
+                chunks.push({
+                    type: "done",
+                    usage: {
+                        promptTokens: data.usage.prompt_tokens ?? 0,
+                        completionTokens: data.usage.completion_tokens ?? 0,
+                        totalTokens: data.usage.total_tokens ?? 0,
+                    },
+                });
+            }
+            return chunks;
+        }
+        catch (err) {
+            if (isTimeout() && err?.name === "AbortError") {
+                throw new Error(t("error.llm_timeout", { timeout: REQUEST_TIMEOUT_MS }));
+            }
+            throw err instanceof Error ? err : new Error(String(err));
+        }
+        finally {
+            cleanup();
+        }
+    }
+    countTokens(text) {
+        return this.tokenCounter.count(text);
+    }
+    async listModels() {
+        try {
+            const url = `${this.config.baseUrl.replace(/\/+$/, "")}/models`;
+            const headers = {
+                "Content-Type": "application/json",
+            };
+            if (this.config.apiKey && this.config.apiKey !== "not-needed") {
+                headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+            }
+            const response = await fetch(url, {
+                method: "GET",
+                headers,
+            });
+            if (!response.ok) {
+                // Surface the failure: health probes must distinguish a dead
+                // provider from one that serves an empty model list.
+                throw new Error(`HTTP ${response.status} from ${url}`);
+            }
+            const data = (await response.json());
+            const models = (data.data || data || [])
+                .map((m) => m.id || m.name || m.model || "")
+                .filter(Boolean);
+            return models;
+        }
+        catch (err) {
+            throw err instanceof Error ? err : new Error(String(err));
+        }
+    }
+    async fetchWithRetry(url, init) {
+        const { maxRetries, baseDelay, maxDelay } = this.retryConfig;
+        let lastStatus = 0;
+        let lastRetryAfter = 0;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                const response = await fetch(url, init);
+                if (!this.isRetryable(response.status))
+                    return response;
+                lastStatus = response.status;
+                const retryAfter = Number(response.headers.get("retry-after") ?? 0);
+                lastRetryAfter = retryAfter > 0 ? retryAfter * 1000 : 0;
+            }
+            catch (err) {
+                if (err.name === "AbortError") {
+                    throw err;
+                }
+                if (attempt === maxRetries)
+                    throw err;
+            }
+            if (attempt < maxRetries) {
+                // Prefer the provider's Retry-After window (saturating at maxDelay);
+                // otherwise exponential backoff. 429s from free tiers need a real wait.
+                const delay = lastRetryAfter > 0
+                    ? Math.min(lastRetryAfter, maxDelay)
+                    : Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
+                const jitter = Math.random() * baseDelay * 0.1;
+                await this.sleep(delay + jitter, init.signal ?? undefined);
+            }
+        }
+        if (lastStatus === 429) {
+            const e429 = new Error(t("error.llm_429", {
+                model: this.model,
+                baseUrl: this.config.baseUrl,
+            }));
+            e429.llmStatus = lastStatus;
+            throw e429;
+        }
+        const eRetry = new Error(t("error.llm_retries"));
+        eRetry.llmStatus = lastStatus;
+        throw eRetry;
+    }
+    isRetryable(status) {
+        return status === 429 || status >= 500;
+    }
+    sleep(ms, signal) {
+        return new Promise((resolve, reject) => {
+            if (signal?.aborted) {
+                reject(new DOMException("Aborted", "AbortError"));
+                return;
+            }
+            let timer;
+            const onAbort = () => {
+                clearTimeout(timer);
+                reject(new DOMException("Aborted", "AbortError"));
+            };
+            timer = setTimeout(() => {
+                signal?.removeEventListener("abort", onAbort);
+                resolve();
+            }, ms);
+            signal?.addEventListener("abort", onAbort, { once: true });
+        });
+    }
+}

package/dist/llm/orchestrator.js

@@ -0,0 +1,200 @@
+import { createProvider } from "../modules/providers/create";
+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 = 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,
+                });
+            }
+        }
+    }
+    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;
+    }
+}