@try-works/dsh-tool-mode 0.0.0-stage → 0.5.45

package/lib/decision-evaluate.js

@@ -0,0 +1,227 @@
+/**
+ * Domain-neutral confidence routing and evaluation for judgment tools.
+ *
+ * Two general lessons are drawn from a published identity-resolution evaluation
+ * (Hightouch, 2026-11-04); that domain is provenance, not scope:
+ * - a fixed 50% cutoff is arbitrary; thresholds trade false positives for false negatives;
+ * - a well-calibrated cheap judge can escalate only its uncertain band to an expensive
+ *   evaluator and approach frontier accuracy at much lower cost.
+ *
+ * These functions are pure. They never call a model; the caller supplies the primary
+ * probability (and, when escalations happen, the secondary one).
+ */
+/**
+ * Route a primary judgment by a two-sided confidence band.
+ *
+ * The defaults are the article's shape (middle band escalated), but NOT a claim
+ * that these thresholds are calibrated for our models: pass reviewed thresholds.
+ * @param probability - the primary judge's probability that the condition is true.
+ * @param acceptAt - at or above this, accept true (default 0.9).
+ * @param rejectAt - at or below this, accept false (default 0.1).
+ * @returns the route, decision and band.
+ */
+export function routeConfidence(probability, acceptAt = 0.9, rejectAt = 0.1) {
+    if (typeof probability !== 'number' || !Number.isFinite(probability) || probability < 0 || probability > 1) {
+        throw new Error('probability must be a finite number in [0,1]');
+    }
+    if (!Number.isFinite(acceptAt) || !Number.isFinite(rejectAt) || rejectAt < 0 || acceptAt > 1 || rejectAt >= acceptAt) {
+        throw new Error('thresholds must satisfy 0 <= rejectAt < acceptAt <= 1');
+    }
+    if (probability >= acceptAt) {
+        return { route: 'accept', decision: true, band: 'high', reason: `p=${probability.toFixed(4)} >= acceptAt=${acceptAt}` };
+    }
+    if (probability <= rejectAt) {
+        return { route: 'reject', decision: false, band: 'low', reason: `p=${probability.toFixed(4)} <= rejectAt=${rejectAt}` };
+    }
+    return { route: 'escalate', decision: null, band: 'middle', reason: `p=${probability.toFixed(4)} lies in (${rejectAt}, ${acceptAt})` };
+}
+function validCase(raw, index) {
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+        throw new Error(`cases[${index}] must be an object`);
+    const c = raw;
+    if (typeof c.expected !== 'boolean')
+        throw new Error(`cases[${index}].expected must be a boolean`);
+    if (typeof c.probability !== 'number' || !Number.isFinite(c.probability) || c.probability < 0 || c.probability > 1) {
+        throw new Error(`cases[${index}].probability must be a finite number in [0,1]`);
+    }
+    if (c.escalatedProbability !== undefined && (typeof c.escalatedProbability !== 'number' || !Number.isFinite(c.escalatedProbability) || c.escalatedProbability < 0 || c.escalatedProbability > 1)) {
+        throw new Error(`cases[${index}].escalatedProbability must be a finite number in [0,1]`);
+    }
+    for (const [key, value] of [['costUsd', c.costUsd], ['latencyMs', c.latencyMs]]) {
+        if (value !== undefined && (typeof value !== 'number' || !Number.isFinite(value) || value < 0)) {
+            throw new Error(`cases[${index}].${key} must be a non-negative finite number`);
+        }
+    }
+    return {
+        ...(typeof c.id === 'string' ? { id: c.id } : {}),
+        expected: c.expected,
+        probability: c.probability,
+        ...c.escalatedProbability === undefined ? {} : { escalatedProbability: c.escalatedProbability },
+        ...c.costUsd === undefined ? {} : { costUsd: c.costUsd },
+        ...c.latencyMs === undefined ? {} : { latencyMs: c.latencyMs },
+    };
+}
+function metrics(cases, decide) {
+    let correct = 0;
+    let tp = 0;
+    let tn = 0;
+    let fp = 0;
+    let fn = 0;
+    let brier = 0;
+    const bins = Array.from({ length: 10 }, () => ({ count: 0, predicted: 0, observed: 0 }));
+    for (const c of cases) {
+        const predicted = decide(c);
+        if (predicted === c.expected)
+            correct += 1;
+        if (predicted && c.expected)
+            tp += 1;
+        else if (!predicted && !c.expected)
+            tn += 1;
+        else if (predicted && !c.expected)
+            fp += 1;
+        else
+            fn += 1;
+        brier += (c.probability - (c.expected ? 1 : 0)) ** 2;
+        const bin = Math.min(9, Math.floor(c.probability * 10));
+        const slot = bins[bin];
+        slot.count += 1;
+        slot.predicted += c.probability;
+        slot.observed += c.expected ? 1 : 0;
+    }
+    let ece = 0;
+    for (const slot of bins) {
+        if (slot.count === 0)
+            continue;
+        ece += (slot.count / cases.length) * Math.abs(slot.predicted / slot.count - slot.observed / slot.count);
+    }
+    const positives = cases.filter(c => c.expected).length;
+    const negatives = cases.length - positives;
+    return {
+        count: cases.length,
+        correct,
+        accuracy: cases.length === 0 ? 0 : correct / cases.length,
+        truePositives: tp,
+        trueNegatives: tn,
+        falsePositives: fp,
+        falseNegatives: fn,
+        falsePositiveRate: negatives === 0 ? 0 : fp / negatives,
+        falseNegativeRate: positives === 0 ? 0 : fn / positives,
+        brier: cases.length === 0 ? 0 : brier / cases.length,
+        expectedCalibrationError: cases.length === 0 ? 0 : ece,
+    };
+}
+/**
+ * Evaluate a labeled set: fixed threshold, best observed threshold, calibration bins,
+ * and an optional hybrid arm that sends the middle band to the secondary probability.
+ * @param rawCases - labeled observations.
+ * @param threshold - the primary cutoff (default 0.5).
+ * @param escalation - optional `{rejectAt, acceptAt}` hybrid band.
+ * @returns metrics, sweep and optional hybrid metrics.
+ */
+export function evaluateDecisions(rawCases, threshold = 0.5, escalation) {
+    if (!Array.isArray(rawCases) || rawCases.length === 0 || rawCases.length > 10_000)
+        throw new Error('cases must be 1–10,000 observations');
+    if (!Number.isFinite(threshold) || threshold < 0 || threshold > 1)
+        throw new Error('threshold must be a finite number in [0,1]');
+    if (escalation !== undefined && (!Number.isFinite(escalation.rejectAt) || !Number.isFinite(escalation.acceptAt) || escalation.rejectAt < 0 || escalation.acceptAt > 1 || escalation.rejectAt >= escalation.acceptAt)) {
+        throw new Error('escalation thresholds must satisfy 0 <= rejectAt < acceptAt <= 1');
+    }
+    const cases = rawCases.map(validCase);
+    const base = metrics(cases, c => c.probability >= threshold);
+    let bestThreshold = threshold;
+    let bestAccuracy = base.accuracy;
+    const sweep = [];
+    for (let step = 0; step <= 100; step += 1) {
+        const candidate = step / 100;
+        const result = metrics(cases, c => c.probability >= candidate);
+        sweep.push({ threshold: candidate, accuracy: result.accuracy });
+        if (result.accuracy > bestAccuracy) {
+            bestAccuracy = result.accuracy;
+            bestThreshold = candidate;
+        }
+    }
+    const calibration = Array.from({ length: 10 }, (_, index) => {
+        const low = index / 10;
+        const high = (index + 1) / 10;
+        const bucket = cases.filter(c => c.probability >= low && (index === 9 ? c.probability <= high : c.probability < high));
+        return {
+            low,
+            high,
+            count: bucket.length,
+            meanPredicted: bucket.length === 0 ? null : bucket.reduce((sum, c) => sum + c.probability, 0) / bucket.length,
+            observedRate: bucket.length === 0 ? null : bucket.filter(c => c.expected).length / bucket.length,
+        };
+    });
+    if (escalation === undefined)
+        return { threshold, base, bestThreshold, bestAccuracy, sweep, calibration };
+    let escalated = 0;
+    let escalatedCostUsd = 0;
+    let escalatedLatencyMs = 0;
+    const hybridDecisions = cases.map(c => {
+        const route = routeConfidence(c.probability, escalation.acceptAt, escalation.rejectAt);
+        if (route.route !== 'escalate')
+            return c.probability >= escalation.acceptAt;
+        escalated += 1;
+        escalatedCostUsd += c.costUsd ?? 0;
+        escalatedLatencyMs += c.latencyMs ?? 0;
+        return (c.escalatedProbability ?? c.probability) >= threshold;
+    });
+    let tp = 0;
+    let tn = 0;
+    let fp = 0;
+    let fn = 0;
+    for (let index = 0; index < cases.length; index += 1) {
+        const c = cases[index];
+        const predicted = hybridDecisions[index];
+        if (predicted && c.expected)
+            tp += 1;
+        else if (!predicted && !c.expected)
+            tn += 1;
+        else if (predicted)
+            fp += 1;
+        else
+            fn += 1;
+    }
+    const positives = cases.filter(c => c.expected).length;
+    const negatives = cases.length - positives;
+    return {
+        threshold,
+        base,
+        bestThreshold,
+        bestAccuracy,
+        sweep,
+        calibration,
+        hybrid: {
+            rejectAt: escalation.rejectAt,
+            acceptAt: escalation.acceptAt,
+            escalated,
+            escalationRate: cases.length === 0 ? 0 : escalated / cases.length,
+            accuracy: (tp + tn) / cases.length,
+            truePositives: tp,
+            trueNegatives: tn,
+            falsePositives: fp,
+            falseNegatives: fn,
+            falsePositiveRate: negatives === 0 ? 0 : fp / negatives,
+            falseNegativeRate: positives === 0 ? 0 : fn / positives,
+            escalatedCostUsd,
+            escalatedLatencyMs,
+        },
+    };
+}
+/** The MCP contract for confidence routing. */
+export const DECISION_ROUTE_CONTRACT = {
+    contract: 'decision.route', version: '1.0.0', toolName: 'decision_route',
+    description: 'Route a primary judgment probability into accept, reject or the escalate band.',
+    inputSchema: { type: 'object', additionalProperties: false, required: ['probability'], properties: { probability: { type: 'number' }, acceptAt: { type: 'number' }, rejectAt: { type: 'number' } } },
+    outputSchema: { type: 'object', additionalProperties: false, required: ['route', 'decision', 'band', 'reason'], properties: { route: { type: 'string' }, decision: { type: ['boolean', 'null'] }, band: { type: 'string' }, reason: { type: 'string' } } },
+    semantics: { deterministic: true, readsInputs: true }, limits: {},
+};
+/** The MCP contract for decision evaluation. */
+export const DECISION_EVALUATE_CONTRACT = {
+    contract: 'decision.evaluate', version: '1.0.0', toolName: 'decision_evaluate',
+    description: 'Evaluate labeled decision probabilities: accuracy, FPR/FNR, Brier, calibration and an optional escalation arm.',
+    inputSchema: { type: 'object', additionalProperties: false, required: ['cases'], properties: { cases: { type: 'array' }, threshold: { type: 'number' }, escalation: { type: 'object' } } },
+    outputSchema: { type: 'object', additionalProperties: true },
+    semantics: { deterministic: true, readsInputs: true }, limits: {},
+};
+//# sourceMappingURL=decision-evaluate.js.map

