@push.rocks/smartagent 1.0.2

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

@@ -0,0 +1,123 @@
+import * as plugins from './plugins.js';
+/**
+ * Configuration options for SmartAgent
+ */
+export interface ISmartAgentOptions extends plugins.smartai.ISmartAiOptions {
+    /** Name of the agent for identification */
+    name?: string;
+    /** Default provider to use for agent operations */
+    defaultProvider?: plugins.smartai.TProvider;
+    /** System message that defines the agent's behavior */
+    systemMessage?: string;
+    /** Maximum number of reasoning steps before forcing completion */
+    maxIterations?: number;
+}
+/**
+ * Represents a tool that an agent can use
+ */
+export interface IAgentTool {
+    /** Unique name for the tool */
+    name: string;
+    /** Description of what the tool does (used by the AI to decide when to use it) */
+    description: string;
+    /** JSON schema defining the tool's parameters */
+    parameters: Record<string, unknown>;
+    /** The function to execute when the tool is called */
+    execute: (params: Record<string, unknown>) => Promise<unknown>;
+}
+/**
+ * Represents a message in the agent's conversation history
+ */
+export interface IAgentMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string;
+    toolName?: string;
+    toolResult?: unknown;
+}
+/**
+ * Result of an agent run
+ */
+export interface IAgentRunResult {
+    /** The final response from the agent */
+    response: string;
+    /** Number of iterations the agent took */
+    iterations: number;
+    /** Full message history from this run */
+    messages: IAgentMessage[];
+    /** Whether the agent completed successfully or hit max iterations */
+    completed: boolean;
+}
+/**
+ * SmartAgent - An agentic framework built on top of @push.rocks/smartai
+ *
+ * Provides autonomous agent capabilities including:
+ * - Tool use and function calling
+ * - Multi-step reasoning
+ * - Conversation memory
+ * - Multiple AI provider support
+ */
+export declare class SmartAgent {
+    options: ISmartAgentOptions;
+    smartai: plugins.smartai.SmartAi;
+    tools: Map<string, IAgentTool>;
+    messageHistory: IAgentMessage[];
+    private isStarted;
+    constructor(optionsArg: ISmartAgentOptions);
+    /**
+     * Starts the agent and initializes the underlying SmartAi instance
+     */
+    start(): Promise<void>;
+    /**
+     * Stops the agent and cleans up resources
+     */
+    stop(): Promise<void>;
+    /**
+     * Registers a tool that the agent can use
+     */
+    registerTool(tool: IAgentTool): void;
+    /**
+     * Removes a tool from the agent
+     */
+    unregisterTool(toolName: string): void;
+    /**
+     * Gets all registered tools
+     */
+    getTools(): IAgentTool[];
+    /**
+     * Sets or updates the system message
+     */
+    setSystemMessage(message: string): void;
+    /**
+     * Clears the conversation history (except system message)
+     */
+    clearHistory(): void;
+    /**
+     * Runs the agent with a user message
+     * The agent will reason, use tools, and respond autonomously
+     */
+    run(userMessage: string): Promise<IAgentRunResult>;
+    /**
+     * Simple chat without tool use
+     */
+    chat(message: string): Promise<string>;
+    /**
+     * Gets the AI provider based on configuration
+     */
+    private getProvider;
+    /**
+     * Builds tool descriptions for the system prompt
+     */
+    private buildToolDescriptions;
+    /**
+     * Builds the system prompt including tool descriptions
+     */
+    private buildSystemPrompt;
+    /**
+     * Builds the contextual prompt from message history
+     */
+    private buildContextualPrompt;
+    /**
+     * Parses a tool call from the AI response
+     */
+    private parseToolCall;
+}

package/dist_ts/smartagent.classes.smartagent.js

