/**
 * Ergonomic agent factory for creating agents with role and task awareness
 */
import { OpenAIAgent } from "../web/openai-agent";
import { AnthropicAgent } from "../web/anthropic-agent";
import { GoogleAgent } from "../web/google-agent";
import { PolarisEngineTask, AgentRole } from "../../types/task";
import { Agent } from "../base/agent";
/**
 * Configuration for creating agents with ergonomic factory functions
 */
export interface AgentFactoryConfig {
    /** Role for the agent */
    role: AgentRole;
    /** Task context */
    task: PolarisEngineTask;
    /** Model to use */
    model: string;
    /** API key (optional, can use environment) */
    apiKey?: string;
    /** Agent name (optional, defaults based on role and model) */
    name?: string;
    /** Maximum tokens */
    maxTokens?: number;
    /** Temperature for randomness */
    temperature?: number;
    /** Custom system prompt */
    systemPrompt?: string;
    /** Additional configuration */
    additionalConfig?: Record<string, any>;
}
/**
 * Create an OpenAI agent with ergonomic configuration
 */
export declare function openAiAgent(config: AgentFactoryConfig): OpenAIAgent;
/**
 * Create an Anthropic agent with ergonomic configuration
 */
export declare function anthropicAgent(config: AgentFactoryConfig): AnthropicAgent;
/**
 * Create a Google agent with ergonomic configuration
 */
export declare function googleAgent(config: AgentFactoryConfig): GoogleAgent;
/**
 * Agent type enumeration for factory selection
 */
export declare enum AgentProvider {
    OPENAI = "openai",
    ANTHROPIC = "anthropic",
    GOOGLE = "google"
}
/**
 * Create an agent using the specified provider
 */
export declare function createAgent(provider: AgentProvider, config: AgentFactoryConfig): Agent;
/**
 * Bulk agent creation utility
 */
export interface BulkAgentConfig {
    task: PolarisEngineTask;
    agents: Array<{
        provider: AgentProvider;
        role: AgentRole;
        model: string;
        name?: string;
        apiKey?: string;
        maxTokens?: number;
        temperature?: number;
        systemPrompt?: string;
        additionalConfig?: Record<string, any>;
    }>;
}
/**
 * Create multiple agents from bulk configuration
 */
export declare function createAgents(config: BulkAgentConfig): Agent[];
/**
 * Quick agent creation helpers with common model configurations
 */
export declare const QuickAgents: {
    /**
     * Create GPT-4o agent
     */
    gpt4o: (role: AgentRole, task: PolarisEngineTask, apiKey?: string) => OpenAIAgent;
    /**
     * Create GPT-4o-mini agent
     */
    gpt4oMini: (role: AgentRole, task: PolarisEngineTask, apiKey?: string) => OpenAIAgent;
    /**
     * Create Claude Sonnet agent
     */
    claudeSonnet: (role: AgentRole, task: PolarisEngineTask, apiKey?: string) => AnthropicAgent;
    /**
     * Create Claude Haiku agent
     */
    claudeHaiku: (role: AgentRole, task: PolarisEngineTask, apiKey?: string) => AnthropicAgent;
    /**
     * Create Gemini Pro agent
     */
    geminiPro: (role: AgentRole, task: PolarisEngineTask, apiKey?: string) => GoogleAgent;
    /**
     * Create Gemini Flash agent
     */
    geminiFlash: (role: AgentRole, task: PolarisEngineTask, apiKey?: string) => GoogleAgent;
};
/**
 * Agent ensemble builder for creating diverse agent teams
 */
export declare class AgentEnsembleBuilder {
    private agents;
    private task;
    constructor(task: PolarisEngineTask);
    /**
     * Add an agent using the factory
     */
    add(provider: AgentProvider, role: AgentRole, model: string, config?: Partial<AgentFactoryConfig>): this;
    /**
     * Add multiple agents for different roles using the same model/provider
     */
    addRoles(provider: AgentProvider, model: string, roles: AgentRole[], config?: Partial<AgentFactoryConfig>): this;
    /**
     * Add a diverse team with different providers for the same role
     */
    addDiverseRole(role: AgentRole, configs: Array<{
        provider: AgentProvider;
        model: string;
        config?: Partial<AgentFactoryConfig>;
    }>): this;
    /**
     * Build and return the agent ensemble
     */
    build(): Agent[];
    /**
     * Get current agent count
     */
    count(): number;
    /**
     * Clear all agents
     */
    clear(): this;
}
/**
 * Create agent ensemble builder
 */
export declare function createEnsemble(task: PolarisEngineTask): AgentEnsembleBuilder;
//# sourceMappingURL=agent-factory.d.ts.map