@push.rocks/smartagent 1.8.0 → 3.0.1

package/ts/smartagent.tools.deno.ts

@@ -1,230 +0,0 @@
-import * as plugins from './plugins.js';
-import * as interfaces from './smartagent.interfaces.js';
-import { BaseToolWrapper } from './smartagent.tools.base.js';
-
-/**
- * Deno permission types for sandboxed code execution
- */
-export type TDenoPermission =
-  | 'all'
-  | 'env'
-  | 'ffi'
-  | 'hrtime'
-  | 'net'
-  | 'read'
-  | 'run'
-  | 'sys'
-  | 'write';
-
-/**
- * Deno tool for executing TypeScript/JavaScript code in a sandboxed environment
- * Wraps @push.rocks/smartdeno
- */
-export class DenoTool extends BaseToolWrapper {
-  public name = 'deno';
-  public description =
-    'Execute TypeScript/JavaScript code in a sandboxed Deno environment with fine-grained permission control';
-
-  public actions: interfaces.IToolAction[] = [
-    {
-      name: 'execute',
-      description:
-        'Execute TypeScript/JavaScript code and return stdout/stderr. Code runs in Deno sandbox with specified permissions.',
-      parameters: {
-        type: 'object',
-        properties: {
-          code: {
-            type: 'string',
-            description: 'TypeScript/JavaScript code to execute',
-          },
-          permissions: {
-            type: 'array',
-            items: {
-              type: 'string',
-              enum: ['all', 'env', 'ffi', 'hrtime', 'net', 'read', 'run', 'sys', 'write'],
-            },
-            description:
-              'Deno permissions to grant. Default: none (fully sandboxed). Options: all, env, net, read, write, run, sys, ffi, hrtime',
-          },
-        },
-        required: ['code'],
-      },
-    },
-    {
-      name: 'executeWithResult',
-      description:
-        'Execute code that outputs JSON on the last line of stdout. The JSON is parsed and returned as the result.',
-      parameters: {
-        type: 'object',
-        properties: {
-          code: {
-            type: 'string',
-            description:
-              'Code that console.logs a JSON value on the final line. This JSON will be parsed and returned.',
-          },
-          permissions: {
-            type: 'array',
-            items: {
-              type: 'string',
-              enum: ['all', 'env', 'ffi', 'hrtime', 'net', 'read', 'run', 'sys', 'write'],
-            },
-            description: 'Deno permissions to grant',
-          },
-        },
-        required: ['code'],
-      },
-    },
-  ];
-
-  private smartdeno!: plugins.smartdeno.SmartDeno;
-
-  public async initialize(): Promise<void> {
-    this.smartdeno = new plugins.smartdeno.SmartDeno();
-    await this.smartdeno.start();
-    this.isInitialized = true;
-  }
-
-  public async cleanup(): Promise<void> {
-    if (this.smartdeno) {
-      await this.smartdeno.stop();
-    }
-    this.isInitialized = false;
-  }
-
-  public async execute(
-    action: string,
-    params: Record<string, unknown>
-  ): Promise<interfaces.IToolExecutionResult> {
-    this.validateAction(action);
-    this.ensureInitialized();
-
-    try {
-      const code = params.code as string;
-      const permissions = (params.permissions as TDenoPermission[]) || [];
-
-      // Execute the script
-      const result = await this.smartdeno.executeScript(code, {
-        permissions,
-      });
-
-      switch (action) {
-        case 'execute': {
-          return {
-            success: result.exitCode === 0,
-            result: {
-              exitCode: result.exitCode,
-              stdout: result.stdout,
-              stderr: result.stderr,
-              permissions,
-            },
-          };
-        }
-
-        case 'executeWithResult': {
-          if (result.exitCode !== 0) {
-            return {
-              success: false,
-              error: `Script failed with exit code ${result.exitCode}: ${result.stderr}`,
-            };
-          }
-
-          // Parse the last line of stdout as JSON
-          const lines = result.stdout.trim().split('\n');
-          const lastLine = lines[lines.length - 1];
-
-          try {
-            const parsedResult = JSON.parse(lastLine);
-            return {
-              success: true,
-              result: {
-                parsed: parsedResult,
-                stdout: result.stdout,
-                stderr: result.stderr,
-              },
-            };
-          } catch (parseError) {
-            return {
-              success: false,
-              error: `Failed to parse JSON from last line of output: ${lastLine}`,
-            };
-          }
-        }
-
-        default:
-          return {
-            success: false,
-            error: `Unknown action: ${action}`,
-          };
-      }
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : String(error),
-      };
-    }
-  }
-
-  public getToolExplanation(): string {
-    return `## Tool: deno
-Execute TypeScript/JavaScript code in a sandboxed Deno environment with fine-grained permission control.
-
-### Actions:
-
-**execute** - Execute TypeScript/JavaScript code and return stdout/stderr
-Parameters:
-  - code (required): TypeScript/JavaScript code to execute
-  - permissions (optional): Array of Deno permissions to grant. Options: "all", "env", "net", "read", "write", "run", "sys", "ffi", "hrtime". Default: none (fully sandboxed)
-
-Example - Simple execution:
-<tool_call>
-  <tool>deno</tool>
-  <action>execute</action>
-  <params>{"code": "console.log('Hello from Deno!');"}</params>
-</tool_call>
-
-Example - With network permission:
-<tool_call>
-  <tool>deno</tool>
-  <action>execute</action>
-  <params>{"code": "const resp = await fetch('https://api.example.com/data');\\nconsole.log(await resp.text());", "permissions": ["net"]}</params>
-</tool_call>
-
-**executeWithResult** - Execute code that outputs JSON on the last line of stdout
-Parameters:
-  - code (required): Code that console.logs a JSON value on the final line
-  - permissions (optional): Array of Deno permissions to grant
-
-Example:
-<tool_call>
-  <tool>deno</tool>
-  <action>executeWithResult</action>
-  <params>{"code": "const result = { sum: 1 + 2, product: 2 * 3 };\\nconsole.log(JSON.stringify(result));"}</params>
-</tool_call>
-`;
-  }
-
-  public getCallSummary(action: string, params: Record<string, unknown>): string {
-    const code = params.code as string;
-    const permissions = (params.permissions as string[]) || [];
-
-    // Create a preview of the code (first 100 chars)
-    const codePreview = code.length > 100 ? code.substring(0, 100) + '...' : code;
-    // Escape newlines for single-line display
-    const cleanPreview = codePreview.replace(/\n/g, '\\n');
-
-    const permissionInfo = permissions.length > 0
-      ? ` [permissions: ${permissions.join(', ')}]`
-      : ' [sandboxed - no permissions]';
-
-    switch (action) {
-      case 'execute':
-        return `Execute Deno code${permissionInfo}: "${cleanPreview}"`;
-
-      case 'executeWithResult':
-        return `Execute Deno code and parse JSON result${permissionInfo}: "${cleanPreview}"`;
-
-      default:
-        return `Unknown action: ${action}`;
-    }
-  }
-}

