AI Providers

async fn call_gemini(prompt: &str, api_key: &str) -> Result<AgentsManifest> {
    let response = CLIENT
        .post(format!("{}?key={}", GEMINI_URL, api_key))
        .json(&json!({
            "contents": [{ "parts": [{ "text": prompt }] }],
            "generationConfig": {
                "temperature": 0.2,  // Low temp for consistency
                "responseMimeType": "application/json"  // Enforced JSON
            }
        }))
        .send()
        .await?;
    
    let raw: Value = response.json().await?;
    let text = raw["candidates"][0]["content"]["parts"][0]["text"]
        .as_str()
        .context("Unexpected Gemini response shape")?;
    
    parse_manifest(text)
}

async fn call_claude(prompt: &str, api_key: &str) -> Result<AgentsManifest> {
    let response = CLIENT
        .post(CLAUDE_URL)
        .header("x-api-key", api_key)
        .header("anthropic-version", "2023-06-01")
        .json(&json!({
            "model": "claude-sonnet-4-5",
            "max_tokens": 4096,
            "messages": [{
                "role": "user",
                "content": prompt
            }]
        }))
        .send()
        .await?;
    
    let raw: Value = response.json().await?;
    let text = raw["content"][0]["text"]
        .as_str()
        .context("Unexpected Claude response shape")?;
    
    parse_manifest(text)
}

async fn call_openai(prompt: &str, api_key: &str) -> Result<AgentsManifest> {
    let response = CLIENT
        .post(OPENAI_URL)
        .bearer_auth(api_key)
        .json(&json!({
            "model": "gpt-4o",
            "temperature": 0.2,
            "response_format": { "type": "json_object" },  // Structured output
            "messages": [
                {
                    "role": "system",
                    "content": "You are an expert at analyzing software repositories. Always respond with valid JSON only."
                },
                {
                    "role": "user",
                    "content": prompt
                }
            ]
        }))
        .send()
        .await?;
    
    let raw: Value = response.json().await?;
    let text = raw["choices"][0]["message"]["content"]
        .as_str()
        .context("Unexpected OpenAI response shape")?;
    
    parse_manifest(text)
}

async fn call_beacon_cloud(ctx: &RepoContext, _prompt: &str) -> Result<AgentsManifest> {
    let initial_res = CLIENT
        .post(&generate_url)
        .json(&ctx)
        .send()
        .await?;
    
    // Server returns 402 Payment Required
    if initial_res.status() == reqwest::StatusCode::PAYMENT_REQUIRED {
        let headers = initial_res.headers();
        let amount = headers.get("x-payment-amount")...;  // "0.09"
        let run_id = headers.get("x-payment-run-id")...;
        let base_addr = headers.get("x-payment-address-base")...;
        let sol_addr = headers.get("x-payment-address-solana")...;
        
        // User sends USDC to provided address
        // User provides transaction hash
        
        let final_res = CLIENT
            .post(&generate_url)
            .header("x-payment-run-id", run_id)
            .header("x-payment-chain", chain)
            .header("x-payment-txn-hash", txn_hash)
            .json(&ctx)
            .send()
            .await?;
        
        // Server verifies payment on-chain and returns result
    }
}

# Initial generation with Gemini
beacon generate ./my-project --output AGENTS.md

# Regenerate with Claude for comparison
beacon generate ./my-project --provider claude --output AGENTS-claude.md

# Compare the results
diff AGENTS.md AGENTS-claude.md

export BEACON_CLOUD_URL=https://my-beacon-instance.com
beacon generate ./my-project --provider beacon-ai-cloud