@frontmcp/plugin-codecall 0.0.1 → 0.7.0

package/index.js

@@ -0,0 +1,2668 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+
+// plugins/plugin-codecall/src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CodeCallPlugin: () => CodeCallPlugin,
+  codeCallDirectCallsOptionsSchema: () => codeCallDirectCallsOptionsSchema,
+  codeCallEmbeddingOptionsSchema: () => codeCallEmbeddingOptionsSchema,
+  codeCallModeSchema: () => codeCallModeSchema,
+  codeCallPluginOptionsSchema: () => codeCallPluginOptionsSchema,
+  codeCallSidecarOptionsSchema: () => codeCallSidecarOptionsSchema,
+  codeCallVmOptionsSchema: () => codeCallVmOptionsSchema,
+  codeCallVmPresetSchema: () => codeCallVmPresetSchema,
+  default: () => CodeCallPlugin,
+  embeddingStrategySchema: () => embeddingStrategySchema,
+  synonymExpansionConfigSchema: () => synonymExpansionConfigSchema
+});
+module.exports = __toCommonJS(index_exports);
+
+// plugins/plugin-codecall/src/codecall.plugin.ts
+var import_sdk7 = require("@frontmcp/sdk");
+
+// plugins/plugin-codecall/src/codecall.types.ts
+var import_zod = require("zod");
+var directCallsFilterSchema = import_zod.z.custom((val) => typeof val === "function", {
+  message: "filter must be a function with signature (tool: DirectCallsFilterToolInfo) => boolean"
+});
+var includeToolsFilterSchema = import_zod.z.custom((val) => typeof val === "function", {
+  message: "includeTools must be a function with signature (tool: IncludeToolsFilterToolInfo) => boolean"
+});
+var codeCallModeSchema = import_zod.z.enum(["codecall_only", "codecall_opt_in", "metadata_driven"]).default("codecall_only");
+var codeCallVmPresetSchema = import_zod.z.enum(["locked_down", "secure", "balanced", "experimental"]).default("secure");
+var DEFAULT_VM_OPTIONS = {
+  preset: "secure"
+};
+var codeCallVmOptionsSchema = import_zod.z.object({
+  /**
+   * CSP-like preset; see README.
+   * @default 'secure'
+   */
+  preset: codeCallVmPresetSchema,
+  /**
+   * Timeout for script execution in milliseconds
+   * Defaults vary by preset
+   */
+  timeoutMs: import_zod.z.number().positive().optional(),
+  /**
+   * Allow loop constructs (for, while, do-while)
+   * Defaults vary by preset
+   */
+  allowLoops: import_zod.z.boolean().optional(),
+  /**
+   * Maximum number of steps (if applicable)
+   * Defaults vary by preset
+   */
+  maxSteps: import_zod.z.number().positive().optional(),
+  /**
+   * List of disabled builtin functions
+   * Defaults vary by preset
+   */
+  disabledBuiltins: import_zod.z.array(import_zod.z.string()).optional(),
+  /**
+   * List of disabled global variables
+   * Defaults vary by preset
+   */
+  disabledGlobals: import_zod.z.array(import_zod.z.string()).optional(),
+  /**
+   * Allow console.log/warn/error
+   * Defaults vary by preset
+   */
+  allowConsole: import_zod.z.boolean().optional()
+}).default(() => DEFAULT_VM_OPTIONS);
+var codeCallDirectCallsOptionsSchema = import_zod.z.object({
+  /**
+   * Enable/disable the `codecall.invoke` meta-tool.
+   */
+  enabled: import_zod.z.boolean(),
+  /**
+   * Optional allowlist of tool names.
+   */
+  allowedTools: import_zod.z.array(import_zod.z.string()).optional(),
+  /**
+   * Optional advanced filter function.
+   * Signature: (tool: DirectCallsFilterToolInfo) => boolean
+   */
+  filter: directCallsFilterSchema.optional()
+});
+var embeddingStrategySchema = import_zod.z.enum(["tfidf", "ml"]).default("tfidf");
+var synonymExpansionConfigSchema = import_zod.z.object({
+  /**
+   * Enable/disable synonym expansion for TF-IDF search.
+   * When enabled, queries are expanded with synonyms to improve relevance.
+   * For example, "add user" will also match tools containing "create user".
+   * @default true
+   */
+  enabled: import_zod.z.boolean().default(true),
+  /**
+   * Additional synonym groups beyond the defaults.
+   * Each group is an array of related terms that should be treated as equivalent.
+   * @example [['customer', 'client', 'buyer'], ['order', 'purchase', 'transaction']]
+   */
+  additionalSynonyms: import_zod.z.array(import_zod.z.array(import_zod.z.string())).optional(),
+  /**
+   * Replace default synonyms entirely with additionalSynonyms.
+   * @default false
+   */
+  replaceDefaults: import_zod.z.boolean().default(false),
+  /**
+   * Maximum number of synonym expansions per term.
+   * Prevents query explosion for terms with many synonyms.
+   * @default 5
+   */
+  maxExpansionsPerTerm: import_zod.z.number().positive().default(5)
+}).default({ enabled: true, replaceDefaults: false, maxExpansionsPerTerm: 5 });
+var DEFAULT_EMBEDDING_OPTIONS = {
+  strategy: "tfidf",
+  modelName: "Xenova/all-MiniLM-L6-v2",
+  cacheDir: "./.cache/transformers",
+  useHNSW: false,
+  synonymExpansion: { enabled: true, replaceDefaults: false, maxExpansionsPerTerm: 5 }
+};
+var codeCallEmbeddingOptionsSchema = import_zod.z.object({
+  /**
+   * Embedding strategy to use for tool search
+   * - 'tfidf': Lightweight, synchronous TF-IDF based search (no ML models required)
+   * - 'ml': ML-based semantic search using transformers.js (better quality, requires model download)
+   * @default 'tfidf'
+   */
+  strategy: embeddingStrategySchema.optional(),
+  /**
+   * Model name for ML-based embeddings (only used when strategy='ml')
+   * @default 'Xenova/all-MiniLM-L6-v2'
+   */
+  modelName: import_zod.z.string().optional(),
+  /**
+   * Cache directory for ML models (only used when strategy='ml')
+   * @default './.cache/transformers'
+   */
+  cacheDir: import_zod.z.string().optional(),
+  /**
+   * Enable HNSW index for faster search (only used when strategy='ml')
+   * When enabled, provides O(log n) search instead of O(n) brute-force
+   * @default false
+   */
+  useHNSW: import_zod.z.boolean().optional(),
+  /**
+   * Synonym expansion configuration for TF-IDF search.
+   * When enabled, queries like "add user" will match tools for "create user".
+   * Only applies when strategy is 'tfidf' (ML already handles semantic similarity).
+   * Set to false to disable, or provide a config object to customize.
+   * @default { enabled: true }
+   */
+  synonymExpansion: import_zod.z.union([import_zod.z.literal(false), synonymExpansionConfigSchema]).optional()
+}).optional().transform((opts) => ({
+  strategy: opts?.strategy ?? DEFAULT_EMBEDDING_OPTIONS.strategy,
+  modelName: opts?.modelName ?? DEFAULT_EMBEDDING_OPTIONS.modelName,
+  cacheDir: opts?.cacheDir ?? DEFAULT_EMBEDDING_OPTIONS.cacheDir,
+  useHNSW: opts?.useHNSW ?? DEFAULT_EMBEDDING_OPTIONS.useHNSW,
+  synonymExpansion: opts?.synonymExpansion ?? DEFAULT_EMBEDDING_OPTIONS.synonymExpansion
+}));
+var codeCallSidecarOptionsSchema = import_zod.z.object({
+  /**
+   * Enable pass-by-reference support via sidecar
+   * When enabled, large strings are automatically lifted to a sidecar
+   * and resolved at the callTool boundary
+   * @default false
+   */
+  enabled: import_zod.z.boolean().default(false),
+  /**
+   * Maximum total size of all stored references in bytes
+   * @default 16MB (from security level)
+   */
+  maxTotalSize: import_zod.z.number().positive().optional(),
+  /**
+   * Maximum size of a single reference in bytes
+   * @default 4MB (from security level)
+   */
+  maxReferenceSize: import_zod.z.number().positive().optional(),
+  /**
+   * Threshold in bytes to trigger extraction from source code
+   * Strings larger than this are lifted to the sidecar
+   * @default 64KB (from security level)
+   */
+  extractionThreshold: import_zod.z.number().positive().optional(),
+  /**
+   * Maximum expanded size when resolving references for tool calls
+   * @default 8MB (from security level)
+   */
+  maxResolvedSize: import_zod.z.number().positive().optional(),
+  /**
+   * Whether to allow composite handles from string concatenation
+   * If false, concatenating references throws an error
+   * @default false (strict mode)
+   */
+  allowComposites: import_zod.z.boolean().optional(),
+  /**
+   * Maximum script length (in characters) when sidecar is disabled
+   * Prevents large inline data from being embedded in script
+   * If null, no limit is enforced
+   * @default 64KB
+   */
+  maxScriptLengthWhenDisabled: import_zod.z.number().positive().nullable().default(64 * 1024)
+}).default(() => ({
+  enabled: false,
+  maxScriptLengthWhenDisabled: 64 * 1024
+}));
+var codeCallPluginOptionsObjectSchema = import_zod.z.object({
+  /**
+   * CodeCall mode
+   * @default 'codecall_only'
+   */
+  mode: codeCallModeSchema,
+  /**
+   * Default number of tools to return in search results
+   * @default 8
+   */
+  topK: import_zod.z.number().positive().default(8),
+  /**
+   * Maximum number of tool definitions to include
+   * @default 8
+   */
+  maxDefinitions: import_zod.z.number().positive().default(8),
+  /**
+   * Optional filter function for including tools.
+   * Signature: (tool: IncludeToolsFilterToolInfo) => boolean
+   */
+  includeTools: includeToolsFilterSchema.optional(),
+  /**
+   * Direct calls configuration
+   */
+  directCalls: codeCallDirectCallsOptionsSchema.optional(),
+  /**
+   * VM execution options
+   */
+  vm: codeCallVmOptionsSchema,
+  /**
+   * Embedding configuration for tool search
+   */
+  embedding: codeCallEmbeddingOptionsSchema,
+  /**
+   * Sidecar (pass-by-reference) configuration
+   * When enabled, large data is stored outside the sandbox and resolved at callTool boundary
+   */
+  sidecar: codeCallSidecarOptionsSchema
+});
+var DEFAULT_PLUGIN_OPTIONS = {
+  mode: "codecall_only",
+  topK: 8,
+  maxDefinitions: 8,
+  vm: DEFAULT_VM_OPTIONS,
+  embedding: DEFAULT_EMBEDDING_OPTIONS,
+  sidecar: {
+    enabled: false,
+    maxScriptLengthWhenDisabled: 64 * 1024
+  }
+};
+var codeCallPluginOptionsSchema = codeCallPluginOptionsObjectSchema.prefault(DEFAULT_PLUGIN_OPTIONS);
+
+// plugins/plugin-codecall/src/services/tool-search.service.ts
+var import_vectoriadb = require("vectoriadb");
+
+// plugins/plugin-codecall/src/services/synonym-expansion.service.ts
+var DEFAULT_SYNONYM_GROUPS = [
+  // ===========================================================================
+  // 1. CORE DATA OPERATIONS (CRUD+)
+  // ===========================================================================
+  // Creation / Instantiation
+  [
+    "create",
+    "add",
+    "new",
+    "insert",
+    "make",
+    "append",
+    "register",
+    "generate",
+    "produce",
+    "build",
+    "construct",
+    "provision",
+    "instantiate",
+    "define",
+    "compose",
+    "draft"
+  ],
+  // Destructive Removal
+  [
+    "delete",
+    "remove",
+    "destroy",
+    "drop",
+    "erase",
+    "clear",
+    "purge",
+    "discard",
+    "eliminate",
+    "nuke",
+    "unbind",
+    "unregister"
+  ],
+  // Retrieval / Access
+  ["get", "fetch", "retrieve", "read", "obtain", "load", "pull", "access", "grab", "snag", "receive"],
+  // Modification
+  [
+    "update",
+    "edit",
+    "modify",
+    "change",
+    "patch",
+    "alter",
+    "revise",
+    "refresh",
+    "correct",
+    "amend",
+    "adjust",
+    "tweak",
+    "rectify",
+    "refine"
+  ],
+  // Viewing / Listing
+  [
+    "list",
+    "show",
+    "display",
+    "enumerate",
+    "browse",
+    "view",
+    "peek",
+    "index",
+    "catalog",
+    "survey",
+    "inspect",
+    "ls",
+    "dir"
+  ],
+  // Searching / Discovery
+  [
+    "find",
+    "search",
+    "lookup",
+    "query",
+    "locate",
+    "filter",
+    "scan",
+    "explore",
+    "investigate",
+    "detect",
+    "scout",
+    "seek"
+  ],
+  // Soft Delete / Archival
+  ["archive", "shelve", "retire", "hide", "suppress", "mute"],
+  ["unarchive", "restore", "recover", "undelete", "unhide"],
+  // ===========================================================================
+  // 2. STATE & LIFECYCLE
+  // ===========================================================================
+  // Activation
+  [
+    "enable",
+    "activate",
+    "start",
+    "turn on",
+    "switch on",
+    "boot",
+    "init",
+    "initialize",
+    "setup",
+    "spin up",
+    "resume",
+    "unpause"
+  ],
+  // Deactivation
+  [
+    "disable",
+    "deactivate",
+    "stop",
+    "turn off",
+    "switch off",
+    "shutdown",
+    "halt",
+    "kill",
+    "terminate",
+    "suspend",
+    "pause",
+    "cease"
+  ],
+  // Execution
+  ["run", "execute", "invoke", "trigger", "launch", "call", "perform", "operate", "handle", "process", "fire"],
+  // Reset cycles
+  ["restart", "reboot", "reset", "reload", "bounce", "recycle", "refresh"],
+  // Validation & Check
+  ["validate", "verify", "check", "confirm", "assert", "test", "audit", "assess", "healthcheck", "ping"],
+  // Analysis & Math
+  [
+    "analyze",
+    "interpret",
+    "diagnose",
+    "evaluate",
+    "review",
+    "summarize",
+    "count",
+    "calculate",
+    "compute",
+    "measure",
+    "aggregate",
+    "summarise"
+  ],
+  // ===========================================================================
+  // 3. TRANSFER, IO & MANIPULATION
+  // ===========================================================================
+  // Duplication
+  ["copy", "duplicate", "clone", "replicate", "mirror", "fork", "repro"],
+  // Movement
+  ["move", "transfer", "migrate", "relocate", "rename", "shift", "mv", "slide"],
+  // Persistence
+  ["save", "store", "write", "persist", "commit", "stash", "record", "log"],
+  // Synchronization
+  ["sync", "synchronize", "resync", "reconcile", "align", "pair"],
+  // Import/Export
+  ["import", "ingest", "upload", "push", "feed"],
+  ["export", "download", "dump", "backup", "extract"],
+  // Connection
+  ["connect", "link", "bind", "attach", "join", "bridge", "associate", "mount", "map"],
+  ["disconnect", "unlink", "unbind", "detach", "leave", "dissociate", "unmount", "unmap"],
+  // ===========================================================================
+  // 4. DEVOPS, SECURITY & TECHNICAL
+  // ===========================================================================
+  // Auth
+  ["login", "log in", "sign in", "authenticate", "auth"],
+  ["logout", "log out", "sign out", "disconnect"],
+  // Permissions
+  ["approve", "authorize", "grant", "permit", "allow", "sanction", "whitelist"],
+  ["deny", "reject", "revoke", "forbid", "block", "ban", "blacklist"],
+  // Encryption
+  ["encrypt", "secure", "lock", "seal", "protect", "scramble", "hash"],
+  ["decrypt", "unlock", "unseal", "reveal", "decode"],
+  // Deployment
+  ["deploy", "release", "ship", "publish", "roll out", "promote", "distribute", "install"],
+  // Development
+  ["debug", "troubleshoot", "fix", "repair", "resolve", "trace"],
+  ["compile", "transpile", "build", "assemble", "package", "bundle", "minify"],
+  // ===========================================================================
+  // 5. COMMERCE & BUSINESS LOGIC
+  // ===========================================================================
+  // Financial Transactions
+  ["buy", "purchase", "order", "pay", "checkout", "spend"],
+  ["sell", "refund", "reimburse", "charge", "invoice", "bill"],
+  ["subscribe", "upgrade", "upsell"],
+  ["unsubscribe", "cancel", "downgrade"],
+  // Scheduling
+  ["schedule", "book", "appoint", "reserve", "plan", "calendar"],
+  ["reschedule", "postpone", "delay", "defer"],
+  // ===========================================================================
+  // 6. COMMUNICATION & SOCIAL
+  // ===========================================================================
+  // Outbound
+  [
+    "send",
+    "dispatch",
+    "deliver",
+    "transmit",
+    "post",
+    "broadcast",
+    "notify",
+    "alert",
+    "email",
+    "text",
+    "message",
+    "chat"
+  ],
+  // Social Interactions
+  ["reply", "respond", "answer", "retort"],
+  ["share", "forward", "retweet", "repost"],
+  ["like", "favorite", "star", "upvote", "heart"],
+  ["dislike", "downvote"],
+  ["follow", "watch", "track"],
+  ["unfollow", "ignore", "mute"],
+  // ===========================================================================
+  // 7. COMMON ENTITIES (NOUNS)
+  // ===========================================================================
+  // Users & Roles
+  [
+    "user",
+    "account",
+    "member",
+    "profile",
+    "identity",
+    "customer",
+    "principal",
+    "admin",
+    "operator",
+    "client",
+    "employee",
+    "staff"
+  ],
+  ["role", "group", "team", "squad", "unit", "department"],
+  // Data Artifacts
+  ["file", "document", "attachment", "blob", "asset", "object", "resource", "content", "media"],
+  ["image", "picture", "photo", "screenshot"],
+  ["video", "clip", "recording", "footage"],
+  // System Artifacts
+  ["message", "notification", "alert", "event", "signal", "webhook", "ping"],
+  ["log", "trace", "metric", "telemetry", "audit trail", "history"],
+  ["settings", "config", "configuration", "preferences", "options", "params", "env", "environment", "variables"],
+  ["permission", "privilege", "access right", "policy", "rule", "scope"],
+  // Business Artifacts
+  ["organization", "company", "tenant", "workspace", "org", "project", "repo", "repository"],
+  ["product", "item", "sku", "inventory", "stock"],
+  ["task", "ticket", "issue", "bug", "story", "epic", "todo", "job", "workitem"],
+  // Identification
+  ["id", "identifier", "key", "uuid", "guid", "token", "hash", "fingerprint"]
+];
+var SynonymExpansionService = class {
+  synonymMap;
+  maxExpansions;
+  constructor(config = {}) {
+    this.maxExpansions = config.maxExpansionsPerTerm ?? 5;
+    const groups = config.replaceDefaults ? config.additionalSynonyms || [] : [...DEFAULT_SYNONYM_GROUPS, ...config.additionalSynonyms || []];
+    this.synonymMap = this.buildSynonymMap(groups);
+  }
+  /**
+   * Build a bidirectional synonym map from groups.
+   * Each term maps to all other terms in its group(s).
+   */
+  buildSynonymMap(groups) {
+    const map = /* @__PURE__ */ new Map();
+    for (const group of groups) {
+      const normalizedGroup = group.map((term) => term.toLowerCase());
+      for (const term of normalizedGroup) {
+        if (!map.has(term)) {
+          map.set(term, /* @__PURE__ */ new Set());
+        }
+        const synonyms = map.get(term);
+        for (const synonym of normalizedGroup) {
+          if (synonym !== term) {
+            synonyms.add(synonym);
+          }
+        }
+      }
+    }
+    return map;
+  }
+  /**
+   * Get synonyms for a single term.
+   * Returns empty array if no synonyms found.
+   *
+   * @example
+   * getSynonyms('add') // ['create', 'new', 'insert', 'make']
+   */
+  getSynonyms(term) {
+    const normalized = term.toLowerCase();
+    const synonyms = this.synonymMap.get(normalized);
+    if (!synonyms) {
+      return [];
+    }
+    return Array.from(synonyms).slice(0, this.maxExpansions);
+  }
+  /**
+   * Expand a query string by adding synonyms for each term.
+   * Returns the expanded query string with original terms and their synonyms.
+   *
+   * @example
+   * expandQuery('add user') // 'add create new insert make user account member profile'
+   */
+  expandQuery(query) {
+    const terms = query.toLowerCase().split(/\s+/).filter((term) => term.length > 1);
+    const expandedTerms = [];
+    for (const term of terms) {
+      expandedTerms.push(term);
+      const synonyms = this.getSynonyms(term);
+      expandedTerms.push(...synonyms);
+    }
+    return expandedTerms.join(" ");
+  }
+  /**
+   * Check if synonym expansion is available for any term in the query.
+   */
+  hasExpansions(query) {
+    const terms = query.toLowerCase().split(/\s+/);
+    return terms.some((term) => this.synonymMap.has(term));
+  }
+  /**
+   * Get statistics about the synonym dictionary.
+   */
+  getStats() {
+    const termCount = this.synonymMap.size;
+    let totalSynonyms = 0;
+    for (const synonyms of this.synonymMap.values()) {
+      totalSynonyms += synonyms.size;
+    }
+    return {
+      termCount,
+      avgSynonymsPerTerm: termCount > 0 ? totalSynonyms / termCount : 0
+    };
+  }
+};
+
+// plugins/plugin-codecall/src/services/tool-search.service.ts
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  // Articles & Determiners
+  "the",
+  "a",
+  "an",
+  "this",
+  "that",
+  "these",
+  "those",
+  // Prepositions
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "by",
+  "from",
+  "into",
+  "over",
+  "after",
+  "before",
+  "between",
+  "under",
+  "about",
+  "against",
+  "during",
+  "through",
+  // Conjunctions
+  "and",
+  "or",
+  "but",
+  "nor",
+  "so",
+  "yet",
+  "as",
+  "than",
+  "if",
+  "because",
+  "while",
+  "when",
+  "where",
+  "unless",
+  // Pronouns (Subject/Object/Possessive)
+  "i",
+  "me",
+  "my",
+  "mine",
+  "myself",
+  "you",
+  "your",
+  "yours",
+  "yourself",
+  "he",
+  "him",
+  "his",
+  "himself",
+  "she",
+  "her",
+  "hers",
+  "herself",
+  "it",
+  "its",
+  "itself",
+  "we",
+  "us",
+  "our",
+  "ours",
+  "ourselves",
+  "they",
+  "them",
+  "their",
+  "theirs",
+  "themselves",
+  "who",
+  "whom",
+  "whose",
+  "which",
+  "what",
+  // Auxiliary/Linking Verbs (State of being is usually noise, Action is signal)
+  "is",
+  "was",
+  "are",
+  "were",
+  "been",
+  "be",
+  "being",
+  "have",
+  "has",
+  "had",
+  "having",
+  "do",
+  "does",
+  "did",
+  "doing",
+  // "do" is usually auxiliary ("do you have..."). "run" or "execute" is better.
+  "will",
+  "would",
+  "shall",
+  "should",
+  "can",
+  "could",
+  "may",
+  "might",
+  "must",
+  // Quantifiers / Adverbs of degree
+  "all",
+  "any",
+  "both",
+  "each",
+  "few",
+  "more",
+  "most",
+  "other",
+  "some",
+  "such",
+  "no",
+  "nor",
+  "not",
+  "only",
+  "own",
+  "same",
+  "too",
+  "very",
+  "just",
+  "even",
+  // Conversational / Chat Fillers (Common in LLM prompts)
+  "please",
+  "pls",
+  "plz",
+  "thanks",
+  "thank",
+  "thx",
+  "hello",
+  "hi",
+  "hey",
+  "ok",
+  "okay",
+  "yes",
+  "no",
+  "actually",
+  "basically",
+  "literally",
+  "maybe",
+  "perhaps",
+  "now",
+  "then",
+  "here",
+  "there",
+  "again",
+  "once",
+  "back",
+  // "back" can be tricky, but usually implies direction not action
+  // Meta/Structural words
+  "example",
+  "context",
+  "optionally",
+  "optional",
+  // Users rarely search for "optional", they search for the thing itself.
+  "etc",
+  "ie",
+  "eg"
+]);
+var ToolSearchService = class _ToolSearchService {
+  static MAX_SUBSCRIPTION_RETRIES = 100;
+  static INITIAL_RETRY_DELAY_MS = 10;
+  static MAX_RETRY_DELAY_MS = 1e3;
+  vectorDB;
+  strategy;
+  initialized = false;
+  mlInitialized = false;
+  config;
+  scope;
+  unsubscribe;
+  synonymService = null;
+  // Subscription tracking for async initialization
+  subscriptionPromise;
+  subscriptionResolved = false;
+  subscriptionResolve = null;
+  subscriptionReject = null;
+  retryTimeoutId = null;
+  disposed = false;
+  constructor(config = {}, scope) {
+    this.scope = scope;
+    const embeddingOptions = config.embeddingOptions || {
+      strategy: "tfidf",
+      modelName: "Xenova/all-MiniLM-L6-v2",
+      cacheDir: "./.cache/transformers",
+      useHNSW: false,
+      synonymExpansion: { enabled: true, replaceDefaults: false, maxExpansionsPerTerm: 5 }
+    };
+    this.strategy = config.strategy || embeddingOptions.strategy || "tfidf";
+    this.config = {
+      strategy: this.strategy,
+      embeddingOptions,
+      defaultTopK: config.defaultTopK ?? 8,
+      defaultSimilarityThreshold: config.defaultSimilarityThreshold ?? 0,
+      mode: config.mode ?? "codecall_only",
+      includeTools: config.includeTools
+    };
+    const validModes = ["codecall_only", "codecall_opt_in", "metadata_driven"];
+    if (!validModes.includes(this.config.mode)) {
+      throw new Error(`Invalid CodeCall mode: ${this.config.mode}. Valid modes: ${validModes.join(", ")}`);
+    }
+    if (this.strategy === "ml") {
+      this.vectorDB = new import_vectoriadb.VectoriaDB({
+        modelName: embeddingOptions.modelName || "Xenova/all-MiniLM-L6-v2",
+        cacheDir: embeddingOptions.cacheDir || "./.cache/transformers",
+        defaultTopK: this.config.defaultTopK,
+        defaultSimilarityThreshold: this.config.defaultSimilarityThreshold,
+        useHNSW: embeddingOptions.useHNSW || false
+      });
+    } else {
+      this.vectorDB = new import_vectoriadb.TFIDFVectoria({
+        defaultTopK: this.config.defaultTopK,
+        defaultSimilarityThreshold: this.config.defaultSimilarityThreshold
+      });
+    }
+    if (config.synonymExpansion === false) {
+      this.synonymService = null;
+    } else if (this.strategy === "tfidf") {
+      const synonymConfig = typeof config.synonymExpansion === "object" ? config.synonymExpansion : {};
+      if (synonymConfig.enabled !== false) {
+        this.synonymService = new SynonymExpansionService(synonymConfig);
+      }
+    }
+    this.subscriptionPromise = new Promise((resolve, reject) => {
+      this.subscriptionResolve = resolve;
+      this.subscriptionReject = reject;
+    });
+    this.setupSubscription();
+  }
+  /**
+   * Ensures the service is subscribed to tool changes before proceeding.
+   * Public methods should call this before accessing tools.
+   */
+  async ensureSubscribed() {
+    if (this.subscriptionResolved) {
+      return;
+    }
+    await this.subscriptionPromise;
+  }
+  /**
+   * Sets up subscription to tool changes with exponential backoff retry.
+   * Handles the case where scope.tools may not be available yet during plugin initialization.
+   */
+  setupSubscription(retryCount = 0, delayMs = _ToolSearchService.INITIAL_RETRY_DELAY_MS) {
+    if (this.scope.tools) {
+      this.subscribeToToolChanges();
+      return;
+    }
+    if (retryCount >= _ToolSearchService.MAX_SUBSCRIPTION_RETRIES) {
+      this.scope.logger.warn(
+        "ToolSearchService: scope.tools not available after max retries. Tool search will return incomplete results until tools are registered."
+      );
+      this.markSubscribed();
+      return;
+    }
+    const nextDelay = Math.min(delayMs * 2, _ToolSearchService.MAX_RETRY_DELAY_MS);
+    this.retryTimeoutId = setTimeout(() => {
+      this.retryTimeoutId = null;
+      if (this.disposed) {
+        return;
+      }
+      this.setupSubscription(retryCount + 1, nextDelay);
+    }, delayMs);
+  }
+  /**
+   * Subscribes to tool changes once scope.tools is available.
+   */
+  subscribeToToolChanges() {
+    this.unsubscribe = this.scope.tools.subscribe({ immediate: true }, (event) => {
+      this.handleToolChange(event.snapshot);
+    });
+    this.markSubscribed();
+  }
+  /**
+   * Marks the subscription as resolved, allowing pending operations to proceed.
+   */
+  markSubscribed() {
+    this.subscriptionResolved = true;
+    if (this.subscriptionResolve) {
+      this.subscriptionResolve();
+      this.subscriptionResolve = null;
+    }
+  }
+  /**
+   * Handles tool change events by reindexing all tools from the snapshot
+   */
+  async handleToolChange(tools) {
+    this.vectorDB.clear();
+    if (tools.length === 0) {
+      this.initialized = true;
+      return;
+    }
+    if (!this.mlInitialized && this.strategy === "ml" && this.vectorDB instanceof import_vectoriadb.VectoriaDB) {
+      await this.vectorDB.initialize();
+      this.mlInitialized = true;
+    }
+    const filteredTools = tools.filter((tool) => this.shouldIndexTool(tool));
+    if (filteredTools.length === 0) {
+      this.initialized = true;
+      return;
+    }
+    const documents = filteredTools.map((tool) => {
+      const searchableText = this.extractSearchableText(tool);
+      const appId = this.extractAppId(tool);
+      const toolName = tool.name;
+      const qualifiedName = tool.fullName || toolName;
+      return {
+        id: toolName,
+        text: searchableText,
+        metadata: {
+          id: toolName,
+          toolName,
+          qualifiedName,
+          appId,
+          toolInstance: tool
+        }
+      };
+    });
+    if (this.strategy === "ml" && this.vectorDB instanceof import_vectoriadb.VectoriaDB) {
+      await this.vectorDB.addMany(documents);
+    } else if (this.vectorDB instanceof import_vectoriadb.TFIDFVectoria) {
+      this.vectorDB.addDocuments(documents);
+      this.vectorDB.reindex();
+    }
+    this.initialized = true;
+  }
+  /**
+   * Determines if a tool should be indexed in the search database.
+   * Filters based on:
+   * - Excludes codecall:* meta-tools (they should not be searchable)
+   * - Mode-based filtering (codecall_only, codecall_opt_in, metadata_driven)
+   * - Per-tool metadata.codecall.enabledInCodeCall
+   * - Custom includeTools filter function
+   */
+  shouldIndexTool(tool) {
+    const toolName = tool.name || tool.fullName;
+    if (toolName.startsWith("codecall:")) {
+      return false;
+    }
+    const codecallMeta = this.getCodeCallMetadata(tool);
+    switch (this.config.mode) {
+      case "codecall_only":
+        if (codecallMeta?.enabledInCodeCall === false) {
+          return false;
+        }
+        break;
+      case "codecall_opt_in":
+        if (codecallMeta?.enabledInCodeCall !== true) {
+          return false;
+        }
+        break;
+      case "metadata_driven":
+        if (codecallMeta?.enabledInCodeCall === false) {
+          return false;
+        }
+        break;
+      default:
+        throw new Error(`Unknown CodeCall mode: ${this.config.mode}`);
+    }
+    if (this.config.includeTools) {
+      const appId = this.extractAppId(tool);
+      const filterInfo = {
+        name: toolName,
+        appId,
+        source: codecallMeta?.source,
+        description: tool.metadata.description,
+        tags: codecallMeta?.tags || tool.metadata.tags
+      };
+      if (!this.config.includeTools(filterInfo)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Extract CodeCall-specific metadata from a tool.
+   */
+  getCodeCallMetadata(tool) {
+    return tool.metadata?.codecall;
+  }
+  /**
+   * Initializes the search service by indexing all tools from the registry.
+   * NOTE: This method is now a no-op. Initialization is handled reactively
+   * via subscription to tool change events in the constructor.
+   * This method exists for interface compatibility.
+   */
+  async initialize() {
+  }
+  /**
+   * Cleanup subscription and pending retries when service is destroyed
+   */
+  dispose() {
+    this.disposed = true;
+    if (this.retryTimeoutId) {
+      clearTimeout(this.retryTimeoutId);
+      this.retryTimeoutId = null;
+    }
+    if (this.subscriptionReject) {
+      this.subscriptionReject(new Error("ToolSearchService disposed before subscription completed"));
+      this.subscriptionReject = null;
+      this.subscriptionResolve = null;
+    }
+    if (this.unsubscribe) {
+      this.unsubscribe();
+      this.unsubscribe = void 0;
+    }
+  }
+  /**
+   * Extracts searchable text from a tool instance.
+   * Uses term weighting to improve relevance:
+   * - Description terms are heavily weighted (most important for semantic matching)
+   * - Tool name parts are tokenized and weighted
+   * - Tags provide additional context
+   */
+  extractSearchableText(tool) {
+    const parts = [];
+    if (tool.name) {
+      const nameParts = tool.name.split(/[:\-_.]/).filter(Boolean);
+      for (const part of nameParts) {
+        parts.push(part, part);
+      }
+    }
+    if (tool.metadata.description) {
+      const description = tool.metadata.description;
+      parts.push(description, description, description);
+      const keyTerms = description.toLowerCase().split(/\s+/).filter((word) => word.length >= 4 && !this.isStopWord(word));
+      parts.push(...keyTerms);
+    }
+    if (tool.metadata.tags && tool.metadata.tags.length > 0) {
+      for (const tag of tool.metadata.tags) {
+        parts.push(tag, tag);
+      }
+    }
+    if (tool.rawInputSchema && typeof tool.rawInputSchema === "object") {
+      const schema = tool.rawInputSchema;
+      if (schema.properties) {
+        parts.push(...Object.keys(schema.properties));
+      }
+    }
+    const examples = tool.metadata?.examples;
+    if (examples && Array.isArray(examples)) {
+      for (const ex of examples) {
+        if (ex.description) {
+          parts.push(ex.description, ex.description);
+        }
+        if (ex.input && typeof ex.input === "object") {
+          for (const [key, value] of Object.entries(ex.input)) {
+            parts.push(key);
+            if (typeof value === "string") {
+              parts.push(value);
+            }
+          }
+        }
+      }
+    }
+    return parts.join(" ");
+  }
+  /**
+   * Checks if a word is a common stop word that should not receive extra weighting.
+   * Uses module-level STOP_WORDS constant to avoid recreating the Set on each call.
+   */
+  isStopWord(word) {
+    return STOP_WORDS.has(word);
+  }
+  /**
+   * Extracts app ID from tool's owner lineage
+   */
+  extractAppId(tool) {
+    if (!tool.owner) return void 0;
+    if (tool.owner.kind === "app") {
+      return tool.owner.id;
+    }
+    return void 0;
+  }
+  /**
+   * Searches for tools matching the query
+   * Implements the ToolSearch interface
+   */
+  async search(query, options = {}) {
+    await this.ensureSubscribed();
+    const { topK = this.config.defaultTopK, appIds, excludeToolNames = [] } = options;
+    const minScore = this.config.defaultSimilarityThreshold;
+    const filter = (metadata) => {
+      if (excludeToolNames.includes(metadata.toolName)) {
+        return false;
+      }
+      if (appIds && appIds.length > 0) {
+        if (!metadata.appId || !appIds.includes(metadata.appId)) {
+          return false;
+        }
+      }
+      return true;
+    };
+    const effectiveQuery = this.synonymService ? this.synonymService.expandQuery(query) : query;
+    const results = await this.vectorDB.search(effectiveQuery, {
+      topK,
+      threshold: minScore,
+      filter
+    });
+    return results.map((result) => ({
+      toolName: result.metadata.toolName,
+      appId: result.metadata.appId,
+      description: result.metadata.toolInstance.metadata.description || "",
+      relevanceScore: result.score
+    }));
+  }
+  /**
+   * Gets all indexed tool names
+   */
+  getAllToolNames() {
+    if (this.vectorDB instanceof import_vectoriadb.VectoriaDB) {
+      return this.vectorDB.getAll().map((doc) => doc.id);
+    } else {
+      return this.vectorDB.getAllDocumentIds();
+    }
+  }
+  /**
+   * Gets the total number of indexed tools
+   */
+  getTotalCount() {
+    if (this.vectorDB instanceof import_vectoriadb.VectoriaDB) {
+      return this.vectorDB.size();
+    } else {
+      return this.vectorDB.getDocumentCount();
+    }
+  }
+  /**
+   * Checks if a tool exists in the index
+   */
+  hasTool(toolName) {
+    if (this.vectorDB instanceof import_vectoriadb.VectoriaDB) {
+      return this.vectorDB.has(toolName);
+    } else {
+      return this.vectorDB.hasDocument(toolName);
+    }
+  }
+  /**
+   * Clears the entire index
+   */
+  clear() {
+    this.vectorDB.clear();
+    this.initialized = false;
+  }
+  /**
+   * Get the current embedding strategy
+   */
+  getStrategy() {
+    return this.strategy;
+  }
+  /**
+   * Check if the service is initialized
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+};
+
+// plugins/plugin-codecall/src/services/enclave.service.ts
+var import_sdk = require("@frontmcp/sdk");
+var import_enclave_vm = require("enclave-vm");
+var ScriptTooLargeError = class extends Error {
+  code = "SCRIPT_TOO_LARGE";
+  scriptLength;
+  maxLength;
+  constructor(scriptLength, maxLength) {
+    super(
+      `Script length (${scriptLength} characters) exceeds maximum allowed length (${maxLength} characters). Enable sidecar to handle large data, or reduce script size.`
+    );
+    this.name = "ScriptTooLargeError";
+    this.scriptLength = scriptLength;
+    this.maxLength = maxLength;
+  }
+};
+var EnclaveService = class {
+  vmOptions;
+  sidecarOptions;
+  constructor(config) {
+    const all = config.getAll();
+    this.vmOptions = all.resolvedVm;
+    this.sidecarOptions = all.sidecar;
+  }
+  /**
+   * Execute AgentScript code in the enclave
+   *
+   * @param code - The AgentScript code to execute (raw, not transformed)
+   * @param environment - The VM environment with callTool, getTool, etc.
+   * @returns Execution result with success/error and logs
+   * @throws ScriptTooLargeError if script exceeds max length and sidecar is disabled
+   */
+  async execute(code, environment) {
+    const logs = [];
+    if (!this.sidecarOptions.enabled && this.sidecarOptions.maxScriptLengthWhenDisabled !== null) {
+      const maxLength = this.sidecarOptions.maxScriptLengthWhenDisabled;
+      if (code.length > maxLength) {
+        throw new ScriptTooLargeError(code.length, maxLength);
+      }
+    }
+    const toolHandler = async (toolName, args) => {
+      return environment.callTool(toolName, args);
+    };
+    const sidecar = this.sidecarOptions.enabled ? {
+      enabled: true,
+      maxTotalSize: this.sidecarOptions.maxTotalSize,
+      maxReferenceSize: this.sidecarOptions.maxReferenceSize,
+      extractionThreshold: this.sidecarOptions.extractionThreshold,
+      maxResolvedSize: this.sidecarOptions.maxResolvedSize,
+      allowComposites: this.sidecarOptions.allowComposites
+    } : void 0;
+    const enclave = new import_enclave_vm.Enclave({
+      timeout: this.vmOptions.timeoutMs,
+      maxToolCalls: this.vmOptions.maxSteps || 100,
+      maxIterations: 1e4,
+      toolHandler,
+      validate: true,
+      transform: true,
+      sidecar,
+      // Allow functions in globals since we intentionally provide getTool, mcpLog, mcpNotify, and console
+      allowFunctionsInGlobals: true,
+      globals: {
+        // Provide getTool as a custom global
+        getTool: environment.getTool,
+        // Provide logging functions if available
+        ...environment.mcpLog ? {
+          mcpLog: (level, message, metadata) => {
+            environment.mcpLog(level, message, metadata);
+            logs.push(`[mcp:${level}] ${message}`);
+          }
+        } : {},
+        ...environment.mcpNotify ? {
+          mcpNotify: (event, payload) => {
+            environment.mcpNotify(event, payload);
+            logs.push(`[notify] ${event}`);
+          }
+        } : {}
+        // Note: enclave-vm v2.0.0+ provides its own __safe_console internally with rate limiting
+        // and output size limits. Passing console in globals causes "Cannot redefine property"
+        // errors due to Double VM architecture. Console output from user scripts goes to stdout
+        // via enclave's internal console, not to this logs array. Only mcpLog/mcpNotify are captured.
+      }
+    });
+    try {
+      const result = await enclave.run(code);
+      return this.mapEnclaveResult(result, logs);
+    } finally {
+      enclave.dispose();
+    }
+  }
+  /**
+   * Map Enclave ExecutionResult to EnclaveExecutionResult
+   */
+  mapEnclaveResult(result, logs) {
+    if (result.success) {
+      return {
+        success: true,
+        result: result.value,
+        logs,
+        timedOut: false,
+        stats: {
+          duration: result.stats.duration,
+          toolCallCount: result.stats.toolCallCount,
+          iterationCount: result.stats.iterationCount
+        }
+      };
+    }
+    const error = result.error;
+    const timedOut = error.message?.includes("timed out") || error.code === "TIMEOUT";
+    if (error.code === "VALIDATION_ERROR") {
+      return {
+        success: false,
+        error: {
+          message: error.message,
+          name: "ValidationError",
+          code: error.code
+        },
+        logs,
+        timedOut: false
+      };
+    }
+    const errorData = error.data;
+    const toolName = errorData?.["toolName"];
+    if (toolName) {
+      return {
+        success: false,
+        error: {
+          message: error.message,
+          name: error.name,
+          stack: error.stack,
+          code: error.code,
+          toolName,
+          toolInput: errorData?.["toolInput"],
+          details: errorData?.["details"]
+        },
+        logs,
+        timedOut
+      };
+    }
+    return {
+      success: false,
+      error: {
+        message: error.message,
+        name: error.name,
+        stack: error.stack,
+        code: error.code
+      },
+      logs,
+      timedOut,
+      stats: {
+        duration: result.stats.duration,
+        toolCallCount: result.stats.toolCallCount,
+        iterationCount: result.stats.iterationCount
+      }
+    };
+  }
+};
+EnclaveService = __decorateClass([
+  (0, import_sdk.Provider)({
+    name: "codecall:enclave",
+    description: "Executes AgentScript code in a secure enclave",
+    scope: import_sdk.ProviderScope.GLOBAL
+  })
+], EnclaveService);
+
+// plugins/plugin-codecall/src/tools/search.tool.ts
+var import_sdk2 = require("@frontmcp/sdk");
+
+// plugins/plugin-codecall/src/tools/search.schema.ts
+var import_zod2 = require("zod");
+var searchToolDescription = `Find tools by splitting user request into atomic actions.
+
+DECOMPOSE: "delete users and send email" \u2192 queries: ["delete user", "send email"]
+DECOMPOSE: "get order and refund" \u2192 queries: ["get order", "calculate refund"]
+
+AVOID RE-SEARCHING: Use excludeToolNames for already-discovered tools.
+RE-SEARCH WHEN: describe fails (typo?) OR execute returns tool_not_found.
+
+INPUT:
+- queries: string[] (required) - atomic action phrases, max 10
+- appIds?: string[] - filter by app
+- excludeToolNames?: string[] - skip known tools
+- topK?: number (default 5) - results per query
+- minRelevanceScore?: number (default 0.3) - minimum match threshold
+
+OUTPUT: Flat deduplicated tool list. relevanceScore: 0.5+=good, 0.7+=strong match.
+
+FLOW: search \u2192 describe \u2192 execute/invoke`;
+var searchToolInputSchema = import_zod2.z.object({
+  queries: import_zod2.z.array(import_zod2.z.string().min(2).max(256)).min(1).max(10).describe("Atomic action queries. Split complex requests into simple actions."),
+  appIds: import_zod2.z.array(import_zod2.z.string()).max(10).optional().describe("Filter by app IDs"),
+  excludeToolNames: import_zod2.z.array(import_zod2.z.string()).max(50).optional().describe("Skip already-known tool names"),
+  topK: import_zod2.z.number().int().positive().max(50).optional().default(10).describe("Results per query (default 10)"),
+  minRelevanceScore: import_zod2.z.number().min(0).max(1).optional().default(0.1).describe("Minimum relevance threshold (default 0.1)")
+});
+var searchToolOutputSchema = import_zod2.z.object({
+  tools: import_zod2.z.array(
+    import_zod2.z.object({
+      name: import_zod2.z.string().describe('Tool name (e.g., "users:list")'),
+      appId: import_zod2.z.string().optional().describe("App ID"),
+      description: import_zod2.z.string().describe("What this tool does"),
+      relevanceScore: import_zod2.z.number().min(0).max(1).describe("Match score (0-1)"),
+      matchedQueries: import_zod2.z.array(import_zod2.z.string()).describe("Which queries matched this tool")
+    })
+  ).describe("Deduplicated tools sorted by relevance"),
+  warnings: import_zod2.z.array(
+    import_zod2.z.object({
+      type: import_zod2.z.enum(["excluded_tool_not_found", "no_results", "low_relevance"]).describe("Warning type"),
+      message: import_zod2.z.string().describe("Warning message"),
+      affectedTools: import_zod2.z.array(import_zod2.z.string()).optional().describe("Affected tool names")
+    })
+  ).describe("Search warnings"),
+  totalAvailableTools: import_zod2.z.number().int().nonnegative().describe("Total tools in index")
+});
+
+// plugins/plugin-codecall/src/tools/search.tool.ts
+var SearchTool = class extends import_sdk2.ToolContext {
+  async execute(input) {
+    const { queries, appIds, excludeToolNames = [], topK = 5, minRelevanceScore = 0.3 } = input;
+    const searchService = this.get(ToolSearchService);
+    const warnings = [];
+    const nonExistentExcludedTools = excludeToolNames.filter((toolName) => !searchService.hasTool(toolName));
+    if (nonExistentExcludedTools.length > 0) {
+      warnings.push({
+        type: "excluded_tool_not_found",
+        message: `Excluded tools not found: ${nonExistentExcludedTools.join(", ")}`,
+        affectedTools: nonExistentExcludedTools
+      });
+    }
+    const toolMap = /* @__PURE__ */ new Map();
+    let lowRelevanceCount = 0;
+    for (const query of queries) {
+      const searchResults = await searchService.search(query, {
+        topK,
+        appIds,
+        excludeToolNames
+      });
+      for (const result of searchResults) {
+        if (result.relevanceScore < minRelevanceScore) {
+          lowRelevanceCount++;
+          continue;
+        }
+        const existing = toolMap.get(result.toolName);
+        if (existing) {
+          existing.matchedQueries.push(query);
+          existing.relevanceScore = Math.max(existing.relevanceScore, result.relevanceScore);
+        } else {
+          toolMap.set(result.toolName, {
+            name: result.toolName,
+            appId: result.appId,
+            description: result.description,
+            relevanceScore: result.relevanceScore,
+            matchedQueries: [query]
+          });
+        }
+      }
+    }
+    const tools = Array.from(toolMap.values()).sort((a, b) => b.relevanceScore - a.relevanceScore).map((tool) => ({
+      name: tool.name,
+      appId: tool.appId,
+      description: tool.description,
+      relevanceScore: tool.relevanceScore,
+      matchedQueries: tool.matchedQueries
+    }));
+    if (tools.length === 0) {
+      warnings.push({
+        type: "no_results",
+        message: `No tools found for queries: ${queries.join(", ")}${appIds?.length ? ` in apps: ${appIds.join(", ")}` : ""}`
+      });
+    }
+    if (lowRelevanceCount > 0 && tools.length > 0) {
+      warnings.push({
+        type: "low_relevance",
+        message: `${lowRelevanceCount} result(s) filtered due to relevance below ${minRelevanceScore}`
+      });
+    }
+    return {
+      tools,
+      warnings,
+      totalAvailableTools: searchService.getTotalCount()
+    };
+  }
+};
+SearchTool = __decorateClass([
+  (0, import_sdk2.Tool)({
+    name: "codecall:search",
+    cache: {
+      ttl: 60,
+      // 1 minute
+      slideWindow: false
+    },
+    codecall: {
+      enabledInCodeCall: false,
+      visibleInListTools: true
+    },
+    description: searchToolDescription,
+    inputSchema: searchToolInputSchema,
+    outputSchema: searchToolOutputSchema,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: true
+    }
+  })
+], SearchTool);
+
+// plugins/plugin-codecall/src/tools/describe.tool.ts
+var import_sdk3 = require("@frontmcp/sdk");
+var import_v4 = require("zod/v4");
+var import_zod4 = require("zod");
+
+// plugins/plugin-codecall/src/tools/describe.schema.ts
+var import_zod3 = require("zod");
+var import_types = require("@modelcontextprotocol/sdk/types.js");
+var describeToolDescription = `Get input/output schemas for tools from search results.
+
+INPUT: toolNames: string[] - tool names from search
+OUTPUT per tool: inputSchema (JSON Schema), outputSchema (JSON Schema), usageExamples (up to 5 callTool examples)
+
+IMPORTANT: If notFound array is non-empty \u2192 re-search with corrected queries.
+FLOW: search \u2192 describe \u2192 execute/invoke`;
+var describeToolInputSchema = import_zod3.z.object({
+  toolNames: import_zod3.z.array(import_zod3.z.string()).min(1).superRefine((toolNames, ctx) => {
+    const seen = /* @__PURE__ */ new Set();
+    const duplicates = /* @__PURE__ */ new Set();
+    for (const name of toolNames) {
+      if (seen.has(name)) {
+        duplicates.add(name);
+      }
+      seen.add(name);
+    }
+    if (duplicates.size > 0) {
+      ctx.addIssue({
+        code: import_zod3.z.ZodIssueCode.custom,
+        message: `Duplicate tool names are not allowed: ${Array.from(duplicates).join(", ")}`
+      });
+    }
+  }).describe(
+    'Array of unique tool names (from codecall:search results) to fetch their detailed schemas and usage examples. Example: ["users:list", "billing:getInvoice"]'
+  )
+});
+var describeToolOutputSchema = import_zod3.z.object({
+  tools: import_zod3.z.array(
+    import_zod3.z.object({
+      name: import_zod3.z.string().describe("Tool name to be used in callTool() within codecall:execute scripts"),
+      appId: import_zod3.z.string().describe("The app ID this tool belongs to"),
+      description: import_zod3.z.string().describe("Detailed description of what this tool does"),
+      inputSchema: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).nullable().describe("JSON Schema object describing the tool input parameters"),
+      outputSchema: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).nullable().describe("JSON Schema object describing the tool output structure"),
+      annotations: import_types.ToolAnnotationsSchema.optional().describe("MCP tool annotations (metadata)"),
+      usageExamples: import_zod3.z.array(
+        import_zod3.z.object({
+          description: import_zod3.z.string().describe("Description of what this example demonstrates"),
+          code: import_zod3.z.string().describe(
+            'JavaScript code example showing how to call this tool using callTool(). Format: const result = await callTool("tool:name", { ...params });'
+          )
+        })
+      ).max(5).describe("Up to 5 practical examples of how to use this tool in a codecall:execute script")
+    })
+  ).describe("Array of tool descriptions with schemas and usage examples"),
+  notFound: import_zod3.z.array(import_zod3.z.string()).optional().describe("Tool names that were requested but not found in the index. Check these for typos.")
+});
+
+// plugins/plugin-codecall/src/utils/describe.utils.ts
+var INTENT_PATTERNS = {
+  create: /^(create|add|new|insert|make|append|register|generate|produce|build|construct|provision|instantiate|define|compose|draft)/i,
+  delete: /^(delete|remove|destroy|drop|erase|clear|purge|discard|eliminate|unbind|unregister)/i,
+  get: /^(get|fetch|retrieve|read|obtain|load|pull|access|grab|receive)/i,
+  update: /^(update|edit|modify|change|patch|set|alter|revise|adjust|amend|correct|fix|refresh|sync|upgrade|downgrade)/i,
+  list: /^(list|all|index|enumerate|show|display|view|browse|scan|inventory)/i,
+  search: /^(search|find|query|lookup|locate|discover|explore|seek|match|filter)/i
+};
+function detectToolIntent(toolName, description) {
+  const parts = toolName.split(":");
+  const actionPart = parts.length > 1 ? parts[parts.length - 1] : toolName;
+  for (const [intent, pattern] of Object.entries(INTENT_PATTERNS)) {
+    if (pattern.test(actionPart)) {
+      return intent;
+    }
+  }
+  if (description) {
+    const descLower = description.toLowerCase();
+    if (/creates?\s|adding\s|inserts?/i.test(descLower)) return "create";
+    if (/deletes?\s|removes?\s|destroys?/i.test(descLower)) return "delete";
+    if (/gets?\s|fetche?s?\s|retrieves?/i.test(descLower)) return "get";
+    if (/updates?\s|modif(?:y|ies)\s|edits?/i.test(descLower)) return "update";
+    if (/lists?\s|shows?\s|displays?/i.test(descLower)) return "list";
+    if (/search(?:es)?\s|find(?:s)?\s|quer(?:y|ies)/i.test(descLower)) return "search";
+  }
+  return "unknown";
+}
+function generateBasicExample(toolName, inputSchema) {
+  const params = generateSampleParams(inputSchema);
+  const paramsStr = params ? JSON.stringify(params, null, 2) : "{}";
+  return {
+    description: `Basic usage of ${toolName}`,
+    code: `const result = await callTool('${toolName}', ${paramsStr});
+return result;`
+  };
+}
+function generateSampleParams(schema) {
+  if (!schema || schema.type !== "object" || !schema.properties) {
+    return null;
+  }
+  const params = {};
+  const required = new Set(schema.required || []);
+  for (const [key, propSchema] of Object.entries(schema.properties)) {
+    if (typeof propSchema === "boolean") continue;
+    if (!required.has(key)) continue;
+    params[key] = getSampleValue(propSchema, key);
+  }
+  return Object.keys(params).length > 0 ? params : null;
+}
+function getSampleValue(schema, key) {
+  if (schema.default !== void 0) {
+    return schema.default;
+  }
+  if (schema.enum && schema.enum.length > 0) {
+    return schema.enum[0];
+  }
+  if (schema.const !== void 0) {
+    return schema.const;
+  }
+  const type = Array.isArray(schema.type) ? schema.type[0] : schema.type;
+  switch (type) {
+    case "string":
+      if (key.toLowerCase().includes("id")) return "abc123";
+      if (key.toLowerCase().includes("email")) return "user@example.com";
+      if (key.toLowerCase().includes("name")) return "Example";
+      if (key.toLowerCase().includes("url")) return "https://example.com";
+      return "string";
+    case "number":
+    case "integer":
+      if (key.toLowerCase().includes("limit")) return 10;
+      if (key.toLowerCase().includes("offset")) return 0;
+      if (key.toLowerCase().includes("page")) return 1;
+      return 0;
+    case "boolean":
+      return true;
+    case "array":
+      return [];
+    case "object":
+      return {};
+    default:
+      return null;
+  }
+}
+function hasPaginationParams(schema) {
+  if (!schema || schema.type !== "object" || !schema.properties) {
+    return false;
+  }
+  const props = Object.keys(schema.properties);
+  return props.some((p) => ["limit", "offset", "page", "pageSize", "cursor"].includes(p.toLowerCase()));
+}
+function generatePaginationExample(toolName) {
+  return {
+    description: `Pagination example for ${toolName}`,
+    code: `// Fetch first page
+const page1 = await callTool('${toolName}', { limit: 10, offset: 0 });
+
+// Fetch second page
+const page2 = await callTool('${toolName}', { limit: 10, offset: 10 });
+
+// Combine results
+return [...page1.items, ...page2.items];`
+  };
+}
+function extractEntityName(toolName) {
+  const parts = toolName.split(":");
+  const entity = parts.length > 1 ? parts[0] : toolName;
+  return entity.endsWith("s") && !entity.endsWith("ss") ? entity.slice(0, -1) : entity;
+}
+function generateCreateExample(toolName, inputSchema) {
+  const entity = extractEntityName(toolName);
+  const params = generateSampleParams(inputSchema);
+  const paramsStr = params ? JSON.stringify(params, null, 2) : "{ /* required fields */ }";
+  return {
+    description: `Create a new ${entity}`,
+    code: `const result = await callTool('${toolName}', ${paramsStr});
+return result;`
+  };
+}
+function generateGetExample(toolName, inputSchema) {
+  const entity = extractEntityName(toolName);
+  const idParam = findIdParameter(inputSchema);
+  if (idParam) {
+    return {
+      description: `Get ${entity} by ${idParam}`,
+      code: `const ${entity} = await callTool('${toolName}', { ${idParam}: 'abc123' });
+return ${entity};`
+    };
+  }
+  const params = generateSampleParams(inputSchema);
+  const paramsStr = params ? JSON.stringify(params, null, 2) : "{}";
+  return {
+    description: `Get ${entity} details`,
+    code: `const ${entity} = await callTool('${toolName}', ${paramsStr});
+return ${entity};`
+  };
+}
+function generateListExample(toolName, inputSchema) {
+  const entity = extractEntityName(toolName);
+  return {
+    description: `List all ${entity}s`,
+    code: `const result = await callTool('${toolName}', {});
+return result.items || result;`
+  };
+}
+function generateUpdateExample(toolName, inputSchema) {
+  const entity = extractEntityName(toolName);
+  const idParam = findIdParameter(inputSchema);
+  const updateFields = generateUpdateFields(inputSchema);
+  const fieldsStr = updateFields ? JSON.stringify(updateFields, null, 2).replace(/\n/g, "\n  ") : "{ /* fields to update */ }";
+  if (idParam) {
+    return {
+      description: `Update ${entity} by ${idParam}`,
+      code: `const updated = await callTool('${toolName}', {
+  ${idParam}: 'abc123',
+  ...${fieldsStr}
+});
+return updated;`
+    };
+  }
+  return {
+    description: `Update ${entity}`,
+    code: `const updated = await callTool('${toolName}', ${fieldsStr});
+return updated;`
+  };
+}
+function generateDeleteExample(toolName, inputSchema) {
+  const entity = extractEntityName(toolName);
+  const idParam = findIdParameter(inputSchema);
+  if (idParam) {
+    return {
+      description: `Delete ${entity} by ${idParam}`,
+      code: `const result = await callTool('${toolName}', { ${idParam}: 'abc123' });
+return result;`
+    };
+  }
+  const params = generateSampleParams(inputSchema);
+  const paramsStr = params ? JSON.stringify(params, null, 2) : "{ /* identifier */ }";
+  return {
+    description: `Delete ${entity}`,
+    code: `const result = await callTool('${toolName}', ${paramsStr});
+return result;`
+  };
+}
+function generateSearchExample(toolName, inputSchema) {
+  const entity = extractEntityName(toolName);
+  const queryParam = findQueryParameter(inputSchema);
+  if (queryParam) {
+    return {
+      description: `Search for ${entity}s`,
+      code: `const results = await callTool('${toolName}', { ${queryParam}: 'search term' });
+return results.items || results;`
+    };
+  }
+  return {
+    description: `Search for ${entity}s`,
+    code: `const results = await callTool('${toolName}', { query: 'search term' });
+return results.items || results;`
+  };
+}
+function findIdParameter(schema) {
+  if (!schema || schema.type !== "object" || !schema.properties) {
+    return null;
+  }
+  const props = Object.keys(schema.properties);
+  const required = new Set(schema.required || []);
+  const idPatterns = ["id", "Id", "ID", "_id", "uuid", "key"];
+  for (const pattern of idPatterns) {
+    const found = props.find((p) => (p === pattern || p.endsWith(pattern)) && required.has(p));
+    if (found) return found;
+  }
+  for (const pattern of idPatterns) {
+    const found = props.find((p) => p === pattern || p.endsWith(pattern));
+    if (found) return found;
+  }
+  return null;
+}
+function findQueryParameter(schema) {
+  if (!schema || schema.type !== "object" || !schema.properties) {
+    return null;
+  }
+  const props = Object.keys(schema.properties);
+  const queryPatterns = ["query", "search", "q", "term", "keyword", "filter"];
+  for (const pattern of queryPatterns) {
+    const found = props.find((p) => p.toLowerCase() === pattern || p.toLowerCase().includes(pattern));
+    if (found) return found;
+  }
+  return null;
+}
+function generateUpdateFields(schema) {
+  if (!schema || schema.type !== "object" || !schema.properties) {
+    return null;
+  }
+  const fields = {};
+  const idPatterns = ["id", "Id", "ID", "_id", "uuid", "key"];
+  for (const [key, propSchema] of Object.entries(schema.properties)) {
+    if (typeof propSchema === "boolean") continue;
+    const isIdField = idPatterns.some((p) => key === p || key.endsWith(p));
+    if (isIdField) continue;
+    if (Object.keys(fields).length < 2) {
+      fields[key] = getSampleValue(propSchema, key);
+    }
+  }
+  return Object.keys(fields).length > 0 ? fields : null;
+}
+function generateSmartExample(toolName, inputSchema, description) {
+  const intent = detectToolIntent(toolName, description);
+  switch (intent) {
+    case "create":
+      return generateCreateExample(toolName, inputSchema);
+    case "get":
+      return generateGetExample(toolName, inputSchema);
+    case "list":
+      return hasPaginationParams(inputSchema) ? generatePaginationExample(toolName) : generateListExample(toolName, inputSchema);
+    case "update":
+      return generateUpdateExample(toolName, inputSchema);
+    case "delete":
+      return generateDeleteExample(toolName, inputSchema);
+    case "search":
+      return generateSearchExample(toolName, inputSchema);
+    default:
+      return generateBasicExample(toolName, inputSchema);
+  }
+}
+
+// plugins/plugin-codecall/src/utils/mcp-result.ts
+function extractResultFromCallToolResult(mcpResult) {
+  if (mcpResult.isError) {
+    const errorContent = mcpResult.content?.[0];
+    if (errorContent && "text" in errorContent) {
+      throw new Error(errorContent.text);
+    }
+    throw new Error("Tool execution failed");
+  }
+  const content = mcpResult.content;
+  if (!content || content.length === 0) {
+    return void 0;
+  }
+  if (content.length === 1 && content[0].type === "text") {
+    try {
+      return JSON.parse(content[0].text);
+    } catch {
+      return content[0].text;
+    }
+  }
+  return content;
+}
+
+// plugins/plugin-codecall/src/errors/tool-call.errors.ts
+var TOOL_CALL_ERROR_CODES = {
+  NOT_FOUND: "NOT_FOUND",
+  VALIDATION: "VALIDATION",
+  EXECUTION: "EXECUTION",
+  TIMEOUT: "TIMEOUT",
+  ACCESS_DENIED: "ACCESS_DENIED",
+  SELF_REFERENCE: "SELF_REFERENCE"
+};
+function createToolCallError(code, toolName, rawMessage) {
+  const sanitizedMessage = getSanitizedMessage(code, toolName, rawMessage);
+  return Object.freeze({
+    code,
+    message: sanitizedMessage,
+    toolName
+  });
+}
+function getSanitizedMessage(code, toolName, rawMessage) {
+  switch (code) {
+    case TOOL_CALL_ERROR_CODES.NOT_FOUND:
+      return `Tool "${toolName}" was not found`;
+    case TOOL_CALL_ERROR_CODES.VALIDATION:
+      return rawMessage ? sanitizeValidationMessage(rawMessage) : `Input validation failed for tool "${toolName}"`;
+    case TOOL_CALL_ERROR_CODES.EXECUTION:
+      return `Tool "${toolName}" execution failed`;
+    case TOOL_CALL_ERROR_CODES.TIMEOUT:
+      return `Tool "${toolName}" execution timed out`;
+    case TOOL_CALL_ERROR_CODES.ACCESS_DENIED:
+      return `Access denied for tool "${toolName}"`;
+    case TOOL_CALL_ERROR_CODES.SELF_REFERENCE:
+      return `Cannot call CodeCall tools from within AgentScript`;
+    default:
+      return `An error occurred while calling "${toolName}"`;
+  }
+}
+function sanitizeValidationMessage(message) {
+  let sanitized = message.replace(/(?:\/[\w.-]+)+|(?:[A-Za-z]:\\[\w\\.-]+)+/g, "[path]");
+  sanitized = sanitized.replace(/\bat line \d+/gi, "");
+  sanitized = sanitized.replace(/\bline \d+/gi, "");
+  sanitized = sanitized.replace(/:\d+:\d+/g, "");
+  sanitized = sanitized.replace(/\n\s*at .*/g, "");
+  if (sanitized.length > 200) {
+    sanitized = sanitized.substring(0, 200) + "...";
+  }
+  return sanitized.trim();
+}
+var SelfReferenceError = class extends Error {
+  code = TOOL_CALL_ERROR_CODES.SELF_REFERENCE;
+  toolName;
+  constructor(toolName) {
+    super(`Self-reference attack: Attempted to call CodeCall tool "${toolName}" from within AgentScript`);
+    this.name = "SelfReferenceError";
+    this.toolName = toolName;
+    Object.freeze(this);
+  }
+};
+
+// plugins/plugin-codecall/src/security/self-reference-guard.ts
+var CODECALL_TOOL_PREFIX = "codecall:";
+var BLOCKED_CODECALL_TOOLS = Object.freeze(
+  /* @__PURE__ */ new Set(["codecall:search", "codecall:describe", "codecall:execute", "codecall:invoke"])
+);
+function isBlockedSelfReference(toolName) {
+  const normalizedName = toolName.toLowerCase().trim();
+  if (normalizedName.startsWith(CODECALL_TOOL_PREFIX)) {
+    return true;
+  }
+  if (BLOCKED_CODECALL_TOOLS.has(toolName)) {
+    return true;
+  }
+  return false;
+}
+function assertNotSelfReference(toolName) {
+  if (isBlockedSelfReference(toolName)) {
+    throw new SelfReferenceError(toolName);
+  }
+}
+
+// plugins/plugin-codecall/src/tools/describe.tool.ts
+var DescribeTool = class extends import_sdk3.ToolContext {
+  async execute(input) {
+    const { toolNames } = input;
+    const tools = [];
+    const notFound = [];
+    const allTools = this.scope.tools.getTools(true);
+    const toolMap = new Map(allTools.map((t) => [t.name, t]));
+    const fullNameMap = new Map(allTools.map((t) => [t.fullName, t]));
+    for (const toolName of toolNames) {
+      if (isBlockedSelfReference(toolName)) {
+        notFound.push(toolName);
+        continue;
+      }
+      const tool = toolMap.get(toolName) || fullNameMap.get(toolName);
+      if (!tool) {
+        notFound.push(toolName);
+        continue;
+      }
+      const appId = this.extractAppId(tool);
+      const inputSchema = this.getInputSchema(tool);
+      const outputSchema = this.toJsonSchema(tool.outputSchema);
+      const usageExamples = this.generateExamples(tool, inputSchema ?? void 0);
+      tools.push({
+        name: tool.name,
+        appId,
+        description: tool.metadata?.description || `Tool: ${tool.name}`,
+        inputSchema: inputSchema || null,
+        outputSchema: outputSchema || null,
+        annotations: tool.metadata?.annotations,
+        usageExamples
+      });
+    }
+    return {
+      tools,
+      notFound: notFound.length > 0 ? notFound : void 0
+    };
+  }
+  /**
+   * Get the input schema for a tool, converting from Zod to JSON Schema.
+   * This ensures that property descriptions from .describe() are included.
+   *
+   * Priority:
+   * 1. Convert from tool.inputSchema (Zod) to get descriptions
+   * 2. Fall back to rawInputSchema if conversion fails
+   * 3. Return null if no schema available
+   */
+  getInputSchema(tool) {
+    if (tool.inputSchema && typeof tool.inputSchema === "object" && Object.keys(tool.inputSchema).length > 0) {
+      try {
+        const firstValue = Object.values(tool.inputSchema)[0];
+        if (firstValue instanceof import_zod4.ZodType) {
+          return (0, import_v4.toJSONSchema)(import_zod4.z.object(tool.inputSchema));
+        }
+      } catch {
+      }
+    }
+    if (tool.rawInputSchema) {
+      return tool.rawInputSchema;
+    }
+    return null;
+  }
+  /**
+   * Convert a schema to JSON Schema format.
+   * Handles Zod schemas, raw shapes, and already-JSON-Schema objects.
+   *
+   * Uses Zod v4's built-in z.toJSONSchema() for conversion.
+   */
+  toJsonSchema(schema) {
+    if (!schema) {
+      return null;
+    }
+    if (schema instanceof import_zod4.ZodType) {
+      try {
+        return (0, import_v4.toJSONSchema)(schema);
+      } catch {
+        return null;
+      }
+    }
+    if (typeof schema === "object" && schema !== null && !Array.isArray(schema)) {
+      const obj = schema;
+      const firstValue = Object.values(obj)[0];
+      if (firstValue instanceof import_zod4.ZodType) {
+        try {
+          return (0, import_v4.toJSONSchema)(import_zod4.z.object(obj));
+        } catch {
+          return null;
+        }
+      }
+      if ("type" in obj || "properties" in obj || "$schema" in obj) {
+        return schema;
+      }
+    }
+    if (typeof schema === "string") {
+      return null;
+    }
+    if (Array.isArray(schema)) {
+      return null;
+    }
+    return null;
+  }
+  /**
+   * Extract app ID from tool metadata or owner.
+   */
+  extractAppId(tool) {
+    if (tool.metadata?.codecall?.appId) {
+      return tool.metadata.codecall.appId;
+    }
+    if (tool.metadata?.source) {
+      return tool.metadata.source;
+    }
+    if (tool.owner?.id) {
+      return tool.owner.id;
+    }
+    const nameParts = tool.name?.split(":");
+    if (nameParts && nameParts.length > 1) {
+      return nameParts[0];
+    }
+    return "unknown";
+  }
+  /**
+   * Generate up to 5 usage examples for a tool.
+   *
+   * Priority:
+   * 1. User-provided examples from @Tool decorator metadata (up to 5)
+   * 2. Smart intent-based generation to fill remaining slots
+   * 3. Returns at least 1 example
+   */
+  generateExamples(tool, inputSchema) {
+    const result = [];
+    const examples = tool.metadata?.examples;
+    if (examples && Array.isArray(examples)) {
+      for (const ex of examples.slice(0, 5)) {
+        result.push({
+          description: ex.description || "Example usage",
+          code: `const result = await callTool('${tool.name}', ${JSON.stringify(ex.input, null, 2)});
+return result;`
+        });
+      }
+    }
+    if (result.length < 5) {
+      result.push(generateSmartExample(tool.name, inputSchema, tool.metadata?.description));
+    }
+    return result.slice(0, 5);
+  }
+};
+DescribeTool = __decorateClass([
+  (0, import_sdk3.Tool)({
+    name: "codecall:describe",
+    cache: {
+      ttl: 60,
+      // 1 minute
+      slideWindow: false
+    },
+    codecall: {
+      enabledInCodeCall: false,
+      visibleInListTools: true
+    },
+    description: describeToolDescription,
+    inputSchema: describeToolInputSchema,
+    outputSchema: describeToolOutputSchema,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: true
+    }
+  })
+], DescribeTool);
+
+// plugins/plugin-codecall/src/tools/execute.tool.ts
+var import_sdk5 = require("@frontmcp/sdk");
+
+// plugins/plugin-codecall/src/tools/execute.schema.ts
+var import_zod5 = require("zod");
+var MIN_EXECUTE_SCRIPT_LENGTH = 'return callTool("a",{})'.length;
+var executeToolDescription = `Execute AgentScript (safe JS subset) for multi-tool orchestration.
+
+API: await callTool(name, args, opts?)
+- Default: throws on error
+- Safe mode: { throwOnError: false } \u2192 returns { success, data?, error? }
+
+EXAMPLE:
+const users = await callTool('users:list', { active: true });
+const results = [];
+for (const u of users.items) {
+  const orders = await callTool('orders:list', { userId: u.id });
+  results.push({ id: u.id, total: orders.items.reduce((s,o) => s + o.amount, 0) });
+}
+return results;
+
+ALLOWED: for, for-of, arrow fn, map/filter/reduce/find, Math.*, JSON.*, if/else, destructuring, spread, template literals
+BLOCKED: while, do-while, function decl, eval, require, fetch, setTimeout, process, globalThis
+
+ERRORS: NOT_FOUND | VALIDATION | EXECUTION | TIMEOUT | ACCESS_DENIED
+STATUS: ok | syntax_error | illegal_access | runtime_error | tool_error | timeout
+LIMITS: 10K iter/loop, 30s timeout, 100 calls max`;
+var executeToolInputSchema = import_zod5.z.object({
+  script: import_zod5.z.string().min(MIN_EXECUTE_SCRIPT_LENGTH).max(100 * 1024).describe(
+    "JavaScript code to execute in the sandbox. Must return a value (implicitly or via explicit return). Use callTool(name, input) to invoke tools."
+  ),
+  allowedTools: import_zod5.z.array(import_zod5.z.string()).optional().describe(
+    'Optional whitelist of tool names that can be called from this script. If not provided, all indexed tools are available. Example: ["users:list", "billing:getInvoice"]'
+  )
+});
+var syntaxErrorPayloadSchema = import_zod5.z.object({
+  message: import_zod5.z.string(),
+  location: import_zod5.z.object({
+    line: import_zod5.z.number(),
+    column: import_zod5.z.number()
+  }).optional()
+});
+var illegalAccessErrorPayloadSchema = import_zod5.z.object({
+  message: import_zod5.z.string(),
+  kind: import_zod5.z.union([
+    import_zod5.z.literal("IllegalBuiltinAccess"),
+    import_zod5.z.literal("DisallowedGlobal"),
+    import_zod5.z.string()
+    // same as your original type: 'A' | 'B' | string
+  ])
+});
+var runtimeErrorPayloadSchema = import_zod5.z.object({
+  source: import_zod5.z.literal("script"),
+  message: import_zod5.z.string(),
+  name: import_zod5.z.string().optional(),
+  stack: import_zod5.z.string().optional()
+});
+var toolErrorPayloadSchema = import_zod5.z.object({
+  source: import_zod5.z.literal("tool"),
+  toolName: import_zod5.z.string(),
+  toolInput: import_zod5.z.unknown(),
+  message: import_zod5.z.string(),
+  code: import_zod5.z.string().optional(),
+  details: import_zod5.z.unknown().optional()
+});
+var timeoutErrorPayloadSchema = import_zod5.z.object({
+  message: import_zod5.z.string()
+});
+var codeCallOkResultSchema = import_zod5.z.object({
+  status: import_zod5.z.literal("ok"),
+  result: import_zod5.z.unknown(),
+  logs: import_zod5.z.array(import_zod5.z.string()).optional()
+});
+var codeCallSyntaxErrorResultSchema = import_zod5.z.object({
+  status: import_zod5.z.literal("syntax_error"),
+  error: syntaxErrorPayloadSchema
+});
+var codeCallIllegalAccessResultSchema = import_zod5.z.object({
+  status: import_zod5.z.literal("illegal_access"),
+  error: illegalAccessErrorPayloadSchema
+});
+var codeCallRuntimeErrorResultSchema = import_zod5.z.object({
+  status: import_zod5.z.literal("runtime_error"),
+  error: runtimeErrorPayloadSchema
+});
+var codeCallToolErrorResultSchema = import_zod5.z.object({
+  status: import_zod5.z.literal("tool_error"),
+  error: toolErrorPayloadSchema
+});
+var codeCallTimeoutResultSchema = import_zod5.z.object({
+  status: import_zod5.z.literal("timeout"),
+  error: timeoutErrorPayloadSchema
+});
+var executeToolOutputSchema = import_zod5.z.discriminatedUnion("status", [
+  codeCallOkResultSchema,
+  codeCallSyntaxErrorResultSchema,
+  codeCallIllegalAccessResultSchema,
+  codeCallRuntimeErrorResultSchema,
+  codeCallToolErrorResultSchema,
+  codeCallTimeoutResultSchema
+]);
+
+// plugins/plugin-codecall/src/providers/code-call.config.ts
+var import_sdk4 = require("@frontmcp/sdk");
+var CodeCallConfig = class extends import_sdk4.BaseConfig {
+  constructor(options = {}) {
+    const parsedConfig = codeCallPluginOptionsSchema.parse(options);
+    const resolvedVm = resolveVmOptions(parsedConfig.vm);
+    super({ ...parsedConfig, resolvedVm });
+  }
+};
+CodeCallConfig = __decorateClass([
+  (0, import_sdk4.Provider)({
+    name: "codecall:config",
+    description: "CodeCall plugin configuration with validated defaults",
+    scope: import_sdk4.ProviderScope.GLOBAL
+  })
+], CodeCallConfig);
+function resolveVmOptions(vmOptions) {
+  const preset = vmOptions?.preset ?? "secure";
+  const base = presetDefaults(preset);
+  return {
+    ...base,
+    ...vmOptions,
+    disabledBuiltins: vmOptions?.disabledBuiltins ?? base.disabledBuiltins,
+    disabledGlobals: vmOptions?.disabledGlobals ?? base.disabledGlobals
+  };
+}
+function presetDefaults(preset) {
+  switch (preset) {
+    case "locked_down":
+      return {
+        preset,
+        timeoutMs: 2e3,
+        allowLoops: false,
+        allowConsole: false,
+        maxSteps: 2e3,
+        disabledBuiltins: ["eval", "Function", "AsyncFunction"],
+        disabledGlobals: [
+          "require",
+          "process",
+          "fetch",
+          "setTimeout",
+          "setInterval",
+          "setImmediate",
+          "global",
+          "globalThis"
+        ]
+      };
+    case "balanced":
+      return {
+        preset,
+        timeoutMs: 5e3,
+        allowLoops: true,
+        allowConsole: true,
+        maxSteps: 1e4,
+        disabledBuiltins: ["eval", "Function", "AsyncFunction"],
+        disabledGlobals: ["require", "process", "fetch"]
+      };
+    case "experimental":
+      return {
+        preset,
+        timeoutMs: 1e4,
+        allowLoops: true,
+        allowConsole: true,
+        maxSteps: 2e4,
+        disabledBuiltins: ["eval", "Function", "AsyncFunction"],
+        disabledGlobals: ["require", "process"]
+      };
+    case "secure":
+    default:
+      return {
+        preset: "secure",
+        timeoutMs: 3500,
+        allowLoops: false,
+        allowConsole: true,
+        maxSteps: 5e3,
+        disabledBuiltins: ["eval", "Function", "AsyncFunction"],
+        disabledGlobals: [
+          "require",
+          "process",
+          "fetch",
+          "setTimeout",
+          "setInterval",
+          "setImmediate",
+          "global",
+          "globalThis"
+        ]
+      };
+  }
+}
+
+// plugins/plugin-codecall/src/tools/execute.tool.ts
+function getErrorCode(error) {
+  if (!(error instanceof Error)) {
+    return TOOL_CALL_ERROR_CODES.EXECUTION;
+  }
+  if (error.name === "ZodError" || error.message?.includes("validation")) {
+    return TOOL_CALL_ERROR_CODES.VALIDATION;
+  }
+  if (error.message?.includes("timeout") || error.message?.includes("timed out")) {
+    return TOOL_CALL_ERROR_CODES.TIMEOUT;
+  }
+  if (error.name === "ToolNotFoundError" || error.message?.includes("not found")) {
+    return TOOL_CALL_ERROR_CODES.NOT_FOUND;
+  }
+  return TOOL_CALL_ERROR_CODES.EXECUTION;
+}
+var ExecuteTool = class extends import_sdk5.ToolContext {
+  async execute(input) {
+    const { script, allowedTools } = input;
+    const allowedToolSet = allowedTools ? new Set(allowedTools) : null;
+    const environment = {
+      callTool: async (name, toolInput, options) => {
+        const throwOnError = options?.throwOnError !== false;
+        assertNotSelfReference(name);
+        if (allowedToolSet && !allowedToolSet.has(name)) {
+          const error = createToolCallError(TOOL_CALL_ERROR_CODES.ACCESS_DENIED, name);
+          if (throwOnError) {
+            throw error;
+          }
+          return { success: false, error };
+        }
+        try {
+          const request = {
+            method: "tools/call",
+            params: {
+              name,
+              arguments: toolInput
+            }
+          };
+          const ctx = {
+            authInfo: this.authInfo
+          };
+          const mcpResult = await this.scope.runFlow("tools:call-tool", { request, ctx });
+          if (!mcpResult) {
+            const error = createToolCallError(TOOL_CALL_ERROR_CODES.EXECUTION, name, "Flow returned no result");
+            if (throwOnError) {
+              throw error;
+            }
+            return { success: false, error };
+          }
+          const result = extractResultFromCallToolResult(mcpResult);
+          if (throwOnError) {
+            return result;
+          }
+          return { success: true, data: result };
+        } catch (error) {
+          const errorCode = getErrorCode(error);
+          const rawMessage = error instanceof Error ? error.message : void 0;
+          const sanitizedError = createToolCallError(errorCode, name, rawMessage);
+          if (throwOnError) {
+            throw sanitizedError;
+          }
+          return { success: false, error: sanitizedError };
+        }
+      },
+      getTool: (name) => {
+        try {
+          const tools = this.scope.tools.getTools(true);
+          const tool = tools.find((t) => t.name === name || t.fullName === name);
+          if (!tool) return void 0;
+          return {
+            name: tool.name,
+            description: tool.metadata?.description,
+            inputSchema: tool.rawInputSchema,
+            outputSchema: tool.outputSchema
+          };
+        } catch {
+          return void 0;
+        }
+      },
+      console: this.get(CodeCallConfig).get("resolvedVm.allowConsole") ? console : void 0,
+      mcpLog: (level, message, metadata) => {
+        this.logger?.[level](message, metadata);
+      },
+      mcpNotify: (event, payload) => {
+        this.logger?.debug("Notification sent", { event, payload });
+      }
+    };
+    const enclaveService = this.get(EnclaveService);
+    const config = this.get(CodeCallConfig);
+    try {
+      const executionResult = await enclaveService.execute(script, environment);
+      if (executionResult.timedOut) {
+        return {
+          status: "timeout",
+          error: {
+            message: `Script execution timed out after ${config.getAll().resolvedVm.timeoutMs}ms`
+          }
+        };
+      }
+      if (!executionResult.success) {
+        const error = executionResult.error;
+        if (error.code === "VALIDATION_ERROR" || error.name === "ValidationError") {
+          return {
+            status: "illegal_access",
+            error: {
+              kind: "IllegalBuiltinAccess",
+              message: error.message
+            }
+          };
+        }
+        if (error.toolName) {
+          return {
+            status: "tool_error",
+            error: {
+              source: "tool",
+              toolName: error.toolName,
+              toolInput: error.toolInput,
+              message: error.message,
+              code: error.code,
+              details: error.details
+            }
+          };
+        }
+        return {
+          status: "runtime_error",
+          error: {
+            source: "script",
+            message: error.message,
+            name: error.name,
+            stack: error.stack
+          }
+        };
+      }
+      return {
+        status: "ok",
+        result: executionResult.result,
+        logs: executionResult.logs.length > 0 ? executionResult.logs : void 0
+      };
+    } catch (error) {
+      const errorName = error instanceof Error ? error.name : "Error";
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const errorStack = error instanceof Error ? error.stack : void 0;
+      const errorLoc = error.loc;
+      if (errorName === "SyntaxError" || errorMessage?.includes("syntax")) {
+        return {
+          status: "syntax_error",
+          error: {
+            message: errorMessage || "Syntax error in script",
+            location: errorLoc ? { line: errorLoc.line, column: errorLoc.column } : void 0
+          }
+        };
+      }
+      return {
+        status: "runtime_error",
+        error: {
+          source: "script",
+          message: errorMessage || "An unexpected error occurred during script execution",
+          name: errorName,
+          stack: errorStack
+        }
+      };
+    }
+  }
+};
+ExecuteTool = __decorateClass([
+  (0, import_sdk5.Tool)({
+    name: "codecall:execute",
+    cache: {
+      ttl: 0,
+      // No caching - each execution is unique
+      slideWindow: false
+    },
+    codecall: {
+      enabledInCodeCall: false,
+      visibleInListTools: true
+    },
+    description: executeToolDescription,
+    inputSchema: executeToolInputSchema,
+    outputSchema: executeToolOutputSchema
+  })
+], ExecuteTool);
+
+// plugins/plugin-codecall/src/tools/invoke.tool.ts
+var import_sdk6 = require("@frontmcp/sdk");
+
+// plugins/plugin-codecall/src/tools/invoke.schema.ts
+var import_zod6 = require("zod");
+var import_types2 = require("@modelcontextprotocol/sdk/types.js");
+var invokeToolDescription = `Call ONE tool directly. Returns standard MCP CallToolResult.
+
+USE invoke: single tool, no transformation
+USE execute: multiple tools, loops, filtering, joining
+
+INPUT: tool (string), input (object matching tool schema)
+OUTPUT: MCP CallToolResult (same as standard tool call)
+ERRORS: tool_not_found (\u2192 re-search) | validation_error | execution_error | permission_denied
+
+FLOW: search \u2192 describe \u2192 invoke`;
+var invokeToolInputSchema = import_zod6.z.object({
+  tool: import_zod6.z.string().describe(
+    'The name of the tool to invoke (e.g., "users:getById", "billing:getInvoice"). Must be a tool you discovered via codecall:search.'
+  ),
+  input: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.unknown()).describe(
+    "The input parameters for the tool. Structure must match the tool's input schema (check codecall:describe for schema details)."
+  )
+});
+var invokeToolOutputSchema = import_types2.CallToolResultSchema;
+
+// plugins/plugin-codecall/src/tools/invoke.tool.ts
+function buildErrorResult(message) {
+  return {
+    content: [{ type: "text", text: message }],
+    isError: true
+  };
+}
+var InvokeTool = class extends import_sdk6.ToolContext {
+  async execute(input) {
+    const { tool: toolName, input: toolInput } = input;
+    if (isBlockedSelfReference(toolName)) {
+      return buildErrorResult(
+        `Tool "${toolName}" cannot be invoked directly. CodeCall tools are internal and not accessible via codecall:invoke.`
+      );
+    }
+    const request = {
+      method: "tools/call",
+      params: {
+        name: toolName,
+        arguments: toolInput
+      }
+    };
+    const ctx = {
+      authInfo: this.authInfo
+    };
+    const result = await this.scope.runFlow("tools:call-tool", { request, ctx });
+    if (!result) {
+      return buildErrorResult(`Tool "${toolName}" not found. Use codecall:search to discover available tools.`);
+    }
+    return result;
+  }
+};
+InvokeTool = __decorateClass([
+  (0, import_sdk6.Tool)({
+    name: "codecall:invoke",
+    cache: {
+      ttl: 0,
+      // No caching - each invocation is unique
+      slideWindow: false
+    },
+    codecall: {
+      enabledInCodeCall: false,
+      visibleInListTools: true
+    },
+    description: invokeToolDescription,
+    inputSchema: invokeToolInputSchema,
+    outputSchema: invokeToolOutputSchema
+  })
+], InvokeTool);
+
+// plugins/plugin-codecall/src/codecall.plugin.ts
+var import_plugin_cache = __toESM(require("@frontmcp/plugin-cache"));
+var CodeCallPlugin = class extends import_sdk7.DynamicPlugin {
+  options;
+  constructor(options = {}) {
+    super();
+    this.options = codeCallPluginOptionsSchema.parse(options);
+    console.log("[CodeCall] Plugin initialized with mode:", this.options.mode);
+  }
+  /**
+   * Dynamic providers allow you to configure the plugin with custom options
+   * without touching the plugin decorator.
+   */
+  static dynamicProviders(options) {
+    const parsedOptions = codeCallPluginOptionsSchema.parse(options);
+    const config = new CodeCallConfig(parsedOptions);
+    return [
+      {
+        name: "codecall:config",
+        provide: CodeCallConfig,
+        useValue: config
+      },
+      {
+        name: "codecall:enclave",
+        provide: EnclaveService,
+        inject: () => [CodeCallConfig],
+        useFactory: async (cfg) => {
+          return new EnclaveService(cfg);
+        }
+      },
+      {
+        name: "codecall:tool-search",
+        provide: ToolSearchService,
+        inject: () => [import_sdk7.ScopeEntry],
+        useFactory: async (scope) => {
+          return new ToolSearchService(
+            {
+              embeddingOptions: parsedOptions.embedding,
+              mode: parsedOptions.mode,
+              includeTools: parsedOptions["includeTools"]
+            },
+            scope
+          );
+        }
+      }
+    ];
+  }
+  async adjustListTools(flowCtx) {
+    const { resolvedTools } = flowCtx.state;
+    console.log("[CodeCall] adjustListTools hook called, mode:", this.options.mode);
+    console.log("[CodeCall] Tools before filter:", resolvedTools?.length ?? 0);
+    if (!resolvedTools || resolvedTools.length === 0) {
+      console.log("[CodeCall] No tools to filter, returning early");
+      return;
+    }
+    const filteredTools = resolvedTools.filter(({ tool }) => {
+      return this.shouldShowInListTools(tool, this.options.mode);
+    });
+    console.log("[CodeCall] Tools after filter:", filteredTools.length);
+    flowCtx.state.set("resolvedTools", filteredTools);
+  }
+  /**
+   * Determine if a tool should be visible in list_tools based on mode.
+   *
+   * @param tool - The tool entry to check
+   * @param mode - The current CodeCall mode
+   * @returns true if tool should be visible
+   */
+  shouldShowInListTools(tool, mode) {
+    if (this.isCodeCallTool(tool)) {
+      return true;
+    }
+    const codecallMeta = this.getCodeCallMetadata(tool);
+    switch (mode) {
+      case "codecall_only":
+        return codecallMeta?.visibleInListTools === true;
+      case "codecall_opt_in":
+        return true;
+      case "metadata_driven":
+        if (codecallMeta?.visibleInListTools === false) {
+          return false;
+        }
+        return true;
+      default:
+        return true;
+    }
+  }
+  /**
+   * Check if a tool is a CodeCall meta-tool.
+   * CodeCall meta-tools always remain visible.
+   */
+  isCodeCallTool(tool) {
+    const name = tool.name || tool.fullName;
+    return name.startsWith("codecall:");
+  }
+  /**
+   * Extract CodeCall-specific metadata from a tool.
+   */
+  getCodeCallMetadata(tool) {
+    return tool.metadata?.codecall;
+  }
+};
+__decorateClass([
+  import_sdk7.ListToolsHook.Did("resolveConflicts", { priority: 1e3 })
+], CodeCallPlugin.prototype, "adjustListTools", 1);
+CodeCallPlugin = __decorateClass([
+  (0, import_sdk7.Plugin)({
+    name: "codecall",
+    description: "CodeCall plugin: AgentScript-based meta-tools for orchestrating MCP tools",
+    providers: [],
+    plugins: [import_plugin_cache.default],
+    tools: [SearchTool, DescribeTool, ExecuteTool, InvokeTool]
+  })
+], CodeCallPlugin);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CodeCallPlugin,
+  codeCallDirectCallsOptionsSchema,
+  codeCallEmbeddingOptionsSchema,
+  codeCallModeSchema,
+  codeCallPluginOptionsSchema,
+  codeCallSidecarOptionsSchema,
+  codeCallVmOptionsSchema,
+  codeCallVmPresetSchema,
+  embeddingStrategySchema,
+  synonymExpansionConfigSchema
+});