import { RunContext, MiddlewareType, GetRunContext } from '../../context.cjs';
import * as zod from 'zod';
import { z } from 'zod';
import { B as BaseAgent, c as AgentMeta } from '../../base-s3ioVIE9.cjs';
import { AnyTool } from '../../tools/base.cjs';
import { BaseMemory } from '../../memory/base.cjs';
import { E as Emitter } from '../../emitter-D4OcelZ9.cjs';
import { a as ChatModel, i as ChatModelOutput, f as ChatModelInput } from '../../chat-C20nYj46.cjs';
import { AssistantMessage, ToolMessage, Message } from '../../backend/message.cjs';
import { c as RequirementAgentExecutionConfig, d as RequirementAgentTemplates, R as RequirementAgentRunState, a as RequirementAgentRequest, e as RequirementAgentRunInput, f as RequirementAgentOutput, g as RequirementAgentRunOptions, h as RequirementAgentCallbacks } from '../../types-BNsa3W7Z.cjs';
import { Requirement, Rule } from './requirements/requirement.cjs';
import { ToolCallPart } from 'ai';
import { RetryCounter } from '../../internals/helpers/counter.cjs';
import { RequirementsReasoner } from './utils/llm.cjs';
import { ToolCallChecker, ToolCallCheckerConfig } from './utils/toolCallChecker.cjs';
import { RequiredExcept } from '../../internals/types.cjs';
import '../../internals/serializable.cjs';
import '../../internals/helpers/guards.cjs';
import '../../internals/helpers/promise.cjs';
import '../../errors.cjs';
import 'ajv';
import 'promise-based-task';
import '../../cache/base.cjs';
import '../../internals/helpers/schema.cjs';
import 'zod-to-json-schema';
import '../../backend/constants.cjs';
import '../../template.cjs';
import '../../logger/logger.cjs';
import 'pino';

/**
 * Copyright 2025 © BeeAI a Series of LF Projects, LLC
 * SPDX-License-Identifier: Apache-2.0
 */

/**
 * Runner for RequirementAgent execution
 */
declare class RequirementAgentRunner {
    protected readonly llm: ChatModel;
    protected readonly runConfig: RequirementAgentExecutionConfig;
    protected readonly requirements: Requirement[];
    protected readonly toolCallCycleChecker: ToolCallChecker;
    protected readonly ctx: RunContext<RequirementAgent>;
    protected forceFinalAnswerAsTool: boolean;
    protected readonly templates: RequirementAgentTemplates;
    protected readonly state: RequirementAgentRunState;
    protected readonly reasoner: RequirementsReasoner;
    protected readonly iterationErrorCounter: RetryCounter;
    protected readonly globalErrorCounter: RetryCounter;
    constructor(llm: ChatModel, runConfig: RequirementAgentExecutionConfig, tools: AnyTool[], requirements: Requirement[], expectedOutput: string | z.ZodSchema | null, toolCallCycleChecker: ToolCallChecker, ctx: RunContext<RequirementAgent>, forceFinalAnswerAsTool: boolean, templates: RequirementAgentTemplates);
    protected incrementIteration(): void;
    protected runLLM(request: RequirementAgentRequest): Promise<ChatModelOutput>;
    protected prepareLLMRequest(request: RequirementAgentRequest): Promise<ChatModelInput>;
    protected createFinalAnswerToolCall(fullText: string): Promise<AssistantMessage | null>;
    protected createRequest(extraRules?: Rule[]): Promise<RequirementAgentRequest>;
    protected invokeToolCalls(tools: AnyTool[], toolCalls: ToolCallPart[]): Promise<ToolMessage[]>;
    addMessages(messages: Message[]): Promise<void>;
    run(): Promise<RequirementAgentRunState>;
    protected runIteration(request: RequirementAgentRequest): Promise<ChatModelOutput>;
    private createFinalAnswerStream;
}

type RequirementAgentTemplateFactory<K extends keyof RequirementAgentTemplates> = (template: RequirementAgentTemplates[K]) => RequirementAgentTemplates[K];
interface RequirementAgentInput {
    llm: ChatModel;
    memory?: BaseMemory;
    tools?: AnyTool[];
    requirements?: Requirement[];
    name?: string;
    description?: string;
    role?: string;
    instructions?: string | string[];
    notes?: string | string[];
    toolCallChecker?: boolean | ToolCallCheckerConfig;
    finalAnswerAsTool?: boolean;
    saveIntermediateSteps?: boolean;
    execution?: RequirementAgentExecutionConfig;
    templates?: Partial<{
        [K in keyof RequirementAgentTemplates]: RequirementAgentTemplates[K] | RequirementAgentTemplateFactory<K>;
    }>;
    middlewares?: MiddlewareType<RequirementAgent>[];
}
type InternalRequirementAgentInput = RequiredExcept<RequirementAgentInput, "role" | "instructions" | "name" | "description" | "templates" | "notes" | "execution" | "middlewares">;
/**
 * RequirementAgent - A declarative AI agent with rule-based constraints
 *
 * The RequirementAgent provides predictable, controlled execution behavior across
 * different language models through rule-based constraints (Requirements).
 * Requirements can be configured as strict or flexible as necessary, adapting to
 * task requirements while ensuring consistent execution regardless of the underlying
 * model's reasoning or tool-calling capabilities.
 */
declare class RequirementAgent extends BaseAgent<RequirementAgentRunInput, RequirementAgentOutput, RequirementAgentRunOptions> {
    readonly emitter: Emitter<RequirementAgentCallbacks>;
    protected readonly input: InternalRequirementAgentInput;
    protected runner: new (...args: ConstructorParameters<typeof RequirementAgentRunner>) => RequirementAgentRunner;
    constructor(input: RequirementAgentInput);
    protected _run(input: RequirementAgentRunInput, options: RequirementAgentRunOptions | undefined, run: GetRunContext<typeof this>): Promise<RequirementAgentOutput>;
    protected processInput(input: RequirementAgentRunInput): Message[];
    protected createToolCallChecker(): ToolCallChecker;
    get meta(): AgentMeta;
    protected get templates(): RequirementAgentTemplates;
    createSnapshot(): {
        input: InternalRequirementAgentInput;
        emitter: Emitter<RequirementAgentCallbacks>;
        runner: new (llm: ChatModel, runConfig: RequirementAgentExecutionConfig, tools: AnyTool[], requirements: Requirement[], expectedOutput: string | zod.ZodType<any, zod.ZodTypeDef, any> | null, toolCallCycleChecker: ToolCallChecker, ctx: RunContext<RequirementAgent, any>, forceFinalAnswerAsTool: boolean, templates: RequirementAgentTemplates) => RequirementAgentRunner;
        isRunning: boolean;
        middlewares: MiddlewareType<any>[];
    };
    set memory(memory: BaseMemory);
    get memory(): BaseMemory;
}

export { RequirementAgent as R, RequirementAgentRunner, type RequirementAgentInput as a, type RequirementAgentTemplateFactory as b };