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

package/dist/{chunk-WBJMSOYD.cjs → chunk-66462UTX.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);
@@ -3254,22 +3306,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 +3368,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 +3409,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 +3489,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 +3546,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 +3573,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 +3606,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 +3628,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 +3674,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 +3699,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 +3813,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-66462UTX.cjs.map
+//# sourceMappingURL=chunk-66462UTX.cjs.map