@alumbwe/anvil 1.0.20 → 1.0.22

package/vendor/@anvil/common/src/__tests__/anvil-trust.test.ts

@@ -0,0 +1,526 @@
+import { describe, expect, it } from 'bun:test'
+
+import {
+  assessAnvilTrust,
+  ANVIL_TRUST_FALLBACK_LEVEL,
+  ANVIL_TRUST_LEVELS,
+  ANVIL_TRUST_EARNED,
+  ANVIL_TRUST_LIMITS,
+  ANVIL_TRUST_THRESHOLDS,
+  anvilTrustLimits,
+  isAtLeastTrustLevel,
+  toAnvilStandingInfo,
+  type AnvilTrustSignals,
+} from '../constants/anvil-trust'
+
+const NOW = new Date('2026-08-11T00:00:00Z')
+const DAY_MS = 24 * 60 * 60 * 1000
+
+function daysAgo(days: number): Date {
+  return new Date(NOW.getTime() - days * DAY_MS)
+}
+
+/** An account we know nothing about: every optional signal unknown. This is
+ *  what most pre-provenance accounts actually look like. */
+const UNKNOWN: AnvilTrustSignals = {
+  accountCreatedAt: null,
+  githubAccountCreatedAt: null,
+  githubOldestRepoCreatedAt: null,
+  githubPublicRepos: null,
+  githubFollowers: null,
+  githubTwoFactorEnabled: null,
+  activeDays: 0,
+  approvedBounties: 0,
+  qualifiedReferrals: 0,
+  hasPaid: false,
+  signupPrivacySignals: null,
+  signupIpSource: null,
+  signupPrefixAccountCount: null,
+  mailboxAccountCount: null,
+  hasUnreversedBanEvent: false,
+  privacyFlaggedAt: null,
+  privacyCorroboratedAt: null,
+  thirdPartyClientAt: null,
+  currentRiskScore: null,
+}
+
+function signals(overrides: Partial<AnvilTrustSignals>) {
+  return { ...UNKNOWN, ...overrides }
+}
+
+describe('level ordering', () => {
+  it('orders least- to most-established', () => {
+    expect(ANVIL_TRUST_LEVELS).toEqual([
+      'new',
+      'verified',
+      'established',
+      'core',
+    ])
+  })
+
+  it('compares by position, not alphabetically', () => {
+    expect(isAtLeastTrustLevel('core', 'new')).toBe(true)
+    expect(isAtLeastTrustLevel('new', 'verified')).toBe(false)
+    expect(isAtLeastTrustLevel('established', 'established')).toBe(true)
+  })
+})
+
+describe('limit matrix', () => {
+  it('reproduces the pre-existing flat limits at established/full', () => {
+    // This is the safety property of the whole rollout: the population that
+    // already looked like ordinary heavy users must keep exactly what it had.
+    const full = anvilTrustLimits('full', 'established')
+    expect(full.messagesPerDay).toBe(5_000)
+    expect(full.messagesPer5Hours).toBe(3_000)
+    expect(full.dailySpendUsd).toBe(50)
+    expect(full.premiumSessionsPerDay).toBe(6)
+
+    const limited = anvilTrustLimits('limited', 'established')
+    expect(limited.messagesPerDay).toBe(3_000)
+    expect(limited.messagesPer5Hours).toBe(2_000)
+  })
+
+  it('is monotonic in level on every axis, in both regions', () => {
+    for (const tier of ['full', 'limited'] as const) {
+      for (let i = 1; i < ANVIL_TRUST_LEVELS.length; i++) {
+        const lower = ANVIL_TRUST_LIMITS[tier][ANVIL_TRUST_LEVELS[i - 1]]
+        const higher = ANVIL_TRUST_LIMITS[tier][ANVIL_TRUST_LEVELS[i]]
+        for (const key of Object.keys(lower) as (keyof typeof lower)[]) {
+          expect(higher[key]).toBeGreaterThanOrEqual(lower[key])
+        }
+      }
+    }
+  })
+
+  it('does not scale session-shape controls, only cost controls', () => {
+    // Browser sessions and Desktop tabs were deliberately removed: an open
+    // session costs nothing until it generates, and the generating is already
+    // bounded. If either reappears here, something re-added a limit that takes
+    // visible capability from new users and saves nothing.
+    expect(Object.keys(ANVIL_TRUST_LIMITS.full.new).sort()).toEqual([
+      'dailySpendUsd',
+      'messagesPer5Hours',
+      'messagesPerDay',
+      'premiumSessionsPerDay',
+      'userMessagesPerDay',
+    ])
+  })
+
+  it('never lets the limited tier reach a premium session', () => {
+    // The model gate already refuses it; a non-zero number here would be a
+    // promise the rest of the system cannot keep.
+    for (const level of ANVIL_TRUST_LEVELS) {
+      expect(ANVIL_TRUST_LIMITS.limited[level].premiumSessionsPerDay).toBe(0)
+    }
+  })
+
+  it('lets a limited-region core member beat a full-region verified user', () => {
+    // The promise the region split has to make to a real developer abroad.
+    const limitedCore = anvilTrustLimits('limited', 'core')
+    const fullVerified = anvilTrustLimits('full', 'verified')
+    expect(limitedCore.messagesPerDay).toBeGreaterThan(
+      fullVerified.messagesPerDay,
+    )
+    expect(limitedCore.userMessagesPerDay).toBeGreaterThan(
+      fullVerified.userMessagesPerDay,
+    )
+    expect(limitedCore.dailySpendUsd).toBeGreaterThan(
+      fullVerified.dailySpendUsd,
+    )
+  })
+
+  it('keeps every new-account daily budget above the measured p90', () => {
+    // Sizing anchor from free-mode-rate-limiter.ts: full-tier per-user-per-day
+    // p90 is 837. A brand-new account doing genuinely heavy work must fit.
+    expect(
+      anvilTrustLimits('full', 'new').messagesPerDay,
+    ).toBeGreaterThanOrEqual(837)
+  })
+})
+
+describe('scoring', () => {
+  it('leaves an unknown account at the floor', () => {
+    const result = assessAnvilTrust(UNKNOWN, NOW)
+    expect(result.level).toBe('new')
+    expect(result.score).toBe(0)
+    expect(result.cappedBy).toBeNull()
+  })
+
+  it('treats null signals as unknown, never as suspicious', () => {
+    // A pre-provenance account (null everything) must score the same as one
+    // explicitly checked and found to share nothing.
+    const unknownProvenance = assessAnvilTrust(
+      signals({ githubAccountCreatedAt: daysAgo(400) }),
+      NOW,
+    )
+    const cleanProvenance = assessAnvilTrust(
+      signals({
+        githubAccountCreatedAt: daysAgo(400),
+        signupPrefixAccountCount: 1,
+        mailboxAccountCount: 1,
+      }),
+      NOW,
+    )
+    expect(unknownProvenance.level).toBe(cleanProvenance.level)
+    expect(unknownProvenance.cappedBy).toBeNull()
+  })
+
+  it('reaches established on GitHub age plus ordinary account history', () => {
+    const result = assessAnvilTrust(
+      signals({
+        accountCreatedAt: daysAgo(120),
+        githubAccountCreatedAt: daysAgo(3 * 365 + 10),
+        githubOldestRepoCreatedAt: daysAgo(400),
+        githubPublicRepos: 12,
+        activeDays: 40,
+      }),
+      NOW,
+    )
+    // 10 linked + 20 age + 10 repo + 5 repos + 15 acct age + 10 active
+    expect(result.score).toBe(70)
+    expect(result.level).toBe('established')
+  })
+
+  it('lets a brand-new limited-region account climb with earned signals alone', () => {
+    // The route that does not require owning an aged GitHub account: this is
+    // what the Earn page has to be able to promise.
+    const result = assessAnvilTrust(
+      signals({
+        accountCreatedAt: daysAgo(10),
+        approvedBounties: 4,
+        qualifiedReferrals: 5,
+      }),
+      NOW,
+    )
+    // 5 acct age + 20 bounties + 15 referrals
+    expect(result.score).toBe(40)
+    expect(result.level).toBe('verified')
+  })
+
+  it('caps bounty and referral contributions', () => {
+    const capped = assessAnvilTrust(
+      signals({ approvedBounties: 50, qualifiedReferrals: 50 }),
+      NOW,
+    )
+    expect(capped.score).toBe(
+      ANVIL_TRUST_EARNED.BOUNTY_POINTS * ANVIL_TRUST_EARNED.BOUNTY_CAP +
+        ANVIL_TRUST_EARNED.REFERRAL_POINTS *
+          ANVIL_TRUST_EARNED.REFERRAL_CAP,
+    )
+  })
+
+  it('lets contribution alone reach core, with no GitHub and no payment', () => {
+    // THE property the earned caps exist for. Before they were raised this
+    // route peaked at 70 against a threshold of 75, so `core` was reachable
+    // only by owning an aged GitHub account or by paying — which is backwards
+    // for a program meant to give developers in unsupported regions a way to
+    // raise their own limits.
+    const earned = assessAnvilTrust(
+      signals({
+        accountCreatedAt: daysAgo(120),
+        activeDays: 40,
+        approvedBounties: ANVIL_TRUST_EARNED.BOUNTY_CAP,
+        qualifiedReferrals: ANVIL_TRUST_EARNED.REFERRAL_CAP,
+        signupPrivacySignals: [],
+        signupIpSource: 'cloudflare',
+      }),
+      NOW,
+    )
+    expect(earned.factors.map((f) => f.id)).not.toContain('github_linked')
+    expect(earned.score).toBeGreaterThanOrEqual(ANVIL_TRUST_THRESHOLDS.core)
+    expect(earned.level).toBe('core')
+  })
+
+  it('keeps paying past the point someone has proved they are real', () => {
+    // A flat incentive is not an incentive. The tenth referral and the sixth
+    // bounty must still be worth something, or the program stops pulling
+    // exactly where it should pull hardest.
+    const few = assessAnvilTrust(
+      signals({ approvedBounties: 4, qualifiedReferrals: 5 }),
+      NOW,
+    )
+    const many = assessAnvilTrust(
+      signals({ approvedBounties: 6, qualifiedReferrals: 10 }),
+      NOW,
+    )
+    expect(many.score).toBeGreaterThan(few.score)
+  })
+
+  it('never returns a score outside 0..100', () => {
+    const maxed = assessAnvilTrust(
+      signals({
+        accountCreatedAt: daysAgo(1000),
+        githubAccountCreatedAt: daysAgo(4000),
+        githubOldestRepoCreatedAt: daysAgo(3000),
+        githubPublicRepos: 100,
+        githubFollowers: 500,
+        githubTwoFactorEnabled: true,
+        activeDays: 300,
+        approvedBounties: 20,
+        qualifiedReferrals: 20,
+        hasPaid: true,
+        signupPrivacySignals: [],
+        signupIpSource: 'cloudflare',
+      }),
+      NOW,
+    )
+    expect(maxed.score).toBe(100)
+    expect(maxed.level).toBe('core')
+  })
+
+  it('ignores a future-dated timestamp rather than crediting it', () => {
+    const skewed = assessAnvilTrust(
+      signals({
+        githubAccountCreatedAt: new Date(NOW.getTime() + 10 * DAY_MS),
+      }),
+      NOW,
+    )
+    // Linked (10) but no age credit.
+    expect(skewed.score).toBe(10)
+  })
+})
+
+describe('caps', () => {
+  const HIGH_SCORE: Partial<AnvilTrustSignals> = {
+    accountCreatedAt: daysAgo(400),
+    githubAccountCreatedAt: daysAgo(2000),
+    githubOldestRepoCreatedAt: daysAgo(1000),
+    githubPublicRepos: 20,
+    githubFollowers: 50,
+    githubTwoFactorEnabled: true,
+    activeDays: 100,
+    approvedBounties: 4,
+  }
+
+  it('caps a live anonymous network at verified however high the score', () => {
+    const result = assessAnvilTrust(
+      signals({ ...HIGH_SCORE, currentRiskScore: 90 }),
+      NOW,
+    )
+    expect(result.uncappedLevel).toBe('core')
+    expect(result.level).toBe('verified')
+    expect(result.cappedBy).toBe('anonymous_network')
+  })
+
+  it('does not cap on a low current risk score', () => {
+    const result = assessAnvilTrust(
+      signals({ ...HIGH_SCORE, currentRiskScore: 10 }),
+      NOW,
+    )
+    expect(result.level).toBe('core')
+    expect(result.cappedBy).toBeNull()
+  })
+
+  it('caps a VPN signup at established, not lower', () => {
+    const result = assessAnvilTrust(
+      signals({ ...HIGH_SCORE, signupPrivacySignals: ['vpn'] }),
+      NOW,
+    )
+    expect(result.level).toBe('established')
+    expect(result.cappedBy).toBe('signup_privacy_egress')
+  })
+
+  it('credits a clean signup rather than capping it', () => {
+    const result = assessAnvilTrust(
+      signals({ ...HIGH_SCORE, signupPrivacySignals: [] }),
+      NOW,
+    )
+    expect(result.cappedBy).toBeNull()
+    expect(result.factors.some((f) => f.id === 'clean_signup')).toBe(true)
+  })
+
+  it('applies the lowest cap when several bind', () => {
+    const result = assessAnvilTrust(
+      signals({
+        ...HIGH_SCORE,
+        signupPrivacySignals: ['vpn'],
+        mailboxAccountCount: 5,
+      }),
+      NOW,
+    )
+    expect(result.level).toBe('verified')
+    expect(result.cappedBy).toBe('shared_mailbox')
+  })
+
+  it('leads the next steps with the cap, since points cannot clear it', () => {
+    const result = assessAnvilTrust(
+      signals({ ...HIGH_SCORE, currentRiskScore: 90 }),
+      NOW,
+    )
+    expect(result.nextSteps[0]?.id).toBe('cap_anonymous_network')
+    expect(result.nextSteps[0]?.label).toMatch(/VPN/i)
+  })
+
+  it('caps an account with unreversed enforcement history', () => {
+    const result = assessAnvilTrust(
+      signals({ ...HIGH_SCORE, hasUnreversedBanEvent: true }),
+      NOW,
+    )
+    expect(result.level).toBe('verified')
+    expect(result.cappedBy).toBe('past_enforcement')
+  })
+})
+
+describe('next steps', () => {
+  it('leads with connecting GitHub for an account that has none', () => {
+    const result = assessAnvilTrust(UNKNOWN, NOW)
+    expect(result.nextSteps[0]?.id).toBe('connect_github')
+    expect(result.nextSteps[0]?.points).toBe(30)
+  })
+
+  it('stops offering steps the user has already exhausted', () => {
+    const result = assessAnvilTrust(
+      signals({
+        approvedBounties: ANVIL_TRUST_EARNED.BOUNTY_CAP,
+        qualifiedReferrals: ANVIL_TRUST_EARNED.REFERRAL_CAP,
+      }),
+      NOW,
+    )
+    expect(result.nextSteps.map((s) => s.id)).not.toContain('bounties')
+    expect(result.nextSteps.map((s) => s.id)).not.toContain('referrals')
+  })
+
+  it('offers the remaining value, not the full value, of a partial step', () => {
+    const result = assessAnvilTrust(signals({ approvedBounties: 2 }), NOW)
+    const remaining =
+      (ANVIL_TRUST_EARNED.BOUNTY_CAP - 2) *
+      ANVIL_TRUST_EARNED.BOUNTY_POINTS
+    expect(result.nextSteps.find((s) => s.id === 'bounties')?.points).toBe(
+      remaining,
+    )
+  })
+})
+
+describe('wire shape', () => {
+  it('never puts a raw limit on the wire', () => {
+    // A published limit is a published target: the abuse pattern here is
+    // sustained pacing just under the caps, so the caps stay server-side. This
+    // asserts the payload rather than the component, because the payload is
+    // what a future surface would reach for.
+    const info = toAnvilStandingInfo(
+      assessAnvilTrust(signals({ approvedBounties: 4 }), NOW),
+      'limited',
+    )
+    expect(info).not.toHaveProperty('limits')
+
+    // Scoped to the distinctive values. Small ones (a $3 spend cap, 6 premium
+    // sessions) collide with legitimate point values in the copy — "worth 3
+    // points" is not a leaked limit, and asserting on them would fail for the
+    // wrong reason.
+    const serialized = JSON.stringify(info)
+    const distinctive = Object.values(
+      anvilTrustLimits('limited', info.level),
+    ).filter((value) => value >= 100)
+    expect(distinctive.length).toBeGreaterThan(0)
+    for (const value of distinctive) {
+      expect(serialized).not.toContain(String(value))
+    }
+    expect(info.accessTier).toBe('limited')
+  })
+
+  it('describes each axis in words', () => {
+    const info = toAnvilStandingInfo(
+      assessAnvilTrust(signals({ approvedBounties: 4 }), NOW),
+      'limited',
+    )
+    expect(info.highlights.map((h) => h.label)).toEqual([
+      'Prompts a day',
+      'Work per prompt',
+      'Premium models',
+    ])
+    for (const highlight of info.highlights) {
+      expect(highlight.value).not.toMatch(/\d/)
+    }
+  })
+
+  it('frames premium as a region fact where no level can unlock it', () => {
+    // Every limited-row level has 0 premium sessions, so calling it a
+    // shortfall would send the user chasing points that cannot buy it.
+    const limited = toAnvilStandingInfo(
+      assessAnvilTrust(signals({ approvedBounties: 4 }), NOW),
+      'limited',
+    )
+    expect(
+      limited.highlights.find((h) => h.label === 'Premium models')?.value,
+    ).toMatch(/region/i)
+
+    const full = toAnvilStandingInfo(
+      assessAnvilTrust(signals({ approvedBounties: 4 }), NOW),
+      'full',
+    )
+    expect(
+      full.highlights.find((h) => h.label === 'Premium models')?.value,
+    ).not.toMatch(/region/i)
+  })
+
+  it('reports the next threshold, and nothing beyond core', () => {
+    const verified = toAnvilStandingInfo(
+      assessAnvilTrust(
+        signals({ approvedBounties: 4, activeDays: 10 }),
+        NOW,
+      ),
+      'full',
+    )
+    expect(verified.level).toBe('verified')
+    expect(verified.nextLevel).toBe('established')
+    expect(verified.nextLevelAt).toBe(ANVIL_TRUST_THRESHOLDS.established)
+
+    const core = toAnvilStandingInfo(
+      assessAnvilTrust(
+        signals({
+          accountCreatedAt: daysAgo(400),
+          githubAccountCreatedAt: daysAgo(2000),
+          githubOldestRepoCreatedAt: daysAgo(1000),
+          githubPublicRepos: 20,
+          githubFollowers: 50,
+          githubTwoFactorEnabled: true,
+          activeDays: 100,
+          approvedBounties: 4,
+        }),
+        NOW,
+      ),
+      'full',
+    )
+    expect(core.level).toBe('core')
+    expect(core.nextLevel).toBeNull()
+    expect(core.nextLevelAt).toBeNull()
+  })
+
+  it('explains a cap in the copy the client renders', () => {
+    const info = toAnvilStandingInfo(
+      assessAnvilTrust(
+        signals({
+          accountCreatedAt: daysAgo(400),
+          githubAccountCreatedAt: daysAgo(2000),
+          activeDays: 100,
+          currentRiskScore: 99,
+        }),
+        NOW,
+      ),
+      'full',
+    )
+    expect(info.cappedBy).toBe('anonymous_network')
+    expect(info.cappedReason).toMatch(/VPN/i)
+  })
+
+  it('reports no cap when the cap sits at or above the earned level', () => {
+    // An account scoring 'new' is not "capped at verified" — nothing bound.
+    const info = toAnvilStandingInfo(
+      assessAnvilTrust(signals({ currentRiskScore: 99 }), NOW),
+      'full',
+    )
+    expect(info.level).toBe('new')
+    expect(info.cappedBy).toBeNull()
+  })
+})
+
+describe('failure behaviour', () => {
+  it('falls back to the level that reproduces the old flat limits', () => {
+    // A broken resolver must cost us the enforcement, never the users: if this
+    // were 'new', one degraded query would throttle the whole product.
+    expect(ANVIL_TRUST_FALLBACK_LEVEL).toBe('established')
+    expect(anvilTrustLimits('full', ANVIL_TRUST_FALLBACK_LEVEL)).toEqual(
+      anvilTrustLimits('full', 'established'),
+    )
+  })
+})

