Skip to content

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

TypeScript
10.4 KB
Raw Blame
import { describe, expect, it, vi } from 'vitest'
import { LlmErrorCode } from '../../core/errors'
import type { SingleTurnProvider } from '../../llm'
import type { ConfigureRequest } from '../types'
import { WorkflowService } from '../workflowService'

// ─── Mock LLM Factory ──────────────────────────────────────────────────

function mockLlmFactory(shouldFail = false) {
  return (provider: string, model: string, _apiKey: string): SingleTurnProvider | null => {
    if (shouldFail) return null
    return {
      completeSingleTurn: vi.fn().mockResolvedValue({
        content: 'ok',
        usage: { input_tokens: 0, output_tokens: 0, total_tokens: 0 },
        finish_reason: 'stop',
      }),
      completeSingleTurnWithTools: vi.fn().mockResolvedValue({
        content: 'ok',
        tool_calls: null,
        usage: { input_tokens: 0, output_tokens: 0, total_tokens: 0 },
        finish_reason: 'stop',
      }),
      getProviderType: () => provider as 'openai',
      classifyError: vi.fn(() => ({
        code: LlmErrorCode.ApiCallFailed,
        retryable: true,
        message: 'mock',
      })),
    }
  }
}

describe('POST /configure — JWT scope', () => {
  // JWT scope validation happens in workflowRouter middleware, not in WorkflowService.
  // These tests verify configure() rejects bad input at the service level.

  it('returns configured: false when provider scope is missing', () => {
    const svc = new WorkflowService('test', { llmFactory: mockLlmFactory() })
    const result = svc.configure({ apiKey: 'sk-123' } as ConfigureRequest)
    expect(result.configured).toBe(false)
    expect(result.message).toContain('provider is required')
  })

  it('returns configured: false when apiKey is missing', () => {
    const svc = new WorkflowService('test', { llmFactory: mockLlmFactory() })
    const result = svc.configure({ provider: 'openai' } as ConfigureRequest)
    expect(result.configured).toBe(false)
    expect(result.message).toContain('apiKey is required')
  })

  it('returns configured: true with valid provider and apiKey', () => {
    const svc = new WorkflowService('test', { llmFactory: mockLlmFactory() })
    const result = svc.configure({ provider: 'openai', model: 'gpt-4', apiKey: 'sk-123' })
    expect(result.configured).toBe(true)
    expect(result.provider).toBe('openai')
  })

  it('publishes SDK bootstrap identity without making the workflow service ready or receiving a key', async () => {
    const onBootstrap = vi.fn()
    const svc = new WorkflowService('test', {
      llmFactory: mockLlmFactory(),
      onPluginWorkloadSdkBootstrapConfigured: onBootstrap,
    })
    const result = await svc.configurePluginWorkloadSdkBootstrap({
      provider: 'openai',
      model: 'gpt-4',
      // @ts-expect-error the public bootstrap contract intentionally has no apiKey
      apiKey: 'must-not-be-consumed',
    })
    expect(result).toEqual({
      capabilityFamily: 'promptBridge',
      configured: true,
      ready: true,
      provider: 'openai',
      model: 'gpt-4',
      contractVersion: 2,
    })
    expect(onBootstrap).toHaveBeenCalledWith({ provider: 'openai', defaultModel: 'gpt-4' })
    expect(svc.isReady()).toBe(false)
  })
})

