import { z } from 'zod';
import { AIConfig } from '../../config/ai.config';
/**
 * Task breakdown structure
 */
export declare const TaskBreakdownSchema: z.ZodObject<{
    title: z.ZodString;
    description: z.ZodString;
    subtasks: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        title: z.ZodString;
        description: z.ZodString;
        estimatedHours: z.ZodOptional<z.ZodNumber>;
        dependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$strip>>;
    estimatedTotalHours: z.ZodOptional<z.ZodNumber>;
    complexity: z.ZodEnum<{
        trivial: "trivial";
        minor: "minor";
        major: "major";
        critical: "critical";
    }>;
    suggestedApproach: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
export type TaskBreakdown = z.infer<typeof TaskBreakdownSchema>;
/**
 * Options for LangChain operations
 */
export interface LangChainOptions {
    temperature?: number;
    maxTokens?: number;
    verbose?: boolean;
    streaming?: boolean;
    memory?: boolean;
}
/**
 * Result from LangChain operations
 */
export interface LangChainResult {
    content: string | any;
    tokensUsed?: number;
    executionTimeMs: number;
    chainType: string;
}
/**
 * Service for LangChain operations with OpenAI integration
 * Implements chains, agents, and memory management for complex task processing
 */
export declare class LangChainService {
    private llm;
    private config;
    private memories;
    constructor(config?: AIConfig);
    /**
     * Create a simple completion chain
     * @param systemPrompt System prompt for the chain
     * @param options Chain options
     * @returns Runnable chain
     */
    createCompletionChain(systemPrompt: string, options?: LangChainOptions): any;
    /**
     * Create a chain with memory for conversation context
     * @param systemPrompt System prompt
     * @param sessionId Session ID for memory management
     * @param options Chain options
     * @returns Runnable chain with memory
     */
    createConversationChain(systemPrompt: string, sessionId: string, options?: LangChainOptions): any;
    /**
     * Create a task breakdown agent
     * @param options Agent options
     * @returns Task breakdown chain
     */
    createTaskBreakdownAgent(options?: LangChainOptions): any;
    /**
     * Create a chain for natural language task creation
     * @param options Chain options
     * @returns Task creation chain
     */
    createTaskCreationChain(options?: LangChainOptions): any;
    /**
     * Create a chain for generating task suggestions
     * @param options Chain options
     * @returns Task suggestion chain
     */
    createTaskSuggestionChain(options?: LangChainOptions): any;
    /**
     * Execute a task breakdown
     * @param taskDescription Task to break down
     * @param context Additional context
     * @param options Execution options
     * @returns Task breakdown result
     */
    breakdownTask(taskDescription: string, context?: string, options?: LangChainOptions): Promise<TaskBreakdown>;
    /**
     * Process natural language task creation
     * @param description Natural language description
     * @param projectContext Project context
     * @param options Execution options
     * @returns Created task object
     */
    createTaskFromNaturalLanguage(description: string, projectContext?: string, options?: LangChainOptions): Promise<any>;
    /**
     * Get task suggestions based on project state
     * @param projectData Project information
     * @param options Execution options
     * @returns Task suggestions
     */
    getTaskSuggestions(projectData: {
        projectDescription: string;
        completedTasks: string[];
        currentTasks: string[];
        goals: string[];
    }, options?: LangChainOptions): Promise<string>;
    /**
     * Execute a chain with streaming support
     * @param chain The chain to execute
     * @param input Input data
     * @param onChunk Callback for each streamed chunk
     * @returns Final result
     */
    streamChain(chain: any, input: any, onChunk: (chunk: string) => void): Promise<string>;
    /**
     * Get or create memory for a session
     * @param sessionId Session identifier
     * @param options Memory options
     * @returns Memory instance
     */
    private getOrCreateMemory;
    /**
     * Add a message to session memory
     * @param sessionId Session identifier
     * @param message Message to add
     * @param role Message role (human or ai)
     */
    addToMemory(sessionId: string, message: string, role: 'human' | 'ai'): Promise<void>;
    /**
     * Clear memory for a session
     * @param sessionId Session identifier
     */
    clearMemory(sessionId: string): void;
    /**
     * Clear all memories
     */
    clearAllMemories(): void;
    /**
     * Get memory summary for a session
     * @param sessionId Session identifier
     * @returns Memory summary or null
     */
    getMemorySummary(sessionId: string): Promise<string | null>;
    /**
     * Test LangChain connection
     * @returns True if connection successful
     */
    testConnection(): Promise<boolean>;
}
//# sourceMappingURL=langchain.service.d.ts.map