@push.rocks/smartagent 1.8.0 → 3.0.0

package/ts_tools/tool.http.ts

@@ -0,0 +1,78 @@
+import * as plugins from './plugins.js';
+
+export function httpTool(): plugins.ToolSet {
+  return {
+    http_get: plugins.tool({
+      description: 'Make an HTTP GET request and return the response.',
+      inputSchema: plugins.z.object({
+        url: plugins.z.string().describe('URL to request'),
+        headers: plugins.z
+          .record(plugins.z.string())
+          .optional()
+          .describe('Request headers'),
+      }),
+      execute: async ({
+        url,
+        headers,
+      }: {
+        url: string;
+        headers?: Record<string, string>;
+      }) => {
+        let req = plugins.smartrequest.default.create().url(url);
+        if (headers) {
+          req = req.headers(headers);
+        }
+        const response = await req.get();
+        let body: string;
+        try {
+          const json = await response.json();
+          body = JSON.stringify(json, null, 2);
+        } catch {
+          body = await response.text();
+        }
+        return plugins.truncateOutput(`HTTP ${response.status}\n${body}`).content;
+      },
+    }),
+
+    http_post: plugins.tool({
+      description: 'Make an HTTP POST request with a JSON body.',
+      inputSchema: plugins.z.object({
+        url: plugins.z.string().describe('URL to request'),
+        body: plugins.z
+          .record(plugins.z.unknown())
+          .optional()
+          .describe('JSON body to send'),
+        headers: plugins.z
+          .record(plugins.z.string())
+          .optional()
+          .describe('Request headers'),
+      }),
+      execute: async ({
+        url,
+        body,
+        headers,
+      }: {
+        url: string;
+        body?: Record<string, unknown>;
+        headers?: Record<string, string>;
+      }) => {
+        let req = plugins.smartrequest.default.create().url(url);
+        if (headers) {
+          req = req.headers(headers);
+        }
+        if (body) {
+          req = req.json(body);
+        }
+        const response = await req.post();
+        let responseBody: string;
+        try {
+          const json = await response.json();
+          responseBody = JSON.stringify(json, null, 2);
+        } catch {
+          responseBody = await response.text();
+        }
+        return plugins.truncateOutput(`HTTP ${response.status}\n${responseBody}`).content;
+      },
+    }),
+  };
+}

package/ts_tools/tool.json.ts

@@ -0,0 +1,53 @@
+import * as plugins from './plugins.js';
+
+export function jsonTool(): plugins.ToolSet {
+  return {
+    json_validate: plugins.tool({
+      description:
+        'Validate a JSON string and optionally check for required fields.',
+      inputSchema: plugins.z.object({
+        jsonString: plugins.z.string().describe('JSON string to validate'),
+        requiredFields: plugins.z
+          .array(plugins.z.string())
+          .optional()
+          .describe('Fields that must exist at the top level'),
+      }),
+      execute: async ({
+        jsonString,
+        requiredFields,
+      }: {
+        jsonString: string;
+        requiredFields?: string[];
+      }) => {
+        try {
+          const parsed = JSON.parse(jsonString);
+          if (requiredFields?.length) {
+            const missing = requiredFields.filter((f) => !(f in parsed));
+            if (missing.length) {
+              return `Invalid: missing required fields: ${missing.join(', ')}`;
+            }
+          }
+          const type = Array.isArray(parsed) ? 'array' : typeof parsed;
+          return `Valid JSON (${type})`;
+        } catch (e) {
+          return `Invalid JSON: ${(e as Error).message}`;
+        }
+      },
+    }),
+
+    json_transform: plugins.tool({
+      description: 'Parse a JSON string and return it pretty-printed.',
+      inputSchema: plugins.z.object({
+        jsonString: plugins.z.string().describe('JSON string to format'),
+      }),
+      execute: async ({ jsonString }: { jsonString: string }) => {
+        try {
+          const parsed = JSON.parse(jsonString);
+          return JSON.stringify(parsed, null, 2);
+        } catch (e) {
+          return `Error parsing JSON: ${(e as Error).message}`;
+        }
+      },
+    }),
+  };
+}

package/ts_tools/tool.shell.ts

