min-agent 0.2.1 → 0.4.0

package/dist/context-window.js

@@ -1,46 +1,104 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { readFileSync, mkdirSync, existsSync } from "fs";
 import path from "path";
-import { getConfigDir, loadConfig } from "./config.js";
+import { atomicWriteFileSync } from "./tools/atomic-file.js";
+import { getConfigDir, getEffectiveConfig, getActiveProvider } from "./config.js";
 /**
  * Auto-detect context window size for the current model.
  *
  * Resolution order:
  * 1. User config: provider.contextWindow (explicit override)
- * 2. Provider-specific API (OpenRouter, vLLM, Ollama)
+ * 2. Provider-specific API (OpenRouter, vLLM, Ollama, OpenAI-compatible /models)
  * 3. models.dev API lookup
- * 4. Fallback: 128000
+ * 4. Fallback: 512000 (memory only — never persisted as a detected value)
  */
-const DEFAULT_CONTEXT_WINDOW = 128000;
-const CACHE_FILE = path.join(getConfigDir(), "context-window-cache.json");
-const CACHE_TTL = 7 * 24 * 60 * 60 * 1000; // 7 days
-function loadCache() {
-    if (!existsSync(CACHE_FILE))
+export const DEFAULT_CONTEXT_WINDOW = 512000;
+const CACHE_TTL = 7 * 24 * 60 * 60 * 1000;
+const FALLBACK_MEMORY_TTL = 10 * 60 * 1000;
+function cacheFile() {
+    return path.join(getConfigDir(), "context-window-cache.json");
+}
+const memoryCache = new Map();
+const inFlight = new Map();
+function loadDiskCache() {
+    const file = cacheFile();
+    if (!existsSync(file))
         return {};
     try {
-        return JSON.parse(readFileSync(CACHE_FILE, "utf-8"));
+        return JSON.parse(readFileSync(file, "utf-8"));
     }
     catch {
         return {};
     }
 }
 function saveCache(cache) {
-    mkdirSync(path.dirname(CACHE_FILE), { recursive: true });
-    writeFileSync(CACHE_FILE, JSON.stringify(cache), "utf-8");
+    const file = cacheFile();
+    mkdirSync(path.dirname(file), { recursive: true });
+    atomicWriteFileSync(file, JSON.stringify(cache));
+}
+function cacheTtl(source) {
+    return source === "fallback" ? FALLBACK_MEMORY_TTL : CACHE_TTL;
 }
 function getCached(modelId) {
-    const cache = loadCache();
-    const entry = cache[modelId];
-    if (!entry)
+    const memory = memoryCache.get(modelId);
+    if (memory && Date.now() - memory.timestamp <= cacheTtl(memory.source)) {
+        return { tokens: memory.contextWindow, source: memory.source };
+    }
+    const disk = loadDiskCache()[modelId];
+    if (!disk || disk.source !== "detected")
         return null;
-    if (Date.now() - entry.timestamp > CACHE_TTL)
+    if (Date.now() - disk.timestamp > CACHE_TTL)
         return null;
-    return entry.contextWindow;
+    memoryCache.set(modelId, { ...disk, source: "detected" });
+    return { tokens: disk.contextWindow, source: "detected" };
 }
-function setCache(modelId, contextWindow) {
-    const cache = loadCache();
-    cache[modelId] = { contextWindow, timestamp: Date.now() };
+function setCache(modelId, contextWindow, source) {
+    const entry = { contextWindow, timestamp: Date.now(), source };
+    memoryCache.set(modelId, entry);
+    if (source !== "detected")
+        return;
+    const cache = loadDiskCache();
+    cache[modelId] = entry;
     saveCache(cache);
 }
+export function extractModelContextLength(model) {
+    if (!model || typeof model !== "object")
+        return null;
+    const rec = model;
+    const nested = [rec, rec.meta, rec.limits, rec.limit, rec.model_info];
+    const keys = [
+        "context_length",
+        "max_model_len",
+        "max_model_length",
+        "max_context_length",
+        "context_window",
+        "max_input_tokens",
+        "max_total_tokens",
+        "context",
+        "general.context_length",
+    ];
+    for (const obj of nested) {
+        if (!obj || typeof obj !== "object")
+            continue;
+        const bag = obj;
+        for (const key of keys) {
+            const n = bag[key];
+            if (typeof n === "number" && Number.isFinite(n) && n >= 4096)
+                return Math.floor(n);
+        }
+    }
+    return null;
+}
+function matchListedModel(models, modelId) {
+    const exact = models.find((m) => m && typeof m === "object" && m.id === modelId);
+    if (exact)
+        return exact;
+    return models.find((m) => {
+        if (!m || typeof m !== "object")
+            return false;
+        const id = m.id;
+        return typeof id === "string" && (id.endsWith(`/${modelId}`) || modelId.endsWith(`/${id}`));
+    });
+}
 /** Try OpenRouter: GET /api/v1/models returns context_length per model */
 async function tryOpenRouter(baseURL, apiKey, modelId) {
     if (!baseURL.includes("openrouter"))
@@ -53,8 +111,7 @@ async function tryOpenRouter(baseURL, apiKey, modelId) {
         if (!response.ok)
             return null;
         const data = (await response.json());
-        const model = data.data?.find((m) => m.id === modelId);
-        return model?.context_length ?? null;
+        return extractModelContextLength(matchListedModel(data.data ?? [], modelId));
     }
     catch {
         return null;
@@ -62,6 +119,8 @@ async function tryOpenRouter(baseURL, apiKey, modelId) {
 }
 /** Try vLLM: GET /v1/models returns max_model_len */
 async function tryVllm(baseURL, apiKey, modelId) {
+    if (!baseURL.includes("vllm"))
+        return null;
     try {
         const url = `${baseURL.replace(/\/$/, "")}/models`;
         const response = await fetch(url, {
@@ -71,9 +130,27 @@ async function tryVllm(baseURL, apiKey, modelId) {
         if (!response.ok)
             return null;
         const data = (await response.json());
-        const model = (data.data ?? []).find((m) => m.id === modelId);
-        // vLLM exposes max_model_len on the model object
-        return model?.max_model_len ?? model?.max_model_length ?? null;
+        return extractModelContextLength(matchListedModel(data.data ?? [], modelId));
+    }
+    catch {
+        return null;
+    }
+}
+/** Any OpenAI-compatible /models that advertises context length (1M custom endpoints included). */
+async function tryProviderModels(baseURL, apiKey, modelId) {
+    if (!baseURL)
+        return null;
+    try {
+        const url = `${baseURL.replace(/\/$/, "")}/models`;
+        const response = await fetch(url, {
+            headers: { Authorization: `Bearer ${apiKey}` },
+            signal: AbortSignal.timeout(8000),
+        });
+        if (!response.ok)
+            return null;
+        const data = (await response.json());
+        const models = Array.isArray(data) ? data : (data.data ?? []);
+        return extractModelContextLength(matchListedModel(models, modelId));
     }
     catch {
         return null;
@@ -96,9 +173,7 @@ async function tryOllama(baseURL, modelId) {
             return null;
         const data = (await response.json());
         // Ollama returns model_info with context length
-        const ctxLength = data.model_info?.["general.context_length"] ??
-            data.model_info?.context_length ??
-            data.parameters?.num_ctx;
+        const ctxLength = data.model_info?.["general.context_length"] ?? data.model_info?.context_length ?? data.parameters?.num_ctx;
         return typeof ctxLength === "number" ? ctxLength : null;
     }
     catch {
@@ -114,15 +189,7 @@ async function tryModelsDev(modelId) {
         if (!response.ok)
             return null;
         const providers = (await response.json());
-        // Search all providers for the model ID
-        for (const provider of Object.values(providers)) {
-            if (!provider.models)
-                continue;
-            const model = provider.models[modelId];
-            if (model?.limit?.context)
-                return model.limit.context;
-        }
-        // Try partial match (some providers prefix model IDs)
+        // Single pass: exact match or partial match (some providers prefix model IDs)
         for (const provider of Object.values(providers)) {
             if (!provider.models)
                 continue;
@@ -140,46 +207,60 @@ async function tryModelsDev(modelId) {
     }
 }
 /**
- * Get context window size for the current model.
- * Tries multiple sources, caches the result.
+ * Detect context window size for a model by probing all sources in parallel.
+ * Returns the first non-null result, respecting the original precedence.
  */
-export async function getContextWindow(modelId) {
-    const config = loadConfig();
-    // 1. Explicit user config
-    if (config.provider?.contextWindow)
-        return config.provider.contextWindow;
-    const id = modelId ?? config.provider?.defaultModel;
+async function detectContextWindow(config, id) {
+    const provider = getActiveProvider(config);
+    const baseURL = provider?.baseURL ?? "";
+    const apiKey = provider?.apiKey ?? "";
+    const results = await Promise.all([
+        tryOpenRouter(baseURL, apiKey, id),
+        tryOllama(baseURL, id),
+        tryVllm(baseURL, apiKey, id),
+        tryProviderModels(baseURL, apiKey, id),
+        tryModelsDev(id),
+    ]);
+    const found = results.find((v) => v !== null);
+    if (found) {
+        setCache(id, found, "detected");
+        return { tokens: found, source: "detected" };
+    }
+    setCache(id, DEFAULT_CONTEXT_WINDOW, "fallback");
+    return { tokens: DEFAULT_CONTEXT_WINDOW, source: "fallback" };
+}
+/**
+ * Get context window size and whether it was configured, detected, or guessed.
+ * Fallback 512k is never written to disk as a detected value.
+ */
+export async function getContextWindowInfo(modelId) {
+    const config = getEffectiveConfig();
+    const provider = getActiveProvider(config);
+    if (provider?.contextWindow)
+        return { tokens: provider.contextWindow, source: "config" };
+    const id = modelId ?? provider?.defaultModel;
     if (!id)
-        return DEFAULT_CONTEXT_WINDOW;
-    // 2. Check cache
+        return { tokens: DEFAULT_CONTEXT_WINDOW, source: "fallback" };
     const cached = getCached(id);
-    if (cached !== null)
+    if (cached)
         return cached;
-    const baseURL = config.provider?.baseURL ?? "";
-    const apiKey = config.provider?.apiKey ?? "";
-    // 3. Provider-specific APIs
-    const openRouter = await tryOpenRouter(baseURL, apiKey, id);
-    if (openRouter) {
-        setCache(id, openRouter);
-        return openRouter;
-    }
-    const ollama = await tryOllama(baseURL, id);
-    if (ollama) {
-        setCache(id, ollama);
-        return ollama;
-    }
-    const vllm = await tryVllm(baseURL, apiKey, id);
-    if (vllm) {
-        setCache(id, vllm);
-        return vllm;
-    }
-    // 4. models.dev lookup
-    const modelsDev = await tryModelsDev(id);
-    if (modelsDev) {
-        setCache(id, modelsDev);
-        return modelsDev;
-    }
-    // 5. Fallback
-    setCache(id, DEFAULT_CONTEXT_WINDOW);
-    return DEFAULT_CONTEXT_WINDOW;
+    const pending = inFlight.get(id);
+    if (pending)
+        return pending;
+    const probing = detectContextWindow(config, id);
+    inFlight.set(id, probing);
+    try {
+        return await probing;
+    }
+    finally {
+        inFlight.delete(id);
+    }
+}
+/**
+ * Get context window size for the current model.
+ * Tries multiple sources, caches detected results in memory and on disk.
+ * Concurrent calls for the same model share a single probe.
+ */
+export async function getContextWindow(modelId) {
+    return (await getContextWindowInfo(modelId)).tokens;
 }

package/dist/doom-loop.js

@@ -1,36 +1,278 @@
 /**
- * Doom loop detection.
+ * Loop / stall detection for the agent run.
  *
- * Detects when the agent calls the same tool with the same arguments
- * repeatedly (indicating it's stuck in a loop). After THRESHOLD consecutive
- * identical calls, the loop is broken and the agent is informed.
+ * 1. Exact identity: the same tool with the same (normalized) arguments,
+ *    THRESHOLD times in a row → halt. Non-consecutive repeats of the same call
+ *    are counted too (a parallel batch used to flush the old sliding window),
+ *    with a higher threshold.
+ * 2. Web research productivity: a research call is judged by what came back.
+ *    Rounds that bring new URLs / domains are free — gathering data about many
+ *    entities legitimately needs many searches. Rounds that bring nothing new
+ *    build an "unproductive" streak that first steers the model to write, then
+ *    removes the research tools for the rest of the turn. A hard per-turn cap
+ *    still applies.
  *
- * Based on opencode's processor.ts doom loop detection.
+ * The detector is owned by the outer run loop so auto-continue cannot reset it.
  */
-const THRESHOLD = 3;
+/** Same tool + same args, back to back. */
+export const EXACT_LOOP_THRESHOLD = 3;
+/** Same tool + same args anywhere in the turn (survives parallel batches). */
+export const REPEAT_TOTAL_THRESHOLD = 5;
+/** Research rounds without new sources before steering the model to deliver. */
+export const RESEARCH_STEER_AFTER = 3;
+/** Research rounds without new sources before the research tools are dropped. */
+export const RESEARCH_STOP_AFTER = 5;
+/** Hard ceiling on research calls in a single turn. */
+export const RESEARCH_TOTAL_CAP = 24;
+export const WEB_RESEARCH_TOOLS = new Set(["search_web", "web_fetch"]);
+const ARTIFACT_TOOLS = new Set(["write", "edit", "apply_patch"]);
+export const STEER_PROMPT = "Your last few searches and page fetches returned nothing new. Stop calling search_web and web_fetch. Using only what you already have, produce the user's requested deliverable now (files, code, or a complete answer). If some fields are uncertain, mark them and proceed — do not search again.";
+export const DELIVER_PROMPT = "The research tools have been removed for the rest of this turn. Do not try to search again. Using the information already in this conversation, produce the user's requested deliverable now (write files with the write/edit tools). If a fact is missing, note the gap and still write the output.";
+export const RESEARCH_STUB_RESULT = "Web search and page fetch are disabled for the rest of this turn. Produce the user's requested deliverable from information already in this conversation. If a fact is missing, note the gap and still write the output.";
+export const LOOP_HALT_MESSAGE = "同一操作连续重复了多次，已停止以免空转。发送消息可继续。";
+function positiveInt(value, fallback) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 1)
+        return fallback;
+    return Math.floor(value);
+}
+/** Deterministic serialization so equivalent objects compare equal regardless of key order. */
+function serializeInput(input) {
+    try {
+        if (input === null || typeof input !== "object")
+            return JSON.stringify(input);
+        if (Array.isArray(input))
+            return JSON.stringify(input.map(serializeInput));
+        const sorted = {};
+        for (const key of Object.keys(input).sort()) {
+            sorted[key] = serializeInput(input[key]);
+        }
+        return JSON.stringify(sorted);
+    }
+    catch {
+        return String(input);
+    }
+}
+function asRecord(input) {
+    if (input && typeof input === "object" && !Array.isArray(input))
+        return input;
+    return null;
+}
+function normalizeQuery(raw) {
+    if (typeof raw !== "string")
+        return "";
+    return raw.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function hostOf(raw) {
+    try {
+        return new URL(raw.trim()).hostname.toLowerCase().replace(/^www\./, "");
+    }
+    catch {
+        return "";
+    }
+}
+function normalizeUrl(raw) {
+    if (typeof raw !== "string")
+        return "";
+    try {
+        const u = new URL(raw.trim());
+        const host = u.hostname.toLowerCase().replace(/^www\./, "");
+        const path = u.pathname.replace(/\/+$/, "");
+        return `${u.protocol}//${host}${path}${u.search}`;
+    }
+    catch {
+        return raw.trim().toLowerCase();
+    }
+}
+/** Identity used for exact-repeat detection (search queries / URLs are normalized). */
+export function identityPayload(toolName, input) {
+    const rec = asRecord(input);
+    if (toolName === "search_web" && rec)
+        return serializeInput({ query: normalizeQuery(rec.query) });
+    if (toolName === "web_fetch" && rec)
+        return serializeInput({ url: normalizeUrl(rec.url) });
+    return serializeInput(input);
+}
+const URL_IN_TEXT = /https?:\/\/[^\s"'<>)\]}]+/g;
+const RESULT_ERROR = /^(error|search error|fetch error)\b/i;
+/** New URLs / domains found in a research result, ignoring ones already seen. */
+export function extractSources(text) {
+    const urls = new Set();
+    const hosts = new Set();
+    for (const raw of text.match(URL_IN_TEXT) ?? []) {
+        const url = normalizeUrl(raw);
+        if (url)
+            urls.add(url);
+        const host = hostOf(raw);
+        if (host)
+            hosts.add(host);
+    }
+    return { urls: [...urls], hosts: [...hosts] };
+}
 export class DoomLoopDetector {
-    recentCalls = [];
-    /** Record a tool call. Returns true if a doom loop is detected. */
+    lastCall = { key: "", count: 0 };
+    callCounts = new Map();
+    webTotal = 0;
+    /** Research calls issued but whose results have not been seen yet. */
+    inFlight = 0;
+    /** Did the current batch of research calls bring anything new? */
+    batchProductive = false;
+    unproductiveRounds = 0;
+    steered = false;
+    capped = false;
+    delivered = false;
+    seenUrls = new Set();
+    seenHosts = new Set();
+    steerAfter;
+    stopAfter;
+    totalCap;
+    constructor(opts) {
+        this.steerAfter = positiveInt(opts?.steerAfter, RESEARCH_STEER_AFTER);
+        this.stopAfter = Math.max(positiveInt(opts?.stopAfter, RESEARCH_STOP_AFTER), this.steerAfter + 1);
+        this.totalCap = positiveInt(opts?.totalCap, RESEARCH_TOTAL_CAP);
+    }
+    get webResearchCount() {
+        return this.webTotal;
+    }
+    get researchCapped() {
+        return this.capped;
+    }
+    get producedArtifact() {
+        return this.delivered;
+    }
+    /** Research rounds in a row that returned no new sources. */
+    get unproductiveStreak() {
+        return this.unproductiveRounds;
+    }
+    /** Record a tool call. Returns true if the run should halt (exact identity loop). */
     record(toolName, input) {
-        const serialized = JSON.stringify(input);
-        this.recentCalls.push({ toolName, input: serialized });
-        // Only check the last THRESHOLD calls
-        if (this.recentCalls.length < THRESHOLD)
-            return false;
-        const recent = this.recentCalls.slice(-THRESHOLD);
-        const allSame = recent.every((call) => call.toolName === recent[0].toolName && call.input === recent[0].input);
-        if (allSame) {
-            // Reset to prevent repeated warnings
-            this.recentCalls = [];
-            return true;
-        }
-        // Keep only last THRESHOLD entries to bound memory
-        if (this.recentCalls.length > THRESHOLD * 2) {
-            this.recentCalls = this.recentCalls.slice(-THRESHOLD);
-        }
-        return false;
+        return this.observe(toolName, input) === "halt";
+    }
+    /** A tool call is starting. */
+    observe(toolName, input) {
+        const key = `${toolName}\u0000${identityPayload(toolName, input)}`;
+        if (this.lastCall.key === key)
+            this.lastCall.count++;
+        else
+            this.lastCall = { key, count: 1 };
+        const total = (this.callCounts.get(key) ?? 0) + 1;
+        this.callCounts.set(key, total);
+        if (this.lastCall.count >= EXACT_LOOP_THRESHOLD || total >= REPEAT_TOTAL_THRESHOLD) {
+            this.lastCall = { key: "", count: 0 };
+            this.callCounts.delete(key);
+            return "halt";
+        }
+        if (WEB_RESEARCH_TOOLS.has(toolName)) {
+            this.webTotal++;
+            if (this.inFlight === 0)
+                this.batchProductive = false;
+            this.inFlight++;
+            if (!this.capped && this.webTotal >= this.totalCap) {
+                this.markCapped();
+                return "cap";
+            }
+            return "ok";
+        }
+        if (ARTIFACT_TOOLS.has(toolName)) {
+            // Real progress: forgive the research history so far.
+            this.delivered = true;
+            this.unproductiveRounds = 0;
+        }
+        // Other tools neither help nor hurt the research budget.
+        return "ok";
+    }
+    /**
+     * A tool result came back. Research productivity is judged here, once the
+     * whole parallel batch has landed, so four fresh searches in one step are not
+     * mistaken for a loop.
+     */
+    observeResult(toolName, output) {
+        if (!WEB_RESEARCH_TOOLS.has(toolName))
+            return "ok";
+        const text = typeof output === "string" ? output : safeString(output);
+        if (!RESULT_ERROR.test(text.trim())) {
+            const { urls, hosts } = extractSources(text);
+            let fresh = 0;
+            for (const url of urls) {
+                if (!this.seenUrls.has(url)) {
+                    this.seenUrls.add(url);
+                    fresh++;
+                }
+            }
+            for (const host of hosts) {
+                if (!this.seenHosts.has(host)) {
+                    this.seenHosts.add(host);
+                    fresh++;
+                }
+            }
+            if (fresh > 0)
+                this.batchProductive = true;
+        }
+        if (this.inFlight > 0)
+            this.inFlight--;
+        if (this.inFlight > 0)
+            return "ok";
+        if (this.batchProductive) {
+            this.unproductiveRounds = 0;
+            return "ok";
+        }
+        this.unproductiveRounds++;
+        if (this.capped)
+            return "ok";
+        if (this.unproductiveRounds >= this.stopAfter) {
+            this.markCapped();
+            return "cap";
+        }
+        if (!this.steered && this.unproductiveRounds >= this.steerAfter) {
+            this.steered = true;
+            return "steer";
+        }
+        return "ok";
+    }
+    markCapped() {
+        this.capped = true;
+        this.steered = true;
+    }
+    promptHint() {
+        if (this.capped) {
+            return [
+                "## Research budget",
+                "search_web and web_fetch have been removed for the rest of this turn.",
+                "Produce the requested deliverable from information already in the conversation.",
+            ].join("\n");
+        }
+        if (this.webTotal < 4)
+            return "";
+        const lines = [
+            "## Research budget",
+            `Research calls this turn: ${this.webTotal}/${this.totalCap}; rounds without new sources: ${this.unproductiveRounds}/${this.stopAfter}.`,
+        ];
+        if (this.steered || this.unproductiveRounds >= this.steerAfter) {
+            lines.push("Recent searches added nothing new. Stop searching and produce the requested deliverable; mark uncertain fields instead of looking for more.");
+        }
+        else {
+            lines.push("Keep queries targeted: fetch the best sources, then write the output.");
+        }
+        return lines.join("\n");
     }
     reset() {
-        this.recentCalls = [];
+        this.lastCall = { key: "", count: 0 };
+        this.callCounts.clear();
+        this.webTotal = 0;
+        this.inFlight = 0;
+        this.batchProductive = false;
+        this.unproductiveRounds = 0;
+        this.steered = false;
+        this.capped = false;
+        this.delivered = false;
+        this.seenUrls.clear();
+        this.seenHosts.clear();
+    }
+}
+function safeString(value) {
+    try {
+        return JSON.stringify(value) ?? String(value);
+    }
+    catch {
+        return String(value);
     }
 }