outcome-cli 1.0.0

package/src/agents/adapters/veo.adapter.ts

@@ -0,0 +1,130 @@
+/**
+ * Gemini Veo Video Generation Adapter
+ * 
+ * Adapts Google's Veo video generation to work with WAI Championship's agent system.
+ * 
+ * @module agents/adapters/veo
+ */
+
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import type { AgentConfig } from '../agent.schema.js';
+import type { AgentArtifact } from '../../eval/evaluateOutcome.js';
+import type { ContentCreationPrompt, ContentCreationResult } from './dalle.adapter.js';
+
+/**
+ * Executes a Veo agent for video generation
+ * 
+ * @param config - WAI agent configuration
+ * @param prompt - Content creation prompt
+ * @param outcomeId - ID of the outcome being attempted
+ * @param attemptNumber - Current attempt number
+ * @returns Result of agent execution with artifact if successful
+ */
+export async function runVeoAgent(
+  config: AgentConfig,
+  prompt: ContentCreationPrompt,
+  outcomeId: string,
+  attemptNumber: number
+): Promise<ContentCreationResult> {
+  try {
+    const genAI = new GoogleGenerativeAI(process.env.GOOGLE_API_KEY || '');
+    
+    // Use the latest Veo model
+    const model = genAI.getGenerativeModel({ model: 'veo-3.1-generate-preview' });
+
+    // Build the video generation prompt
+    const videoPrompt = `Generate a video: ${prompt.description}${prompt.style ? ` Style: ${prompt.style}` : ''}`;
+
+    // Note: Veo uses predictLongRunning method, not generateContent
+    // This is a placeholder implementation - actual API integration needed
+    const result = await model.generateContent(videoPrompt);
+    const response = result.response;
+    const content = response.text();
+
+    const artifact: AgentArtifact = {
+      agentId: config.id,
+      outcomeId,
+      attemptNumber,
+      content: {
+        type: 'video',
+        videoUrl: 'https://via.placeholder.com/1280x720/FF4444/FFFFFF?text=Veo+Video+Generated', // Placeholder
+        originalPrompt: videoPrompt,
+        revisedPrompt: content,
+        dimensions: prompt.dimensions || '1280x720',
+        model: 'veo-3.1-generate-preview',
+        style: prompt.style,
+        target: prompt.target,
+        generatedText: content,
+        duration: '5s', // Default duration
+      },
+      timestamp: new Date().toISOString(),
+    };
+
+    // Estimate tokens
+    const estimatedTokens = Math.ceil((videoPrompt.length + content.length) / 4);
+
+    return {
+      success: true,
+      message: 'Veo agent completed successfully',
+      tokensUsed: estimatedTokens,
+      artifact,
+      imageUrl: artifact.content.videoUrl, // Using imageUrl field for video URL
+      revisedPrompt: content,
+    };
+
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+    return {
+      success: false,
+      message: `Veo agent execution failed: ${errorMessage}`,
+      tokensUsed: 0,
+      error: errorMessage,
+    };
+  }
+}
+
+/**
+ * Creates a mock Veo agent run for testing
+ * 
+ * @param config - Agent configuration
+ * @param prompt - Content creation prompt
+ * @param outcomeId - Outcome ID
+ * @param attemptNumber - Attempt number
+ * @returns Mock result matching Veo output format
+ */
+export function mockVeoAgent(
+  config: AgentConfig,
+  prompt: ContentCreationPrompt,
+  outcomeId: string,
+  attemptNumber: number
+): ContentCreationResult {
+  const mockVideoUrl = 'https://via.placeholder.com/1280x720/FF4444/FFFFFF?text=Veo+Mock+Video';
+  
+  const artifact: AgentArtifact = {
+    agentId: config.id,
+    outcomeId,
+    attemptNumber,
+    content: {
+      type: 'video',
+      videoUrl: mockVideoUrl,
+      originalPrompt: prompt.description,
+      revisedPrompt: `Veo enhanced: ${prompt.description} with cinematic quality and smooth motion`,
+      dimensions: prompt.dimensions || '1280x720',
+      model: 'veo-3.1-generate-preview',
+      style: prompt.style,
+      target: prompt.target,
+      generatedText: `Created a dynamic video of ${prompt.description} with professional cinematography`,
+      duration: '5s',
+    },
+    timestamp: new Date().toISOString(),
+  };
+
+  return {
+    success: true,
+    message: 'Mock Veo agent completed',
+    tokensUsed: 500,
+    artifact,
+    imageUrl: mockVideoUrl,
+    revisedPrompt: `Veo enhanced: ${prompt.description} with cinematic quality and smooth motion`,
+  };
+}

