Configuration

import { CodeCallPlugin } from '@frontmcp/plugin-codecall';

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

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

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

  // Search results per query when a codecall:search call names no topK (default 8)
  topK: 8,

  // Most tools one codecall:describe call describes (default 8); a call that would describe more is refused
  maxDefinitions: 8,

  // 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, and callable directly with tools/call?
    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 tools tagged as destructive
    if (tool.tags?.includes('destructive')) return false;

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

interface IncludeToolsFilterToolInfo {
  name: string;          // the tool's own name, e.g. 'admin:deleteUser' — never prefixed with the app id
  fullName?: string;     // the qualified name, e.g. 'crm:admin:deleteUser'
  appId?: string;        // the owning app's id, also for tools the app's adapters and plugins provide
  source?: string;       // codecall.source
  description?: string;
  tags?: string[];       // codecall.tags, falling back to the tool's tags
  annotations?: Readonly<{ readOnlyHint?: boolean; destructiveHint?: boolean; /* ... */ }>;
  metadata?: Readonly<Record<string, unknown>>; // the tool's declared metadata (annotations, tags, codecall, ...)
}

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

    // Or override individual settings
    timeoutMs: 5000,
    maxSteps: 10000,
    allowLoops: true, // for and for-of; false allows for-of only

    // Names a script may not use, refused before it runs
    disabledBuiltins: ['eval', 'Function', 'parseInt'],
    disabledGlobals: ['process', 'require', 'JSON'],
  },
});

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

  sidecar: {
    enabled: true,                       // opt-in (default: false)
    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
    allowComposites: false,              // Block reference concatenation
  },
});

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

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

    // TF-IDF only: expand queries with synonyms ("add issue" finds create_ticket); false turns it off
    synonymExpansion: { enabled: true },
  },
});

embedding: {
  strategy: 'tfidf',
}

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

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

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

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
├─ VM execution: ~1-2ms
├─ Tool execution: ~varies
└─ Total overhead: ~3-5ms

{
  "content": [
    { "type": "text", "text": "Tool \"users:delete\" is not available. Use codecall:search to discover available tools." }
  ],
  "isError": true
}

import { App } from '@frontmcp/sdk';
import { CodeCallPlugin } from '@frontmcp/plugin-codecall';

@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.tags?.includes('destructive')) return false;
        return true;
      },

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

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

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