@push.rocks/smartagent 1.0.2

package/dist_ts/00_commitinfo_data.d.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export declare const commitinfo: {
+    name: string;
+    version: string;
+    description: string;
+};

package/dist_ts/00_commitinfo_data.js

@@ -0,0 +1,9 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+    name: '@push.rocks/smartagent',
+    version: '1.0.2',
+    description: 'an agentic framework built on top of @push.rocks/smartai'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLDBEQUEwRDtDQUN4RSxDQUFBIn0=

package/dist_ts/index.d.ts

@@ -0,0 +1,10 @@
+export { DualAgentOrchestrator } from './smartagent.classes.dualagent.js';
+export { DriverAgent } from './smartagent.classes.driveragent.js';
+export { GuardianAgent } from './smartagent.classes.guardianagent.js';
+export { BaseToolWrapper } from './smartagent.tools.base.js';
+export { FilesystemTool } from './smartagent.tools.filesystem.js';
+export { HttpTool } from './smartagent.tools.http.js';
+export { ShellTool } from './smartagent.tools.shell.js';
+export { BrowserTool } from './smartagent.tools.browser.js';
+export * from './smartagent.interfaces.js';
+export { type ISmartAiOptions, type TProvider, type ChatMessage, type ChatOptions, type ChatResponse, } from '@push.rocks/smartai';

package/dist_ts/index.js

@@ -0,0 +1,18 @@
+import * as plugins from './plugins.js';
+// Export the dual-agent orchestrator (main entry point)
+export { DualAgentOrchestrator } from './smartagent.classes.dualagent.js';
+// Export individual agents
+export { DriverAgent } from './smartagent.classes.driveragent.js';
+export { GuardianAgent } from './smartagent.classes.guardianagent.js';
+// Export base tool class for custom tool creation
+export { BaseToolWrapper } from './smartagent.tools.base.js';
+// Export standard tools
+export { FilesystemTool } from './smartagent.tools.filesystem.js';
+export { HttpTool } from './smartagent.tools.http.js';
+export { ShellTool } from './smartagent.tools.shell.js';
+export { BrowserTool } from './smartagent.tools.browser.js';
+// Export all interfaces
+export * from './smartagent.interfaces.js';
+// Re-export useful types from smartai
+export {} from '@push.rocks/smartai';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQUV4Qyx3REFBd0Q7QUFDeEQsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sbUNBQW1DLENBQUM7QUFFMUUsMkJBQTJCO0FBQzNCLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUNsRSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sdUNBQXVDLENBQUM7QUFFdEUsa0RBQWtEO0FBQ2xELE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUU3RCx3QkFBd0I7QUFDeEIsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBQ2xFLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUN0RCxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDeEQsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBRTVELHdCQUF3QjtBQUN4QixjQUFjLDRCQUE0QixDQUFDO0FBRTNDLHNDQUFzQztBQUN0QyxPQUFPLEVBTU4sTUFBTSxxQkFBcUIsQ0FBQyJ9

package/dist_ts/plugins.d.ts

@@ -0,0 +1,6 @@
+import * as smartai from '@push.rocks/smartai';
+import * as smartfs from '@push.rocks/smartfs';
+import * as smartrequest from '@push.rocks/smartrequest';
+import * as smartbrowser from '@push.rocks/smartbrowser';
+import * as smartshell from '@push.rocks/smartshell';
+export { smartai, smartfs, smartrequest, smartbrowser, smartshell, };

package/dist_ts/plugins.js

@@ -0,0 +1,8 @@
+// @push.rocks scope
+import * as smartai from '@push.rocks/smartai';
+import * as smartfs from '@push.rocks/smartfs';
+import * as smartrequest from '@push.rocks/smartrequest';
+import * as smartbrowser from '@push.rocks/smartbrowser';
+import * as smartshell from '@push.rocks/smartshell';
+export { smartai, smartfs, smartrequest, smartbrowser, smartshell, };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxPQUFPLE1BQU0scUJBQXFCLENBQUM7QUFDL0MsT0FBTyxLQUFLLE9BQU8sTUFBTSxxQkFBcUIsQ0FBQztBQUMvQyxPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxLQUFLLFVBQVUsTUFBTSx3QkFBd0IsQ0FBQztBQUVyRCxPQUFPLEVBQ0wsT0FBTyxFQUNQLE9BQU8sRUFDUCxZQUFZLEVBQ1osWUFBWSxFQUNaLFVBQVUsR0FDWCxDQUFDIn0=

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

