openagentic/dist/index.d.ts

A TypeScript framework for building AI agents with self-contained tool orchestration capabilities

import { A as AIModel, L as LogLevel, O as OrchestratorOptions, E as ExecutionResult, C as CoreMessage, a as OpenAgenticTool, B as BaseOrchestrator, M as Message, b as ApiKeyMap, c as OrchestratorType, P as PromptBasedOrchestrator, d as OrchestratorContext, e as CustomLogicOrchestrator } from './index-Bbhf6zbC.js';
export { W as AIModelSchema, a0 as ExecutionResultSchema, Z as ExecutionStats, Y as LoggingConfig, X as MessageSchema, _ as StepInfo, T as ToolDescription, $ as ToolDetails, g as aiTools, i as allToolDescriptions, h as allTools, p as anthropicTool, q as cohereTool, f as convertLangchainTool, H as elevenlabsTool, n as geminiImageTool, r as geminiTool, J as geminiTtsTool, j as getToolDescription, k as getToolDescriptionsByCategory, v as githubTool, w as grokTool, S as groqTool, N as htmlComposerTool, K as inceptionLabsTool, x as llamaTool, U as lumaImageTool, y as mistralTool, z as newsdataTool, l as openaiImageTool, o as openaiTool, m as openaiVectorStoreTool, D as perplexityTool, F as qrcodeTool, s as searchToolDescriptions, R as slackPosterTool, V as toOpenAgenticTool, t as toolDescriptionsByCategory, Q as unsplashTool, u as utilityTools, I as videoGenerationTool, G as websearchTool } from './index-Bbhf6zbC.js';
import { streamText } from 'ai';
import 'zod';

declare class Orchestrator {
    private model;
    private tools;
    private messages;
    private iterations;
    private maxIterations;
    private customLogic?;
    private orchestrator?;
    private orchestratorOptions;
    private loggingConfig;
    private executionStartTime;
    private stepTimings;
    private toolCallTimings;
    private stepsExecuted;
    private toolCallsExecuted;
    constructor(options: {
        model: string | AIModel;
        tools?: any[];
        systemPrompt?: string;
        maxIterations?: number;
        customLogic?: (input: string, context: any) => Promise<any>;
        enableDebugLogging?: boolean;
        logLevel?: LogLevel;
        enableStepLogging?: boolean;
        enableToolLogging?: boolean;
        enableTimingLogging?: boolean;
        enableStatisticsLogging?: boolean;
    } & OrchestratorOptions);
    execute(input: string): Promise<ExecutionResult>;
    execute(messages: CoreMessage[]): Promise<ExecutionResult>;
    private executeWithOrchestrator;
    private executeWithCustomLogicOrchestrator;
    private executeWithPromptBasedOrchestrator;
    private executeWithString;
    private executeWithMessages;
    addTool(tool: OpenAgenticTool): void;
    removeTool(toolName: string): void;
    getTool(toolName: string): any;
    getAllTools(): OpenAgenticTool[];
    switchModel(model: string | AIModel): void;
    getModelInfo(): any;
    getOrchestrator(): BaseOrchestrator | undefined;
    setOrchestrator(orchestrator: string | BaseOrchestrator | undefined): void;
    hasOrchestrator(): boolean;
    getMessages(): Message[];
    addMessage(message: Message): void;
    reset(): void;
    clear(): void;
    private createStepFinishCallback;
    private convertCoresToAISDK;
    private convertCoreToInternal;
    private convertToAISDKTools;
    private log;
    private sanitizeForLogging;
    private resetExecutionStats;
    private calculateExecutionStats;
    private executeWithCustomLogic;
}

