@frontmcp/plugin-codecall 1.3.0 → 1.4.0

package/index.js

@@ -53,7 +53,8 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // plugins/plugin-codecall/src/codecall.plugin.ts
-var import_sdk7 = require("@frontmcp/sdk");
+var import_plugin_cache = __toESM(require("@frontmcp/plugin-cache"));
+var import_sdk9 = require("@frontmcp/sdk");
 
 // plugins/plugin-codecall/src/codecall.types.ts
 var import_lazy_zod = require("@frontmcp/lazy-zod");
@@ -310,6 +311,104 @@ var DEFAULT_PLUGIN_OPTIONS = {
 };
 var codeCallPluginOptionsSchema = codeCallPluginOptionsObjectSchema.prefault(DEFAULT_PLUGIN_OPTIONS);
 
+// plugins/plugin-codecall/src/providers/code-call.config.ts
+var import_sdk = require("@frontmcp/sdk");
+var CodeCallConfig = class extends import_sdk.BaseConfig {
+  constructor(options = {}) {
+    const parsedConfig = codeCallPluginOptionsSchema.parse(options);
+    const resolvedVm = resolveVmOptions(parsedConfig.vm);
+    super({ ...parsedConfig, resolvedVm });
+  }
+};
+CodeCallConfig = __decorateClass([
+  (0, import_sdk.Provider)({
+    name: "codecall:config",
+    description: "CodeCall plugin configuration with validated defaults",
+    scope: import_sdk.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"
+        ],
+        maxSanitizeDepth: 10,
+        maxSanitizeProperties: 1e3
+      };
+    case "balanced":
+      return {
+        preset,
+        timeoutMs: 5e3,
+        allowLoops: true,
+        allowConsole: true,
+        maxSteps: 1e4,
+        disabledBuiltins: ["eval", "Function", "AsyncFunction"],
+        disabledGlobals: ["require", "process", "fetch"],
+        maxSanitizeDepth: 50,
+        maxSanitizeProperties: 5e3
+      };
+    case "experimental":
+      return {
+        preset,
+        timeoutMs: 1e4,
+        allowLoops: true,
+        allowConsole: true,
+        maxSteps: 2e4,
+        disabledBuiltins: ["eval", "Function", "AsyncFunction"],
+        disabledGlobals: ["require", "process"],
+        maxSanitizeDepth: 100,
+        maxSanitizeProperties: 2e4
+      };
+    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"
+        ],
+        maxSanitizeDepth: 50,
+        maxSanitizeProperties: 2e3
+      };
+  }
+}
+
 // plugins/plugin-codecall/src/services/tool-search.service.ts
 var import_vectoriadb = require("vectoriadb");
 
@@ -1216,8 +1315,8 @@ var ToolSearchService = class _ToolSearchService {
 };
 
 // plugins/plugin-codecall/src/services/enclave.service.ts
-var import_sdk = require("@frontmcp/sdk");
 var import_core = require("@enclave-vm/core");
