micro-models-agent 0.19.0 → 0.19.2

package/dist/llm/image-utils.js

@@ -1,144 +0,0 @@
-import { readFileSync } from "fs";
-import { extname } from "path";
-const MIME_MAP = {
-    ".png": "image/png",
-    ".jpg": "image/jpeg",
-    ".jpeg": "image/jpeg",
-    ".gif": "image/gif",
-    ".webp": "image/webp",
-    ".bmp": "image/bmp",
-    ".svg": "image/svg+xml",
-};
-/** Detect MIME type from file extension. */
-export function detectMime(filePath) {
-    const ext = extname(filePath).toLowerCase();
-    return MIME_MAP[ext] ?? "image/png";
-}
-/**
- * Read image from system clipboard using Bun.Image (macOS/Windows).
- * Falls back to platform-specific commands on Linux.
- * Returns null if clipboard has no image.
- */
-export async function readClipboardImage() {
-    // Bun.Image.fromClipboard() works on macOS and Windows
-    if (typeof Bun !== "undefined" && typeof Bun.Image !== "undefined") {
-        try {
-            const img = Bun.Image.fromClipboard();
-            if (img) {
-                const buf = await img
-                    .resize(800, 800, { fit: "inside" })
-                    .jpeg({ quality: 60 })
-                    .buffer();
-                return Buffer.from(buf);
-            }
-        }
-        catch {
-            // Bun.Image.fromClipboard() failed — fall through to platform fallback
-        }
-    }
-    // Linux fallback: xclip/wl-paste → temp file → read
-    return readClipboardFallback();
-}
-async function readClipboardFallback() {
-    const { platform } = await import("os");
-    const { execSync } = await import("child_process");
-    const { readFileSync, unlinkSync } = await import("fs");
-    const { join } = await import("path");
-    const tmpPath = join(process.env.TEMP || process.env.TMP || "/tmp", `mma-clip-${Date.now()}.png`);
-    try {
-        if (platform() === "linux") {
-            execSync(`xclip -selection clipboard -t image/png -o > "${tmpPath}" 2>/dev/null`, { timeout: 5000 });
-        }
-        else {
-            return null; // macOS/Windows should use Bun.Image
-        }
-        const buf = readFileSync(tmpPath);
-        unlinkSync(tmpPath);
-        return buf.length > 0 ? buf : null;
-    }
-    catch {
-        try {
-            unlinkSync(tmpPath);
-        }
-        catch { }
-        return null;
-    }
-}
-/**
- * Load an image from a file path, resize via Bun.Image, return as JPEG data URL.
- * Target: ~800px wide, JPEG quality 60 — typically 5-15KB (~2-4K tokens).
- */
-export async function loadFileAsDataUrl(filePath) {
-    const buf = readFileSync(filePath);
-    // Use Bun.Image if available — resize + convert to JPEG
-    if (typeof Bun !== "undefined" && typeof Bun.Image !== "undefined") {
-        try {
-            const img = new Bun.Image(buf);
-            const { width } = await img.metadata();
-            const targetWidth = Math.min(800, width || 800);
-            const dataUrl = await img
-                .resize(targetWidth, 800, { fit: "inside" })
-                .jpeg({ quality: 60 })
-                .dataurl();
-            return { dataUrl };
-        }
-        catch {
-            // Bun.Image failed — fall through to raw base64
-        }
-    }
-    // Fallback: raw base64 (no resize)
-    const b64 = buf.toString("base64");
-    const ext = filePath.split(".").pop()?.toLowerCase();
-    const mime = ext === "jpg" || ext === "jpeg" ? "image/jpeg" : ext === "webp" ? "image/webp" : "image/png";
-    return { dataUrl: `data:${mime};base64,${b64}` };
-}
-/**
- * Load an image from a URL, resize, return as JPEG data URL.
- */
-export async function loadUrlAsDataUrl(url) {
-    const resp = await fetch(url);
-    if (!resp.ok) {
-        throw new Error(`Failed to fetch image: ${resp.status} ${resp.statusText}`);
-    }
-    const buf = Buffer.from(await resp.arrayBuffer());
-    if (typeof Bun !== "undefined" && typeof Bun.Image !== "undefined") {
-        try {
-            const img = new Bun.Image(buf);
-            const { width } = await img.metadata();
-            const targetWidth = Math.min(800, width || 800);
-            const dataUrl = await img
-                .resize(targetWidth, 800, { fit: "inside" })
-                .jpeg({ quality: 60 })
-                .dataurl();
-            return { dataUrl };
-        }
-        catch {
-            // fall through
-        }
-    }
-    const b64 = buf.toString("base64");
-    return { dataUrl: `data:image/png;base64,${b64}` };
-}
-/**
- * Process a clipboard buffer (already resized by readClipboardImage)
- * into a data URL. Used by Ctrl+V handler.
- */
-export async function bufferToDataUrl(buf) {
-    if (typeof Bun !== "undefined" && typeof Bun.Image !== "undefined") {
-        try {
-            const img = new Bun.Image(buf);
-            const { width } = await img.metadata();
-            const targetWidth = Math.min(800, width || 800);
-            const dataUrl = await img
-                .resize(targetWidth, 800, { fit: "inside" })
-                .jpeg({ quality: 60 })
-                .dataurl();
-            return { dataUrl };
-        }
-        catch {
-            // fall through
-        }
-    }
-    const b64 = buf.toString("base64");
-    return { dataUrl: `data:image/png;base64,${b64}` };
-}

