dsh-llm-verifier 0.1.0

package/lib/types/cache.d.ts

@@ -0,0 +1,27 @@
+import type { UsageStats } from './caller.ts';
+export interface CachedPairScore {
+    scoreA: number;
+    scoreB: number;
+    usage: UsageStats;
+    scoringMode: 'top-logprobs' | 'explicit-tag';
+    createdAt: number;
+}
+export declare function stableHash(value: unknown): string;
+export declare function resolveCacheFile(cacheDir: string, cwd?: string): string;
+export declare class ScoreCache {
+    private readonly file;
+    private readonly maxEntries;
+    private loaded;
+    private entries;
+    private readonly inflight;
+    private writing;
+    constructor(file: string, maxEntries: number);
+    load(): Promise<void>;
+    getOrCreate(key: string, create: () => Promise<CachedPairScore>): Promise<{
+        value: CachedPairScore;
+        hit: boolean;
+    }>;
+    private trim;
+    private persist;
+}
+//# sourceMappingURL=cache.d.ts.map

package/lib/types/cache.js

@@ -0,0 +1,82 @@
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+export function stableHash(value) {
+    return createHash('sha256').update(JSON.stringify(value)).digest('hex');
+}
+export function resolveCacheFile(cacheDir, cwd = process.cwd()) {
+    const root = isAbsolute(cacheDir) ? cacheDir : resolve(cwd, cacheDir);
+    return join(root, 'scores-v1.json');
+}
+export class ScoreCache {
+    file;
+    maxEntries;
+    loaded = false;
+    entries = new Map();
+    inflight = new Map();
+    writing = Promise.resolve();
+    constructor(file, maxEntries) {
+        this.file = file;
+        this.maxEntries = maxEntries;
+    }
+    async load() {
+        if (this.loaded)
+            return;
+        this.loaded = true;
+        try {
+            const document = JSON.parse(await readFile(this.file, 'utf8'));
+            if (document.version !== 1 || typeof document.entries !== 'object' || document.entries === null)
+                return;
+            this.entries = new Map(Object.entries(document.entries).map(([key, value]) => [key, { ...value, scoringMode: value.scoringMode ?? 'explicit-tag' }]));
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+    async getOrCreate(key, create) {
+        await this.load();
+        const cached = this.entries.get(key);
+        if (cached !== undefined)
+            return { value: cached, hit: true };
+        const existing = this.inflight.get(key);
+        if (existing !== undefined)
+            return { value: await existing, hit: true };
+        const pending = create();
+        this.inflight.set(key, pending);
+        try {
+            const value = await pending;
+            this.entries.set(key, value);
+            this.trim();
+            await this.persist();
+            return { value, hit: false };
+        }
+        finally {
+            this.inflight.delete(key);
+        }
+    }
+    trim() {
+        if (this.entries.size <= this.maxEntries)
+            return;
+        const sorted = [...this.entries].sort((a, b) => a[1].createdAt - b[1].createdAt);
+        for (let index = 0; index < sorted.length - this.maxEntries; index += 1)
+            this.entries.delete(sorted[index][0]);
+    }
+    async persist() {
+        const snapshot = { version: 1, entries: Object.fromEntries(this.entries) };
+        this.writing = this.writing.then(async () => {
+            await mkdir(dirname(this.file), { recursive: true });
+            const temporary = this.file + '.tmp-' + process.pid;
+            await writeFile(temporary, JSON.stringify(snapshot), 'utf8');
+            try {
+                await rename(temporary, this.file);
+            }
+            catch (error) {
+                await unlink(temporary).catch(() => { });
+                throw error;
+            }
+        });
+        await this.writing;
+    }
+}
+//# sourceMappingURL=cache.js.map

package/lib/types/caller.d.ts

@@ -0,0 +1,48 @@
+import { type LlmRuntime } from '@deepseek-ai/dsh-llm';
+import type { AttachmentStore } from '@deepseek-ai/dsh-attachment';
+import type { CompletionLogprobs } from './core.ts';
+import { TopLogprobCapabilityCache } from './top-logprobs.ts';
+import type { Context } from '@deepseek-ai/cordis';
+export interface VerifierClientConfig {
+    ctx: Context;
+    llm: LlmRuntime;
+    attachments: AttachmentStore;
+    topLogprobCapabilities: TopLogprobCapabilityCache;
+    provider: string;
+    model: string;
+    reasoningEffort?: string;
+    maxTokens: number;
+    timeoutMs: number;
+    maxRetries: number;
+    retryBaseDelayMs: number;
+    limiter?: RequestLimiter;
+}
+export interface VerifierImage {
+    data: Uint8Array;
+    mediaType: 'image/png' | 'image/jpeg' | 'image/webp' | 'image/gif';
+}
+export interface UsageStats {
+    calls: number;
+    attempts: number;
+    retries: number;
+    inputTokens: number;
+    cachedInputTokens: number;
+    outputTokens: number;
+    reasoningTokens: number;
+}
+export type ScoringMode = 'top-logprobs' | 'explicit-tag';
+export interface VerifierCompletion extends CompletionLogprobs {
+    usage: UsageStats;
+    scoringMode: ScoringMode;
+}
+export declare class RequestLimiter {
+    readonly limit: number;
+    private active;
+    private readonly queue;
+    constructor(limit: number);
+    run<T>(operation: () => Promise<T>, signal?: AbortSignal): Promise<T>;
+}
+export declare function callVerifier(config: VerifierClientConfig, prompt: string, signal?: AbortSignal, images?: readonly VerifierImage[]): Promise<VerifierCompletion>;
+export declare function addUsage(target: UsageStats, source: UsageStats): void;
+export declare function emptyUsage(): UsageStats;
+//# sourceMappingURL=caller.d.ts.map

package/lib/types/caller.js

@@ -0,0 +1,125 @@
+import { BlockAssembler, ReasoningEffortId, createUserMessage, deepFreeze } from '@deepseek-ai/dsh-llm';
+import { TopLogprobCapabilityCache, TopLogprobsUnsupportedError, callTopLogprobs, resolveTopLogprobRoute } from "./top-logprobs.js";
+function failureMessage(finish) {
+    if (finish.kind === 'error' || finish.kind === 'aborted')
+        return finish.failure.message;
+    if (finish.kind === 'max-tokens')
+        return 'verifier response reached max tokens before completing its answer';
+    return undefined;
+}
+async function delay(ms, signal) {
+    if (signal?.aborted)
+        throw signal.reason;
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(resolve, ms);
+        const abort = () => { clearTimeout(timer); reject(signal?.reason); };
+        signal?.addEventListener('abort', abort, { once: true });
+    });
+}
+function usage(attempts, value = {}) {
+    return { calls: 1, attempts, retries: attempts - 1, inputTokens: value.inputTokens ?? 0, cachedInputTokens: (value.cacheReadTokens ?? 0) + (value.cacheWriteTokens ?? 0), outputTokens: value.outputTokens ?? 0, reasoningTokens: value.reasoningTokens ?? 0 };
+}
+async function callExplicitTag(config, prompt, signal, images) {
+    let attempt = 0;
+    while (true) {
+        attempt += 1;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(new Error('llm-verifier: request timed out')), config.timeoutMs);
+        const abort = () => controller.abort(signal?.reason);
+        signal?.addEventListener('abort', abort, { once: true });
+        try {
+            const content = [{ type: 'text', text: prompt }];
+            for (const image of images ?? []) {
+                const ref = await config.attachments.saveImage({ data: image.data, mediaType: image.mediaType });
+                content.push({ type: 'image', attachment: ref });
+            }
+            const messages = [createUserMessage({ content, source: { kind: 'plugin', plugin: 'dsh-llm-verifier' } })];
+            const assembler = new BlockAssembler();
+            const options = deepFreeze({
+                provider: config.provider,
+                model: config.model,
+                ...(config.reasoningEffort ? { reasoningEffort: ReasoningEffortId(config.reasoningEffort) } : {}),
+                messages,
+                maxTokens: config.maxTokens,
+                temperature: 1,
+                signal: controller.signal,
+            });
+            for await (const chunk of config.llm.stream(options))
+                assembler.push(chunk);
+            const failed = failureMessage(assembler.finish);
+            if (failed !== undefined)
+                throw new Error('llm-verifier: model call failed: ' + failed);
+            const text = assembler.blocks().filter((block) => block.type === 'text').map(block => block.text).join('');
+            if (!text.trim())
+                throw new Error('llm-verifier: selected DSH model produced no text');
+            // DSH adapters expose provider-neutral text/usage but not top-logprob candidates.
+            // extractScore() therefore uses the model's explicit final A–T tags.
+            return { text, tokens: [], positions: [], scoringMode: 'explicit-tag', usage: usage(attempt, assembler.usage) };
+        }
+        catch (error) {
+            if (signal?.aborted)
+                throw signal.reason;
+            if (attempt > config.maxRetries || !(error instanceof Error) || !/rate|quota|timeout|timed out|temporar|network|fetch|socket|5dd/i.test(error.message))
+                throw error;
+            await delay(Math.min(30000, config.retryBaseDelayMs * 2 ** (attempt - 1) * (0.8 + Math.random() * 0.4)), signal);
+        }
+        finally {
+            clearTimeout(timeout);
+            signal?.removeEventListener('abort', abort);
+        }
+    }
+}
+export class RequestLimiter {
+    limit;
+    active = 0;
+    queue = [];
+    constructor(limit) {
+        this.limit = limit;
+    }
+    async run(operation, signal) {
+        if (this.active >= this.limit)
+            await new Promise((resolve, reject) => {
+                const enter = () => { signal?.removeEventListener('abort', abort); resolve(); };
+                const abort = () => { const index = this.queue.indexOf(enter); if (index >= 0)
+                    this.queue.splice(index, 1); reject(signal?.reason); };
+                this.queue.push(enter);
+                signal?.addEventListener('abort', abort, { once: true });
+            });
+        if (signal?.aborted)
+            throw signal.reason;
+        this.active += 1;
+        try {
+            return await operation();
+        }
+        finally {
+            this.active -= 1;
+            this.queue.shift()?.();
+        }
+    }
+}
+async function callAutomatic(config, prompt, signal, images) {
+    if (!config.topLogprobCapabilities.isUnsupported(config.provider, config.model)) {
+        const route = await resolveTopLogprobRoute(config.ctx, config.provider);
+        if (route !== undefined) {
+            try {
+                return await callTopLogprobs(route, config.model, prompt, config.maxTokens, config.reasoningEffort, signal, images);
+            }
+            catch (error) {
+                if (!(error instanceof TopLogprobsUnsupportedError))
+                    throw error;
+                config.topLogprobCapabilities.markUnsupported(config.provider, config.model);
+            }
+        }
+        else
+            config.topLogprobCapabilities.markUnsupported(config.provider, config.model);
+    }
+    return callExplicitTag(config, prompt, signal, images);
+}
+export async function callVerifier(config, prompt, signal, images) {
+    const invoke = () => callAutomatic(config, prompt, signal, images);
+    return config.limiter === undefined ? invoke() : config.limiter.run(invoke, signal);
+}
+export function addUsage(target, source) { for (const key of ['calls', 'attempts', 'retries', 'inputTokens', 'cachedInputTokens', 'outputTokens', 'reasoningTokens'])
+    target[key] += source[key]; }
+export function emptyUsage() { return { calls: 0, attempts: 0, retries: 0, inputTokens: 0, cachedInputTokens: 0, outputTokens: 0, reasoningTokens: 0 }; }
+//# sourceMappingURL=caller.js.map