declare class StreamingOrchestrator {
    private model;
    private tools;
    private messages;
    private maxIterations;
    private customLogic?;
    private orchestrator?;
    private orchestratorOptions;
    private loggingConfig;
    private executionStartTime;
    private stepTimings;
    private toolCallTimings;
    private stepsExecuted;
    private toolCallsExecuted;
    private chunksProcessed;
    private totalTextLength;
    private onFinishCallback?;
    constructor(options: {
        model: string | AIModel;
        tools?: any[];
        systemPrompt?: string;
        maxIterations?: number;
        customLogic?: (input: string, context: any) => Promise<any>;
        enableDebugLogging?: boolean;
        logLevel?: LogLevel;
        enableStepLogging?: boolean;
        enableToolLogging?: boolean;
        enableTimingLogging?: boolean;
        enableStatisticsLogging?: boolean;
        enableStreamingLogging?: boolean;
        onFinish?: (result: any) => void | Promise<void>;
    } & OrchestratorOptions);
    stream(input: string): Promise<ReturnType<typeof streamText>>;
    stream(messages: CoreMessage[]): Promise<ReturnType<typeof streamText>>;
    private streamWithCustomLogic;
    private streamWithOrchestrator;
    private streamWithCustomLogicOrchestrator;
    private streamWithPromptBasedOrchestrator;
    private streamWithString;
    private streamWithMessages;
    addTool(tool: OpenAgenticTool): void;
    removeTool(toolName: string): void;
    getTool(toolName: string): OpenAgenticTool | undefined;
    getAllTools(): OpenAgenticTool[];
    switchModel(model: string | AIModel): void;
    getModelInfo(): any;
    getOrchestrator(): BaseOrchestrator | undefined;
    setOrchestrator(orchestrator: string | BaseOrchestrator | undefined): void;
    hasOrchestrator(): boolean;
    getMessages(): Message[];
    addMessage(message: Message): void;
    reset(): void;
    clear(): void;
    private createStepFinishCallback;
    private createChunkCallback;
    private createErrorCallback;
    private convertCoresToAISDK;
    private convertCoreToInternal;
    private convertToAISDKTools;
    private transformMessages;
    private log;
    private sanitizeForLogging;
    private resetExecutionStats;
    private calculateExecutionStats;
}

declare class ProviderManager {
    private static userApiKeys;
    /**
     * Set user-provided API keys that take precedence over environment variables
     */
    static setUserApiKeys(apiKeys: ApiKeyMap | undefined): void;
    /**
     * Get AWS credentials from user API keys or environment variables
     */
    static getAwsCredentials(): {
        accessKeyId?: string;
        secretAccessKey?: string;
        region?: string;
        bucketName?: string;
    };
    /**
     * Get AWS Bedrock credentials from user API keys or environment variables
     */
    static getBedrockCredentials(): {
        accessKeyId?: string;
        secretAccessKey?: string;
        region?: string;
    };
    /**
     * Create a model configuration from a string or AIModel object
     * Automatically detects provider from model name if string is provided
     */
    static createModel(input: string | AIModel): AIModel;
    /**
     * Create an AI SDK provider instance for the given model
     */
    static createProvider(model: AIModel): Promise<any>;
    /**
     * Create a provider for a specific provider name (for tool context)
     */
    static createProviderByName(providerName: string, apiKey?: string): Promise<any>;
    /**
     * Get all available providers and their models
     */
    static getAllProviders(): Array<{
        provider: string;
        models: string[];
    }>;
    /**
     * Get supported models for a provider
     */
    static getProviderModels(provider: string): string[];
    /**
     * Check if a model is supported by a provider
     */
    static isModelSupported(provider: string, model: string): boolean;
    /**
     * Get model information (context window, cost, description)
     */
    static getModelInfo(provider: string, model: string): never;
    private static autoDetectProvider;
    private static validateAndNormalizeModel;
    private static getDefaultApiKey;
}

/**
 * Register an orchestrator in the global registry
 * @param orchestrator - The orchestrator to register
 * @throws {Error} If an orchestrator with the same ID already exists
 */
declare function registerOrchestrator(orchestrator: BaseOrchestrator): void;
/**
 * Get an orchestrator by ID
 * @param id - The orchestrator ID
 * @returns The orchestrator instance or undefined if not found
 */
declare function getOrchestrator(id: string): BaseOrchestrator | undefined;
/**
 * List all registered orchestrators
 * @returns Array of all registered orchestrators
 */