@@ -0,0 +1,62 @@
+import * as plugins from './plugins.js';
+
+export interface IShellToolOptions {
+  /** Allowed commands whitelist. If empty, all commands are allowed. */
+  allowedCommands?: string[];
+  /** Working directory for shell execution */
+  cwd?: string;
+}
+
+export function shellTool(options?: IShellToolOptions): plugins.ToolSet {
+  const smartshell = new plugins.smartshell.Smartshell({ executor: 'bash' });
+
+  return {
+    run_command: plugins.tool({
+      description:
+        'Execute a shell command. Provide the full command string. stdout and stderr are returned.',
+      inputSchema: plugins.z.object({
+        command: plugins.z.string().describe('The shell command to execute'),
+        cwd: plugins.z
+          .string()
+          .optional()
+          .describe('Working directory for the command'),
+        timeout: plugins.z
+          .number()
+          .optional()
+          .describe('Timeout in milliseconds'),
+      }),
+      execute: async ({
+        command,
+        cwd,
+        timeout,
+      }: {
+        command: string;
+        cwd?: string;
+        timeout?: number;
+      }) => {
+        // Validate against allowed commands whitelist
+        if (options?.allowedCommands?.length) {
+          const baseCommand = command.split(/\s+/)[0];
+          if (!options.allowedCommands.includes(baseCommand)) {
+            return `Command "${baseCommand}" is not in the allowed commands list: ${options.allowedCommands.join(', ')}`;
+          }
+        }
+
+        // Build full command string with cd prefix if cwd specified
+        const effectiveCwd = cwd ?? options?.cwd;
+        const fullCommand = effectiveCwd
+          ? `cd ${JSON.stringify(effectiveCwd)} && ${command}`
+          : command;
+
+        const execResult = await smartshell.exec(fullCommand);
+
+        const output =
+          execResult.exitCode === 0
+            ? execResult.stdout
+            : `Exit code: ${execResult.exitCode}\nstdout:\n${execResult.stdout}\nstderr:\n${execResult.stderr ?? ''}`;
+
+        return plugins.truncateOutput(output).content;
+      },
+    }),
+  };
+}

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

@@ -1,134 +0,0 @@
-import * as plugins from './plugins.js';
-import * as interfaces from './smartagent.interfaces.js';
-import type { BaseToolWrapper } from './smartagent.tools.base.js';
-/**
- * Options for configuring the DriverAgent
- */
-export interface IDriverAgentOptions {
-    /** Custom system message for the driver */
-    systemMessage?: string;
-    /** Maximum history messages to pass to API (default: 20). Set to 0 for unlimited. */
-    maxHistoryMessages?: number;
-    /** Callback fired for each token during LLM generation */
-    onToken?: (token: string) => void;
-}
-/**
- * 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 maxHistoryMessages;
-    private messageHistory;
-    private tools;
-    private onToken?;
-    private isInThinkingMode;
-    constructor(provider: plugins.smartai.MultiModalModel, options?: IDriverAgentOptions | string);
-    /**
-     * Set the token callback for streaming mode
-     * @param callback Function to call for each generated token
-     */
-    setOnToken(callback: (token: string) => void): void;
-    /**
-     * 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
-     * @param task The task description
-     * @param images Optional base64-encoded images for vision tasks
-     */
-    startTask(task: string, images?: 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;
-    /**
-     * Get the system message when no tools are available
-     * Used for direct task completion without tool usage
-     */
-    private getNoToolsSystemMessage;
-    /**
-     * Reset the conversation state
-     */
-    reset(): void;
-    /**
-     * Start a task with native tool calling support
-     * Uses Ollama's native tool calling API instead of XML parsing
-     * @param task The task description
-     * @param images Optional base64-encoded images for vision tasks
-     * @returns Response with content, reasoning, and any tool calls
-     */
-    startTaskWithNativeTools(task: string, images?: string[]): Promise<{
-        message: interfaces.IAgentMessage;
-        toolCalls?: interfaces.INativeToolCall[];
-    }>;
-    /**
-     * Continue conversation with native tool calling support
-     * @param message The message to continue with (e.g., tool result)
-     * @param toolName Optional tool name - when provided, message is added as role: 'tool' instead of 'user'
-     * @returns Response with content, reasoning, and any tool calls
-     */
-    continueWithNativeTools(message: string, toolName?: string): Promise<{
-        message: interfaces.IAgentMessage;
-        toolCalls?: interfaces.INativeToolCall[];
-    }>;
-    /**
-     * Get system message for native tool calling mode
-     * Simplified prompt that lets the model use tools naturally
-     */
-    private getNativeToolsSystemMessage;
-    /**
-     * Convert registered tools to Ollama JSON Schema format for native tool calling
-     * Each tool action becomes a separate function with name format: "toolName_actionName"
-     * @returns Array of IOllamaTool compatible tool definitions
-     */
-    getToolsAsJsonSchema(): plugins.smartai.IOllamaTool[];
-    /**
-     * Parse native tool calls from provider response into IToolCallProposal format
-     * @param toolCalls Array of native tool calls from the provider
-     * @returns Array of IToolCallProposal ready for execution
-     */
-    parseNativeToolCalls(toolCalls: interfaces.INativeToolCall[]): interfaces.IToolCallProposal[];
-}