package/lib/types/client.d.ts

@@ -0,0 +1,4 @@
+import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client';
+export declare const inject: string[];
+export declare function apply(ctx: ClientContext): void;
+//# sourceMappingURL=client.d.ts.map

package/lib/types/client.js

@@ -0,0 +1,66 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button, Input, StateDot } from '@deepseek-ai/dsh-client-ui-primitives';
+import { useEffect, useMemo, useState } from 'react';
+const NS = 'llm-verifier';
+const shell = { display: 'flex', flexDirection: 'column', gap: 18, padding: '8px 4px 32px', color: 'var(--dsw-text-primary)' };
+const card = { display: 'flex', flexDirection: 'column', gap: 0, padding: '16px 16px 0', border: '1px solid var(--dsw-alias-border-l2, rgba(255, 255, 255, 0.16))', borderRadius: 12, background: 'var(--dsw-alias-bg-module, rgba(20, 31, 57, 0.42))', overflow: 'hidden' };
+const sectionTitle = { display: 'flex', gap: 10, alignItems: 'center', padding: '0 0 12px', borderBottom: '1px solid var(--dsw-alias-border-l2, rgba(255, 255, 255, 0.16))' };
+const row = { display: 'grid', gridTemplateColumns: 'minmax(150px, 1fr) minmax(220px, 1.4fr)', gap: 18, alignItems: 'center', padding: '14px 0', borderBottom: '1px solid var(--dsw-alias-border-l2, rgba(255, 255, 255, 0.16))' };
+const selectStyle = { width: '100%', minHeight: 38, padding: '0 12px', borderRadius: 10, color: 'var(--dsw-text-primary)', background: 'var(--dsw-surface-sunken)', border: '1px solid var(--dsw-alias-border-l2, rgba(255, 255, 255, 0.16))' };
+function record(value) { return typeof value === 'object' && value !== null && !Array.isArray(value) ? value : {}; }
+function values(view) { const v = record(view.value); return { provider: String(v.provider ?? ''), model: String(v.model ?? ''), ...(typeof v.reasoningEffort === 'string' ? { reasoningEffort: v.reasoningEffort } : {}), maxTokens: Number(v.maxTokens ?? 32768), maxConcurrency: Number(v.maxConcurrency ?? 8), maxRetries: Number(v.maxRetries ?? 3), timeoutMs: Number(v.timeoutMs ?? 300000), cacheMaxEntries: Number(v.cacheMaxEntries ?? 10000), estimatedInputUsdPerMillion: Number(v.estimatedInputUsdPerMillion ?? 0), estimatedOutputUsdPerMillion: Number(v.estimatedOutputUsdPerMillion ?? 0) }; }
+function message(error) { return error instanceof Error ? error.message : String(error); }
+function Label({ title, help }) { return _jsxs("div", { children: [_jsx("div", { style: { fontWeight: 600 }, children: title }), _jsx("div", { style: { fontSize: 12, color: 'var(--dsw-text-secondary)', marginTop: 3 }, children: help })] }); }
+function VerifierSettings({ api }) {
+    const [loaded, setLoaded] = useState(null);
+    const [draft, setDraft] = useState(null);
+    const [busy, setBusy] = useState(false);
+    const [error, setError] = useState(null);
+    const [saved, setSaved] = useState(false);
+    const load = async () => { setError(null); try {
+        const [m, s] = await Promise.all([api.llm.models({}), api.settings.describe({})]);
+        if (!m.result.ok)
+            throw new Error(m.result.error.message);
+        if (!s.result.ok)
+            throw new Error(s.result.error.message);
+        const view = s.result.value.namespaces.find((x) => x.ns === NS);
+        if (!view)
+            throw new Error('Verifier settings namespace is not registered. Restart the DSH host.');
+        const next = { groups: m.result.value.groups, settings: view, writable: s.result.value.writable, failures: m.result.value.failures.map((f) => f.name + ': ' + f.message) };
+        setLoaded(next);
+        setDraft(values(view));
+    }
+    catch (e) {
+        setError(message(e));
+    } };
+    useEffect(() => { void load(); }, []);
+    const models = useMemo(() => loaded?.groups.find(g => g.id === draft?.provider)?.models ?? [], [loaded, draft?.provider]);
+    const selected = models.find(m => m.id === draft?.model);
+    const efforts = selected?.reasoning?.efforts ?? [];
+    const patch = (key, value) => setDraft(v => v ? { ...v, [key]: value } : v);
+    const save = async () => { if (!loaded || !draft)
+        return; setBusy(true); setSaved(false); setError(null); try {
+        const section = { ...record(loaded.settings.user), ...draft };
+        if (!draft.reasoningEffort)
+            delete section.reasoningEffort;
+        const res = await api.settings.update({ ns: NS, patch: section, expectedRevision: loaded.settings.revision });
+        if (!res.result.ok)
+            throw new Error(res.result.error.message);
+        setLoaded(v => v ? { ...v, settings: res.result.value } : v);
+        setDraft(values(res.result.value));
+        setSaved(true);
+    }
+    catch (e) {
+        setError(message(e));
+    }
+    finally {
+        setBusy(false);
+    } };
+    if (!loaded || !draft)
+        return _jsxs("div", { style: shell, children: [_jsx("h2", { children: "LLM Verifier" }), _jsx("p", { children: error ?? '正在读取 DSH 模型和设置…' }), error && _jsx(Button, { onClick: () => void load(), children: "\u91CD\u8BD5" })] });
+    const numeric = (key, min = 0) => _jsx(Input, { type: "number", min: min, value: String(draft[key]), onChange: e => patch(key, Number(e.target.value)) });
+    return _jsxs("div", { style: shell, children: [_jsxs("div", { children: [_jsx("h2", { style: { margin: '0 0 6px' }, children: "LLM Verifier" }), _jsx("p", { style: { margin: 0, color: 'var(--dsw-text-secondary)' }, children: "\u9009\u62E9\u4EFB\u610F\u5DF2\u5728 DSH\u300C\u6A21\u578B\u300D\u9875\u914D\u7F6E\u5E76\u542F\u7528\u7684\u6A21\u578B\u4F5C\u4E3A\u72EC\u7ACB\u88C1\u5224\u3002\u8BBE\u7F6E\u5B9E\u65F6\u751F\u6548\u3002" })] }), _jsxs("div", { style: card, children: [_jsxs("div", { style: sectionTitle, children: [_jsx(StateDot, { state: "done" }), _jsx("strong", { children: "\u88C1\u5224\u6A21\u578B" })] }), _jsxs("div", { style: row, children: [_jsx(Label, { title: "\u4F9B\u5E94\u5546", help: "\u53EA\u663E\u793A\u5F53\u524D DSH \u4E2D\u53EF\u8DEF\u7531\u7684\u4F9B\u5E94\u5546" }), _jsx("select", { style: selectStyle, value: draft.provider, onChange: e => { const provider = e.target.value; const first = loaded.groups.find(g => g.id === provider)?.models[0]; setDraft({ ...draft, provider, ...(first ? { model: first.id, reasoningEffort: first.reasoning?.defaultEffort } : {}) }); }, children: loaded.groups.map(g => _jsxs("option", { value: g.id, children: [g.name, " \u00B7 ", g.id] }, g.id)) })] }), _jsxs("div", { style: row, children: [_jsx(Label, { title: "\u6A21\u578B", help: "\u6A21\u578B\u76EE\u5F55\u6765\u81EA DSH adapter\uFF0C\u9009\u62E9\u7ED3\u679C\u4F1A\u6301\u4E45\u5316" }), _jsx("select", { style: selectStyle, value: draft.model, onChange: e => { const model = e.target.value; const found = models.find(m => m.id === model); setDraft({ ...draft, model, ...(found?.reasoning?.defaultEffort ? { reasoningEffort: found.reasoning.defaultEffort } : { reasoningEffort: undefined }) }); }, children: models.map(m => _jsxs("option", { value: m.id, children: [m.name, " \u00B7 ", m.id] }, m.id)) })] }), _jsxs("div", { style: row, children: [_jsx(Label, { title: "\u63A8\u7406\u5F3A\u5EA6", help: "\u7531\u6240\u9009\u6A21\u578B adapter \u58F0\u660E\uFF1B\u7559\u7A7A\u4F7F\u7528\u6A21\u578B\u9ED8\u8BA4\u503C" }), _jsxs("select", { style: selectStyle, value: draft.reasoningEffort ?? '', onChange: e => patch('reasoningEffort', e.target.value || undefined), children: [_jsx("option", { value: "", children: "\u6A21\u578B\u9ED8\u8BA4" }), efforts.map(e => _jsx("option", { value: e.id, children: e.name }, e.id))] })] }), _jsxs("div", { style: row, children: [_jsx(Label, { title: "\u6700\u5927\u8F93\u51FA Token", help: "\u6BCF\u4E2A\u88C1\u5224\u8BF7\u6C42\u7684\u8F93\u51FA\u4E0A\u9650" }), numeric('maxTokens', 1)] })] }), _jsxs("div", { style: card, children: [_jsx("div", { style: sectionTitle, children: _jsx("strong", { children: "\u6267\u884C\u63A7\u5236" }) }), _jsxs("div", { style: row, children: [_jsx(Label, { title: "\u6700\u5927\u5E76\u53D1", help: "\u6240\u6709 verifier \u5DE5\u5177\u5171\u4EAB\u7684\u8BF7\u6C42\u5E76\u53D1\u4E0A\u9650" }), numeric('maxConcurrency', 1)] }), _jsxs("div", { style: row, children: [_jsx(Label, { title: "\u6700\u591A\u91CD\u8BD5", help: "\u77ED\u6682\u7F51\u7EDC\u3001\u9650\u6D41\u548C\u670D\u52A1\u7AEF\u9519\u8BEF\u7684\u91CD\u8BD5\u6B21\u6570" }), numeric('maxRetries', 0)] }), _jsxs("div", { style: row, children: [_jsx(Label, { title: "\u8BF7\u6C42\u8D85\u65F6\uFF08\u6BEB\u79D2\uFF09", help: "\u5355\u4E2A\u6A21\u578B\u8BF7\u6C42\u7684\u8D85\u65F6\u65F6\u95F4" }), numeric('timeoutMs', 1)] }), _jsxs("div", { style: row, children: [_jsx(Label, { title: "\u7F13\u5B58\u6761\u76EE\u4E0A\u9650", help: "\u6301\u4E45\u8BC4\u5206\u7F13\u5B58\u4FDD\u7559\u7684\u6700\u5927\u6761\u76EE\u6570" }), numeric('cacheMaxEntries', 1)] })] }), _jsxs("div", { style: card, children: [_jsx("div", { style: sectionTitle, children: _jsx("strong", { children: "\u8D39\u7528\u4F30\u7B97\uFF08\u6BCF\u767E\u4E07 Token\uFF0CUSD\uFF09" }) }), _jsxs("div", { style: row, children: [_jsx(Label, { title: "\u8F93\u5165\u4EF7\u683C", help: "\u4EC5\u7528\u4E8E\u7ED3\u679C\u4E2D\u7684 estimatedCostUsd" }), numeric('estimatedInputUsdPerMillion', 0)] }), _jsxs("div", { style: row, children: [_jsx(Label, { title: "\u8F93\u51FA\u4EF7\u683C", help: "\u4EC5\u7528\u4E8E\u7ED3\u679C\u4E2D\u7684 estimatedCostUsd" }), numeric('estimatedOutputUsdPerMillion', 0)] })] }), loaded.failures.length > 0 && _jsxs("div", { style: { ...card, borderColor: 'var(--dsw-alias-state-warn-primary, #d9a441)', paddingBottom: 16 }, children: [_jsx("strong", { children: "\u90E8\u5206\u6A21\u578B\u76EE\u5F55\u8BFB\u53D6\u5931\u8D25" }), loaded.failures.map(x => _jsx("div", { children: x }, x))] }), error && _jsx("div", { style: { color: 'var(--dsw-danger)' }, children: error }), saved && _jsx("div", { style: { color: 'var(--dsw-success)' }, children: "\u5DF2\u4FDD\u5B58\uFF0C\u540E\u7EED verifier \u8C03\u7528\u5C06\u4F7F\u7528\u65B0\u8BBE\u7F6E\u3002" }), _jsxs("div", { style: { display: 'flex', gap: 10 }, children: [_jsx(Button, { disabled: busy || !loaded.writable, onClick: () => void save(), children: busy ? '保存中…' : '保存设置' }), _jsx(Button, { variant: "outline", disabled: busy, onClick: () => void load(), children: "\u91CD\u65B0\u8F7D\u5165" })] })] });
+}
+export const inject = ['slots', 'connection'];
+export function apply(ctx) { const connection = ctx.get('connection'); ctx.slots.inject('settings.section', () => ctx.slots.register({ name: 'settings.section', id: 'llm-verifier', order: 35, label: 'LLM Verifier', inject: () => ({ api: connection.api }) }, VerifierSettings)); }
+//# sourceMappingURL=client.js.map