declare function listOrchestrators(): BaseOrchestrator[];
/**
 * Get orchestrators by type
 * @param type - The orchestrator type to filter by
 * @returns Array of orchestrators matching the type
 */
declare function getOrchestratorsByType(type: OrchestratorType): BaseOrchestrator[];
/**
 * Check if an orchestrator is registered
 * @param id - The orchestrator ID
 * @returns True if the orchestrator is registered
 */
declare function hasOrchestrator(id: string): boolean;
/**
 * Unregister an orchestrator
 * @param id - The orchestrator ID to remove
 * @returns True if the orchestrator was removed, false if it didn't exist
 */
declare function unregisterOrchestrator(id: string): boolean;
/**
 * Clear all registered orchestrators
 */
declare function clearOrchestratorRegistry(): void;
/**
 * Get registry statistics
 * @returns Object with registry statistics
 */
declare function getRegistryStats(): {
    total: number;
    byType: Record<OrchestratorType, number>;
    orchestratorIds: string[];
};
/**
 * Resolve orchestrator from string ID or instance
 * @param orchestratorInput - String ID or orchestrator instance
 * @returns The orchestrator instance or undefined if not found
 */
declare function resolveOrchestrator(orchestratorInput: string | BaseOrchestrator | undefined): BaseOrchestrator | undefined;

/**
 * Base class for prompt-based orchestrators
 * Overrides system prompts and filters tools to create specialized agents
 */
declare class PromptBasedOrchestratorClass implements PromptBasedOrchestrator {
    readonly id: string;
    readonly name: string;
    readonly description: string;
    readonly systemPrompt: string;
    readonly allowedTools: string[];
    readonly type: "prompt-based";
    constructor(id: string, name: string, description: string, systemPrompt: string, allowedTools?: string[]);
    getName(): string;
    getDescription(): string;
    getType(): 'prompt-based';
    getSystemPrompt(): string;
    /**
     * Override system prompt based on context (can be customized by subclasses)
     */
    buildSystemPrompt(context: OrchestratorContext): string;
    /**
     * Filter tools based on allowed tools list
     */
    private filterTools;
    /**
     * Validate input before execution
     */
    validate(input: string | CoreMessage[], context: OrchestratorContext): Promise<boolean>;
    /**
     * Optional initialization
     */
    initialize(context: OrchestratorContext): Promise<void>;
    /**
     * Optional cleanup
     */
    cleanup(context: OrchestratorContext): Promise<void>;
    /**
     * Execute the orchestration by creating a specialized orchestrator instance
     */
    execute(input: string | CoreMessage[], context: OrchestratorContext): Promise<ExecutionResult>;
}
/**
 * Helper function to create prompt-based orchestrators
 */
declare function createPromptBasedOrchestrator(id: string, name: string, description: string, systemPrompt: string, allowedTools?: string[]): PromptBasedOrchestratorClass;

/**
 * Abstract base class for custom logic orchestrators
 * Provides common functionality and helper methods for implementing custom orchestration logic
 */
