min-agent 0.5.0 → 0.5.1

package/dist/ollama-model.js

@@ -0,0 +1,234 @@
+import { readFileSync, mkdirSync, existsSync } from "fs";
+import path from "path";
+import { getActiveProvider, getConfigDir, getEffectiveConfig } from "./config.js";
+import { atomicWriteFileSync } from "./tools/atomic-file.js";
+const OLLAMA_ENTRY_VERSION = 2;
+const CACHE_TTL = 7 * 24 * 60 * 60 * 1000;
+const NEGATIVE_TTL = 60 * 60 * 1000;
+const FETCH_TIMEOUT_MS = 8000;
+const OLLAMA_MIN_CONTEXT = 512;
+/** Native Ollama default when /api/show has no num_ctx and no architecture length. */
+export const OLLAMA_DEFAULT_CONTEXT_WINDOW = 2048;
+/** Architecture max is not the loaded window; cap what we request/display for agents. */
+export const OLLAMA_AGENT_CONTEXT_CAP = 32_768;
+const memoryCache = new Map();
+const inFlight = new Map();
+const negativeCache = new Map();
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+export function ollamaNativeBase(baseURL) {
+    return baseURL.replace(/\/$/, "").replace(/\/v1$/i, "");
+}
+export function ollamaModelCacheKey(baseURL, modelId) {
+    let host = "";
+    try {
+        host = new URL(baseURL).hostname.toLowerCase();
+    }
+    catch {
+        host = ollamaNativeBase(baseURL).toLowerCase();
+    }
+    const model = modelId.trim().toLowerCase();
+    return host ? `${host}::${model}` : model;
+}
+function asContextTokens(value) {
+    const n = typeof value === "string" && value.trim() !== "" ? Number(value) : value;
+    if (typeof n !== "number" || !Number.isFinite(n) || n < OLLAMA_MIN_CONTEXT)
+        return undefined;
+    return Math.floor(n);
+}
+function contextFromModelInfo(info) {
+    const found = [];
+    for (const [key, value] of Object.entries(info)) {
+        if (key === "context_length" || key.endsWith(".context_length")) {
+            const n = asContextTokens(value);
+            if (n != null)
+                found.push(n);
+        }
+    }
+    if (found.length === 0)
+        return undefined;
+    return Math.max(...found);
+}
+function numCtxFromParameters(raw) {
+    if (typeof raw === "number")
+        return asContextTokens(raw);
+    if (isRecord(raw))
+        return asContextTokens(raw.num_ctx);
+    if (typeof raw !== "string")
+        return undefined;
+    const match = raw.match(/(?:^|\n)\s*num_ctx\s+(\d+)/);
+    if (match?.[1])
+        return asContextTokens(Number(match[1]));
+    return asContextTokens(raw);
+}
+function thinkingFromCapabilities(raw) {
+    if (!Array.isArray(raw))
+        return null;
+    return raw.some((item) => String(item).toLowerCase() === "thinking");
+}
+export function ollamaOperationalContext(numCtx, architecture) {
+    if (numCtx != null)
+        return numCtx;
+    if (architecture != null)
+        return Math.min(architecture, OLLAMA_AGENT_CONTEXT_CAP);
+    return undefined;
+}
+export function applyOllamaChatOptions(body, numCtx) {
+    const prev = isRecord(body.options) ? body.options : {};
+    return {
+        ...body,
+        options: { ...prev, num_ctx: numCtx },
+    };
+}
+export function ollamaThinkValue(spec, modelThinking) {
+    if (modelThinking === false)
+        return false;
+    if (!spec)
+        return undefined;
+    if (!spec.thinkingEnabled)
+        return false;
+    const effort = spec.reasoningEffort;
+    if (effort === "low" || effort === "medium" || effort === "high")
+        return effort;
+    if (effort === "none")
+        return false;
+    return "high";
+}
+export function resolveOllamaNumCtx(modelId, requestUrl) {
+    const provider = getActiveProvider(getEffectiveConfig());
+    if (typeof provider?.contextWindow === "number" &&
+        Number.isFinite(provider.contextWindow) &&
+        provider.contextWindow >= OLLAMA_MIN_CONTEXT) {
+        return Math.floor(provider.contextWindow);
+    }
+    const cached = getCachedOllamaModel(modelId, requestUrl ?? provider?.baseURL);
+    return cached?.contextWindow ?? OLLAMA_DEFAULT_CONTEXT_WINDOW;
+}
+export function parseOllamaShow(payload, modelId) {
+    const root = isRecord(payload) ? payload : {};
+    const modelInfo = isRecord(root.model_info) ? root.model_info : {};
+    const contextWindow = ollamaOperationalContext(numCtxFromParameters(root.parameters), contextFromModelInfo(modelInfo));
+    return {
+        version: OLLAMA_ENTRY_VERSION,
+        modelId,
+        ...(contextWindow != null ? { contextWindow } : {}),
+        thinking: thinkingFromCapabilities(root.capabilities),
+        timestamp: Date.now(),
+    };
+}
+export function thinkingChoicesFromOllama(info) {
+    if (info.thinking === false)
+        return ["off"];
+    return ["off", "low", "medium", "high", "max"];
+}
+function cacheFile() {
+    return path.join(getConfigDir(), "ollama-model-cache.json");
+}
+function loadDiskCache() {
+    const file = cacheFile();
+    if (!existsSync(file))
+        return {};
+    try {
+        const parsed = JSON.parse(readFileSync(file, "utf-8"));
+        if (!isRecord(parsed))
+            return {};
+        const out = {};
+        for (const [key, value] of Object.entries(parsed)) {
+            if (!isRecord(value) || value.version !== OLLAMA_ENTRY_VERSION)
+                continue;
+            if (typeof value.modelId !== "string")
+                continue;
+            const thinking = value.thinking === true || value.thinking === false ? value.thinking : null;
+            const contextWindow = asContextTokens(value.contextWindow);
+            const timestamp = typeof value.timestamp === "number" ? value.timestamp : 0;
+            out[key] = {
+                version: OLLAMA_ENTRY_VERSION,
+                modelId: value.modelId,
+                ...(contextWindow != null ? { contextWindow } : {}),
+                thinking,
+                timestamp,
+            };
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
+function saveDiskCache(cache) {
+    const file = cacheFile();
+    mkdirSync(path.dirname(file), { recursive: true });
+    atomicWriteFileSync(file, JSON.stringify(cache));
+}
+export function clearOllamaModelCache() {
+    memoryCache.clear();
+    inFlight.clear();
+    negativeCache.clear();
+}
+export function getCachedOllamaModel(modelId, baseURL) {
+    const key = ollamaModelCacheKey(baseURL ?? "", modelId);
+    const memory = memoryCache.get(key);
+    if (memory && memory.version === OLLAMA_ENTRY_VERSION && Date.now() - memory.timestamp <= CACHE_TTL)
+        return memory;
+    const disk = loadDiskCache()[key];
+    if (!disk || disk.version !== OLLAMA_ENTRY_VERSION || Date.now() - disk.timestamp > CACHE_TTL)
+        return null;
+    memoryCache.set(key, disk);
+    return disk;
+}
+function setCache(key, entry) {
+    memoryCache.set(key, entry);
+    const cache = loadDiskCache();
+    cache[key] = entry;
+    saveDiskCache(cache);
+}
+async function fetchShow(baseURL, modelId) {
+    try {
+        const response = await fetch(`${ollamaNativeBase(baseURL)}/api/show`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ name: modelId }),
+            signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+        });
+        if (!response.ok)
+            return null;
+        return await response.json();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Load context window and thinking capability from a user-configured Ollama
+ * provider via native POST /api/show. Cached 7 days after a successful lookup.
+ */
+export async function getOllamaModel(modelId, baseURL) {
+    const url = baseURL ?? "";
+    const key = ollamaModelCacheKey(url, modelId);
+    const cached = getCachedOllamaModel(modelId, url);
+    if (cached)
+        return cached;
+    const negAt = negativeCache.get(key);
+    if (negAt !== undefined && Date.now() - negAt <= NEGATIVE_TTL)
+        return null;
+    const pending = inFlight.get(key);
+    if (pending)
+        return pending;
+    const probing = fetchShow(url, modelId).then((payload) => {
+        if (!payload) {
+            negativeCache.set(key, Date.now());
+            return null;
+        }
+        const entry = parseOllamaShow(payload, modelId);
+        setCache(key, entry);
+        return entry;
+    });
+    inFlight.set(key, probing);
+    try {
+        return await probing;
+    }
+    finally {
+        inFlight.delete(key);
+    }
+}

package/dist/ollama-openai-bridge.js

@@ -0,0 +1,383 @@
+import { applyOllamaChatOptions, getCachedOllamaModel, ollamaNativeBase, ollamaThinkValue, resolveOllamaNumCtx, } from "./ollama-model.js";
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+export function requestHref(input) {
+    return typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+}
+export function isOllamaChatCompletionsUrl(href) {
+    try {
+        return /\/chat\/completions\/?$/i.test(new URL(href).pathname);
+    }
+    catch {
+        return /\/chat\/completions\/?$/i.test(href);
+    }
+}
+export function ollamaNativeChatUrl(href) {
+    const stripped = href.replace(/\/v1\/chat\/completions\/?$/i, "").replace(/\/chat\/completions\/?$/i, "");
+    return `${ollamaNativeBase(stripped)}/api/chat`;
+}
+export async function readFetchBody(body) {
+    if (body == null)
+        return null;
+    if (typeof body === "string")
+        return body;
+    if (body instanceof Uint8Array)
+        return new TextDecoder().decode(body);
+    if (body instanceof ArrayBuffer)
+        return new TextDecoder().decode(body);
+    if (Buffer?.isBuffer(body))
+        return body.toString("utf8");
+    if (typeof Blob !== "undefined" && body instanceof Blob)
+        return await body.text();
+    if (typeof ReadableStream !== "undefined" && body instanceof ReadableStream) {
+        const reader = body.getReader();
+        const chunks = [];
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (value)
+                chunks.push(value);
+        }
+        const total = chunks.reduce((n, c) => n + c.length, 0);
+        const out = new Uint8Array(total);
+        let offset = 0;
+        for (const chunk of chunks) {
+            out.set(chunk, offset);
+            offset += chunk.length;
+        }
+        return new TextDecoder().decode(out);
+    }
+    return null;
+}
+function dataUrlBase64(url) {
+    const match = url.match(/^data:[^;]+;base64,(.+)$/s);
+    return match?.[1] ?? null;
+}
+function textFromContent(content) {
+    if (typeof content === "string")
+        return { text: content, images: [] };
+    if (!Array.isArray(content))
+        return { text: content == null ? "" : JSON.stringify(content), images: [] };
+    const texts = [];
+    const images = [];
+    for (const part of content) {
+        if (!isRecord(part))
+            continue;
+        if (part.type === "text" && typeof part.text === "string")
+            texts.push(part.text);
+        else if (part.type === "image_url") {
+            const image = isRecord(part.image_url) ? part.image_url.url : undefined;
+            if (typeof image === "string") {
+                const b64 = dataUrlBase64(image);
+                if (b64)
+                    images.push(b64);
+            }
+        }
+        else if (typeof part.text === "string")
+            texts.push(part.text);
+    }
+    return { text: texts.join("\n"), images };
+}
+function argsAsObject(raw) {
+    if (isRecord(raw))
+        return raw;
+    if (typeof raw !== "string" || !raw.trim())
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        return isRecord(parsed) ? parsed : { value: parsed };
+    }
+    catch {
+        return { value: raw };
+    }
+}
+function argsAsString(raw) {
+    if (typeof raw === "string")
+        return raw;
+    try {
+        return JSON.stringify(raw ?? {});
+    }
+    catch {
+        return "{}";
+    }
+}
+function convertToolCallsOut(raw) {
+    if (!Array.isArray(raw) || raw.length === 0)
+        return undefined;
+    return raw.map((item) => {
+        const rec = isRecord(item) ? item : {};
+        const fn = isRecord(rec.function) ? rec.function : rec;
+        return {
+            function: {
+                name: typeof fn.name === "string" ? fn.name : "",
+                arguments: argsAsObject(fn.arguments),
+            },
+        };
+    });
+}
+export function openaiMessagesToOllama(messages) {
+    if (!Array.isArray(messages))
+        return [];
+    return messages.map((item) => {
+        const rec = isRecord(item) ? item : {};
+        const { text, images } = textFromContent(rec.content);
+        const out = {
+            role: typeof rec.role === "string" ? rec.role : "user",
+            content: text,
+        };
+        if (images.length > 0)
+            out.images = images;
+        const toolCalls = convertToolCallsOut(rec.tool_calls);
+        if (toolCalls)
+            out.tool_calls = toolCalls;
+        return out;
+    });
+}
+function copySampling(body) {
+    const options = isRecord(body.options) ? { ...body.options } : {};
+    if (typeof body.temperature === "number")
+        options.temperature = body.temperature;
+    if (typeof body.top_p === "number")
+        options.top_p = body.top_p;
+    if (typeof body.seed === "number")
+        options.seed = body.seed;
+    if (typeof body.max_tokens === "number")
+        options.num_predict = body.max_tokens;
+    if (typeof body.max_completion_tokens === "number")
+        options.num_predict = body.max_completion_tokens;
+    if (Array.isArray(body.stop) || typeof body.stop === "string")
+        options.stop = body.stop;
+    return options;
+}
+export function openaiChatToOllamaNative(body, opts) {
+    const native = {
+        model: body.model,
+        messages: openaiMessagesToOllama(body.messages),
+        stream: body.stream !== false,
+        options: copySampling(body),
+    };
+    if (Array.isArray(body.tools) && body.tools.length > 0)
+        native.tools = body.tools;
+    if (body.format != null)
+        native.format = body.format;
+    if (opts.think !== undefined)
+        native.think = opts.think;
+    return applyOllamaChatOptions(native, opts.numCtx);
+}
+function finishReasonFor(doneReason, toolCalls) {
+    if (Array.isArray(toolCalls) && toolCalls.length > 0)
+        return "tool_calls";
+    if (doneReason === "length" || doneReason === "max_tokens")
+        return "length";
+    return "stop";
+}
+function usageFromNative(row) {
+    const prompt = typeof row.prompt_eval_count === "number" ? row.prompt_eval_count : undefined;
+    const completion = typeof row.eval_count === "number" ? row.eval_count : undefined;
+    if (prompt == null && completion == null)
+        return undefined;
+    const promptTokens = prompt ?? 0;
+    const completionTokens = completion ?? 0;
+    return {
+        prompt_tokens: promptTokens,
+        completion_tokens: completionTokens,
+        total_tokens: promptTokens + completionTokens,
+    };
+}
+function openaiToolCallDeltas(raw) {
+    if (!Array.isArray(raw) || raw.length === 0)
+        return undefined;
+    return raw.map((item, index) => {
+        const rec = isRecord(item) ? item : {};
+        const fn = isRecord(rec.function) ? rec.function : rec;
+        const id = typeof rec.id === "string" && rec.id ? rec.id : `ollama_call_${index}`;
+        return {
+            index,
+            id,
+            type: "function",
+            function: {
+                name: typeof fn.name === "string" ? fn.name : "",
+                arguments: argsAsString(fn.arguments),
+            },
+        };
+    });
+}
+export function nativeChatRowToOpenAIChunk(row, state) {
+    const message = isRecord(row.message) ? row.message : {};
+    const content = typeof message.content === "string" ? message.content : "";
+    const thinking = typeof message.thinking === "string" ? message.thinking : "";
+    const toolCalls = openaiToolCallDeltas(message.tool_calls);
+    const done = row.done === true;
+    const delta = {};
+    if (!state.sentRole) {
+        delta.role = "assistant";
+        state.sentRole = true;
+    }
+    if (thinking)
+        delta.reasoning = thinking;
+    if (content)
+        delta.content = content;
+    if (toolCalls)
+        delta.tool_calls = toolCalls;
+    const chunk = {
+        id: "chatcmpl-ollama",
+        object: "chat.completion.chunk",
+        created: Math.floor(Date.now() / 1000),
+        model: typeof row.model === "string" ? row.model : "",
+        choices: [
+            {
+                index: 0,
+                delta,
+                finish_reason: done ? finishReasonFor(row.done_reason, message.tool_calls) : null,
+            },
+        ],
+    };
+    const usage = usageFromNative(row);
+    if (usage)
+        chunk.usage = usage;
+    return chunk;
+}
+export function nativeChatToOpenAIResponse(row) {
+    const message = isRecord(row.message) ? row.message : {};
+    const content = typeof message.content === "string" ? message.content : "";
+    const thinking = typeof message.thinking === "string" ? message.thinking : "";
+    const toolCalls = openaiToolCallDeltas(message.tool_calls);
+    const assistant = { role: "assistant", content };
+    if (thinking)
+        assistant.reasoning = thinking;
+    if (toolCalls)
+        assistant.tool_calls = toolCalls;
+    const out = {
+        id: "chatcmpl-ollama",
+        object: "chat.completion",
+        created: Math.floor(Date.now() / 1000),
+        model: typeof row.model === "string" ? row.model : "",
+        choices: [
+            {
+                index: 0,
+                message: assistant,
+                finish_reason: finishReasonFor(row.done_reason, message.tool_calls),
+            },
+        ],
+    };
+    const usage = usageFromNative(row);
+    if (usage)
+        out.usage = usage;
+    return out;
+}
+function sseLine(payload) {
+    return `data: ${JSON.stringify(payload)}\n\n`;
+}
+export function transformOllamaNdjsonToSse(source) {
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    const reader = source.getReader();
+    const state = { sentRole: false };
+    let pending = "";
+    return new ReadableStream({
+        async pull(controller) {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    pending += decoder.decode();
+                    const leftover = pending.trim();
+                    if (leftover) {
+                        try {
+                            const parsed = JSON.parse(leftover);
+                            if (isRecord(parsed))
+                                controller.enqueue(encoder.encode(sseLine(nativeChatRowToOpenAIChunk(parsed, state))));
+                        }
+                        catch {
+                            /* ignore trailing garbage */
+                        }
+                    }
+                    controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+                    controller.close();
+                    return;
+                }
+                pending += decoder.decode(value, { stream: true });
+                const nl = pending.lastIndexOf("\n");
+                if (nl < 0)
+                    continue;
+                const complete = pending.slice(0, nl + 1);
+                pending = pending.slice(nl + 1);
+                const out = [];
+                for (const line of complete.split("\n")) {
+                    const trimmed = line.trim();
+                    if (!trimmed)
+                        continue;
+                    try {
+                        const parsed = JSON.parse(trimmed);
+                        if (isRecord(parsed))
+                            out.push(sseLine(nativeChatRowToOpenAIChunk(parsed, state)));
+                    }
+                    catch {
+                        /* skip malformed native lines */
+                    }
+                }
+                if (out.length > 0) {
+                    controller.enqueue(encoder.encode(out.join("")));
+                    return;
+                }
+            }
+        },
+        cancel(reason) {
+            return reader.cancel(reason);
+        },
+    });
+}
+function jsonHeaders(headers) {
+    const next = new Headers(headers);
+    next.set("content-type", "application/json");
+    return next;
+}
+function sseHeaders(headers) {
+    const next = new Headers(headers);
+    next.set("content-type", "text/event-stream");
+    next.delete("content-length");
+    return next;
+}
+export async function fetchOllamaNativeChat(inner, input, init, body, spec) {
+    const href = requestHref(input);
+    if (!isOllamaChatCompletionsUrl(href)) {
+        return inner(input, { ...init, body: JSON.stringify(body) });
+    }
+    const modelId = typeof body.model === "string" ? body.model : "";
+    const cached = getCachedOllamaModel(modelId, href);
+    const nativeBody = openaiChatToOllamaNative(body, {
+        numCtx: resolveOllamaNumCtx(modelId, href),
+        think: ollamaThinkValue(spec, cached?.thinking ?? null),
+    });
+    const response = await inner(ollamaNativeChatUrl(href), {
+        ...init,
+        method: init.method ?? "POST",
+        headers: { ...Object.fromEntries(new Headers(init.headers).entries()), "Content-Type": "application/json" },
+        body: JSON.stringify(nativeBody),
+    });
+    if (response.status >= 400)
+        return response;
+    const streaming = body.stream !== false;
+    if (!streaming) {
+        try {
+            const payload = await response.json();
+            const converted = isRecord(payload) ? nativeChatToOpenAIResponse(payload) : nativeChatToOpenAIResponse({});
+            return new Response(JSON.stringify(converted), {
+                status: response.status,
+                statusText: response.statusText,
+                headers: jsonHeaders(response.headers),
+            });
+        }
+        catch {
+            return response;
+        }
+    }
+    if (!response.body)
+        return response;
+    return new Response(transformOllamaNdjsonToSse(response.body), {
+        status: response.status,
+        statusText: response.statusText,
+        headers: sseHeaders(response.headers),
+    });
+}

