min-agent 0.2.1 → 0.4.0

package/dist/pricing.js

@@ -0,0 +1,119 @@
+import { readFileSync, mkdirSync, existsSync } from "fs";
+import path from "path";
+import { atomicWriteFileSync } from "./tools/atomic-file.js";
+import { getConfigDir, loadConfig } from "./config.js";
+const CACHE_TTL = 7 * 24 * 60 * 60 * 1000;
+const memoryCache = new Map();
+const inFlight = new Map();
+const NEGATIVE_TTL = 60 * 60 * 1000;
+const negativeCache = new Map();
+function cacheFile() {
+    return path.join(getConfigDir(), "pricing-cache.json");
+}
+function loadDiskCache() {
+    const file = cacheFile();
+    if (!existsSync(file))
+        return {};
+    try {
+        return JSON.parse(readFileSync(file, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function saveCache(cache) {
+    const file = cacheFile();
+    mkdirSync(path.dirname(file), { recursive: true });
+    atomicWriteFileSync(file, JSON.stringify(cache));
+}
+function getCached(modelId) {
+    const memory = memoryCache.get(modelId);
+    if (memory && Date.now() - memory.timestamp <= CACHE_TTL)
+        return memory;
+    const disk = loadDiskCache()[modelId];
+    if (disk && Date.now() - disk.timestamp <= CACHE_TTL) {
+        memoryCache.set(modelId, disk);
+        return disk;
+    }
+    return null;
+}
+function setCache(modelId, price) {
+    const entry = { price, timestamp: Date.now() };
+    memoryCache.set(modelId, entry);
+    const cache = loadDiskCache();
+    cache[modelId] = entry;
+    saveCache(cache);
+}
+function priceFromConfig(modelId) {
+    const override = loadConfig().pricing?.[modelId];
+    if (!override)
+        return null;
+    if (typeof override.inputPerMillion !== "number" || typeof override.outputPerMillion !== "number")
+        return null;
+    return { inputPerMillion: override.inputPerMillion, outputPerMillion: override.outputPerMillion };
+}
+async function fetchFromModelsDev(modelId) {
+    try {
+        const response = await fetch("https://models.dev/api.json", { signal: AbortSignal.timeout(10000) });
+        if (!response.ok)
+            return null;
+        const providers = (await response.json());
+        for (const provider of Object.values(providers)) {
+            if (!provider.models)
+                continue;
+            for (const [id, model] of Object.entries(provider.models)) {
+                if (id === modelId || id.endsWith(`/${modelId}`) || modelId.endsWith(`/${id}`)) {
+                    const p = model?.pricing;
+                    if (p && typeof p.input === "number" && typeof p.output === "number") {
+                        return { inputPerMillion: p.input, outputPerMillion: p.output };
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function getModelPrice(modelId) {
+    const override = priceFromConfig(modelId);
+    if (override)
+        return override;
+    const cached = getCached(modelId);
+    if (cached)
+        return cached.price;
+    const negAt = negativeCache.get(modelId);
+    if (negAt !== undefined && Date.now() - negAt <= NEGATIVE_TTL)
+        return null;
+    const pending = inFlight.get(modelId);
+    if (pending)
+        return pending;
+    const probing = fetchFromModelsDev(modelId).then((price) => {
+        if (price) {
+            setCache(modelId, price);
+        }
+        else {
+            negativeCache.set(modelId, Date.now());
+        }
+        return price;
+    });
+    inFlight.set(modelId, probing);
+    try {
+        return await probing;
+    }
+    finally {
+        inFlight.delete(modelId);
+    }
+}
+export function estimateCost(usage, price) {
+    if (!price)
+        return null;
+    const cost = (usage.inputTokens / 1_000_000) * price.inputPerMillion + (usage.outputTokens / 1_000_000) * price.outputPerMillion;
+    return cost > 0 ? cost : null;
+}
+export function formatCost(cost) {
+    if (cost === null)
+        return "--";
+    return cost >= 0.1 ? `$${cost.toFixed(3)}` : `$${cost.toFixed(4)}`;
+}

package/dist/provider.js

@@ -1,41 +1,60 @@
 import { createOpenAI } from "@ai-sdk/openai";
-import { loadConfig } from "./config.js";
-function normalizeOllamaBaseURL(baseURL) {
-    const trimmed = baseURL.replace(/\/$/, "");
-    return trimmed.endsWith("/v1") ? trimmed : `${trimmed}/v1`;
+import { getEffectiveConfig, getActiveProvider, normalizeOllamaBaseURL } from "./config.js";
+import { createTimeoutFetch, DEFAULT_FIRST_BYTE_TIMEOUT_MS, DEFAULT_STREAM_IDLE_TIMEOUT_MS, } from "./fetch-timeout.js";
+function positiveMs(raw, fallback) {
+    const value = typeof raw === "string" ? Number(raw) : raw;
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+        return fallback;
+    return value;
 }
-export function resolveModel(modelId) {
-    const config = loadConfig();
-    const provider = config.provider;
-    if (!provider?.baseURL || !provider?.apiKey) {
+/** Timeout/trace-aware fetch shared by every provider client. */
+export function modelFetch() {
+    const cfg = getEffectiveConfig();
+    return createTimeoutFetch({
+        firstByteTimeoutMs: positiveMs(process.env.MIN_AGENT_REQUEST_TIMEOUT_MS ?? cfg.agent?.requestTimeoutMs, DEFAULT_FIRST_BYTE_TIMEOUT_MS),
+        idleTimeoutMs: positiveMs(process.env.MIN_AGENT_STREAM_IDLE_TIMEOUT_MS ?? cfg.agent?.streamIdleTimeoutMs, DEFAULT_STREAM_IDLE_TIMEOUT_MS),
+        trace: process.env.MIN_AGENT_TRACE === "1" || process.env.MIN_AGENT_TRACE === "true",
+    });
+}
+export function resolveModelForProvider(provider, modelId) {
+    if (!provider.baseURL || !provider.apiKey) {
         throw new Error("Not configured. Run: min-agent setup");
     }
     const id = modelId ?? provider.defaultModel;
     if (!id) {
         throw new Error("No model specified. Run: min-agent setup");
     }
-    const type = provider.type ?? "openai-compatible";
-    switch (type) {
+    const fetchImpl = modelFetch();
+    switch (provider.type ?? "openai-compatible") {
         case "openai": {
-            const client = createOpenAI({ apiKey: provider.apiKey });
+            const client = createOpenAI({ apiKey: provider.apiKey, fetch: fetchImpl });
             return client.chat(id);
         }
         case "ollama": {
-            // Ollama exposes an OpenAI-compatible API at /v1.
-            // Accept both "...:11434" and "...:11434/v1" in user config.
             const client = createOpenAI({
                 baseURL: normalizeOllamaBaseURL(provider.baseURL),
                 apiKey: provider.apiKey || "ollama",
+                fetch: fetchImpl,
             });
             return client.chat(id);
         }
-        case "openai-compatible":
-        default: {
+        case "openai-compatible": {
             const client = createOpenAI({
                 baseURL: provider.baseURL,
                 apiKey: provider.apiKey,
+                fetch: fetchImpl,
             });
             return client.chat(id);
         }
+        default:
+            throw new Error(`Unknown provider type: ${provider.type}`);
+    }
+}
+export function resolveModel(modelId, providerName) {
+    const config = getEffectiveConfig();
+    const provider = providerName ? config.providers?.find((p) => p.name === providerName) : getActiveProvider(config);
+    if (!provider) {
+        throw new Error(providerName ? `Provider "${providerName}" not found` : "Not configured. Run: min-agent setup");
     }
+    return resolveModelForProvider(provider, modelId);
 }

package/dist/question-format.js

@@ -0,0 +1,60 @@
+const OPTION_TEXT_KEYS = ["label", "description", "title", "text", "value", "content", "prompt"];
+function firstText(rec, keys) {
+    const parts = [];
+    const seen = new Set();
+    for (const key of keys) {
+        const v = rec[key];
+        if (typeof v !== "string")
+            continue;
+        const text = v.trim();
+        if (!text || seen.has(text))
+            continue;
+        seen.add(text);
+        parts.push(text);
+    }
+    return parts;
+}
+/** Pull a user-visible label out of a model-supplied question option. */
+export function optionText(item) {
+    if (item == null)
+        return null;
+    if (typeof item === "string") {
+        const text = item.trim();
+        return text.length > 0 ? text : null;
+    }
+    if (typeof item === "number" || typeof item === "boolean")
+        return String(item);
+    if (typeof item !== "object" || Array.isArray(item))
+        return null;
+    const rec = item;
+    const parts = firstText(rec, OPTION_TEXT_KEYS);
+    if (parts.length > 0)
+        return parts.join(" — ");
+    const key = rec.key;
+    return typeof key === "string" && key.trim() ? key.trim() : null;
+}
+export function normalizeQuestionPrompt(question) {
+    if (typeof question === "string")
+        return question;
+    return optionText(question) ?? "";
+}
+/**
+ * Models often send `{label, description, key}` (Claude-style) instead of
+ * `string[]`. Normalize to display strings so the TUI never calls string
+ * methods on objects.
+ */
+export function normalizeQuestionOptions(options) {
+    if (options == null)
+        return [];
+    const list = Array.isArray(options) ? options : [options];
+    const out = [];
+    const seen = new Set();
+    for (const item of list) {
+        const text = optionText(item);
+        if (!text || seen.has(text))
+            continue;
+        seen.add(text);
+        out.push(text);
+    }
+    return out;
+}

package/dist/sandbox-cli.js

@@ -0,0 +1,82 @@
+import { takeScopeFlags } from "./memory.js";
+import { getSandboxSnapshot, setSandboxConfig } from "./config.js";
+import { parseNetworkPolicy, parseSandboxMode, getEffectiveSandboxPolicy, sandboxEnforcementCaveat, sandboxModeLabel, sandboxStatusLabel, setSandboxOverride, } from "./sandbox.js";
+export const SANDBOX_CLI_USAGE = [
+    "Usage: min-agent sandbox [off|workspace|strict] [--project|--global]",
+    "       min-agent sandbox network allow|deny [--project|--global]",
+    "       min-agent --sandbox off|workspace|strict [--project|--global]",
+].join("\n");
+function sourceLabel(source) {
+    return source === "cli"
+        ? "this run"
+        : source === "env"
+            ? "environment variable"
+            : source === "project"
+                ? "project"
+                : source === "global"
+                    ? "global"
+                    : "default";
+}
+function scopeLabel(scope) {
+    return scope === "project" ? "project" : "global";
+}
+export function runSandboxCli(input) {
+    const { scope: posScope, rest } = takeScopeFlags(input.positionals);
+    const scope = posScope ?? input.scope ?? "global";
+    if (rest[0] === "--help" || rest[0] === "-h") {
+        return { ok: true, lines: [SANDBOX_CLI_USAGE] };
+    }
+    if (rest[0] === "network") {
+        const parsed = parseNetworkPolicy(rest[1]);
+        if (!parsed || rest.length > 2)
+            return { ok: false, lines: [SANDBOX_CLI_USAGE] };
+        setSandboxConfig({ network: parsed }, scope);
+        setSandboxOverride({ network: parsed });
+        return { ok: true, lines: [`✓ Network set to ${parsed === "deny" ? "denied" : "allowed"} (${scopeLabel(scope)})`] };
+    }
+    if (rest.length === 1) {
+        const parsed = parseSandboxMode(rest[0]);
+        if (!parsed)
+            return { ok: false, lines: [SANDBOX_CLI_USAGE] };
+        setSandboxConfig({ mode: parsed }, scope);
+        setSandboxOverride({ mode: parsed });
+        const caveat = sandboxEnforcementCaveat(parsed);
+        return {
+            ok: true,
+            lines: [`✓ Sandbox set to ${sandboxModeLabel(parsed)} (${scopeLabel(scope)})`, ...(caveat ? [caveat] : [])],
+        };
+    }
+    if (rest.length > 1)
+        return { ok: false, lines: [SANDBOX_CLI_USAGE] };
+    if (input.flagMode || input.flagNetwork) {
+        setSandboxConfig({
+            ...(input.flagMode ? { mode: input.flagMode } : {}),
+            ...(input.flagNetwork ? { network: input.flagNetwork } : {}),
+        }, scope);
+        setSandboxOverride({
+            ...(input.flagMode ? { mode: input.flagMode } : {}),
+            ...(input.flagNetwork ? { network: input.flagNetwork } : {}),
+        });
+        const parts = [
+            ...(input.flagMode ? [`sandbox set to ${sandboxModeLabel(input.flagMode)}`] : []),
+            ...(input.flagNetwork ? [`network set to ${input.flagNetwork === "deny" ? "denied" : "allowed"}`] : []),
+        ];
+        const caveat = input.flagMode ? sandboxEnforcementCaveat(input.flagMode) : null;
+        return { ok: true, lines: [`✓ ${parts.join(", ")} (${scopeLabel(scope)})`, ...(caveat ? [caveat] : [])] };
+    }
+    const snap = getSandboxSnapshot();
+    const extras = [
+        ...(snap.extraWriteRoots.length > 0 ? [`Extra writable dirs: ${snap.extraWriteRoots.join(", ")}`] : []),
+        ...(snap.extraReadRoots.length > 0 ? [`Extra readable dirs: ${snap.extraReadRoots.join(", ")}`] : []),
+    ];
+    const caveat = sandboxEnforcementCaveat(getEffectiveSandboxPolicy().mode);
+    return {
+        ok: true,
+        lines: [
+            `Current sandbox: ${sandboxStatusLabel()} (${sourceLabel(snap.source)})`,
+            ...extras,
+            ...(caveat ? [caveat] : []),
+            SANDBOX_CLI_USAGE,
+        ],
+    };
+}