@frontmcp/plugins 0.6.3 → 0.7.1

package/index.js

@@ -1,15 +1,8 @@
 "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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-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))
@@ -18,2956 +11,20 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 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;
-};
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // libs/plugins/src/index.ts
 var index_exports = {};
-__export(index_exports, {
-  CachePlugin: () => CachePlugin,
-  CodeCallPlugin: () => CodeCallPlugin
-});
 module.exports = __toCommonJS(index_exports);
-
-// libs/plugins/src/cache/cache.plugin.ts
-var import_sdk4 = require("@frontmcp/sdk");
-
-// libs/plugins/src/cache/providers/cache-redis.provider.ts
-var import_ioredis = __toESM(require("ioredis"));
-var import_sdk = require("@frontmcp/sdk");
-var CacheRedisProvider = class {
-  client;
-  constructor(options) {
-    if (options.type !== "redis" && options.type !== "redis-client") {
-      throw new Error("Invalid cache provider type");
-    }
-    if (options.type === "redis-client") {
-      this.client = options.client;
-      return;
-    }
-    this.client = new import_ioredis.default({
-      lazyConnect: false,
-      maxRetriesPerRequest: 3,
-      ...options.config
-    });
-    this.client.on("connect", () => console.log("[Redis] Connected"));
-    this.client.on("error", (err) => console.error("[Redis] Error:", err));
-  }
-  /** Set a value (auto-stringifies objects) */
-  async setValue(key, value, ttlSeconds) {
-    const strValue = typeof value === "string" ? value : JSON.stringify(value);
-    if (ttlSeconds && ttlSeconds > 0) {
-      await this.client.set(key, strValue, "EX", ttlSeconds);
-    } else {
-      await this.client.set(key, strValue);
-    }
-  }
-  /** Get a value and automatically parse JSON if possible */
-  async getValue(key, defaultValue) {
-    const raw = await this.client.get(key);
-    if (raw === null) return defaultValue;
-    try {
-      return JSON.parse(raw);
-    } catch {
-      return raw;
-    }
-  }
-  /** Delete a key */
-  async delete(key) {
-    await this.client.del(key);
-  }
-  /** Check if a key exists */
-  async exists(key) {
-    return await this.client.exists(key) === 1;
-  }
-  /** Gracefully close the Redis connection */
-  async close() {
-    await this.client.quit();
-  }
-};
-CacheRedisProvider = __decorateClass([
-  (0, import_sdk.Provider)({
-    name: "provider:cache:redis",
-    description: "Redis-based cache provider",
-    scope: import_sdk.ProviderScope.GLOBAL
-  })
-], CacheRedisProvider);
-
-// libs/plugins/src/cache/providers/cache-memory.provider.ts
-var import_sdk2 = require("@frontmcp/sdk");
-var MAX_TIMEOUT_MS = 2 ** 31 - 1;
-var CacheMemoryProvider = class {
-  memory = /* @__PURE__ */ new Map();
-  sweeper;
-  constructor(sweepIntervalTTL = 60) {
-    this.sweeper = setInterval(() => this.sweep(), sweepIntervalTTL * 1e3);
-    this.sweeper.unref?.();
-  }
-  /** Set a value (auto-stringifies objects) */
-  async setValue(key, value, ttlSeconds) {
-    const strValue = typeof value === "string" ? value : JSON.stringify(value);
-    const existing = this.memory.get(key);
-    if (existing?.timeout) clearTimeout(existing.timeout);
-    const entry = { value: strValue };
-    if (ttlSeconds && ttlSeconds > 0) {
-      const ttlMs = ttlSeconds * 1e3;
-      entry.expiresAt = Date.now() + ttlMs;
-      if (ttlMs <= MAX_TIMEOUT_MS) {
-        entry.timeout = setTimeout(() => {
-          const e = this.memory.get(key);
-          if (e && e.expiresAt && e.expiresAt <= Date.now()) {
-            this.memory.delete(key);
-          }
-        }, ttlMs);
-        entry.timeout.unref?.();
-      }
-    }
-    this.memory.set(key, entry);
-  }
-  /** Get a value and automatically parse JSON if possible */
-  async getValue(key, defaultValue) {
-    const entry = this.memory.get(key);
-    if (!entry) return defaultValue;
-    if (this.isExpired(entry)) {
-      await this.delete(key);
-      return defaultValue;
-    }
-    const raw = entry.value;
-    try {
-      return JSON.parse(raw);
-    } catch {
-      return raw;
-    }
-  }
-  /** Delete a key */
-  async delete(key) {
-    const entry = this.memory.get(key);
-    if (entry?.timeout) clearTimeout(entry.timeout);
-    this.memory.delete(key);
-  }
-  /** Check if a key exists (and not expired) */
-  async exists(key) {
-    const entry = this.memory.get(key);
-    if (!entry) return false;
-    if (this.isExpired(entry)) {
-      await this.delete(key);
-      return false;
-    }
-    return true;
-  }
-  /** Gracefully close the provider */
-  async close() {
-    if (this.sweeper) clearInterval(this.sweeper);
-    for (const [, entry] of this.memory) {
-      if (entry.timeout) clearTimeout(entry.timeout);
-    }
-    this.memory.clear();
-  }
-  // ---- internals ----
-  isExpired(entry) {
-    return entry.expiresAt !== void 0 && entry.expiresAt <= Date.now();
-  }
-  /** Periodically remove expired keys to keep memory tidy */
-  sweep() {
-    const now = Date.now();
-    for (const [key, entry] of this.memory) {
-      if (entry.expiresAt !== void 0 && entry.expiresAt <= now) {
-        if (entry.timeout) clearTimeout(entry.timeout);
-        this.memory.delete(key);
-      }
-    }
-  }
-};
-CacheMemoryProvider = __decorateClass([
-  (0, import_sdk2.Provider)({
-    name: "provider:cache:memory",
-    description: "Memory-based cache provider",
-    scope: import_sdk2.ProviderScope.GLOBAL
-  })
-], CacheMemoryProvider);
-
-// libs/plugins/src/cache/providers/cache-vercel-kv.provider.ts
-var import_sdk3 = require("@frontmcp/sdk");
-var CacheVercelKvProvider = class {
-  kv;
-  keyPrefix;
-  defaultTTL;
-  constructor(options = {}) {
-    const vercelKv = require("@vercel/kv");
-    const hasUrl = options.url !== void 0;
-    const hasToken = options.token !== void 0;
-    if (hasUrl !== hasToken) {
-      throw new Error(
-        `CacheVercelKvProvider: Both 'url' and 'token' must be provided together, or neither. Received: url=${hasUrl ? "provided" : "missing"}, token=${hasToken ? "provided" : "missing"}`
-      );
-    }
-    if (options.url && options.token) {
-      this.kv = vercelKv.createClient({
-        url: options.url,
-        token: options.token
-      });
-    } else {
-      this.kv = vercelKv.kv;
-    }
-    this.keyPrefix = options.keyPrefix ?? "cache:";
-    this.defaultTTL = options.defaultTTL ?? 60 * 60 * 24;
-  }
-  prefixKey(key) {
-    return `${this.keyPrefix}${key}`;
-  }
-  /** Set a value (auto-stringifies objects) */
-  async setValue(key, value, ttlSeconds) {
-    const strValue = typeof value === "string" ? value : JSON.stringify(value);
-    const ttl = ttlSeconds ?? this.defaultTTL;
-    if (ttl > 0) {
-      await this.kv.set(this.prefixKey(key), strValue, { ex: ttl });
-    } else {
-      await this.kv.set(this.prefixKey(key), strValue);
-    }
-  }
-  /** Get a value and automatically parse JSON if possible */
-  async getValue(key, defaultValue) {
-    const raw = await this.kv.get(this.prefixKey(key));
-    if (raw === null || raw === void 0) return defaultValue;
-    if (typeof raw === "string") {
-      try {
-        return JSON.parse(raw);
-      } catch {
-        return raw;
-      }
-    }
-    return raw;
-  }
-  /** Delete a key */
-  async delete(key) {
-    await this.kv.del(this.prefixKey(key));
-  }
-  /** Check if a key exists */
-  async exists(key) {
-    return await this.kv.exists(this.prefixKey(key)) === 1;
-  }
-  /** Gracefully close the provider (no-op for Vercel KV - stateless REST API) */
-  async close() {
-  }
-};
-CacheVercelKvProvider = __decorateClass([
-  (0, import_sdk3.Provider)({
-    name: "provider:cache:vercel-kv",
-    description: "Vercel KV-based cache provider",
-    scope: import_sdk3.ProviderScope.GLOBAL
-  })
-], CacheVercelKvProvider);
-
-// libs/plugins/src/cache/cache.symbol.ts
-var CacheStoreToken = /* @__PURE__ */ Symbol("plugin:cache:store");
-
-// libs/plugins/src/cache/cache.plugin.ts
-var CachePlugin = class extends import_sdk4.DynamicPlugin {
-  options;
-  constructor(options = CachePlugin.defaultOptions) {
-    super();
-    this.options = {
-      defaultTTL: 60 * 60 * 24,
-      ...options
-    };
-  }
-  async willReadCache(flowCtx) {
-    const { tool, toolContext } = flowCtx.state;
-    if (!tool || !toolContext) return;
-    const { cache } = toolContext.metadata;
-    if (!cache || typeof toolContext.input === "undefined") {
-      return;
-    }
-    const cacheStore = this.get(CacheStoreToken);
-    const hash = hashObject({ tool: tool.fullName, input: toolContext.input });
-    const cached = await cacheStore.getValue(hash);
-    if (cached !== void 0 && cached !== null) {
-      if (cache === true || cache.ttl && cache.slideWindow) {
-        const ttl = cache === true ? this.options.defaultTTL : cache.ttl ?? this.options.defaultTTL;
-        await cacheStore.setValue(hash, cached, ttl);
-      }
-      if (!tool.safeParseOutput(cached).success) {
-        await cacheStore.delete(hash);
-        return;
-      }
-      flowCtx.state.rawOutput = cached;
-      toolContext.respond(cached);
-    }
-  }
-  async willWriteCache(flowCtx) {
-    const { tool, toolContext } = flowCtx.state;
-    if (!tool || !toolContext) return;
-    const { cache } = toolContext.metadata;
-    if (!cache || typeof toolContext.input === "undefined") {
-      return;
-    }
-    const cacheStore = this.get(CacheStoreToken);
-    const ttl = cache === true ? this.options.defaultTTL : cache.ttl ?? this.options.defaultTTL;
-    const hash = hashObject({ tool: tool.fullName, input: toolContext.input });
-    await cacheStore.setValue(hash, toolContext.output, ttl);
-  }
-};
-__publicField(CachePlugin, "dynamicProviders", (options) => {
-  const providers = [];
-  switch (options.type) {
-    case "global-store":
-      providers.push({
-        name: "cache:global-store",
-        provide: CacheStoreToken,
-        inject: () => [import_sdk4.FrontMcpConfig],
-        useFactory: (config) => {
-          const storeConfig = (0, import_sdk4.getGlobalStoreConfig)("CachePlugin", config);
-          const globalOptions = options;
-          if ((0, import_sdk4.isVercelKvProvider)(storeConfig)) {
-            return new CacheVercelKvProvider({
-              url: storeConfig.url,
-              token: storeConfig.token,
-              keyPrefix: storeConfig.keyPrefix,
-              defaultTTL: globalOptions.defaultTTL
-            });
-          }
-          return new CacheRedisProvider({
-            type: "redis",
-            config: {
-              host: storeConfig.host ?? "localhost",
-              port: storeConfig.port ?? 6379,
-              password: storeConfig.password,
-              db: storeConfig.db
-            },
-            defaultTTL: globalOptions.defaultTTL
-          });
-        }
-      });
-      break;
-    case "redis":
-    case "redis-client":
-      providers.push({
-        name: "cache:redis",
-        provide: CacheStoreToken,
-        useValue: new CacheRedisProvider(options)
-      });
-      break;
-    case "memory":
-      providers.push({
-        name: "cache:memory",
-        provide: CacheStoreToken,
-        useValue: new CacheMemoryProvider(options.defaultTTL)
-      });
-      break;
-  }
-  return providers;
-});
-__publicField(CachePlugin, "defaultOptions", {
-  type: "memory"
-});
-__decorateClass([
-  import_sdk4.ToolHook.Will("execute", { priority: 1e3 })
-], CachePlugin.prototype, "willReadCache", 1);
-__decorateClass([
-  import_sdk4.ToolHook.Did("execute", { priority: 1e3 })
-], CachePlugin.prototype, "willWriteCache", 1);
-CachePlugin = __decorateClass([
-  (0, import_sdk4.Plugin)({
-    name: "cache",
-    description: "Cache plugin for caching tool results",
-    providers: [
-      /* add providers that always loaded with the plugin or default providers */
-      {
-        // this is a default provider for cache, will be overridden if dynamicProviders based on config
-        name: "cache:memory",
-        provide: CacheStoreToken,
-        useValue: new CacheMemoryProvider(60 * 60 * 24)
-      }
-    ]
-  })
-], CachePlugin);
-function hashObject(obj) {
-  const keys = Object.keys(obj).sort();
-  return keys.reduce((acc, key) => {
-    acc += key + ":";
-    const val = obj[key];
-    if (typeof val === "object" && val !== null) {
-      acc += hashObject(val);
-    } else {
-      acc += String(val);
-    }
-    acc += ";";
-    return acc;
-  }, "");
-}
-
-// libs/plugins/src/codecall/codecall.plugin.ts
-var import_sdk11 = require("@frontmcp/sdk");
-
-// libs/plugins/src/codecall/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);
-
-// libs/plugins/src/codecall/services/tool-search.service.ts
-var import_vectoriadb = require("vectoriadb");
-
-// libs/plugins/src/codecall/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
-    };
-  }
-};
-
-// libs/plugins/src/codecall/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;
-  vectorDB;
-  strategy;
-  initialized = false;
-  mlInitialized = false;
-  subscriptionRetries = 0;
-  config;
-  scope;
-  unsubscribe;
-  synonymService = null;
-  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.setupSubscription();
-  }
-  /**
-   * Sets up subscription to tool changes. Handles the case where scope.tools
-   * may not be available yet during plugin initialization.
-   */
-  setupSubscription() {
-    if (!this.scope.tools) {
-      if (this.subscriptionRetries++ >= _ToolSearchService.MAX_SUBSCRIPTION_RETRIES) {
-        console.warn("ToolSearchService: scope.tools not available after max retries");
-        return;
-      }
-      queueMicrotask(() => this.setupSubscription());
-      return;
-    }
-    this.subscriptionRetries = 0;
-    this.unsubscribe = this.scope.tools.subscribe({ immediate: true }, (event) => {
-      this.handleToolChange(event.snapshot);
-    });
-  }
-  /**
-   * 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 when service is destroyed
-   */
-  dispose() {
-    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 = {}) {
-    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;
-  }
-};
-
-// libs/plugins/src/codecall/services/enclave.service.ts
-var import_sdk5 = 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}`);
-          }
-        } : {},
-        // Provide console if allowed
-        ...this.vmOptions.allowConsole ? {
-          console: {
-            log: (...args) => {
-              const message = args.map((arg) => String(arg)).join(" ");
-              logs.push(`[log] ${message}`);
-            },
-            warn: (...args) => {
-              const message = args.map((arg) => String(arg)).join(" ");
-              logs.push(`[warn] ${message}`);
-            },
-            error: (...args) => {
-              const message = args.map((arg) => String(arg)).join(" ");
-              logs.push(`[error] ${message}`);
-            }
-          }
-        } : {}
-      }
-    });
-    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_sdk5.Provider)({
-    name: "codecall:enclave",
-    description: "Executes AgentScript code in a secure enclave",
-    scope: import_sdk5.ProviderScope.GLOBAL
-  })
-], EnclaveService);
-
-// libs/plugins/src/codecall/tools/search.tool.ts
-var import_sdk6 = require("@frontmcp/sdk");
-
-// libs/plugins/src/codecall/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")
-});
-
-// libs/plugins/src/codecall/tools/search.tool.ts
-var SearchTool = class extends import_sdk6.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_sdk6.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);
-
-// libs/plugins/src/codecall/tools/describe.tool.ts
-var import_sdk7 = require("@frontmcp/sdk");
-var import_v4 = require("zod/v4");
-var import_zod4 = require("zod");
-
-// libs/plugins/src/codecall/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.")
-});
-
-// libs/plugins/src/codecall/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);
-  }
-}
-
-// libs/plugins/src/codecall/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;
-}
-
-// libs/plugins/src/codecall/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);
-  }
-};
-
-// libs/plugins/src/codecall/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);
-  }
-}
-
-// libs/plugins/src/codecall/tools/describe.tool.ts
-var DescribeTool = class extends import_sdk7.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_sdk7.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);
-
-// libs/plugins/src/codecall/tools/execute.tool.ts
-var import_sdk9 = require("@frontmcp/sdk");
-
-// libs/plugins/src/codecall/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
-]);
-
-// libs/plugins/src/codecall/providers/code-call.config.ts
-var import_sdk8 = require("@frontmcp/sdk");
-var CodeCallConfig = class extends import_sdk8.BaseConfig {
-  constructor(options = {}) {
-    const parsedConfig = codeCallPluginOptionsSchema.parse(options);
-    const resolvedVm = resolveVmOptions(parsedConfig.vm);
-    super({ ...parsedConfig, resolvedVm });
-  }
-};
-CodeCallConfig = __decorateClass([
-  (0, import_sdk8.Provider)({
-    name: "codecall:config",
-    description: "CodeCall plugin configuration with validated defaults",
-    scope: import_sdk8.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"
-        ]
-      };
-  }
-}
-
-// libs/plugins/src/codecall/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_sdk9.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_sdk9.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);
-
-// libs/plugins/src/codecall/tools/invoke.tool.ts
-var import_sdk10 = require("@frontmcp/sdk");
-
-// libs/plugins/src/codecall/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;
-
-// libs/plugins/src/codecall/tools/invoke.tool.ts
-function buildErrorResult(message) {
-  return {
-    content: [{ type: "text", text: message }],
-    isError: true
-  };
-}
-var InvokeTool = class extends import_sdk10.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_sdk10.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);
-
-// libs/plugins/src/codecall/codecall.plugin.ts
-var CodeCallPlugin = class extends import_sdk11.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_sdk11.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_sdk11.ListToolsHook.Did("resolveConflicts", { priority: 1e3 })
-], CodeCallPlugin.prototype, "adjustListTools", 1);
-CodeCallPlugin = __decorateClass([
-  (0, import_sdk11.Plugin)({
-    name: "codecall",
-    description: "CodeCall plugin: AgentScript-based meta-tools for orchestrating MCP tools",
-    providers: [],
-    plugins: [CachePlugin],
-    tools: [SearchTool, DescribeTool, ExecuteTool, InvokeTool]
-  })
-], CodeCallPlugin);
+__reExport(index_exports, require("@frontmcp/plugin-cache"), module.exports);
+__reExport(index_exports, require("@frontmcp/plugin-codecall"), module.exports);
+__reExport(index_exports, require("@frontmcp/plugin-dashboard"), module.exports);
+__reExport(index_exports, require("@frontmcp/plugin-remember"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  CachePlugin,
-  CodeCallPlugin
+  ...require("@frontmcp/plugin-cache"),
+  ...require("@frontmcp/plugin-codecall"),
+  ...require("@frontmcp/plugin-dashboard"),
+  ...require("@frontmcp/plugin-remember")
 });