describe('POST /configure — provider hot-swap', () => {
  it('creates new LLM provider instance with given provider and model', () => {
    const factory = vi.fn(mockLlmFactory())
    const svc = new WorkflowService('test', { llmFactory: factory })
    svc.configure({ provider: 'openai', model: 'gpt-4', apiKey: 'sk-123' })
    expect(factory).toHaveBeenCalledWith('openai', 'gpt-4', 'sk-123')
  })

  it('replaces in-memory provider reference atomically', () => {
    const svc = new WorkflowService('test', { llmFactory: mockLlmFactory() })
    svc.configure({ provider: 'openai', model: 'gpt-4', apiKey: 'sk-123' })
    expect(svc.isReady()).toBe(true)

    svc.configure({ provider: 'claude', model: 'claude-3', apiKey: 'sk-ant-456' })
    expect(svc.isReady()).toBe(true)
  })

  it('returns configured: true with provider and model', () => {
    const svc = new WorkflowService('test', { llmFactory: mockLlmFactory() })
    const result = svc.configure({ provider: 'zai', model: 'glm-4.7', apiKey: 'zai-123' })
    expect(result).toEqual({ configured: true, provider: 'zai', model: 'glm-4.7' })
  })

  it('returns configured: false for unknown provider string', () => {
    const svc = new WorkflowService('test', { llmFactory: mockLlmFactory() })
    const result = svc.configure({ provider: 'unknown' as never, model: 'x', apiKey: 'k' })
    expect(result.configured).toBe(false)
  })

  it('returns configured: false for missing apiKey', () => {
    const svc = new WorkflowService('test', { llmFactory: mockLlmFactory() })
    const result = svc.configure({ provider: 'openai', model: 'gpt-4' } as ConfigureRequest)
    expect(result.configured).toBe(false)
  })

  it('swaps onto codex-subscription without an apiKey so the next step cannot inherit the prior key', () => {
    const factory = vi.fn(mockLlmFactory())
    const svc = new WorkflowService('test', { llmFactory: factory })
    svc.configure({ provider: 'openai', model: 'gpt-4', apiKey: 'sk-123' })
    const result = svc.configure({
      provider: 'codex-subscription',
      model: 'gpt-5.3-codex',
    } as ConfigureRequest)
    expect(result).toEqual({
      configured: true,
      provider: 'codex-subscription',
      model: 'gpt-5.3-codex',
      identityBound: true,
    })
    expect(result.grantRedeemable).toBeUndefined()
    expect(factory).toHaveBeenLastCalledWith('codex-subscription', 'gpt-5.3-codex', '')
  })

  it('treats a 200 Codex configure as identity-bound, not execute-ready', () => {
    const svc = new WorkflowService('test', { llmFactory: mockLlmFactory() })
    const result = svc.configure({
      provider: 'codex-subscription',
      model: 'gpt-5.3-codex',
    } as ConfigureRequest)
    expect(result.configured).toBe(true)
    expect(result.identityBound).toBe(true)
    expect(result.grantRedeemable).not.toBe(true)
    expect(result).not.toHaveProperty('connectionRef')
    expect(result).not.toHaveProperty('apiKey')
  })

  it('does not leave the prior provider ready when a Codex configure fails', () => {
    const factory = vi
      .fn()
      .mockImplementationOnce(mockLlmFactory())
      .mockImplementationOnce(() => {
        throw new Error('static slot')
      })
    const svc = new WorkflowService('test', { llmFactory: factory })
    expect(svc.configure({ provider: 'openai', model: 'gpt-4', apiKey: 'sk-123' }).configured).toBe(
      true
    )
    const result = svc.configure({
      provider: 'codex-subscription',
      model: 'gpt-5.3-codex',
      soulContent: 'must not stick on a failed bind',
    } as ConfigureRequest)
    expect(result.configured).toBe(false)
    expect(svc.isReady()).toBe(false)
    expect(svc.isSoulOverrideActive()).toBe(false)
  })

  it('constructs keyless Codex through the default factory without throwing on primarySlot', () => {
    const previous = process.env.MCP_HOST_CODEX_SUBSCRIPTION_ENABLED
    process.env.MCP_HOST_CODEX_SUBSCRIPTION_ENABLED = 'true'
    try {
      const svc = new WorkflowService('test')
      const result = svc.configure({
        provider: 'codex-subscription',
        model: 'gpt-5.3-codex',
      } as ConfigureRequest)
      expect(result).toEqual({
        configured: true,
        provider: 'codex-subscription',
        model: 'gpt-5.3-codex',
        identityBound: true,
      })
      expect(result.grantRedeemable).toBeUndefined()
      expect(svc.isReady()).toBe(true)
    } finally {
      if (previous === undefined) delete process.env.MCP_HOST_CODEX_SUBSCRIPTION_ENABLED
      else process.env.MCP_HOST_CODEX_SUBSCRIPTION_ENABLED = previous
    }
  })
})

describe('POST /configure — SOUL override', () => {
  it('sets soulOverrideActive flag when soulContent is present', () => {
    const svc = new WorkflowService('test', { llmFactory: mockLlmFactory() })
    svc.configure({
      provider: 'openai',
      model: 'gpt-4',
      apiKey: 'k',
      soulContent: 'You are an expert.',
    })
    expect(svc.isSoulOverrideActive()).toBe(true)
  })

  it('does not set soulOverrideActive flag when soulContent is absent', () => {
    const svc = new WorkflowService('test', { llmFactory: mockLlmFactory() })
    svc.configure({ provider: 'openai', model: 'gpt-4', apiKey: 'k' })
    expect(svc.isSoulOverrideActive()).toBe(false)
  })

  it('stores soulContent in memory for use by next execute call', () => {
    const svc = new WorkflowService('test', { llmFactory: mockLlmFactory() })
    svc.configure({ provider: 'openai', model: 'gpt-4', apiKey: 'k', soulContent: 'Custom SOUL' })
    expect(svc.getActiveSoulContent()).toBe('Custom SOUL')
  })

  it('returns configured: false when soulContent exceeds 64KB', () => {
    const svc = new WorkflowService('test', { llmFactory: mockLlmFactory() })
    const bigContent = 'x'.repeat(65 * 1024)
    const result = svc.configure({
      provider: 'openai',
      model: 'gpt-4',
      apiKey: 'k',
      soulContent: bigContent,
    })
    expect(result.configured).toBe(false)
    expect(result.message).toContain('64KB')
  })
})

describe('POST /configure — idempotency', () => {
  it('second configure call with different model replaces first', () => {
    const factory = vi.fn(mockLlmFactory())
    const svc = new WorkflowService('test', { llmFactory: factory })
    svc.configure({ provider: 'openai', model: 'gpt-4', apiKey: 'k1' })
    svc.configure({ provider: 'openai', model: 'gpt-4o', apiKey: 'k2' })
    expect(factory).toHaveBeenCalledTimes(2)
  })

  it('configure with same provider/model is a no-op (no new instance created)', () => {
    const factory = vi.fn(mockLlmFactory())
    const svc = new WorkflowService('test', { llmFactory: factory })
    svc.configure({ provider: 'openai', model: 'gpt-4', apiKey: 'k1' })
    svc.configure({ provider: 'openai', model: 'gpt-4', apiKey: 'k1' })
    expect(factory).toHaveBeenCalledTimes(1) // idempotent
  })

  it('rejects invalid llmSecretName metadata before configuring provider', () => {
    const factory = vi.fn(mockLlmFactory())
    const svc = new WorkflowService('test', { llmFactory: factory })
    const result = svc.configure({
      provider: 'openai',
      model: 'gpt-4',
      apiKey: 'k1',
      llmSecretName: '../secret',
    })
    expect(result.configured).toBe(false)
    expect(result.message).toContain('llmSecretName')
    expect(factory).not.toHaveBeenCalled()
  })
})