package/lib/types/config.d.ts

@@ -0,0 +1,35 @@
+import type { Context } from '@deepseek-ai/cordis';
+import z from 'schemastery';
+export declare const VERIFIER_SETTINGS_NAMESPACE: import("@deepseek-ai/dsh-settings").SettingsNamespace;
+export interface Config {
+    provider?: string;
+    model?: string;
+    reasoningEffort?: string;
+    maxTokens?: number;
+    timeoutMs?: number;
+    maxConcurrency?: number;
+    maxRetries?: number;
+    retryBaseDelayMs?: number;
+    cacheDir?: string;
+    cacheMaxEntries?: number;
+    estimatedInputUsdPerMillion?: number;
+    estimatedOutputUsdPerMillion?: number;
+}
+export interface ResolvedConfig {
+    provider: string;
+    model: string;
+    reasoningEffort?: string;
+    maxTokens: number;
+    timeoutMs: number;
+    maxConcurrency: number;
+    maxRetries: number;
+    retryBaseDelayMs: number;
+    cacheDir: string;
+    cacheMaxEntries: number;
+    estimatedInputUsdPerMillion: number;
+    estimatedOutputUsdPerMillion: number;
+}
+export declare const Config: z<Config>;
+export declare function resolveConfig(config?: Config): ResolvedConfig;
+export declare function installVerifierSettings(ctx: Context, entry: ResolvedConfig, onChange: () => void): () => ResolvedConfig;
+//# sourceMappingURL=config.d.ts.map