declare abstract class CustomLogicOrchestratorClass implements CustomLogicOrchestrator {
    readonly id: string;
    readonly name: string;
    readonly description: string;
    readonly type: "custom-logic";
    constructor(id: string, name: string, description: string);
    getName(): string;
    getDescription(): string;
    getType(): 'custom-logic';
    /**
     * Abstract method that subclasses must implement
     * This is where the custom orchestration logic goes
     */
    abstract customLogic(input: string | CoreMessage[], context: OrchestratorContext): Promise<any>;
    /**
     * Main execute method that calls customLogic and formats the result
     * Can be overridden by subclasses for more control
     */
    execute(input: string | CoreMessage[], context: OrchestratorContext): Promise<ExecutionResult>;
    /**
     * Optional validation method
     */
    validate(input: string | CoreMessage[], context: OrchestratorContext): Promise<boolean>;
    /**
     * Optional initialization method
     */
    initialize(context: OrchestratorContext): Promise<void>;
    /**
     * Optional cleanup method
     */
    cleanup(context: OrchestratorContext): Promise<void>;
    /**
     * Optional method to determine if custom logic should be used
     * Default implementation always returns true
     */
    shouldUseCustomLogic(input: string | CoreMessage[], context: OrchestratorContext): boolean;
    /**
     * Helper to get available tools filtered by ID
     */
    protected getToolsByIds(context: OrchestratorContext, toolIds: string[]): OpenAgenticTool[];
    /**
     * Helper to execute a single tool
     */
    protected executeTool(tool: OpenAgenticTool, parameters: any, context?: any): Promise<any>;
    /**
     * Helper to execute multiple tools in parallel
     */
    protected executeToolsInParallel(toolExecutions: Array<{
        tool: OpenAgenticTool;
        parameters: any;
        context?: any;
    }>): Promise<any[]>;
    /**
     * Helper to execute tools sequentially
     */
    protected executeToolsInSequence(toolExecutions: Array<{
        tool: OpenAgenticTool;
        parameters: any;
        context?: any;
    }>): Promise<any[]>;
    /**
     * Helper to call AI models directly (bypassing the orchestrator)
     */
    protected callAIModel(prompt: string, modelOverride?: string, context?: OrchestratorContext): Promise<string>;
    /**
     * Helper to consolidate multiple results into a single response
     */
    protected consolidateResults(results: any[], consolidationPrompt?: string): string;
    /**
     * Helper to get API keys for external services
     */
    protected getApiKey(provider: string): string | undefined;
    /**
     * Helper to create structured output
     */
    protected createStructuredOutput(data: any): string;
    /**
     * Helper to sanitize data for logging
     */
    private sanitizeForLogging;
}
/**
 * Helper function to create custom logic orchestrators
 */
declare function createCustomLogicOrchestrator(id: string, name: string, description: string, customLogicImplementation: (input: string | CoreMessage[], context: OrchestratorContext) => Promise<any>): CustomLogicOrchestratorClass;

/**
 * Result from parallel AI execution
 */
interface ParallelAIResult {
    modelId: string;
    provider: string;
    success: boolean;
    result?: string;
    error?: string;
    duration: number;
    usage?: {
        promptTokens: number;
        completionTokens: number;
        totalTokens: number;
    };
}
/**
 * Result from tool chain execution
 */
interface ToolChainResult {
    step: number;
    toolId: string;
    success: boolean;
    result?: any;
    error?: string;
    duration: number;
}
/**
 * Analysis aggregation result
 */
interface AnalysisAggregation {
    primaryAnalysis: string;
    supportingAnalyses: string[];
    synthesis: string;
    confidence: number;
    sources: string[];
}
/**
 * Advanced helper class for multi-AI orchestrators
 * Provides sophisticated patterns for complex AI workflows
 */