package/lib/deployment-coordinator.d.ts

@@ -0,0 +1,213 @@
+/**
+ * Deployment coordination: preparation, single-flight loading and reference counting
+ * (RES-02, RES-03, RES-05).
+ *
+ * This is the module that makes readiness states PRODUCED rather than assigned. Before
+ * it, `prepared-cold` and `ready` were values a test could write; here they are values
+ * this coordinator derives from what actually happened.
+ *
+ * Three rules shape the design:
+ *
+ * - **One operation per EXACT deployment** (RES-05). The key that identifies a
+ *   deployment includes the model revision, engine version, quantization and
+ *   preprocessing recipe, not just a model name — two builds of "the same model" that
+ *   differ in quantization are different deployments and loading one must not satisfy
+ *   a request for the other.
+ * - **Concurrent callers JOIN** (RES-05). A second caller during a load awaits the
+ *   same promise rather than starting a second load, which is the difference between
+ *   sharing 349 MB and allocating it twice.
+ * - **A failed or interrupted preparation cannot become ready** (RES-03). Failure is
+ *   recorded as failure, and a later caller retries rather than inheriting a
+ *   half-prepared deployment that reports success.
+ *
+ * @module @try-works/dsh-tool-mode/deployment-coordinator
+ */
+import type { ModelReadiness } from '@try-works/tool-mode-extension-sdk';
+/**
+ * The identity of an EXACT provider deployment (RES-02, RES-05).
+ *
+ * Every field participates in the deployment key. Pinning only the model name would
+ * let a caller be served by a differently-quantized build than the one it requested.
+ */
+export interface DeploymentIdentity {
+    /** The extension package that provides it. */
+    readonly extensionId: string;
+    /** The model inside that package. */
+    readonly modelId: string;
+    /** The exact model revision, not a branch or a floating tag. */
+    readonly modelRevision: string;
+    /** The engine or SDK version the assets were converted for. */
+    readonly engineVersion: string;
+    /** The quantization, which changes outputs and is therefore part of identity. */
+    readonly quantization: string;
+    /** The tokenizer identity. */
+    readonly tokenizer: string;
+    /** The preprocessing recipe version. */
+    readonly preprocessingRecipe: string;
+}
+/**
+ * The stable key for an exact deployment (RES-05).
+ *
+ * A delimiter that cannot appear in a component, so two different field combinations
+ * cannot collide into one key.
+ * @param identity - the deployment identity.
+ * @returns the key.
+ */
+export declare function deploymentKey(identity: DeploymentIdentity): string;
+/** One asset a preparation must obtain (RES-02, RES-03). */
+export interface PlannedAsset {
+    /** The asset id from the lock file. */
+    readonly assetId: string;
+    /** The download size in bytes, for the pre-approval disclosure. */
+    readonly bytes: number;
+    /** The pinned source. */
+    readonly source: string;
+    /** The expected content digest. */
+    readonly digest: string;
+    /**
+     * Whether this asset is an EXECUTABLE.
+     *
+     * RES-02: prebuilt engine downloads count as executable installation, so they
+     * require the separate executable-preparation approval rather than riding along
+     * with a model download.
+     */
+    readonly executable: boolean;
+}
+/** What a preparation would do, shown before approval (RES-02). */
+export interface PreparationPlan {
+    readonly identity: DeploymentIdentity;
+    readonly assets: readonly PlannedAsset[];
+    /** Total download size, so an operator approves a number rather than a hope. */
+    readonly totalBytes: number;
+    /** Total bytes retained after installation. */
+    readonly storageBytes: number;
+    /** Whether any asset is executable, which changes which approval is needed. */
+    readonly requiresExecutableApproval: boolean;
+    /** The pinned license terms, surfaced before the download rather than after. */
+    readonly license: {
+        readonly name: string;
+        readonly url: string;
+    };
+}
+/**
+ * Build the pre-approval disclosure (RES-02).
+ *
+ * An operator approving a preparation is approving a specific download of a specific
+ * size under specific terms, so all three are computed here rather than discovered
+ * during the install.
+ * @param identity - the exact deployment.
+ * @param assets - the assets the lock resolves to.
+ * @param license - the pinned license.
+ * @returns the plan.
+ */
+export declare function planPreparation(identity: DeploymentIdentity, assets: readonly PlannedAsset[], license: {
+    readonly name: string;
+    readonly url: string;
+}): PreparationPlan;
+/** A preparation that has not yet completed. */
+export interface DeploymentRecord {
+    /** The exact deployment key. */
+    readonly key: string;
+    /** The identity it belongs to. */
+    readonly identity: DeploymentIdentity;
+    /** The current state, using the RES-04 vocabulary. */
+    readiness: ModelReadiness;
+    /** How many callers currently hold a reference. */
+    activeUsers: number;
+    /** When the current load began, if one is in progress. */
+    loadingSince: number | null;
+    /** Why it failed, when it did. */
+    failureReason: string | null;
+}
+/** What a caller receives when it acquires a deployment. */
+export interface DeploymentLease {
+    /** The deployment key. */
+    readonly key: string;
+    /** The state at acquisition. */
+    readonly readiness: ModelReadiness;
+    /** Whether the caller waited for a load to finish. */
+    readonly joined: boolean;
+    /** Release this caller's reference. Idempotent. */
+    release(): void;
+}
+/** Raised when a deployment cannot be prepared. */
+export declare class DeploymentError extends Error {
+    readonly name = "DeploymentError";
+    readonly key: string;
+    constructor(key: string, message: string);
+}
+/**
+ * Coordinates preparation, loading and reference counting per exact deployment.
+ *
+ * Not thread-safe in the language sense — Node is single-threaded — but
+ * single-flight with respect to `await`: two callers that reach `acquire` before the
+ * load settles both await ONE promise.
+ */
+export declare class DeploymentCoordinator {
+    #private;
+    /** Every tracked deployment, for diagnostics. */
+    get deployments(): readonly DeploymentRecord[];
+    /** One deployment's record. */
+    record(key: string): DeploymentRecord | undefined;
+    /**
+     * The state to report for a deployment that has not been touched yet.
+     * @param identity - the exact deployment.
+     * @returns the readiness.
+     */
+    readinessOf(identity: DeploymentIdentity): ModelReadiness;
+    /**
+     * Prepare and load a deployment, joining an in-flight load if there is one.
+     *
+     * RES-05: "One preparation/load operation per exact provider deployment; concurrent
+     * callers join or queue."
+     * @param identity - the exact deployment.
+     * @param load - performs the load. Called AT MOST ONCE per concurrent group.
+     * @param options - cancellation for THIS caller.
+     * @returns the lease.
+     * @throws DeploymentError when the load fails.
+     */
+    acquire(identity: DeploymentIdentity, load: () => Promise<void>, options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<DeploymentLease>;
+    /**
+     * Unload a deployment, but only when it is IDLE (RES-05).
+     *
+     * "Unload only idle resources or an explicitly revoked deployment after coordinated
+     * cleanup." Unloading a busy deployment would discard another caller's work.
+     * @param key - the deployment key.
+     * @param force - set only for an explicitly revoked deployment.
+     * @returns whether it was unloaded, and why not when it was not.
+     */
+    unload(key: string, force?: boolean): {
+        readonly unloaded: boolean;
+        readonly reason?: string;
+    };
+    /**
+     * Revoke a deployment, discarding in-flight work after coordinated cleanup (RES-05).
+     * @param key - the deployment key.
+     * @returns whether it was revoked.
+     */
+    revoke(key: string): boolean;
+}
+/** An asset ownership record (RES-03). */
+export interface AssetOwnership {
+    /** The content digest, which is what makes sharing safe. */
+    readonly digest: string;
+    /** The holders of this asset, by owner id. */
+    readonly owners: readonly string[];
+}
+/**
+ * Decide which assets may be deleted (RES-03).
+ *
+ * RES-03: "Package uninstall and asset purge are separate operations; delete only
+ * unreferenced host-owned assets." So removing an owner does not delete anything, and
+ * an asset with another owner is never deleted.
+ * @param ownership - the current records.
+ * @param removedOwner - the owner being uninstalled.
+ * @returns the digests that are now unreferenced, and those still held.
+ */
+export declare function purgeCandidates(ownership: readonly AssetOwnership[], removedOwner: string): {
+    readonly deletable: readonly string[];
+    readonly retained: readonly string[];
+};
+//# sourceMappingURL=deployment-coordinator.d.ts.map

package/lib/deployment-coordinator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deployment-coordinator.d.ts","sourceRoot":"","sources":["../src/deployment-coordinator.ts"],"names":[],"mappings":"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"}