dank-ai 1.0.32 → 1.0.33

package/lib/agent.js

@@ -6,7 +6,7 @@
  */
 
 const Joi = require('joi');
-const { DEFAULT_CONFIG, SUPPORTED_LLMS, DOCKER_CONFIG } = require('./constants');
+const { DEFAULT_CONFIG, SUPPORTED_LLMS, DOCKER_CONFIG, INSTANCE_TYPES } = require('./constants');
 const { ToolRegistry, ToolExecutor } = require('./tools');
 const builtinTools = require('./tools/builtin');
 
@@ -28,6 +28,11 @@ class DankAgent {
     if (config.enableBuiltinTools !== false) {
       this.registerBuiltinTools();
     }
+    
+    // Ensure instanceType has a default value if not set
+    if (!this.config.instanceType) {
+      this.config.instanceType = 'small';
+    }
   }
 
   /**
@@ -59,24 +64,59 @@ class DankAgent {
   }
 
   /**
-   * Set resource limits for the container
+   * Set instance type (small, medium, large, xlarge)
+   * @param {string} instanceType - Instance type string
    */
-  setResources(resources) {
-    const schema = Joi.object({
-      memory: Joi.string().pattern(/^\d+[mMgG]$/).default('512m'),
-      cpu: Joi.number().min(0.1).max(8).default(1),
-      timeout: Joi.number().min(1000).default(30000)
-    });
+  setInstanceType(instanceType) {
+    if (!instanceType || typeof instanceType !== 'string') {
+      throw new Error('Instance type must be a non-empty string');
+    }
 
-    const { error, value } = schema.validate(resources);
-    if (error) {
-      throw new Error(`Invalid resource configuration: ${error.message}`);
+    const normalizedType = instanceType.toLowerCase().trim();
+    
+    if (!INSTANCE_TYPES[normalizedType]) {
+      const validTypes = Object.keys(INSTANCE_TYPES).join(', ');
+      throw new Error(`Invalid instance type: "${instanceType}". Valid types are: ${validTypes}`);
     }
 
-    this.config.resources = { ...this.config.resources, ...value };
+    this.config.instanceType = normalizedType;
     return this;
   }
 
+  /**
+   * @deprecated Use setInstanceType() instead. This method is kept for backward compatibility.
+   * Set resource limits for the container
+   */
+  setResources(resources) {
+    // Map old resources format to instance type
+    if (resources && typeof resources === 'object') {
+      const memory = resources.memory || '512m';
+      const cpu = resources.cpu || 1;
+      
+      // Try to map to an instance type
+      let instanceType = 'small'; // default
+      
+      if (memory === '512m' && cpu === 1) {
+        instanceType = 'small';
+      } else if (memory === '1g' && cpu === 2) {
+        instanceType = 'medium';
+      } else if (memory === '2g' && cpu === 2) {
+        instanceType = 'large';
+      } else if (memory === '4g' && cpu === 4) {
+        instanceType = 'xlarge';
+      } else {
+        // For custom configurations, default to small and log a warning
+        console.warn(`⚠️  setResources() is deprecated. Using 'small' instance type. Please use setInstanceType('small'|'medium'|'large'|'xlarge') instead.`);
+        instanceType = 'small';
+      }
+      
+      return this.setInstanceType(instanceType);
+    }
+    
+    // If no resources provided, default to small
+    return this.setInstanceType('small');
+  }
+
   /**
    * Set Docker configuration including base image
    */
@@ -116,7 +156,6 @@ class DankAgent {
    */
   setPromptingServer(options = {}) {
     const schema = Joi.object({
-      protocol: Joi.string().valid('websocket', 'tcp', 'http').default('http'),
       port: Joi.number().min(1000).max(65535).default(3000),
       authentication: Joi.boolean().default(false),
       maxConnections: Joi.number().min(1).max(1000).default(50),
@@ -131,12 +170,13 @@ class DankAgent {
     // Set the port in docker config
     this.config.docker = { ...this.config.docker, port: value.port };
 
-    // Set the communication config (excluding port)
+    // Set the communication config (always HTTP, excluding port)
     const { port, ...communicationConfig } = value;
     this.config.communication = {
       ...this.config.communication,
       directPrompting: {
         enabled: true,
+        protocol: 'http', // Always HTTP
         ...communicationConfig
       }
     };
@@ -162,6 +202,8 @@ class DankAgent {
 
   /**
    * Enable HTTP server with Express.js
+   * Optional: Use this to configure HTTP options (port, CORS, rate limiting, etc.)
+   * HTTP auto-enables when routes are added, so this is only needed for custom configuration
    */
   enableHttp(options = {}) {
     const schema = Joi.object({
@@ -186,11 +228,15 @@ class DankAgent {
       throw new Error(`Invalid HTTP configuration: ${error.message}`);
     }
 
+    // Preserve existing routes and middleware if HTTP was already auto-enabled
+    const existingRoutes = this.config.http?.routes || new Map();
+    const existingMiddleware = this.config.http?.middleware || [];
+
     this.config.http = {
       enabled: true,
       ...value,
-      routes: new Map(),
-      middleware: []
+      routes: existingRoutes,
+      middleware: existingMiddleware
     };
 
     return this;
@@ -198,10 +244,24 @@ class DankAgent {
 
   /**
    * Add HTTP route handler
+   * Auto-enables HTTP server if not already enabled
    */
   addRoute(method, path, handler, options = {}) {
+    // Auto-enable HTTP if not already enabled
     if (!this.config.http || !this.config.http.enabled) {
-      throw new Error('HTTP server must be enabled before adding routes. Call enableHttp() first.');
+      this.config.http = {
+        enabled: true,
+        port: 3000,
+        host: '0.0.0.0',
+        cors: true,
+        rateLimit: {
+          windowMs: 15 * 60 * 1000,
+          max: 100,
+          message: 'Too many requests'
+        },
+        routes: new Map(),
+        middleware: []
+      };
     }
 
     if (typeof handler !== 'function') {
@@ -215,6 +275,11 @@ class DankAgent {
       throw new Error(`Invalid HTTP method: ${method}. Valid methods: ${validMethods.join(', ')}`);
     }
 
+    // Ensure routes Map exists
+    if (!this.config.http.routes) {
+      this.config.http.routes = new Map();
+    }
+
     const routeKey = `${upperMethod}:${path}`;
     
     if (!this.config.http.routes.has(routeKey)) {
@@ -239,10 +304,24 @@ class DankAgent {
 
   /**
    * Add HTTP middleware
+   * Auto-enables HTTP server if not already enabled
    */
   addMiddleware(middleware, options = {}) {
+    // Auto-enable HTTP if not already enabled
     if (!this.config.http || !this.config.http.enabled) {
-      throw new Error('HTTP server must be enabled before adding middleware. Call enableHttp() first.');
+      this.config.http = {
+        enabled: true,
+        port: 3000,
+        host: '0.0.0.0',
+        cors: true,
+        rateLimit: {
+          windowMs: 15 * 60 * 1000,
+          max: 100,
+          message: 'Too many requests'
+        },
+        routes: new Map(),
+        middleware: []
+      };
     }
 
     if (typeof middleware !== 'function') {
@@ -434,7 +513,7 @@ class DankAgent {
         ...this.config.communication,
         directPrompting: {
           enabled: finalEnabled,
-          protocol: currentDirectPrompting?.protocol || 'websocket',
+          protocol: 'http', // Always HTTP
           authentication: currentDirectPrompting?.authentication || false,
           maxConnections: currentDirectPrompting?.maxConnections || 100,
           timeout: currentDirectPrompting?.timeout || 30000
@@ -570,11 +649,7 @@ class DankAgent {
       
       prompt: Joi.string().optional(),
       
-      resources: Joi.object({
-        memory: Joi.string().pattern(/^\d+[mMgG]$/).default('512m'),
-        cpu: Joi.number().min(0.1).max(8).default(1),
-        timeout: Joi.number().min(1000).default(30000)
-      }).default({}),
+      instanceType: Joi.string().valid('small', 'medium', 'large', 'xlarge').default('small'),
       
       docker: Joi.object({
         baseImage: Joi.string().default(`${DOCKER_CONFIG.baseImagePrefix}:${DOCKER_CONFIG.defaultTag}`),
@@ -584,7 +659,7 @@ class DankAgent {
       communication: Joi.object({
         directPrompting: Joi.object({
           enabled: Joi.boolean().default(false),
-          protocol: Joi.string().valid('websocket', 'tcp', 'http').default('http'),
+          protocol: Joi.string().valid('http').default('http'), // Always HTTP, kept for backward compatibility
           authentication: Joi.boolean().default(false),
           maxConnections: Joi.number().min(1).max(1000).default(50),
           timeout: Joi.number().min(1000).default(30000)

package/lib/cli/init.js

@@ -320,20 +320,7 @@ Handle LLM interactions and modify prompts/responses:
 })
 \`\`\`
 
-### 2. HTTP API Events (\`tool:http-server\`)
-Handle HTTP requests and responses:
-
-\`\`\`javascript
-.addHandler('tool:http-server:call', (data) => {
-  console.log('HTTP request received:', data.method, data.path);
-})
-
-.addHandler('tool:http-server:response', (data) => {
-  console.log('HTTP response sent:', data.statusCode);
-})
-\`\`\`
-
-### 3. System Events
+### 2. System Events
 Handle agent lifecycle and errors:
 
 \`\`\`javascript

package/lib/cli/production-build.js

@@ -14,7 +14,6 @@ const analytics = require('../analytics');
 function extractAgentMetadata(agent, buildOptions, imageName) {
   const config = agent.config || {};
   const dockerConfig = config.docker || {};
-  const resources = config.resources || {};
   const communication = config.communication || {};
   const directPrompting = communication.directPrompting || {};
   const httpConfig = config.http || {};
@@ -39,12 +38,10 @@ function extractAgentMetadata(agent, buildOptions, imageName) {
     timeout: directPrompting.timeout || 30000
   } : null;
 
-  // Extract resources configuration
-  const resourcesConfig = {
-    memory: resources.memory || '512m',
-    cpu: resources.cpu || 1,
-    timeout: resources.timeout || 30000
-  };
+  // Extract resources configuration from instance type
+  const { AgentConfig } = require('../config');
+  const instanceType = config.instanceType || 'small';
+  const resourcesConfig = AgentConfig.getResourcesFromInstanceType(instanceType);
 
   // Extract HTTP server configuration if enabled
   const httpServer = httpConfig.enabled ? {
@@ -159,7 +156,8 @@ async function productionBuildCommand(options) {
           namespace: options.namespace || agentImageConfig.namespace,
           tagByAgent: Boolean(options.tagByAgent || agentImageConfig.tagByAgent),
           force: options.force || false,
-          push: options.push || false
+          push: options.push || false,
+          baseImageOverride: options.baseImageOverride || null
         };
         
         const result = await dockerManager.buildProductionImage(agent, buildOptions);

package/lib/config.js

@@ -3,7 +3,7 @@
  */
 
 const Joi = require('joi');
-const { SUPPORTED_LLMS } = require('./constants');
+const { SUPPORTED_LLMS, INSTANCE_TYPES } = require('./constants');
 
 class AgentConfig {
   /**
@@ -76,28 +76,22 @@ class AgentConfig {
   }
 
   /**
-   * Validate resource configuration
+   * Get resources (memory, cpu) from instance type
+   * @param {string} instanceType - Instance type (small, medium, large, xlarge)
+   * @returns {Object} Resources object with memory and cpu
    */
-  static validateResources(resources) {
-    const schema = Joi.object({
-      memory: Joi.string()
-        .pattern(/^\d+[mMgG]$/)
-        .default('512m')
-        .messages({
-          'string.pattern.base': 'Memory must be in format like "512m" or "1g"'
-        }),
-      cpu: Joi.number().min(0.1).max(32).default(1),
-      timeout: Joi.number().min(1000).default(30000),
-      maxRestarts: Joi.number().min(0).default(3),
-      healthCheckInterval: Joi.number().min(1000).default(10000)
-    });
-
-    const { error, value } = schema.validate(resources);
-    if (error) {
-      throw new Error(`Invalid resource configuration: ${error.message}`);
+  static getResourcesFromInstanceType(instanceType) {
+    const normalizedType = (instanceType || 'small').toLowerCase().trim();
+    const instanceConfig = INSTANCE_TYPES[normalizedType];
+    
+    if (!instanceConfig) {
+      throw new Error(`Invalid instance type: "${instanceType}". Valid types are: ${Object.keys(INSTANCE_TYPES).join(', ')}`);
     }
-
-    return value;
+    
+    return {
+      memory: instanceConfig.memory,
+      cpu: instanceConfig.cpu
+    };
   }
 
   /**
@@ -143,11 +137,13 @@ class AgentConfig {
     }
 
     // Add HTTP server environment variables
-    if (agent.config.http && agent.config.http.enabled) {
+    // HTTP is enabled if explicitly enabled OR if routes exist (auto-enabled)
+    const hasRoutes = agent.config.http?.routes && agent.config.http.routes.size > 0;
+    if (agent.config.http && (agent.config.http.enabled || hasRoutes)) {
       env.HTTP_ENABLED = 'true';
-      env.HTTP_PORT = agent.config.http.port.toString();
-      env.HTTP_HOST = agent.config.http.host;
-      env.HTTP_CORS = agent.config.http.cors.toString();
+      env.HTTP_PORT = (agent.config.http.port || 3000).toString();
+      env.HTTP_HOST = agent.config.http.host || '0.0.0.0';
+      env.HTTP_CORS = (agent.config.http.cors !== false).toString();
       
       if (agent.config.http.rateLimit) {
         env.HTTP_RATE_LIMIT = 'true';
@@ -158,20 +154,23 @@ class AgentConfig {
     }
 
     // Add direct prompting environment variables
+    // If setPromptingServer was called, it sets directPrompting.enabled = true
+    // The main HTTP server always runs, and /prompt endpoint is available if setPromptingServer was called
     if (agent.config.communication?.directPrompting?.enabled) {
       env.DIRECT_PROMPTING_ENABLED = 'true';
-      env.DIRECT_PROMPTING_PROTOCOL = agent.config.communication.directPrompting.protocol || 'websocket';
-      env.DIRECT_PROMPTING_MAX_CONNECTIONS = agent.config.communication.directPrompting.maxConnections?.toString() || '100';
-      env.DIRECT_PROMPTING_AUTHENTICATION = agent.config.communication.directPrompting.authentication?.toString() || 'false';
-      env.DIRECT_PROMPTING_TIMEOUT = agent.config.communication.directPrompting.timeout?.toString() || '30000';
+      env.DIRECT_PROMPTING_PROTOCOL = 'http'; // Always HTTP
+      env.DIRECT_PROMPTING_MAX_CONNECTIONS = agent.config.communication.directPrompting?.maxConnections?.toString() || '100';
+      env.DIRECT_PROMPTING_AUTHENTICATION = agent.config.communication.directPrompting?.authentication?.toString() || 'false';
+      env.DIRECT_PROMPTING_TIMEOUT = agent.config.communication.directPrompting?.timeout?.toString() || '30000';
     } else {
       env.DIRECT_PROMPTING_ENABLED = 'false';
     }
 
-    // Add main Docker port
-    if (agent.config.docker?.port) {
-      env.DOCKER_PORT = agent.config.docker.port.toString();
-    }
+    // Add main Docker port (always set, defaults to 3000 if not specified)
+    const dockerPort = agent.config.docker?.port || 3000;
+    env.DOCKER_PORT = dockerPort.toString();
+    // Health check uses the same port as the main agent port
+    env.HEALTH_PORT = dockerPort.toString();
 
     return env;
   }

package/lib/constants.js

@@ -19,15 +19,31 @@ const DEFAULT_CONFIG = {
     maxTokens: 1000
   },
   prompt: 'You are a helpful AI assistant.',
-  resources: {
-    memory: '512m',
-    cpu: 1,
-    timeout: 30000
-  },
+  instanceType: 'small',
   environment: {},
   custom: {}
 };
 
+// Instance type mappings: instanceType -> { memory, cpu }
+const INSTANCE_TYPES = {
+  small: {
+    memory: '512m',
+    cpu: 1
+  },
+  medium: {
+    memory: '1g',
+    cpu: 2
+  },
+  large: {
+    memory: '2g',
+    cpu: 2
+  },
+  xlarge: {
+    memory: '4g',
+    cpu: 4
+  }
+};
+
 const DOCKER_CONFIG = {
   baseImage: 'deltadarkly/dank-agent-base',
   baseImagePrefix: 'deltadarkly/dank-agent-base',
@@ -54,5 +70,6 @@ module.exports = {
   SUPPORTED_LLMS,
   DEFAULT_CONFIG,
   DOCKER_CONFIG,
-  AGENT_EVENTS
+  AGENT_EVENTS,
+  INSTANCE_TYPES
 };