@@ -0,0 +1,274 @@
+import * as plugins from './plugins.js';
+/**
+ * SmartAgent - An agentic framework built on top of @push.rocks/smartai
+ *
+ * Provides autonomous agent capabilities including:
+ * - Tool use and function calling
+ * - Multi-step reasoning
+ * - Conversation memory
+ * - Multiple AI provider support
+ */
+export class SmartAgent {
+    options;
+    smartai;
+    tools = new Map();
+    messageHistory = [];
+    isStarted = false;
+    constructor(optionsArg) {
+        this.options = {
+            name: 'SmartAgent',
+            defaultProvider: 'openai',
+            maxIterations: 10,
+            ...optionsArg,
+        };
+        this.smartai = new plugins.smartai.SmartAi(this.options);
+        if (this.options.systemMessage) {
+            this.messageHistory.push({
+                role: 'system',
+                content: this.options.systemMessage,
+            });
+        }
+    }
+    /**
+     * Starts the agent and initializes the underlying SmartAi instance
+     */
+    async start() {
+        if (this.isStarted)
+            return;
+        await this.smartai.start();
+        this.isStarted = true;
+    }
+    /**
+     * Stops the agent and cleans up resources
+     */
+    async stop() {
+        if (!this.isStarted)
+            return;
+        await this.smartai.stop();
+        this.isStarted = false;
+    }
+    /**
+     * Registers a tool that the agent can use
+     */
+    registerTool(tool) {
+        this.tools.set(tool.name, tool);
+    }
+    /**
+     * Removes a tool from the agent
+     */
+    unregisterTool(toolName) {
+        this.tools.delete(toolName);
+    }
+    /**
+     * Gets all registered tools
+     */
+    getTools() {
+        return Array.from(this.tools.values());
+    }
+    /**
+     * Sets or updates the system message
+     */
+    setSystemMessage(message) {
+        const existingIndex = this.messageHistory.findIndex(m => m.role === 'system');
+        if (existingIndex >= 0) {
+            this.messageHistory[existingIndex].content = message;
+        }
+        else {
+            this.messageHistory.unshift({
+                role: 'system',
+                content: message,
+            });
+        }
+    }
+    /**
+     * Clears the conversation history (except system message)
+     */
+    clearHistory() {
+        this.messageHistory = this.messageHistory.filter(m => m.role === 'system');
+    }
+    /**
+     * Runs the agent with a user message
+     * The agent will reason, use tools, and respond autonomously
+     */
+    async run(userMessage) {
+        if (!this.isStarted) {
+            await this.start();
+        }
+        // Add user message to history
+        this.messageHistory.push({
+            role: 'user',
+            content: userMessage,
+        });
+        let iterations = 0;
+        let completed = false;
+        let response = '';
+        while (iterations < (this.options.maxIterations || 10) && !completed) {
+            iterations++;
+            // Build the prompt with tool descriptions if tools are available
+            const toolDescriptions = this.buildToolDescriptions();
+            const systemPrompt = this.buildSystemPrompt(toolDescriptions);
+            // Get response from AI
+            const provider = this.getProvider();
+            const chatResponse = await provider.chat({
+                systemMessage: systemPrompt,
+                userMessage: this.buildContextualPrompt(),
+                messageHistory: [],
+            });
+            response = chatResponse.message;
+            // Check if the response contains a tool call
+            const toolCall = this.parseToolCall(response);
+            if (toolCall) {
+                // Execute the tool
+                const tool = this.tools.get(toolCall.name);
+                if (tool) {
+                    try {
+                        const toolResult = await tool.execute(toolCall.params);
+                        // Add tool interaction to history
+                        this.messageHistory.push({
+                            role: 'assistant',
+                            content: response,
+                        });
+                        this.messageHistory.push({
+                            role: 'tool',
+                            content: JSON.stringify(toolResult),
+                            toolName: toolCall.name,
+                            toolResult,
+                        });
+                    }
+                    catch (error) {
+                        // Add error to history
+                        this.messageHistory.push({
+                            role: 'tool',
+                            content: `Error executing tool ${toolCall.name}: ${error}`,
+                            toolName: toolCall.name,
+                        });
+                    }
+                }
+                else {
+                    // Unknown tool
+                    this.messageHistory.push({
+                        role: 'tool',
+                        content: `Unknown tool: ${toolCall.name}`,
+                        toolName: toolCall.name,
+                    });
+                }
+            }
+            else {
+                // No tool call, this is the final response
+                this.messageHistory.push({
+                    role: 'assistant',
+                    content: response,
+                });
+                completed = true;
+            }
+        }
+        return {
+            response,
+            iterations,
+            messages: [...this.messageHistory],
+            completed,
+        };
+    }
+    /**
+     * Simple chat without tool use
+     */
+    async chat(message) {
+        if (!this.isStarted) {
+            await this.start();
+        }
+        const systemMessage = this.messageHistory.find(m => m.role === 'system')?.content || 'You are a helpful assistant.';
+        const provider = this.getProvider();
+        const response = await provider.chat({
+            systemMessage,
+            userMessage: message,
+            messageHistory: this.messageHistory
+                .filter(m => m.role !== 'system')
+                .map(m => ({
+                role: m.role === 'tool' ? 'user' : m.role,
+                content: m.content,
+            })),
+        });
+        this.messageHistory.push({ role: 'user', content: message });
+        this.messageHistory.push({ role: 'assistant', content: response.message });
+        return response.message;
+    }
+    /**
+     * Gets the AI provider based on configuration
+     */
+    getProvider() {
+        const providerName = this.options.defaultProvider || 'openai';
+        switch (providerName) {
+            case 'openai':
+                return this.smartai.openaiProvider;
+            case 'anthropic':
+                return this.smartai.anthropicProvider;
+            case 'perplexity':
+                return this.smartai.perplexityProvider;
+            case 'groq':
+                return this.smartai.groqProvider;
+            case 'ollama':
+                return this.smartai.ollamaProvider;
+            case 'xai':
+                return this.smartai.xaiProvider;
+            case 'exo':
+                return this.smartai.exoProvider;
+            default:
+                return this.smartai.openaiProvider;
+        }
+    }
+    /**
+     * Builds tool descriptions for the system prompt
+     */
+    buildToolDescriptions() {
+        if (this.tools.size === 0)
+            return '';
+        const toolList = Array.from(this.tools.values())
+            .map(tool => `- ${tool.name}: ${tool.description}\n  Parameters: ${JSON.stringify(tool.parameters)}`)
+            .join('\n');
+        return `\nYou have access to the following tools:\n${toolList}\n\nTo use a tool, respond with:\n<tool_call>\n{"name": "tool_name", "params": {...}}\n</tool_call>\n\nAfter receiving the tool result, continue your reasoning or provide a final response.`;
+    }
+    /**
+     * Builds the system prompt including tool descriptions
+     */
+    buildSystemPrompt(toolDescriptions) {
+        const baseSystemMessage = this.messageHistory.find(m => m.role === 'system')?.content ||
+            'You are a helpful AI assistant.';
+        return baseSystemMessage + toolDescriptions;
+    }
+    /**
+     * Builds the contextual prompt from message history
+     */
+    buildContextualPrompt() {
+        return this.messageHistory
+            .filter(m => m.role !== 'system')
+            .map(m => {
+            if (m.role === 'tool') {
+                return `[Tool Result from ${m.toolName}]: ${m.content}`;
+            }
+            return `[${m.role}]: ${m.content}`;
+        })
+            .join('\n\n');
+    }
+    /**
+     * Parses a tool call from the AI response
+     */
+    parseToolCall(response) {
+        const toolCallMatch = response.match(/<tool_call>\s*(\{[\s\S]*?\})\s*<\/tool_call>/);
+        if (!toolCallMatch)
+            return null;
+        try {
+            const parsed = JSON.parse(toolCallMatch[1]);
+            if (parsed.name && typeof parsed.name === 'string') {
+                return {
+                    name: parsed.name,
+                    params: parsed.params || {},
+                };
+            }
+        }
+        catch {
+            return null;
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartagent.classes.smartagent.js","sourceRoot":"","sources":["../ts/smartagent.classes.smartagent.ts"],"names":[],"mappings":"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"}

package/dist_ts/smartagent.interfaces.d.ts

@@ -0,0 +1,165 @@
+import * as plugins from './plugins.js';
+/**
+ * Configuration options for the DualAgentOrchestrator
+ */
+export interface IDualAgentOptions extends plugins.smartai.ISmartAiOptions {
+    /** Name of the agent system */
+    name?: string;
+    /** Default AI provider for both Driver and Guardian */
+    defaultProvider?: plugins.smartai.TProvider;
+    /** Optional separate provider for Guardian (for cost optimization) */
+    guardianProvider?: plugins.smartai.TProvider;
+    /** System message for the Driver agent */
+    driverSystemMessage?: string;
+    /** Policy prompt for the Guardian agent - REQUIRED */
+    guardianPolicyPrompt: string;
+    /** Maximum iterations for task completion (default: 20) */
+    maxIterations?: number;
+    /** Maximum consecutive rejections before aborting (default: 3) */
+    maxConsecutiveRejections?: number;
+    /** Enable verbose logging */
+    verbose?: boolean;
+}
+/**
+ * Represents a message in the agent's conversation history
+ */
+export interface IAgentMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool' | 'guardian';
+    content: string;
+    toolName?: string;
+    toolResult?: unknown;
+    toolCall?: IToolCallProposal;
+    guardianDecision?: IGuardianDecision;
+    timestamp?: Date;
+}
+/**
+ * Represents an action that a tool can perform
+ */
+export interface IToolAction {
+    /** Action name (e.g., 'read', 'write', 'delete') */
+    name: string;
+    /** Description of what this action does */
+    description: string;
+    /** JSON schema for action parameters */
+    parameters: Record<string, unknown>;
+}
+/**
+ * Proposed tool call from the Driver
+ */
+export interface IToolCallProposal {
+    /** Unique ID for this proposal */
+    proposalId: string;
+    /** Name of the tool */
+    toolName: string;
+    /** Specific action to perform */
+    action: string;
+    /** Parameters for the action */
+    params: Record<string, unknown>;
+    /** Driver's reasoning for this call */
+    reasoning?: string;
+}
+/**
+ * Result of tool execution
+ */
+export interface IToolExecutionResult {
+    success: boolean;
+    result?: unknown;
+    error?: string;
+}
+/**
+ * Base interface for wrapped tools
+ */
+export interface IAgentToolWrapper {
+    /** Tool name */
+    name: string;
+    /** Tool description */
+    description: string;
+    /** Available actions */
+    actions: IToolAction[];
+    /** Initialize the tool */
+    initialize(): Promise<void>;
+    /** Cleanup resources */
+    cleanup(): Promise<void>;
+    /** Execute an action */
+    execute(action: string, params: Record<string, unknown>): Promise<IToolExecutionResult>;
+    /** Get a summary for Guardian review */
+    getCallSummary(action: string, params: Record<string, unknown>): string;
+}
+/**
+ * Request for Guardian evaluation
+ */
+export interface IGuardianEvaluationRequest {
+    /** The proposed tool call */
+    proposal: IToolCallProposal;
+    /** Current task context */
+    taskContext: string;
+    /** Recent conversation history (last N messages) */
+    recentHistory: IAgentMessage[];
+    /** Summary of what the tool call will do */
+    callSummary: string;
+}
+/**
+ * Guardian's decision
+ */
+export interface IGuardianDecision {
+    /** Approve or reject */
+    decision: 'approve' | 'reject';
+    /** Explanation of the decision */
+    reason: string;
+    /** Specific concerns if rejected */
+    concerns?: string[];
+    /** Suggestions for the Driver if rejected */
+    suggestions?: string;
+    /** Confidence level (0-1) */
+    confidence?: number;
+}
+/**
+ * Log entry for tool executions
+ */
+export interface IToolExecutionLog {
+    timestamp: Date;
+    toolName: string;
+    action: string;
+    params: Record<string, unknown>;
+    guardianDecision: 'approved' | 'rejected';
+    guardianReason: string;
+    executionResult?: unknown;
+    executionError?: string;
+}
+/**
+ * Status of a dual-agent run
+ */
+export type TDualAgentRunStatus = 'completed' | 'in_progress' | 'max_iterations_reached' | 'max_rejections_reached' | 'clarification_needed' | 'error';
+/**
+ * Result of a dual-agent run
+ */
+export interface IDualAgentRunResult {
+    /** Whether the task was successful */
+    success: boolean;
+    /** Whether the task is completed */
+    completed: boolean;
+    /** Final result or response */
+    result: string;
+    /** Total iterations taken */
+    iterations: number;
+    /** Full conversation history */
+    history: IAgentMessage[];
+    /** Current status */
+    status: TDualAgentRunStatus;
+    /** Number of tool calls made */
+    toolCallCount?: number;
+    /** Number of Guardian rejections */
+    rejectionCount?: number;
+    /** Tool execution log */
+    toolLog?: IToolExecutionLog[];
+    /** Error message if status is 'error' */
+    error?: string;
+}
+/**
+ * Available tool names
+ */
+export type TToolName = 'filesystem' | 'http' | 'browser' | 'shell';
+/**
+ * Generate a unique proposal ID
+ */
+export declare function generateProposalId(): string;

package/dist_ts/smartagent.interfaces.js

@@ -0,0 +1,8 @@
+import * as plugins from './plugins.js';
+/**
+ * Generate a unique proposal ID
+ */
+export function generateProposalId() {
+    return `proposal_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRhZ2VudC5pbnRlcmZhY2VzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvc21hcnRhZ2VudC5pbnRlcmZhY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBNE14Qzs7R0FFRztBQUNILE1BQU0sVUFBVSxrQkFBa0I7SUFDaEMsT0FBTyxZQUFZLElBQUksQ0FBQyxHQUFHLEVBQUUsSUFBSSxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLEVBQUUsQ0FBQztBQUNoRixDQUFDIn0=

package/dist_ts/smartagent.tools.base.d.ts

@@ -0,0 +1,46 @@
+import * as interfaces from './smartagent.interfaces.js';
+/**
+ * Abstract base class for tool wrappers
+ * All tool implementations should extend this class
+ */
+export declare abstract class BaseToolWrapper implements interfaces.IAgentToolWrapper {
+    abstract name: string;
+    abstract description: string;
+    abstract actions: interfaces.IToolAction[];
+    protected isInitialized: boolean;
+    /**
+     * Initialize the tool and any required resources
+     */
+    abstract initialize(): Promise<void>;
+    /**
+     * Cleanup any resources used by the tool
+     */
+    abstract cleanup(): Promise<void>;
+    /**
+     * Execute an action with the given parameters
+     */
+    abstract execute(action: string, params: Record<string, unknown>): Promise<interfaces.IToolExecutionResult>;
+    /**
+     * Generate a human-readable summary of what the action will do
+     * This is used by the Guardian to understand the proposed action
+     */
+    abstract getCallSummary(action: string, params: Record<string, unknown>): string;
+    /**
+     * Validate that an action exists for this tool
+     * @throws Error if the action is not valid
+     */
+    protected validateAction(action: string): void;
+    /**
+     * Check if the tool is initialized
+     */
+    protected ensureInitialized(): void;
+    /**
+     * Get the full tool description including all actions
+     * Used for Driver's tool awareness
+     */
+    getFullDescription(): string;
+    /**
+     * Get the JSON schema for a specific action
+     */
+    getActionSchema(action: string): Record<string, unknown> | undefined;
+}

package/dist_ts/smartagent.tools.base.js

@@ -0,0 +1,45 @@
+import * as interfaces from './smartagent.interfaces.js';
+/**
+ * Abstract base class for tool wrappers
+ * All tool implementations should extend this class
+ */
+export class BaseToolWrapper {
+    isInitialized = false;
+    /**
+     * Validate that an action exists for this tool
+     * @throws Error if the action is not valid
+     */
+    validateAction(action) {
+        const validAction = this.actions.find((a) => a.name === action);
+        if (!validAction) {
+            const availableActions = this.actions.map((a) => a.name).join(', ');
+            throw new Error(`Unknown action "${action}" for tool "${this.name}". Available actions: ${availableActions}`);
+        }
+    }
+    /**
+     * Check if the tool is initialized
+     */
+    ensureInitialized() {
+        if (!this.isInitialized) {
+            throw new Error(`Tool "${this.name}" is not initialized. Call initialize() first.`);
+        }
+    }
+    /**
+     * Get the full tool description including all actions
+     * Used for Driver's tool awareness
+     */
+    getFullDescription() {
+        const actionDescriptions = this.actions
+            .map((a) => `  - ${a.name}: ${a.description}`)
+            .join('\n');
+        return `${this.name}: ${this.description}\nActions:\n${actionDescriptions}`;
+    }
+    /**
+     * Get the JSON schema for a specific action
+     */
+    getActionSchema(action) {
+        const actionDef = this.actions.find((a) => a.name === action);
+        return actionDef?.parameters;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRhZ2VudC50b29scy5iYXNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvc21hcnRhZ2VudC50b29scy5iYXNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxVQUFVLE1BQU0sNEJBQTRCLENBQUM7QUFFekQ7OztHQUdHO0FBQ0gsTUFBTSxPQUFnQixlQUFlO0lBS3pCLGFBQWEsR0FBRyxLQUFLLENBQUM7SUEwQmhDOzs7T0FHRztJQUNPLGNBQWMsQ0FBQyxNQUFjO1FBQ3JDLE1BQU0sV0FBVyxHQUFHLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsSUFBSSxLQUFLLE1BQU0sQ0FBQyxDQUFDO1FBQ2hFLElBQUksQ0FBQyxXQUFXLEVBQUUsQ0FBQztZQUNqQixNQUFNLGdCQUFnQixHQUFHLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO1lBQ3BFLE1BQU0sSUFBSSxLQUFLLENBQ2IsbUJBQW1CLE1BQU0sZUFBZSxJQUFJLENBQUMsSUFBSSx5QkFBeUIsZ0JBQWdCLEVBQUUsQ0FDN0YsQ0FBQztRQUNKLENBQUM7SUFDSCxDQUFDO0lBRUQ7O09BRUc7SUFDTyxpQkFBaUI7UUFDekIsSUFBSSxDQUFDLElBQUksQ0FBQyxhQUFhLEVBQUUsQ0FBQztZQUN4QixNQUFNLElBQUksS0FBSyxDQUFDLFNBQVMsSUFBSSxDQUFDLElBQUksZ0RBQWdELENBQUMsQ0FBQztRQUN0RixDQUFDO0lBQ0gsQ0FBQztJQUVEOzs7T0FHRztJQUNJLGtCQUFrQjtRQUN2QixNQUFNLGtCQUFrQixHQUFHLElBQUksQ0FBQyxPQUFPO2FBQ3BDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsT0FBTyxDQUFDLENBQUMsSUFBSSxLQUFLLENBQUMsQ0FBQyxXQUFXLEVBQUUsQ0FBQzthQUM3QyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7UUFFZCxPQUFPLEdBQUcsSUFBSSxDQUFDLElBQUksS0FBSyxJQUFJLENBQUMsV0FBVyxlQUFlLGtCQUFrQixFQUFFLENBQUM7SUFDOUUsQ0FBQztJQUVEOztPQUVHO0lBQ0ksZUFBZSxDQUFDLE1BQWM7UUFDbkMsTUFBTSxTQUFTLEdBQUcsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLEtBQUssTUFBTSxDQUFDLENBQUM7UUFDOUQsT0FBTyxTQUFTLEVBQUUsVUFBVSxDQUFDO0lBQy9CLENBQUM7Q0FDRiJ9