Configuration

import { CodeCallPlugin } from '@frontmcp/plugins';

CodeCallPlugin.init({
  // Tool visibility mode
  mode: 'codecall_only' | 'codecall_opt_in' | 'metadata_driven',

  // VM/sandbox configuration
  vm: { /* ... */ },

  // Embedding/search configuration
  embedding: { /* ... */ },

  // Tool filtering
  includeTools: (tool) => boolean,

  // Direct invoke configuration
  directCalls: { /* ... */ },
});

CodeCallPlugin.init({
  mode: 'codecall_only',
});

CodeCallPlugin.init({
  mode: 'codecall_opt_in',
});

CodeCallPlugin.init({
  mode: 'metadata_driven',
});

@Tool({
  name: 'users:list',
  description: 'List all users',
  codecall: {
    // Is this tool searchable and callable via CodeCall?
    enabledInCodeCall: true,  // default depends on mode

    // Is this tool visible in standard list_tools?
    visibleInListTools: false,  // default depends on mode

    // App ID for multi-app filtering (auto-detected if not set)
    appId: 'user-service',
  },
})

CodeCallPlugin.init({
  mode: 'codecall_only',

  // Only include tools matching this filter
  includeTools: (tool) => {
    // Exclude admin tools
    if (tool.name.startsWith('admin:')) return false;

    // Exclude destructive tools
    if (tool.metadata?.annotations?.destructiveHint) return false;

    // Include everything else
    return true;
  },
});

interface ToolEntry {
  name: string;
  fullName: string;
  metadata?: {
    description?: string;
    annotations?: {
      destructiveHint?: boolean;
      idempotentHint?: boolean;
      readOnlyHint?: boolean;
    };
    codecall?: {
      enabledInCodeCall?: boolean;
      visibleInListTools?: boolean;
      appId?: string;
    };
  };
  owner?: { id: string };
}

CodeCallPlugin.init({
  vm: {
    // Use a preset (recommended)
    preset: 'secure',

    // Or override individual settings
    timeoutMs: 5000,
    maxIterations: 10000,
    allowConsole: true,

    // Blocked identifiers (in addition to preset)
    disabledBuiltins: ['eval', 'Function'],
    disabledGlobals: ['process', 'require'],
  },
});

CodeCallPlugin.init({
  vm: {
    preset: 'secure',
    adapter: 'worker_threads',  // Enable Worker Pool

    workerPool: {
      minWorkers: 2,              // Minimum warm workers
      maxWorkers: 8,              // Maximum concurrent workers
      memoryLimitPerWorker: 128 * 1024 * 1024,  // 128MB per worker
      maxExecutionsPerWorker: 500,  // Recycle after N executions
      maxMessagesPerSecond: 500,    // Rate limit per worker
      maxPendingToolCalls: 50,      // Max concurrent tool calls
      idleTimeoutMs: 30000,         // Release idle workers after 30s
      queueTimeoutMs: 20000,        // Max queue wait time
      maxQueueSize: 50,             // Max pending executions
    },
  },
});

CodeCallPlugin.init({
  vm: {
    preset: 'secure',

    sidecar: {
      maxTotalSize: 64 * 1024 * 1024,     // 64MB total storage
      maxReferenceSize: 16 * 1024 * 1024,  // 16MB per reference
      extractionThreshold: 256 * 1024,     // Extract strings > 256KB
      maxResolvedSize: 32 * 1024 * 1024,   // 32MB max when resolving
      maxReferenceCount: 100,              // Max 100 references
      maxResolutionDepth: 10,              // Max nesting depth
      allowComposites: false,              // Block reference concatenation
    },
  },
});

CodeCallPlugin.init({
  embedding: {
    // Search strategy
    strategy: 'tfidf' | 'embedding',

    // TF-IDF specific
    similarityThreshold: 0.3,

    // Embedding specific (requires VectoriaDB)
    modelName: 'Xenova/all-MiniLM-L6-v2',
    cacheDir: './.cache/transformers',
  },
});

