@antseed/router-core 0.1.0 → 0.1.1

package/package.json

@@ -1,22 +1,25 @@
 {
   "name": "@antseed/router-core",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Shared router infrastructure for Antseed plugins",
   "type": "module",
+  "files": [
+    "dist"
+  ],
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "scripts": {
-    "prebuild": "rm -rf dist",
-    "build": "tsc",
-    "test": "vitest run",
-    "typecheck": "tsc --noEmit"
-  },
   "peerDependencies": {
     "@antseed/node": ">=0.1.0"
   },
   "devDependencies": {
     "typescript": "^5.5.0",
     "vitest": "^2.0.0",
-    "@antseed/node": "workspace:*"
+    "@antseed/node": "0.1.1"
+  },
+  "scripts": {
+    "prebuild": "rm -rf dist",
+    "build": "tsc",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
   }
-}
+}

package/src/index.ts

@@ -1,17 +0,0 @@
-export {
-  scoreCandidates,
-  DEFAULT_WEIGHTS,
-  type ScoringWeights,
-  type ScoredCandidate,
-  type TokenPricingUsdPerMillion,
-  type PeerMetrics,
-} from './peer-scorer.js'
-export {
-  PeerMetricsTracker,
-  type PeerMetricsTrackerConfig,
-} from './peer-metrics.js'
-export {
-  WELL_KNOWN_TOOL_HINTS,
-  formatToolHints,
-  type ToolHint,
-} from './tool-hints.js'

package/src/peer-metrics.test.ts

