Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure
TypeScript
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([])
})
})