import { Effect, Stream } from 'effect';
import * as Schema from 'effect/Schema';
import type * as SchemaTypes from 'effect/Schema';
import type { StreamEvent } from '../stream/events';
import type { AgentConfig, AgentInvocationMetadata, AgentMessage, AgentResponse, AgentStreamOptions } from './agent';
import { type PromptSourceService as PromptSourceServiceApi } from './prompt-source';
import type { ProviderDefinition } from '../platform/provider';
import type { Tool as FredTool } from '../tool/tool';
import { MCPServerRegistry } from '../mcp';
import type { Tracer } from '../tracing';
import type { ToolGateServiceApi, ToolGateContext } from '../tool-gate/types';
import type { FrameworkConfig } from '../config/types';
import { type AgentStatusService } from '../observability/status';
type ObservabilityServiceApi = {
    logStructured: (options: {
        level: 'trace' | 'debug' | 'info' | 'warning' | 'error' | 'fatal';
        message: string;
        metadata?: Record<string, unknown>;
    }) => Effect.Effect<void>;
    recordTokenUsage: (options: {
        provider: string;
        model: string;
        inputTokens: number;
        outputTokens: number;
    }) => Effect.Effect<void>;
    recordModelCost: (options: {
        provider: string;
        model: string;
        inputTokens: number;
        outputTokens: number;
    }) => Effect.Effect<number | undefined>;
};
export interface MCPClientMetrics {
    totalConnections: number;
    activeConnections: number;
    failedConnections: number;
    closedConnections: number;
    connectionsByAgent: Record<string, number>;
    lastConnectionTime?: Date;
    lastDisconnectionTime?: Date;
}
type AgentRuntimeOptions = AgentInvocationMetadata & {
    policyContext?: ToolGateContext & {
        conversationId?: string;
    };
};
/** Minimal tool registry interface for agent factory tool resolution */
export interface ToolRegistryLike {
    getMissingToolIds(ids: string[]): string[];
    getTools(ids: string[]): FredTool[];
    hasTool(id: string): boolean;
    registerTool(tool: FredTool): void;
}
type TemplateEngineLike = {
    resolveBody: (template: string, context: any, filePath: string) => Effect.Effect<string, any>;
};
export declare class AgentFactory {
    private toolRegistry;
    private handoffHandler?;
    private mcpClients;
    private tracer?;
    private observabilityService?;
    private agentStatusService?;
    private defaultSystemMessage?;
    private metrics;
    private shutdownHooksRegistered;
    private globalVariablesResolver?;
    private toolGateService?;
    private mcpServerRegistry?;
    private templateEngine?;
    private templateCustomNamespaces;
    private envAllowlist;
    private templateFredConfig;
    private promptSourceService;
    constructor(toolRegistry: ToolRegistryLike, tracer?: Tracer, promptSourceService?: PromptSourceServiceApi);
    setToolRegistry(toolRegistry: ToolRegistryLike): void;
    setGlobalVariablesResolver(resolver: () => Record<string, string | number | boolean>): void;
    setTemplateEngine(engine?: TemplateEngineLike): void;
    setTemplateCustomNamespaces(namespaces: Record<string, unknown>): void;
    setEnvAllowlist(envAllowlist: string[]): void;
    setTemplateFredConfig(config: Partial<FrameworkConfig>): void;
    setPromptSourceService(service: PromptSourceServiceApi): void;
    setDefaultSystemMessage(systemMessage?: string): void;
    setTracer(tracer?: Tracer): void;
    setObservabilityService(observabilityService?: ObservabilityServiceApi): void;
    setAgentStatusService(agentStatusService?: AgentStatusService): void;
    private logWarning;
    setToolGateService(toolGateService?: ToolGateServiceApi): void;
    setMCPServerRegistry(registry: MCPServerRegistry): void;
    setHandoffHandler(handler: {
        getAgent: (id: string) => any;
        getAvailableAgents: () => string[];
    }): void;
    cleanupMCPClients(agentId: string): Promise<void>;
    cleanupAllMCPClients(): Promise<void>;
    getMCPMetrics(): MCPClientMetrics;
    registerShutdownHooks(): void;
    createAgent<InputSchema extends SchemaTypes.Schema.AnyNoContext = typeof Schema.String, OutputSchema extends SchemaTypes.Schema.AnyNoContext = typeof Schema.Unknown>(config: AgentConfig<InputSchema, OutputSchema>, provider: ProviderDefinition): Effect.Effect<{
        run: (input: SchemaTypes.Schema.Type<InputSchema>, messages?: AgentMessage[], runtimeOptions?: AgentRuntimeOptions) => Effect.Effect<AgentResponse<SchemaTypes.Schema.Type<OutputSchema>>, Error>;
        processMessage: (message: string, messages?: AgentMessage[], runtimeOptions?: AgentRuntimeOptions) => Effect.Effect<AgentResponse<SchemaTypes.Schema.Type<OutputSchema>>, Error>;
        streamMessage?: (message: string, messages?: AgentMessage[], options?: AgentStreamOptions) => Stream.Stream<StreamEvent, unknown, any>;
    }, Error>;
}
export {};
//# sourceMappingURL=factory.d.ts.map