@frontmcp/plugin-codecall 1.0.4 → 1.1.0

package/index.js

@@ -56,19 +56,19 @@ module.exports = __toCommonJS(index_exports);
 var import_sdk7 = require("@frontmcp/sdk");
 
 // plugins/plugin-codecall/src/codecall.types.ts
-var import_zod = require("zod");
-var directCallsFilterSchema = import_zod.z.custom((val) => typeof val === "function", {
+var import_lazy_zod = require("@frontmcp/lazy-zod");
+var directCallsFilterSchema = import_lazy_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", {
+var includeToolsFilterSchema = import_lazy_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 codeCallModeSchema = import_lazy_zod.z.enum(["codecall_only", "codecall_opt_in", "metadata_driven"]).default("codecall_only");
+var codeCallVmPresetSchema = import_lazy_zod.z.enum(["locked_down", "secure", "balanced", "experimental"]).default("secure");
 var DEFAULT_VM_OPTIONS = {
   preset: "secure"
 };
-var codeCallVmOptionsSchema = import_zod.z.object({
+var codeCallVmOptionsSchema = import_lazy_zod.z.object({
   /**
    * CSP-like preset; see README.
    * @default 'secure'
@@ -78,86 +78,86 @@ var codeCallVmOptionsSchema = import_zod.z.object({
    * Timeout for script execution in milliseconds
    * Defaults vary by preset
    */
-  timeoutMs: import_zod.z.number().positive().optional(),
+  timeoutMs: import_lazy_zod.z.number().positive().optional(),
   /**
    * Allow loop constructs (for, while, do-while)
    * Defaults vary by preset
    */
-  allowLoops: import_zod.z.boolean().optional(),
+  allowLoops: import_lazy_zod.z.boolean().optional(),
   /**
    * Maximum number of steps (if applicable)
    * Defaults vary by preset
    */
-  maxSteps: import_zod.z.number().positive().optional(),
+  maxSteps: import_lazy_zod.z.number().positive().optional(),
   /**
    * List of disabled builtin functions
    * Defaults vary by preset
    */
-  disabledBuiltins: import_zod.z.array(import_zod.z.string()).optional(),
+  disabledBuiltins: import_lazy_zod.z.array(import_lazy_zod.z.string()).optional(),
   /**
    * List of disabled global variables
    * Defaults vary by preset
    */
-  disabledGlobals: import_zod.z.array(import_zod.z.string()).optional(),
+  disabledGlobals: import_lazy_zod.z.array(import_lazy_zod.z.string()).optional(),
   /**
    * Allow console.log/warn/error
    * Defaults vary by preset
    */
-  allowConsole: import_zod.z.boolean().optional(),
+  allowConsole: import_lazy_zod.z.boolean().optional(),
   /**
    * Maximum nesting depth for sanitized output values
    * Prevents deeply nested objects from causing stack overflow
    * @default varies by preset (secure: 50)
    */
-  maxSanitizeDepth: import_zod.z.number().positive().optional(),
+  maxSanitizeDepth: import_lazy_zod.z.number().positive().optional(),
   /**
    * Maximum properties per object in sanitized output values
    * Limits array sizes and object keys in return values
    * @default varies by preset (secure: 2000)
    */
-  maxSanitizeProperties: import_zod.z.number().positive().optional()
+  maxSanitizeProperties: import_lazy_zod.z.number().positive().optional()
 }).default(() => DEFAULT_VM_OPTIONS);
-var codeCallDirectCallsOptionsSchema = import_zod.z.object({
+var codeCallDirectCallsOptionsSchema = import_lazy_zod.z.object({
   /**
    * Enable/disable the `codecall.invoke` meta-tool.
    */
-  enabled: import_zod.z.boolean(),
+  enabled: import_lazy_zod.z.boolean(),
   /**
    * Optional allowlist of tool names.
    */
-  allowedTools: import_zod.z.array(import_zod.z.string()).optional(),
+  allowedTools: import_lazy_zod.z.array(import_lazy_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({
+var embeddingStrategySchema = import_lazy_zod.z.enum(["tfidf", "ml"]).default("tfidf");
+var synonymExpansionConfigSchema = import_lazy_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),
+  enabled: import_lazy_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(),
+  additionalSynonyms: import_lazy_zod.z.array(import_lazy_zod.z.array(import_lazy_zod.z.string())).optional(),
   /**
    * Replace default synonyms entirely with additionalSynonyms.
    * @default false
    */
-  replaceDefaults: import_zod.z.boolean().default(false),
+  replaceDefaults: import_lazy_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)
+  maxExpansionsPerTerm: import_lazy_zod.z.number().positive().default(5)
 }).default({ enabled: true, replaceDefaults: false, maxExpansionsPerTerm: 5 });
 var DEFAULT_EMBEDDING_OPTIONS = {
   strategy: "tfidf",
@@ -166,7 +166,7 @@ var DEFAULT_EMBEDDING_OPTIONS = {
   useHNSW: false,
   synonymExpansion: { enabled: true, replaceDefaults: false, maxExpansionsPerTerm: 5 }
 };
-var codeCallEmbeddingOptionsSchema = import_zod.z.object({
+var codeCallEmbeddingOptionsSchema = import_lazy_zod.z.object({
   /**
    * Embedding strategy to use for tool search
    * - 'tfidf': Lightweight, synchronous TF-IDF based search (no ML models required)
@@ -178,18 +178,18 @@ var codeCallEmbeddingOptionsSchema = import_zod.z.object({
    * Model name for ML-based embeddings (only used when strategy='ml')
    * @default 'Xenova/all-MiniLM-L6-v2'
    */
-  modelName: import_zod.z.string().optional(),
+  modelName: import_lazy_zod.z.string().optional(),
   /**
    * Cache directory for ML models (only used when strategy='ml')
    * @default './.cache/transformers'
    */
-  cacheDir: import_zod.z.string().optional(),
+  cacheDir: import_lazy_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(),
+  useHNSW: import_lazy_zod.z.boolean().optional(),
   /**
    * Synonym expansion configuration for TF-IDF search.
    * When enabled, queries like "add user" will match tools for "create user".
@@ -197,7 +197,7 @@ var codeCallEmbeddingOptionsSchema = import_zod.z.object({
    * 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()
+  synonymExpansion: import_lazy_zod.z.union([import_lazy_zod.z.literal(false), synonymExpansionConfigSchema]).optional()
 }).optional().transform((opts) => ({
   strategy: opts?.strategy ?? DEFAULT_EMBEDDING_OPTIONS.strategy,
   modelName: opts?.modelName ?? DEFAULT_EMBEDDING_OPTIONS.modelName,
@@ -205,53 +205,53 @@ var codeCallEmbeddingOptionsSchema = import_zod.z.object({
   useHNSW: opts?.useHNSW ?? DEFAULT_EMBEDDING_OPTIONS.useHNSW,
   synonymExpansion: opts?.synonymExpansion ?? DEFAULT_EMBEDDING_OPTIONS.synonymExpansion
 }));
-var codeCallSidecarOptionsSchema = import_zod.z.object({
+var codeCallSidecarOptionsSchema = import_lazy_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),
+  enabled: import_lazy_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(),
+  maxTotalSize: import_lazy_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(),
+  maxReferenceSize: import_lazy_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(),
+  extractionThreshold: import_lazy_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(),
+  maxResolvedSize: import_lazy_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(),
+  allowComposites: import_lazy_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)
+  maxScriptLengthWhenDisabled: import_lazy_zod.z.number().positive().nullable().default(64 * 1024)
 }).default(() => ({
   enabled: false,
   maxScriptLengthWhenDisabled: 64 * 1024
 }));
-var codeCallPluginOptionsObjectSchema = import_zod.z.object({
+var codeCallPluginOptionsObjectSchema = import_lazy_zod.z.object({
   /**
    * CodeCall mode
    * @default 'codecall_only'
@@ -263,17 +263,17 @@ var codeCallPluginOptionsObjectSchema = import_zod.z.object({
    * When unset (default), all tools in the server are affected.
    * @example ['ecommerce'] — only hide ecommerce app tools, keep calc tools visible
    */
-  appIds: import_zod.z.array(import_zod.z.string()).optional(),
+  appIds: import_lazy_zod.z.array(import_lazy_zod.z.string()).optional(),
   /**
    * Default number of tools to return in search results
    * @default 8
    */
-  topK: import_zod.z.number().positive().default(8),
+  topK: import_lazy_zod.z.number().positive().default(8),
   /**
    * Maximum number of tool definitions to include
    * @default 8
    */
-  maxDefinitions: import_zod.z.number().positive().default(8),
+  maxDefinitions: import_lazy_zod.z.number().positive().default(8),
   /**
    * Optional filter function for including tools.
    * Signature: (tool: IncludeToolsFilterToolInfo) => boolean
@@ -1386,7 +1386,7 @@ EnclaveService = __decorateClass([
 var import_sdk2 = require("@frontmcp/sdk");
 
 // plugins/plugin-codecall/src/tools/search.schema.ts
-var import_zod2 = require("zod");
+var import_lazy_zod2 = require("@frontmcp/lazy-zod");
 var searchToolDescription = `Find tools by splitting user request into atomic actions.
 
 DECOMPOSE: "delete users and send email" \u2192 queries: ["delete user", "send email"]
@@ -1406,30 +1406,30 @@ OUTPUT: Flat deduplicated tool list. relevanceScore: 0.5+=good, 0.7+=strong matc
 
 FLOW: search \u2192 describe \u2192 execute/invoke`;
 var searchToolInputSchema = {
-  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)")
+  queries: import_lazy_zod2.z.array(import_lazy_zod2.z.string().min(2).max(256)).min(1).max(10).describe("Atomic action queries. Split complex requests into simple actions."),
+  appIds: import_lazy_zod2.z.array(import_lazy_zod2.z.string()).max(10).optional().describe("Filter by app IDs"),
+  excludeToolNames: import_lazy_zod2.z.array(import_lazy_zod2.z.string()).max(50).optional().describe("Skip already-known tool names"),
+  topK: import_lazy_zod2.z.number().int().positive().max(50).optional().default(10).describe("Results per query (default 10)"),
+  minRelevanceScore: import_lazy_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")
+var searchToolOutputSchema = import_lazy_zod2.z.object({
+  tools: import_lazy_zod2.z.array(
+    import_lazy_zod2.z.object({
+      name: import_lazy_zod2.z.string().describe('Tool name (e.g., "users:list")'),
+      appId: import_lazy_zod2.z.string().optional().describe("App ID"),
+      description: import_lazy_zod2.z.string().describe("What this tool does"),
+      relevanceScore: import_lazy_zod2.z.number().min(0).max(1).describe("Match score (0-1)"),
+      matchedQueries: import_lazy_zod2.z.array(import_lazy_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")
+  warnings: import_lazy_zod2.z.array(
+    import_lazy_zod2.z.object({
+      type: import_lazy_zod2.z.enum(["excluded_tool_not_found", "no_results", "low_relevance"]).describe("Warning type"),
+      message: import_lazy_zod2.z.string().describe("Warning message"),
+      affectedTools: import_lazy_zod2.z.array(import_lazy_zod2.z.string()).optional().describe("Affected tool names")
     })
   ).describe("Search warnings"),
-  totalAvailableTools: import_zod2.z.number().int().nonnegative().describe("Total tools in index")
+  totalAvailableTools: import_lazy_zod2.z.number().int().nonnegative().describe("Total tools in index")
 });
 
 // plugins/plugin-codecall/src/tools/search.tool.ts
@@ -1523,61 +1523,86 @@ SearchTool = __decorateClass([
 ], SearchTool);
 
 // plugins/plugin-codecall/src/tools/describe.tool.ts
+var import_lazy_zod4 = require("@frontmcp/lazy-zod");
 var import_sdk3 = require("@frontmcp/sdk");
-var import_v4 = require("zod/v4");
-var import_zod4 = require("zod");
 
-// plugins/plugin-codecall/src/tools/describe.schema.ts
-var import_zod3 = require("zod");
-var import_protocol = require("@frontmcp/protocol");
-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 = {
-  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"]'
-  )
+// plugins/plugin-codecall/src/errors/tool-call.errors.ts
+var TOOL_CALL_ERROR_CODES = {
+  NOT_FOUND: "NOT_FOUND",
+  VALIDATION: "VALIDATION",
+  EXECUTION: "EXECUTION",
+  TIMEOUT: "TIMEOUT",
+  ACCESS_DENIED: "ACCESS_DENIED",
+  SELF_REFERENCE: "SELF_REFERENCE"
 };
-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_protocol.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.")
-});
+function createToolCallError(code, toolName, rawMessage) {
+  const sanitizedMessage = getSanitizedMessage(code, toolName, rawMessage);
+  return Object.freeze({
+    code,
+    message: sanitizedMessage,
+    toolName
+  });
+}
+function getSanitizedMessage(code, toolName, rawMessage) {
+  switch (code) {
+    case TOOL_CALL_ERROR_CODES.NOT_FOUND:
+      return `Tool "${toolName}" was not found`;
+    case TOOL_CALL_ERROR_CODES.VALIDATION:
+      return rawMessage ? sanitizeValidationMessage(rawMessage) : `Input validation failed for tool "${toolName}"`;
+    case TOOL_CALL_ERROR_CODES.EXECUTION:
+      return `Tool "${toolName}" execution failed`;
+    case TOOL_CALL_ERROR_CODES.TIMEOUT:
+      return `Tool "${toolName}" execution timed out`;
+    case TOOL_CALL_ERROR_CODES.ACCESS_DENIED:
+      return `Access denied for tool "${toolName}"`;
+    case TOOL_CALL_ERROR_CODES.SELF_REFERENCE:
+      return `Cannot call CodeCall tools from within AgentScript`;
+    default:
+      return `An error occurred while calling "${toolName}"`;
+  }
+}
+function sanitizeValidationMessage(message) {
+  let sanitized = message.replace(/(?:\/[\w.-]+)+|(?:[A-Za-z]:\\[\w\\.-]+)+/g, "[path]");
+  sanitized = sanitized.replace(/\bat line \d+/gi, "");
+  sanitized = sanitized.replace(/\bline \d+/gi, "");
+  sanitized = sanitized.replace(/:\d+:\d+/g, "");
+  sanitized = sanitized.replace(/\n\s*at .*/g, "");
+  if (sanitized.length > 200) {
+    sanitized = sanitized.substring(0, 200) + "...";
+  }
+  return sanitized.trim();
+}
+var SelfReferenceError = class extends Error {
+  code = TOOL_CALL_ERROR_CODES.SELF_REFERENCE;
+  toolName;
+  constructor(toolName) {
+    super(`Self-reference attack: Attempted to call CodeCall tool "${toolName}" from within AgentScript`);
+    this.name = "SelfReferenceError";
+    this.toolName = toolName;
+    Object.freeze(this);
+  }
+};
+
+// plugins/plugin-codecall/src/security/self-reference-guard.ts
+var CODECALL_TOOL_PREFIX = "codecall:";
+var BLOCKED_CODECALL_TOOLS = Object.freeze(
+  /* @__PURE__ */ new Set(["codecall:search", "codecall:describe", "codecall:execute", "codecall:invoke"])
+);
+function isBlockedSelfReference(toolName) {
+  const normalizedName = toolName.toLowerCase().trim();
+  if (normalizedName.startsWith(CODECALL_TOOL_PREFIX)) {
+    return true;
+  }
+  if (BLOCKED_CODECALL_TOOLS.has(toolName)) {
+    return true;
+  }
+  return false;
+}
+function assertNotSelfReference(toolName) {
+  if (isBlockedSelfReference(toolName)) {
+    throw new SelfReferenceError(toolName);
+  }
+}
 
 // plugins/plugin-codecall/src/utils/describe.utils.ts
 var INTENT_PATTERNS = {
@@ -1867,83 +1892,57 @@ function extractResultFromCallToolResult(mcpResult) {
   return content;
 }
 
-// plugins/plugin-codecall/src/errors/tool-call.errors.ts
-var TOOL_CALL_ERROR_CODES = {
-  NOT_FOUND: "NOT_FOUND",
-  VALIDATION: "VALIDATION",
-  EXECUTION: "EXECUTION",
-  TIMEOUT: "TIMEOUT",
-  ACCESS_DENIED: "ACCESS_DENIED",
-  SELF_REFERENCE: "SELF_REFERENCE"
-};
-function createToolCallError(code, toolName, rawMessage) {
-  const sanitizedMessage = getSanitizedMessage(code, toolName, rawMessage);
-  return Object.freeze({
-    code,
-    message: sanitizedMessage,
-    toolName
-  });
-}
-function getSanitizedMessage(code, toolName, rawMessage) {
-  switch (code) {
-    case TOOL_CALL_ERROR_CODES.NOT_FOUND:
-      return `Tool "${toolName}" was not found`;
-    case TOOL_CALL_ERROR_CODES.VALIDATION:
-      return rawMessage ? sanitizeValidationMessage(rawMessage) : `Input validation failed for tool "${toolName}"`;
-    case TOOL_CALL_ERROR_CODES.EXECUTION:
-      return `Tool "${toolName}" execution failed`;
-    case TOOL_CALL_ERROR_CODES.TIMEOUT:
-      return `Tool "${toolName}" execution timed out`;
-    case TOOL_CALL_ERROR_CODES.ACCESS_DENIED:
-      return `Access denied for tool "${toolName}"`;
-    case TOOL_CALL_ERROR_CODES.SELF_REFERENCE:
-      return `Cannot call CodeCall tools from within AgentScript`;
-    default:
-      return `An error occurred while calling "${toolName}"`;
-  }
-}
-function sanitizeValidationMessage(message) {
-  let sanitized = message.replace(/(?:\/[\w.-]+)+|(?:[A-Za-z]:\\[\w\\.-]+)+/g, "[path]");
-  sanitized = sanitized.replace(/\bat line \d+/gi, "");
-  sanitized = sanitized.replace(/\bline \d+/gi, "");
-  sanitized = sanitized.replace(/:\d+:\d+/g, "");
-  sanitized = sanitized.replace(/\n\s*at .*/g, "");
-  if (sanitized.length > 200) {
-    sanitized = sanitized.substring(0, 200) + "...";
-  }
-  return sanitized.trim();
-}
-var SelfReferenceError = class extends Error {
-  code = TOOL_CALL_ERROR_CODES.SELF_REFERENCE;
-  toolName;
-  constructor(toolName) {
-    super(`Self-reference attack: Attempted to call CodeCall tool "${toolName}" from within AgentScript`);
-    this.name = "SelfReferenceError";
-    this.toolName = toolName;
-    Object.freeze(this);
-  }
-};
+// plugins/plugin-codecall/src/tools/describe.schema.ts
+var import_lazy_zod3 = require("@frontmcp/lazy-zod");
+var import_protocol = require("@frontmcp/protocol");
+var describeToolDescription = `Get input/output schemas for tools from search results.
 
-// plugins/plugin-codecall/src/security/self-reference-guard.ts
-var CODECALL_TOOL_PREFIX = "codecall:";
-var BLOCKED_CODECALL_TOOLS = Object.freeze(
-  /* @__PURE__ */ new Set(["codecall:search", "codecall:describe", "codecall:execute", "codecall:invoke"])
-);
-function isBlockedSelfReference(toolName) {
-  const normalizedName = toolName.toLowerCase().trim();
-  if (normalizedName.startsWith(CODECALL_TOOL_PREFIX)) {
-    return true;
-  }
-  if (BLOCKED_CODECALL_TOOLS.has(toolName)) {
-    return true;
-  }
-  return false;
-}
-function assertNotSelfReference(toolName) {
-  if (isBlockedSelfReference(toolName)) {
-    throw new SelfReferenceError(toolName);
-  }
-}
+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 = {
+  toolNames: import_lazy_zod3.z.array(import_lazy_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_lazy_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_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"),
+      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(
+            '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.")
+});
 
 // plugins/plugin-codecall/src/tools/describe.tool.ts
 var DescribeTool = class extends import_sdk3.ToolContext {
@@ -1996,8 +1995,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_zod4.ZodType) {
-          return (0, import_v4.toJSONSchema)(import_zod4.z.object(tool.inputSchema));
+        if (firstValue instanceof import_lazy_zod4.ZodType) {
+          return (0, import_lazy_zod4.toJSONSchema)(import_lazy_zod4.z.object(tool.inputSchema));
         }
       } catch {
       }
@@ -2017,9 +2016,9 @@ var DescribeTool = class extends import_sdk3.ToolContext {
     if (!schema) {
       return null;
     }
-    if (schema instanceof import_zod4.ZodType) {
+    if (schema instanceof import_lazy_zod4.ZodType) {
       try {
-        return (0, import_v4.toJSONSchema)(schema);
+        return (0, import_lazy_zod4.toJSONSchema)(schema);
       } catch {
         return null;
       }
@@ -2027,9 +2026,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_zod4.ZodType) {
+      if (firstValue instanceof import_lazy_zod4.ZodType) {
         try {
-          return (0, import_v4.toJSONSchema)(import_zod4.z.object(obj));
+          return (0, import_lazy_zod4.toJSONSchema)(import_lazy_zod4.z.object(obj));
         } catch {
           return null;
         }
@@ -2117,7 +2116,7 @@ DescribeTool = __decorateClass([
 var import_sdk5 = require("@frontmcp/sdk");
 
 // plugins/plugin-codecall/src/tools/execute.schema.ts
-var import_zod5 = require("zod");
+var import_lazy_zod5 = require("@frontmcp/lazy-zod");
 var MIN_EXECUTE_SCRIPT_LENGTH = 'return callTool("a",{})'.length;
 var executeToolDescription = `Execute AgentScript (safe JS subset) for multi-tool orchestration.
 
@@ -2141,72 +2140,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_zod5.z.string().min(MIN_EXECUTE_SCRIPT_LENGTH).max(100 * 1024).describe(
+  script: import_lazy_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(
+  allowedTools: import_lazy_zod5.z.array(import_lazy_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()
+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()
   }).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()
+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()
     // 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 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 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 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 timeoutErrorPayloadSchema = import_zod5.z.object({
-  message: import_zod5.z.string()
+var timeoutErrorPayloadSchema = import_lazy_zod5.z.object({
+  message: import_lazy_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 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 codeCallSyntaxErrorResultSchema = import_zod5.z.object({
-  status: import_zod5.z.literal("syntax_error"),
+var codeCallSyntaxErrorResultSchema = import_lazy_zod5.z.object({
+  status: import_lazy_zod5.z.literal("syntax_error"),
   error: syntaxErrorPayloadSchema
 });
-var codeCallIllegalAccessResultSchema = import_zod5.z.object({
-  status: import_zod5.z.literal("illegal_access"),
+var codeCallIllegalAccessResultSchema = import_lazy_zod5.z.object({
+  status: import_lazy_zod5.z.literal("illegal_access"),
   error: illegalAccessErrorPayloadSchema
 });
-var codeCallRuntimeErrorResultSchema = import_zod5.z.object({
-  status: import_zod5.z.literal("runtime_error"),
+var codeCallRuntimeErrorResultSchema = import_lazy_zod5.z.object({
+  status: import_lazy_zod5.z.literal("runtime_error"),
   error: runtimeErrorPayloadSchema
 });
-var codeCallToolErrorResultSchema = import_zod5.z.object({
-  status: import_zod5.z.literal("tool_error"),
+var codeCallToolErrorResultSchema = import_lazy_zod5.z.object({
+  status: import_lazy_zod5.z.literal("tool_error"),
   error: toolErrorPayloadSchema
 });
-var codeCallTimeoutResultSchema = import_zod5.z.object({
-  status: import_zod5.z.literal("timeout"),
+var codeCallTimeoutResultSchema = import_lazy_zod5.z.object({
+  status: import_lazy_zod5.z.literal("timeout"),
   error: timeoutErrorPayloadSchema
 });
-var executeToolOutputSchema = import_zod5.z.discriminatedUnion("status", [
+var executeToolOutputSchema = import_lazy_zod5.z.discriminatedUnion("status", [
   codeCallOkResultSchema,
   codeCallSyntaxErrorResultSchema,
   codeCallIllegalAccessResultSchema,
@@ -2500,7 +2499,7 @@ ExecuteTool = __decorateClass([
 var import_sdk6 = require("@frontmcp/sdk");
 
 // plugins/plugin-codecall/src/tools/invoke.schema.ts
-var import_zod6 = require("zod");
+var import_lazy_zod6 = require("@frontmcp/lazy-zod");
 var import_protocol2 = require("@frontmcp/protocol");
 var invokeToolDescription = `Call ONE tool directly. Returns standard MCP CallToolResult.
 
@@ -2513,10 +2512,10 @@ ERRORS: tool_not_found (\u2192 re-search) | validation_error | execution_error |
 
 FLOW: search \u2192 describe \u2192 invoke`;
 var invokeToolInputSchema = {
-  tool: import_zod6.z.string().describe(
+  tool: import_lazy_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(
+  input: import_lazy_zod6.z.record(import_lazy_zod6.z.string(), import_lazy_zod6.z.unknown()).describe(
     "The input parameters for the tool. Structure must match the tool's input schema (check codecall:describe for schema details)."
   )
 };