embedding: {
  strategy: 'tfidf',
  similarityThreshold: 0.3,  // Minimum score to include in results
}

embedding: {
  strategy: 'embedding',
  modelName: 'Xenova/all-MiniLM-L6-v2',  // Default
  cacheDir: './.cache/transformers',
  useHNSW: true,  // For large toolsets (1000+)
}

CodeCallPlugin.init({
  embedding: {
    strategy: 'tfidf',

    search: {
      // Term weighting (higher = more important)
      weights: {
        name: 2.0,         // Tool name matches
        description: 3.0,  // Description matches (most important)
        tags: 2.0,         // Tag matches
      },

      // Stop words to ignore during tokenization
      stopWords: ['the', 'a', 'an', 'is', 'are', 'to', 'for'],

      // Minimum score to include in results
      minScore: 0.25,

      // Maximum results to return
      maxResults: 10,
    },
  },
});

Tool: users:list
- Name match "users" + "list": 2.0 × 2 = 4.0
- Description "List all users in the system": 3.0 × 3 = 9.0
- Tags ["users", "list", "admin"]: 2.0 × 2 = 4.0
- Total: 17.0 (normalized)

CodeCallPlugin.init({
  embedding: {
    strategy: 'embedding',  // Better semantic matching

    search: {
      // Pre-filter by namespace before semantic search
      prefixFilter: true,

      // Use approximate nearest neighbor for speed
      useHNSW: true,
      hnswEfConstruction: 200,  // Index quality
      hnswEfSearch: 100,        // Search quality vs speed

      // Batch indexing for startup performance
      batchSize: 100,
    },
  },
});

CodeCallPlugin.init({
  directCalls: {
    // Enable/disable codecall:invoke
    enabled: true,

    // Optional: restrict to specific tools
    allowedTools: ['users:getById', 'billing:getInvoice'],

    // Optional: timeout for direct calls (default: 30s)
    timeoutMs: 30000,
  },
});

codecall:invoke (direct)
├─ Parse input: ~0.1ms
├─ Tool lookup: ~0.1ms
├─ Tool execution: ~varies
└─ Total overhead: ~0.2ms

codecall:execute (VM)
├─ Pre-scan: ~0.5ms
├─ AST validation: ~1-2ms
├─ Code transformation: ~0.5ms
├─ AI scoring: ~1ms (if enabled)
├─ VM execution: ~1-2ms
├─ Tool execution: ~varies
└─ Total overhead: ~4-6ms

{
  "status": "error",
  "error": {
    "code": "TOOL_NOT_FOUND",
    "message": "Tool 'users:delete' is not in the allowed list",
    "tool": "users:delete",
    "allowedTools": ["users:getById", "billing:getInvoice"]
  }
}

import { App } from '@frontmcp/sdk';
import { CodeCallPlugin } from '@frontmcp/plugins';

@App({
  id: 'my-app',
  plugins: [
    CodeCallPlugin.init({
      // Hide all tools, expose via CodeCall
      mode: 'codecall_only',

      // Filter out admin and destructive tools
      includeTools: (tool) => {
        if (tool.name.startsWith('admin:')) return false;
        if (tool.metadata?.annotations?.destructiveHint) return false;
        return true;
      },

      // Secure sandbox with custom timeout
      vm: {
        preset: 'secure',
        timeoutMs: 5000,  // 5 second timeout
        allowConsole: true,
      },

      // Fast TF-IDF search
      embedding: {
        strategy: 'tfidf',
        similarityThreshold: 0.25,
      },

      // Enable direct invocation for simple calls
      directCalls: {
        enabled: true,
        allowedTools: ['users:getById', 'health:ping'],
      },
    }),
  ],
})
export default class MyApp {}

CODECALL_VM_TIMEOUT=10000 CODECALL_MODE=codecall_opt_in npm start