@push.rocks/smartagent 1.0.2

package/dist_ts/smartagent.classes.dualagent.js

@@ -0,0 +1,298 @@
+import * as plugins from './plugins.js';
+import * as interfaces from './smartagent.interfaces.js';
+import { BaseToolWrapper } from './smartagent.tools.base.js';
+import { DriverAgent } from './smartagent.classes.driveragent.js';
+import { GuardianAgent } from './smartagent.classes.guardianagent.js';
+import { FilesystemTool } from './smartagent.tools.filesystem.js';
+import { HttpTool } from './smartagent.tools.http.js';
+import { ShellTool } from './smartagent.tools.shell.js';
+import { BrowserTool } from './smartagent.tools.browser.js';
+/**
+ * DualAgentOrchestrator - Coordinates Driver and Guardian agents
+ * Manages the complete lifecycle of task execution with tool approval
+ */
+export class DualAgentOrchestrator {
+    options;
+    smartai;
+    driverProvider;
+    guardianProvider;
+    driver;
+    guardian;
+    tools = new Map();
+    isRunning = false;
+    conversationHistory = [];
+    constructor(options) {
+        this.options = {
+            maxIterations: 20,
+            maxConsecutiveRejections: 3,
+            defaultProvider: 'openai',
+            ...options,
+        };
+        // Create SmartAi instance
+        this.smartai = new plugins.smartai.SmartAi(options);
+        // Get providers
+        this.driverProvider = this.getProviderByName(this.options.defaultProvider);
+        this.guardianProvider = this.options.guardianProvider
+            ? this.getProviderByName(this.options.guardianProvider)
+            : this.driverProvider;
+        // Create agents
+        this.driver = new DriverAgent(this.driverProvider, options.driverSystemMessage);
+        this.guardian = new GuardianAgent(this.guardianProvider, options.guardianPolicyPrompt);
+    }
+    /**
+     * Get provider by name
+     */
+    getProviderByName(providerName) {
+        switch (providerName) {
+            case 'openai':
+                return this.smartai.openaiProvider;
+            case 'anthropic':
+                return this.smartai.anthropicProvider;
+            case 'perplexity':
+                return this.smartai.perplexityProvider;
+            case 'ollama':
+                return this.smartai.ollamaProvider;
+            case 'groq':
+                return this.smartai.groqProvider;
+            case 'xai':
+                return this.smartai.xaiProvider;
+            case 'exo':
+                return this.smartai.exoProvider;
+            default:
+                return this.smartai.openaiProvider;
+        }
+    }
+    /**
+     * Register a custom tool
+     */
+    registerTool(tool) {
+        this.tools.set(tool.name, tool);
+        this.driver.registerTool(tool);
+        this.guardian.registerTool(tool);
+    }
+    /**
+     * Register all standard tools
+     */
+    registerStandardTools() {
+        const standardTools = [
+            new FilesystemTool(),
+            new HttpTool(),
+            new ShellTool(),
+            new BrowserTool(),
+        ];
+        for (const tool of standardTools) {
+            this.registerTool(tool);
+        }
+    }
+    /**
+     * Initialize all tools (eager loading)
+     */
+    async start() {
+        // Start smartai
+        await this.smartai.start();
+        // Initialize all tools
+        const initPromises = [];
+        for (const tool of this.tools.values()) {
+            initPromises.push(tool.initialize());
+        }
+        await Promise.all(initPromises);
+        this.isRunning = true;
+    }
+    /**
+     * Cleanup all tools
+     */
+    async stop() {
+        const cleanupPromises = [];
+        for (const tool of this.tools.values()) {
+            cleanupPromises.push(tool.cleanup());
+        }
+        await Promise.all(cleanupPromises);
+        await this.smartai.stop();
+        this.isRunning = false;
+        this.driver.reset();
+    }
+    /**
+     * Run a task through the dual-agent system
+     */
+    async run(task) {
+        if (!this.isRunning) {
+            throw new Error('Orchestrator not started. Call start() first.');
+        }
+        this.conversationHistory = [];
+        let iterations = 0;
+        let consecutiveRejections = 0;
+        let completed = false;
+        let finalResult = null;
+        // Add initial task to history
+        this.conversationHistory.push({
+            role: 'user',
+            content: task,
+        });
+        // Start the driver with the task
+        let driverResponse = await this.driver.startTask(task);
+        this.conversationHistory.push(driverResponse);
+        while (iterations < this.options.maxIterations &&
+            consecutiveRejections < this.options.maxConsecutiveRejections &&
+            !completed) {
+            iterations++;
+            // Check if task is complete
+            if (this.driver.isTaskComplete(driverResponse.content)) {
+                completed = true;
+                finalResult = this.driver.extractTaskResult(driverResponse.content) || driverResponse.content;
+                break;
+            }
+            // Check if driver needs clarification
+            if (this.driver.needsClarification(driverResponse.content)) {
+                // Return with clarification needed status
+                return {
+                    success: false,
+                    completed: false,
+                    result: driverResponse.content,
+                    iterations,
+                    history: this.conversationHistory,
+                    status: 'clarification_needed',
+                };
+            }
+            // Parse tool call proposals
+            const proposals = this.driver.parseToolCallProposals(driverResponse.content);
+            if (proposals.length === 0) {
+                // No tool calls, continue the conversation
+                driverResponse = await this.driver.continueWithMessage('Please either use a tool to make progress on the task, or indicate that the task is complete with <task_complete>summary</task_complete>.');
+                this.conversationHistory.push(driverResponse);
+                continue;
+            }
+            // Process the first proposal (one at a time)
+            const proposal = proposals[0];
+            // Quick validation first
+            const quickDecision = this.guardian.quickValidate(proposal);
+            let decision;
+            if (quickDecision) {
+                decision = quickDecision;
+            }
+            else {
+                // Full AI evaluation
+                decision = await this.guardian.evaluate(proposal, task);
+            }
+            if (decision.decision === 'approve') {
+                consecutiveRejections = 0;
+                // Execute the tool
+                const tool = this.tools.get(proposal.toolName);
+                if (!tool) {
+                    const errorMessage = `Tool "${proposal.toolName}" not found.`;
+                    driverResponse = await this.driver.continueWithMessage(`TOOL ERROR: ${errorMessage}\n\nPlease try a different approach.`);
+                    this.conversationHistory.push(driverResponse);
+                    continue;
+                }
+                try {
+                    const result = await tool.execute(proposal.action, proposal.params);
+                    // Send result to driver
+                    const resultMessage = result.success
+                        ? `TOOL RESULT (${proposal.toolName}.${proposal.action}):\n${JSON.stringify(result.result, null, 2)}`
+                        : `TOOL ERROR (${proposal.toolName}.${proposal.action}):\n${result.error}`;
+                    this.conversationHistory.push({
+                        role: 'system',
+                        content: resultMessage,
+                        toolCall: proposal,
+                        toolResult: result,
+                    });
+                    driverResponse = await this.driver.continueWithMessage(resultMessage);
+                    this.conversationHistory.push(driverResponse);
+                }
+                catch (error) {
+                    const errorMessage = `Tool execution failed: ${error instanceof Error ? error.message : String(error)}`;
+                    driverResponse = await this.driver.continueWithMessage(`TOOL ERROR: ${errorMessage}\n\nPlease try a different approach.`);
+                    this.conversationHistory.push(driverResponse);
+                }
+            }
+            else {
+                // Rejected
+                consecutiveRejections++;
+                // Build rejection feedback
+                let feedback = `TOOL CALL REJECTED by Guardian:\n`;
+                feedback += `- Reason: ${decision.reason}\n`;
+                if (decision.concerns && decision.concerns.length > 0) {
+                    feedback += `- Concerns:\n${decision.concerns.map(c => `  - ${c}`).join('\n')}\n`;
+                }
+                if (decision.suggestions) {
+                    feedback += `- Suggestions: ${decision.suggestions}\n`;
+                }
+                feedback += `\nPlease adapt your approach based on this feedback.`;
+                this.conversationHistory.push({
+                    role: 'system',
+                    content: feedback,
+                    toolCall: proposal,
+                    guardianDecision: decision,
+                });
+                driverResponse = await this.driver.continueWithMessage(feedback);
+                this.conversationHistory.push(driverResponse);
+            }
+        }
+        // Determine final status
+        let status = 'completed';
+        if (!completed) {
+            if (iterations >= this.options.maxIterations) {
+                status = 'max_iterations_reached';
+            }
+            else if (consecutiveRejections >= this.options.maxConsecutiveRejections) {
+                status = 'max_rejections_reached';
+            }
+        }
+        return {
+            success: completed,
+            completed,
+            result: finalResult || driverResponse.content,
+            iterations,
+            history: this.conversationHistory,
+            status,
+        };
+    }
+    /**
+     * Continue an existing task with user input
+     */
+    async continueTask(userInput) {
+        if (!this.isRunning) {
+            throw new Error('Orchestrator not started. Call start() first.');
+        }
+        this.conversationHistory.push({
+            role: 'user',
+            content: userInput,
+        });
+        const driverResponse = await this.driver.continueWithMessage(userInput);
+        this.conversationHistory.push(driverResponse);
+        // Continue the run loop
+        // For simplicity, we return the current state - full continuation would need refactoring
+        return {
+            success: false,
+            completed: false,
+            result: driverResponse.content,
+            iterations: 1,
+            history: this.conversationHistory,
+            status: 'in_progress',
+        };
+    }
+    /**
+     * Get the conversation history
+     */
+    getHistory() {
+        return [...this.conversationHistory];
+    }
+    /**
+     * Update the guardian policy
+     */
+    setGuardianPolicy(policyPrompt) {
+        this.guardian.setPolicy(policyPrompt);
+    }
+    /**
+     * Check if orchestrator is running
+     */
+    isActive() {
+        return this.isRunning;
+    }
+    /**
+     * Get registered tool names
+     */
+    getToolNames() {
+        return Array.from(this.tools.keys());
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartagent.classes.dualagent.js","sourceRoot":"","sources":["../ts/smartagent.classes.dualagent.ts"],"names":[],"mappings":"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"}

package/dist_ts/smartagent.classes.guardianagent.d.ts

@@ -0,0 +1,46 @@
+import * as plugins from './plugins.js';
+import * as interfaces from './smartagent.interfaces.js';
+import type { BaseToolWrapper } from './smartagent.tools.base.js';
+/**
+ * GuardianAgent - Evaluates tool call proposals against a policy
+ * Uses AI reasoning to approve or reject tool calls
+ */
+export declare class GuardianAgent {
+    private provider;
+    private policyPrompt;
+    private tools;
+    constructor(provider: plugins.smartai.MultiModalModel, policyPrompt: string);
+    /**
+     * Register a tool for reference during evaluation
+     */
+    registerTool(tool: BaseToolWrapper): void;
+    /**
+     * Evaluate a tool call proposal against the policy
+     */
+    evaluate(proposal: interfaces.IToolCallProposal, taskContext: string): Promise<interfaces.IGuardianDecision>;
+    /**
+     * Build the system message for the Guardian
+     */
+    private buildGuardianSystemMessage;
+    /**
+     * Build the evaluation prompt for a specific proposal
+     */
+    private buildEvaluationPrompt;
+    /**
+     * Parse the guardian decision from the response
+     */
+    private parseDecision;
+    /**
+     * Quick validation without AI (for obviously safe/unsafe operations)
+     * Returns null if AI evaluation is needed
+     */
+    quickValidate(proposal: interfaces.IToolCallProposal): interfaces.IGuardianDecision | null;
+    /**
+     * Update the policy prompt
+     */
+    setPolicy(policyPrompt: string): void;
+    /**
+     * Get current policy
+     */
+    getPolicy(): string;
+}

package/dist_ts/smartagent.classes.guardianagent.js

@@ -0,0 +1,201 @@
+import * as plugins from './plugins.js';
+import * as interfaces from './smartagent.interfaces.js';
+/**
+ * GuardianAgent - Evaluates tool call proposals against a policy
+ * Uses AI reasoning to approve or reject tool calls
+ */
+export class GuardianAgent {
+    provider;
+    policyPrompt;
+    tools = new Map();
+    constructor(provider, policyPrompt) {
+        this.provider = provider;
+        this.policyPrompt = policyPrompt;
+    }
+    /**
+     * Register a tool for reference during evaluation
+     */
+    registerTool(tool) {
+        this.tools.set(tool.name, tool);
+    }
+    /**
+     * Evaluate a tool call proposal against the policy
+     */
+    async evaluate(proposal, taskContext) {
+        // Get the tool to generate a human-readable summary
+        const tool = this.tools.get(proposal.toolName);
+        let callSummary = `${proposal.toolName}.${proposal.action}(${JSON.stringify(proposal.params)})`;
+        if (tool) {
+            try {
+                callSummary = tool.getCallSummary(proposal.action, proposal.params);
+            }
+            catch {
+                // Fallback to basic summary
+            }
+        }
+        // Build the evaluation prompt
+        const evaluationPrompt = this.buildEvaluationPrompt(proposal, callSummary, taskContext);
+        // Get response from provider
+        const response = await this.provider.chat({
+            systemMessage: this.buildGuardianSystemMessage(),
+            userMessage: evaluationPrompt,
+            messageHistory: [],
+        });
+        // Parse the decision from the response
+        return this.parseDecision(response.message, proposal);
+    }
+    /**
+     * Build the system message for the Guardian
+     */
+    buildGuardianSystemMessage() {
+        return `You are a Guardian AI responsible for evaluating tool call proposals.
+
+## Your Role
+You evaluate whether proposed tool calls are safe and aligned with the policy.
+
+## Policy to Enforce
+${this.policyPrompt}
+
+## Response Format
+For EVERY evaluation, respond with a decision in this exact format:
+
+<guardian_decision>
+  <decision>approve OR reject</decision>
+  <reason>Your detailed explanation</reason>
+  <concerns>List any concerns, even if approving</concerns>
+  <suggestions>Alternative approaches if rejecting</suggestions>
+</guardian_decision>
+
+## Guidelines
+1. Carefully analyze what the tool call will do
+2. Consider security implications
+3. Check against the policy requirements
+4. If uncertain, err on the side of caution (reject)
+5. Provide actionable feedback when rejecting`;
+    }
+    /**
+     * Build the evaluation prompt for a specific proposal
+     */
+    buildEvaluationPrompt(proposal, callSummary, taskContext) {
+        const toolInfo = this.tools.get(proposal.toolName);
+        const toolDescription = toolInfo ? toolInfo.getFullDescription() : 'Unknown tool';
+        return `## Task Context
+${taskContext}
+
+## Tool Being Used
+${toolDescription}
+
+## Proposed Tool Call
+- **Tool**: ${proposal.toolName}
+- **Action**: ${proposal.action}
+- **Parameters**: ${JSON.stringify(proposal.params, null, 2)}
+
+## Human-Readable Summary
+${callSummary}
+
+## Driver's Reasoning
+${proposal.reasoning || 'No reasoning provided'}
+
+---
+
+Evaluate this tool call against the policy. Should it be approved or rejected?`;
+    }
+    /**
+     * Parse the guardian decision from the response
+     */
+    parseDecision(response, proposal) {
+        // Try to extract from XML tags
+        const decisionMatch = response.match(/<decision>(.*?)<\/decision>/s);
+        const reasonMatch = response.match(/<reason>([\s\S]*?)<\/reason>/);
+        const concernsMatch = response.match(/<concerns>([\s\S]*?)<\/concerns>/);
+        const suggestionsMatch = response.match(/<suggestions>([\s\S]*?)<\/suggestions>/);
+        // Determine decision
+        let decision = 'reject';
+        if (decisionMatch) {
+            const decisionText = decisionMatch[1].trim().toLowerCase();
+            decision = decisionText.includes('approve') ? 'approve' : 'reject';
+        }
+        else {
+            // Fallback: look for approval keywords in the response
+            const lowerResponse = response.toLowerCase();
+            if (lowerResponse.includes('approved') ||
+                lowerResponse.includes('i approve') ||
+                lowerResponse.includes('looks safe')) {
+                decision = 'approve';
+            }
+        }
+        // Extract reason
+        let reason = reasonMatch ? reasonMatch[1].trim() : '';
+        if (!reason) {
+            // Use the full response as reason if no tag found
+            reason = response.substring(0, 500);
+        }
+        // Extract concerns
+        const concerns = [];
+        if (concernsMatch) {
+            const concernsText = concernsMatch[1].trim();
+            if (concernsText && concernsText.toLowerCase() !== 'none') {
+                // Split by newlines or bullet points
+                const concernLines = concernsText.split(/[\n\r]+/).map(l => l.trim()).filter(l => l);
+                concerns.push(...concernLines);
+            }
+        }
+        // Extract suggestions
+        const suggestions = suggestionsMatch ? suggestionsMatch[1].trim() : undefined;
+        return {
+            decision,
+            reason,
+            concerns: concerns.length > 0 ? concerns : undefined,
+            suggestions: suggestions && suggestions.toLowerCase() !== 'none' ? suggestions : undefined,
+        };
+    }
+    /**
+     * Quick validation without AI (for obviously safe/unsafe operations)
+     * Returns null if AI evaluation is needed
+     */
+    quickValidate(proposal) {
+        // Check if tool exists
+        if (!this.tools.has(proposal.toolName)) {
+            return {
+                decision: 'reject',
+                reason: `Unknown tool: ${proposal.toolName}`,
+            };
+        }
+        // Check if action exists
+        const tool = this.tools.get(proposal.toolName);
+        const validAction = tool.actions.find(a => a.name === proposal.action);
+        if (!validAction) {
+            return {
+                decision: 'reject',
+                reason: `Unknown action "${proposal.action}" for tool "${proposal.toolName}". Available actions: ${tool.actions.map(a => a.name).join(', ')}`,
+            };
+        }
+        // Check required parameters
+        const schema = validAction.parameters;
+        if (schema && schema.required && Array.isArray(schema.required)) {
+            for (const requiredParam of schema.required) {
+                if (!(requiredParam in proposal.params)) {
+                    return {
+                        decision: 'reject',
+                        reason: `Missing required parameter: ${requiredParam}`,
+                    };
+                }
+            }
+        }
+        // Needs full AI evaluation
+        return null;
+    }
+    /**
+     * Update the policy prompt
+     */
+    setPolicy(policyPrompt) {
+        this.policyPrompt = policyPrompt;
+    }
+    /**
+     * Get current policy
+     */
+    getPolicy() {
+        return this.policyPrompt;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRhZ2VudC5jbGFzc2VzLmd1YXJkaWFuYWdlbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydGFnZW50LmNsYXNzZXMuZ3VhcmRpYW5hZ2VudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQUN4QyxPQUFPLEtBQUssVUFBVSxNQUFNLDRCQUE0QixDQUFDO0FBR3pEOzs7R0FHRztBQUNILE1BQU0sT0FBTyxhQUFhO0lBQ2hCLFFBQVEsQ0FBa0M7SUFDMUMsWUFBWSxDQUFTO0lBQ3JCLEtBQUssR0FBaUMsSUFBSSxHQUFHLEVBQUUsQ0FBQztJQUV4RCxZQUNFLFFBQXlDLEVBQ3pDLFlBQW9CO1FBRXBCLElBQUksQ0FBQyxRQUFRLEdBQUcsUUFBUSxDQUFDO1FBQ3pCLElBQUksQ0FBQyxZQUFZLEdBQUcsWUFBWSxDQUFDO0lBQ25DLENBQUM7SUFFRDs7T0FFRztJQUNJLFlBQVksQ0FBQyxJQUFxQjtRQUN2QyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxDQUFDO0lBQ2xDLENBQUM7SUFFRDs7T0FFRztJQUNJLEtBQUssQ0FBQyxRQUFRLENBQ25CLFFBQXNDLEVBQ3RDLFdBQW1CO1FBRW5CLG9EQUFvRDtRQUNwRCxNQUFNLElBQUksR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDLENBQUM7UUFDL0MsSUFBSSxXQUFXLEdBQUcsR0FBRyxRQUFRLENBQUMsUUFBUSxJQUFJLFFBQVEsQ0FBQyxNQUFNLElBQUksSUFBSSxDQUFDLFNBQVMsQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQztRQUVoRyxJQUFJLElBQUksRUFBRSxDQUFDO1lBQ1QsSUFBSSxDQUFDO2dCQUNILFdBQVcsR0FBRyxJQUFJLENBQUMsY0FBYyxDQUFDLFFBQVEsQ0FBQyxNQUFNLEVBQUUsUUFBUSxDQUFDLE1BQU0sQ0FBQyxDQUFDO1lBQ3RFLENBQUM7WUFBQyxNQUFNLENBQUM7Z0JBQ1AsNEJBQTRCO1lBQzlCLENBQUM7UUFDSCxDQUFDO1FBRUQsOEJBQThCO1FBQzlCLE1BQU0sZ0JBQWdCLEdBQUcsSUFBSSxDQUFDLHFCQUFxQixDQUNqRCxRQUFRLEVBQ1IsV0FBVyxFQUNYLFdBQVcsQ0FDWixDQUFDO1FBRUYsNkJBQTZCO1FBQzdCLE1BQU0sUUFBUSxHQUFHLE1BQU0sSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUM7WUFDeEMsYUFBYSxFQUFFLElBQUksQ0FBQywwQkFBMEIsRUFBRTtZQUNoRCxXQUFXLEVBQUUsZ0JBQWdCO1lBQzdCLGNBQWMsRUFBRSxFQUFFO1NBQ25CLENBQUMsQ0FBQztRQUVILHVDQUF1QztRQUN2QyxPQUFPLElBQUksQ0FBQyxhQUFhLENBQUMsUUFBUSxDQUFDLE9BQU8sRUFBRSxRQUFRLENBQUMsQ0FBQztJQUN4RCxDQUFDO0lBRUQ7O09BRUc7SUFDSywwQkFBMEI7UUFDaEMsT0FBTzs7Ozs7O0VBTVQsSUFBSSxDQUFDLFlBQVk7Ozs7Ozs7Ozs7Ozs7Ozs7OzhDQWlCMkIsQ0FBQztJQUM3QyxDQUFDO0lBRUQ7O09BRUc7SUFDSyxxQkFBcUIsQ0FDM0IsUUFBc0MsRUFDdEMsV0FBbUIsRUFDbkIsV0FBbUI7UUFFbkIsTUFBTSxRQUFRLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBQ25ELE1BQU0sZUFBZSxHQUFHLFFBQVEsQ0FBQyxDQUFDLENBQUMsUUFBUSxDQUFDLGtCQUFrQixFQUFFLENBQUMsQ0FBQyxDQUFDLGNBQWMsQ0FBQztRQUVsRixPQUFPO0VBQ1QsV0FBVzs7O0VBR1gsZUFBZTs7O2NBR0gsUUFBUSxDQUFDLFFBQVE7Z0JBQ2YsUUFBUSxDQUFDLE1BQU07b0JBQ1gsSUFBSSxDQUFDLFNBQVMsQ0FBQyxRQUFRLENBQUMsTUFBTSxFQUFFLElBQUksRUFBRSxDQUFDLENBQUM7OztFQUcxRCxXQUFXOzs7RUFHWCxRQUFRLENBQUMsU0FBUyxJQUFJLHVCQUF1Qjs7OzsrRUFJZ0MsQ0FBQztJQUM5RSxDQUFDO0lBRUQ7O09BRUc7SUFDSyxhQUFhLENBQ25CLFFBQWdCLEVBQ2hCLFFBQXNDO1FBRXRDLCtCQUErQjtRQUMvQixNQUFNLGFBQWEsR0FBRyxRQUFRLENBQUMsS0FBSyxDQUFDLDhCQUE4QixDQUFDLENBQUM7UUFDckUsTUFBTSxXQUFXLEdBQUcsUUFBUSxDQUFDLEtBQUssQ0FBQyw4QkFBOEIsQ0FBQyxDQUFDO1FBQ25FLE1BQU0sYUFBYSxHQUFHLFFBQVEsQ0FBQyxLQUFLLENBQUMsa0NBQWtDLENBQUMsQ0FBQztRQUN6RSxNQUFNLGdCQUFnQixHQUFHLFFBQVEsQ0FBQyxLQUFLLENBQUMsd0NBQXdDLENBQUMsQ0FBQztRQUVsRixxQkFBcUI7UUFDckIsSUFBSSxRQUFRLEdBQXlCLFFBQVEsQ0FBQztRQUM5QyxJQUFJLGFBQWEsRUFBRSxDQUFDO1lBQ2xCLE1BQU0sWUFBWSxHQUFHLGFBQWEsQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxXQUFXLEVBQUUsQ0FBQztZQUMzRCxRQUFRLEdBQUcsWUFBWSxDQUFDLFFBQVEsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUM7UUFDckUsQ0FBQzthQUFNLENBQUM7WUFDTix1REFBdUQ7WUFDdkQsTUFBTSxhQUFhLEdBQUcsUUFBUSxDQUFDLFdBQVcsRUFBRSxDQUFDO1lBQzdDLElBQ0UsYUFBYSxDQUFDLFFBQVEsQ0FBQyxVQUFVLENBQUM7Z0JBQ2xDLGFBQWEsQ0FBQyxRQUFRLENBQUMsV0FBVyxDQUFDO2dCQUNuQyxhQUFhLENBQUMsUUFBUSxDQUFDLFlBQVksQ0FBQyxFQUNwQyxDQUFDO2dCQUNELFFBQVEsR0FBRyxTQUFTLENBQUM7WUFDdkIsQ0FBQztRQUNILENBQUM7UUFFRCxpQkFBaUI7UUFDakIsSUFBSSxNQUFNLEdBQUcsV0FBVyxDQUFDLENBQUMsQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztRQUN0RCxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUM7WUFDWixrREFBa0Q7WUFDbEQsTUFBTSxHQUFHLFFBQVEsQ0FBQyxTQUFTLENBQUMsQ0FBQyxFQUFFLEdBQUcsQ0FBQyxDQUFDO1FBQ3RDLENBQUM7UUFFRCxtQkFBbUI7UUFDbkIsTUFBTSxRQUFRLEdBQWEsRUFBRSxDQUFDO1FBQzlCLElBQUksYUFBYSxFQUFFLENBQUM7WUFDbEIsTUFBTSxZQUFZLEdBQUcsYUFBYSxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksRUFBRSxDQUFDO1lBQzdDLElBQUksWUFBWSxJQUFJLFlBQVksQ0FBQyxXQUFXLEVBQUUsS0FBSyxNQUFNLEVBQUUsQ0FBQztnQkFDMUQscUNBQXFDO2dCQUNyQyxNQUFNLFlBQVksR0FBRyxZQUFZLENBQUMsS0FBSyxDQUFDLFNBQVMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDO2dCQUNyRixRQUFRLENBQUMsSUFBSSxDQUFDLEdBQUcsWUFBWSxDQUFDLENBQUM7WUFDakMsQ0FBQztRQUNILENBQUM7UUFFRCxzQkFBc0I7UUFDdEIsTUFBTSxXQUFXLEdBQUcsZ0JBQWdCLENBQUMsQ0FBQyxDQUFDLGdCQUFnQixDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksRUFBRSxDQUFDLENBQUMsQ0FBQyxTQUFTLENBQUM7UUFFOUUsT0FBTztZQUNMLFFBQVE7WUFDUixNQUFNO1lBQ04sUUFBUSxFQUFFLFFBQVEsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLFNBQVM7WUFDcEQsV0FBVyxFQUFFLFdBQVcsSUFBSSxXQUFXLENBQUMsV0FBVyxFQUFFLEtBQUssTUFBTSxDQUFDLENBQUMsQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDLFNBQVM7U0FDM0YsQ0FBQztJQUNKLENBQUM7SUFFRDs7O09BR0c7SUFDSSxhQUFhLENBQUMsUUFBc0M7UUFDekQsdUJBQXVCO1FBQ3ZCLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQztZQUN2QyxPQUFPO2dCQUNMLFFBQVEsRUFBRSxRQUFRO2dCQUNsQixNQUFNLEVBQUUsaUJBQWlCLFFBQVEsQ0FBQyxRQUFRLEVBQUU7YUFDN0MsQ0FBQztRQUNKLENBQUM7UUFFRCx5QkFBeUI7UUFDekIsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBRSxDQUFDO1FBQ2hELE1BQU0sV0FBVyxHQUFHLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLElBQUksS0FBSyxRQUFRLENBQUMsTUFBTSxDQUFDLENBQUM7UUFDdkUsSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDO1lBQ2pCLE9BQU87Z0JBQ0wsUUFBUSxFQUFFLFFBQVE7Z0JBQ2xCLE1BQU0sRUFBRSxtQkFBbUIsUUFBUSxDQUFDLE1BQU0sZUFBZSxRQUFRLENBQUMsUUFBUSx5QkFBeUIsSUFBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxFQUFFO2FBQzlJLENBQUM7UUFDSixDQUFDO1FBRUQsNEJBQTRCO1FBQzVCLE1BQU0sTUFBTSxHQUFHLFdBQVcsQ0FBQyxVQUFVLENBQUM7UUFDdEMsSUFBSSxNQUFNLElBQUksTUFBTSxDQUFDLFFBQVEsSUFBSSxLQUFLLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDO1lBQ2hFLEtBQUssTUFBTSxhQUFhLElBQUksTUFBTSxDQUFDLFFBQW9CLEVBQUUsQ0FBQztnQkFDeEQsSUFBSSxDQUFDLENBQUMsYUFBYSxJQUFJLFFBQVEsQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDO29CQUN4QyxPQUFPO3dCQUNMLFFBQVEsRUFBRSxRQUFRO3dCQUNsQixNQUFNLEVBQUUsK0JBQStCLGFBQWEsRUFBRTtxQkFDdkQsQ0FBQztnQkFDSixDQUFDO1lBQ0gsQ0FBQztRQUNILENBQUM7UUFFRCwyQkFBMkI7UUFDM0IsT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDO0lBRUQ7O09BRUc7SUFDSSxTQUFTLENBQUMsWUFBb0I7UUFDbkMsSUFBSSxDQUFDLFlBQVksR0FBRyxZQUFZLENBQUM7SUFDbkMsQ0FBQztJQUVEOztPQUVHO0lBQ0ksU0FBUztRQUNkLE9BQU8sSUFBSSxDQUFDLFlBQVksQ0FBQztJQUMzQixDQUFDO0NBQ0YifQ==