package/src/agents/agent.schema.property.test.ts

@@ -0,0 +1,379 @@
+/**
+ * Property-based tests for Agent Configuration Schema Validation
+ *
+ * **Feature: earnd-bounty-engine, Property 10: Agent Configuration Schema Validation**
+ * **Validates: Requirements 6.5, 8.3, 8.4**
+ *
+ * Property 10: Agent Configuration Schema Validation
+ * *For any* agent configuration object, the agent config validator SHALL return true
+ * if and only if all required fields are present with correct types and constraints.
+ */
+
+import { describe, test, expect } from 'vitest';
+import * as fc from 'fast-check';
+import { readFile } from 'node:fs/promises';
+import { parse } from 'yaml';
+import {
+  AgentConfig,
+  ModelProvider,
+  validateAgentConfig,
+  isAgentConfig,
+  parseAgentConfigYaml,
+} from './agent.schema.js';
+
+/** Valid model providers per schema definition */
+const VALID_MODEL_PROVIDERS: ModelProvider[] = ['claude', 'openai', 'ollama'];
+
+/** Custom arbitrary for valid AgentConfig objects */
+const validAgentConfigArb = fc.record({
+  id: fc.string({ minLength: 1 }).filter((s) => s.trim().length > 0),
+  name: fc.string({ minLength: 1 }).filter((s) => s.trim().length > 0),
+  prompt: fc.string({ minLength: 1 }).filter((s) => s.trim().length > 0),
+  strategyDescription: fc.string({ minLength: 1 }).filter((s) => s.trim().length > 0),
+  toolAccess: fc.array(fc.string()),
+  costCeiling: fc.integer({ min: 1, max: 1000000 }),
+  modelProvider: fc.constantFrom(...VALID_MODEL_PROVIDERS),
+  modelId: fc.string({ minLength: 1 }).filter((s) => s.trim().length > 0),
+});
+
+describe('Agent Configuration Schema Validation - Property Tests', () => {
+  // **Feature: earnd-bounty-engine, Property 10: Agent Configuration Schema Validation**
+  test('valid agent configurations pass validation', () => {
+    fc.assert(
+      fc.property(validAgentConfigArb, (config) => {
+        const result = validateAgentConfig(config);
+        expect(result.valid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 10: Agent Configuration Schema Validation**
+  test('configurations with empty id are invalid', () => {
+    fc.assert(
+      fc.property(
+        validAgentConfigArb.map((config) => ({ ...config, id: '' })),
+        (config) => {
+          const result = validateAgentConfig(config);
+          expect(result.valid).toBe(false);
+          expect(result.errors).toContain('Agent config "id" must not be empty');
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 10: Agent Configuration Schema Validation**
+  test('configurations with empty name are invalid', () => {
+    fc.assert(
+      fc.property(
+        validAgentConfigArb.map((config) => ({ ...config, name: '' })),
+        (config) => {
+          const result = validateAgentConfig(config);
+          expect(result.valid).toBe(false);
+          expect(result.errors).toContain('Agent config "name" must not be empty');
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 10: Agent Configuration Schema Validation**
+  test('configurations with empty prompt are invalid', () => {
+    fc.assert(
+      fc.property(
+        validAgentConfigArb.map((config) => ({ ...config, prompt: '' })),
+        (config) => {
+          const result = validateAgentConfig(config);
+          expect(result.valid).toBe(false);
+          expect(result.errors).toContain('Agent config "prompt" must not be empty');
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 10: Agent Configuration Schema Validation**
+  test('configurations with empty strategyDescription are invalid', () => {
+    fc.assert(
+      fc.property(
+        validAgentConfigArb.map((config) => ({ ...config, strategyDescription: '' })),
+        (config) => {
+          const result = validateAgentConfig(config);
+          expect(result.valid).toBe(false);
+          expect(result.errors).toContain('Agent config "strategyDescription" must not be empty');
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 10: Agent Configuration Schema Validation**
+  test('configurations with non-positive costCeiling are invalid', () => {
+    fc.assert(
+      fc.property(
+        fc.integer({ min: -1000, max: 0 }),
+        validAgentConfigArb,
+        (invalidCeiling, config) => {
+          const invalidConfig = { ...config, costCeiling: invalidCeiling };
+          const result = validateAgentConfig(invalidConfig);
+          expect(result.valid).toBe(false);
+          expect(result.errors).toContain('Agent config "costCeiling" must be positive');
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 10: Agent Configuration Schema Validation**
+  test('configurations with invalid modelProvider are invalid', () => {
+    const invalidProviders = ['gemini', 'gpt', 'llama', 'invalid', ''];
+    
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...invalidProviders),
+        validAgentConfigArb,
+        (invalidProvider, config) => {
+          const invalidConfig = { ...config, modelProvider: invalidProvider };
+          const result = validateAgentConfig(invalidConfig);
+          expect(result.valid).toBe(false);
+          expect(result.errors).toContain('Agent config "modelProvider" must be "claude", "openai", or "ollama"');
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 10: Agent Configuration Schema Validation**
+  test('configurations with empty modelId are invalid', () => {
+    fc.assert(
+      fc.property(
+        validAgentConfigArb.map((config) => ({ ...config, modelId: '' })),
+        (config) => {
+          const result = validateAgentConfig(config);
+          expect(result.valid).toBe(false);
+          expect(result.errors).toContain('Agent config "modelId" must not be empty');
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 10: Agent Configuration Schema Validation**
+  test('configurations with non-array toolAccess are invalid', () => {
+    const nonArrayValues = [null, undefined, 'string', 123, {}, true];
+    
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...nonArrayValues),
+        validAgentConfigArb,
+        (invalidToolAccess, config) => {
+          const invalidConfig = { ...config, toolAccess: invalidToolAccess };
+          const result = validateAgentConfig(invalidConfig);
+          expect(result.valid).toBe(false);
+          expect(result.errors).toContain('Agent config must have an array "toolAccess"');
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 10: Agent Configuration Schema Validation**
+  test('configurations with non-string tools in toolAccess are invalid', () => {
+    fc.assert(
+      fc.property(
+        fc.array(fc.oneof(fc.integer(), fc.boolean(), fc.object())),
+        validAgentConfigArb,
+        (invalidTools, config) => {
+          if (invalidTools.length === 0) return; // Skip empty arrays
+          
+          const invalidConfig = { ...config, toolAccess: invalidTools };
+          const result = validateAgentConfig(invalidConfig);
+          expect(result.valid).toBe(false);
+          expect(result.errors.some(error => error.includes('must be a string'))).toBe(true);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 10: Agent Configuration Schema Validation**
+  test('non-object values are invalid', () => {
+    const nonObjectValues = [null, undefined, 'string', 123, [], true, false];
+    
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...nonObjectValues),
+        (nonObject) => {
+          const result = validateAgentConfig(nonObject);
+          expect(result.valid).toBe(false);
+          expect(result.errors).toContain('Agent config must be an object');
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 10: Agent Configuration Schema Validation**
+  test('validation is deterministic - same input produces same output', () => {
+    fc.assert(
+      fc.property(validAgentConfigArb, (config) => {
+        const result1 = validateAgentConfig(config);
+        const result2 = validateAgentConfig(config);
+        expect(result1.valid).toBe(result2.valid);
+        expect(result1.errors).toEqual(result2.errors);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 10: Agent Configuration Schema Validation**
+  test('validation result structure is correct', () => {
+    fc.assert(
+      fc.property(fc.anything(), (input) => {
+        const result = validateAgentConfig(input);
+        // Result must have valid boolean and errors array
+        expect(typeof result.valid).toBe('boolean');
+        expect(Array.isArray(result.errors)).toBe(true);
+        // If valid, errors should be empty; if invalid, errors should have content
+        if (result.valid) {
+          expect(result.errors).toHaveLength(0);
+        } else {
+          expect(result.errors.length).toBeGreaterThan(0);
+        }
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 10: Agent Configuration Schema Validation**
+  test('isAgentConfig type guard matches validateAgentConfig', () => {
+    fc.assert(
+      fc.property(fc.anything(), (input) => {
+        const validationResult = validateAgentConfig(input);
+        const typeGuardResult = isAgentConfig(input);
+        expect(typeGuardResult).toBe(validationResult.valid);
+      }),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: earnd-bounty-engine, Property 10: Agent Configuration Schema Validation**
+  test('configurations with infinite or NaN costCeiling are invalid', () => {
+    // Test positive infinity and NaN (which should trigger finite number check)
+    fc.assert(
+      fc.property(
+        fc.constantFrom(Infinity, NaN),
+        validAgentConfigArb,
+        (invalidNumber, config) => {
+          const invalidConfig = { ...config, costCeiling: invalidNumber };
+          const result = validateAgentConfig(invalidConfig);
+          expect(result.valid).toBe(false);
+          expect(result.errors).toContain('Agent config "costCeiling" must be a finite number');
+        }
+      ),
+      { numRuns: 100 }
+    );
+
+    // Test negative infinity (which should trigger positive check first)
+    const negInfinityConfig = {
+      id: 'test',
+      name: 'test',
+      prompt: 'test',
+      strategyDescription: 'test',
+      toolAccess: [],
+      costCeiling: -Infinity,
+      modelProvider: 'claude' as const,
+      modelId: 'test'
+    };
+    const result = validateAgentConfig(negInfinityConfig);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain('Agent config "costCeiling" must be positive');
+  });
+
+  // **Feature: earnd-bounty-engine, Property 10: Agent Configuration Schema Validation**
+  test('configurations with whitespace-only strings are invalid', () => {
+    const whitespaceStrings = ['   ', '\t\t', '\n\n', '  \t\n  '];
+    
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...whitespaceStrings),
+        validAgentConfigArb,
+        (whitespace, config) => {
+          // Test each string field with whitespace
+          const fields = ['id', 'name', 'prompt', 'strategyDescription', 'modelId'];
+          
+          fields.forEach(field => {
+            const invalidConfig = { ...config, [field]: whitespace };
+            const result = validateAgentConfig(invalidConfig);
+            expect(result.valid).toBe(false);
+            expect(result.errors.some(error => error.includes(`"${field}" must not be empty`))).toBe(true);
+          });
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+});
+
+describe('Tournament Agent Configuration Files - Property Tests', () => {
+  const tournamentAgentFiles = [
+    'src/agents/configs/tournament-coderabbit.yaml',
+    'src/agents/configs/tournament-claude-sonnet.yaml',
+    'src/agents/configs/tournament-gpt4o.yaml',
+    'src/agents/configs/tournament-llama3.yaml',
+  ];
+
+  // **Feature: earnd-bounty-engine, Property 10: Agent Configuration Schema Validation**
+  test('all tournament agent configurations are valid', async () => {
+    for (const filePath of tournamentAgentFiles) {
+      const yamlContent = await readFile(filePath, 'utf-8');
+      const config = parse(yamlContent);
+      
+      const result = validateAgentConfig(config);
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+      
+      // Verify it's a proper AgentConfig
+      expect(isAgentConfig(config)).toBe(true);
+    }
+  });
+
+  // **Feature: earnd-bounty-engine, Property 10: Agent Configuration Schema Validation**
+  test('tournament agents have required tournament-specific properties', async () => {
+    for (const filePath of tournamentAgentFiles) {
+      const yamlContent = await readFile(filePath, 'utf-8');
+      const config = parse(yamlContent) as AgentConfig;
+      
+      // Tournament agents should have specific naming pattern
+      expect(config.id).toMatch(/^tournament-/);
+      
+      // Should have reasonable cost ceilings
+      expect(config.costCeiling).toBeGreaterThan(0);
+      expect(config.costCeiling).toBeLessThanOrEqual(15000);
+      
+      // Should have valid model providers
+      expect(VALID_MODEL_PROVIDERS).toContain(config.modelProvider);
+      
+      // Should have non-empty strategy descriptions
+      expect(config.strategyDescription.trim().length).toBeGreaterThan(0);
+      
+      // Should have tool access arrays
+      expect(Array.isArray(config.toolAccess)).toBe(true);
+    }
+  });
+
+  // **Feature: earnd-bounty-engine, Property 10: Agent Configuration Schema Validation**
+  test('parseAgentConfigYaml works correctly for tournament configs', async () => {
+    for (const filePath of tournamentAgentFiles) {
+      const yamlContent = await readFile(filePath, 'utf-8');
+      const { config, validation } = await parseAgentConfigYaml(yamlContent);
+      
+      expect(validation.valid).toBe(true);
+      expect(validation.errors).toHaveLength(0);
+      expect(config).not.toBeNull();
+      expect(isAgentConfig(config)).toBe(true);
+    }
+  });
+});

package/src/agents/agent.schema.test.ts

@@ -0,0 +1,148 @@
+/**
+ * Agent Schema Tests
+ *
+ * Unit tests for agent configuration validation.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { readFile } from 'node:fs/promises';
+import { parse } from 'yaml';
+import {
+  AgentConfig,
+  validateAgentConfig,
+  isAgentConfig,
+} from './agent.schema.js';
+
+describe('validateAgentConfig', () => {
+  it('accepts a valid agent config', () => {
+    const config: AgentConfig = {
+      id: 'test-agent-001',
+      name: 'Test Agent',
+      prompt: 'You are a test agent.',
+      strategyDescription: 'Test strategy',
+      toolAccess: ['tool1', 'tool2'],
+      costCeiling: 10000,
+      modelProvider: 'claude',
+      modelId: 'claude-3-sonnet-20240229',
+    };
+
+    const result = validateAgentConfig(config);
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it('rejects non-object values', () => {
+    expect(validateAgentConfig(null).valid).toBe(false);
+    expect(validateAgentConfig(undefined).valid).toBe(false);
+    expect(validateAgentConfig('string').valid).toBe(false);
+    expect(validateAgentConfig(123).valid).toBe(false);
+  });
+
+  it('rejects empty id', () => {
+    const config = {
+      id: '',
+      name: 'Test',
+      prompt: 'Test',
+      strategyDescription: 'Test',
+      toolAccess: [],
+      costCeiling: 100,
+      modelProvider: 'claude',
+      modelId: 'test',
+    };
+
+    const result = validateAgentConfig(config);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain('Agent config "id" must not be empty');
+  });
+
+  it('rejects invalid modelProvider', () => {
+    const config = {
+      id: 'test',
+      name: 'Test',
+      prompt: 'Test',
+      strategyDescription: 'Test',
+      toolAccess: [],
+      costCeiling: 100,
+      modelProvider: 'invalid',
+      modelId: 'test',
+    };
+
+    const result = validateAgentConfig(config);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain(
+      'Agent config "modelProvider" must be "claude", "openai", or "ollama"'
+    );
+  });
+
+  it('rejects negative costCeiling', () => {
+    const config = {
+      id: 'test',
+      name: 'Test',
+      prompt: 'Test',
+      strategyDescription: 'Test',
+      toolAccess: [],
+      costCeiling: -100,
+      modelProvider: 'claude',
+      modelId: 'test',
+    };
+
+    const result = validateAgentConfig(config);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain(
+      'Agent config "costCeiling" must be positive'
+    );
+  });
+});
+
+describe('isAgentConfig', () => {
+  it('returns true for valid config', () => {
+    const config: AgentConfig = {
+      id: 'test-agent-001',
+      name: 'Test Agent',
+      prompt: 'You are a test agent.',
+      strategyDescription: 'Test strategy',
+      toolAccess: [],
+      costCeiling: 10000,
+      modelProvider: 'openai',
+      modelId: 'gpt-4-turbo-preview',
+    };
+
+    expect(isAgentConfig(config)).toBe(true);
+  });
+
+  it('returns false for invalid config', () => {
+    expect(isAgentConfig(null)).toBe(false);
+    expect(isAgentConfig({})).toBe(false);
+  });
+});
+
+describe('sales_agent.yaml', () => {
+  it('is a valid agent configuration', async () => {
+    const yamlContent = await readFile(
+      './src/agents/sales_agent.yaml',
+      'utf-8'
+    );
+    const config = parse(yamlContent);
+
+    const result = validateAgentConfig(config);
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it('has all required fields', async () => {
+    const yamlContent = await readFile(
+      './src/agents/sales_agent.yaml',
+      'utf-8'
+    );
+    const config = parse(yamlContent) as AgentConfig;
+
+    expect(config.id).toBe('sales-agent-001');
+    expect(config.name).toBe('Sales Qualifier Agent');
+    expect(config.prompt).toContain('sales qualification');
+    expect(config.strategyDescription).toContain('consultative');
+    expect(config.toolAccess).toContain('email_lookup');
+    expect(config.costCeiling).toBe(10000);
+    expect(config.modelProvider).toBe('claude');
+    expect(config.modelId).toBe('claude-3-sonnet-20240229');
+  });
+});