+var import_sdk2 = require("@frontmcp/sdk");
 var ScriptTooLargeError = class extends Error {
   code = "SCRIPT_TOO_LARGE";
   scriptLength;
@@ -1266,6 +1365,10 @@ var EnclaveService = class {
       maxResolvedSize: this.sidecarOptions.maxResolvedSize,
       allowComposites: this.sidecarOptions.allowComposites
     } : void 0;
+    const RESERVED_GLOBALS = /* @__PURE__ */ new Set(["getTool", "mcpLog", "mcpNotify"]);
+    const safeNamespaces = Object.fromEntries(
+      Object.entries(environment.namespaces ?? {}).filter(([key]) => !RESERVED_GLOBALS.has(key))
+    );
     const enclave = new import_core.Enclave({
       timeout: this.vmOptions.timeoutMs,
       maxToolCalls: this.vmOptions.maxSteps || 100,
@@ -1279,6 +1382,11 @@ var EnclaveService = class {
       // Allow functions in globals since we intentionally provide getTool, mcpLog, mcpNotify, and console
       allowFunctionsInGlobals: true,
       globals: {
+        // Tool namespaces (e.g. `acme.getUser`) flow through here. Spread
+        // FIRST so the runtime reserved globals below are guaranteed
+        // last-wins. Reserved keys have already been stripped above —
+        // belt-and-braces ordering makes the invariant locally obvious.
+        ...safeNamespaces,
         // Provide getTool as a custom global
         getTool: environment.getTool,
         // Provide logging functions if available
@@ -1375,15 +1483,15 @@ var EnclaveService = class {
   }
 };
 EnclaveService = __decorateClass([
-  (0, import_sdk.Provider)({
+  (0, import_sdk2.Provider)({
     name: "codecall:enclave",
     description: "Executes AgentScript code in a secure enclave",
-    scope: import_sdk.ProviderScope.GLOBAL
+    scope: import_sdk2.ProviderScope.GLOBAL
   })
 ], EnclaveService);
 
 // plugins/plugin-codecall/src/tools/search.tool.ts
-var import_sdk2 = require("@frontmcp/sdk");
+var import_sdk3 = require("@frontmcp/sdk");
 
 // plugins/plugin-codecall/src/tools/search.schema.ts
 var import_lazy_zod2 = require("@frontmcp/lazy-zod");
@@ -1433,7 +1541,7 @@ var searchToolOutputSchema = import_lazy_zod2.z.object({
 });
 
 // plugins/plugin-codecall/src/tools/search.tool.ts
-var SearchTool = class extends import_sdk2.ToolContext {
+var SearchTool = class extends import_sdk3.ToolContext {
   async execute(input) {
     const { queries, appIds, excludeToolNames = [], topK = 5, minRelevanceScore = 0.3 } = input;
     const searchService = this.get(ToolSearchService);
@@ -1501,7 +1609,7 @@ var SearchTool = class extends import_sdk2.ToolContext {
   }
 };
 SearchTool = __decorateClass([
-  (0, import_sdk2.Tool)({
+  (0, import_sdk3.Tool)({
     name: "codecall:search",
     cache: {
       ttl: 60,
@@ -1522,9 +1630,294 @@ SearchTool = __decorateClass([
   })
 ], SearchTool);
 
-// plugins/plugin-codecall/src/tools/describe.tool.ts
+// plugins/plugin-codecall/src/tools/search-skills.tool.ts
+var import_sdk4 = require("@frontmcp/sdk");
+
+// plugins/plugin-codecall/src/tools/search-skills.schema.ts
+var import_lazy_zod3 = require("@frontmcp/lazy-zod");
+var searchSkillsToolDescription = `Search for EXECUTABLE skills. Each result returns the skill's description, tags, and the openapi operation IDs it can call from within AgentScript.
+
+DECOMPOSE complex requests into atomic queries. AVOID re-searching: use excludeSkillNames.
+
+INPUT:
+- queries: string[] (required) - atomic skill descriptions, max 10
+- tags?: string[] - filter to skills carrying any of these tags
+- excludeSkillNames?: string[] - skip already-discovered skills
+- topK?: number (default 5) - results per query
+- minRelevanceScore?: number (default 0.1) - minimum match threshold
+
+OUTPUT: Flat deduplicated executable skill list. Each entry includes the operationIds the skill is allowed to call (via the markdown harvester). The agent can use those operationIds directly in execute() AgentScript via the generated namespaces (e.g. acme.getOrder({...})).
+
+FLOW: searchSkills \u2192 describe \u2192 execute`;
+var searchSkillsToolInputSchema = {
+  queries: import_lazy_zod3.z.array(import_lazy_zod3.z.string().min(2).max(256)).min(1).max(10).describe("Atomic skill queries. Split complex requests into simple actions."),
+  tags: import_lazy_zod3.z.array(import_lazy_zod3.z.string().min(1).max(64)).max(16).optional().describe("Filter to skills with any of these tags"),
+  excludeSkillNames: import_lazy_zod3.z.array(import_lazy_zod3.z.string()).max(50).optional().describe("Skip already-known skill names"),
+  topK: import_lazy_zod3.z.number().int().positive().max(50).optional().default(5).describe("Results per query (default 5)"),
+  minRelevanceScore: import_lazy_zod3.z.number().min(0).max(1).optional().default(0.1).describe("Minimum relevance threshold (default 0.1)")
+};
+var referencedOperationSchema = import_lazy_zod3.z.object({
+  spec: import_lazy_zod3.z.string().describe('OpenAPI spec id (e.g. "acme")'),
+  operationId: import_lazy_zod3.z.string().describe('OpenAPI operation id (e.g. "getOrder")')
+});
+var skillSearchHitSchema = import_lazy_zod3.z.object({
+  name: import_lazy_zod3.z.string().describe("Skill name"),
+  description: import_lazy_zod3.z.string().describe("Short description of what the skill does"),
+  tags: import_lazy_zod3.z.array(import_lazy_zod3.z.string()).describe("Tags carried by the skill"),
+  /**
+   * OpenAPI operations the skill is allowed to call. Inlined so the agent
+   * can author AgentScript from a single search response.
+   */
+  operations: import_lazy_zod3.z.array(referencedOperationSchema).describe("OpenAPI operations the skill can call"),
+  /** Decorator-declared tools (for skills built the legacy way). */
+  tools: import_lazy_zod3.z.array(import_lazy_zod3.z.string()).describe("Tool names the skill declares (if any)"),
+  relevanceScore: import_lazy_zod3.z.number().min(0).max(1).describe("Match score (0-1)"),
+  matchedQueries: import_lazy_zod3.z.array(import_lazy_zod3.z.string()).describe("Which queries matched this skill"),
+  source: import_lazy_zod3.z.enum(["local", "external"]).describe("Where the skill was loaded from")
+});
+var searchSkillsToolOutputSchema = import_lazy_zod3.z.object({
+  skills: import_lazy_zod3.z.array(skillSearchHitSchema).describe("Deduplicated executable skills, sorted by relevance"),
+  warnings: import_lazy_zod3.z.array(
+    import_lazy_zod3.z.object({
+      type: import_lazy_zod3.z.enum(["no_results", "low_relevance", "excluded_skill_not_found"]).describe("Warning type"),
+      message: import_lazy_zod3.z.string().describe("Warning message"),
+      affectedSkills: import_lazy_zod3.z.array(import_lazy_zod3.z.string()).optional().describe("Affected skill names")
+    })
+  ).describe("Search warnings"),
+  totalExecutableSkills: import_lazy_zod3.z.number().int().nonnegative().describe("Total executable skills available")
+});
+
+// plugins/plugin-codecall/src/tools/search-skills.tool.ts
+var SearchSkillsTool = class extends import_sdk4.ToolContext {
+  async execute(input) {
+    const { queries, tags, excludeSkillNames = [], topK = 5, minRelevanceScore = 0.1 } = input;
+    const skillRegistry = this.scope.skills;
+    const executableSkills = skillRegistry.getExecutableSkills();
+    const executableSet = new Set(executableSkills.map((s) => s.name));
+    const totalExecutableSkills = executableSkills.length;
+    const warnings = [];
+    const nonExistentExcluded = excludeSkillNames.filter((n) => !executableSet.has(n));
+    if (nonExistentExcluded.length > 0) {
+      warnings.push({
+        type: "excluded_skill_not_found",
+        message: `Excluded skills not found: ${nonExistentExcluded.join(", ")}`,
+        affectedSkills: nonExistentExcluded
+      });
+    }
+    const matches = /* @__PURE__ */ new Map();
+    let lowRelevanceCount = 0;
+    const excludedSet = new Set(excludeSkillNames);
+    const perQueryResults = await Promise.all(
+      queries.map(
+        (query) => skillRegistry.search(query, { topK, tags, minScore: minRelevanceScore }).then((results) => ({ query, results }))
+      )
+    );
+    for (const { query, results } of perQueryResults) {
+      for (const result of results) {
+        const name = result.metadata.name;
+        if (!executableSet.has(name)) continue;
+        if (excludedSet.has(name)) continue;
+        if (result.score < minRelevanceScore) {
+          lowRelevanceCount++;
+          continue;
+        }
+        const existing = matches.get(name);
+        if (existing) {
+          existing.matchedQueries.push(query);
+          existing.relevanceScore = Math.max(existing.relevanceScore, result.score);
+        } else {
+          const ops = result.metadata.referencedOperations ?? [];
+          const toolNames = (result.metadata.tools ?? []).map((t) => {
+            if (typeof t === "string") return t;
+            if (typeof t === "object" && t !== null && "name" in t) return t.name;
+            return null;
+          }).filter((n) => typeof n === "string");
+          matches.set(name, {
+            name,
+            description: result.metadata.description,
+            tags: result.metadata.tags ?? [],
+            operations: ops.map((op) => ({ spec: op.spec, operationId: op.operationId })),
+            tools: toolNames,
+            relevanceScore: result.score,
+            matchedQueries: [query],
+            source: result.source
+          });
+        }
+      }
+    }
+    const skills = Array.from(matches.values()).sort((a, b) => b.relevanceScore - a.relevanceScore);
+    if (skills.length === 0) {
+      warnings.push({
+        type: "no_results",
+        message: `No executable skills found for queries: ${queries.join(", ")}${tags?.length ? ` with tags: ${tags.join(", ")}` : ""}`
+      });
+    }
+    if (lowRelevanceCount > 0 && skills.length > 0) {
+      warnings.push({
+        type: "low_relevance",
+        message: `${lowRelevanceCount} result(s) filtered due to relevance below ${minRelevanceScore}`
+      });
+    }
+    return { skills, warnings, totalExecutableSkills };
+  }
+};
+SearchSkillsTool = __decorateClass([
+  (0, import_sdk4.Tool)({
+    name: "codecall:searchSkills",
+    cache: {
+      ttl: 60,
+      slideWindow: false
+    },
+    codecall: {
+      enabledInCodeCall: false,
+      visibleInListTools: true
+    },
+    description: searchSkillsToolDescription,
+    inputSchema: searchSkillsToolInputSchema,
+    outputSchema: searchSkillsToolOutputSchema,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: true
+    }
+  })
+], SearchSkillsTool);
+
+// plugins/plugin-codecall/src/tools/search-knowledge.tool.ts
+var import_sdk5 = require("@frontmcp/sdk");
+
+// plugins/plugin-codecall/src/tools/search-knowledge.schema.ts
 var import_lazy_zod4 = require("@frontmcp/lazy-zod");
-var import_sdk3 = require("@frontmcp/sdk");
+var searchKnowledgeToolDescription = `Search for KNOWLEDGE-ONLY skills \u2014 domain context the agent should read before deciding what to do. These skills have no tools and no openapi operation refs; they are pure prose / references / examples.
+
+USE WHEN: the agent needs background to interpret a request, validate eligibility, or recall a procedure that isn't yet executable.
+
+INPUT:
+- queries: string[] (required) - atomic context queries, max 10
+- tags?: string[] - filter to knowledge carrying any of these tags
+- excludeSkillNames?: string[] - skip already-loaded knowledge
+- topK?: number (default 5) - results per query
+- minRelevanceScore?: number (default 0.1) - minimum match threshold
+
+OUTPUT: Deduplicated knowledge skill list with description + tags. To read the body, follow up with describe(skillName) or the skill:// resource URI.
+
+FLOW: searchKnowledge \u2192 describe (for body) \u2192 continue with searchSkills`;
+var searchKnowledgeToolInputSchema = {
+  queries: import_lazy_zod4.z.array(import_lazy_zod4.z.string().min(2).max(256)).min(1).max(10).describe("Atomic context queries."),
+  tags: import_lazy_zod4.z.array(import_lazy_zod4.z.string().min(1).max(64)).max(16).optional().describe("Filter to skills with any of these tags"),
+  excludeSkillNames: import_lazy_zod4.z.array(import_lazy_zod4.z.string()).max(50).optional().describe("Skip already-loaded knowledge skill names"),
+  topK: import_lazy_zod4.z.number().int().positive().max(50).optional().default(5).describe("Results per query (default 5)"),
+  minRelevanceScore: import_lazy_zod4.z.number().min(0).max(1).optional().default(0.1).describe("Minimum relevance threshold (default 0.1)")
+};
+var knowledgeHitSchema = import_lazy_zod4.z.object({
+  name: import_lazy_zod4.z.string().describe("Skill name"),
+  description: import_lazy_zod4.z.string().describe("Short description of what the knowledge covers"),
+  tags: import_lazy_zod4.z.array(import_lazy_zod4.z.string()).describe("Tags carried by the skill"),
+  relevanceScore: import_lazy_zod4.z.number().min(0).max(1).describe("Match score (0-1)"),
+  matchedQueries: import_lazy_zod4.z.array(import_lazy_zod4.z.string()).describe("Which queries matched this knowledge"),
+  source: import_lazy_zod4.z.enum(["local", "external"]).describe("Where the skill was loaded from")
+});
+var searchKnowledgeToolOutputSchema = import_lazy_zod4.z.object({
+  knowledge: import_lazy_zod4.z.array(knowledgeHitSchema).describe("Deduplicated knowledge skills, sorted by relevance"),
+  warnings: import_lazy_zod4.z.array(
+    import_lazy_zod4.z.object({
+      type: import_lazy_zod4.z.enum(["no_results", "low_relevance", "excluded_skill_not_found"]).describe("Warning type"),
+      message: import_lazy_zod4.z.string().describe("Warning message"),
+      affectedSkills: import_lazy_zod4.z.array(import_lazy_zod4.z.string()).optional().describe("Affected skill names")
+    })
+  ).describe("Search warnings"),
+  totalKnowledgeSkills: import_lazy_zod4.z.number().int().nonnegative().describe("Total knowledge-only skills available")
+});
+
+// plugins/plugin-codecall/src/tools/search-knowledge.tool.ts
+var SearchKnowledgeTool = class extends import_sdk5.ToolContext {
+  async execute(input) {
+    const { queries, tags, excludeSkillNames = [], topK = 5, minRelevanceScore = 0.1 } = input;
+    const skillRegistry = this.scope.skills;
+    const knowledgeSkills = skillRegistry.getKnowledgeOnlySkills();
+    const knowledgeSet = new Set(knowledgeSkills.map((s) => s.name));
+    const totalKnowledgeSkills = knowledgeSkills.length;
+    const warnings = [];
+    const nonExistentExcluded = excludeSkillNames.filter((n) => !knowledgeSet.has(n));
+    if (nonExistentExcluded.length > 0) {
+      warnings.push({
+        type: "excluded_skill_not_found",
+        message: `Excluded knowledge skills not found: ${nonExistentExcluded.join(", ")}`,
+        affectedSkills: nonExistentExcluded
+      });
+    }
+    const matches = /* @__PURE__ */ new Map();
+    let lowRelevanceCount = 0;
+    const excludedSet = new Set(excludeSkillNames);
+    const perQueryResults = await Promise.all(
+      queries.map(
+        (query) => skillRegistry.search(query, { topK, tags, minScore: minRelevanceScore }).then((results) => ({ query, results }))
+      )
+    );
+    for (const { query, results } of perQueryResults) {
+      for (const result of results) {
+        const name = result.metadata.name;
+        if (!knowledgeSet.has(name)) continue;
+        if (excludedSet.has(name)) continue;
+        if (result.score < minRelevanceScore) {
+          lowRelevanceCount++;
+          continue;
+        }
+        const existing = matches.get(name);
+        if (existing) {
+          existing.matchedQueries.push(query);
+          existing.relevanceScore = Math.max(existing.relevanceScore, result.score);
+        } else {
+          matches.set(name, {
+            name,
+            description: result.metadata.description,
+            tags: result.metadata.tags ?? [],
+            relevanceScore: result.score,
+            matchedQueries: [query],
+            source: result.source
+          });
+        }
+      }
+    }
+    const knowledge = Array.from(matches.values()).sort((a, b) => b.relevanceScore - a.relevanceScore);
+    if (knowledge.length === 0) {
+      warnings.push({
+        type: "no_results",
+        message: `No knowledge skills found for queries: ${queries.join(", ")}${tags?.length ? ` with tags: ${tags.join(", ")}` : ""}`
+      });
+    }
+    if (lowRelevanceCount > 0 && knowledge.length > 0) {
+      warnings.push({
+        type: "low_relevance",
+        message: `${lowRelevanceCount} result(s) filtered due to relevance below ${minRelevanceScore}`
+      });
+    }
+    return { knowledge, warnings, totalKnowledgeSkills };
+  }
+};
+SearchKnowledgeTool = __decorateClass([
+  (0, import_sdk5.Tool)({
+    name: "codecall:searchKnowledge",
+    cache: {
+      ttl: 60,
+      slideWindow: false
+    },
+    codecall: {
+      enabledInCodeCall: false,
+      visibleInListTools: true
+    },
+    description: searchKnowledgeToolDescription,
+    inputSchema: searchKnowledgeToolInputSchema,
+    outputSchema: searchKnowledgeToolOutputSchema,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: true
+    }
+  })
+], SearchKnowledgeTool);
+
+// plugins/plugin-codecall/src/tools/describe.tool.ts
+var import_lazy_zod6 = require("@frontmcp/lazy-zod");
+var import_sdk6 = require("@frontmcp/sdk");
 
 // plugins/plugin-codecall/src/errors/tool-call.errors.ts
 var TOOL_CALL_ERROR_CODES = {
@@ -1604,6 +1997,70 @@ function assertNotSelfReference(toolName) {
   }
 }
 
+// plugins/plugin-codecall/src/utils/build-tool-namespaces.ts
+var IDENT_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var RESERVED_NAMESPACES = /* @__PURE__ */ new Set([
+  "console",
+  "Math",
+  "JSON",
+  "Object",
+  "Array",
+  "String",
+  "Number",
+  "Boolean",
+  "Promise",
+  "Symbol",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Date",
+  "Error",
+  "RegExp",
+  "globalThis",
+  "global",
+  "window",
+  "self",
+  "undefined",
+  "null",
+  "true",
+  "false",
+  "callTool",
+  "getTool",
+  "mcpLog",
+  "mcpNotify"
+]);
+function buildToolNamespaces(tools, callTool) {
+  const namespaces = {};
+  const skipped = [];
+  for (const tool of tools) {
+    const name = tool?.name;
+    if (typeof name !== "string" || name.length === 0) continue;
+    const dot = name.indexOf(".");
+    if (dot <= 0 || dot === name.length - 1) {
+      skipped.push({ name, reason: "no-namespace-prefix" });
+      continue;
+    }
+    const ns = name.slice(0, dot);
+    const method = name.slice(dot + 1);
+    if (!IDENT_RE.test(ns) || !IDENT_RE.test(method)) {
+      skipped.push({ name, reason: "invalid-identifier" });
+      continue;
+    }
+    if (RESERVED_NAMESPACES.has(ns)) {
+      skipped.push({ name, reason: "reserved-namespace" });
+      continue;
+    }
+    const bucket = namespaces[ns] ?? (namespaces[ns] = {});
+    if (Object.prototype.hasOwnProperty.call(bucket, method)) {
+      skipped.push({ name, reason: "duplicate-method" });
+      continue;
+    }
+    bucket[method] = (input, options) => callTool(name, input, options);
+  }
+  return { namespaces, skipped };
+}
+
 // plugins/plugin-codecall/src/utils/describe.utils.ts
 var INTENT_PATTERNS = {
   create: /^(create|add|new|insert|make|append|register|generate|produce|build|construct|provision|instantiate|define|compose|draft)/i,
@@ -1893,7 +2350,7 @@ function extractResultFromCallToolResult(mcpResult) {
 }
 
 // plugins/plugin-codecall/src/tools/describe.schema.ts
-var import_lazy_zod3 = require("@frontmcp/lazy-zod");
+var import_lazy_zod5 = require("@frontmcp/lazy-zod");
 var import_protocol = require("@frontmcp/protocol");
 var describeToolDescription = `Get input/output schemas for tools from search results.
 
@@ -1903,7 +2360,7 @@ OUTPUT per tool: inputSchema (JSON Schema), outputSchema (JSON Schema), usageExa
 IMPORTANT: If notFound array is non-empty \u2192 re-search with corrected queries.
 FLOW: search \u2192 describe \u2192 execute/invoke`;
 var describeToolInputSchema = {
-  toolNames: import_lazy_zod3.z.array(import_lazy_zod3.z.string()).min(1).superRefine((toolNames, ctx) => {
+  toolNames: import_lazy_zod5.z.array(import_lazy_zod5.z.string()).min(1).superRefine((toolNames, ctx) => {
     const seen = /* @__PURE__ */ new Set();
     const duplicates = /* @__PURE__ */ new Set();
     for (const name of toolNames) {
@@ -1914,7 +2371,7 @@ var describeToolInputSchema = {
     }
     if (duplicates.size > 0) {
       ctx.addIssue({
-        code: import_lazy_zod3.z.ZodIssueCode.custom,
+        code: import_lazy_zod5.z.ZodIssueCode.custom,
         message: `Duplicate tool names are not allowed: ${Array.from(duplicates).join(", ")}`
       });
     }
@@ -1922,30 +2379,30 @@ var describeToolInputSchema = {
     '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_lazy_zod3.z.object({
-  tools: import_lazy_zod3.z.array(
-    import_lazy_zod3.z.object({
-      name: import_lazy_zod3.z.string().describe("Tool name to be used in callTool() within codecall:execute scripts"),
-      appId: import_lazy_zod3.z.string().describe("The app ID this tool belongs to"),
-      description: import_lazy_zod3.z.string().describe("Detailed description of what this tool does"),
-      inputSchema: import_lazy_zod3.z.record(import_lazy_zod3.z.string(), import_lazy_zod3.z.unknown()).nullable().describe("JSON Schema object describing the tool input parameters"),
-      outputSchema: import_lazy_zod3.z.record(import_lazy_zod3.z.string(), import_lazy_zod3.z.unknown()).nullable().describe("JSON Schema object describing the tool output structure"),
+var describeToolOutputSchema = import_lazy_zod5.z.object({
+  tools: import_lazy_zod5.z.array(
+    import_lazy_zod5.z.object({
+      name: import_lazy_zod5.z.string().describe("Tool name to be used in callTool() within codecall:execute scripts"),
+      appId: import_lazy_zod5.z.string().describe("The app ID this tool belongs to"),
+      description: import_lazy_zod5.z.string().describe("Detailed description of what this tool does"),
+      inputSchema: import_lazy_zod5.z.record(import_lazy_zod5.z.string(), import_lazy_zod5.z.unknown()).nullable().describe("JSON Schema object describing the tool input parameters"),
+      outputSchema: import_lazy_zod5.z.record(import_lazy_zod5.z.string(), import_lazy_zod5.z.unknown()).nullable().describe("JSON Schema object describing the tool output structure"),
       annotations: import_protocol.ToolAnnotationsSchema.optional().describe("MCP tool annotations (metadata)"),
-      usageExamples: import_lazy_zod3.z.array(
-        import_lazy_zod3.z.object({
-          description: import_lazy_zod3.z.string().describe("Description of what this example demonstrates"),
-          code: import_lazy_zod3.z.string().describe(
+      usageExamples: import_lazy_zod5.z.array(
+        import_lazy_zod5.z.object({
+          description: import_lazy_zod5.z.string().describe("Description of what this example demonstrates"),
+          code: import_lazy_zod5.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_lazy_zod3.z.array(import_lazy_zod3.z.string()).optional().describe("Tool names that were requested but not found in the index. Check these for typos.")
+  notFound: import_lazy_zod5.z.array(import_lazy_zod5.z.string()).optional().describe("Tool names that were requested but not found in the index. Check these for typos.")
 });
 
 // plugins/plugin-codecall/src/tools/describe.tool.ts
-var DescribeTool = class extends import_sdk3.ToolContext {
+var DescribeTool = class extends import_sdk6.ToolContext {
   async execute(input) {
     const { toolNames } = input;
     const tools = [];
@@ -1965,7 +2422,7 @@ var DescribeTool = class extends import_sdk3.ToolContext {
       }
       const appId = this.extractAppId(tool);
       const inputSchema = this.getInputSchema(tool);
-      const outputSchema = this.toJsonSchema(tool.outputSchema);
+      const outputSchema = this.toJsonSchema(tool.rawOutputSchema ?? tool.outputSchema);
       const usageExamples = this.generateExamples(tool, inputSchema ?? void 0);
       tools.push({
         name: tool.name,
@@ -1995,8 +2452,8 @@ var DescribeTool = class extends import_sdk3.ToolContext {
     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_lazy_zod4.ZodType) {
-          return (0, import_lazy_zod4.toJSONSchema)(import_lazy_zod4.z.object(tool.inputSchema));
+        if (firstValue instanceof import_lazy_zod6.ZodType) {
+          return (0, import_lazy_zod6.toJSONSchema)(import_lazy_zod6.z.object(tool.inputSchema));
         }
       } catch {
       }
@@ -2016,9 +2473,9 @@ var DescribeTool = class extends import_sdk3.ToolContext {
     if (!schema) {
       return null;
     }
-    if (schema instanceof import_lazy_zod4.ZodType) {
+    if (schema instanceof import_lazy_zod6.ZodType) {
       try {
-        return (0, import_lazy_zod4.toJSONSchema)(schema);
+        return (0, import_lazy_zod6.toJSONSchema)(schema);
       } catch {
         return null;
       }
@@ -2026,9 +2483,9 @@ var DescribeTool = class extends import_sdk3.ToolContext {
     if (typeof schema === "object" && schema !== null && !Array.isArray(schema)) {
       const obj = schema;
       const firstValue = Object.values(obj)[0];
-      if (firstValue instanceof import_lazy_zod4.ZodType) {
+      if (firstValue instanceof import_lazy_zod6.ZodType) {
         try {
-          return (0, import_lazy_zod4.toJSONSchema)(import_lazy_zod4.z.object(obj));
+          return (0, import_lazy_zod6.toJSONSchema)(import_lazy_zod6.z.object(obj));
         } catch {
           return null;
         }
@@ -2091,7 +2548,7 @@ return result;`
   }
 };
 DescribeTool = __decorateClass([
-  (0, import_sdk3.Tool)({
+  (0, import_sdk6.Tool)({
     name: "codecall:describe",
     cache: {
       ttl: 60,
@@ -2113,10 +2570,10 @@ DescribeTool = __decorateClass([
 ], DescribeTool);
 
 // plugins/plugin-codecall/src/tools/execute.tool.ts
-var import_sdk5 = require("@frontmcp/sdk");
+var import_sdk7 = require("@frontmcp/sdk");
 
 // plugins/plugin-codecall/src/tools/execute.schema.ts
-var import_lazy_zod5 = require("@frontmcp/lazy-zod");
+var import_lazy_zod7 = require("@frontmcp/lazy-zod");
 var MIN_EXECUTE_SCRIPT_LENGTH = 'return callTool("a",{})'.length;
 var executeToolDescription = `Execute AgentScript (safe JS subset) for multi-tool orchestration.
 
@@ -2140,72 +2597,72 @@ 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 = {
-  script: import_lazy_zod5.z.string().min(MIN_EXECUTE_SCRIPT_LENGTH).max(100 * 1024).describe(
+  script: import_lazy_zod7.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_lazy_zod5.z.array(import_lazy_zod5.z.string()).optional().describe(
+  allowedTools: import_lazy_zod7.z.array(import_lazy_zod7.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_lazy_zod5.z.object({
-  message: import_lazy_zod5.z.string(),
-  location: import_lazy_zod5.z.object({
-    line: import_lazy_zod5.z.number(),
-    column: import_lazy_zod5.z.number()
+var syntaxErrorPayloadSchema = import_lazy_zod7.z.object({
+  message: import_lazy_zod7.z.string(),
+  location: import_lazy_zod7.z.object({
+    line: import_lazy_zod7.z.number(),
+    column: import_lazy_zod7.z.number()
   }).optional()
 });
-var illegalAccessErrorPayloadSchema = import_lazy_zod5.z.object({
-  message: import_lazy_zod5.z.string(),
-  kind: import_lazy_zod5.z.union([
-    import_lazy_zod5.z.literal("IllegalBuiltinAccess"),
-    import_lazy_zod5.z.literal("DisallowedGlobal"),
-    import_lazy_zod5.z.string()
+var illegalAccessErrorPayloadSchema = import_lazy_zod7.z.object({
+  message: import_lazy_zod7.z.string(),
+  kind: import_lazy_zod7.z.union([
+    import_lazy_zod7.z.literal("IllegalBuiltinAccess"),
+    import_lazy_zod7.z.literal("DisallowedGlobal"),
+    import_lazy_zod7.z.string()
     // same as your original type: 'A' | 'B' | string
   ])
 });
-var runtimeErrorPayloadSchema = import_lazy_zod5.z.object({
-  source: import_lazy_zod5.z.literal("script"),
-  message: import_lazy_zod5.z.string(),
-  name: import_lazy_zod5.z.string().optional(),
-  stack: import_lazy_zod5.z.string().optional()
+var runtimeErrorPayloadSchema = import_lazy_zod7.z.object({
+  source: import_lazy_zod7.z.literal("script"),
+  message: import_lazy_zod7.z.string(),
+  name: import_lazy_zod7.z.string().optional(),
+  stack: import_lazy_zod7.z.string().optional()
 });
-var toolErrorPayloadSchema = import_lazy_zod5.z.object({
-  source: import_lazy_zod5.z.literal("tool"),
-  toolName: import_lazy_zod5.z.string(),
-  toolInput: import_lazy_zod5.z.unknown(),
-  message: import_lazy_zod5.z.string(),
-  code: import_lazy_zod5.z.string().optional(),
-  details: import_lazy_zod5.z.unknown().optional()
+var toolErrorPayloadSchema = import_lazy_zod7.z.object({
+  source: import_lazy_zod7.z.literal("tool"),
+  toolName: import_lazy_zod7.z.string(),
+  toolInput: import_lazy_zod7.z.unknown(),
+  message: import_lazy_zod7.z.string(),
+  code: import_lazy_zod7.z.string().optional(),
+  details: import_lazy_zod7.z.unknown().optional()
 });
-var timeoutErrorPayloadSchema = import_lazy_zod5.z.object({
-  message: import_lazy_zod5.z.string()
+var timeoutErrorPayloadSchema = import_lazy_zod7.z.object({
+  message: import_lazy_zod7.z.string()
 });
-var codeCallOkResultSchema = import_lazy_zod5.z.object({
-  status: import_lazy_zod5.z.literal("ok"),
-  result: import_lazy_zod5.z.unknown(),
-  logs: import_lazy_zod5.z.array(import_lazy_zod5.z.string()).optional()
+var codeCallOkResultSchema = import_lazy_zod7.z.object({
+  status: import_lazy_zod7.z.literal("ok"),
+  result: import_lazy_zod7.z.unknown(),
+  logs: import_lazy_zod7.z.array(import_lazy_zod7.z.string()).optional()
 });
-var codeCallSyntaxErrorResultSchema = import_lazy_zod5.z.object({
-  status: import_lazy_zod5.z.literal("syntax_error"),
+var codeCallSyntaxErrorResultSchema = import_lazy_zod7.z.object({
+  status: import_lazy_zod7.z.literal("syntax_error"),
   error: syntaxErrorPayloadSchema
 });
-var codeCallIllegalAccessResultSchema = import_lazy_zod5.z.object({
-  status: import_lazy_zod5.z.literal("illegal_access"),
+var codeCallIllegalAccessResultSchema = import_lazy_zod7.z.object({
+  status: import_lazy_zod7.z.literal("illegal_access"),
   error: illegalAccessErrorPayloadSchema
 });
-var codeCallRuntimeErrorResultSchema = import_lazy_zod5.z.object({
-  status: import_lazy_zod5.z.literal("runtime_error"),
+var codeCallRuntimeErrorResultSchema = import_lazy_zod7.z.object({
+  status: import_lazy_zod7.z.literal("runtime_error"),
   error: runtimeErrorPayloadSchema
 });
-var codeCallToolErrorResultSchema = import_lazy_zod5.z.object({
-  status: import_lazy_zod5.z.literal("tool_error"),
+var codeCallToolErrorResultSchema = import_lazy_zod7.z.object({
+  status: import_lazy_zod7.z.literal("tool_error"),
   error: toolErrorPayloadSchema
 });
-var codeCallTimeoutResultSchema = import_lazy_zod5.z.object({
-  status: import_lazy_zod5.z.literal("timeout"),
+var codeCallTimeoutResultSchema = import_lazy_zod7.z.object({
+  status: import_lazy_zod7.z.literal("timeout"),
   error: timeoutErrorPayloadSchema
 });
-var executeToolOutputSchema = import_lazy_zod5.z.discriminatedUnion("status", [
+var executeToolOutputSchema = import_lazy_zod7.z.discriminatedUnion("status", [
   codeCallOkResultSchema,
   codeCallSyntaxErrorResultSchema,
   codeCallIllegalAccessResultSchema,
@@ -2214,104 +2671,6 @@ var executeToolOutputSchema = import_lazy_zod5.z.discriminatedUnion("status", [
   codeCallTimeoutResultSchema
 ]);
 
-// plugins/plugin-codecall/src/providers/code-call.config.ts
-var import_sdk4 = require("@frontmcp/sdk");
-var CodeCallConfig = class extends import_sdk4.BaseConfig {
-  constructor(options = {}) {
-    const parsedConfig = codeCallPluginOptionsSchema.parse(options);
-    const resolvedVm = resolveVmOptions(parsedConfig.vm);
-    super({ ...parsedConfig, resolvedVm });
-  }
-};
-CodeCallConfig = __decorateClass([
-  (0, import_sdk4.Provider)({
-    name: "codecall:config",
-    description: "CodeCall plugin configuration with validated defaults",
-    scope: import_sdk4.ProviderScope.GLOBAL
-  })
-], CodeCallConfig);
-function resolveVmOptions(vmOptions) {
-  const preset = vmOptions?.preset ?? "secure";
-  const base = presetDefaults(preset);
-  return {
-    ...base,
-    ...vmOptions,
-    disabledBuiltins: vmOptions?.disabledBuiltins ?? base.disabledBuiltins,
-    disabledGlobals: vmOptions?.disabledGlobals ?? base.disabledGlobals
-  };
-}
-function presetDefaults(preset) {
-  switch (preset) {
-    case "locked_down":
-      return {
-        preset,
-        timeoutMs: 2e3,
-        allowLoops: false,
-        allowConsole: false,
-        maxSteps: 2e3,
-        disabledBuiltins: ["eval", "Function", "AsyncFunction"],
-        disabledGlobals: [
-          "require",
-          "process",
-          "fetch",
-          "setTimeout",
-          "setInterval",
-          "setImmediate",
-          "global",
-          "globalThis"
-        ],
-        maxSanitizeDepth: 10,
-        maxSanitizeProperties: 1e3
-      };
-    case "balanced":
-      return {
-        preset,
-        timeoutMs: 5e3,
-        allowLoops: true,
-        allowConsole: true,
-        maxSteps: 1e4,
-        disabledBuiltins: ["eval", "Function", "AsyncFunction"],
-        disabledGlobals: ["require", "process", "fetch"],
-        maxSanitizeDepth: 50,
-        maxSanitizeProperties: 5e3
-      };
-    case "experimental":
-      return {
-        preset,
-        timeoutMs: 1e4,
-        allowLoops: true,
-        allowConsole: true,
-        maxSteps: 2e4,
-        disabledBuiltins: ["eval", "Function", "AsyncFunction"],
-        disabledGlobals: ["require", "process"],
-        maxSanitizeDepth: 100,
-        maxSanitizeProperties: 2e4
-      };
-    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"
-        ],
-        maxSanitizeDepth: 50,
-        maxSanitizeProperties: 2e3
-      };
-  }
-}
-
 // plugins/plugin-codecall/src/tools/execute.tool.ts
 function getErrorCode(error) {
   if (!(error instanceof Error)) {
@@ -2328,7 +2687,7 @@ function getErrorCode(error) {
   }
   return TOOL_CALL_ERROR_CODES.EXECUTION;
 }
-var ExecuteTool = class extends import_sdk5.ToolContext {
+var ExecuteTool = class extends import_sdk7.ToolContext {
   async execute(input) {
     const { script, allowedTools } = input;
     const allowedToolSet = allowedTools ? new Set(allowedTools) : null;
@@ -2400,6 +2759,22 @@ var ExecuteTool = class extends import_sdk5.ToolContext {
         this.logger?.debug("Notification sent", { event, payload });
       }
     };
+    try {
+      const registeredTools = this.scope.tools.getTools(true);
+      const { namespaces, skipped } = buildToolNamespaces(registeredTools, environment.callTool);
+      environment.namespaces = namespaces;
+      if (skipped.length > 0) {
+        this.logger?.debug?.("codecall: tools skipped during namespace generation", {
+          count: skipped.length,
+          // Cap the debug payload so a huge skip list doesn't bloat logs.
+          sample: skipped.slice(0, 25)
+        });
+      }
+    } catch (error) {
+      this.logger?.warn?.("codecall: failed to build tool namespaces", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
     const enclaveService = this.get(EnclaveService);
     const config = this.get(CodeCallConfig);
     try {
@@ -2478,7 +2853,7 @@ var ExecuteTool = class extends import_sdk5.ToolContext {
   }
 };
 ExecuteTool = __decorateClass([
-  (0, import_sdk5.Tool)({
+  (0, import_sdk7.Tool)({
     name: "codecall:execute",
     cache: {
       ttl: 0,
@@ -2496,10 +2871,10 @@ ExecuteTool = __decorateClass([
 ], ExecuteTool);
 
 // plugins/plugin-codecall/src/tools/invoke.tool.ts
-var import_sdk6 = require("@frontmcp/sdk");
+var import_sdk8 = require("@frontmcp/sdk");
 
 // plugins/plugin-codecall/src/tools/invoke.schema.ts
-var import_lazy_zod6 = require("@frontmcp/lazy-zod");
+var import_lazy_zod8 = require("@frontmcp/lazy-zod");
 var import_protocol2 = require("@frontmcp/protocol");
 var invokeToolDescription = `Call ONE tool directly. Returns standard MCP CallToolResult.
 
@@ -2512,10 +2887,10 @@ ERRORS: tool_not_found (\u2192 re-search) | validation_error | execution_error |
 
 FLOW: search \u2192 describe \u2192 invoke`;
 var invokeToolInputSchema = {
-  tool: import_lazy_zod6.z.string().describe(
+  tool: import_lazy_zod8.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_lazy_zod6.z.record(import_lazy_zod6.z.string(), import_lazy_zod6.z.unknown()).describe(
+  input: import_lazy_zod8.z.record(import_lazy_zod8.z.string(), import_lazy_zod8.z.unknown()).describe(
     "The input parameters for the tool. Structure must match the tool's input schema (check codecall:describe for schema details)."
   )
 };
@@ -2528,7 +2903,7 @@ function buildErrorResult(message) {
     isError: true
   };
 }
-var InvokeTool = class extends import_sdk6.ToolContext {
+var InvokeTool = class extends import_sdk8.ToolContext {
   async execute(input) {
     const { tool: toolName, input: toolInput } = input;
     if (isBlockedSelfReference(toolName)) {
@@ -2554,7 +2929,7 @@ var InvokeTool = class extends import_sdk6.ToolContext {
   }
 };
 InvokeTool = __decorateClass([
-  (0, import_sdk6.Tool)({
+  (0, import_sdk8.Tool)({
     name: "codecall:invoke",
     cache: {
       ttl: 0,
@@ -2572,13 +2947,12 @@ InvokeTool = __decorateClass([
 ], InvokeTool);
 
 // plugins/plugin-codecall/src/codecall.plugin.ts
-var import_plugin_cache = __toESM(require("@frontmcp/plugin-cache"));
-var CodeCallPlugin = class extends import_sdk7.DynamicPlugin {
+var CodeCallPlugin = class extends import_sdk9.DynamicPlugin {
   options;
   cachedLogger;
   getLogger() {
     if (!this.cachedLogger) {
-      this.cachedLogger = this.get(import_sdk7.FrontMcpLogger).child("CodeCall");
+      this.cachedLogger = this.get(import_sdk9.FrontMcpLogger).child("CodeCall");
     }
     return this.cachedLogger;
   }
@@ -2610,7 +2984,7 @@ var CodeCallPlugin = class extends import_sdk7.DynamicPlugin {
       {
         name: "codecall:tool-search",
         provide: ToolSearchService,
-        inject: () => [import_sdk7.ScopeEntry],
+        inject: () => [import_sdk9.ScopeEntry],
         useFactory: async (scope) => {
           return new ToolSearchService(
             {
@@ -2649,7 +3023,6 @@ var CodeCallPlugin = class extends import_sdk7.DynamicPlugin {
    * @param mode - The current CodeCall mode
    * @returns true if tool should be visible
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- ToolEntry generics vary across call sites
   shouldShowInListTools(tool, mode) {
     if (this.isCodeCallTool(tool)) {
       return true;
@@ -2681,29 +3054,27 @@ var CodeCallPlugin = class extends import_sdk7.DynamicPlugin {
    * Check if a tool is a CodeCall meta-tool.
    * CodeCall meta-tools always remain visible.
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   isCodeCallTool(tool) {
     const name = tool.name || tool.fullName;
-    return name.startsWith("codecall:");
+    return typeof name === "string" && name.startsWith("codecall:");
   }
   /**
    * Extract CodeCall-specific metadata from a tool.
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   getCodeCallMetadata(tool) {
     return tool.metadata?.["codecall"];
   }
 };
 __decorateClass([
-  import_sdk7.ListToolsHook.Did("resolveConflicts", { priority: 1e3 })
+  import_sdk9.ListToolsHook.Did("resolveConflicts", { priority: 1e3 })
 ], CodeCallPlugin.prototype, "adjustListTools", 1);
 CodeCallPlugin = __decorateClass([
-  (0, import_sdk7.Plugin)({
+  (0, import_sdk9.Plugin)({
     name: "codecall",
     description: "CodeCall plugin: AgentScript-based meta-tools for orchestrating MCP tools",
     providers: [],
     plugins: [import_plugin_cache.default],
-    tools: [SearchTool, DescribeTool, ExecuteTool, InvokeTool]
+    tools: [SearchTool, SearchSkillsTool, SearchKnowledgeTool, DescribeTool, ExecuteTool, InvokeTool]
   })
 ], CodeCallPlugin);
 // Annotate the CommonJS export names for ESM import in node: