import type { Agent } from '../services/agent';
export interface AgentConfig<TDeps = any, TOutput = string> {
    model: string | ModelInstance;
    depsType?: new (...args: any[]) => TDeps;
    outputType?: new (...args: any[]) => TOutput;
    instructions?: string | ((_ctx: RunContext<TDeps>) => Promise<string> | string);
    systemPrompt?: string | ((_ctx: RunContext<TDeps>) => Promise<string> | string);
    tools?: ToolFunction<TDeps>[];
    toolsets?: ToolFunction<TDeps>[][];
    modelSettings?: ModelSettings;
}
export interface ModelSettings {
    temperature?: number;
    maxTokens?: number;
    topP?: number;
    timeout?: number;
    maxRetries?: number;
    retryDelay?: number;
}
export interface ModelInstance {
    provider: string;
    model: string;
    settings?: ModelSettings;
}
export interface FallbackModel {
    models: (string | ModelInstance)[];
    strategy: 'sequential' | 'random' | 'fastest';
}
export interface RunContext<TDeps = any> {
    deps: TDeps;
    sessionId: string;
    messageHistory: Message[];
    modelSettings?: ModelSettings;
    metadata: Record<string, any>;
}
export interface Message {
    role: 'system' | 'user' | 'assistant' | 'tool';
    content: string;
    toolCalls?: ToolCall[];
    toolCallId?: string;
    timestamp: Date;
}
export interface ToolCall {
    id: string;
    name: string;
    arguments: Record<string, any>;
}
export interface ToolReturn {
    id: string;
    content: string;
    isError?: boolean;
}
export interface ToolFunction<TDeps = any> {
    name: string;
    description: string;
    parameters: {
        type: 'object';
        properties: Record<string, any>;
        required?: string[];
    };
    handler: (_ctx: RunContext<TDeps>, args: Record<string, any>) => Promise<any> | any;
    requiresContext?: boolean;
}
export interface RunResult<TOutput = string> {
    data: TOutput;
    success?: boolean;
    error?: string | Error;
    usage: {
        promptTokens: number;
        completionTokens: number;
        totalTokens: number;
        cost: number;
    };
    messageHistory: Message[];
    toolCalls: ToolCall[];
    modelUsed: string;
    timestamp: Date;
    sessionId: string;
    metadata?: Record<string, any>;
}
export interface StreamResponse<TOutput = string> {
    stream(): AsyncIterable<StreamEvent>;
    streamText(): AsyncIterable<string>;
    getResult(): Promise<RunResult<TOutput>>;
    abort(): void;
}
export type StreamEvent = TextDeltaEvent | ToolCallEvent | ToolReturnEvent | ModelSwitchEvent | ErrorEvent | CompletionEvent;
export interface TextDeltaEvent {
    type: 'text_delta';
    delta: string;
    timestamp: Date;
}
export interface ToolCallEvent {
    type: 'tool_call';
    toolCall: ToolCall;
    timestamp: Date;
}
export interface ToolReturnEvent {
    type: 'tool_return';
    toolReturn: ToolReturn;
    timestamp: Date;
}
export interface ModelSwitchEvent {
    type: 'model_switch';
    fromModel: string;
    toModel: string;
    reason: string;
    timestamp: Date;
}
export interface ErrorEvent {
    type: 'error';
    error: Error;
    recoverable: boolean;
    timestamp: Date;
}
export interface CompletionEvent {
    type: 'completion';
    result: RunResult;
    timestamp: Date;
}
export declare class ModelRetry extends Error {
    readonly suggestion?: string | undefined;
    readonly retryCount?: number | undefined;
    constructor(message: string, suggestion?: string | undefined, retryCount?: number | undefined);
}
export declare class ValidationError extends Error {
    readonly field?: string | undefined;
    readonly value?: any | undefined;
    constructor(message: string, field?: string | undefined, value?: any | undefined);
}
export interface AgentRunOptions<TDeps = any> {
    deps?: TDeps;
    messages?: Message[];
    modelSettings?: ModelSettings;
    metadata?: Record<string, any>;
    timeout?: number;
    onEvent?: (event: StreamEvent) => void;
}
export interface TestModel {
    type: 'test';
    responses: string[];
    toolBehavior: 'call_all' | 'call_first' | 'call_none';
}
export interface FunctionModel {
    type: 'function';
    handler: (messages: Message[]) => Promise<string> | string;
}
export type MockModel = TestModel | FunctionModel;
export type InferDepsType<T> = T extends Agent<infer D, any> ? D : never;
export type InferOutputType<T> = T extends Agent<any, infer O> ? O : never;
export interface ToolDecorator<_TDeps = any> {
    (target: any, propertyKey: string, descriptor: PropertyDescriptor): void;
}
export interface ToolPlainDecorator {
    (target: any, propertyKey: string, descriptor: PropertyDescriptor): void;
}
export interface ValidationSchema<T = any> {
    parse(input: unknown): T;
    safeParse(input: unknown): {
        success: true;
        data: T;
    } | {
        success: false;
        error: Error;
    };
}
export type { AgentInstance, DynamicAgentTemplate, SMEAgentDefinition as AgentDefinition, } from './orchestrator';
export interface AgentAvailability {
    agentId: string;
    available: boolean;
    currentLoad: number;
    maxCapacity: number;
    estimatedFreeTime?: Date;
    capabilities: string[];
}
export interface TaskRequirements {
    skills: string[];
    resources: string[];
    constraints: Record<string, any>;
    priority: 'low' | 'medium' | 'high';
    deadline?: Date;
    tasks: string[];
}
//# sourceMappingURL=agent.d.ts.map