declare abstract class MultiAIOrchestrator extends CustomLogicOrchestratorClass {
    constructor(id: string, name: string, description: string);
    /**
     * Execute multiple AI models in parallel with the same prompt
     * @param prompt - The prompt to send to all models
     * @param models - Array of model identifiers or configurations
     * @param options - Execution options
     * @returns Array of results from all models
     */
    protected runInParallel(prompt: string, models: (string | AIModel)[], options?: {
        temperature?: number;
        maxTokens?: number;
        timeoutMs?: number;
        failFast?: boolean;
        retryCount?: number;
    }): Promise<ParallelAIResult[]>;
    /**
     * Consolidate results from parallel AI execution
     * @param results - Array of ParallelAIResult
     * @param strategy - Consolidation strategy
     * @returns Consolidated result
     */
    protected consolidateResults(results: ParallelAIResult[], strategy?: 'best' | 'consensus' | 'weighted' | 'all'): string;
    /**
     * Create a model instance with specific configuration
     * @param modelConfig - Model identifier or full configuration
     * @param overrides - Parameter overrides
     * @returns Configured AIModel
     */
    protected createModelInstance(modelConfig: string | AIModel, overrides?: {
        temperature?: number;
        maxTokens?: number;
        topP?: number;
    }): AIModel;
    /**
     * Execute a prompt with a specific model
     * @param prompt - The prompt to execute
     * @param model - Model configuration
     * @param options - Execution options
     * @returns Generation result
     */
    protected executeWithModel(prompt: string, model: AIModel, options?: {
        temperature?: number;
        maxTokens?: number;
        topP?: number;
    }): Promise<{
        text: string;
        usage?: {
            promptTokens: number;
            completionTokens: number;
            totalTokens: number;
        };
        finishReason?: string;
    }>;
    /**
     * Merge multiple analyses into a comprehensive report
     * @param analyses - Array of analysis results
     * @param prompt - Optional merging prompt
     * @returns Merged analysis
     */
    protected mergeAnalysis(analyses: Array<{
        source: string;
        content: string;
        confidence?: number;
        metadata?: any;
    }>, prompt?: string): Promise<AnalysisAggregation>;
    /**
     * Synthesize findings from multiple sources
     * @param findings - Array of findings with metadata
     * @param options - Synthesis options
     * @returns Synthesized findings
     */
    protected synthesizeFindings(findings: Array<{
        title: string;
        content: string;
        source: string;
        importance?: number;
        tags?: string[];
    }>, options?: {
        maxLength?: number;
        focusAreas?: string[];
        style?: 'technical' | 'executive' | 'detailed';
    }): Promise<string>;
    /**
     * Execute a chain of tools sequentially, passing results between them
     * @param toolChain - Array of tool configurations
     * @param context - Orchestrator context
     * @returns Array of tool chain results
     */
    protected executeToolChain(toolChain: Array<{
        tool: OpenAgenticTool;
        parameters: any | ((previousResults: ToolChainResult[]) => any);
        onSuccess?: (result: any, step: number) => void;
        onError?: (error: Error, step: number) => boolean;
    }>, context: OrchestratorContext): Promise<ToolChainResult[]>;
    /**
     * Upload result to S3 as HTML report
     * @param content - Content to upload
     * @param filename - Filename (without extension)
     * @param metadata - Additional metadata
     * @returns S3 URL
     */
    protected uploadResult(content: string, filename: string, metadata?: {
        title?: string;
        description?: string;
        author?: string;
        tags?: string[];
    }): Promise<string>;
    /**
     * Format content as a professional HTML report
     * @param content - Report content (supports Markdown)
     * @param options - Formatting options
     * @returns Formatted HTML
     */
    protected formatReport(content: string, options?: {
        title?: string;
        description?: string;
        author?: string;
        tags?: string[];
        style?: 'professional' | 'minimal' | 'detailed';
    }): string;
    /**
     * Handle partial failures in multi-AI operations
     * @param results - Array of results with success/failure status
     * @param options - Recovery options
     * @returns Recovery strategy result
     */
    protected handlePartialFailures<T extends {
        success: boolean;
        error?: string;
    }>(results: T[], options?: {
        minimumSuccessRate?: number;
        fallbackStrategy?: 'continue' | 'retry' | 'abort';
        maxRetries?: number;
    }): {
        shouldContinue: boolean;
        successfulResults: T[];
        failedResults: T[];
        recommendation: string;
    };
    /**
     * Sanitize sensitive data for logging
     * @param data - Data to sanitize
     * @returns Sanitized data
     */
    private sanitizeDataForLogging;
}

/**
 * Video Creator Orchestrator
 * Specialized orchestrator for creating professional videos using a 4-stage workflow
 */
declare const videoCreatorOrchestrator: PromptBasedOrchestratorClass;

/**
 * Code Assessment Orchestrator
 *
 * Implements a sophisticated workflow for comprehensive code analysis:
 * 1. Fetch code from GitHub repository
 * 2. Parallel analysis with Claude (code quality) and Gemini (technical depth)
 * 3. GPT-4o synthesizes findings into executive summary
 * 4. Generate comprehensive markdown report
 * 5. Upload to S3 as professional HTML report
 * 6. Generate PR diff and upload to S3 as text file (if requested)
 */
