min-agent 0.5.1 → 0.6.0

package/dist/ollama-model.js

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

@@ -1,383 +0,0 @@
-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/output.js

@@ -1,76 +0,0 @@
-import { loadConfig, getActiveProvider } from "./config.js";
-import { summarizeToolCall, toolResultText, truncateDisplay } from "./tool-display.js";
-const COLORS = {
-    reset: "\x1b[0m",
-    dim: "\x1b[2m",
-    bold: "\x1b[1m",
-    cyan: "\x1b[36m",
-    green: "\x1b[32m",
-    yellow: "\x1b[33m",
-    red: "\x1b[31m",
-    magenta: "\x1b[35m",
-    gray: "\x1b[90m",
-};
-export function printHeader(modelId) {
-    const model = modelId ?? getActiveProvider(loadConfig())?.defaultModel ?? "unknown";
-    console.log(`${COLORS.bold}🤖 min-agent${COLORS.reset} ${COLORS.dim}(${model})${COLORS.reset}`);
-}
-export function printDivider() {
-    console.log(`${COLORS.dim}${"─".repeat(60)}${COLORS.reset}`);
-}
-export function printToolCall(name, input) {
-    const argsStr = summarizeToolCall(name, input, 160);
-    console.log(`\n${COLORS.yellow}⚡ ${name}${COLORS.reset} ${COLORS.dim}${argsStr}${COLORS.reset}`);
-}
-/** Console preview limits for a tool result (the full text goes to the model). */
-const RESULT_PREVIEW_MAX_LINES = 20;
-const RESULT_PREVIEW_MAX_CHARS = 1200;
-/**
- * Print a tool result preview. Lines are kept whole and both limits are
- * applied in one pass, so the "N more lines" count always matches what was
- * actually withheld.
- */
-export function printToolResult(_name, result, isError = false) {
-    const text = toolResultText(result).replace(/\s+$/, "");
-    const lines = text === "" ? [] : text.split("\n");
-    const kept = [];
-    let chars = 0;
-    for (const line of lines) {
-        if (kept.length >= RESULT_PREVIEW_MAX_LINES)
-            break;
-        if (chars + line.length > RESULT_PREVIEW_MAX_CHARS)
-            break;
-        kept.push(line);
-        chars += line.length + 1;
-    }
-    // A single very long first line still deserves a preview.
-    if (kept.length === 0 && lines.length > 0) {
-        kept.push(truncateDisplay(lines[0], RESULT_PREVIEW_MAX_CHARS));
-    }
-    const hidden = lines.length - kept.length;
-    const suffix = hidden > 0 ? ` (${hidden} more line${hidden === 1 ? "" : "s"})` : "";
-    const marker = isError ? `${COLORS.red}  ✗${COLORS.reset}` : `${COLORS.green}  ✓${COLORS.reset}`;
-    const body = kept.join(`\n${COLORS.dim}    `);
-    console.log(`${marker} ${COLORS.dim}${body}${suffix}${COLORS.reset}\n`);
-}
-export function printDone(steps, usage, contextWindow, contextTokens) {
-    const input = usage?.inputTokens ?? 0;
-    const output = usage?.outputTokens ?? 0;
-    const total = input + output;
-    const occupied = contextTokens !== undefined ? contextTokens : input;
-    let contextInfo = "";
-    if (occupied > 0 && contextWindow && contextWindow > 0) {
-        const pct = Math.round((occupied / contextWindow) * 100);
-        const bar = renderBar(pct);
-        contextInfo = ` | Context: ${bar} ${pct}%`;
-    }
-    console.log(`${COLORS.dim}Done in ${steps} step(s) | Tokens: ${input} in / ${output} out / ${total} total${contextInfo}${COLORS.reset}`);
-}
-function renderBar(pct) {
-    const width = 10;
-    const safePct = Math.max(0, Math.min(100, pct));
-    const filled = Math.round((safePct / 100) * width);
-    const empty = width - filled;
-    const color = pct >= 80 ? "\x1b[31m" : pct >= 50 ? "\x1b[33m" : "\x1b[32m";
-    return `${color}${"█".repeat(filled)}${"░".repeat(empty)}\x1b[0m\x1b[90m`;
-}