micro-models-agent 0.28.9 → 0.29.0

package/dist/llm/image-utils.js

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

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

package/dist/llm/model-loader.js

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

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