@openvulcan/dsh-vulcancode 0.0.0-stage → 0.4.0

package/node_modules/@openvulcan/vulcan-decision/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 OpenVulcan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/@openvulcan/vulcan-decision/README.md

@@ -0,0 +1,23 @@
+# @openvulcan/vulcan-decision
+
+Vulcan Decision 的判定引擎与命令行。它判断 AI 编码工具的一次工具调用应当放行（allow）、确认（review）还是
+拦截（block），供各宿主插件共用。判定默认走 OpenVulcan 云端节点；也可以按需安装本机运行包，在本机运行
+`vulcan-decision-shell` 模型。本包没有原生依赖与安装脚本。
+
+```sh
+npx @openvulcan/vulcan-decision login --site cn          # 或 global
+npx @openvulcan/vulcan-decision cloud probe
+npx @openvulcan/vulcan-decision judge --tool shell_command --args '{"command":"git status"}'
+
+npx @openvulcan/vulcan-decision hardware                 # 显卡、NPU 与推荐的运行包
+npx @openvulcan/vulcan-decision packs install torch-cu128 --source cn
+npx @openvulcan/vulcan-decision models install <模型目录>
+npx @openvulcan/vulcan-decision judge --tool shell_command --args '{"command":"git status"}' --pack torch-cu128 --model <模型 id>
+```
+
+运行包（`onnx-cpu`、`onnx-cuda`、`torch-cpu`、`torch-cu128`）是预编译的 Python 与官方 wheel，按锁定的 SHA-256
+校验，不编译任何东西，也不安装驱动。数据目录默认为 `~/.vulcan-decision`，可用 `VULCAN_DECISION_HOME` 改到别处；
+宿主插件使用自己的目录，账号由宿主提供。本包属于
+[dsh-vulcancode](https://github.com/OpenVulcan/dsh-vulcancode) 套件。
+
+许可：MIT

package/node_modules/@openvulcan/vulcan-decision/bin/vulcan-decision.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { main } from '../lib/cli.js'
+
+process.exitCode = await main(process.argv.slice(2))

package/node_modules/@openvulcan/vulcan-decision/lib/cli.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The `vulcan-decision` command line: the account, runtime packs, models and test judgements.
+ */
+/** Run one command. @returns the process exit code. */
+export declare function main(args: readonly string[]): Promise<number>;

package/node_modules/@openvulcan/vulcan-decision/lib/cli.js

@@ -0,0 +1,267 @@
+/**
+ * The `vulcan-decision` command line: the account, runtime packs, models and test judgements.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import { parseArgs } from 'node:util';
+import { AccountError, FileCredentialStore, isSite, OpenVulcanAccount } from '@openvulcan/openvulcan-account';
+import { EdgeClient, TEST_PRESETS } from './cloud/edge.js';
+import { DOWNLOAD_SOURCES } from './download.js';
+import { DecisionEngine } from './engine.js';
+import { detectHardware, gpuGeneration, recommend } from './hardware.js';
+import { defaultHome } from './home.js';
+import { LocalEngine } from './local/engine.js';
+import { backendOf, downloadModel, installModelFromDirectory, listModels, MODEL_CATALOG, MODEL_FAMILIES, MODEL_SOURCES, PACKAGE_PRECISIONS, preferredPrecision, removeModel, sourcesOf } from './local/models.js';
+import { installPack, installedPack, isPackId, PACK_IDS, PLANNED_PACKS, readLock, removePack } from './local/packs.js';
+import { DEFAULT_OPTIONS, DecisionError } from './protocol.js';
+import { VERSION } from './version.js';
+const USAGE = `vulcan-decision ${VERSION}
+
+Usage:
+  vulcan-decision hardware                     Graphics cards, NPUs and the recommended runtime pack
+  vulcan-decision login [--site cn|global]     Sign in to OpenVulcan in the browser
+  vulcan-decision logout                       Sign out and revoke this device
+  vulcan-decision account                      Show the signed-in account
+  vulcan-decision cloud models                 Models this account may use
+  vulcan-decision cloud probe [--model <id>]   Measure the endpoints of a cloud model
+  vulcan-decision cloud test --endpoint <id> [--model <id>] [--preset <${TEST_PRESETS.join('|')}> | --command <cmd>]
+                                               Time five real judgements on one endpoint
+  vulcan-decision packs                        Runtime packs and whether they fit this machine
+  vulcan-decision packs install <pack> [--source official|cn]
+  vulcan-decision packs remove <pack>
+  vulcan-decision models                       Installed and published local models
+  vulcan-decision models install <dir>         Install a model package from a local directory
+  vulcan-decision models download <mini|flash|standard> --from <huggingface|modelscope-intl|modelscope-cn>
+  vulcan-decision models remove <id>
+  vulcan-decision judge --tool <name> --args <json> [--project <dir>] [--cloud <model> | --pack <pack> --model <id>]
+  vulcan-decision eval --input <file> --pack <pack> --model <id>
+                                               Judge {settings, rendered} records locally, printing JSON
+
+The data directory is ${defaultHome().root}; set VULCAN_DECISION_HOME to use another one.`;
+/** Run one command. @returns the process exit code. */
+export async function main(args) {
+    const [command, ...rest] = args;
+    const home = defaultHome();
+    try {
+        switch (command) {
+            case 'hardware':
+                return runHardware();
+            case 'login':
+                return await runLogin(home, rest);
+            case 'logout':
+                await account(home).signOut();
+                console.log('signed out');
+                return 0;
+            case 'account':
+                console.log(JSON.stringify(await account(home).status(), null, 2));
+                return 0;
+            case 'cloud':
+                return await runCloud(home, rest);
+            case 'packs':
+                return await runPacks(home, rest);
+            case 'models':
+                return await runModels(home, rest);
+            case 'judge':
+                return await runJudge(home, rest);
+            case 'eval':
+                return await runEval(home, rest);
+            case undefined:
+            case 'help':
+            case '--help':
+            case '-h':
+                console.log(USAGE);
+                return 0;
+            default:
+                console.error(`unknown command ${command}\n\n${USAGE}`);
+                return 2;
+        }
+    }
+    catch (error) {
+        console.error(error instanceof DecisionError || error instanceof AccountError ? `${error.code}: ${error.message}` : error.message);
+        return 1;
+    }
+}
+function account(home) {
+    return new OpenVulcanAccount(new FileCredentialStore(home.file('account.json')), device(), process.env.VULCAN_DECISION_AUTH_ORIGIN);
+}
+function device() {
+    return { display_name: `Vulcan Decision CLI on ${os.hostname()}`, client_version: `vulcan-decision ${VERSION}` };
+}
+function runHardware() {
+    const hardware = detectHardware();
+    const recommendation = recommend(hardware);
+    const gpus = hardware.gpus.map(gpu => ({
+        ...gpu,
+        ...gpu.computeCapability === undefined ? {} : { generation: gpuGeneration(gpu.computeCapability) },
+    }));
+    console.log(JSON.stringify({ ...hardware, gpus, recommendation }, null, 2));
+    return 0;
+}
+async function runLogin(home, args) {
+    const { values } = parseArgs({ args: [...args], options: { site: { type: 'string', default: 'global' } } });
+    if (!isSite(values.site))
+        throw new Error('--site must be cn or global');
+    const pending = await account(home).signIn(values.site);
+    console.log(`Open this page to approve the sign-in:\n${pending.approvalUrl}`);
+    const status = await pending.done;
+    console.log(`signed in to ${status.site}, valid until ${status.expiresAt}`);
+    return 0;
+}
+async function runCloud(home, args) {
+    const [sub, ...rest] = args;
+    const edge = new EdgeClient(account(home));
+    if (sub === 'models') {
+        console.log((await edge.models()).join('\n'));
+        return 0;
+    }
+    if (sub === 'probe') {
+        const { values } = parseArgs({ args: rest, options: { model: { type: 'string' } } });
+        console.log(JSON.stringify(await edge.probe(await edge.resolveModel(values.model)), null, 2));
+        return 0;
+    }
+    if (sub === 'test') {
+        const { values } = parseArgs({ args: rest, options: { model: { type: 'string' }, endpoint: { type: 'string' }, preset: { type: 'string', default: 'ordinary' }, command: { type: 'string' } } });
+        if (values.endpoint === undefined)
+            throw new Error('--endpoint is required');
+        if (values.command === undefined && !TEST_PRESETS.includes(values.preset))
+            throw new Error(`--preset must be one of ${TEST_PRESETS.join(', ')}`);
+        const input = values.command === undefined ? { kind: 'preset', preset: values.preset } : { kind: 'custom', command: values.command };
+        console.log(JSON.stringify(await edge.requestTest(await edge.resolveModel(values.model), values.endpoint, input), null, 2));
+        return 0;
+    }
+    throw new Error('usage: cloud models | cloud probe [--model <id>] | cloud test --endpoint <id>');
+}
+async function runPacks(home, args) {
+    const [sub, id, ...rest] = args;
+    if (sub === undefined) {
+        const recommendation = recommend(detectHardware());
+        for (const pack of PACK_IDS) {
+            const fit = recommendation.packs.find(item => item.pack === pack);
+            const installed = installedPack(home, pack);
+            const state = installed === undefined ? 'not installed' : installed.lock === readLock(pack).id ? 'installed' : 'installed, outdated';
+            const size = fit.bytes === undefined ? '' : `${(fit.bytes / 1024 ** 2).toFixed(0)} MiB`;
+            console.log(`${pack.padEnd(12)} ${fit.fit.padEnd(16)} ${size.padStart(9)}  ${state}`);
+        }
+        for (const planned of PLANNED_PACKS)
+            console.log(`${planned.id.padEnd(12)} planned          (${planned.accelerator}: waiting for an NPU model release)`);
+        return 0;
+    }
+    if (!isPackId(id))
+        throw new Error(`unknown pack ${String(id)}; known: ${PACK_IDS.join(', ')}`);
+    if (sub === 'install') {
+        const { values } = parseArgs({ args: rest, options: { source: { type: 'string', default: 'official' } } });
+        if (!DOWNLOAD_SOURCES.includes(values.source))
+            throw new Error('--source must be official or cn');
+        let lastPercent = -1;
+        const record = await installPack(home, id, {
+            source: values.source,
+            onProgress: progress => {
+                if (progress.phase !== 'download') {
+                    console.error(progress.phase);
+                    return;
+                }
+                const percent = Math.floor((progress.done / progress.total) * 100);
+                if (percent !== lastPercent && percent % 5 === 0)
+                    console.error(`download ${percent}% (${progress.file})`);
+                lastPercent = percent;
+            },
+        });
+        console.log(JSON.stringify(record, null, 2));
+        return 0;
+    }
+    if (sub === 'remove') {
+        console.log(removePack(home, id) ? `removed ${id}` : `${id} was not installed`);
+        return 0;
+    }
+    throw new Error('usage: packs [install <pack> | remove <pack>]');
+}
+async function runModels(home, args) {
+    const [sub, target, ...rest] = args;
+    const progress = (done, total, file) => {
+        if (file !== '')
+            console.error(`${total === 0 ? 100 : Math.floor((done / total) * 100)}% ${file}`);
+    };
+    if (sub === undefined) {
+        for (const model of listModels(home))
+            console.log(`installed  ${model.id}  ${model.package_format}  ${(model.bytes / 1024 ** 2).toFixed(0)} MiB`);
+        for (const model of MODEL_CATALOG) {
+            const sources = sourcesOf(model);
+            console.log(`published  ${model.family} (${model.name}, ${model.parameters}, ${Object.keys(model.packages).join('/')})  ${sources.length === 0 ? 'no download address yet' : sources.join(', ')}`);
+        }
+        return 0;
+    }
+    if (sub === 'install' && target !== undefined) {
+        const model = await installModelFromDirectory(home, target, { onProgress: progress });
+        console.log(`installed ${model.id} (${model.package_format})`);
+        return 0;
+    }
+    if (sub === 'download' && target !== undefined) {
+        const { values } = parseArgs({ args: rest, options: { from: { type: 'string' }, precision: { type: 'string' } } });
+        const entry = MODEL_CATALOG.find(model => model.family === target);
+        if (entry === undefined)
+            throw new Error(`unknown model ${target}; known: ${MODEL_FAMILIES.join(', ')}`);
+        if (!MODEL_SOURCES.includes(values.from))
+            throw new Error(`--from must be one of ${MODEL_SOURCES.join(', ')}`);
+        if (values.precision !== undefined && !PACKAGE_PRECISIONS.includes(values.precision))
+            throw new Error(`--precision must be one of ${PACKAGE_PRECISIONS.join(', ')}`);
+        const precision = values.precision ?? preferredPrecision(entry, recommend(detectHardware()).onnxPack);
+        if (precision === undefined)
+            throw new Error(`${entry.family} has no published package`);
+        const model = await downloadModel(home, entry.family, precision, values.from, { onProgress: progress });
+        console.log(`installed ${model.id}`);
+        return 0;
+    }
+    if (sub === 'remove' && target !== undefined) {
+        console.log(removeModel(home, target) ? `removed ${target}` : `${target} was not installed`);
+        return 0;
+    }
+    throw new Error('usage: models [install <dir> | download <family> --from <source> [--precision fp16|fp32] | remove <id>]');
+}
+async function runJudge(home, args) {
+    const { values } = parseArgs({
+        args: [...args],
+        options: {
+            tool: { type: 'string' }, args: { type: 'string', default: '{}' }, project: { type: 'string' },
+            cloud: { type: 'string' }, pack: { type: 'string' }, model: { type: 'string' },
+        },
+    });
+    if (values.tool === undefined)
+        throw new Error('--tool is required');
+    const engine = new DecisionEngine({ home, account: account(home) });
+    try {
+        const local = values.pack === undefined ? undefined : { pack: packArgument(values.pack), model: values.model ?? '' };
+        const verdict = await engine.judge({ tool: values.tool, arguments: JSON.parse(values.args), ...values.project === undefined ? {} : { project: values.project } }, { backend: local === undefined ? 'cloud' : 'local', cloudModel: values.cloud ?? '', ...local === undefined ? {} : { local }, options: DEFAULT_OPTIONS });
+        console.log(JSON.stringify(verdict, null, 2));
+        return 0;
+    }
+    finally {
+        engine.stop();
+    }
+}
+async function runEval(home, args) {
+    const { values } = parseArgs({ args: [...args], options: { input: { type: 'string' }, pack: { type: 'string' }, model: { type: 'string' } } });
+    if (values.input === undefined || values.pack === undefined || values.model === undefined)
+        throw new Error('--input, --pack and --model are required');
+    const inputs = JSON.parse(fs.readFileSync(values.input, 'utf8'));
+    const model = listModels(home).find(item => item.id === values.model);
+    const pack = packArgument(values.pack);
+    if (model !== undefined && backendOf(model.package_format) !== readLock(pack).backend)
+        throw new Error(`${model.id} does not run on ${pack}`);
+    const engine = new LocalEngine(home);
+    try {
+        const started = performance.now();
+        const loaded = await engine.warm({ pack, model: values.model });
+        const loadedAt = performance.now();
+        const results = await engine.judge({ pack, model: values.model }, inputs);
+        console.log(JSON.stringify({ loaded, load_ms: Math.round(loadedAt - started), judge_ms: Math.round(performance.now() - loadedAt), results }, null, 2));
+        return 0;
+    }
+    finally {
+        engine.stop();
+    }
+}
+function packArgument(value) {
+    if (!isPackId(value))
+        throw new Error(`unknown pack ${value}; known: ${PACK_IDS.join(', ')}`);
+    return value;
+}

package/node_modules/@openvulcan/vulcan-decision/lib/cloud/edge.d.ts

@@ -0,0 +1,211 @@
+/**
+ * The cloud backend: OpenVulcan's decision endpoints, as VulcanCode uses them.
+ *
+ * The signed-in device asks its auth host for the models it may use (`edge-models`; the server
+ * decides, nothing is hard-coded) and, per model, for a short-lived access grant (`edge-access`):
+ * an EdDSA token valid on every endpoint of that model, the account's site and the endpoint list.
+ * Calls go straight to one endpoint's `POST /v1/judge` with `Authorization: Bearer` and
+ * `X-OpenVulcan-Site`.
+ *
+ * The endpoint is chosen by measurement, never per request: each endpoint's public `/v1/status` is
+ * fetched three times in a row, endpoint after endpoint, at start, every 10 minutes and at most
+ * every 30 seconds after a failure. The score is the median round trip plus the reported median
+ * compute time (round trip alone when any eligible endpoint has not measured compute yet), and a
+ * new endpoint wins only when it scores below 80% of the current one. A user lock always uses its
+ * endpoint and never fails over. A request that fails is an error, never an allow, and is never
+ * retried on another endpoint.
+ */
+import { type JudgeInput, type ModelResult } from '../protocol.js';
+import { type AccountSource, type Site } from '@openvulcan/openvulcan-account';
+export interface EdgeEndpoint {
+    readonly endpoint_id: string;
+    readonly endpoint: string;
+    readonly priority: number;
+    readonly online: boolean;
+}
+export interface EdgeGrant {
+    readonly model_id: string;
+    readonly site: Site | string;
+    readonly endpoints: readonly EdgeEndpoint[];
+    readonly access_token: string;
+    readonly expires_at: string;
+}
+/** One endpoint's `/v1/status` answer, reduced to what selection reads. */
+export interface EndpointStatus {
+    readonly endpoint_id: string;
+    readonly model_id: string;
+    readonly region?: string;
+    readonly sites: readonly string[];
+    readonly ready: boolean;
+    readonly compute_ms: {
+        readonly p50: number;
+        readonly p95: number;
+    } | null;
+}
+/** One probe of one endpoint. */
+export interface ProbeResult {
+    readonly endpoint_id: string;
+    /** Lower median round trip of the successful attempts, undefined when all failed. */
+    readonly rtt_ms?: number;
+    readonly status?: EndpointStatus;
+    /** Why it cannot be used, when it cannot. */
+    readonly excluded?: 'unreachable' | 'wrong_endpoint' | 'wrong_model' | 'site_not_served' | 'not_ready';
+    /** The last failure of an unreachable endpoint. */
+    readonly error?: string;
+    readonly at: number;
+}
+/** One row of the endpoint table, as hosts show it. */
+export interface EndpointRow {
+    readonly endpointId: string;
+    readonly endpoint: string;
+    readonly priority: number;
+    readonly online: boolean;
+    readonly region?: string;
+    readonly ready?: boolean;
+    readonly acceptsSite?: boolean;
+    readonly rttMs?: number;
+    readonly computeP50Ms?: number;
+    readonly scoreMs?: number;
+    readonly error?: string;
+}
+/** The endpoint table of the current model. */
+export interface EndpointSnapshot {
+    readonly modelId?: string;
+    readonly site?: string;
+    readonly mode: 'auto' | 'locked';
+    readonly lockedEndpointId?: string;
+    readonly selectedEndpointId?: string;
+    readonly probedAtMs?: number;
+    readonly nextProbeAtMs?: number;
+    /** Why there is no table: no sign-in, no model, or the grant was refused. */
+    readonly error?: string;
+    readonly endpoints: readonly EndpointRow[];
+}
+/** The sample calls a request test can send, besides a custom command. */
+export declare const TEST_PRESETS: readonly ["ordinary", "destructive", "database_reset", "oversized"];
+export type TestPreset = typeof TEST_PRESETS[number];
+export type TestInput = {
+    readonly kind: 'preset';
+    readonly preset: TestPreset;
+} | {
+    readonly kind: 'custom';
+    readonly command: string;
+};
+/** One timed request of a request test. Times are milliseconds; absent when not reported. */
+export interface TestAttempt {
+    readonly requestId: string;
+    readonly totalMs: number;
+    readonly networkMs?: number;
+    readonly endpointMs?: number;
+    readonly nodeMs?: number;
+    readonly queueMs?: number;
+    readonly computeMs?: number;
+    readonly httpStatus?: number;
+    readonly tokenRenewed: boolean;
+    readonly answer?: JudgeAnswer;
+    readonly errorCode?: string;
+    readonly error?: string;
+}
+export interface TestResult {
+    readonly modelId: string;
+    readonly endpointId: string;
+    readonly endpoint: string;
+    readonly site: string;
+    readonly renderedChars: number;
+    readonly attempts: readonly TestAttempt[];
+    readonly succeeded: number;
+    readonly minMs?: number;
+    readonly medianMs?: number;
+    readonly maxMs?: number;
+}
+/** A checked `/v1/judge` answer. */
+export interface JudgeAnswer {
+    readonly region?: string;
+    readonly model?: string;
+    readonly checkpointSha256: string;
+    readonly policyVersion: string;
+    readonly results: readonly ModelResult[];
+}
+export declare const PROBE_INTERVAL_MS: number;
+export declare const TEST_ATTEMPTS = 5;
+export declare const MAX_TEST_COMMAND = 65536;
+export declare class EdgeClient {
+    private readonly account;
+    private readonly fetchImpl;
+    private grant;
+    private grantKey;
+    private grantError;
+    private modelList;
+    private probes;
+    private probedFor;
+    private probedAt;
+    private lastFailureProbe;
+    private selected;
+    private probing;
+    constructor(account: AccountSource, fetchImpl?: typeof fetch);
+    /** The account's credential; an account that cannot supply one means "not signed in". */
+    private credential;
+    /** Models this account may use, sorted; the first is the default. */
+    models(): Promise<string[]>;
+    /**
+     * The model to use: the saved one, or else the first one OpenVulcan lists for this account.
+     * @throws DecisionError when nothing is saved and the account has no model.
+     */
+    resolveModel(saved: string | undefined): Promise<string>;
+    /** The endpoint table of `model` with the last measurements, without measuring. */
+    snapshot(model: string | undefined, lock?: string): EndpointSnapshot;
+    /** Forget grants, model lists and measurements, after a sign-out or account change. */
+    reset(): void;
+    /**
+     * Measure every endpoint of `model` now and update the selection.
+     * @param lock the endpoint id the user locked, which is never replaced.
+     */
+    probe(model: string, lock?: string): Promise<EndpointSnapshot>;
+    /** Measure `model` in the background when its last measurement is older than the interval. */
+    refreshIfStale(model: string): void;
+    /** Check that `endpointId` serves `model`, for a lock the user is about to save. */
+    checkEndpoint(model: string, endpointId: string): Promise<void>;
+    /**
+     * Judge `inputs` with `model` on the selected (or locked) endpoint.
+     * @throws DecisionError for every failure; a failure never carries a decision.
+     */
+    judge(model: string, inputs: readonly JudgeInput[], lock?: string): Promise<{
+        results: ModelResult[];
+        endpoint: string;
+    }>;
+    /**
+     * Send {@link TEST_ATTEMPTS} real judgements of one sample call to one endpoint, one after
+     * another, and time each. The grant is fetched first so its call is not timed. Nothing changes
+     * the selection.
+     */
+    requestTest(model: string, endpointId: string, input: TestInput): Promise<TestResult>;
+    private post;
+    private send;
+    /** The current grant for `model`, renewed when it is about to expire or `renew` is set. */
+    private access;
+    private choose;
+    private measureOnce;
+    private afterFailure;
+    private measure;
+    private probeEndpoint;
+    private compareCompute;
+    /** Map account-host failures to decision errors. */
+    private call;
+}
+/** The command a request test sends. */
+export declare function testCommand(input: TestInput): string;
+/** The `edge`, `node`, `queue` and `compute` durations of a `Server-Timing` header. */
+export declare function parseServerTiming(header: string | null): Partial<Record<'edge' | 'node' | 'queue' | 'compute', number>>;
+/**
+ * The endpoint to use after a measurement: the lowest score (ties by priority, then id), unless
+ * the current one is still usable and the best is not 20% better.
+ */
+export declare function selectEndpoint(endpoints: readonly EdgeEndpoint[], probes: readonly ProbeResult[], current: string | undefined): string | undefined;
+export declare function parseGrant(value: unknown, model: string): EdgeGrant;
+/** A bare https origin, or http on a loopback address. */
+export declare function isEndpointOrigin(value: string): boolean;
+export declare function parseStatus(value: unknown): EndpointStatus | undefined;
+/** Check a `/v1/judge` answer against the request before anyone acts on it. */
+export declare function parseJudgeAnswer(text: string, requestId: string, count: number): ModelResult[];
+/** {@link parseJudgeAnswer} with the answer's region, model and checkpoint. */
+export declare function parseJudgeEnvelope(text: string, requestId: string, count: number): JudgeAnswer;