@@ -1,192 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { PeerMetricsTracker } from './peer-metrics.js'
-
-describe('PeerMetricsTracker', () => {
-  describe('latency EMA calculation', () => {
-    it('initializes EMA to the first latency value', () => {
-      const tracker = new PeerMetricsTracker()
-      tracker.recordResult('peer1', { success: true, latencyMs: 100 })
-
-      const metrics = tracker.getMetrics('peer1')
-      // First call: prev = 100 (default to result), EMA = 100 * 0.7 + 100 * 0.3 = 100
-      expect(metrics.latencyEma).toBe(100)
-    })
-
-    it('applies exponential moving average on subsequent results', () => {
-      const tracker = new PeerMetricsTracker({ latencyAlpha: 0.3 })
-      tracker.recordResult('peer1', { success: true, latencyMs: 100 })
-      tracker.recordResult('peer1', { success: true, latencyMs: 200 })
-
-      const metrics = tracker.getMetrics('peer1')
-      // After first: EMA = 100
-      // After second: EMA = 100 * 0.7 + 200 * 0.3 = 70 + 60 = 130
-      expect(metrics.latencyEma).toBe(130)
-    })
-
-    it('respects custom latencyAlpha', () => {
-      const tracker = new PeerMetricsTracker({ latencyAlpha: 0.5 })
-      tracker.recordResult('peer1', { success: true, latencyMs: 100 })
-      tracker.recordResult('peer1', { success: true, latencyMs: 200 })
-
-      const metrics = tracker.getMetrics('peer1')
-      // After first: EMA = 100
-      // After second: EMA = 100 * 0.5 + 200 * 0.5 = 150
-      expect(metrics.latencyEma).toBe(150)
-    })
-  })
-
-  describe('failure streak tracking', () => {
-    it('increments failure streak on consecutive failures', () => {
-      const tracker = new PeerMetricsTracker()
-      tracker.recordResult('peer1', { success: false, latencyMs: 100 })
-      tracker.recordResult('peer1', { success: false, latencyMs: 100 })
-
-      const metrics = tracker.getMetrics('peer1')
-      expect(metrics.failureStreak).toBe(2)
-      expect(metrics.totalFailures).toBe(2)
-      expect(metrics.totalAttempts).toBe(2)
-    })
-
-    it('success resets failure streak', () => {
-      const tracker = new PeerMetricsTracker()
-      tracker.recordResult('peer1', { success: false, latencyMs: 100 })
-      tracker.recordResult('peer1', { success: false, latencyMs: 100 })
-      tracker.recordResult('peer1', { success: true, latencyMs: 100 })
-
-      const metrics = tracker.getMetrics('peer1')
-      expect(metrics.failureStreak).toBe(0)
-      // Total failures and attempts remain
-      expect(metrics.totalFailures).toBe(2)
-      expect(metrics.totalAttempts).toBe(3)
-    })
-
-    it('tracks total failures independently from streak', () => {
-      const tracker = new PeerMetricsTracker()
-      tracker.recordResult('peer1', { success: false, latencyMs: 100 })
-      tracker.recordResult('peer1', { success: true, latencyMs: 100 })
-      tracker.recordResult('peer1', { success: false, latencyMs: 100 })
-
-      const metrics = tracker.getMetrics('peer1')
-      expect(metrics.failureStreak).toBe(1)
-      expect(metrics.totalFailures).toBe(2)
-      expect(metrics.totalAttempts).toBe(3)
-    })
-  })
-
-  describe('cooldown timing', () => {
-    it('enters cooldown after maxFailures consecutive failures', () => {
-      let now = 1_000_000
-      const tracker = new PeerMetricsTracker({
-        maxFailures: 2,
-        failureCooldownMs: 500,
-        now: () => now,
-      })
-
-      tracker.recordResult('peer1', { success: false, latencyMs: 100 })
-      expect(tracker.isCoolingDown('peer1')).toBe(false)
-
-      tracker.recordResult('peer1', { success: false, latencyMs: 100 })
-      expect(tracker.isCoolingDown('peer1')).toBe(true)
-    })
-
-    it('cooldown expires after failureCooldownMs', () => {
-      let now = 1_000_000
-      const tracker = new PeerMetricsTracker({
-        maxFailures: 2,
-        failureCooldownMs: 500,
-        now: () => now,
-      })
-
-      tracker.recordResult('peer1', { success: false, latencyMs: 100 })
-      tracker.recordResult('peer1', { success: false, latencyMs: 100 })
-      expect(tracker.isCoolingDown('peer1')).toBe(true)
-
-      now += 501
-      expect(tracker.isCoolingDown('peer1')).toBe(false)
-    })
-
-    it('success clears cooldown', () => {
-      let now = 1_000_000
-      const tracker = new PeerMetricsTracker({
-        maxFailures: 2,
-        failureCooldownMs: 500,
-        now: () => now,
-      })
-
-      tracker.recordResult('peer1', { success: false, latencyMs: 100 })
-      tracker.recordResult('peer1', { success: false, latencyMs: 100 })
-      expect(tracker.isCoolingDown('peer1')).toBe(true)
-
-      tracker.recordResult('peer1', { success: true, latencyMs: 100 })
-      expect(tracker.isCoolingDown('peer1')).toBe(false)
-    })
-
-    it('applies exponential backoff for repeated failure streaks beyond threshold', () => {
-      let now = 1_000_000
-      const tracker = new PeerMetricsTracker({
-        maxFailures: 2,
-        failureCooldownMs: 500,
-        now: () => now,
-      })
-
-      // 2 failures: cooldown = 500 * 2^0 = 500
-      tracker.recordResult('peer1', { success: false, latencyMs: 100 })
-      tracker.recordResult('peer1', { success: false, latencyMs: 100 })
-
-      const metrics2 = tracker.getMetrics('peer1')
-      expect(metrics2.cooldownUntil).toBe(now + 500)
-
-      // 3rd failure: cooldown = 500 * 2^1 = 1000
-      now += 501 // past first cooldown
-      tracker.recordResult('peer1', { success: false, latencyMs: 100 })
-
-      const metrics3 = tracker.getMetrics('peer1')
-      expect(metrics3.cooldownUntil).toBe(now + 1000)
-    })
-  })
-
-  describe('median latency', () => {
-    it('returns 500 when no latencies recorded', () => {
-      const tracker = new PeerMetricsTracker()
-      expect(tracker.getMedianLatency()).toBe(500)
-    })
-
-    it('returns single value when only one peer has latency', () => {
-      const tracker = new PeerMetricsTracker()
-      tracker.recordResult('peer1', { success: true, latencyMs: 200 })
-      expect(tracker.getMedianLatency()).toBe(200)
-    })
-
-    it('returns median of odd number of values', () => {
-      const tracker = new PeerMetricsTracker()
-      tracker.recordResult('peer1', { success: true, latencyMs: 100 })
-      tracker.recordResult('peer2', { success: true, latencyMs: 300 })
-      tracker.recordResult('peer3', { success: true, latencyMs: 200 })
-
-      expect(tracker.getMedianLatency()).toBe(200)
-    })
-
-    it('returns average of two middle values for even count', () => {
-      const tracker = new PeerMetricsTracker()
-      tracker.recordResult('peer1', { success: true, latencyMs: 100 })
-      tracker.recordResult('peer2', { success: true, latencyMs: 200 })
-      tracker.recordResult('peer3', { success: true, latencyMs: 300 })
-      tracker.recordResult('peer4', { success: true, latencyMs: 400 })
-
-      expect(tracker.getMedianLatency()).toBe(250)
-    })
-  })
-
-  describe('getMetrics', () => {
-    it('returns zeroed metrics for unknown peer', () => {
-      const tracker = new PeerMetricsTracker()
-      const metrics = tracker.getMetrics('unknown')
-
-      expect(metrics.latencyEma).toBeUndefined()
-      expect(metrics.failureStreak).toBe(0)
-      expect(metrics.totalFailures).toBe(0)
-      expect(metrics.totalAttempts).toBe(0)
-      expect(metrics.cooldownUntil).toBeUndefined()
-    })
-  })
-})