package/vendor/@anvil/common/src/__tests__/deepseek-direct.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, test } from 'bun:test'
+
+import {
+  DEFAULT_DIRECT_DEEPSEEK_MODEL,
+  remapModelForDirectDeepSeek,
+} from '../constants/deepseek-direct'
+
+describe('remapModelForDirectDeepSeek', () => {
+  test('keeps the model name for DeepSeek lane ids', () => {
+    expect(remapModelForDirectDeepSeek('deepseek/deepseek-v4-pro')).toBe(
+      'deepseek-v4-pro',
+    )
+    expect(remapModelForDirectDeepSeek('deepseek/deepseek-v4-flash')).toBe(
+      'deepseek-v4-flash',
+    )
+  })
+
+  test('normalizes -max context tiers to their base model', () => {
+    expect(remapModelForDirectDeepSeek('deepseek/deepseek-v4-pro-max')).toBe(
+      'deepseek-v4-pro',
+    )
+    expect(remapModelForDirectDeepSeek('deepseek/deepseek-v4-flash-max')).toBe(
+      'deepseek-v4-flash',
+    )
+  })
+
+  test('maps the legacy fireworks lane to flash', () => {
+    expect(remapModelForDirectDeepSeek('fireworks/deepseek-v4-flash')).toBe(
+      'deepseek-v4-flash',
+    )
+  })
+
+  test('falls back to the default model for other providers', () => {
+    // The default base agent requests anthropic/claude-opus-5, which DeepSeek
+    // rejects outright ("The supported API model names are deepseek-v4-pro or
+    // deepseek-v4-flash"). Every non-DeepSeek provider must fall back.
+    for (const model of [
+      'anthropic/claude-opus-5',
+      'openai/gpt-5.4',
+      'google/gemini-3.5-flash-lite',
+      'minimax/minimax-m3',
+      'z-ai/glm-5.2',
+    ]) {
+      expect(remapModelForDirectDeepSeek(model)).toBe(
+        DEFAULT_DIRECT_DEEPSEEK_MODEL,
+      )
+    }
+  })
+
+  test('honors the DEEPSEEK_MODEL override', () => {
+    const previous = process.env.DEEPSEEK_MODEL
+    process.env.DEEPSEEK_MODEL = 'deepseek-chat'
+    try {
+      expect(remapModelForDirectDeepSeek('anthropic/claude-opus-5')).toBe(
+        'deepseek-chat',
+      )
+      expect(remapModelForDirectDeepSeek('deepseek/deepseek-v4-pro')).toBe(
+        'deepseek-chat',
+      )
+    } finally {
+      if (previous === undefined) {
+        delete process.env.DEEPSEEK_MODEL
+      } else {
+        process.env.DEEPSEEK_MODEL = previous
+      }
+    }
+  })
+})