Skip to content

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

TypeScript
19.0 KB
Raw Blame
import { describe, expect, it, vi } from 'vitest'
import { CODEX_UNASSIGNED_CONNECTION_KEY } from '@clerum/codex-catalog-projection'
import { computeGrokPolicyHash } from '@clerum/grok-provider-attempt-contract'
import { computeCodexPolicyHash } from '@clerum/llm-provider-attempt-contract'
import {
  configurePluginWorkloadSdkBootstrapIdentity,
  resolvePluginWorkloadSdkBootstrapCapabilityFamily,
} from './bootstrapIdentity'
import * as sdkOnlyCodexBinding from './sdkOnlyCodexBinding'
import {
  readSdkOnlyCodexBinding,
  readVerifiedSdkOnlyCodexBinding,
  replaceSdkOnlyCodexBinding,
} from './sdkOnlyCodexBinding'
import { readSdkOnlyGrokBinding, replaceSdkOnlyGrokBinding } from './sdkOnlyGrokBinding'

describe('readVerifiedSdkOnlyCodexBinding', () => {
  const model = 'gpt-5.6-luna'
  const binding = {
    connectionKey: 'team-plus',
    catalogRevision: 4,
    credentialRevision: 1,
    model,
    bindingHash: computeCodexPolicyHash({
      model,
      catalogRevision: 4,
      credentialRevision: 1,
      connectionKey: 'team-plus',
    }),
  }

  it('accepts only a hash that matches the bound fields and expected model', () => {
    expect(readVerifiedSdkOnlyCodexBinding(binding, model)).toEqual(binding)
    expect(
      readVerifiedSdkOnlyCodexBinding({ ...binding, bindingHash: 'a'.repeat(64) }, model)
    ).toBeNull()
    expect(readVerifiedSdkOnlyCodexBinding(binding, 'gpt-5.4-mini')).toBeNull()
    expect(readVerifiedSdkOnlyCodexBinding(undefined, model)).toBeNull()
    expect(readVerifiedSdkOnlyCodexBinding({ ...binding, extra: 'drop-me' }, model)).toEqual(
      binding
    )
  })

  it('rejects the shared unassigned connection sentinel', () => {
    expect(
      readVerifiedSdkOnlyCodexBinding(
        {
          ...binding,
          connectionKey: CODEX_UNASSIGNED_CONNECTION_KEY,
          bindingHash: computeCodexPolicyHash({
            model,
            catalogRevision: 4,
            credentialRevision: 1,
            connectionKey: CODEX_UNASSIGNED_CONNECTION_KEY,
          }),
        },
        model
      )
    ).toBeNull()
  })
})