package/src/peer-metrics.ts

@@ -1,88 +0,0 @@
-import type { PeerMetrics } from './peer-scorer.js'
-
-export interface PeerMetricsTrackerConfig {
-  latencyAlpha?: number       // Default: 0.3
-  maxFailures?: number        // Default: 3
-  failureCooldownMs?: number  // Default: 30000
-  now?: () => number
-}
-
-export class PeerMetricsTracker {
-  private readonly _latencyMap = new Map<string, number>()
-  private readonly _failureStreakMap = new Map<string, number>()
-  private readonly _totalFailureMap = new Map<string, number>()
-  private readonly _attemptMap = new Map<string, number>()
-  private readonly _cooldownUntilMap = new Map<string, number>()
-
-  private readonly _latencyAlpha: number
-  private readonly _maxFailures: number
-  private readonly _failureCooldownMs: number
-  private readonly _now: () => number
-
-  constructor(config?: PeerMetricsTrackerConfig) {
-    this._latencyAlpha = config?.latencyAlpha ?? 0.3
-    this._maxFailures = Math.max(1, config?.maxFailures ?? 3)
-    this._failureCooldownMs = Math.max(1, config?.failureCooldownMs ?? 30_000)
-    this._now = config?.now ?? (() => Date.now())
-  }
-
-  recordResult(peerId: string, result: { success: boolean; latencyMs: number }): void {
-    const now = this._now()
-    const attempts = (this._attemptMap.get(peerId) ?? 0) + 1
-    this._attemptMap.set(peerId, attempts)
-
-    if (result.success) {
-      // Update latency EMA
-      const prev = this._latencyMap.get(peerId) ?? result.latencyMs
-      this._latencyMap.set(
-        peerId,
-        prev * (1 - this._latencyAlpha) + result.latencyMs * this._latencyAlpha,
-      )
-      // Reset failure count on success
-      this._failureStreakMap.delete(peerId)
-      this._cooldownUntilMap.delete(peerId)
-    } else {
-      const currentStreak = this._failureStreakMap.get(peerId) ?? 0
-      const nextStreak = currentStreak + 1
-      this._failureStreakMap.set(peerId, nextStreak)
-      this._totalFailureMap.set(peerId, (this._totalFailureMap.get(peerId) ?? 0) + 1)
-
-      if (nextStreak >= this._maxFailures) {
-        const penaltyPower = Math.min(4, nextStreak - this._maxFailures)
-        const cooldownMs = this._failureCooldownMs * (2 ** penaltyPower)
-        this._cooldownUntilMap.set(peerId, now + cooldownMs)
-      }
-    }
-  }
-
-  getMetrics(peerId: string): PeerMetrics {
-    return {
-      latencyEma: this._latencyMap.get(peerId),
-      failureStreak: this._failureStreakMap.get(peerId) ?? 0,
-      totalFailures: this._totalFailureMap.get(peerId) ?? 0,
-      totalAttempts: this._attemptMap.get(peerId) ?? 0,
-      cooldownUntil: this._cooldownUntilMap.get(peerId),
-    }
-  }
-
-  isCoolingDown(peerId: string): boolean {
-    const now = this._now()
-    const until = this._cooldownUntilMap.get(peerId)
-    if (until === undefined) return false
-    if (until <= now) {
-      this._cooldownUntilMap.delete(peerId)
-      return false
-    }
-    return true
-  }
-
-  getMedianLatency(): number {
-    const values = [...this._latencyMap.values()]
-    if (values.length === 0) return 500
-    values.sort((a, b) => a - b)
-    const mid = Math.floor(values.length / 2)
-    return values.length % 2 === 0
-      ? (values[mid - 1]! + values[mid]!) / 2
-      : values[mid]!
-  }
-}