package/dist/llm/index.js

@@ -1,4 +0,0 @@
-export { OpenAICompatProvider } from './openai-compat';
-export { TokenCounter } from './token-counter';
-export { parseChunks } from './response';
-export { OrchestratorClient } from './orchestrator';

package/dist/llm/model-loader.js

@@ -1,78 +0,0 @@
-export class ModelLoader {
-    baseUrl;
-    logger;
-    constructor(baseUrl, logger) {
-        const url = baseUrl.replace(/\/$/, '');
-        this.baseUrl = url.replace(/\/v1\/?$/, '');
-        this.logger = logger;
-    }
-    async ensureModelLoaded(config) {
-        if (config.autoLoad === false) {
-            return { success: true, alreadyLoaded: true };
-        }
-        try {
-            const isLoaded = await this.isModelLoaded(config.model, config.contextLength);
-            if (isLoaded) {
-                this.logger.debug(`Model ${config.model} already loaded with correct context`);
-                return { success: true, alreadyLoaded: true };
-            }
-            return await this.loadModel(config);
-        }
-        catch (err) {
-            this.logger.error(`Model loader failed: ${err.message}`);
-            return { success: false, error: err.message };
-        }
-    }
-    async isModelLoaded(model, contextLength) {
-        try {
-            const response = await fetch(`${this.baseUrl}/api/v1/models`, {
-                signal: AbortSignal.timeout(3000),
-            });
-            if (!response.ok)
-                return false;
-            const data = await response.json();
-            const models = data.models || [];
-            const found = models.find((m) => m.key === model || m.name === model);
-            if (!found)
-                return false;
-            const loadedInstances = found.loaded_instances || [];
-            return loadedInstances.some((inst) => inst.config?.context_length === contextLength);
-        }
-        catch {
-            return false;
-        }
-    }
-    async loadModel(config) {
-        const body = {
-            model: config.model,
-            context_length: config.contextLength,
-        };
-        if (config.flashAttention !== undefined)
-            body.flash_attention = config.flashAttention;
-        if (config.evalBatchSize !== undefined)
-            body.eval_batch_size = config.evalBatchSize;
-        if (config.offloadKvCacheToGpu !== undefined)
-            body.offload_kv_cache_to_gpu = config.offloadKvCacheToGpu;
-        this.logger.info(`Loading model ${config.model} with context_length=${config.contextLength}`);
-        this.logger.debug(`POST ${this.baseUrl}/api/v1/models/load`);
-        const response = await fetch(`${this.baseUrl}/api/v1/models/load`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(body),
-            signal: AbortSignal.timeout(120000),
-        });
-        if (!response.ok) {
-            const error = await response.text();
-            this.logger.error(`Model load failed: HTTP ${response.status}: ${error}`);
-            return { success: false, error: `HTTP ${response.status}: ${error}` };
-        }
-        const result = await response.json();
-        this.logger.debug(`Model load response: ${JSON.stringify(result)}`);
-        const loadTime = result.load_time_seconds ?? result.loadTime;
-        return {
-            success: true,
-            alreadyLoaded: false,
-            loadTime,
-        };
-    }
-}

package/dist/llm/openai-compat.js

@@ -1,324 +0,0 @@
-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();
-        let usage;
-        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) {
-                            // 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 (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
-                    }
-                }
-            }
-            if (usage) {
-                yield { type: "done", usage };
-            }
-        }
-        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();
-                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) {
-            throw err instanceof Error ? err : new Error(String(err));
-        }
-    }
-    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) {
-                return [];
-            }
-            const data = (await response.json());
-            const models = (data.data || data || [])
-                .map((m) => m.id || m.name || m.model || "")
-                .filter(Boolean);
-            return models;
-        }
-        catch {
-            return [];
-        }
-    }
-    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));
-    }
-}