export type AmazonBedrockOrchestratorParams = {
    momento?: {
        apiKey: string;
        cacheName: string;
    };
    bedrock?: {
        modelId?: string;
        accessKeyId?: string;
        secretAccessKey?: string;
        region?: string;
        profile?: string;
    };
    config?: {
        agentLoadingConcurrency?: number;
        systemPrompt?: string;
        maxTokens?: number;
        tokenWarningThreshold?: number;
        debug?: boolean;
        preserveThinkingTags?: boolean;
        tools?: Array<{
            name: string;
            description: string;
            schema: any;
            handler: (input: any) => Promise<any> | any;
        }>;
    };
};
export type SendMessageParams = {
    message: string;
    contextId?: string;
};
/**
 * A chunk of text from the streaming orchestrator.
 * - 'chunk': Partial output received during streaming
 * - 'final': Full final message after stream ends
 */
export type StreamChunk = {
    type: 'chunk';
    text: string;
} | {
    type: 'final';
    text: string;
};
/**
 * Orchestrates conversations between the user and distributed A2A agents using Amazon Bedrock.
 */
export declare class AmazonBedrockOrchestrator {
    private client;
    private model;
    private agentUrls;
    private concurrencyLimit;
    private maxTokens;
    private tokenWarningThreshold;
    private _agentCards;
    private _loadingPromise;
    private bedrock;
    private logger;
    private preserveThinkingTags;
    private additionalSystemPrompt?;
    private tools;
    constructor(params: AmazonBedrockOrchestratorParams);
    /**
     * Registers additional agent URLs that can be used for orchestration.
     * @param agentUrls - List of agent endpoint URLs.
     */
    registerAgents(agentUrls: string[]): void;
    /**
     * Returns true if agent cards have already been loaded.
     */
    isReady(): boolean;
    /**
     * Sends a message to the orchestrator and returns the final response text.
     * @param params - Message and optional context ID.
     */
    sendMessage(params: SendMessageParams): Promise<string>;
    /**
   * Sends a message and returns an async generator that yields response chunks.
   * Recommended for streaming user experiences.
   *
   * @param params - Message and optional context ID.
   * @returns Async generator yielding text chunks from the orchestrator.
   */
    sendMessageStream(params: SendMessageParams): AsyncGenerator<StreamChunk>;
    /**
     * Sends a message and invokes the callback with each streamed response chunk.
     * Useful for minimal setups or environments without async iterators.
     *
     * @param params - Message and optional context ID.
     * @param onText - Callback to receive streamed output chunks.
     */
    sendMessageStreamWithCallback(params: SendMessageParams, onText: (text: StreamChunk) => void): Promise<void>;
    /**
     * Estimates token count for a message array (rough approximation)
     * This is a simple heuristic - for production you might want to use a proper tokenizer
     */
    private estimateTokenCount;
    /**
     * Checks if we have enough tokens remaining for another iteration
     */
    private hasTokensRemaining;
    private getAgentCards;
    private loadAgents;
    private loadAgentCard;
    private buildConverseCommand;
    private buildConverseStreamCommand;
}
//# sourceMappingURL=amazon_bedrock.d.ts.map