describe('Plugin Workload SDK bootstrap identity', () => {
  it('uses the host capability projection instead of a request-selected family', async () => {
    const verify = vi.fn().mockResolvedValue({
      ready: true,
      contractVersion: 2,
      provider: 'openai',
      model: 'gpt-5.4-mini',
      policyReady: true,
      policyState: 'active',
    })

    const result = await configurePluginWorkloadSdkBootstrapIdentity(
      {
        capabilityFamily: 'promptBridge',
        provider: 'openai',
        model: 'gpt-5.4-mini',
      },
      { capabilityFamily: 'promptBridge', verify }
    )

    expect(result).toMatchObject({
      configured: true,
      ready: true,
      capabilityFamily: 'promptBridge',
      provider: 'openai',
      model: 'gpt-5.4-mini',
    })
    expect(verify).toHaveBeenCalledWith('openai', 'gpt-5.4-mini')
  })

  it('rejects a request that tries to switch the projected family before verification', async () => {
    const verify = vi.fn()

    const result = await configurePluginWorkloadSdkBootstrapIdentity(
      {
        capabilityFamily: 'clientNotifications',
        provider: 'openai',
        model: 'gpt-5.4-mini',
      },
      { capabilityFamily: 'promptBridge', verify }
    )

    expect(result).toEqual({
      configured: false,
      ready: false,
      contractVersion: 2,
      capabilityFamily: 'promptBridge',
      message: 'Plugin Workload SDK bootstrap capability family does not match the host projection',
    })
    expect(verify).not.toHaveBeenCalled()
  })

  it('keeps notifications-only bootstrap provider-free under its projected family', async () => {
    const verifyClientNotifications = vi.fn().mockResolvedValue({
      ready: true,
      contractVersion: 2,
      policyReady: true,
      policyState: 'active',
    })
    const onConfigured = vi.fn()

    const result = await configurePluginWorkloadSdkBootstrapIdentity(
      { capabilityFamily: 'clientNotifications', provider: 'openai', model: 'gpt-5.4-mini' },
      { capabilityFamily: 'clientNotifications', verifyClientNotifications, onConfigured }
    )

    expect(result).toMatchObject({
      configured: true,
      ready: true,
      capabilityFamily: 'clientNotifications',
      policyReady: true,
      policyState: 'active',
    })
    expect(verifyClientNotifications).toHaveBeenCalledOnce()
    expect(onConfigured).not.toHaveBeenCalled()
  })

  it('maps the mounted capability projection to the bootstrap proof family', () => {
    expect(resolvePluginWorkloadSdkBootstrapCapabilityFamily(['promptBridge'])).toBe('promptBridge')
    expect(
      resolvePluginWorkloadSdkBootstrapCapabilityFamily(['promptBridge', 'clientNotifications'])
    ).toBe('promptBridge')
    expect(resolvePluginWorkloadSdkBootstrapCapabilityFamily(['clientNotifications'])).toBe(
      'clientNotifications'
    )
  })

  it('keeps Codex identity ready while the v3 execution binding is missing', async () => {
    replaceSdkOnlyCodexBinding(null)
    const verify = vi.fn()
    const result = await configurePluginWorkloadSdkBootstrapIdentity(
      {
        capabilityFamily: 'promptBridge',
        provider: 'codex-subscription',
        model: 'gpt-5.6-luna',
        contractVersion: 2,
      },
      { capabilityFamily: 'promptBridge', verify }
    )
    expect(result).toMatchObject({
      configured: true,
      ready: true,
      contractVersion: 3,
      policyReady: false,
      policyReason: 'codex_execution_binding_missing',
    })
    expect(verify).not.toHaveBeenCalled()
    expect(readSdkOnlyCodexBinding()).toBeNull()
  })

  it('stores a verified v3 Codex binding before identity verification', async () => {
    const binding = {
      connectionKey: 'team-plus',
      catalogRevision: 4,
      credentialRevision: 1,
      model: 'gpt-5.6-luna',
      bindingHash: computeCodexPolicyHash({
        model: 'gpt-5.6-luna',
        catalogRevision: 4,
        credentialRevision: 1,
        connectionKey: 'team-plus',
      }),
    }
    const verify = vi.fn().mockResolvedValue({
      ready: true,
      contractVersion: 3,
      provider: 'codex-subscription',
      model: 'gpt-5.6-luna',
      policyReady: true,
      policyState: 'active',
      codexBindingReady: true,
    })
    const result = await configurePluginWorkloadSdkBootstrapIdentity(
      {
        capabilityFamily: 'promptBridge',
        provider: 'codex-subscription',
        model: 'gpt-5.6-luna',
        contractVersion: 3,
        codexBinding: binding,
      },
      { capabilityFamily: 'promptBridge', verify }
    )
    expect(result).toMatchObject({
      configured: true,
      ready: true,
      contractVersion: 3,
      provider: 'codex-subscription',
      model: 'gpt-5.6-luna',
      codexBinding: binding,
    })
    expect(readSdkOnlyCodexBinding()).toEqual(binding)
    replaceSdkOnlyCodexBinding(null)
  })

  it('clears the stored Codex binding when identity verification throws', async () => {
    const binding = {
      connectionKey: 'team-plus',
      catalogRevision: 4,
      credentialRevision: 1,
      model: 'gpt-5.6-luna',
      bindingHash: computeCodexPolicyHash({
        model: 'gpt-5.6-luna',
        catalogRevision: 4,
        credentialRevision: 1,
        connectionKey: 'team-plus',
      }),
    }
    // The binding is installed BEFORE verification because `verify` reads the
    // live global to build its capabilities request. A transport failure there
    // must not leave an unconfirmed binding behind for the next prompt to
    // execute against — and must still surface as the original error.
    const verify = vi.fn().mockRejectedValue(new Error('control-api unreachable'))
    await expect(
      configurePluginWorkloadSdkBootstrapIdentity(
        {
          capabilityFamily: 'promptBridge',
          provider: 'codex-subscription',
          model: 'gpt-5.6-luna',
          contractVersion: 3,
          codexBinding: binding,
        },
        { capabilityFamily: 'promptBridge', verify }
      )
    ).rejects.toThrow('control-api unreachable')
    expect(readSdkOnlyCodexBinding()).toBeNull()
  })

  it('integrity-checks a supplied Codex binding even when the request provider is not Codex', async () => {
    replaceSdkOnlyCodexBinding(null)
    const verifyBinding = vi.spyOn(sdkOnlyCodexBinding, 'readVerifiedSdkOnlyCodexBinding')
    const binding = {
      connectionKey: 'team-plus',
      catalogRevision: 4,
      credentialRevision: 1,
      model: 'gpt-5.4-mini',
      bindingHash: computeCodexPolicyHash({
        model: 'gpt-5.4-mini',
        catalogRevision: 4,
        credentialRevision: 1,
        connectionKey: 'team-plus',
      }),
    }
    const verify = vi.fn().mockResolvedValue({
      ready: true,
      contractVersion: 2,
      provider: 'openai',
      model: 'gpt-5.4-mini',
      policyReady: true,
      policyState: 'active',
    })
    const result = await configurePluginWorkloadSdkBootstrapIdentity(
      {
        capabilityFamily: 'promptBridge',
        provider: 'openai',
        model: 'gpt-5.4-mini',
        contractVersion: 2,
        codexBinding: binding,
      },
      { capabilityFamily: 'promptBridge', verify }
    )
    expect(result).toMatchObject({
      configured: true,
      ready: true,
      provider: 'openai',
      contractVersion: 2,
    })
    expect(result).not.toHaveProperty('codexBinding')
    expect(verifyBinding).toHaveBeenCalledWith(binding, 'gpt-5.4-mini')
    expect(readSdkOnlyCodexBinding()).toBeNull()
    verifyBinding.mockRestore()
  })

  it('rejects a Codex binding whose hash does not match the bound fields', async () => {
    replaceSdkOnlyCodexBinding(null)
    const verify = vi.fn()
    const result = await configurePluginWorkloadSdkBootstrapIdentity(
      {
        capabilityFamily: 'promptBridge',
        provider: 'codex-subscription',
        model: 'gpt-5.6-luna',
        contractVersion: 3,
        codexBinding: {
          connectionKey: 'team-plus',
          catalogRevision: 4,
          credentialRevision: 1,
          model: 'gpt-5.6-luna',
          bindingHash: 'a'.repeat(64),
        },
      },
      { capabilityFamily: 'promptBridge', verify }
    )
    expect(result).toMatchObject({
      configured: true,
      ready: true,
      contractVersion: 3,
      policyReady: false,
      policyReason: 'codex_execution_binding_missing',
    })
    expect(verify).not.toHaveBeenCalled()
    expect(readSdkOnlyCodexBinding()).toBeNull()
  })

  it('accepts a hash-valid Codex binding even if the request echoes contract v2', async () => {
    const binding = {
      connectionKey: 'team-plus',
      catalogRevision: 4,
      credentialRevision: 1,
      model: 'gpt-5.6-luna',
      bindingHash: computeCodexPolicyHash({
        model: 'gpt-5.6-luna',
        catalogRevision: 4,
        credentialRevision: 1,
        connectionKey: 'team-plus',
      }),
    }
    const verify = vi.fn().mockResolvedValue({
      ready: true,
      contractVersion: 3,
      provider: 'codex-subscription',
      model: 'gpt-5.6-luna',
      policyReady: true,
      policyState: 'active',
      codexBindingReady: true,
    })
    const result = await configurePluginWorkloadSdkBootstrapIdentity(
      {
        capabilityFamily: 'promptBridge',
        provider: 'codex-subscription',
        model: 'gpt-5.6-luna',
        contractVersion: 2,
        codexBinding: binding,
      },
      { capabilityFamily: 'promptBridge', verify }
    )
    expect(result).toMatchObject({
      configured: true,
      ready: true,
      contractVersion: 3,
      codexBinding: binding,
    })
    expect(readSdkOnlyCodexBinding()).toEqual(binding)
    replaceSdkOnlyCodexBinding(null)
  })

  it('echoes a sanitized five-field Codex binding instead of extra request keys', async () => {
    const binding = {
      connectionKey: 'team-plus',
      catalogRevision: 4,
      credentialRevision: 1,
      model: 'gpt-5.6-luna',
      bindingHash: computeCodexPolicyHash({
        model: 'gpt-5.6-luna',
        catalogRevision: 4,
        credentialRevision: 1,
        connectionKey: 'team-plus',
      }),
    }
    const verify = vi.fn().mockResolvedValue({
      ready: true,
      contractVersion: 3,
      provider: 'codex-subscription',
      model: 'gpt-5.6-luna',
      policyReady: true,
      policyState: 'active',
      codexBindingReady: true,
    })
    const result = await configurePluginWorkloadSdkBootstrapIdentity(
      {
        capabilityFamily: 'promptBridge',
        provider: 'codex-subscription',
        model: 'gpt-5.6-luna',
        contractVersion: 3,
        codexBinding: { ...binding, leaked: 'drop-me' } as typeof binding,
      },
      { capabilityFamily: 'promptBridge', verify }
    )
    expect(result.codexBinding).toEqual(binding)
    expect(result.codexBinding).not.toHaveProperty('leaked')
    replaceSdkOnlyCodexBinding(null)
  })

  it('keeps Grok identity ready while the v3 execution binding is missing', async () => {
    replaceSdkOnlyGrokBinding(null)
    const verify = vi.fn()
    const result = await configurePluginWorkloadSdkBootstrapIdentity(
      {
        capabilityFamily: 'promptBridge',
        provider: 'grok-subscription',
        model: 'grok-4.6',
        contractVersion: 3,
      },
      { capabilityFamily: 'promptBridge', verify }
    )
    expect(result).toMatchObject({
      configured: true,
      ready: true,
      contractVersion: 3,
      policyReady: false,
      policyReason: 'execution_binding_missing',
      bindingReady: false,
    })
    expect(result).not.toHaveProperty('codexBinding')
    expect(verify).not.toHaveBeenCalled()
    expect(readSdkOnlyGrokBinding()).toBeNull()
  })

  it('echoes subscriptionBinding and generic ready flags for a verified Grok proof', async () => {
    const binding = {
      connectionKey: 'team-grok',
      catalogRevision: 5,
      credentialRevision: 2,
      model: 'grok-4.6',
      bindingHash: computeGrokPolicyHash({
        model: 'grok-4.6',
        catalogRevision: 5,
        credentialRevision: 2,
        connectionKey: 'team-grok',
      }),
    }
    const verify = vi.fn().mockResolvedValue({
      ready: true,
      contractVersion: 3,
      provider: 'grok-subscription',
      model: 'grok-4.6',
      policyReady: true,
      policyState: 'active',
      bindingReady: true,
    })
    const result = await configurePluginWorkloadSdkBootstrapIdentity(
      {
        capabilityFamily: 'promptBridge',
        provider: 'grok-subscription',
        model: 'grok-4.6',
        contractVersion: 3,
        subscriptionBinding: binding,
      },
      { capabilityFamily: 'promptBridge', verify }
    )
    expect(result).toMatchObject({
      configured: true,
      ready: true,
      contractVersion: 3,
      provider: 'grok-subscription',
      model: 'grok-4.6',
      subscriptionBinding: binding,
      bindingReady: true,
    })
    expect(result).not.toHaveProperty('codexBinding')
    expect(readSdkOnlyGrokBinding()).toEqual(binding)
    expect(readSdkOnlyCodexBinding()).toBeNull()
    replaceSdkOnlyGrokBinding(null)
  })

  describe('strict provider binding slots (B-L14)', () => {
    function grokBinding(connectionKey: string) {
      const fields = { connectionKey, catalogRevision: 5, credentialRevision: 2, model: 'grok-4.6' }
      return { ...fields, bindingHash: computeGrokPolicyHash(fields) }
    }
    function codexBinding(connectionKey: string) {
      const fields = {
        connectionKey,
        catalogRevision: 4,
        credentialRevision: 1,
        model: 'gpt-5.6-luna',
      }
      return { ...fields, bindingHash: computeCodexPolicyHash(fields) }
    }
    const readyProof = (provider: string, model: string) => ({
      ready: true,
      contractVersion: 3,
      provider,
      model,
      policyReady: true,
      policyState: 'active',
      bindingReady: true,
      codexBindingReady: true,
    })

    it('ignores a hash-valid Grok binding delivered in the Codex slot', async () => {
      replaceSdkOnlyGrokBinding(null)
      replaceSdkOnlyCodexBinding(null)
      const verify = vi.fn()
      const result = await configurePluginWorkloadSdkBootstrapIdentity(
        {
          capabilityFamily: 'promptBridge',
          provider: 'grok-subscription',
          model: 'grok-4.6',
          contractVersion: 3,
          codexBinding: grokBinding('team-grok'),
        },
        { capabilityFamily: 'promptBridge', verify }
      )
      expect(result).toMatchObject({
        configured: true,
        policyReady: false,
        policyReason: 'execution_binding_missing',
        bindingReady: false,
      })
      expect(result).not.toHaveProperty('subscriptionBinding')
      expect(verify).not.toHaveBeenCalled()
      expect(readSdkOnlyGrokBinding()).toBeNull()
      expect(readSdkOnlyCodexBinding()).toBeNull()
    })

    it('ignores a hash-valid Codex binding delivered in the Grok slot', async () => {
      replaceSdkOnlyGrokBinding(null)
      replaceSdkOnlyCodexBinding(null)
      const verify = vi.fn()
      const result = await configurePluginWorkloadSdkBootstrapIdentity(
        {
          capabilityFamily: 'promptBridge',
          provider: 'codex-subscription',
          model: 'gpt-5.6-luna',
          contractVersion: 3,
          subscriptionBinding: codexBinding('team-plus'),
        },
        { capabilityFamily: 'promptBridge', verify }
      )
      expect(result).toMatchObject({
        configured: true,
        policyReady: false,
        policyReason: 'codex_execution_binding_missing',
      })
      expect(result).not.toHaveProperty('codexBinding')
      expect(verify).not.toHaveBeenCalled()
      expect(readSdkOnlyCodexBinding()).toBeNull()
      expect(readSdkOnlyGrokBinding()).toBeNull()
    })

    it('installs the Grok binding from subscriptionBinding even when codexBinding also verifies', async () => {
      const own = grokBinding('team-grok')
      const verify = vi.fn().mockResolvedValue(readyProof('grok-subscription', 'grok-4.6'))
      const result = await configurePluginWorkloadSdkBootstrapIdentity(
        {
          capabilityFamily: 'promptBridge',
          provider: 'grok-subscription',
          model: 'grok-4.6',
          contractVersion: 3,
          codexBinding: grokBinding('other-grok'),
          subscriptionBinding: own,
        },
        { capabilityFamily: 'promptBridge', verify }
      )
      expect(result).toMatchObject({ subscriptionBinding: own, bindingReady: true })
      expect(readSdkOnlyGrokBinding()).toEqual(own)
      replaceSdkOnlyGrokBinding(null)
    })

    it('installs the Codex binding from codexBinding even when subscriptionBinding also verifies', async () => {
      const own = codexBinding('team-plus')
      const verify = vi.fn().mockResolvedValue(readyProof('codex-subscription', 'gpt-5.6-luna'))
      const result = await configurePluginWorkloadSdkBootstrapIdentity(
        {
          capabilityFamily: 'promptBridge',
          provider: 'codex-subscription',
          model: 'gpt-5.6-luna',
          contractVersion: 3,
          codexBinding: own,
          subscriptionBinding: codexBinding('other-plus'),
        },
        { capabilityFamily: 'promptBridge', verify }
      )
      expect(result).toMatchObject({ codexBinding: own })
      expect(readSdkOnlyCodexBinding()).toEqual(own)
      replaceSdkOnlyCodexBinding(null)
    })
  })
})