package/src/peer-scorer.test.ts

@@ -1,195 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import type { PeerInfo } from '@antseed/node'
-import { scoreCandidates, DEFAULT_WEIGHTS } from './peer-scorer.js'
-import type { PeerMetrics, TokenPricingUsdPerMillion } from './peer-scorer.js'
-
-function makePeerId(char: string): PeerInfo['peerId'] {
-  return char.repeat(64) as PeerInfo['peerId']
-}
-
-function makePeer(overrides?: Partial<PeerInfo>): PeerInfo {
-  return {
-    peerId: makePeerId('a'),
-    lastSeen: 1_000_000,
-    providers: ['anthropic'],
-    reputationScore: 80,
-    trustScore: 80,
-    maxConcurrency: 10,
-    currentLoad: 1,
-    ...overrides,
-  }
-}
-
-const defaultMetrics: PeerMetrics = {
-  latencyEma: undefined,
-  failureStreak: 0,
-  totalFailures: 0,
-  totalAttempts: 0,
-  cooldownUntil: undefined,
-}
-
-const defaultOffer: TokenPricingUsdPerMillion = {
-  inputUsdPerMillion: 10,
-  outputUsdPerMillion: 10,
-}
-
-const defaultContext = {
-  now: 1_000_000,
-  medianLatency: 500,
-  maxPeerStalenessMs: 300_000,
-  maxFailures: 3,
-}
-
-describe('scoreCandidates', () => {
-  it('returns correct score ordering — cheaper peer ranks higher', () => {
-    const cheapPeer = makePeer({ peerId: makePeerId('1') })
-    const expensivePeer = makePeer({ peerId: makePeerId('2') })
-
-    const result = scoreCandidates(
-      [
-        {
-          peer: expensivePeer,
-          provider: 'anthropic',
-          providerRank: 0,
-          offer: { inputUsdPerMillion: 100, outputUsdPerMillion: 100 },
-          metrics: defaultMetrics,
-        },
-        {
-          peer: cheapPeer,
-          provider: 'anthropic',
-          providerRank: 0,
-          offer: { inputUsdPerMillion: 5, outputUsdPerMillion: 5 },
-          metrics: defaultMetrics,
-        },
-      ],
-      defaultContext,
-    )
-
-    expect(result).toHaveLength(2)
-    expect(result[0]!.peer.peerId).toBe(cheapPeer.peerId)
-    expect(result[1]!.peer.peerId).toBe(expensivePeer.peerId)
-    expect(result[0]!.score).toBeGreaterThan(result[1]!.score)
-  })
-
-  it('custom weights change ranking — zero out price, maximize latency', () => {
-    const cheapButSlow = makePeer({ peerId: makePeerId('1') })
-    const expensiveButFast = makePeer({ peerId: makePeerId('2') })
-
-    const result = scoreCandidates(
-      [
-        {
-          peer: cheapButSlow,
-          provider: 'anthropic',
-          providerRank: 0,
-          offer: { inputUsdPerMillion: 1, outputUsdPerMillion: 1 },
-          metrics: { ...defaultMetrics, latencyEma: 1000 },
-        },
-        {
-          peer: expensiveButFast,
-          provider: 'anthropic',
-          providerRank: 0,
-          offer: { inputUsdPerMillion: 100, outputUsdPerMillion: 100 },
-          metrics: { ...defaultMetrics, latencyEma: 50 },
-        },
-      ],
-      {
-        ...defaultContext,
-        weights: {
-          price: 0,
-          latency: 1.0,
-          capacity: 0,
-          reputation: 0,
-          freshness: 0,
-          reliability: 0,
-        },
-      },
-    )
-
-    expect(result[0]!.peer.peerId).toBe(expensiveButFast.peerId)
-  })
-
-  it('handles single candidate', () => {
-    const peer = makePeer({ peerId: makePeerId('1') })
-
-    const result = scoreCandidates(
-      [
-        {
-          peer,
-          provider: 'anthropic',
-          providerRank: 0,
-          offer: defaultOffer,
-          metrics: defaultMetrics,
-        },
-      ],
-      defaultContext,
-    )
-
-    expect(result).toHaveLength(1)
-    expect(result[0]!.peer.peerId).toBe(peer.peerId)
-    expect(result[0]!.score).toBeGreaterThan(0)
-  })
-
-  it('handles all equal scores — tie-broken by peerId', () => {
-    const peerA = makePeer({ peerId: makePeerId('a') })
-    const peerB = makePeer({ peerId: makePeerId('b') })
-
-    const result = scoreCandidates(
-      [
-        {
-          peer: peerB,
-          provider: 'anthropic',
-          providerRank: 0,
-          offer: defaultOffer,
-          metrics: defaultMetrics,
-        },
-        {
-          peer: peerA,
-          provider: 'anthropic',
-          providerRank: 0,
-          offer: defaultOffer,
-          metrics: defaultMetrics,
-        },
-      ],
-      defaultContext,
-    )
-
-    expect(result).toHaveLength(2)
-    // Both have identical inputs so scores should be equal; tie-break by peerId ascending
-    expect(result[0]!.peer.peerId).toBe(peerA.peerId)
-    expect(result[1]!.peer.peerId).toBe(peerB.peerId)
-  })
-
-  it('returns empty array for empty candidates', () => {
-    const result = scoreCandidates([], defaultContext)
-    expect(result).toHaveLength(0)
-  })
-
-  it('uses default weights when none provided', () => {
-    const peer = makePeer({ peerId: makePeerId('1') })
-
-    const result = scoreCandidates(
-      [
-        {
-          peer,
-          provider: 'anthropic',
-          providerRank: 0,
-          offer: defaultOffer,
-          metrics: defaultMetrics,
-        },
-      ],
-      defaultContext,
-    )
-
-    // With a single candidate, all normalized-inverted factors are 1.0
-    // Score = sum of all weights = 1.0 (minus any freshness/reputation adjustments)
-    expect(result[0]!.score).toBeGreaterThan(0)
-    expect(result[0]!.score).toBeLessThanOrEqual(
-      DEFAULT_WEIGHTS.price +
-      DEFAULT_WEIGHTS.latency +
-      DEFAULT_WEIGHTS.capacity +
-      DEFAULT_WEIGHTS.reputation +
-      DEFAULT_WEIGHTS.freshness +
-      DEFAULT_WEIGHTS.reliability,
-    )
-  })
-})

