onbuzz 4.1.0 → 4.3.0

package/src/tools/fileSystemTool.js

@@ -421,6 +421,38 @@ SECURITY:
 
     const { projectDir, agentId, directoryAccess } = context;
 
+    // Per-agent config overrides (agent.toolConfig.filesystem) merged
+    // with this tool's global defaults. Applied per-action at the top of
+    // the execute loop — every action that touches a file path is
+    // gated against the effective extension policy, and write/append
+    // payloads are size-gated against the effective maxFileSize.
+    const effectiveFs = this.getEffectiveConfig(context, {
+      allowedExtensions: this.allowedExtensions,
+      blockedExtensions: this.blockedExtensions,
+      maxFileSize: this.maxFileSize,
+    });
+    const effectiveBlockedExt = Array.isArray(effectiveFs.blockedExtensions)
+      ? effectiveFs.blockedExtensions.map(e => String(e).toLowerCase())
+      : [];
+    const effectiveAllowedExt = (Array.isArray(effectiveFs.allowedExtensions) && effectiveFs.allowedExtensions.length > 0)
+      ? effectiveFs.allowedExtensions.map(e => String(e).toLowerCase())
+      : null;
+    const effectiveMaxFileSize = (typeof effectiveFs.maxFileSize === 'number' && effectiveFs.maxFileSize > 0)
+      ? effectiveFs.maxFileSize
+      : this.maxFileSize;
+
+    const _checkExt = (filePath) => {
+      if (!filePath) return null;
+      const ext = (filePath.match(/\.[^./\\]+$/)?.[0] || '').toLowerCase();
+      if (effectiveBlockedExt.includes(ext)) {
+        return `File extension ${ext || '(none)'} is blocked by agent policy: ${filePath}`;
+      }
+      if (effectiveAllowedExt && !effectiveAllowedExt.includes(ext)) {
+        return `File extension ${ext || '(none)'} is not in the agent's allowed list: ${filePath}`;
+      }
+      return null;
+    };
+
     // Get directory access configuration from agent or create default
     const accessConfig = directoryAccess ||
       this.directoryAccessManager.createDirectoryAccess({
@@ -446,13 +478,47 @@ SECURITY:
     
     for (const action of actions) {
       try {
+        // Per-agent extension policy gate — runs BEFORE the action so
+        // disallowed file types never reach the filesystem layer. Terminal
+        // and web tools use the same short-circuit pattern.
+        const pathsToCheck = [action.filePath, action.outputPath].filter(Boolean);
+        for (const p of pathsToCheck) {
+          const err = _checkExt(p);
+          if (err) {
+            results.push({ success: false, action: action.type, error: err });
+            throw new Error('__skip');
+          }
+        }
+        // Per-agent maxFileSize gate for write/append — fires ONLY when
+        // the agent explicitly overrides maxFileSize via toolConfig. When
+        // the agent has no override, the existing `this.maxFileSize`
+        // check downstream handles it with its original error message,
+        // preserving backward compatibility. Read-side and stat-based
+        // size checks still use `this.maxFileSize` at deeper call sites.
+        const perAgentMaxFileSize = (typeof context?.toolConfig?.maxFileSize === 'number' && context.toolConfig.maxFileSize > 0)
+          ? context.toolConfig.maxFileSize
+          : null;
+        if (perAgentMaxFileSize != null
+            && (action.type === 'write' || action.type === 'append')
+            && typeof action.content === 'string') {
+          const payloadBytes = Buffer.byteLength(action.content, 'utf8');
+          if (payloadBytes > perAgentMaxFileSize) {
+            results.push({
+              success: false,
+              action: action.type,
+              error: `Content too large: ${payloadBytes} bytes exceeds per-agent maxFileSize (${perAgentMaxFileSize})`,
+            });
+            throw new Error('__skip');
+          }
+        }
+
         let result;
-        
+
         switch (action.type) {
           case 'read':
             result = await this.readFile(action.filePath, accessConfig, action.encoding);
             break;
-            
+
           case 'write':
             result = await this.writeFile(action.outputPath, action.content, accessConfig, {
               encoding: action.encoding,
@@ -501,6 +567,14 @@ SECURITY:
         this.addToHistory(action, result, context.agentId);
         
       } catch (error) {
+        // Per-agent policy gate above uses "__skip" to signal that it
+        // already pushed a useful error onto results — don't double-log
+        // or double-push.
+        if (error.message === '__skip') {
+          this.addToHistory(action, results[results.length - 1], context.agentId);
+          continue;
+        }
+
         // Log detailed error for debugging
         console.error(`[FileSystemTool] Action '${action.type}' failed:`, {
           action: action.type,

package/src/tools/imageTool.js

@@ -7,6 +7,7 @@ import path from 'path';
 import os from 'os';
 import { promises as fs } from 'fs';
 import { BaseTool } from './baseTool.js';
+import { getGalleryService } from '../services/galleryService.js';
 
 /**
  * Configuration constants for image generation
@@ -15,20 +16,50 @@ const IMAGE_CONFIG = {
   DEFAULT_MODEL: null, // Resolved dynamically from modelsService via aiService
   DEFAULT_SIZE: '1024x1024',
   DEFAULT_QUALITY: 'standard',
-  // Flux 1.1 Pro size constraints
+  // Flux-family size rules (used when the effective model matches FLUX_MODELS).
   SIZE_MIN: 256,
   SIZE_MAX: 1440,
   SIZE_INCREMENT: 32,  // Must be multiples of 32
-  // Common presets for convenience (all valid per constraints above)
+
+  /**
+   * Per-model size rules. Two kinds of rule:
+   *   { kind: 'enum',  values: ['1024x1024', ...] }      — exact match required
+   *   { kind: 'range', min, max, increment }             — W×H in grid
+   * Key matching is substring, case-insensitive (so 'gpt-image-1.5' matches
+   * 'gpt-image-1.5-preview', etc.). The first matching entry wins; anything
+   * else falls back to `default`.
+   *
+   * This table is the SINGLE SOURCE OF TRUTH for what the tool accepts
+   * client-side. Previously the validator was hardcoded to Flux rules and
+   * actively rejected valid gpt-image-1.5 sizes (1024x1536, 1536x1024, auto)
+   * while the tool's own docstring advertised them. See _validateParameters.
+   */
+  MODEL_SIZES: {
+    'gpt-image-1.5': { kind: 'enum',  values: ['1024x1024', '1024x1536', '1536x1024', 'auto'] },
+    'gpt-image-1':   { kind: 'enum',  values: ['1024x1024', '1024x1536', '1536x1024', 'auto'] },
+    'flux':          { kind: 'range', min: 256, max: 1440, increment: 32 },
+    'default':       { kind: 'range', min: 256, max: 1440, increment: 32 },
+  },
+
+  /**
+   * Size presets, model-aware. Each entry is a shape key; the resolver
+   * picks the variant for the effective model. If the model isn't listed,
+   * the `default` variant is used (Flux-shaped).
+   *
+   * Agents were previously confused because `portrait` → 1024x1440 always,
+   * even when the tool silently auto-switched to gpt-image-1.5 (where that
+   * size is invalid). Now `portrait` resolves to 1024x1536 for gpt-image.
+   */
   SIZE_PRESETS: {
-    'square': '1024x1024',
-    'square_hd': '1440x1440',
-    'portrait': '1024x1440',
-    'landscape': '1440x1024',
-    'portrait_4_3': '768x1024',
-    'landscape_4_3': '1024x768',
-    'small': '512x512'
+    'square':         { default: '1024x1024', 'gpt-image-1.5': '1024x1024' },
+    'square_hd':      { default: '1440x1440', 'gpt-image-1.5': '1024x1024' },
+    'portrait':       { default: '1024x1440', 'gpt-image-1.5': '1024x1536' },
+    'landscape':      { default: '1440x1024', 'gpt-image-1.5': '1536x1024' },
+    'portrait_4_3':   { default: '768x1024',  'gpt-image-1.5': '1024x1536' },
+    'landscape_4_3':  { default: '1024x768',  'gpt-image-1.5': '1536x1024' },
+    'small':          { default: '512x512',   'gpt-image-1.5': '1024x1024' },
   },
+
   VALID_FORMATS: ['png', 'jpg', 'jpeg', 'webp'],
   MAX_CONCURRENT: 3,
   QUEUE_LIMIT: 10,
@@ -37,6 +68,100 @@ const IMAGE_CONFIG = {
   DOWNLOAD_TIMEOUT: 60000 // 60 seconds
 };
 
+/**
+ * Resolve the effective model given the caller's inputs.
+ *
+ * The tool auto-switches to `gpt-image-1.5` when the caller asks for
+ * transparency or supplies a sourceImage (only gpt-image-1.5 supports
+ * those features). Previously this logic lived inside the async worker,
+ * AFTER _validateParameters ran — so validation applied Flux rules even
+ * when the real model would end up being gpt-image-1.5 and vice versa.
+ * Hoisted here so validators, error messages, and preset resolution all
+ * see the same truth.
+ *
+ * @param {object} params - imageParams with { model, transparency, sourceImage }
+ * @returns {string} — the effective model id (lowercase)
+ */
+export function resolveEffectiveImageModel(params = {}) {
+  const explicit = (params.model || '').toLowerCase();
+  if (explicit && explicit !== 'auto') return explicit;
+  if (params.transparency === true) return 'gpt-image-1.5';
+  if (params.sourceImage)            return 'gpt-image-1.5';
+  // Null → defer to downstream (aiService resolves from catalog). We
+  // still return a sentinel so validators can use `default` rules.
+  return '';
+}
+
+/**
+ * Translate an image-generation error into an actionable message for the
+ * agent. The backend (`aiService._generateImageOpenAI` / Flux) wraps HTTP
+ * responses as `"HTTP 400: Bad Request - <provider text>"` and throws.
+ * That passes through to the agent as raw stack text — agents don't know
+ * whether they tripped a size rule, a moderation rule, or something else.
+ *
+ * This helper parses the incoming `Error` for the common signatures and
+ * produces a message that includes (a) the effective model, (b) what
+ * class of failure it was, and (c) a concrete next-action.
+ *
+ * @param {Error}  error - Thrown from aiService / downstream
+ * @param {object} job   - The queued job (provides model + size + prompt)
+ * @returns {string}
+ */
+export function _translateImageError(error, job = {}) {
+  const raw = (error && error.message) || String(error || 'unknown error');
+  const effectiveModel = resolveEffectiveImageModel(job) || job.model || 'auto';
+  const size = job.size || IMAGE_CONFIG.DEFAULT_SIZE;
+  const lower = raw.toLowerCase();
+
+  // Content moderation family — providers use various phrasings.
+  if (/moderat|content[_ -]policy|safety|flagged|unsafe/.test(lower)) {
+    return (
+      `Image generation rejected by content moderation (model=${effectiveModel}). ` +
+      `The prompt was flagged. Rephrase rather than retrying verbatim: soften explicit ` +
+      `adjectives (e.g. drop "blood", "gore", "bones"), describe style instead of violence, ` +
+      `and avoid real-person likenesses. Original provider message: ${raw}`
+    );
+  }
+
+  // Size-shaped rejections from the provider (leaks through when our
+  // client-side validator missed, or when the catalogue changes).
+  if (/size|dimension|unsupported|out of range|must be one of|invalid image size/.test(lower)) {
+    const { rule } = _getModelSizeRule(effectiveModel);
+    const valid = rule.kind === 'enum'
+      ? `Valid sizes for ${effectiveModel}: ${rule.values.join(', ')}.`
+      : `Valid for ${effectiveModel}: WIDTHxHEIGHT in ${rule.min}-${rule.max}, multiples of ${rule.increment}.`;
+    return (
+      `Image generation rejected: size "${size}" not accepted by ${effectiveModel}. ${valid} ` +
+      `Original provider message: ${raw}`
+    );
+  }
+
+  // Auth / quota.
+  if (/unauthorized|forbidden|quota|rate.?limit|429|401|403/.test(lower)) {
+    return (
+      `Image generation failed for ${effectiveModel}: authentication or quota problem. ` +
+      `Retrying with the same inputs will likely fail again — check API keys / billing. ` +
+      `Original: ${raw}`
+    );
+  }
+
+  // Fall-through: still tell the agent which model ran.
+  return `Image generation failed (model=${effectiveModel}, size=${size}): ${raw}`;
+}
+
+/**
+ * Look up the size rule for an effective model id. Substring match.
+ * Always returns a rule (falls back to `default`).
+ */
+export function _getModelSizeRule(effectiveModel) {
+  const key = String(effectiveModel || '').toLowerCase();
+  for (const [needle, rule] of Object.entries(IMAGE_CONFIG.MODEL_SIZES)) {
+    if (needle === 'default') continue;
+    if (key.includes(needle)) return { modelKey: needle, rule };
+  }
+  return { modelKey: 'default', rule: IMAGE_CONFIG.MODEL_SIZES.default };
+}
+
 /**
  * ImageTool - Generate images using AI models
  * Supports queueing, async processing, and both temp/project directory storage
@@ -140,20 +265,34 @@ export class ImageTool extends BaseTool {
 **Parameters:**
 - **prompt** (required): Description of image to generate OR editing instruction
 - **outputPath** (optional): Path to save image (permanent). Omit for temp file.
-- **size** (optional): Custom WIDTHxHEIGHT or preset name (default: 1024x1024)
-  - For Flux models: 256-1440px, multiples of 32 (e.g., 1024x768, 1280x960)
-  - For gpt-image-1.5: 1024x1024, 1024x1536, 1536x1024, or "auto"
-  - Presets: square (1024x1024), square_hd (1440x1440), portrait (1024x1440), landscape (1440x1024), portrait_4_3 (768x1024), landscape_4_3 (1024x768), small (512x512)
+- **size** (optional): WIDTHxHEIGHT or preset name. DIFFERENT MODELS ACCEPT DIFFERENT SIZES — read the rules below. Default: 1024x1024.
 - **quality** (optional): "standard" or "hd" (default: standard)
-- **model** (optional): Use "gpt-image-1.5" for transparency and editing capabilities (default: auto)
-- **sourceImage** (optional): Path to source image for editing (enables edit mode)
+- **model** (optional): "gpt-image-1.5" or a flux variant. Default: auto. Auto-switches to gpt-image-1.5 if transparency=true OR sourceImage is set.
+- **sourceImage** (optional): Path to source image for editing (forces gpt-image-1.5)
 - **mask** (optional): Path to mask image for editing (white=edit area, black=keep area)
-- **transparency** (optional): true to generate image with transparent background (auto-selects gpt-image-1.5)
+- **transparency** (optional): true to generate with transparent background (forces gpt-image-1.5)
+
+⚠ SIZE RULES — read before picking a size:
+
+  (A) gpt-image-1.5 (auto-selected on transparency=true or sourceImage, or set explicitly):
+      size MUST be one of: 1024x1024, 1024x1536 (portrait), 1536x1024 (landscape), or "auto".
+      Any other value is rejected; the error lists the valid options.
+      Presets remap automatically — e.g. "portrait" → 1024x1536 on this model.
+
+  (B) Flux models (the default when transparency is not required):
+      size must be WIDTHxHEIGHT, both in 256-1440, both multiples of 32 (e.g. 1024x768, 1280x960).
+      "auto" is NOT valid for Flux.
+
+Presets (shape names — resolved per the chosen model):
+  square, square_hd, portrait, landscape, portrait_4_3, landscape_4_3, small
+
+Content moderation:
+- Prompts with graphic violence, gore, explicit sexual content, or real-person likenesses are commonly rejected by the provider as "Bad request". If you hit one of those, REPHRASE — don't retry verbatim. Soften explicit adjectives (e.g. "dark fantasy queen with crimson rubies" works; "blood tears, bone crown, dripping" typically doesn't).
 
 **Notes:**
 - Images take 15-30 seconds to generate
 - Be descriptive in prompts for better results
-- Use **gpt-image-1.5** when you need: transparent backgrounds, image editing, or image-to-image transformations
+- Use gpt-image-1.5 when you need transparent backgrounds, image editing, or image-to-image transformations
 - Max ${IMAGE_CONFIG.QUEUE_LIMIT} images in queue`;
   }
 
@@ -335,6 +474,10 @@ export class ImageTool extends BaseTool {
           quality: imageParams.quality,
           projectDir: projectDir || process.cwd(),
           directoryAccess,
+          // Carry the caller's per-agent image-gen config onto the job
+          // so the async processor (which doesn't have the original
+          // context) can still honor `saveToGallery` etc.
+          toolConfig: context?.toolConfig || null,
           status: 'queued',
           createdAt: new Date().toISOString()
         };
@@ -402,35 +545,88 @@ export class ImageTool extends BaseTool {
         throw new Error(`Prompt too long (max ${IMAGE_CONFIG.MAX_PROMPT_LENGTH} characters)`);
       }
 
-      if (img.size) {
-        // Check for preset names first
-        if (IMAGE_CONFIG.SIZE_PRESETS[img.size]) {
-          img.size = IMAGE_CONFIG.SIZE_PRESETS[img.size];
-        }
+      // Resolve the effective model FIRST so size validation, preset
+      // resolution, and error messages all see the model that will
+      // actually run. Previously this logic lived downstream in the
+      // async worker so Flux rules were applied even when the tool
+      // would silently switch to gpt-image-1.5 (transparency=true,
+      // sourceImage set, or explicit model) — and vice versa.
+      const effectiveModel = resolveEffectiveImageModel(img);
+      const { modelKey: ruleKey, rule } = _getModelSizeRule(effectiveModel);
 
-        // Validate WxH format
-        const sizeMatch = img.size.match(/^(\d+)x(\d+)$/);
-        if (!sizeMatch) {
-          throw new Error(`Invalid size format: ${img.size}. Use WIDTHxHEIGHT (e.g., 1024x768) or preset: ${Object.keys(IMAGE_CONFIG.SIZE_PRESETS).join(', ')}`);
+      if (img.size) {
+        // Step 1: expand preset names. Presets are model-aware — e.g.
+        // `portrait` is 1024x1440 on Flux but 1024x1536 on gpt-image-1.5
+        // (the latter only accepts specific enum values). Previously the
+        // preset was resolved Flux-shaped and then rejected downstream.
+        const presetEntry = IMAGE_CONFIG.SIZE_PRESETS[img.size];
+        if (presetEntry) {
+          img.size = presetEntry[ruleKey] || presetEntry.default;
         }
 
-        const width = parseInt(sizeMatch[1], 10);
-        const height = parseInt(sizeMatch[2], 10);
-
-        // Validate constraints
-        const { SIZE_MIN, SIZE_MAX, SIZE_INCREMENT } = IMAGE_CONFIG;
-
-        if (width < SIZE_MIN || width > SIZE_MAX) {
-          throw new Error(`Width ${width} out of range. Must be ${SIZE_MIN}-${SIZE_MAX}px.`);
-        }
-        if (height < SIZE_MIN || height > SIZE_MAX) {
-          throw new Error(`Height ${height} out of range. Must be ${SIZE_MIN}-${SIZE_MAX}px.`);
-        }
-        if (width % SIZE_INCREMENT !== 0) {
-          throw new Error(`Width ${width} must be a multiple of ${SIZE_INCREMENT}.`);
-        }
-        if (height % SIZE_INCREMENT !== 0) {
-          throw new Error(`Height ${height} must be a multiple of ${SIZE_INCREMENT}.`);
+        // Step 2: per-model rule check.
+        if (rule.kind === 'enum') {
+          // gpt-image-1.5 et al — exact enum.
+          if (!rule.values.includes(img.size)) {
+            const modelLabel = effectiveModel || 'gpt-image-1.5';
+            const autoHint = img.transparency
+              ? ' (auto-selected because transparency=true)'
+              : img.sourceImage
+                ? ' (auto-selected because sourceImage was provided)'
+                : '';
+            throw new Error(
+              `Image size "${img.size}" is not supported by ${modelLabel}${autoHint}. ` +
+              `Valid sizes: ${rule.values.join(', ')}. ` +
+              `For portrait orientation use "1024x1536"; for landscape use "1536x1024".`
+            );
+          }
+        } else {
+          // Range rule (Flux and default). `auto` is an enum-only value
+          // that makes no sense for a range model — reject with a hint.
+          if (img.size === 'auto') {
+            throw new Error(
+              `Image size "auto" is only valid for gpt-image-1.5. ` +
+              `For the current model (${effectiveModel || 'flux'}) pick a WIDTHxHEIGHT ` +
+              `between ${rule.min} and ${rule.max} in ${rule.increment}-pixel steps ` +
+              `(e.g. 1024x1024).`
+            );
+          }
+          const sizeMatch = img.size.match(/^(\d+)x(\d+)$/);
+          if (!sizeMatch) {
+            throw new Error(
+              `Invalid size format: "${img.size}". ` +
+              `Use WIDTHxHEIGHT (e.g. 1024x768) or one of these presets: ` +
+              `${Object.keys(IMAGE_CONFIG.SIZE_PRESETS).join(', ')}.`
+            );
+          }
+          const width  = parseInt(sizeMatch[1], 10);
+          const height = parseInt(sizeMatch[2], 10);
+          const { min, max, increment } = rule;
+          const modelLabel = effectiveModel || 'flux';
+          if (width < min || width > max) {
+            throw new Error(
+              `Width ${width} out of range for ${modelLabel}. Must be ${min}-${max}px ` +
+              `(multiple of ${increment}).`
+            );
+          }
+          if (height < min || height > max) {
+            throw new Error(
+              `Height ${height} out of range for ${modelLabel}. Must be ${min}-${max}px ` +
+              `(multiple of ${increment}).`
+            );
+          }
+          if (width % increment !== 0) {
+            throw new Error(
+              `Width ${width} must be a multiple of ${increment} for ${modelLabel}. ` +
+              `Nearest valid: ${Math.round(width / increment) * increment}.`
+            );
+          }
+          if (height % increment !== 0) {
+            throw new Error(
+              `Height ${height} must be a multiple of ${increment} for ${modelLabel}. ` +
+              `Nearest valid: ${Math.round(height / increment) * increment}.`
+            );
+          }
         }
       }
 
@@ -492,6 +688,42 @@ export class ImageTool extends BaseTool {
             // Image was saved successfully - use our server endpoint
             imageUrl = this._convertToWebUrl(result.resolvedOutputPath, job.sessionId);
             this.logger?.info('Using local server URL for image', { imageUrl });
+
+            // Durable gallery copy (non-blocking, non-fatal).
+            // Gated by per-agent `toolConfig.image-gen.saveToGallery`.
+            // Default is ON — users who want to keep disk usage down can
+            // opt out via the image-gen configurator in the agent modal.
+            const saveToGallery = job.toolConfig?.saveToGallery !== false;
+            if (saveToGallery) {
+              try {
+                let agentName = null;
+                if (this.agentPool && job.agentId) {
+                  try {
+                    const a = await this.agentPool.getAgent(job.agentId);
+                    agentName = a?.name || null;
+                  } catch { /* non-fatal */ }
+                }
+                await getGalleryService(this.logger).saveImage({
+                  sourcePath: result.resolvedOutputPath,
+                  metadata: {
+                    prompt: job.prompt,
+                    model: job.model,
+                    size: job.size,
+                    quality: job.quality,
+                    agentId: job.agentId,
+                    agentName,
+                    sessionId: job.sessionId,
+                    jobId: job.jobId,
+                    createdAt: job.completedAt || job.createdAt,
+                  },
+                });
+              } catch (galErr) {
+                this.logger?.warn?.('Gallery save failed (non-fatal)', {
+                  jobId: job.jobId,
+                  error: galErr.message,
+                });
+              }
+            }
           } else if (result.temporaryUrl) {
             // Download failed - use temporary AI-generated URL (expires in ~1 hour)
             imageUrl = result.temporaryUrl;
@@ -619,7 +851,13 @@ export class ImageTool extends BaseTool {
         this.logger?.error(`Image generation failed: ${job.jobId}`, error);
 
         job.status = 'failed';
-        job.error = error.message;
+        // Translate opaque backend errors into something actionable. The
+        // downstream aiService wraps HTTP errors as "HTTP 400: Bad Request - …"
+        // with the provider text tacked on; agents previously saw that
+        // verbatim and had to guess whether it was a size mismatch, a
+        // content-policy trip, or an auth problem. Route known signals
+        // to a structured hint.
+        job.error = _translateImageError(error, job);
         job.completedAt = new Date().toISOString();
 
         this.completedJobs.set(job.jobId, job);

package/src/tools/memoryTool.js

@@ -675,6 +675,10 @@ BEST PRACTICES:
       // read-only window selectors (sub-message granularity)
       lineFrom: params.lineFrom, lineTo: params.lineTo,
       contentFrom: params.contentFrom, contentTo: params.contentTo,
+      // Opt-in reasoning-content inclusion (default off — chain-of-thought
+      // text can be very long; agents ask for it only when they actually
+      // want to inspect what the model was thinking).
+      includeReasoning: !!params.includeReasoning,
     };
 
     let result;

package/src/tools/taskManagerTool.js

@@ -576,10 +576,21 @@ Always use a detailed task description to provide context for the task, and leve
       };
 
     } catch (error) {
+      // IMPORTANT: do NOT log the raw `context` object. The tool-execute
+      // context contains back-references to AgentPool ⇄ MessageProcessor
+      // (plus agentPool.messageProcessor.agentPool…), which triggers
+      // "Converting circular structure to JSON" in the logger's
+      // JSON.stringify — and THAT throw escapes this catch, corrupting
+      // the error surfaced to the agent. Pluck only plain-data fields.
+      // Regression guard: src/utilities/logger.js also has a defensive
+      // replacer that strips known back-ref keys if anyone else leaks a
+      // context-shaped object into logs.
       this.logger?.error('TaskManager execution failed', {
         error: error.message,
-        context,
-        params
+        stack: error.stack,
+        agentId: context?.agentId,
+        action: params?.action,
+        paramKeys: params ? Object.keys(params) : [],
       });
 
       return {

package/src/tools/terminalTool.js

@@ -423,9 +423,49 @@ After each invocation you will get a tool-result embedded in the following user
   async execute(params, context) {
     const { actions, timeout: customTimeout, async: forceAsync } = params;
     const { agentId, projectDir, directoryAccess } = context;
-    
+
+    // Per-agent terminal config overrides (agent.toolConfig.terminal).
+    // Falls back to this.config-level lists from constructor (global
+    // defaults). If neither is set, allowedCommands is null (=any) and
+    // blockedCommands is the class-default set from the constructor.
+    const effectiveConfig = this.getEffectiveConfig(context, {
+      allowedCommands: this.allowedCommands,
+      blockedCommands: this.blockedCommands,
+      maxBackgroundCommandsPerAgent: this.MAX_BACKGROUND_COMMANDS_PER_AGENT,
+    });
+    const allowedOverride = Array.isArray(effectiveConfig.allowedCommands)
+      ? effectiveConfig.allowedCommands
+      : this.allowedCommands;
+    const blockedOverride = Array.isArray(effectiveConfig.blockedCommands)
+      ? effectiveConfig.blockedCommands
+      : this.blockedCommands;
+
+    // Re-validate each run-command action against the per-agent rules.
+    // customValidateParameters() runs BEFORE execute and cannot see the
+    // context, so it only applies global rules. This pass catches
+    // commands that the per-agent overrides forbid.
+    for (const action of actions) {
+      if (action.type === 'run-command' && typeof action.command === 'string') {
+        if (this._matchesAny(action.command, blockedOverride)) {
+          return {
+            success: false,
+            error: `Command is blocked by agent policy: ${action.command}`,
+            actions: [],
+          };
+        }
+        if (allowedOverride && allowedOverride.length > 0
+            && !this._matchesAny(action.command, allowedOverride, { prefix: true })) {
+          return {
+            success: false,
+            error: `Command is not in the agent's allowed list: ${action.command}`,
+            actions: [],
+          };
+        }
+      }
+    }
+
     // Get directory access configuration from agent or create default
-    const accessConfig = directoryAccess || 
+    const accessConfig = directoryAccess ||
       this.directoryAccessManager.createDirectoryAccess({
         workingDirectory: projectDir || process.cwd(),
         writeEnabledDirectories: [projectDir || process.cwd()],
@@ -1079,6 +1119,26 @@ After each invocation you will get a tool-result embedded in the following user
     }
   }
 
+  /**
+   * Test if a command matches ANY pattern in a list. Patterns match if:
+   *   - exact equality (case-insensitive), OR
+   *   - command starts with `${pattern} ` (the base command matches).
+   *
+   * Shared helper used by the per-agent config check in execute(). The
+   * class-level isBlockedCommand/isAllowedCommand still exist for the
+   * pre-execute validator pass.
+   * @private
+   */
+  _matchesAny(command, patterns, _opts = {}) {
+    if (!Array.isArray(patterns) || patterns.length === 0) return false;
+    const cmd = (command || '').toLowerCase().trim();
+    const base = cmd.split(' ')[0];
+    return patterns.some((p) => {
+      const pat = (p || '').toLowerCase();
+      return pat === cmd || pat === base || cmd.startsWith(pat + ' ');
+    });
+  }
+
   /**
    * Check if command is blocked for security
    * @private