package/lib/types/config.js

@@ -0,0 +1,57 @@
+import { installSettingsSection, settingsNamespace } from '@deepseek-ai/dsh-settings';
+import z from 'schemastery';
+export const VERIFIER_SETTINGS_NAMESPACE = settingsNamespace('llm-verifier');
+export const Config = z.object({
+    provider: z.string().default('deepseek-official'),
+    model: z.string().default('deepseek-v4-flash'),
+    reasoningEffort: z.string(),
+    maxTokens: z.number().step(1).min(1).default(32768),
+    timeoutMs: z.number().step(1).min(1).default(300000),
+    maxConcurrency: z.number().step(1).min(1).default(8),
+    maxRetries: z.number().step(1).min(0).default(3),
+    retryBaseDelayMs: z.number().step(1).min(1).default(500),
+    cacheDir: z.string().default('.dsh-verifier-cache'),
+    cacheMaxEntries: z.number().step(1).min(1).default(10000),
+    estimatedInputUsdPerMillion: z.number().min(0).default(0),
+    estimatedOutputUsdPerMillion: z.number().min(0).default(0),
+});
+export function resolveConfig(config = {}) {
+    const provider = (config.provider ?? 'deepseek-official').trim();
+    const model = (config.model ?? 'deepseek-v4-flash').trim();
+    if (!provider)
+        throw new Error('llm-verifier: provider must be non-empty');
+    if (!model)
+        throw new Error('llm-verifier: model must be non-empty');
+    const values = {
+        maxTokens: config.maxTokens ?? 32768,
+        timeoutMs: config.timeoutMs ?? 300000,
+        maxConcurrency: config.maxConcurrency ?? 8,
+        retryBaseDelayMs: config.retryBaseDelayMs ?? 500,
+        cacheMaxEntries: config.cacheMaxEntries ?? 10000,
+    };
+    for (const [name, value] of Object.entries(values))
+        if (!Number.isSafeInteger(value) || value <= 0)
+            throw new Error('llm-verifier: ' + name + ' must be a positive safe integer');
+    const maxRetries = config.maxRetries ?? 3;
+    if (!Number.isSafeInteger(maxRetries) || maxRetries < 0)
+        throw new Error('llm-verifier: maxRetries must be a non-negative safe integer');
+    const cacheDir = (config.cacheDir ?? '.dsh-verifier-cache').trim();
+    if (!cacheDir)
+        throw new Error('llm-verifier: cacheDir must be non-empty');
+    const estimatedInputUsdPerMillion = config.estimatedInputUsdPerMillion ?? 0;
+    const estimatedOutputUsdPerMillion = config.estimatedOutputUsdPerMillion ?? 0;
+    if (![estimatedInputUsdPerMillion, estimatedOutputUsdPerMillion].every(value => Number.isFinite(value) && value >= 0))
+        throw new Error('llm-verifier: estimated token prices must be finite non-negative numbers');
+    const reasoningEffort = config.reasoningEffort?.trim();
+    return { provider, model, ...(reasoningEffort ? { reasoningEffort } : {}), maxRetries, cacheDir, estimatedInputUsdPerMillion, estimatedOutputUsdPerMillion, ...values };
+}
+export function installVerifierSettings(ctx, entry, onChange) {
+    let source = () => entry;
+    installSettingsSection(ctx, VERIFIER_SETTINGS_NAMESPACE, Config, entry, {
+        setSource(current) { source = current; },
+        onChange,
+        validate(value) { resolveConfig(value); },
+    });
+    return () => resolveConfig(source());
+}
+//# sourceMappingURL=config.js.map

