@poco-ai/agentero-dsh-host 0.0.0-stage → 0.1.0

package/lib/recommend.js

@@ -0,0 +1,864 @@
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { cliFailure, runAgentero } from './cli-run.js';
+const PREFIX = '/agentero/api/recommend';
+const BODY_LIMIT = 128 * 1024;
+const FEED_TIMEOUT_MS = 30_000;
+const EMBED_TIMEOUT_MS = 120_000;
+const ZHIHU_TIMEOUT_MS = 20_000;
+const CLI_TIMEOUT_MS = 20_000;
+const EMBED_BATCH = 20;
+const EMBED_CHARS = 4_000;
+const MAX_CORPUS = 2_000;
+const MAX_TOP_N = 100;
+const DEFAULT_TOP_N = 20;
+const ZHIHU_SCORE_FLOOR = 0.5;
+const DEFAULT_CATEGORIES = ['cs.AI', 'cs.CL', 'cs.LG', 'cs.CV', 'stat.ML'];
+const ZHIHU_BASE = 'https://developer.zhihu.com';
+const ARXIV_RSS_BASE = 'https://rss.arxiv.org/rss/';
+function record(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    return value;
+}
+function stringValue(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function maskedSecret(value) {
+    return value !== '' && /^\*+$/.test(value);
+}
+function configHome() {
+    const xdg = stringValue(process.env.XDG_CONFIG_HOME);
+    if (xdg !== '')
+        return xdg;
+    if (process.platform === 'win32') {
+        const appData = stringValue(process.env.APPDATA);
+        if (appData !== '')
+            return appData;
+    }
+    return join(homedir(), '.config');
+}
+function cacheHome() {
+    const xdg = stringValue(process.env.XDG_CACHE_HOME);
+    if (xdg !== '')
+        return xdg;
+    if (process.platform === 'win32') {
+        const local = stringValue(process.env.LOCALAPPDATA);
+        if (local !== '')
+            return local;
+    }
+    return join(homedir(), '.cache');
+}
+function agenteroSettingsPath(settings) {
+    const explicit = settings.agenteroSettings.trim();
+    return explicit !== '' ? explicit : join(configHome(), 'agentero', 'settings.json');
+}
+function overrideSettingsPath() {
+    return join(configHome(), 'agentero', 'dsh-recommend.json');
+}
+function cacheFilePath() {
+    return join(cacheHome(), 'agentero', 'dsh-recommend-cache.json');
+}
+async function readJsonFile(path) {
+    try {
+        const text = await readFile(path, 'utf8');
+        return record(JSON.parse(text));
+    }
+    catch {
+        return undefined;
+    }
+}
+async function writeSecureJson(path, value) {
+    const directory = dirname(path);
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    const temporary = `${path}.tmp-${process.pid}-${Date.now()}`;
+    await writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+    await rename(temporary, path);
+}
+async function loadOverrides() {
+    const raw = await readJsonFile(overrideSettingsPath());
+    if (raw === undefined)
+        return {};
+    const out = {};
+    const baseUrl = stringValue(raw.embeddingBaseUrl);
+    const apiKey = stringValue(raw.embeddingApiKey);
+    const model = stringValue(raw.embeddingModel);
+    const zhihu = stringValue(raw.zhihuAccessSecret);
+    if (baseUrl !== '')
+        out.embeddingBaseUrl = baseUrl;
+    if (apiKey !== '' && !maskedSecret(apiKey))
+        out.embeddingApiKey = apiKey;
+    if (model !== '')
+        out.embeddingModel = model;
+    if (zhihu !== '' && !maskedSecret(zhihu))
+        out.zhihuAccessSecret = zhihu;
+    return out;
+}
+async function resolveRuntime(settings) {
+    const agentero = await readJsonFile(agenteroSettingsPath(settings));
+    const overrides = await loadOverrides();
+    const agenteroEmbedding = record(agentero?.embedding);
+    const agenteroSource = stringValue(agenteroEmbedding?.source);
+    const agenteroIsBuiltin = agenteroSource === 'builtin';
+    const agenteroBase = agenteroIsBuiltin ? '' : stringValue(agenteroEmbedding?.baseUrl);
+    const agenteroModel = agenteroIsBuiltin ? '' : stringValue(agenteroEmbedding?.model);
+    const agenteroKeyRaw = agenteroIsBuiltin ? '' : stringValue(agenteroEmbedding?.apiKey);
+    const agenteroKey = maskedSecret(agenteroKeyRaw) ? '' : agenteroKeyRaw;
+    const overrideBase = overrides.embeddingBaseUrl ?? '';
+    const overrideModel = overrides.embeddingModel ?? '';
+    const overrideKey = overrides.embeddingApiKey ?? '';
+    let baseUrl = '';
+    let model = '';
+    let key = '';
+    let source = 'agentero';
+    if (overrideBase !== '' || overrideModel !== '') {
+        baseUrl = overrideBase !== '' ? overrideBase : agenteroBase;
+        model = overrideModel !== '' ? overrideModel : agenteroModel;
+        key = overrideKey !== '' ? overrideKey : agenteroKey;
+        source = 'dsh';
+    }
+    else {
+        baseUrl = agenteroBase;
+        model = agenteroModel;
+        key = overrideKey !== '' ? overrideKey : agenteroKey;
+        source = overrideKey !== '' ? 'dsh' : 'agentero';
+    }
+    const embedding = baseUrl !== '' && model !== ''
+        ? { baseUrl, model, source, ...(key !== '' ? { apiKey: key } : {}) }
+        : undefined;
+    const agenteroZhihuRaw = stringValue(agentero?.zhihuAccessSecret);
+    const agenteroZhihu = maskedSecret(agenteroZhihuRaw) ? '' : agenteroZhihuRaw;
+    const zhihuSecret = overrides.zhihuAccessSecret !== undefined && overrides.zhihuAccessSecret !== ''
+        ? overrides.zhihuAccessSecret
+        : agenteroZhihu;
+    return {
+        ...(embedding !== undefined ? { embedding } : {}),
+        ...(zhihuSecret !== '' ? { zhihuSecret, zhihuSource: overrides.zhihuAccessSecret !== undefined ? 'dsh' : 'agentero' } : {}),
+    };
+}
+function settingsView(settings, runtime) {
+    return {
+        vaultConfigured: settings.vault.trim() !== '',
+        embedding: {
+            configured: runtime.embedding !== undefined,
+            baseUrl: runtime.embedding?.baseUrl ?? '',
+            model: runtime.embedding?.model ?? '',
+            keyPresent: runtime.embedding?.apiKey !== undefined,
+            source: runtime.embedding?.source ?? 'none',
+        },
+        zhihu: {
+            configured: runtime.zhihuSecret !== undefined,
+            source: runtime.zhihuSource ?? 'none',
+        },
+    };
+}
+async function saveOverrides(raw) {
+    const current = await loadOverrides();
+    const next = { ...current };
+    const assign = (key, value, allowMask) => {
+        if (typeof value !== 'string')
+            return;
+        const trimmed = value.trim();
+        if (trimmed === '' || (allowMask && maskedSecret(trimmed)))
+            return;
+        next[key] = trimmed;
+    };
+    assign('embeddingBaseUrl', raw.embeddingBaseUrl, false);
+    assign('embeddingModel', raw.embeddingModel, false);
+    assign('embeddingApiKey', raw.embeddingApiKey, true);
+    assign('zhihuAccessSecret', raw.zhihuAccessSecret, true);
+    await writeSecureJson(overrideSettingsPath(), next);
+}
+async function readCache() {
+    const raw = await readJsonFile(cacheFilePath());
+    const runs = record(raw?.runs);
+    if (runs === undefined)
+        return { runs: {} };
+    const out = {};
+    for (const [key, value] of Object.entries(runs)) {
+        const entry = record(value);
+        const computedAt = stringValue(entry?.computedAt);
+        const result = parseArxivResult(entry?.result);
+        if (computedAt === '' || result === undefined)
+            continue;
+        out[key] = { computedAt, result };
+    }
+    return { runs: out };
+}
+async function writeCache(cache) {
+    const entries = Object.entries(cache.runs)
+        .sort((a, b) => b[1].computedAt.localeCompare(a[1].computedAt))
+        .slice(0, 24);
+    await writeSecureJson(cacheFilePath(), { runs: Object.fromEntries(entries) });
+}
+function parseArxivResult(value) {
+    const raw = record(value);
+    if (raw === undefined)
+        return undefined;
+    const itemsRaw = raw.items;
+    if (!Array.isArray(itemsRaw))
+        return undefined;
+    const items = [];
+    for (const entry of itemsRaw) {
+        const item = record(entry);
+        if (item === undefined)
+            continue;
+        const arxivId = stringValue(item.arxivId);
+        const title = stringValue(item.title);
+        const url = stringValue(item.url);
+        if (arxivId === '' || title === '' || url === '')
+            continue;
+        const score = typeof item.score === 'number' && Number.isFinite(item.score) ? item.score : 0;
+        items.push({
+            arxivId,
+            title,
+            abstract: stringValue(item.abstract),
+            url,
+            ...(stringValue(item.publishedAt) !== '' ? { publishedAt: stringValue(item.publishedAt) } : {}),
+            score,
+        });
+    }
+    const categories = Array.isArray(raw.categories)
+        ? raw.categories.filter((c) => typeof c === 'string' && c.trim() !== '')
+        : [];
+    return {
+        items,
+        computedAt: stringValue(raw.computedAt),
+        categories,
+        corpusSize: typeof raw.corpusSize === 'number' && Number.isFinite(raw.corpusSize) ? raw.corpusSize : 0,
+        reusedCache: raw.reusedCache === true,
+    };
+}
+function normalizeCategories(input) {
+    const values = Array.isArray(input) ? input : [];
+    const out = [];
+    for (const value of values) {
+        if (typeof value !== 'string')
+            continue;
+        const trimmed = value.trim();
+        if (trimmed === '' || trimmed.length > 40)
+            continue;
+        if (!out.some(category => category.toLowerCase() === trimmed.toLowerCase()))
+            out.push(trimmed);
+    }
+    return out;
+}
+function topNFrom(value) {
+    const n = typeof value === 'number' && Number.isFinite(value) ? Math.trunc(value) : DEFAULT_TOP_N;
+    return Math.min(MAX_TOP_N, Math.max(1, n));
+}
+function todayUtc() {
+    return new Date().toISOString().slice(0, 10);
+}
+function fresh(result) {
+    return result.items.length > 0 && result.computedAt.startsWith(todayUtc());
+}
+function runKey(model, categories, topN) {
+    const normalized = categories.map(category => category.toLowerCase()).join(',');
+    return createHash('sha256').update(`arxiv|${model}|${topN}|${normalized}`).digest('hex');
+}
+function sameCategories(left, right) {
+    if (left.length !== right.length)
+        return false;
+    const normalizedRight = new Set(right.map(category => category.toLowerCase()));
+    return left.every(category => normalizedRight.has(category.toLowerCase()));
+}
+function latestSameDay(cache, categories) {
+    const entries = Object.values(cache.runs)
+        .filter(entry => fresh(entry.result))
+        .filter(entry => categories === undefined || categories.length === 0 || sameCategories(entry.result.categories, categories))
+        .sort((a, b) => b.computedAt.localeCompare(a.computedAt));
+    return entries[0]?.result;
+}
+function decodeXml(input) {
+    return input
+        .replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, '$1')
+        .replace(/&#x([0-9a-f]+);/gi, (_, hex) => String.fromCodePoint(Number.parseInt(hex, 16)))
+        .replace(/&#(\d+);/g, (_, dec) => String.fromCodePoint(Number.parseInt(dec, 10)))
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&apos;/g, "'")
+        .replace(/&nbsp;/g, ' ')
+        .replace(/&amp;/g, '&');
+}
+function stripHtml(input) {
+    return input.replace(/<[^>]*>/g, ' ').replace(/\s+/g, ' ').trim();
+}
+function itemTag(item, name) {
+    const match = new RegExp(`<${name}(?:\\s[^>]*)?>([\\s\\S]*?)</${name}>`, 'i').exec(item);
+    return match?.[1] !== undefined ? decodeXml(match[1]) : '';
+}
+function itemLink(item) {
+    const text = itemTag(item, 'link').trim();
+    if (text !== '')
+        return text;
+    const match = /<link\b[^>]*\bhref=(?:"([^"]*)"|'([^']*)')/i.exec(item);
+    return decodeXml(match?.[1] ?? match?.[2] ?? '').trim();
+}
+function stripLabeledPrefix(text, label) {
+    const lower = text.toLowerCase();
+    if (!lower.startsWith(label))
+        return undefined;
+    const after = text.slice(label.length).trimStart();
+    if (label === 'abstract:')
+        return after;
+    const whitespace = after.search(/\s/);
+    return after.slice(whitespace === -1 ? after.length : whitespace).trimStart();
+}
+function cleanAbstract(input) {
+    let text = stripHtml(decodeXml(input));
+    const labels = ['arxiv:', 'announce type:', 'comments:', 'subjects:', 'journal-ref:', 'report-no:', 'license:', 'abstract:'];
+    for (let changed = true; changed;) {
+        changed = false;
+        for (const label of labels) {
+            const next = stripLabeledPrefix(text, label);
+            if (next !== undefined) {
+                text = next;
+                changed = true;
+            }
+        }
+    }
+    return text;
+}
+function arxivIdFrom(text) {
+    const match = /(?:arxiv\.org\/(?:abs|pdf|html)\/|arxiv:)([a-z-]+(?:\.[a-z]{2})?\/\d{7}|\d{4}\.\d{4,5})(?:v\d+)?/i.exec(text);
+    if (match?.[1] !== undefined)
+        return match[1];
+    return '';
+}
+function parseFeed(xml) {
+    const out = [];
+    const items = xml.match(/<item\b[\s\S]*?<\/item>/gi) ?? [];
+    for (const item of items) {
+        const title = stripHtml(itemTag(item, 'title'));
+        const description = itemTag(item, 'description');
+        const link = itemLink(item);
+        const abstract = cleanAbstract(description);
+        if (title === '' || abstract === '')
+            continue;
+        const arxivId = arxivIdFrom(`${link}\n${description}\n${itemTag(item, 'guid')}`);
+        if (arxivId === '')
+            continue;
+        const published = itemTag(item, 'pubDate').trim();
+        out.push({
+            arxivId,
+            title,
+            abstract,
+            url: `https://arxiv.org/abs/${arxivId}`,
+            ...(published !== '' ? { publishedAt: published } : {}),
+        });
+    }
+    return out;
+}
+async function fetchText(url, timeoutMs) {
+    const response = await fetch(url, {
+        headers: { 'user-agent': 'Agentero/1.0 (+https://github.com/Phil-Fan)' },
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (!response.ok)
+        throw new Error(`${url} returned HTTP ${response.status}`);
+    return response.text();
+}
+async function fetchCandidates(categories) {
+    const out = [];
+    const seen = new Set();
+    let lastError;
+    for (const category of categories) {
+        try {
+            const xml = await fetchText(`${ARXIV_RSS_BASE}${encodeURIComponent(category)}`, FEED_TIMEOUT_MS);
+            for (const candidate of parseFeed(xml)) {
+                if (seen.has(candidate.arxivId))
+                    continue;
+                seen.add(candidate.arxivId);
+                out.push(candidate);
+            }
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+        }
+    }
+    if (out.length === 0 && lastError !== undefined)
+        throw lastError;
+    return out;
+}
+function resolveEmbeddingEndpoint(baseUrl) {
+    const base = baseUrl.trim().replace(/\/+$/, '');
+    if (base === '')
+        return '';
+    return base.endsWith('/embeddings') ? base : `${base}/embeddings`;
+}
+function embedText(title, abstract) {
+    return `${title.trim()}\n\n${abstract.trim()}`.slice(0, EMBED_CHARS);
+}
+function normalizeVector(vector) {
+    let sum = 0;
+    for (const value of vector)
+        sum += value * value;
+    const norm = Math.sqrt(sum);
+    return norm > 0 ? vector.map(value => value / norm) : vector;
+}
+function dot(left, right) {
+    if (left.length !== right.length)
+        return 0;
+    let sum = 0;
+    for (let index = 0; index < left.length; index += 1)
+        sum += (left[index] ?? 0) * (right[index] ?? 0);
+    return sum;
+}
+function isBatchRejection(status, body) {
+    if (status !== 400 && status !== 413 && status !== 422)
+        return false;
+    const lower = body.toLowerCase();
+    return lower.includes('batch')
+        || lower.includes('too many input')
+        || lower.includes('too many text')
+        || lower.includes('maximum number of');
+}
+async function embedBatch(endpoint, apiKey, model, texts) {
+    if (texts.length === 0)
+        return [];
+    const headers = { 'content-type': 'application/json' };
+    if (apiKey !== undefined)
+        headers.authorization = `Bearer ${apiKey}`;
+    let response;
+    try {
+        response = await fetch(endpoint, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({ model, input: texts }),
+            signal: AbortSignal.timeout(EMBED_TIMEOUT_MS),
+        });
+    }
+    catch (error) {
+        throw new Error(`embeddings request failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!response.ok) {
+        const body = await response.text().catch(() => '');
+        if (texts.length > 1 && isBatchRejection(response.status, body)) {
+            const middle = Math.ceil(texts.length / 2);
+            const left = await embedBatch(endpoint, apiKey, model, texts.slice(0, middle));
+            const right = await embedBatch(endpoint, apiKey, model, texts.slice(middle));
+            return [...left, ...right];
+        }
+        throw new Error(`embeddings HTTP ${response.status}: ${body.slice(0, 300)}`);
+    }
+    let body;
+    try {
+        body = await response.json();
+    }
+    catch {
+        throw new Error('embeddings returned invalid JSON');
+    }
+    const data = record(body)?.data;
+    if (!Array.isArray(data))
+        throw new Error('embeddings response has no data');
+    const vectors = [];
+    for (const entry of data) {
+        const row = record(entry);
+        const vector = row?.embedding;
+        if (!Array.isArray(vector))
+            throw new Error('embeddings response has no vector');
+        const values = [];
+        for (const value of vector) {
+            if (typeof value !== 'number' || !Number.isFinite(value))
+                throw new Error('embeddings response has an invalid vector');
+            values.push(value);
+        }
+        vectors.push(values);
+    }
+    if (vectors.length !== texts.length)
+        throw new Error(`embeddings returned ${vectors.length} vectors for ${texts.length} inputs`);
+    return vectors;
+}
+async function embedAll(endpoint, apiKey, model, texts) {
+    const out = [];
+    for (let start = 0; start < texts.length; start += EMBED_BATCH) {
+        const chunk = texts.slice(start, start + EMBED_BATCH);
+        out.push(...await embedBatch(endpoint, apiKey, model, chunk));
+    }
+    return out;
+}
+/** Raw vectors kept for this host process so a refresh does not re-embed the corpus. */
+const vectorMemo = new Map();
+const VECTOR_MEMO_LIMIT = 5_000;
+function memoKey(model, text) {
+    return `${model}\0${createHash('sha256').update(text).digest('hex')}`;
+}
+async function embedAllMemo(endpoint, apiKey, model, texts) {
+    const keys = texts.map(text => memoKey(model, text));
+    const missing = new Map();
+    for (let index = 0; index < keys.length; index += 1) {
+        const key = keys[index];
+        const text = texts[index];
+        if (key === undefined || text === undefined || vectorMemo.has(key) || missing.has(key))
+            continue;
+        missing.set(key, text);
+    }
+    if (missing.size > 0) {
+        const missingKeys = [...missing.keys()];
+        const vectors = await embedAll(endpoint, apiKey, model, [...missing.values()]);
+        for (let index = 0; index < missingKeys.length; index += 1) {
+            const key = missingKeys[index];
+            const vector = vectors[index];
+            if (key === undefined || vector === undefined)
+                continue;
+            vectorMemo.set(key, vector);
+            if (vectorMemo.size > VECTOR_MEMO_LIMIT) {
+                const oldest = vectorMemo.keys().next().value;
+                if (oldest !== undefined)
+                    vectorMemo.delete(oldest);
+            }
+        }
+    }
+    return keys.map(key => vectorMemo.get(key) ?? []);
+}
+async function corpusTexts(settings, children) {
+    const result = await runAgentero(settings.agenteroBin, [
+        '--vault', settings.vault,
+        '--json',
+        'paper', 'list',
+        '--fields', 'abstract,added_at',
+    ], CLI_TIMEOUT_MS, children);
+    if (result.timedOut || result.spawnError !== undefined || result.code !== 0) {
+        throw new Error(cliFailure(result, 'agentero paper list'));
+    }
+    let body;
+    try {
+        body = JSON.parse(result.stdout);
+    }
+    catch {
+        throw new Error('agentero paper list returned invalid JSON');
+    }
+    const root = record(body);
+    const data = Array.isArray(root?.data) ? root.data : Array.isArray(root?.items) ? root.items : [];
+    const rows = [];
+    for (const entry of data) {
+        const row = record(entry);
+        if (row === undefined)
+            continue;
+        const title = stringValue(row.title);
+        const abstract = stringValue(row.abstract);
+        if (title === '' || abstract === '')
+            continue;
+        rows.push({ addedAt: stringValue(row.added_at), text: embedText(title, abstract) });
+    }
+    rows.sort((a, b) => b.addedAt.localeCompare(a.addedAt));
+    return rows.slice(0, MAX_CORPUS).map(row => row.text);
+}
+function decayWeights(length) {
+    const raw = [];
+    for (let index = 0; index < length; index += 1)
+        raw.push(1 / (1 + Math.log10(index + 2)));
+    const total = raw.reduce((sum, value) => sum + value, 0);
+    return total > 0 ? raw.map(value => value / total) : raw.map(() => 0);
+}
+async function recommendArxiv(settings, runtime, input, children) {
+    if (settings.vault.trim() === '')
+        throw new Error('vault is not configured');
+    const categories = normalizeCategories(input.categories);
+    const resolvedCategories = categories.length > 0 ? categories : [...DEFAULT_CATEGORIES];
+    const topN = topNFrom(input.topN);
+    const force = input.force === true;
+    const cache = await readCache();
+    if (runtime.embedding === undefined) {
+        const stored = latestSameDay(cache, resolvedCategories);
+        if (!force && stored !== undefined)
+            return { ...stored, reusedCache: true };
+        throw new Error('recommend.no_embedding');
+    }
+    const key = runKey(runtime.embedding.model, resolvedCategories, topN);
+    const cached = cache.runs[key];
+    if (!force && cached !== undefined && fresh(cached.result))
+        return { ...cached.result, reusedCache: true };
+    const corpus = await corpusTexts(settings, children);
+    if (corpus.length === 0)
+        throw new Error('recommend.empty_corpus');
+    const candidates = await fetchCandidates(resolvedCategories);
+    if (candidates.length === 0)
+        throw new Error('recommend.no_candidates');
+    const endpoint = resolveEmbeddingEndpoint(runtime.embedding.baseUrl);
+    if (endpoint === '')
+        throw new Error('recommend.no_embedding');
+    const corpusVectors = (await embedAllMemo(endpoint, runtime.embedding.apiKey, runtime.embedding.model, corpus))
+        .map(normalizeVector);
+    const candidateVectors = (await embedAllMemo(endpoint, runtime.embedding.apiKey, runtime.embedding.model, candidates.map(candidate => embedText(candidate.title, candidate.abstract)))).map(normalizeVector);
+    const weights = decayWeights(corpusVectors.length);
+    const items = candidates.map((candidate, index) => {
+        const candidateVector = candidateVectors[index] ?? [];
+        let score = 0;
+        for (let corpusIndex = 0; corpusIndex < corpusVectors.length; corpusIndex += 1) {
+            const weight = weights[corpusIndex] ?? 0;
+            score += dot(corpusVectors[corpusIndex] ?? [], candidateVector) * weight;
+        }
+        return { ...candidate, score };
+    });
+    items.sort((left, right) => right.score - left.score);
+    const result = {
+        items: items.slice(0, topN),
+        computedAt: new Date().toISOString(),
+        categories: resolvedCategories,
+        corpusSize: corpusVectors.length,
+        reusedCache: false,
+    };
+    cache.runs[key] = { computedAt: result.computedAt, result };
+    await writeCache(cache);
+    return result;
+}
+async function probeEmbedding(runtime, input) {
+    const overrideBase = stringValue(input.baseUrl);
+    const overrideModel = stringValue(input.model);
+    const rawKey = stringValue(input.apiKey);
+    const baseUrl = overrideBase !== '' ? overrideBase : runtime.embedding?.baseUrl ?? '';
+    const model = overrideModel !== '' ? overrideModel : runtime.embedding?.model ?? '';
+    const apiKey = rawKey !== '' && !maskedSecret(rawKey) ? rawKey : runtime.embedding?.apiKey;
+    if (baseUrl === '' || model === '')
+        throw new Error('recommend.no_embedding');
+    const endpoint = resolveEmbeddingEndpoint(baseUrl);
+    const started = Date.now();
+    try {
+        const vectors = await embedBatch(endpoint, apiKey, model, ['hi']);
+        const vector = vectors[0] ?? [];
+        if (vector.length === 0)
+            throw new Error('response has no embedding');
+        return { dim: vector.length, latencyMs: Date.now() - started };
+    }
+    catch (error) {
+        console.warn('[agentero] embedding probe failed:', error);
+        throw new Error('recommend.probe_failed');
+    }
+}
+function parseZhihuItems(body) {
+    const root = record(body);
+    const code = typeof root?.Code === 'number' ? root.Code : 0;
+    if (code !== 0) {
+        const message = stringValue(root?.Message);
+        throw new Error(message !== '' ? message : '知乎检索失败');
+    }
+    const data = record(root?.Data);
+    const items = Array.isArray(data?.Items) ? data.Items : [];
+    const out = [];
+    for (const raw of items) {
+        const item = record(raw);
+        if (item === undefined)
+            continue;
+        const title = stringValue(item.Title).replace(/\s*-\s*知乎$/, '');
+        const url = stringValue(item.Url).split('?')[0] ?? '';
+        if (title === '' || url === '')
+            continue;
+        const score = typeof item.RankingScore === 'number' && Number.isFinite(item.RankingScore) ? item.RankingScore : 0;
+        if (score < ZHIHU_SCORE_FLOOR)
+            continue;
+        const contentType = stringValue(item.ContentType).toLowerCase();
+        out.push({
+            kind: contentType === 'answer' ? 'answer' : 'article',
+            title,
+            url,
+            excerpt: [...stringValue(item.ContentText)].slice(0, 160).join(''),
+            author: stringValue(item.AuthorName),
+            votes: typeof item.VoteUpCount === 'number' && Number.isFinite(item.VoteUpCount) ? item.VoteUpCount : 0,
+            score,
+        });
+    }
+    return out;
+}
+async function searchZhihu(runtime, query, count) {
+    if (runtime.zhihuSecret === undefined)
+        throw new Error('zhihu.no_secret');
+    const trimmed = query.trim();
+    if (trimmed === '')
+        throw new Error('zhihu.empty_query');
+    const url = new URL(`${ZHIHU_BASE}/api/v1/content/zhihu_search`);
+    url.searchParams.set('Query', trimmed);
+    url.searchParams.set('Count', String(Math.min(10, Math.max(1, count))));
+    let response;
+    try {
+        response = await fetch(url, {
+            headers: {
+                authorization: `Bearer ${runtime.zhihuSecret}`,
+                'x-request-timestamp': String(Math.floor(Date.now() / 1000)),
+            },
+            signal: AbortSignal.timeout(ZHIHU_TIMEOUT_MS),
+        });
+    }
+    catch (error) {
+        throw new Error(`知乎检索请求失败：${error instanceof Error ? error.message : String(error)}`);
+    }
+    const text = await response.text();
+    if (!response.ok)
+        throw new Error(`知乎检索 HTTP ${response.status}: ${text.slice(0, 300)}`);
+    let body;
+    try {
+        body = JSON.parse(text);
+    }
+    catch {
+        throw new Error('知乎检索响应解析失败');
+    }
+    return parseZhihuItems(body);
+}
+function sendJson(res, status, payload) {
+    res.statusCode = status;
+    res.setHeader('content-type', 'application/json');
+    res.setHeader('cache-control', 'no-store');
+    res.end(JSON.stringify(payload));
+}
+function readJsonBody(req) {
+    const declared = req.headers['content-length'];
+    if (declared !== undefined) {
+        const length = Number(declared);
+        if (!Number.isFinite(length) || length > BODY_LIMIT)
+            return Promise.resolve(undefined);
+    }
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        let settled = false;
+        const cleanup = () => {
+            req.off('data', onData);
+            req.off('end', onEnd);
+            req.off('error', onError);
+        };
+        const finish = (value, error) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            if (error !== undefined)
+                reject(error instanceof Error ? error : new Error(String(error)));
+            else
+                resolve(value);
+        };
+        const onData = (chunk) => {
+            const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            size += buffer.length;
+            if (size > BODY_LIMIT) {
+                finish(undefined);
+                return;
+            }
+            chunks.push(buffer);
+        };
+        const onEnd = () => {
+            const text = Buffer.concat(chunks).toString('utf8').trim();
+            if (text === '') {
+                finish({});
+                return;
+            }
+            try {
+                finish(record(JSON.parse(text)));
+            }
+            catch {
+                finish(undefined);
+            }
+        };
+        const onError = (error) => { finish(undefined, error); };
+        req.on('data', onData);
+        req.on('end', onEnd);
+        req.on('error', onError);
+    });
+}
+function statusFor(error) {
+    const message = error.message;
+    if (message === 'invalid body')
+        return 400;
+    if (message === 'vault is not configured')
+        return 503;
+    return 502;
+}
+/**
+ * Handle `/agentero/api/recommend/*`. Returns false when the path is outside
+ * this prefix so the caller can continue routing.
+ */
+export async function handleRecommendRequest(settings, req, res, children) {
+    let url;
+    try {
+        url = new URL(req.url ?? '/', 'http://127.0.0.1');
+    }
+    catch {
+        return false;
+    }
+    if (url.pathname !== PREFIX && !url.pathname.startsWith(`${PREFIX}/`))
+        return false;
+    const route = url.pathname.slice(PREFIX.length) || '/';
+    try {
+        if (route === '/settings') {
+            if (req.method === 'GET') {
+                sendJson(res, 200, settingsView(settings, await resolveRuntime(settings)));
+                return true;
+            }
+            if (req.method === 'PUT') {
+                const body = await readJsonBody(req);
+                if (body === undefined) {
+                    sendJson(res, 400, { error: 'invalid body' });
+                    return true;
+                }
+                await saveOverrides(body);
+                sendJson(res, 200, settingsView(settings, await resolveRuntime(settings)));
+                return true;
+            }
+            res.statusCode = 405;
+            res.setHeader('allow', 'GET, PUT');
+            res.end();
+            return true;
+        }
+        if (route === '/probe') {
+            if (req.method !== 'POST') {
+                res.statusCode = 405;
+                res.setHeader('allow', 'POST');
+                res.end();
+                return true;
+            }
+            const body = await readJsonBody(req);
+            if (body === undefined) {
+                sendJson(res, 400, { error: 'invalid body' });
+                return true;
+            }
+            sendJson(res, 200, await probeEmbedding(await resolveRuntime(settings), body));
+            return true;
+        }
+        if (route === '/arxiv') {
+            if (req.method === 'GET') {
+                const requested = normalizeCategories(url.searchParams.getAll('categories').flatMap(value => value.split(',')));
+                const cache = await readCache();
+                sendJson(res, 200, { result: latestSameDay(cache, requested) ?? null });
+                return true;
+            }
+            if (req.method === 'POST') {
+                const body = await readJsonBody(req);
+                if (body === undefined) {
+                    sendJson(res, 400, { error: 'invalid body' });
+                    return true;
+                }
+                sendJson(res, 200, await recommendArxiv(settings, await resolveRuntime(settings), body, children));
+                return true;
+            }
+            res.statusCode = 405;
+            res.setHeader('allow', 'GET, POST');
+            res.end();
+            return true;
+        }
+        if (route === '/zhihu') {
+            if (req.method !== 'GET') {
+                res.statusCode = 405;
+                res.setHeader('allow', 'GET');
+                res.end();
+                return true;
+            }
+            const query = stringValue(url.searchParams.get('query'));
+            const countRaw = Number(url.searchParams.get('count') ?? '10');
+            const count = Number.isFinite(countRaw) ? countRaw : 10;
+            sendJson(res, 200, { items: await searchZhihu(await resolveRuntime(settings), query, count) });
+            return true;
+        }
+        sendJson(res, 404, { error: 'not found' });
+        return true;
+    }
+    catch (error) {
+        const failure = error instanceof Error ? error : new Error(String(error));
+        if (!res.headersSent)
+            sendJson(res, statusFor(failure), { error: failure.message });
+        return true;
+    }
+}
+//# sourceMappingURL=recommend.js.map