declare class CodeAssessmentOrchestrator extends MultiAIOrchestrator {
    constructor();
    /**
     * Custom logic implementation for code assessment
     */
    customLogic(input: string | CoreMessage[], context: OrchestratorContext): Promise<any>;
    /**
     * Parse repository information and additional directory paths from input and orchestratorParams
     */
    private parseRepositoryInfo;
    /**
     * Fetch repository code using GitHub tool
     */
    private fetchRepositoryCode;
    /**
     * Explore specific repository directories for source code
     */
    private exploreRepositoryStructure;
    /**
     * Perform specialized parallel analysis with Claude and Gemini
     */
    private performParallelAnalysis;
    /**
     * Prepare code context for analysis with less aggressive truncation
     */
    private prepareCodeContext;
    /**
     * Synthesize findings using GPT-4o
     */
    private synthesizeAnalysisFindings;
    /**
     * Parse GPT-4o synthesis response into structured sections
     */
    private parseSynthesisResponse;
    /**
     * Create fallback synthesis if GPT-4o fails
     */
    private createFallbackSynthesis;
    /**
     * Generate final comprehensive report
     */
    private generateFinalReport;
    /**
     * Generate PR diff with suggested improvements using Anthropic with increased token limits
     */
    private generatePRDiff;
    /**
     * Upload diff content to S3 as a text file
     */
    private uploadDiffToS3;
    /**
     * Prepare enhanced code context for diff generation with more comprehensive content
     */
    private prepareEnhancedCodeContextForDiff;
}
declare const codeAssessmentOrchestrator: CodeAssessmentOrchestrator;

/**
 * Enhanced Image Generation Orchestrator
 * Specialized orchestrator that enhances image prompts using GPT-4o before generating images
 */
declare const enhancedImageGenerationOrchestrator: PromptBasedOrchestratorClass;

/**
 * News Specialist Orchestrator
 *
 * Uses an OpenAI agent with news analysis tools to gather information intelligently,
 * then generates professional HTML reports with visual content.
 *
 * Workflow:
 * 1. OpenAI agent uses news tools (perplexity, newsdata, websearch) intelligently
 * 2. AI-powered analysis and insight generation with visual content
 * 3. Professional HTML report generation for web publication
 */
declare class NewsSpecialistOrchestrator extends MultiAIOrchestrator {
    constructor();
    /**
     * Custom logic implementation using OpenAI agent for news analysis
     */
    customLogic(input: string | CoreMessage[], context: OrchestratorContext): Promise<any>;
    /**
     * Create OpenAI agent with news analysis tools
     */
    private createNewsAnalysisAgent;
    /**
     * Run news analysis using OpenAI agent
     */
    private runNewsAnalysisAgent;
    /**
     * Parse analysis parameters from user input
     */
    private parseAnalysisParameters;
    /**
     * Generate visual content for the news article
     */
    private generateVisualContent;
    /**
     * Create image prompts based on analysis content
     */
    private createImagePrompts;
    /**
     * Extract keywords for image generation
     */
    private extractKeywords;
    /**
     * Consolidate all findings into a structured report
     */
    private consolidateFindings;
    /**
     * Generate professional HTML report using HTML Composer tool
     */
    private generateHtmlReport;
    /**
     * Extract topic from content for title generation
     */
    private extractTopicFromContent;
    /**
     * Extract a section from structured text
     */
    private extractSection;
    /**
     * Extract list items from structured text
     */
    private extractListItems;
}
declare const newsSpecialistOrchestrator: NewsSpecialistOrchestrator;

/**
 * Flash Headlines Orchestrator
 *
 * Implements a fast workflow for generating top 10 news headlines with accompanying images:
 * 1. Use Gemini Flash to generate 10 structured headlines with titles and subtitles
 * 2. Use Gemini Image Generator to create relevant 500x500 photos for each headline
 * 3. Return structured array of {title, subtitle, imgSrc} objects ready for display
 */