@@ -0,0 +1,70 @@
+import * as plugins from './plugins.js';
+import * as interfaces from './smartagent.interfaces.js';
+import type { BaseToolWrapper } from './smartagent.tools.base.js';
+/**
+ * DriverAgent - Executes tasks by reasoning and proposing tool calls
+ * Works in conjunction with GuardianAgent for approval
+ */
+export declare class DriverAgent {
+    private provider;
+    private systemMessage;
+    private messageHistory;
+    private tools;
+    constructor(provider: plugins.smartai.MultiModalModel, systemMessage?: string);
+    /**
+     * Register a tool for use by the driver
+     */
+    registerTool(tool: BaseToolWrapper): void;
+    /**
+     * Get all registered tools
+     */
+    getTools(): Map<string, BaseToolWrapper>;
+    /**
+     * Initialize a new conversation for a task
+     */
+    startTask(task: string): Promise<interfaces.IAgentMessage>;
+    /**
+     * Continue the conversation with feedback or results
+     */
+    continueWithMessage(message: string): Promise<interfaces.IAgentMessage>;
+    /**
+     * Parse tool call proposals from assistant response
+     */
+    parseToolCallProposals(response: string): interfaces.IToolCallProposal[];
+    /**
+     * Parse the content inside a tool_call block
+     */
+    private parseToolCallContent;
+    /**
+     * Extract parameters from XML-like format when JSON parsing fails
+     */
+    private extractParamsFromXml;
+    /**
+     * Check if the response indicates task completion
+     */
+    isTaskComplete(response: string): boolean;
+    /**
+     * Check if the response needs clarification or user input
+     */
+    needsClarification(response: string): boolean;
+    /**
+     * Extract the final result from a completed task
+     */
+    extractTaskResult(response: string): string | null;
+    /**
+     * Build tool descriptions for the system message
+     */
+    private buildToolDescriptions;
+    /**
+     * Generate a unique proposal ID
+     */
+    private generateProposalId;
+    /**
+     * Get the default system message for the driver
+     */
+    private getDefaultSystemMessage;
+    /**
+     * Reset the conversation state
+     */
+    reset(): void;
+}

package/dist_ts/smartagent.classes.driveragent.js