package/src/peer-scorer.ts

@@ -1,196 +0,0 @@
-import type { PeerInfo } from '@antseed/node'
-
-export interface TokenPricingUsdPerMillion {
-  inputUsdPerMillion: number
-  outputUsdPerMillion: number
-}
-
-export interface ScoringWeights {
-  price: number
-  latency: number
-  capacity: number
-  reputation: number
-  freshness: number
-  reliability: number
-}
-
-export const DEFAULT_WEIGHTS: ScoringWeights = {
-  price: 0.30,
-  latency: 0.25,
-  capacity: 0.20,
-  reputation: 0.10,
-  freshness: 0.10,
-  reliability: 0.05,
-}
-
-export interface PeerMetrics {
-  latencyEma: number | undefined
-  failureStreak: number
-  totalFailures: number
-  totalAttempts: number
-  cooldownUntil: number | undefined
-}
-
-export interface ScoredCandidate {
-  peer: PeerInfo
-  provider: string
-  providerRank: number
-  offer: TokenPricingUsdPerMillion
-  score: number
-}
-
-interface CandidateInput {
-  peer: PeerInfo
-  provider: string
-  providerRank: number
-  offer: TokenPricingUsdPerMillion
-  metrics: PeerMetrics
-}
-
-interface ScoringContext {
-  now: number
-  medianLatency: number
-  maxPeerStalenessMs: number
-  maxFailures: number
-  weights?: Partial<ScoringWeights>
-}
-
-function normalizedInverted(value: number, min: number, range: number): number {
-  if (range <= 0) {
-    return 1
-  }
-  return 1 - (value - min) / range
-}
-
-function effectiveReputation(p: PeerInfo): number {
-  if (p.onChainReputation !== undefined) {
-    return p.onChainReputation
-  }
-  return p.trustScore ?? p.reputationScore ?? 0
-}
-
-function availableCapacity(p: PeerInfo): number {
-  const max = p.maxConcurrency ?? 1
-  const current = p.currentLoad ?? 0
-  return Math.max(0, max - current)
-}
-
-function freshnessFactor(p: PeerInfo, now: number, maxPeerStalenessMs: number): number {
-  if (!Number.isFinite(p.lastSeen)) return 0.5
-  const age = Math.max(0, now - p.lastSeen)
-  if (age >= maxPeerStalenessMs) return 0
-  return 1 - (age / maxPeerStalenessMs)
-}
-
-function reliabilityFactor(metrics: PeerMetrics, maxFailures: number): number {
-  const historicalPenalty = metrics.totalAttempts > 0 ? metrics.totalFailures / metrics.totalAttempts : 0
-  const streakPenalty = Math.min(1, metrics.failureStreak / maxFailures)
-  return Math.max(0, 1 - Math.max(historicalPenalty, streakPenalty))
-}
-
-function peerLatency(metrics: PeerMetrics, medianLatency: number): number {
-  return metrics.latencyEma ?? medianLatency
-}
-
-function tieBreak(a: PeerInfo, aLatencyEma: number | undefined, b: PeerInfo, bLatencyEma: number | undefined): number {
-  const latA = aLatencyEma ?? Number.POSITIVE_INFINITY
-  const latB = bLatencyEma ?? Number.POSITIVE_INFINITY
-  if (latA !== latB) {
-    return latA - latB
-  }
-  return a.peerId.localeCompare(b.peerId)
-}
-
-/**
- * Score and rank candidates using the composite scoring algorithm.
- *
- * Calculates normalization context (min/max price, latency, capacity),
- * scores each candidate with weighted factors, and returns candidates
- * sorted by score (highest first).
- */
-export function scoreCandidates(
-  candidates: CandidateInput[],
-  context: ScoringContext,
-): ScoredCandidate[] {
-  if (candidates.length === 0) return []
-
-  const w: ScoringWeights = { ...DEFAULT_WEIGHTS, ...context.weights }
-
-  // --- Normalization context ---
-  const knownPrices = candidates
-    .map((c) => c.offer.inputUsdPerMillion)
-    .filter((value) => Number.isFinite(value))
-  const fallbackPrice = knownPrices.length > 0 ? Math.max(...knownPrices) * 1.25 : 1
-  let minPrice = knownPrices.length > 0 ? Math.min(...knownPrices) : fallbackPrice
-  let maxPrice = knownPrices.length > 0 ? Math.max(...knownPrices) : fallbackPrice
-  let minLatency = Number.POSITIVE_INFINITY
-  let maxLatency = 0
-  let maxCap = 0
-
-  for (const c of candidates) {
-    const price = c.offer.inputUsdPerMillion
-    if (price < minPrice) minPrice = price
-    if (price > maxPrice) maxPrice = price
-
-    const lat = peerLatency(c.metrics, context.medianLatency)
-    if (lat < minLatency) minLatency = lat
-    if (lat > maxLatency) maxLatency = lat
-
-    const cap = availableCapacity(c.peer)
-    if (cap > maxCap) maxCap = cap
-  }
-
-  const priceRange = maxPrice - minPrice
-  const latencyRange = maxLatency - minLatency
-
-  // --- Score each candidate ---
-  const scored: ScoredCandidate[] = []
-
-  for (const c of candidates) {
-    // Price factor (lower is better, inverted)
-    const price = c.offer.inputUsdPerMillion ?? fallbackPrice
-    const priceFactor = normalizedInverted(price, minPrice, priceRange)
-
-    // Latency factor (lower is better, inverted)
-    const lat = peerLatency(c.metrics, context.medianLatency)
-    const latencyFactor = normalizedInverted(lat, minLatency, latencyRange)
-
-    // Capacity factor (higher is better)
-    const capFactor = maxCap > 0
-      ? availableCapacity(c.peer) / maxCap
-      : 1
-
-    // Reputation factor (higher is better, normalized 0-100 to 0-1)
-    const repFactor = effectiveReputation(c.peer) / 100
-    const fresh = freshnessFactor(c.peer, context.now, context.maxPeerStalenessMs)
-    const reliability = reliabilityFactor(c.metrics, context.maxFailures)
-
-    const score =
-      w.price * priceFactor +
-      w.latency * latencyFactor +
-      w.capacity * capFactor +
-      w.reputation * repFactor +
-      w.freshness * fresh +
-      w.reliability * reliability
-
-    scored.push({
-      peer: c.peer,
-      provider: c.provider,
-      providerRank: c.providerRank,
-      offer: c.offer,
-      score,
-    })
-  }
-
-  // Sort by score descending, tie-break by latency then peerId
-  scored.sort((a, b) => {
-    if (Math.abs(a.score - b.score) < 1e-9) {
-      const aMetrics = candidates.find((c) => c.peer.peerId === a.peer.peerId)
-      const bMetrics = candidates.find((c) => c.peer.peerId === b.peer.peerId)
-      return tieBreak(a.peer, aMetrics?.metrics.latencyEma, b.peer, bMetrics?.metrics.latencyEma)
-    }
-    return b.score - a.score
-  })
-
-  return scored
-}

package/src/tool-hints.ts

@@ -1,15 +0,0 @@
-export interface ToolHint {
-  name: string
-  envVar: string
-}
-
-export const WELL_KNOWN_TOOL_HINTS: ToolHint[] = [
-  { name: 'Claude Code', envVar: 'ANTHROPIC_BASE_URL' },
-  { name: 'Aider', envVar: 'OPENAI_API_BASE' },
-  { name: 'Continue.dev', envVar: 'OPENAI_BASE_URL' },
-  { name: 'Codex', envVar: 'OPENAI_BASE_URL' },
-]
-
-export function formatToolHints(hints: ToolHint[], proxyUrl: string): string[] {
-  return hints.map(hint => `export ${hint.envVar}=${proxyUrl}   # ${hint.name}`)
-}

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "dist",
-    "rootDir": "src"
-  },
-  "include": ["src"],
-  "exclude": ["src/**/*.test.ts"]
-}