@frontmcp/plugin-codecall 1.2.1 → 1.4.0

package/esm/index.mjs

@@ -10,6 +10,7 @@ var __decorateClass = (decorators, target, key, kind) => {
 };
 
 // plugins/plugin-codecall/src/codecall.plugin.ts
+import CachePlugin from "@frontmcp/plugin-cache";
 import {
   DynamicPlugin,
   FrontMcpLogger,
@@ -273,6 +274,104 @@ var DEFAULT_PLUGIN_OPTIONS = {
 };
 var codeCallPluginOptionsSchema = codeCallPluginOptionsObjectSchema.prefault(DEFAULT_PLUGIN_OPTIONS);
 
+// plugins/plugin-codecall/src/providers/code-call.config.ts
+import { Provider, ProviderScope, BaseConfig } from "@frontmcp/sdk";
+var CodeCallConfig = class extends BaseConfig {
+  constructor(options = {}) {
+    const parsedConfig = codeCallPluginOptionsSchema.parse(options);
+    const resolvedVm = resolveVmOptions(parsedConfig.vm);
+    super({ ...parsedConfig, resolvedVm });
+  }
+};
+CodeCallConfig = __decorateClass([
+  Provider({
+    name: "codecall:config",
+    description: "CodeCall plugin configuration with validated defaults",
+    scope: 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
 import { TFIDFVectoria, VectoriaDB } from "vectoriadb";
 
@@ -1179,8 +1278,8 @@ var ToolSearchService = class _ToolSearchService {
 };
 
 // plugins/plugin-codecall/src/services/enclave.service.ts
-import { Provider, ProviderScope } from "@frontmcp/sdk";
 import { Enclave } from "@enclave-vm/core";
+import { Provider as Provider2, ProviderScope as ProviderScope2 } from "@frontmcp/sdk";
 var ScriptTooLargeError = class extends Error {
   code = "SCRIPT_TOO_LARGE";
   scriptLength;
@@ -1229,6 +1328,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 Enclave({
       timeout: this.vmOptions.timeoutMs,
       maxToolCalls: this.vmOptions.maxSteps || 100,
@@ -1242,6 +1345,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
@@ -1338,10 +1446,10 @@ var EnclaveService = class {
   }
 };
 EnclaveService = __decorateClass([
-  Provider({
+  Provider2({
     name: "codecall:enclave",
     description: "Executes AgentScript code in a secure enclave",
-    scope: ProviderScope.GLOBAL
+    scope: ProviderScope2.GLOBAL
   })
 ], EnclaveService);
 
@@ -1485,10 +1593,295 @@ SearchTool = __decorateClass([
   })
 ], SearchTool);
 
-// plugins/plugin-codecall/src/tools/describe.tool.ts
-import { toJSONSchema, z as z4, ZodType } from "@frontmcp/lazy-zod";
+// plugins/plugin-codecall/src/tools/search-skills.tool.ts
 import { Tool as Tool2, ToolContext as ToolContext2 } from "@frontmcp/sdk";
 
+// plugins/plugin-codecall/src/tools/search-skills.schema.ts
+import { z as z3 } from "@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: z3.array(z3.string().min(2).max(256)).min(1).max(10).describe("Atomic skill queries. Split complex requests into simple actions."),
+  tags: z3.array(z3.string().min(1).max(64)).max(16).optional().describe("Filter to skills with any of these tags"),
+  excludeSkillNames: z3.array(z3.string()).max(50).optional().describe("Skip already-known skill names"),
+  topK: z3.number().int().positive().max(50).optional().default(5).describe("Results per query (default 5)"),
+  minRelevanceScore: z3.number().min(0).max(1).optional().default(0.1).describe("Minimum relevance threshold (default 0.1)")
+};
+var referencedOperationSchema = z3.object({
+  spec: z3.string().describe('OpenAPI spec id (e.g. "acme")'),
+  operationId: z3.string().describe('OpenAPI operation id (e.g. "getOrder")')
+});
+var skillSearchHitSchema = z3.object({
+  name: z3.string().describe("Skill name"),
+  description: z3.string().describe("Short description of what the skill does"),
+  tags: z3.array(z3.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: z3.array(referencedOperationSchema).describe("OpenAPI operations the skill can call"),
+  /** Decorator-declared tools (for skills built the legacy way). */
+  tools: z3.array(z3.string()).describe("Tool names the skill declares (if any)"),
+  relevanceScore: z3.number().min(0).max(1).describe("Match score (0-1)"),
+  matchedQueries: z3.array(z3.string()).describe("Which queries matched this skill"),
+  source: z3.enum(["local", "external"]).describe("Where the skill was loaded from")
+});
+var searchSkillsToolOutputSchema = z3.object({
+  skills: z3.array(skillSearchHitSchema).describe("Deduplicated executable skills, sorted by relevance"),
+  warnings: z3.array(
+    z3.object({
+      type: z3.enum(["no_results", "low_relevance", "excluded_skill_not_found"]).describe("Warning type"),
+      message: z3.string().describe("Warning message"),
+      affectedSkills: z3.array(z3.string()).optional().describe("Affected skill names")
+    })
+  ).describe("Search warnings"),
+  totalExecutableSkills: z3.number().int().nonnegative().describe("Total executable skills available")
+});
+
+// plugins/plugin-codecall/src/tools/search-skills.tool.ts
+var SearchSkillsTool = class extends ToolContext2 {
+  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([
+  Tool2({
+    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
+import { Tool as Tool3, ToolContext as ToolContext3 } from "@frontmcp/sdk";
+
+// plugins/plugin-codecall/src/tools/search-knowledge.schema.ts
+import { z as z4 } from "@frontmcp/lazy-zod";
+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: z4.array(z4.string().min(2).max(256)).min(1).max(10).describe("Atomic context queries."),
+  tags: z4.array(z4.string().min(1).max(64)).max(16).optional().describe("Filter to skills with any of these tags"),
+  excludeSkillNames: z4.array(z4.string()).max(50).optional().describe("Skip already-loaded knowledge skill names"),
+  topK: z4.number().int().positive().max(50).optional().default(5).describe("Results per query (default 5)"),
+  minRelevanceScore: z4.number().min(0).max(1).optional().default(0.1).describe("Minimum relevance threshold (default 0.1)")
+};
+var knowledgeHitSchema = z4.object({
+  name: z4.string().describe("Skill name"),
+  description: z4.string().describe("Short description of what the knowledge covers"),
+  tags: z4.array(z4.string()).describe("Tags carried by the skill"),
+  relevanceScore: z4.number().min(0).max(1).describe("Match score (0-1)"),
+  matchedQueries: z4.array(z4.string()).describe("Which queries matched this knowledge"),
+  source: z4.enum(["local", "external"]).describe("Where the skill was loaded from")
+});
+var searchKnowledgeToolOutputSchema = z4.object({
+  knowledge: z4.array(knowledgeHitSchema).describe("Deduplicated knowledge skills, sorted by relevance"),
+  warnings: z4.array(
+    z4.object({
+      type: z4.enum(["no_results", "low_relevance", "excluded_skill_not_found"]).describe("Warning type"),
+      message: z4.string().describe("Warning message"),
+      affectedSkills: z4.array(z4.string()).optional().describe("Affected skill names")
+    })
+  ).describe("Search warnings"),
+  totalKnowledgeSkills: z4.number().int().nonnegative().describe("Total knowledge-only skills available")
+});
+
+// plugins/plugin-codecall/src/tools/search-knowledge.tool.ts
+var SearchKnowledgeTool = class extends ToolContext3 {
+  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([
+  Tool3({
+    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
+import { toJSONSchema, z as z6, ZodType } from "@frontmcp/lazy-zod";
+import { Tool as Tool4, ToolContext as ToolContext4 } from "@frontmcp/sdk";
+
 // plugins/plugin-codecall/src/errors/tool-call.errors.ts
 var TOOL_CALL_ERROR_CODES = {
   NOT_FOUND: "NOT_FOUND",
@@ -1567,6 +1960,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,
@@ -1856,7 +2313,7 @@ function extractResultFromCallToolResult(mcpResult) {
 }
 
 // plugins/plugin-codecall/src/tools/describe.schema.ts
-import { z as z3 } from "@frontmcp/lazy-zod";
+import { z as z5 } from "@frontmcp/lazy-zod";
 import { ToolAnnotationsSchema } from "@frontmcp/protocol";
 var describeToolDescription = `Get input/output schemas for tools from search results.
 
@@ -1866,7 +2323,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: z3.array(z3.string()).min(1).superRefine((toolNames, ctx) => {
+  toolNames: z5.array(z5.string()).min(1).superRefine((toolNames, ctx) => {
     const seen = /* @__PURE__ */ new Set();
     const duplicates = /* @__PURE__ */ new Set();
     for (const name of toolNames) {
@@ -1877,7 +2334,7 @@ var describeToolInputSchema = {
     }
     if (duplicates.size > 0) {
       ctx.addIssue({
-        code: z3.ZodIssueCode.custom,
+        code: z5.ZodIssueCode.custom,
         message: `Duplicate tool names are not allowed: ${Array.from(duplicates).join(", ")}`
       });
     }
@@ -1885,30 +2342,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 = z3.object({
-  tools: z3.array(
-    z3.object({
-      name: z3.string().describe("Tool name to be used in callTool() within codecall:execute scripts"),
-      appId: z3.string().describe("The app ID this tool belongs to"),
-      description: z3.string().describe("Detailed description of what this tool does"),
-      inputSchema: z3.record(z3.string(), z3.unknown()).nullable().describe("JSON Schema object describing the tool input parameters"),
-      outputSchema: z3.record(z3.string(), z3.unknown()).nullable().describe("JSON Schema object describing the tool output structure"),
+var describeToolOutputSchema = z5.object({
+  tools: z5.array(
+    z5.object({
+      name: z5.string().describe("Tool name to be used in callTool() within codecall:execute scripts"),
+      appId: z5.string().describe("The app ID this tool belongs to"),
+      description: z5.string().describe("Detailed description of what this tool does"),
+      inputSchema: z5.record(z5.string(), z5.unknown()).nullable().describe("JSON Schema object describing the tool input parameters"),
+      outputSchema: z5.record(z5.string(), z5.unknown()).nullable().describe("JSON Schema object describing the tool output structure"),
       annotations: ToolAnnotationsSchema.optional().describe("MCP tool annotations (metadata)"),
-      usageExamples: z3.array(
-        z3.object({
-          description: z3.string().describe("Description of what this example demonstrates"),
-          code: z3.string().describe(
+      usageExamples: z5.array(
+        z5.object({
+          description: z5.string().describe("Description of what this example demonstrates"),
+          code: z5.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: z3.array(z3.string()).optional().describe("Tool names that were requested but not found in the index. Check these for typos.")
+  notFound: z5.array(z5.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 ToolContext2 {
+var DescribeTool = class extends ToolContext4 {
   async execute(input) {
     const { toolNames } = input;
     const tools = [];
@@ -1928,7 +2385,7 @@ var DescribeTool = class extends ToolContext2 {
       }
       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,
@@ -1959,7 +2416,7 @@ var DescribeTool = class extends ToolContext2 {
       try {
         const firstValue = Object.values(tool.inputSchema)[0];
         if (firstValue instanceof ZodType) {
-          return toJSONSchema(z4.object(tool.inputSchema));
+          return toJSONSchema(z6.object(tool.inputSchema));
         }
       } catch {
       }
@@ -1991,7 +2448,7 @@ var DescribeTool = class extends ToolContext2 {
       const firstValue = Object.values(obj)[0];
       if (firstValue instanceof ZodType) {
         try {
-          return toJSONSchema(z4.object(obj));
+          return toJSONSchema(z6.object(obj));
         } catch {
           return null;
         }
@@ -2054,7 +2511,7 @@ return result;`
   }
 };
 DescribeTool = __decorateClass([
-  Tool2({
+  Tool4({
     name: "codecall:describe",
     cache: {
       ttl: 60,
@@ -2076,10 +2533,10 @@ DescribeTool = __decorateClass([
 ], DescribeTool);
 
 // plugins/plugin-codecall/src/tools/execute.tool.ts
-import { Tool as Tool3, ToolContext as ToolContext3 } from "@frontmcp/sdk";
+import { Tool as Tool5, ToolContext as ToolContext5 } from "@frontmcp/sdk";
 
 // plugins/plugin-codecall/src/tools/execute.schema.ts
-import { z as z5 } from "@frontmcp/lazy-zod";
+import { z as z7 } from "@frontmcp/lazy-zod";
 var MIN_EXECUTE_SCRIPT_LENGTH = 'return callTool("a",{})'.length;
 var executeToolDescription = `Execute AgentScript (safe JS subset) for multi-tool orchestration.
 
@@ -2103,72 +2560,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: z5.string().min(MIN_EXECUTE_SCRIPT_LENGTH).max(100 * 1024).describe(
+  script: z7.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: z5.array(z5.string()).optional().describe(
+  allowedTools: z7.array(z7.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 = z5.object({
-  message: z5.string(),
-  location: z5.object({
-    line: z5.number(),
-    column: z5.number()
+var syntaxErrorPayloadSchema = z7.object({
+  message: z7.string(),
+  location: z7.object({
+    line: z7.number(),
+    column: z7.number()
   }).optional()
 });
-var illegalAccessErrorPayloadSchema = z5.object({
-  message: z5.string(),
-  kind: z5.union([
-    z5.literal("IllegalBuiltinAccess"),
-    z5.literal("DisallowedGlobal"),
-    z5.string()
+var illegalAccessErrorPayloadSchema = z7.object({
+  message: z7.string(),
+  kind: z7.union([
+    z7.literal("IllegalBuiltinAccess"),
+    z7.literal("DisallowedGlobal"),
+    z7.string()
     // same as your original type: 'A' | 'B' | string
   ])
 });
-var runtimeErrorPayloadSchema = z5.object({
-  source: z5.literal("script"),
-  message: z5.string(),
-  name: z5.string().optional(),
-  stack: z5.string().optional()
+var runtimeErrorPayloadSchema = z7.object({
+  source: z7.literal("script"),
+  message: z7.string(),
+  name: z7.string().optional(),
+  stack: z7.string().optional()
 });
-var toolErrorPayloadSchema = z5.object({
-  source: z5.literal("tool"),
-  toolName: z5.string(),
-  toolInput: z5.unknown(),
-  message: z5.string(),
-  code: z5.string().optional(),
-  details: z5.unknown().optional()
+var toolErrorPayloadSchema = z7.object({
+  source: z7.literal("tool"),
+  toolName: z7.string(),
+  toolInput: z7.unknown(),
+  message: z7.string(),
+  code: z7.string().optional(),
+  details: z7.unknown().optional()
 });
-var timeoutErrorPayloadSchema = z5.object({
-  message: z5.string()
+var timeoutErrorPayloadSchema = z7.object({
+  message: z7.string()
 });
-var codeCallOkResultSchema = z5.object({
-  status: z5.literal("ok"),
-  result: z5.unknown(),
-  logs: z5.array(z5.string()).optional()
+var codeCallOkResultSchema = z7.object({
+  status: z7.literal("ok"),
+  result: z7.unknown(),
+  logs: z7.array(z7.string()).optional()
 });
-var codeCallSyntaxErrorResultSchema = z5.object({
-  status: z5.literal("syntax_error"),
+var codeCallSyntaxErrorResultSchema = z7.object({
+  status: z7.literal("syntax_error"),
   error: syntaxErrorPayloadSchema
 });
-var codeCallIllegalAccessResultSchema = z5.object({
-  status: z5.literal("illegal_access"),
+var codeCallIllegalAccessResultSchema = z7.object({
+  status: z7.literal("illegal_access"),
   error: illegalAccessErrorPayloadSchema
 });
-var codeCallRuntimeErrorResultSchema = z5.object({
-  status: z5.literal("runtime_error"),
+var codeCallRuntimeErrorResultSchema = z7.object({
+  status: z7.literal("runtime_error"),
   error: runtimeErrorPayloadSchema
 });
-var codeCallToolErrorResultSchema = z5.object({
-  status: z5.literal("tool_error"),
+var codeCallToolErrorResultSchema = z7.object({
+  status: z7.literal("tool_error"),
   error: toolErrorPayloadSchema
 });
-var codeCallTimeoutResultSchema = z5.object({
-  status: z5.literal("timeout"),
+var codeCallTimeoutResultSchema = z7.object({
+  status: z7.literal("timeout"),
   error: timeoutErrorPayloadSchema
 });
-var executeToolOutputSchema = z5.discriminatedUnion("status", [
+var executeToolOutputSchema = z7.discriminatedUnion("status", [
   codeCallOkResultSchema,
   codeCallSyntaxErrorResultSchema,
   codeCallIllegalAccessResultSchema,
@@ -2177,104 +2634,6 @@ var executeToolOutputSchema = z5.discriminatedUnion("status", [
   codeCallTimeoutResultSchema
 ]);
 
-// plugins/plugin-codecall/src/providers/code-call.config.ts
-import { Provider as Provider2, ProviderScope as ProviderScope2, BaseConfig } from "@frontmcp/sdk";
-var CodeCallConfig = class extends BaseConfig {
-  constructor(options = {}) {
-    const parsedConfig = codeCallPluginOptionsSchema.parse(options);
-    const resolvedVm = resolveVmOptions(parsedConfig.vm);
-    super({ ...parsedConfig, resolvedVm });
-  }
-};
-CodeCallConfig = __decorateClass([
-  Provider2({
-    name: "codecall:config",
-    description: "CodeCall plugin configuration with validated defaults",
-    scope: ProviderScope2.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)) {
@@ -2291,7 +2650,7 @@ function getErrorCode(error) {
   }
   return TOOL_CALL_ERROR_CODES.EXECUTION;
 }
-var ExecuteTool = class extends ToolContext3 {
+var ExecuteTool = class extends ToolContext5 {
   async execute(input) {
     const { script, allowedTools } = input;
     const allowedToolSet = allowedTools ? new Set(allowedTools) : null;
@@ -2363,6 +2722,22 @@ var ExecuteTool = class extends ToolContext3 {
         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 {
@@ -2441,7 +2816,7 @@ var ExecuteTool = class extends ToolContext3 {
   }
 };
 ExecuteTool = __decorateClass([
-  Tool3({
+  Tool5({
     name: "codecall:execute",
     cache: {
       ttl: 0,
@@ -2459,10 +2834,10 @@ ExecuteTool = __decorateClass([
 ], ExecuteTool);
 
 // plugins/plugin-codecall/src/tools/invoke.tool.ts
-import { Tool as Tool4, ToolContext as ToolContext4 } from "@frontmcp/sdk";
+import { Tool as Tool6, ToolContext as ToolContext6 } from "@frontmcp/sdk";
 
 // plugins/plugin-codecall/src/tools/invoke.schema.ts
-import { z as z6 } from "@frontmcp/lazy-zod";
+import { z as z8 } from "@frontmcp/lazy-zod";
 import { CallToolResultSchema } from "@frontmcp/protocol";
 var invokeToolDescription = `Call ONE tool directly. Returns standard MCP CallToolResult.
 
@@ -2475,10 +2850,10 @@ ERRORS: tool_not_found (\u2192 re-search) | validation_error | execution_error |
 
 FLOW: search \u2192 describe \u2192 invoke`;
 var invokeToolInputSchema = {
-  tool: z6.string().describe(
+  tool: z8.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: z6.record(z6.string(), z6.unknown()).describe(
+  input: z8.record(z8.string(), z8.unknown()).describe(
     "The input parameters for the tool. Structure must match the tool's input schema (check codecall:describe for schema details)."
   )
 };
@@ -2491,7 +2866,7 @@ function buildErrorResult(message) {
     isError: true
   };
 }
-var InvokeTool = class extends ToolContext4 {
+var InvokeTool = class extends ToolContext6 {
   async execute(input) {
     const { tool: toolName, input: toolInput } = input;
     if (isBlockedSelfReference(toolName)) {
@@ -2517,7 +2892,7 @@ var InvokeTool = class extends ToolContext4 {
   }
 };
 InvokeTool = __decorateClass([
-  Tool4({
+  Tool6({
     name: "codecall:invoke",
     cache: {
       ttl: 0,
@@ -2535,7 +2910,6 @@ InvokeTool = __decorateClass([
 ], InvokeTool);
 
 // plugins/plugin-codecall/src/codecall.plugin.ts
-import CachePlugin from "@frontmcp/plugin-cache";
 var CodeCallPlugin = class extends DynamicPlugin {
   options;
   cachedLogger;
@@ -2612,7 +2986,6 @@ var CodeCallPlugin = class extends 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;
@@ -2644,15 +3017,13 @@ var CodeCallPlugin = class extends 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"];
   }
@@ -2666,7 +3037,7 @@ CodeCallPlugin = __decorateClass([
     description: "CodeCall plugin: AgentScript-based meta-tools for orchestrating MCP tools",
     providers: [],
     plugins: [CachePlugin],
-    tools: [SearchTool, DescribeTool, ExecuteTool, InvokeTool]
+    tools: [SearchTool, SearchSkillsTool, SearchKnowledgeTool, DescribeTool, ExecuteTool, InvokeTool]
   })
 ], CodeCallPlugin);
 export {