declare class FlashHeadlinesOrchestrator extends MultiAIOrchestrator {
    constructor();
    /**
     * Custom logic implementation for flash headlines generation
     */
    customLogic(input: string | CoreMessage[], context: OrchestratorContext): Promise<any>;
    /**
     * Parse topic from user input, default to general news if no specific topic
     */
    private parseTopicFromInput;
    /**
     * Generate 10 structured headlines using Gemini Flash
     */
    private generateHeadlines;
    /**
     * Parse headlines from Gemini's JSON response
     */
    private parseHeadlinesFromResponse;
    /**
     * Fallback method to extract headlines from unstructured text
     */
    private extractHeadlinesFromText;
    /**
     * Generate 500x500 images for each headline using Gemini Image Generator
     */
    private generateHeadlineImages;
    /**
     * Create descriptive prompt for generating news-related images
     */
    private createImagePrompt;
}
declare const flashHeadlinesOrchestrator: FlashHeadlinesOrchestrator;

interface OrchestratorInfo {
    id: string;
    name: string;
    description: string;
    type: 'prompt-based' | 'custom-logic' | 'multi-ai';
    systemPrompt?: string;
    allowedTools?: string[];
}
declare const orchestratorDescriptions: OrchestratorInfo[];
declare function loadBuiltInOrchestrators(): void;

/**
 * Create a standard agent for non-streaming execution
 */
declare function createAgent(options: {
    model: string | AIModel;
    tools?: any[];
    systemPrompt?: string;
    maxIterations?: number;
    customLogic?: (input: string, context: any) => Promise<any>;
    enableDebugLogging?: boolean;
    logLevel?: 'none' | 'basic' | 'detailed';
    enableStepLogging?: boolean;
    enableToolLogging?: boolean;
    enableTimingLogging?: boolean;
    enableStatisticsLogging?: boolean;
    enableStreamingLogging?: boolean;
    /**
     * API keys for various providers. Can include:
     * - Provider keys: openai, anthropic, google, etc.
     * - AWS credentials: awsAccessKeyId, awsSecretAccessKey, awsRegion, awsS3Bucket
     * - Bedrock credentials: bedrockAccessKeyId, bedrockSecretAccessKey, bedrockRegion
     */
    apiKeys?: ApiKeyMap;
} & OrchestratorOptions): Orchestrator;
/**
 * Create a streaming agent for real-time response streaming
 */
declare function createStreamingAgent(options: {
    model: string | AIModel;
    tools?: any[];
    systemPrompt?: string;
    maxIterations?: number;
    enableDebugLogging?: boolean;
    logLevel?: 'none' | 'basic' | 'detailed';
    enableStepLogging?: boolean;
    enableToolLogging?: boolean;
    enableTimingLogging?: boolean;
    enableStatisticsLogging?: boolean;
    enableStreamingLogging?: boolean;
    onFinish?: (result: any) => void | Promise<void>;
    /**
     * API keys for various providers. Can include:
     * - Provider keys: openai, anthropic, google, etc.
     * - AWS credentials: awsAccessKeyId, awsSecretAccessKey, awsRegion, awsS3Bucket
     * - Bedrock credentials: bedrockAccessKeyId, bedrockSecretAccessKey, bedrockRegion
     */
    apiKeys?: ApiKeyMap;
} & OrchestratorOptions): StreamingOrchestrator;

export { AIModel, ApiKeyMap, BaseOrchestrator, CoreMessage, CustomLogicOrchestrator, CustomLogicOrchestratorClass, ExecutionResult, LogLevel, Message, MultiAIOrchestrator, OpenAgenticTool, Orchestrator, OrchestratorContext, type OrchestratorInfo, OrchestratorOptions, OrchestratorType, PromptBasedOrchestrator, PromptBasedOrchestratorClass, ProviderManager, StreamingOrchestrator, clearOrchestratorRegistry, codeAssessmentOrchestrator, createAgent, createCustomLogicOrchestrator, createPromptBasedOrchestrator, createStreamingAgent, enhancedImageGenerationOrchestrator, flashHeadlinesOrchestrator, getOrchestrator, getOrchestratorsByType, getRegistryStats, hasOrchestrator, listOrchestrators, loadBuiltInOrchestrators, newsSpecialistOrchestrator, orchestratorDescriptions, registerOrchestrator, resolveOrchestrator, unregisterOrchestrator, videoCreatorOrchestrator };