micro-models-agent 0.52.0 → 0.52.1

package/dist/llm/openai-compat.js

@@ -1,497 +0,0 @@
-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

@@ -1,200 +0,0 @@
-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;
-    }
-}