min-agent 0.2.1 → 0.4.0

package/dist/updater.js

@@ -0,0 +1,116 @@
+import { readFileSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { spawnSync } from "child_process";
+export const UPDATE_PACKAGE = "min-agent";
+export const NPM_LATEST_URL = `https://registry.npmjs.org/${UPDATE_PACKAGE}/latest`;
+export const UPDATE_NPM_BIN = "npm";
+export const UPDATE_NPM_ARGS = ["install", "-g", UPDATE_PACKAGE];
+const VERSION_RE = /^\d+\.\d+\.\d+/;
+const FETCH_TIMEOUT_MS = 10_000;
+export function updateInstallCommand() {
+    return [UPDATE_NPM_BIN, ...UPDATE_NPM_ARGS].join(" ");
+}
+export function localVersion() {
+    try {
+        const pkgPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../package.json");
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        return typeof pkg.version === "string" && pkg.version.length > 0 ? pkg.version : "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+export function compareVersions(a, b) {
+    const pa = a.split("-")[0].split(".").map(Number);
+    const pb = b.split("-")[0].split(".").map(Number);
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        const va = pa[i] ?? 0;
+        const vb = pb[i] ?? 0;
+        const na = Number.isFinite(va) ? va : 0;
+        const nb = Number.isFinite(vb) ? vb : 0;
+        if (na !== nb)
+            return na - nb;
+    }
+    return 0;
+}
+function parseVersion(value) {
+    if (typeof value !== "string" || !VERSION_RE.test(value))
+        return null;
+    return value;
+}
+export async function fetchLatestVersion(fetchFn = fetch) {
+    let response;
+    try {
+        response = await fetchFn(NPM_LATEST_URL, {
+            signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+            headers: { Accept: "application/json" },
+        });
+    }
+    catch {
+        return null;
+    }
+    if (!response.ok)
+        return null;
+    let data;
+    try {
+        data = await response.json();
+    }
+    catch {
+        return null;
+    }
+    if (!data || typeof data !== "object" || !("version" in data))
+        return null;
+    return parseVersion(data.version);
+}
+export async function checkForUpdate(opts) {
+    const current = opts?.currentVersion ?? localVersion();
+    const latest = await fetchLatestVersion(opts?.fetchFn);
+    return {
+        current,
+        latest,
+        updateAvailable: latest !== null && compareVersions(current, latest) < 0,
+    };
+}
+export function installLatest() {
+    const result = spawnSync(UPDATE_NPM_BIN, [...UPDATE_NPM_ARGS], {
+        stdio: "inherit",
+        shell: process.platform === "win32",
+        env: process.env,
+    });
+    if (result.error) {
+        const code = result.error.code;
+        return { ok: false, missing: code === "ENOENT" };
+    }
+    return { ok: result.status === 0 };
+}
+export async function runUpdate(io = {}) {
+    const log = io.log ?? ((msg) => console.log(msg));
+    const error = io.error ?? ((msg) => console.error(msg));
+    const current = io.currentVersion?.() ?? localVersion();
+    const cmd = updateInstallCommand();
+    log(`当前版本: ${current}`);
+    const latest = io.fetchLatest ? await io.fetchLatest() : await fetchLatestVersion();
+    if (!latest) {
+        error(`无法检查新版本（网络不可用）。请稍后重试，或手动执行: ${cmd}`);
+        return { status: "check-failed", current, latest: null };
+    }
+    if (compareVersions(current, latest) >= 0) {
+        log(`已是最新版本 (${latest})`);
+        return { status: "up-to-date", current, latest };
+    }
+    log(`发现新版本: ${latest}`);
+    log(`正在执行 ${cmd} ...`);
+    const installed = (io.install ?? installLatest)();
+    if (!installed.ok) {
+        if (installed.missing) {
+            error(`未找到 npm。请先安装 Node.js，然后执行: ${cmd}`);
+        }
+        else {
+            error(`自动升级失败。请手动执行: ${cmd}`);
+        }
+        return { status: "install-failed", current, latest };
+    }
+    log(`✓ 已升级到 ${latest}`);
+    return { status: "updated", current, latest };
+}

package/dist/xml-search.js

@@ -0,0 +1,194 @@
+/**
+ * Some OpenAI-compatible gateways (and a few models) dump built-in web search
+ * into the assistant text as <web_search>…</web_search> instead of a tool call,
+ * then stop. This module splits those blocks out of the stream so the agent can
+ * turn them into search_web tool results and keep going.
+ */
+const OPEN_NAME = "<web_search";
+const CLOSE_NAME = "</web_search";
+const PARTIAL_TAG_HOLD = 80;
+const UNCLOSED_MAX = 64 * 1024;
+function collapse(s) {
+    return s.replace(/\s+/g, " ").trim();
+}
+function isNameBoundary(ch) {
+    return ch === undefined || ch === ">" || ch === "/" || ch === " " || ch === "\t" || ch === "\n" || ch === "\r";
+}
+function findOpen(buf) {
+    const l = buf.toLowerCase();
+    let from = 0;
+    while (from < l.length) {
+        const index = l.indexOf(OPEN_NAME, from);
+        if (index < 0)
+            return null;
+        if (!isNameBoundary(l[index + OPEN_NAME.length])) {
+            from = index + 1;
+            continue;
+        }
+        const gt = buf.indexOf(">", index);
+        if (gt < 0)
+            return null;
+        return { index, openLen: gt - index + 1, raw: buf.slice(index, gt + 1) };
+    }
+    return null;
+}
+function findClose(buf, from) {
+    const l = buf.toLowerCase();
+    let start = from;
+    while (start < l.length) {
+        const index = l.indexOf(CLOSE_NAME, start);
+        if (index < 0)
+            return null;
+        if (!isNameBoundary(l[index + CLOSE_NAME.length])) {
+            start = index + 1;
+            continue;
+        }
+        const gt = buf.indexOf(">", index);
+        if (gt < 0)
+            return null;
+        return { innerEnd: index, tagEnd: gt + 1 };
+    }
+    return null;
+}
+function queryFromOpenTag(raw) {
+    const m = /\bquery\s*=\s*"([^"]*)"/i.exec(raw) ?? /\bquery\s*=\s*'([^']*)'/i.exec(raw);
+    return m?.[1]?.trim() ?? "";
+}
+const RESULTS_HEADER = /^Search results for\s+"([^"]*)"\s*:/im;
+export function classifyXmlSearchBody(inner, attrQuery = "") {
+    const trimmed = inner.trim();
+    if (!trimmed) {
+        const query = attrQuery.trim();
+        return query ? { kind: "invoke", query } : { kind: "results", query: "", body: "" };
+    }
+    const header = RESULTS_HEADER.exec(trimmed);
+    if (header) {
+        return { kind: "results", query: header[1].trim() || attrQuery, body: trimmed };
+    }
+    if (/^\d+\.\s+Title\s*:/m.test(trimmed) && /\bURL\s*:/m.test(trimmed)) {
+        return { kind: "results", query: attrQuery, body: trimmed };
+    }
+    const query = collapse(trimmed) || attrQuery;
+    if (query && query.length <= 500 && !/\bURL\s*:\s*https?:\/\//i.test(trimmed)) {
+        return { kind: "invoke", query };
+    }
+    return { kind: "results", query: attrQuery || query, body: trimmed };
+}
+function lastPotentialPartialOpen(buf) {
+    const start = Math.max(0, buf.length - PARTIAL_TAG_HOLD);
+    const tail = buf.slice(start);
+    const lt = tail.lastIndexOf("<");
+    if (lt < 0)
+        return -1;
+    const globalLt = start + lt;
+    const cand = buf.slice(globalLt).toLowerCase();
+    if (cand.length > 72)
+        return -1;
+    if (OPEN_NAME.startsWith(cand) || CLOSE_NAME.startsWith(cand))
+        return globalLt;
+    if (cand.startsWith(OPEN_NAME) && !cand.includes(">"))
+        return globalLt;
+    if (cand.startsWith(CLOSE_NAME) && !cand.includes(">"))
+        return globalLt;
+    return -1;
+}
+export class XmlSearchSplitter {
+    buf = "";
+    feed(chunk) {
+        this.buf += chunk;
+        return this.drain(false);
+    }
+    flush() {
+        return this.drain(true);
+    }
+    drain(isFinal) {
+        const out = [];
+        let hadBlock = false;
+        const pushDisplay = (text) => {
+            if (!text)
+                return;
+            const last = out[out.length - 1];
+            if (last?.type === "display")
+                last.text += text;
+            else
+                out.push({ type: "display", text });
+        };
+        while (this.buf.length > 0) {
+            const open = findOpen(this.buf);
+            if (!open) {
+                if (isFinal) {
+                    pushDisplay(this.buf);
+                    this.buf = "";
+                }
+                else {
+                    const holdFrom = lastPotentialPartialOpen(this.buf);
+                    if (holdFrom >= 0) {
+                        pushDisplay(this.buf.slice(0, holdFrom));
+                        this.buf = this.buf.slice(holdFrom);
+                    }
+                    else {
+                        pushDisplay(this.buf);
+                        this.buf = "";
+                    }
+                }
+                break;
+            }
+            if (open.index > 0) {
+                let pre = this.buf.slice(0, open.index);
+                pre = pre.replace(/\n+$/, "");
+                if (pre)
+                    pushDisplay(pre);
+                this.buf = this.buf.slice(open.index);
+            }
+            const close = findClose(this.buf, open.openLen);
+            if (!close) {
+                const innerLen = this.buf.length - open.openLen;
+                if (isFinal || innerLen > UNCLOSED_MAX) {
+                    const inner = this.buf.slice(open.openLen);
+                    out.push({ type: "search", block: classifyXmlSearchBody(inner, queryFromOpenTag(open.raw)) });
+                    hadBlock = true;
+                    this.buf = "";
+                }
+                break;
+            }
+            const inner = this.buf.slice(open.openLen, close.innerEnd);
+            out.push({ type: "search", block: classifyXmlSearchBody(inner, queryFromOpenTag(open.raw)) });
+            hadBlock = true;
+            this.buf = this.buf.slice(close.tagEnd).replace(/^\n+/, "");
+        }
+        if (hadBlock) {
+            const first = out[0];
+            if (first?.type === "display")
+                first.text = first.text.replace(/^\n+/, "");
+        }
+        return out.filter((sl) => sl.type === "search" || sl.text.length > 0);
+    }
+}
+export function extractXmlSearch(text) {
+    const splitter = new XmlSearchSplitter();
+    const slices = [...splitter.feed(text), ...splitter.flush()];
+    let display = "";
+    const blocks = [];
+    for (const sl of slices) {
+        if (sl.type === "display")
+            display += sl.text;
+        else
+            blocks.push(sl.block);
+    }
+    return { display, blocks, slices };
+}
+/** Drop the XML wrappers but keep the inner query/results, for sub-agent returns. */
+export function unwrapXmlSearchTags(text) {
+    const { slices } = extractXmlSearch(text);
+    if (slices.every((sl) => sl.type === "display"))
+        return text;
+    return slices
+        .map((sl) => {
+        if (sl.type === "display")
+            return sl.text;
+        return sl.block.kind === "results" ? sl.block.body : sl.block.query;
+    })
+        .join("")
+        .replace(/^\n+/, "")
+        .replace(/\n+$/, "");
+}