@mastra/core 1.1.0-alpha.0 → 1.1.0-alpha.2

package/dist/{chunk-WBJMSOYD.cjs → chunk-RYVRCT7Z.cjs}

@@ -1,7 +1,6 @@
 'use strict';
 
 var chunkIIZF4W7B_cjs = require('./chunk-IIZF4W7B.cjs');
-var z = require('zod');
 var fs2 = require('fs/promises');
 var nodePath = require('path');
 var fs = require('fs');
@@ -9,6 +8,7 @@ var matter = require('gray-matter');
 var childProcess = require('child_process');
 var crypto = require('crypto');
 var os = require('os');
+var zod = require('zod');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -30,7 +30,6 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var z__default = /*#__PURE__*/_interopDefault(z);
 var fs2__namespace = /*#__PURE__*/_interopNamespace(fs2);
 var nodePath__namespace = /*#__PURE__*/_interopNamespace(nodePath);
 var matter__default = /*#__PURE__*/_interopDefault(matter);
@@ -858,6 +857,8 @@ var SearchEngine = class {
     };
   }
 };
+
+// src/workspace/skills/schemas.ts
 var SKILL_LIMITS = {
   /** Recommended max tokens for instructions */
   MAX_INSTRUCTION_TOKENS: 5e3,
@@ -866,34 +867,77 @@ var SKILL_LIMITS = {
   /** Max characters for name field */
   MAX_NAME_LENGTH: 64,
   /** Max characters for description field */
-  MAX_DESCRIPTION_LENGTH: 1024,
-  /** Max characters for compatibility field */
-  MAX_COMPATIBILITY_LENGTH: 500
-};
-var SkillNameSchema = z__default.default.string().min(1, "Skill name cannot be empty").max(SKILL_LIMITS.MAX_NAME_LENGTH, `Skill name must be ${SKILL_LIMITS.MAX_NAME_LENGTH} characters or less`).regex(/^[a-z0-9-]+$/, "Skill name must contain only lowercase letters, numbers, and hyphens").refine((name) => !name.startsWith("-") && !name.endsWith("-"), {
-  message: "Skill name must not start or end with a hyphen"
-}).refine((name) => !name.includes("--"), {
-  message: "Skill name must not contain consecutive hyphens"
-}).describe("Skill name (1-64 chars, lowercase letters/numbers/hyphens only, must match directory name)");
-var SkillDescriptionSchema = z__default.default.string().min(1, "Skill description cannot be empty").max(
-  SKILL_LIMITS.MAX_DESCRIPTION_LENGTH,
-  `Skill description must be ${SKILL_LIMITS.MAX_DESCRIPTION_LENGTH} characters or less`
-).refine((desc) => desc.trim().length > 0, {
-  message: "Skill description cannot be only whitespace"
-}).describe("Description of what the skill does and when to use it (1-1024 characters)");
-var SkillCompatibilitySchema = z__default.default.string().max(
-  SKILL_LIMITS.MAX_COMPATIBILITY_LENGTH,
-  `Compatibility field must be ${SKILL_LIMITS.MAX_COMPATIBILITY_LENGTH} characters or less`
-).optional().describe("Environment requirements or compatibility notes (max 500 chars)");
-var SkillLicenseSchema = z__default.default.string().optional().describe('License for the skill (e.g., "Apache-2.0", "MIT")');
-var SkillMetadataFieldSchema = z__default.default.record(z__default.default.string()).optional().describe("Arbitrary key-value metadata (e.g., author, version)");
-var SkillMetadataSchema = z__default.default.object({
-  name: SkillNameSchema,
-  description: SkillDescriptionSchema,
-  license: SkillLicenseSchema,
-  compatibility: SkillCompatibilitySchema,
-  metadata: SkillMetadataFieldSchema
-});
+  MAX_DESCRIPTION_LENGTH: 1024};
+function validateSkillName(name) {
+  const errors = [];
+  const fieldPath = "name";
+  if (typeof name !== "string") {
+    errors.push(`${fieldPath}: Expected string, received ${typeof name}`);
+    return errors;
+  }
+  if (name.length === 0) {
+    errors.push(`${fieldPath}: Skill name cannot be empty`);
+    return errors;
+  }
+  if (name.length > SKILL_LIMITS.MAX_NAME_LENGTH) {
+    errors.push(`${fieldPath}: Skill name must be ${SKILL_LIMITS.MAX_NAME_LENGTH} characters or less`);
+  }
+  if (!/^[a-z0-9-]+$/.test(name)) {
+    errors.push(`${fieldPath}: Skill name must contain only lowercase letters, numbers, and hyphens`);
+  }
+  if (name.startsWith("-") || name.endsWith("-")) {
+    errors.push(`${fieldPath}: Skill name must not start or end with a hyphen`);
+  }
+  if (name.includes("--")) {
+    errors.push(`${fieldPath}: Skill name must not contain consecutive hyphens`);
+  }
+  return errors;
+}
+function validateSkillDescription(description) {
+  const errors = [];
+  const fieldPath = "description";
+  if (typeof description !== "string") {
+    errors.push(`${fieldPath}: Expected string, received ${typeof description}`);
+    return errors;
+  }
+  if (description.length === 0) {
+    errors.push(`${fieldPath}: Skill description cannot be empty`);
+    return errors;
+  }
+  if (description.length > SKILL_LIMITS.MAX_DESCRIPTION_LENGTH) {
+    errors.push(`${fieldPath}: Skill description must be ${SKILL_LIMITS.MAX_DESCRIPTION_LENGTH} characters or less`);
+  }
+  if (description.trim().length === 0) {
+    errors.push(`${fieldPath}: Skill description cannot be only whitespace`);
+  }
+  return errors;
+}
+function validateSkillLicense(license) {
+  const errors = [];
+  const fieldPath = "license";
+  if (license === void 0 || license === null) {
+    return errors;
+  }
+  if (typeof license !== "string") {
+    errors.push(`${fieldPath}: Expected string, received ${typeof license}`);
+  }
+  return errors;
+}
+function validateSkillCompatibility(_compatibility) {
+  return [];
+}
+function validateSkillMetadataField(metadata) {
+  const errors = [];
+  const fieldPath = "metadata";
+  if (metadata === void 0 || metadata === null) {
+    return errors;
+  }
+  if (typeof metadata !== "object" || Array.isArray(metadata)) {
+    errors.push(`${fieldPath}: Expected object, received ${Array.isArray(metadata) ? "array" : typeof metadata}`);
+    return errors;
+  }
+  return errors;
+}
 function estimateTokens(text) {
   const words = text.split(/\s+/).filter(Boolean).length;
   return Math.ceil(words * 1.3);
@@ -904,12 +948,20 @@ function countLines(text) {
 function validateSkillMetadata(metadata, dirName, instructions) {
   const errors = [];
   const warnings = [];
-  const result = SkillMetadataSchema.safeParse(metadata);
-  if (!result.success) {
-    errors.push(...result.error.errors.map((err) => `${err.path.join(".")}: ${err.message}`));
+  if (typeof metadata !== "object" || metadata === null || Array.isArray(metadata)) {
+    errors.push(
+      `Expected object, received ${metadata === null ? "null" : Array.isArray(metadata) ? "array" : typeof metadata}`
+    );
+    return { valid: false, errors, warnings };
   }
-  if (dirName && result.success && result.data.name !== dirName) {
-    errors.push(`Skill name "${result.data.name}" must match directory name "${dirName}"`);
+  const data = metadata;
+  errors.push(...validateSkillName(data.name));
+  errors.push(...validateSkillDescription(data.description));
+  errors.push(...validateSkillLicense(data.license));
+  errors.push(...validateSkillCompatibility());
+  errors.push(...validateSkillMetadataField(data.metadata));
+  if (dirName && typeof data.name === "string" && data.name !== dirName) {
+    errors.push(`Skill name "${data.name}" must match directory name "${dirName}"`);
   }
   if (instructions) {
     const lineCount = countLines(instructions);
@@ -931,11 +983,6 @@ function validateSkillMetadata(metadata, dirName, instructions) {
     warnings
   };
 }
-
-// src/workspace/skills/skill-source.ts
-function isWritableSource(source) {
-  return "writeFile" in source && typeof source.writeFile === "function" && "mkdir" in source && typeof source.mkdir === "function" && "rmdir" in source && typeof source.rmdir === "function";
-}
 function isEnoentError(error) {
   return error !== null && typeof error === "object" && "code" in error && error.code === "ENOENT";
 }
@@ -1557,7 +1604,6 @@ var WorkspaceSkillsImpl = class {
   #skillsResolver;
   #searchEngine;
   #validateOnLoad;
-  #isWritable;
   /** Map of skill name -> full skill data */
   #skills = /* @__PURE__ */ new Map();
   /** Whether skills have been discovered */
@@ -1573,21 +1619,6 @@ var WorkspaceSkillsImpl = class {
     this.#skillsResolver = config.skills;
     this.#searchEngine = config.searchEngine;
     this.#validateOnLoad = config.validateOnLoad ?? true;
-    this.#isWritable = isWritableSource(this.#source);
-  }
-  /**
-   * Whether this skills instance supports write operations.
-   * Returns true if backed by a WorkspaceFilesystem, false for read-only sources.
-   */
-  get isWritable() {
-    return this.#isWritable;
-  }
-  /**
-   * Get the source as a writable source.
-   * Only call after checking #isWritable is true.
-   */
-  #getWritableSource() {
-    return this.#source;
   }
   // ===========================================================================
   // Discovery
@@ -1692,142 +1723,6 @@ var WorkspaceSkillsImpl = class {
     return results;
   }
   // ===========================================================================
-  // CRUD Operations
-  // ===========================================================================
-  async create(input) {
-    await this.#ensureInitialized();
-    if (!this.#isWritable) {
-      throw new Error("Skills are read-only. Write operations require a WorkspaceFilesystem.");
-    }
-    const { metadata, instructions, references, scripts, assets } = input;
-    if (this.#skills.has(metadata.name)) {
-      throw new Error(`Skill "${metadata.name}" already exists`);
-    }
-    if (this.#validateOnLoad) {
-      const validation = this.#validateSkillMetadata(metadata, metadata.name, instructions);
-      if (!validation.valid) {
-        throw new Error(`Invalid skill metadata:
-${validation.errors.join("\n")}`);
-      }
-    }
-    const skillsPath = this.#resolvedPaths[0];
-    if (!skillsPath) {
-      throw new Error("No skills path configured for creating skills");
-    }
-    const skillDir = this.#joinPath(skillsPath, metadata.name);
-    if (await this.#source.exists(skillDir)) {
-      throw new Error(`Directory "${skillDir}" already exists`);
-    }
-    const fs5 = this.#getWritableSource();
-    await fs5.mkdir(skillDir);
-    const skillMdContent = this.#buildSkillMd(metadata, instructions);
-    await fs5.writeFile(this.#joinPath(skillDir, "SKILL.md"), skillMdContent);
-    const refPaths = [];
-    if (references && references.length > 0) {
-      const refsDir = this.#joinPath(skillDir, "references");
-      await fs5.mkdir(refsDir);
-      for (const ref of references) {
-        const safeRefPath = this.#assertRelativePath(ref.path, "reference");
-        const refPath = this.#joinPath(refsDir, safeRefPath);
-        await this.#ensureParentDir(refPath);
-        await fs5.writeFile(refPath, ref.content);
-        refPaths.push(safeRefPath);
-      }
-    }
-    const scriptPaths = [];
-    if (scripts && scripts.length > 0) {
-      const scriptsDir = this.#joinPath(skillDir, "scripts");
-      await fs5.mkdir(scriptsDir);
-      for (const script of scripts) {
-        const safeScriptPath = this.#assertRelativePath(script.path, "script");
-        const scriptPath = this.#joinPath(scriptsDir, safeScriptPath);
-        await this.#ensureParentDir(scriptPath);
-        await fs5.writeFile(scriptPath, script.content);
-        scriptPaths.push(safeScriptPath);
-      }
-    }
-    const assetPaths = [];
-    if (assets && assets.length > 0) {
-      const assetsDir = this.#joinPath(skillDir, "assets");
-      await fs5.mkdir(assetsDir);
-      for (const asset of assets) {
-        const safeAssetPath = this.#assertRelativePath(asset.path, "asset");
-        const assetPath = this.#joinPath(assetsDir, safeAssetPath);
-        await this.#ensureParentDir(assetPath);
-        await fs5.writeFile(assetPath, asset.content);
-        assetPaths.push(safeAssetPath);
-      }
-    }
-    const source = this.#determineSource(skillsPath);
-    const indexableContent = await this.#buildIndexableContent(instructions, skillDir, refPaths);
-    const skill = {
-      ...metadata,
-      path: skillDir,
-      instructions,
-      source,
-      references: refPaths,
-      scripts: scriptPaths,
-      assets: assetPaths,
-      indexableContent
-    };
-    this.#skills.set(metadata.name, skill);
-    await this.#indexSkill(skill);
-    const { indexableContent: _, ...skillData } = skill;
-    return skillData;
-  }
-  async update(name, input) {
-    await this.#ensureInitialized();
-    if (!this.#isWritable) {
-      throw new Error("Skills are read-only. Write operations require a WorkspaceFilesystem.");
-    }
-    const skill = this.#skills.get(name);
-    if (!skill) {
-      throw new Error(`Skill "${name}" not found`);
-    }
-    const { metadata: updatedMetadata, instructions: updatedInstructions } = input;
-    const newMetadata = {
-      name: skill.name,
-      // Name cannot be changed
-      description: updatedMetadata?.description ?? skill.description,
-      license: updatedMetadata?.license ?? skill.license,
-      compatibility: updatedMetadata?.compatibility ?? skill.compatibility,
-      metadata: updatedMetadata?.metadata ?? skill.metadata
-    };
-    const newInstructions = updatedInstructions ?? skill.instructions;
-    if (this.#validateOnLoad) {
-      const validation = this.#validateSkillMetadata(newMetadata, name, newInstructions);
-      if (!validation.valid) {
-        throw new Error(`Invalid skill metadata:
-${validation.errors.join("\n")}`);
-      }
-    }
-    const skillMdContent = this.#buildSkillMd(newMetadata, newInstructions);
-    await this.#getWritableSource().writeFile(this.#joinPath(skill.path, "SKILL.md"), skillMdContent);
-    const indexableContent = await this.#buildIndexableContent(newInstructions, skill.path, skill.references);
-    const updatedSkill = {
-      ...skill,
-      ...newMetadata,
-      instructions: newInstructions,
-      indexableContent
-    };
-    this.#skills.set(name, updatedSkill);
-    await this.#indexSkill(updatedSkill);
-    const { indexableContent: _, ...skillData } = updatedSkill;
-    return skillData;
-  }
-  async delete(name) {
-    await this.#ensureInitialized();
-    if (!this.#isWritable) {
-      throw new Error("Skills are read-only. Write operations require a WorkspaceFilesystem.");
-    }
-    const skill = this.#skills.get(name);
-    if (!skill) {
-      throw new Error(`Skill "${name}" not found`);
-    }
-    await this.#getWritableSource().rmdir(skill.path, { recursive: true });
-    this.#skills.delete(name);
-  }
-  // ===========================================================================
   // Single-item Accessors
   // ===========================================================================
   async getReference(skillName, referencePath) {
@@ -2182,25 +2077,6 @@ ${validation.errors.join("\n")}`);
     }
     return { type: "local", projectPath: skillsPath };
   }
-  /**
-   * Build SKILL.md content from metadata and instructions
-   */
-  #buildSkillMd(metadata, instructions) {
-    const frontmatter = {
-      name: metadata.name,
-      description: metadata.description
-    };
-    if (metadata.license) {
-      frontmatter.license = metadata.license;
-    }
-    if (metadata.compatibility) {
-      frontmatter.compatibility = metadata.compatibility;
-    }
-    if (metadata.metadata) {
-      frontmatter.metadata = metadata.metadata;
-    }
-    return matter__default.default.stringify(instructions, frontmatter);
-  }
   /**
    * Join path segments (workspace paths use forward slashes)
    */
@@ -2229,30 +2105,6 @@ ${validation.errors.join("\n")}`);
     const lastSlash = path4.lastIndexOf("/");
     return lastSlash > 0 ? path4.substring(0, lastSlash) : "/";
   }
-  /**
-   * Ensure parent directory exists for a file path.
-   * Recursively creates parent directories if they don't exist.
-   * Only called from write operations that already checked #isWritable.
-   */
-  async #ensureParentDir(filePath) {
-    const parentPath = this.#getParentPath(filePath);
-    if (parentPath && parentPath !== "/") {
-      await this.#mkdirRecursive(parentPath);
-    }
-  }
-  /**
-   * Recursively create directories if they don't exist.
-   */
-  async #mkdirRecursive(dirPath) {
-    if (await this.#source.exists(dirPath)) {
-      return;
-    }
-    const parentPath = this.#getParentPath(dirPath);
-    if (parentPath && parentPath !== "/") {
-      await this.#mkdirRecursive(parentPath);
-    }
-    await this.#getWritableSource().mkdir(dirPath);
-  }
 };
 
 // src/workspace/workspace.ts
@@ -2309,12 +2161,6 @@ var Workspace = class {
   get filesystem() {
     return this._fs;
   }
-  /**
-   * Alias for filesystem.
-   */
-  get fs() {
-    return this._fs;
-  }
   /**
    * The sandbox provider (if configured).
    */
@@ -2334,19 +2180,11 @@ var Workspace = class {
    *
    * Returns undefined if no skillPaths are configured.
    *
-   * When filesystem is available, skills support full CRUD operations.
-   * Without filesystem, skills are loaded read-only via LocalSkillSource.
-   *
    * @example
    * ```typescript
    * const skills = await workspace.skills?.list();
    * const skill = await workspace.skills?.get('brand-guidelines');
    * const results = await workspace.skills?.search('brand colors');
-   *
-   * // CRUD operations (only available with filesystem)
-   * if (workspace.skills?.isWritable) {
-   *   await workspace.skills.create({ ... });
-   * }
    * ```
    */
   get skills() {
@@ -3254,22 +3092,22 @@ function createWorkspaceTools(workspace) {
         id: WORKSPACE_TOOLS.FILESYSTEM.READ_FILE,
         description: "Read the contents of a file from the workspace filesystem. Supports reading specific line ranges using offset/limit parameters.",
         requireApproval: readFileConfig.requireApproval,
-        inputSchema: z.z.object({
-          path: z.z.string().describe('The path to the file to read (e.g., "/data/config.json")'),
-          encoding: z.z.enum(["utf-8", "utf8", "base64", "hex", "binary"]).optional().describe("The encoding to use when reading the file. Defaults to utf-8 for text files."),
-          offset: z.z.number().optional().describe("Line number to start reading from (1-indexed). If omitted, starts from line 1."),
-          limit: z.z.number().optional().describe("Maximum number of lines to read. If omitted, reads to the end of the file."),
-          showLineNumbers: z.z.boolean().optional().default(true).describe("Whether to prefix each line with its line number (default: true)")
+        inputSchema: zod.z.object({
+          path: zod.z.string().describe('The path to the file to read (e.g., "/data/config.json")'),
+          encoding: zod.z.enum(["utf-8", "utf8", "base64", "hex", "binary"]).optional().describe("The encoding to use when reading the file. Defaults to utf-8 for text files."),
+          offset: zod.z.number().optional().describe("Line number to start reading from (1-indexed). If omitted, starts from line 1."),
+          limit: zod.z.number().optional().describe("Maximum number of lines to read. If omitted, reads to the end of the file."),
+          showLineNumbers: zod.z.boolean().optional().default(true).describe("Whether to prefix each line with its line number (default: true)")
         }),
-        outputSchema: z.z.object({
-          content: z.z.string().describe("The file contents (with optional line number prefixes)"),
-          size: z.z.number().describe("The file size in bytes"),
-          path: z.z.string().describe("The full path to the file"),
-          lines: z.z.object({
-            start: z.z.number().describe("First line number returned"),
-            end: z.z.number().describe("Last line number returned")
+        outputSchema: zod.z.object({
+          content: zod.z.string().describe("The file contents (with optional line number prefixes)"),
+          size: zod.z.number().describe("The file size in bytes"),
+          path: zod.z.string().describe("The full path to the file"),
+          lines: zod.z.object({
+            start: zod.z.number().describe("First line number returned"),
+            end: zod.z.number().describe("Last line number returned")
           }).optional().describe("Line range information (when offset/limit used)"),
-          totalLines: z.z.number().optional().describe("Total number of lines in the file")
+          totalLines: zod.z.number().optional().describe("Total number of lines in the file")
         }),
         execute: async ({ path: path4, encoding, offset, limit, showLineNumbers }) => {
           const effectiveEncoding = encoding ?? "utf-8";
@@ -3316,15 +3154,15 @@ function createWorkspaceTools(workspace) {
         id: WORKSPACE_TOOLS.FILESYSTEM.WRITE_FILE,
         description: "Write content to a file in the workspace filesystem. Creates parent directories if needed.",
         requireApproval: writeFileConfig.requireApproval,
-        inputSchema: z.z.object({
-          path: z.z.string().describe('The path where to write the file (e.g., "/data/output.txt")'),
-          content: z.z.string().describe("The content to write to the file"),
-          overwrite: z.z.boolean().optional().default(true).describe("Whether to overwrite the file if it already exists")
+        inputSchema: zod.z.object({
+          path: zod.z.string().describe('The path where to write the file (e.g., "/data/output.txt")'),
+          content: zod.z.string().describe("The content to write to the file"),
+          overwrite: zod.z.boolean().optional().default(true).describe("Whether to overwrite the file if it already exists")
         }),
-        outputSchema: z.z.object({
-          success: z.z.boolean(),
-          path: z.z.string().describe("The path where the file was written"),
-          size: z.z.number().describe("The size of the written content in bytes")
+        outputSchema: zod.z.object({
+          success: zod.z.boolean(),
+          path: zod.z.string().describe("The path where the file was written"),
+          size: zod.z.number().describe("The size of the written content in bytes")
         }),
         execute: async ({ path: path4, content, overwrite }) => {
           if (readTracker && writeFileConfig.requireReadBeforeWrite) {
@@ -3357,17 +3195,17 @@ function createWorkspaceTools(workspace) {
         id: WORKSPACE_TOOLS.FILESYSTEM.EDIT_FILE,
         description: "Edit a file by replacing specific text. The old_string must match exactly and be unique in the file (unless using replace_all). You should read the file first to ensure you have the exact text to replace.",
         requireApproval: editFileConfig.requireApproval,
-        inputSchema: z.z.object({
-          path: z.z.string().describe("The path to the file to edit"),
-          old_string: z.z.string().describe("The exact text to find and replace. Must be unique in the file."),
-          new_string: z.z.string().describe("The text to replace old_string with"),
-          replace_all: z.z.boolean().optional().default(false).describe("If true, replace all occurrences. If false (default), old_string must be unique.")
+        inputSchema: zod.z.object({
+          path: zod.z.string().describe("The path to the file to edit"),
+          old_string: zod.z.string().describe("The exact text to find and replace. Must be unique in the file."),
+          new_string: zod.z.string().describe("The text to replace old_string with"),
+          replace_all: zod.z.boolean().optional().default(false).describe("If true, replace all occurrences. If false (default), old_string must be unique.")
         }),
-        outputSchema: z.z.object({
-          success: z.z.boolean(),
-          path: z.z.string().describe("The path to the edited file"),
-          replacements: z.z.number().describe("Number of replacements made"),
-          error: z.z.string().optional().describe("Error message if the edit failed")
+        outputSchema: zod.z.object({
+          success: zod.z.boolean(),
+          path: zod.z.string().describe("The path to the edited file"),
+          replacements: zod.z.number().describe("Number of replacements made"),
+          error: zod.z.string().optional().describe("Error message if the edit failed")
         }),
         execute: async ({ path: path4, old_string, new_string, replace_all }) => {
           try {
@@ -3437,26 +3275,26 @@ Examples:
 - Directories only: { path: "/", dirsOnly: true }
 - Exclude node_modules: { path: "/", exclude: "node_modules" }`,
         requireApproval: listFilesConfig.requireApproval,
-        inputSchema: z.z.object({
-          path: z.z.string().default("/").describe("Directory path to list"),
-          maxDepth: z.z.number().optional().default(3).describe("Maximum depth to descend (default: 3). Similar to tree -L flag."),
-          showHidden: z.z.boolean().optional().default(false).describe('Show hidden files starting with "." (default: false). Similar to tree -a flag.'),
-          dirsOnly: z.z.boolean().optional().default(false).describe("List directories only, no files (default: false). Similar to tree -d flag."),
-          exclude: z.z.string().optional().describe('Pattern to exclude (e.g., "node_modules"). Similar to tree -I flag.'),
-          extension: z.z.string().optional().describe('Filter by file extension (e.g., ".ts"). Similar to tree -P flag.')
+        inputSchema: zod.z.object({
+          path: zod.z.string().default("/").describe("Directory path to list"),
+          maxDepth: zod.z.number().optional().default(3).describe("Maximum depth to descend (default: 3). Similar to tree -L flag."),
+          showHidden: zod.z.boolean().optional().default(false).describe('Show hidden files starting with "." (default: false). Similar to tree -a flag.'),
+          dirsOnly: zod.z.boolean().optional().default(false).describe("List directories only, no files (default: false). Similar to tree -d flag."),
+          exclude: zod.z.string().optional().describe('Pattern to exclude (e.g., "node_modules"). Similar to tree -I flag.'),
+          extension: zod.z.string().optional().describe('Filter by file extension (e.g., ".ts"). Similar to tree -P flag.')
         }),
-        outputSchema: z.z.object({
-          tree: z.z.string().describe("Tree-style directory listing"),
-          summary: z.z.string().describe('Summary of directories and files (e.g., "3 directories, 12 files")'),
-          metadata: z.z.object({
-            workspace: z.z.object({
-              id: z.z.string().optional(),
-              name: z.z.string().optional()
+        outputSchema: zod.z.object({
+          tree: zod.z.string().describe("Tree-style directory listing"),
+          summary: zod.z.string().describe('Summary of directories and files (e.g., "3 directories, 12 files")'),
+          metadata: zod.z.object({
+            workspace: zod.z.object({
+              id: zod.z.string().optional(),
+              name: zod.z.string().optional()
             }).optional(),
-            filesystem: z.z.object({
-              id: z.z.string().optional(),
-              name: z.z.string().optional(),
-              provider: z.z.string().optional()
+            filesystem: zod.z.object({
+              id: zod.z.string().optional(),
+              name: zod.z.string().optional(),
+              provider: zod.z.string().optional()
             }).optional()
           }).optional().describe("Metadata about the workspace and filesystem")
         }),
@@ -3494,15 +3332,15 @@ Examples:
         id: WORKSPACE_TOOLS.FILESYSTEM.DELETE,
         description: "Delete a file or directory from the workspace filesystem",
         requireApproval: deleteConfig.requireApproval,
-        inputSchema: z.z.object({
-          path: z.z.string().describe("The path to the file or directory to delete"),
-          recursive: z.z.boolean().optional().default(false).describe(
+        inputSchema: zod.z.object({
+          path: zod.z.string().describe("The path to the file or directory to delete"),
+          recursive: zod.z.boolean().optional().default(false).describe(
             "If true, delete directories and their contents recursively. Required for non-empty directories."
           )
         }),
-        outputSchema: z.z.object({
-          success: z.z.boolean(),
-          path: z.z.string()
+        outputSchema: zod.z.object({
+          success: zod.z.boolean(),
+          path: zod.z.string()
         }),
         execute: async ({ path: path4, recursive }) => {
           const stat3 = await workspace.filesystem.stat(path4);
@@ -3521,14 +3359,14 @@ Examples:
         id: WORKSPACE_TOOLS.FILESYSTEM.FILE_STAT,
         description: "Get file or directory metadata from the workspace. Returns existence, type, size, and modification time.",
         requireApproval: fileStatConfig.requireApproval,
-        inputSchema: z.z.object({
-          path: z.z.string().describe("The path to check")
+        inputSchema: zod.z.object({
+          path: zod.z.string().describe("The path to check")
         }),
-        outputSchema: z.z.object({
-          exists: z.z.boolean().describe("Whether the path exists"),
-          type: z.z.enum(["file", "directory", "none"]).describe("The type of the path if it exists"),
-          size: z.z.number().optional().describe("Size in bytes (for files)"),
-          modifiedAt: z.z.string().optional().describe("Last modification time (ISO string)")
+        outputSchema: zod.z.object({
+          exists: zod.z.boolean().describe("Whether the path exists"),
+          type: zod.z.enum(["file", "directory", "none"]).describe("The type of the path if it exists"),
+          size: zod.z.number().optional().describe("Size in bytes (for files)"),
+          modifiedAt: zod.z.string().optional().describe("Last modification time (ISO string)")
         }),
         execute: async ({ path: path4 }) => {
           try {
@@ -3554,13 +3392,13 @@ Examples:
         id: WORKSPACE_TOOLS.FILESYSTEM.MKDIR,
         description: "Create a directory in the workspace filesystem",
         requireApproval: mkdirConfig.requireApproval,
-        inputSchema: z.z.object({
-          path: z.z.string().describe("The path of the directory to create"),
-          recursive: z.z.boolean().optional().default(true).describe("Whether to create parent directories if they do not exist")
+        inputSchema: zod.z.object({
+          path: zod.z.string().describe("The path of the directory to create"),
+          recursive: zod.z.boolean().optional().default(true).describe("Whether to create parent directories if they do not exist")
         }),
-        outputSchema: z.z.object({
-          success: z.z.boolean(),
-          path: z.z.string()
+        outputSchema: zod.z.object({
+          success: zod.z.boolean(),
+          path: zod.z.string()
         }),
         execute: async ({ path: path4, recursive }) => {
           await workspace.filesystem.mkdir(path4, { recursive });
@@ -3576,26 +3414,26 @@ Examples:
         id: WORKSPACE_TOOLS.SEARCH.SEARCH,
         description: "Search indexed content in the workspace. Supports keyword (BM25), semantic (vector), and hybrid search modes.",
         requireApproval: searchConfig.requireApproval,
-        inputSchema: z.z.object({
-          query: z.z.string().describe("The search query string"),
-          topK: z.z.number().optional().default(5).describe("Maximum number of results to return"),
-          mode: z.z.enum(["bm25", "vector", "hybrid"]).optional().describe("Search mode: bm25 for keyword search, vector for semantic search, hybrid for both combined"),
-          minScore: z.z.number().optional().describe("Minimum score threshold (0-1 for normalized scores)")
+        inputSchema: zod.z.object({
+          query: zod.z.string().describe("The search query string"),
+          topK: zod.z.number().optional().default(5).describe("Maximum number of results to return"),
+          mode: zod.z.enum(["bm25", "vector", "hybrid"]).optional().describe("Search mode: bm25 for keyword search, vector for semantic search, hybrid for both combined"),
+          minScore: zod.z.number().optional().describe("Minimum score threshold (0-1 for normalized scores)")
         }),
-        outputSchema: z.z.object({
-          results: z.z.array(
-            z.z.object({
-              id: z.z.string().describe("Document/file path"),
-              content: z.z.string().describe("The matching content"),
-              score: z.z.number().describe("Relevance score"),
-              lineRange: z.z.object({
-                start: z.z.number(),
-                end: z.z.number()
+        outputSchema: zod.z.object({
+          results: zod.z.array(
+            zod.z.object({
+              id: zod.z.string().describe("Document/file path"),
+              content: zod.z.string().describe("The matching content"),
+              score: zod.z.number().describe("Relevance score"),
+              lineRange: zod.z.object({
+                start: zod.z.number(),
+                end: zod.z.number()
               }).optional().describe("Line range where query terms were found")
             })
           ),
-          count: z.z.number().describe("Number of results returned"),
-          mode: z.z.string().describe("The search mode that was used")
+          count: zod.z.number().describe("Number of results returned"),
+          mode: zod.z.string().describe("The search mode that was used")
         }),
         execute: async ({ query, topK, mode, minScore }) => {
           const results = await workspace.search(query, {
@@ -3622,14 +3460,14 @@ Examples:
         id: WORKSPACE_TOOLS.SEARCH.INDEX,
         description: "Index content for search. The path becomes the document ID in search results.",
         requireApproval: indexConfig.requireApproval,
-        inputSchema: z.z.object({
-          path: z.z.string().describe("The document ID/path for search results"),
-          content: z.z.string().describe("The text content to index"),
-          metadata: z.z.record(z.z.unknown()).optional().describe("Optional metadata to store with the document")
+        inputSchema: zod.z.object({
+          path: zod.z.string().describe("The document ID/path for search results"),
+          content: zod.z.string().describe("The text content to index"),
+          metadata: zod.z.record(zod.z.unknown()).optional().describe("Optional metadata to store with the document")
         }),
-        outputSchema: z.z.object({
-          success: z.z.boolean(),
-          path: z.z.string().describe("The indexed document ID")
+        outputSchema: zod.z.object({
+          success: zod.z.boolean(),
+          path: zod.z.string().describe("The indexed document ID")
         }),
         execute: async ({ path: path4, content, metadata }) => {
           await workspace.index(path4, content, { metadata });
@@ -3647,20 +3485,20 @@ Examples:
         id: WORKSPACE_TOOLS.SANDBOX.EXECUTE_COMMAND,
         description: `Execute a shell command in the workspace sandbox. The output (stdout/stderr) is displayed to the user automatically in the tool result. ${pathInfo}`,
         requireApproval: executeCommandConfig.requireApproval,
-        inputSchema: z.z.object({
-          command: z.z.string().describe('The command to execute (e.g., "ls", "npm", "python")'),
-          args: z.z.array(z.z.string()).nullish().default([]).describe("Arguments to pass to the command"),
-          timeout: z.z.number().nullish().default(3e4).describe(
+        inputSchema: zod.z.object({
+          command: zod.z.string().describe('The command to execute (e.g., "ls", "npm", "python")'),
+          args: zod.z.array(zod.z.string()).nullish().default([]).describe("Arguments to pass to the command"),
+          timeout: zod.z.number().nullish().default(3e4).describe(
             "Maximum execution time in milliseconds. Default is 30000 (30 seconds). Example: 60000 for 1 minute."
           ),
-          cwd: z.z.string().nullish().describe("Working directory for the command")
+          cwd: zod.z.string().nullish().describe("Working directory for the command")
         }),
-        outputSchema: z.z.object({
-          success: z.z.boolean().describe("Whether the command executed successfully (exit code 0)"),
-          stdout: z.z.string().describe("Standard output from the command"),
-          stderr: z.z.string().describe("Standard error output"),
-          exitCode: z.z.number().describe("Exit code (0 = success)"),
-          executionTimeMs: z.z.number().describe("How long the execution took in milliseconds")
+        outputSchema: zod.z.object({
+          success: zod.z.boolean().describe("Whether the command executed successfully (exit code 0)"),
+          stdout: zod.z.string().describe("Standard output from the command"),
+          stderr: zod.z.string().describe("Standard error output"),
+          exitCode: zod.z.number().describe("Exit code (0 = success)"),
+          executionTimeMs: zod.z.number().describe("How long the execution took in milliseconds")
         }),
         execute: async ({ command, args, timeout, cwd }, context) => {
           const getExecutionMetadata = () => ({
@@ -3761,5 +3599,5 @@ exports.extractLines = extractLines;
 exports.getRecommendedIsolation = getRecommendedIsolation;
 exports.isIsolationAvailable = isIsolationAvailable;
 exports.resolveToolConfig = resolveToolConfig;
-//# sourceMappingURL=chunk-WBJMSOYD.cjs.map
-//# sourceMappingURL=chunk-WBJMSOYD.cjs.map
+//# sourceMappingURL=chunk-RYVRCT7Z.cjs.map
+//# sourceMappingURL=chunk-RYVRCT7Z.cjs.map