package/lib/types/core.d.ts

@@ -0,0 +1,38 @@
+/** Pure scoring and Probabilistic Pivot Tournament primitives. */
+export interface Criterion {
+    id: string;
+    name: string;
+    description: string;
+}
+export interface TokenAlternative {
+    token: string;
+    logprob: number;
+}
+export interface CompletionLogprobs {
+    text: string;
+    tokens: string[];
+    positions: TokenAlternative[][];
+}
+export interface CandidateScore {
+    index: number;
+    score: number;
+}
+export declare const GRANULARITY = 20;
+export declare const LETTERS: string[];
+export declare const SCALE_DESCRIPTION: string;
+export declare const DEFAULT_CRITERIA: Criterion[];
+export declare const DEFAULT_GROUND_TRUTH_NOTE = "**IMPORTANT:** Focus on observed tool and terminal output as ground truth. Do NOT trust the agent's self-assessment or claims of success.";
+export declare function normalizeScoreLetter(token: string): string | undefined;
+export declare function extractScore(completion: CompletionLogprobs, tag: string): number;
+export declare function buildPairwisePrompt(problem: string, traceA: string, traceB: string, criterion: Criterion, groundTruthNote?: string): string;
+export declare function buildProgressPrompt(problem: string, steps: readonly string[], checkpoints: readonly number[]): string;
+/** Progress uses A=NO..T=YES, the reverse of pairwise success scoring. */
+export declare function extractProgressScore(completion: CompletionLogprobs, tag: string): number;
+export declare function bradleyTerry(rewardA: number, rewardB: number): number;
+export declare function seededRandom(seed: number): () => number;
+export declare function ringCycle(count: number, seed?: number): Array<[number, number]>;
+export declare function pivotRoundPairs(count: number, pivots: readonly number[]): Array<[number, number]>;
+export declare function accumulatePairs(pairs: readonly [number, number][], rewards: ReadonlyMap<string, readonly [number, number]>, wins: number[], counts: number[]): void;
+export declare function topPivots(wins: readonly number[], counts: readonly number[], requested: number): number[];
+export declare function rankScores(wins: readonly number[], counts: readonly number[]): CandidateScore[];
+//# sourceMappingURL=core.d.ts.map