Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript
5.2 KB
Raw Blame
import { describe, expect, it } from 'vitest'
import { CODEX_CONNECTION_REF_ANNOTATION } from '../src/services/codexSubscriptionConnection.js'
import {
  SUBSCRIPTION_CONNECTION_REF_ANNOTATION,
  attestRequestedBrokerProvider,
  collectHostOauthBrokerProviders,
  collectRecipeOauthBrokerProviders,
  readSubscriptionConnectionRef,
} from '../src/services/subscriptionGrantIdentity.js'

describe('collectHostOauthBrokerProviders', () => {
  it('includes Codex fallbacks when the primary is static', () => {
    expect(
      collectHostOauthBrokerProviders({
        model: { provider: 'openai', name: 'gpt-5.1' },
        secretRef: 'llm',
        llmPolicy: { fallbacks: [{ provider: 'codex-subscription', name: 'gpt-5.3-codex' }] },
        allowedModels: [{ provider: 'codex-subscription', name: 'gpt-5.3-codex' }],
      })
    ).toEqual(['codex-subscription'])
  })

  it('returns empty when every target is static', () => {
    expect(
      collectHostOauthBrokerProviders({
        model: { provider: 'openai', name: 'gpt-5.1' },
      })
    ).toEqual([])
  })
})

describe('attestRequestedBrokerProvider', () => {
  it('allows a static primary plus Codex fallback to spend Codex', () => {
    const result = attestRequestedBrokerProvider({
      requestedProvider: 'codex-subscription',
      liveBrokerProviders: collectHostOauthBrokerProviders({
        model: { provider: 'openai' },
        llmPolicy: { fallbacks: [{ provider: 'codex-subscription' }] },
      }),
      liveConnectionRef: 'team-plus',
    })
    expect(result).toEqual({
      ok: true,
      provider: 'codex-subscription',
      connectionKey: 'team-plus',
    })
  })

  it('denies a Codex body on a static-only Host', () => {
    const result = attestRequestedBrokerProvider({
      requestedProvider: 'codex-subscription',
      liveBrokerProviders: collectHostOauthBrokerProviders({
        model: { provider: 'openai' },
      }),
      liveConnectionRef: 'team-plus',
    })
    expect(result.ok).toBe(false)
    if (!result.ok) expect(result.code).toBe('host_binding_mismatch')
  })

  it('returns unassigned when connectionRef is empty', () => {
    const result = attestRequestedBrokerProvider({
      requestedProvider: 'codex-subscription',
      liveBrokerProviders: ['codex-subscription'],
      liveConnectionRef: '',
    })
    expect(result.ok).toBe(false)
    if (!result.ok) expect(result.code).toBe('unassigned_connection')
  })

  it('keeps empty Grok connectionRef unassigned and never aliases deployment-default', () => {
    const empty = attestRequestedBrokerProvider({
      requestedProvider: 'grok-subscription',
      liveBrokerProviders: ['grok-subscription'],
      liveConnectionRef: '',
    })
    expect(empty.ok).toBe(false)
    if (!empty.ok) expect(empty.code).toBe('unassigned_connection')
    const reserved = attestRequestedBrokerProvider({
      requestedProvider: 'grok-subscription',
      liveBrokerProviders: ['grok-subscription'],
      liveConnectionRef: 'deployment-default',
    })
    expect(reserved.ok).toBe(false)
    if (!reserved.ok) expect(reserved.code).toBe('unassigned_connection')
  })
})

describe('readSubscriptionConnectionRef', () => {
  it('reads the Codex alias when only that key is set', () => {
    const result = readSubscriptionConnectionRef({
      provider: 'codex-subscription',
      annotations: { [CODEX_CONNECTION_REF_ANNOTATION]: 'team-plus' },
    })
    expect(result).toEqual({ ok: true, connectionKey: 'team-plus' })
  })

  it('fails closed when Codex annotations disagree', () => {
    const result = readSubscriptionConnectionRef({
      provider: 'codex-subscription',
      annotations: {
        [CODEX_CONNECTION_REF_ANNOTATION]: 'team-plus',
        [SUBSCRIPTION_CONNECTION_REF_ANNOTATION]: 'other-key',
      },
    })
    expect(result.ok).toBe(false)
  })

  it('fails closed when a non-Codex broker still has the Codex alias', () => {
    const result = readSubscriptionConnectionRef({
      provider: 'openai',
      annotations: { [CODEX_CONNECTION_REF_ANNOTATION]: 'team-plus' },
    })
    expect(result.ok).toBe(false)
  })

  it('fails closed when a Grok recipe still has the Codex alias leftover', () => {
    const result = readSubscriptionConnectionRef({
      provider: 'grok-subscription',
      annotations: { [CODEX_CONNECTION_REF_ANNOTATION]: 'team-plus' },
    })
    expect(result.ok).toBe(false)
  })

  it('reads only the canonical annotation for Grok', () => {
    const result = readSubscriptionConnectionRef({
      provider: 'grok-subscription',
      annotations: { [SUBSCRIPTION_CONNECTION_REF_ANNOTATION]: 'team-grok' },
    })
    expect(result).toEqual({ ok: true, connectionKey: 'team-grok' })
  })
})

describe('collectRecipeOauthBrokerProviders', () => {
  it('includes Codex step agents when the recipe agent is static', () => {
    expect(
      collectRecipeOauthBrokerProviders({
        agent: { provider: 'openai' },
        steps: [{ agent: { provider: 'codex-subscription' } }],
      })
    ).toEqual(['codex-subscription'])
  })

  it('does not treat promptTargets as a recipe spec field', () => {
    expect(
      collectRecipeOauthBrokerProviders({
        agent: { provider: 'openai' },
        promptTargets: [{ provider: 'codex-subscription' }],
      })
    ).toEqual([])
  })
})