@@ -0,0 +1,274 @@
+import * as plugins from './plugins.js';
+import * as interfaces from './smartagent.interfaces.js';
+/**
+ * DriverAgent - Executes tasks by reasoning and proposing tool calls
+ * Works in conjunction with GuardianAgent for approval
+ */
+export class DriverAgent {
+    provider;
+    systemMessage;
+    messageHistory = [];
+    tools = new Map();
+    constructor(provider, systemMessage) {
+        this.provider = provider;
+        this.systemMessage = systemMessage || this.getDefaultSystemMessage();
+    }
+    /**
+     * Register a tool for use by the driver
+     */
+    registerTool(tool) {
+        this.tools.set(tool.name, tool);
+    }
+    /**
+     * Get all registered tools
+     */
+    getTools() {
+        return this.tools;
+    }
+    /**
+     * Initialize a new conversation for a task
+     */
+    async startTask(task) {
+        // Reset message history
+        this.messageHistory = [];
+        // Build the user message
+        const userMessage = `TASK: ${task}\n\nAnalyze this task and determine what actions are needed. If you need to use a tool, provide a tool call proposal.`;
+        // Add to history
+        this.messageHistory.push({
+            role: 'user',
+            content: userMessage,
+        });
+        // Build tool descriptions for the system message
+        const toolDescriptions = this.buildToolDescriptions();
+        const fullSystemMessage = `${this.systemMessage}\n\n## Available Tools\n${toolDescriptions}`;
+        // Get response from provider
+        const response = await this.provider.chat({
+            systemMessage: fullSystemMessage,
+            userMessage: userMessage,
+            messageHistory: [],
+        });
+        // Add assistant response to history
+        this.messageHistory.push({
+            role: 'assistant',
+            content: response.message,
+        });
+        return {
+            role: 'assistant',
+            content: response.message,
+        };
+    }
+    /**
+     * Continue the conversation with feedback or results
+     */
+    async continueWithMessage(message) {
+        // Add the new message to history
+        this.messageHistory.push({
+            role: 'user',
+            content: message,
+        });
+        // Build tool descriptions for the system message
+        const toolDescriptions = this.buildToolDescriptions();
+        const fullSystemMessage = `${this.systemMessage}\n\n## Available Tools\n${toolDescriptions}`;
+        // Get response from provider (pass all but last user message as history)
+        const historyForChat = this.messageHistory.slice(0, -1);
+        const response = await this.provider.chat({
+            systemMessage: fullSystemMessage,
+            userMessage: message,
+            messageHistory: historyForChat,
+        });
+        // Add assistant response to history
+        this.messageHistory.push({
+            role: 'assistant',
+            content: response.message,
+        });
+        return {
+            role: 'assistant',
+            content: response.message,
+        };
+    }
+    /**
+     * Parse tool call proposals from assistant response
+     */
+    parseToolCallProposals(response) {
+        const proposals = [];
+        // Match <tool_call>...</tool_call> blocks
+        const toolCallRegex = /<tool_call>([\s\S]*?)<\/tool_call>/g;
+        let match;
+        while ((match = toolCallRegex.exec(response)) !== null) {
+            const content = match[1];
+            try {
+                const proposal = this.parseToolCallContent(content);
+                if (proposal) {
+                    proposals.push(proposal);
+                }
+            }
+            catch (error) {
+                // Skip malformed tool calls
+                console.warn('Failed to parse tool call:', error);
+            }
+        }
+        return proposals;
+    }
+    /**
+     * Parse the content inside a tool_call block
+     */
+    parseToolCallContent(content) {
+        // Extract tool name
+        const toolMatch = content.match(/<tool>(.*?)<\/tool>/s);
+        if (!toolMatch)
+            return null;
+        const toolName = toolMatch[1].trim();
+        // Extract action
+        const actionMatch = content.match(/<action>(.*?)<\/action>/s);
+        if (!actionMatch)
+            return null;
+        const action = actionMatch[1].trim();
+        // Extract params (JSON)
+        const paramsMatch = content.match(/<params>([\s\S]*?)<\/params>/);
+        let params = {};
+        if (paramsMatch) {
+            try {
+                params = JSON.parse(paramsMatch[1].trim());
+            }
+            catch {
+                // Try to extract individual parameters if JSON fails
+                params = this.extractParamsFromXml(paramsMatch[1]);
+            }
+        }
+        // Extract reasoning (optional)
+        const reasoningMatch = content.match(/<reasoning>([\s\S]*?)<\/reasoning>/);
+        const reasoning = reasoningMatch ? reasoningMatch[1].trim() : undefined;
+        return {
+            proposalId: this.generateProposalId(),
+            toolName,
+            action,
+            params,
+            reasoning,
+        };
+    }
+    /**
+     * Extract parameters from XML-like format when JSON parsing fails
+     */
+    extractParamsFromXml(content) {
+        const params = {};
+        const paramRegex = /<(\w+)>([\s\S]*?)<\/\1>/g;
+        let match;
+        while ((match = paramRegex.exec(content)) !== null) {
+            const key = match[1];
+            let value = match[2].trim();
+            // Try to parse as JSON for arrays/objects
+            try {
+                value = JSON.parse(value);
+            }
+            catch {
+                // Keep as string if not valid JSON
+            }
+            params[key] = value;
+        }
+        return params;
+    }
+    /**
+     * Check if the response indicates task completion
+     */
+    isTaskComplete(response) {
+        // Check for explicit completion markers
+        const completionMarkers = [
+            '<task_complete>',
+            '<task_completed>',
+            'TASK COMPLETE',
+            'Task completed successfully',
+        ];
+        const lowerResponse = response.toLowerCase();
+        return completionMarkers.some(marker => lowerResponse.includes(marker.toLowerCase()));
+    }
+    /**
+     * Check if the response needs clarification or user input
+     */
+    needsClarification(response) {
+        const clarificationMarkers = [
+            '<needs_clarification>',
+            '<question>',
+            'please clarify',
+            'could you specify',
+            'what do you mean by',
+        ];
+        const lowerResponse = response.toLowerCase();
+        return clarificationMarkers.some(marker => lowerResponse.includes(marker.toLowerCase()));
+    }
+    /**
+     * Extract the final result from a completed task
+     */
+    extractTaskResult(response) {
+        // Try to extract from result tags
+        const resultMatch = response.match(/<task_result>([\s\S]*?)<\/task_result>/);
+        if (resultMatch) {
+            return resultMatch[1].trim();
+        }
+        const completeMatch = response.match(/<task_complete>([\s\S]*?)<\/task_complete>/);
+        if (completeMatch) {
+            return completeMatch[1].trim();
+        }
+        return null;
+    }
+    /**
+     * Build tool descriptions for the system message
+     */
+    buildToolDescriptions() {
+        const descriptions = [];
+        for (const tool of this.tools.values()) {
+            descriptions.push(tool.getFullDescription());
+        }
+        return descriptions.join('\n\n');
+    }
+    /**
+     * Generate a unique proposal ID
+     */
+    generateProposalId() {
+        return `prop_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+    }
+    /**
+     * Get the default system message for the driver
+     */
+    getDefaultSystemMessage() {
+        return `You are an AI assistant that executes tasks by using available tools.
+
+## Your Role
+You analyze tasks, break them down into steps, and use tools to accomplish goals.
+
+## Tool Usage Format
+When you need to use a tool, output a tool call proposal in this format:
+
+<tool_call>
+  <tool>tool_name</tool>
+  <action>action_name</action>
+  <params>
+    {"param1": "value1", "param2": "value2"}
+  </params>
+  <reasoning>Brief explanation of why this action is needed</reasoning>
+</tool_call>
+
+## Guidelines
+1. Think step by step about what needs to be done
+2. Use only the tools that are available to you
+3. Provide clear reasoning for each tool call
+4. If a tool call is rejected, adapt your approach based on the feedback
+5. When the task is complete, indicate this clearly:
+
+<task_complete>
+  Brief summary of what was accomplished
+</task_complete>
+
+## Important
+- Only propose ONE tool call at a time
+- Wait for the result before proposing the next action
+- If you encounter an error, analyze it and try an alternative approach
+- If you need clarification, ask using <needs_clarification>your question</needs_clarification>`;
+    }
+    /**
+     * Reset the conversation state
+     */
+    reset() {
+        this.messageHistory = [];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,62 @@
+import * as interfaces from './smartagent.interfaces.js';
+import { BaseToolWrapper } from './smartagent.tools.base.js';
+/**
+ * DualAgentOrchestrator - Coordinates Driver and Guardian agents
+ * Manages the complete lifecycle of task execution with tool approval
+ */
+export declare class DualAgentOrchestrator {
+    private options;
+    private smartai;
+    private driverProvider;
+    private guardianProvider;
+    private driver;
+    private guardian;
+    private tools;
+    private isRunning;
+    private conversationHistory;
+    constructor(options: interfaces.IDualAgentOptions);
+    /**
+     * Get provider by name
+     */
+    private getProviderByName;
+    /**
+     * Register a custom tool
+     */
+    registerTool(tool: BaseToolWrapper): void;
+    /**
+     * Register all standard tools
+     */
+    registerStandardTools(): void;
+    /**
+     * Initialize all tools (eager loading)
+     */
+    start(): Promise<void>;
+    /**
+     * Cleanup all tools
+     */
+    stop(): Promise<void>;
+    /**
+     * Run a task through the dual-agent system
+     */
+    run(task: string): Promise<interfaces.IDualAgentRunResult>;
+    /**
+     * Continue an existing task with user input
+     */
+    continueTask(userInput: string): Promise<interfaces.IDualAgentRunResult>;
+    /**
+     * Get the conversation history
+     */
+    getHistory(): interfaces.IAgentMessage[];
+    /**
+     * Update the guardian policy
+     */
+    setGuardianPolicy(policyPrompt: string): void;
+    /**
+     * Check if orchestrator is running
+     */
+    isActive(): boolean;
+    /**
+     * Get registered tool names
+     */
+    getToolNames(): string[];
+}