package/dist/serve/routes-meta.js

@@ -5,6 +5,7 @@ import { readScope } from "../scope.js";
 import { getWorkingTreeDiff } from "../tui/diff-view.js";
 import { scanProject } from "../code-mode.js";
 import { getContextWindowInfo } from "../context-window.js";
+import { parseCtxChoice, setOllamaContextChoice, ctxPayload, CTX_CHOICES } from "../ctx.js";
 import { getModelPrice, estimateCost } from "../pricing.js";
 import { checkForUpdate } from "../updater.js";
 import { sendJson, sendJsonError, readJsonBody, readStringPathList, sandboxPayload, permissionPayload, thinkingPayload, memoryPayload, } from "./common.js";
@@ -209,6 +210,40 @@ export const handleMetaRoutes = async (req, res, ctx, url, pathname) => {
             context_window: info.tokens,
             source: info.source,
             model: provider?.defaultModel ?? null,
+            ...ctxPayload(),
+        });
+        return true;
+    }
+    if (req.method === "POST" && pathname === "/v1/context") {
+        const parsed = await readJsonBody(req);
+        if (!parsed.ok) {
+            sendJsonError(res, parsed);
+            return true;
+        }
+        const choice = typeof parsed.value.level === "string" ? parseCtxChoice(parsed.value.level) : null;
+        if (!choice) {
+            sendJson(res, 400, {
+                error: "invalid_context_level",
+                detail: `level must be one of: ${CTX_CHOICES.join(", ")}`,
+            });
+            return true;
+        }
+        const result = setOllamaContextChoice(choice);
+        if (!result.ok) {
+            sendJson(res, 400, {
+                error: "ctx_not_supported",
+                detail: "context levels are only available for an Ollama provider",
+            });
+            return true;
+        }
+        const provider = getActiveProvider(getEffectiveConfig());
+        const info = await getContextWindowInfo(provider?.defaultModel);
+        sendJson(res, 200, {
+            ok: true,
+            context_window: info.tokens,
+            source: info.source,
+            model: provider?.defaultModel ?? null,
+            ...ctxPayload(),
         });
         return true;
     }