package/ts/smartagent.tools.expert.ts

@@ -1,144 +0,0 @@
-import * as plugins from './plugins.js';
-import * as interfaces from './smartagent.interfaces.js';
-import { BaseToolWrapper } from './smartagent.tools.base.js';
-
-// Forward declaration to avoid circular import at module load time
-// The actual import happens lazily in initialize()
-let DualAgentOrchestrator: typeof import('./smartagent.classes.dualagent.js').DualAgentOrchestrator;
-
-/**
- * ExpertTool - A specialized agent wrapped as a tool
- *
- * Enables hierarchical agent architectures where the Driver can delegate
- * complex tasks to specialized experts with their own tools and policies.
- */
-export class ExpertTool extends BaseToolWrapper {
-  public name: string;
-  public description: string;
-  public actions: interfaces.IToolAction[] = [
-    {
-      name: 'consult',
-      description: 'Delegate a task or question to this expert',
-      parameters: {
-        type: 'object',
-        properties: {
-          task: { type: 'string', description: 'The task or question for the expert' },
-          context: { type: 'string', description: 'Additional context to help the expert' },
-        },
-        required: ['task'],
-      },
-    },
-  ];
-
-  private config: interfaces.IExpertConfig;
-  private smartAi: plugins.smartai.SmartAi;
-  private inner?: InstanceType<typeof DualAgentOrchestrator>;
-
-  constructor(config: interfaces.IExpertConfig, smartAi: plugins.smartai.SmartAi) {
-    super();
-    this.config = config;
-    this.smartAi = smartAi;
-    this.name = config.name;
-    this.description = config.description;
-  }
-
-  async initialize(): Promise<void> {
-    // Lazy import to avoid circular dependency
-    if (!DualAgentOrchestrator) {
-      const module = await import('./smartagent.classes.dualagent.js');
-      DualAgentOrchestrator = module.DualAgentOrchestrator;
-    }
-
-    this.inner = new DualAgentOrchestrator({
-      smartAiInstance: this.smartAi, // Share SmartAi instance
-      defaultProvider: this.config.provider,
-      driverSystemMessage: this.config.systemMessage,
-      guardianPolicyPrompt: this.config.guardianPolicy,
-      maxIterations: this.config.maxIterations ?? 10,
-    });
-
-    // Register expert's tools
-    if (this.config.tools) {
-      for (const tool of this.config.tools) {
-        // Tools in the config are IAgentToolWrapper, but we need BaseToolWrapper
-        // Since all our tools extend BaseToolWrapper, this cast is safe
-        this.inner.registerTool(tool as BaseToolWrapper);
-      }
-    }
-
-    await this.inner.start();
-    this.isInitialized = true;
-  }
-
-  async cleanup(): Promise<void> {
-    if (this.inner) {
-      await this.inner.stop();
-      this.inner = undefined;
-    }
-    this.isInitialized = false;
-  }
-
-  async execute(
-    action: string,
-    params: Record<string, unknown>
-  ): Promise<interfaces.IToolExecutionResult> {
-    this.validateAction(action);
-    this.ensureInitialized();
-
-    const task = params.task as string;
-    const context = params.context as string | undefined;
-
-    const fullTask = context ? `Context: ${context}\n\nTask: ${task}` : task;
-
-    try {
-      const result = await this.inner!.run(fullTask);
-
-      return {
-        success: result.success,
-        result: {
-          response: result.result,
-          iterations: result.iterations,
-          status: result.status,
-        },
-        summary: result.success
-          ? `Expert "${this.name}" completed (${result.iterations} iterations)`
-          : `Expert "${this.name}" failed: ${result.status}`,
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: `Expert error: ${error instanceof Error ? error.message : String(error)}`,
-      };
-    }
-  }
-
-  getCallSummary(action: string, params: Record<string, unknown>): string {
-    const task = params.task as string;
-    const preview = task.length > 60 ? task.substring(0, 60) + '...' : task;
-    return `Consult ${this.name}: "${preview}"`;
-  }
-
-  getToolExplanation(): string {
-    return `## Expert: ${this.name}
-${this.description}
-
-### Usage:
-Delegate tasks to this expert when you need specialized help.
-
-\`\`\`
-<tool_call>
-  <tool>${this.name}</tool>
-  <action>consult</action>
-  <params>{"task": "Your question or task", "context": "Optional background"}</params>
-</tool_call>
-\`\`\`
-`;
-  }
-
-  /**
-   * Get the expert's configuration
-   */
-  getConfig(): interfaces.IExpertConfig {
-    return this.config;
-  }
-}