@polka-codes/core 0.9.80 → 0.9.82

package/dist/index.js

@@ -127,12 +127,6 @@ function computeRateLimitBackoffSeconds(count, baseSeconds = 2, capSeconds = 60)
 
 // src/config.ts
 import { z } from "zod";
-var providerModelSchema = z.object({
-  provider: z.string().optional(),
-  model: z.string().optional(),
-  parameters: z.record(z.string(), z.any()).optional(),
-  budget: z.number().positive().optional()
-});
 var ruleSchema = z.union([
   z.string(),
   z.object({ path: z.string() }).strict(),
@@ -145,6 +139,69 @@ var ruleSchema = z.union([
     branch: z.string().optional()
   }).strict()
 ]);
+var providerConfigSchema = z.object({
+  apiKey: z.string().optional(),
+  defaultModel: z.string().optional(),
+  defaultParameters: z.record(z.string(), z.any()).optional(),
+  location: z.string().optional(),
+  project: z.string().optional(),
+  keyFile: z.string().optional(),
+  baseUrl: z.string().optional()
+});
+var providerModelSchema = z.object({
+  provider: z.string().optional(),
+  model: z.string().optional(),
+  parameters: z.record(z.string(), z.any()).optional(),
+  budget: z.number().positive().optional(),
+  rules: z.array(ruleSchema).optional().or(z.string()).optional()
+});
+var scriptSchema = z.union([
+  // Type 1: Simple shell command (backward compatible)
+  z.string(),
+  // Type 2: Object with command and description (backward compatible)
+  z.object({
+    command: z.string(),
+    description: z.string()
+  }).strict(),
+  // Type 3: Reference to dynamic workflow YAML
+  z.object({
+    workflow: z.string(),
+    // Path to .yml workflow file
+    description: z.string().optional(),
+    input: z.record(z.string(), z.any()).optional()
+    // Default workflow input
+  }).strict(),
+  // Type 4: TypeScript script file (NEW)
+  z.object({
+    script: z.string(),
+    // Path to .ts file
+    description: z.string().optional(),
+    permissions: z.object({
+      fs: z.enum(["read", "write", "none"]).optional(),
+      network: z.boolean().optional(),
+      subprocess: z.boolean().optional()
+    }).optional(),
+    timeout: z.number().int().positive().max(36e5).optional(),
+    // Max 1 hour in milliseconds
+    memory: z.number().int().positive().min(64).max(8192).optional()
+    // 64MB-8GB in MB
+  }).strict()
+]);
+var mcpServerConfigSchema = z.object({
+  command: z.string(),
+  args: z.array(z.string()).optional(),
+  env: z.record(z.string(), z.string()).optional(),
+  tools: z.record(
+    z.string(),
+    z.boolean().or(
+      z.object({
+        provider: z.string().optional(),
+        model: z.string().optional(),
+        parameters: z.record(z.string(), z.unknown()).optional()
+      }).strict()
+    )
+  ).optional()
+}).strict();
 var configSchema = z.object({
   prices: z.record(
     z.string(),
@@ -160,17 +217,7 @@ var configSchema = z.object({
       })
     )
   ).optional(),
-  providers: z.record(
-    z.string(),
-    z.object({
-      apiKey: z.string().optional(),
-      defaultModel: z.string().optional(),
-      defaultParameters: z.record(z.string(), z.any()).optional(),
-      location: z.string().optional(),
-      project: z.string().optional(),
-      keyFile: z.string().optional()
-    })
-  ).optional(),
+  providers: z.record(z.string(), providerConfigSchema).optional(),
   defaultProvider: z.string().optional(),
   defaultModel: z.string().optional(),
   defaultParameters: z.record(z.string(), z.any()).optional(),
@@ -179,42 +226,690 @@ var configSchema = z.object({
   retryCount: z.number().int().min(0).optional(),
   requestTimeoutSeconds: z.number().int().positive().optional(),
   summaryThreshold: z.number().int().positive().optional(),
-  scripts: z.record(
-    z.string(),
-    z.string().or(
-      z.object({
-        command: z.string(),
-        description: z.string()
-      })
-    )
-  ).optional(),
+  scripts: z.record(z.string(), scriptSchema).optional(),
   commands: z.record(z.string(), providerModelSchema).optional(),
   tools: z.object({
     search: providerModelSchema.or(z.boolean()).optional()
   }).optional(),
+  mcpServers: z.record(z.string(), mcpServerConfigSchema).optional(),
   rules: z.array(ruleSchema).optional().or(z.string()).optional(),
   excludeFiles: z.array(z.string()).optional()
 }).strict().nullish();
 
-// src/tool.ts
-var ToolResponseType = /* @__PURE__ */ ((ToolResponseType2) => {
-  ToolResponseType2["Reply"] = "Reply";
-  ToolResponseType2["Exit"] = "Exit";
-  ToolResponseType2["Error"] = "Error";
-  return ToolResponseType2;
-})(ToolResponseType || {});
+// src/fs/node-provider.ts
+import { existsSync } from "fs";
+import { readdir, readFile, stat } from "fs/promises";
+import { join, normalize } from "path";
+var NodeFileSystemProvider = class {
+  constructor(_options = {}) {
+    this._options = _options;
+  }
+  exists(path) {
+    return existsSync(path);
+  }
+  async readdir(path) {
+    const entries = await readdir(path, { withFileTypes: true });
+    return entries.map((entry) => ({
+      name: entry.name,
+      isDirectory: entry.isDirectory(),
+      isFile: entry.isFile()
+    }));
+  }
+  async readFile(path) {
+    return readFile(path, "utf-8");
+  }
+  async readFileAsBuffer(path) {
+    const buffer = await readFile(path);
+    return new Uint8Array(buffer);
+  }
+  async stat(path) {
+    const stats = await stat(path);
+    return {
+      size: stats.size,
+      isDirectory: stats.isDirectory(),
+      isFile: stats.isFile()
+    };
+  }
+  join(...paths) {
+    return join(...paths);
+  }
+  normalize(path) {
+    return normalize(path);
+  }
+};
+
+// src/skills/constants.ts
+var SKILL_LIMITS = {
+  MAX_FILE_SIZE: 1024 * 1024,
+  // 1MB per file
+  MAX_SKILL_SIZE: 10 * 1024 * 1024,
+  // 10MB total
+  MAX_DEPTH: 10,
+  // Maximum directory recursion depth
+  MAX_FILES: 500,
+  // Maximum files to load per skill
+  MIN_DESCRIPTION_LENGTH: 20,
+  // Minimum description length
+  MAX_DESCRIPTION_LENGTH: 1024,
+  // Maximum description length
+  MAX_NAME_LENGTH: 64
+  // Maximum skill name length
+};
+var IGNORED_DIRECTORIES = [
+  ".git",
+  "node_modules",
+  ".next",
+  ".turbo",
+  "dist",
+  "build",
+  "coverage",
+  ".cache",
+  ".vscode",
+  ".idea",
+  "tmp",
+  "temp",
+  ".DS_Store"
+];
+var SUSPICIOUS_PATTERNS = [
+  /<script[^>]*>[\s\S]*?<\/script>/i,
+  // Script tags (with dotAll for multiline)
+  /javascript:/i,
+  // JavaScript URLs
+  /on\w+\s*=/i
+  // Event handlers (onclick, onload, etc.)
+];
+var SKILL_ERROR_MESSAGES = {
+  MISSING_FRONTMATTER: "SKILL.md must begin with YAML frontmatter enclosed in ---",
+  FRONTMATTER_INVALID: "Invalid frontmatter: {message}",
+  SKILL_NOT_FOUND: "Skill not found",
+  CONTEXT_NOT_INITIALIZED: "Skill context not initialized"
+};
+var SOURCE_ICONS = {
+  project: "\u{1F4C1}",
+  personal: "\u{1F3E0}",
+  plugin: "\u{1F50C}"
+};
+
+// src/skills/discovery.ts
+import { homedir } from "os";
+import { parse } from "yaml";
+import { ZodError } from "zod";
 
-// src/tools/askFollowupQuestion.ts
+// src/skills/types.ts
 import { z as z2 } from "zod";
-var questionObject = z2.object({
-  prompt: z2.string().describe("The text of the question.").meta({ usageValue: "question text here" }),
-  options: z2.array(z2.string()).default([]).describe("Ordered list of suggested answers (omit if none).").meta({ usageValue: "suggested answer here" })
+var skillMetadataSchema = z2.object({
+  name: z2.string().regex(/^[a-z0-9-]+$/, "Skill name must be lowercase letters, numbers, and hyphens").max(64, "Skill name must be at most 64 characters"),
+  description: z2.string().max(1024, "Description must be at most 1024 characters"),
+  allowedTools: z2.array(z2.string()).optional()
+});
+var SkillDiscoveryError = class extends Error {
+  constructor(message, path) {
+    super(message);
+    this.path = path;
+    this.name = "SkillDiscoveryError";
+  }
+};
+var SkillValidationError = class extends Error {
+  constructor(message, path) {
+    super(message);
+    this.path = path;
+    this.name = "SkillValidationError";
+  }
+};
+
+// src/skills/discovery.ts
+var BINARY_EXTENSIONS = [
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".webp",
+  ".pdf",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".bin",
+  ".dat",
+  ".db",
+  ".sqlite",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot"
+];
+function isBinaryFile(filename) {
+  const ext = filename.toLowerCase().slice(filename.lastIndexOf("."));
+  return BINARY_EXTENSIONS.includes(ext);
+}
+function isBinaryContent(buffer) {
+  const checkLength = Math.min(buffer.length, 8192);
+  for (let i = 0; i < checkLength; i++) {
+    if (buffer[i] === 0) {
+      return true;
+    }
+  }
+  return false;
+}
+async function tryReadTextFile(filePath, fs) {
+  try {
+    const buffer = await fs.readFileAsBuffer(filePath);
+    if (isBinaryContent(buffer)) {
+      return null;
+    }
+    try {
+      return new TextDecoder("utf-8", { fatal: true }).decode(buffer);
+    } catch (_decodeError) {
+      return null;
+    }
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && (error.code === "EINVAL" || error.code === "EISDIR")) {
+      return null;
+    }
+    throw error;
+  }
+}
+var SkillDiscoveryService = class {
+  fs;
+  personalSkillsDir;
+  projectSkillsDir;
+  pluginSkillsDirs;
+  constructor(options) {
+    this.fs = options.fs ?? new NodeFileSystemProvider();
+    this.personalSkillsDir = options.personalSkillsDir ?? this.fs.join(homedir(), ".claude", "skills");
+    this.projectSkillsDir = this.fs.join(options.cwd, ".claude", "skills");
+    this.pluginSkillsDirs = options.pluginSkillsDirs ?? [];
+  }
+  /**
+   * Discover all available skills from all sources
+   * Removes duplicates (project skills take priority over personal/plugin)
+   */
+  async discoverAll() {
+    const skills = [];
+    const results = await Promise.allSettled([
+      this.discoverInDirectory(this.projectSkillsDir, "project"),
+      this.discoverInDirectory(this.personalSkillsDir, "personal"),
+      this.discoverPlugins()
+    ]);
+    const projectSkills = results[0].status === "fulfilled" ? results[0].value : [];
+    const personalSkills = results[1].status === "fulfilled" ? results[1].value : [];
+    const pluginSkills = results[2].status === "fulfilled" ? results[2].value : [];
+    if (results[0].status === "rejected") {
+      console.warn(`Failed to load project skills: ${results[0].reason}`);
+    }
+    if (results[1].status === "rejected") {
+      console.warn(`Failed to load personal skills: ${results[1].reason}`);
+    }
+    if (results[2].status === "rejected") {
+      console.warn(`Failed to load plugin skills: ${results[2].reason}`);
+    }
+    const seenNames = /* @__PURE__ */ new Set();
+    const allSkills = [...projectSkills, ...personalSkills, ...pluginSkills];
+    for (const skill of allSkills) {
+      if (!seenNames.has(skill.metadata.name)) {
+        seenNames.add(skill.metadata.name);
+        skills.push(skill);
+      }
+    }
+    return skills;
+  }
+  /**
+   * Discover skills in a specific directory
+   */
+  async discoverInDirectory(dir, source) {
+    const exists = typeof this.fs.exists === "boolean" ? this.fs.exists(dir) : await this.fs.exists(dir);
+    if (!exists) {
+      return [];
+    }
+    const skills = [];
+    const entries = await this.fs.readdir(dir);
+    for (const entry of entries) {
+      if (!entry.isDirectory) {
+        continue;
+      }
+      const skillPath = this.fs.join(dir, entry.name);
+      const skillMdPath = this.fs.join(skillPath, "SKILL.md");
+      const skillMdExists = typeof this.fs.exists === "boolean" ? this.fs.exists(skillMdPath) : await this.fs.exists(skillMdPath);
+      if (!skillMdExists) {
+        continue;
+      }
+      try {
+        const content = await this.fs.readFile(skillMdPath);
+        const { metadata } = this.parseSkillMd(content);
+        skills.push({
+          metadata,
+          path: skillPath,
+          source
+        });
+      } catch (error) {
+        let message = "Unknown error";
+        let path = skillPath;
+        if (error instanceof SkillDiscoveryError) {
+          message = error.message;
+          path = error.path;
+        } else if (error instanceof ZodError) {
+          message = error.issues[0]?.message ?? "Invalid skill metadata";
+        } else if (error instanceof Error) {
+          message = error.message;
+        }
+        console.warn(`Warning: Failed to load skill at ${path}: ${message}`);
+      }
+    }
+    return skills;
+  }
+  /**
+   * Discover skills from plugin directories (node_modules)
+   */
+  async discoverPlugins() {
+    const skills = [];
+    for (const pluginDir of this.pluginSkillsDirs) {
+      const exists = typeof this.fs.exists === "boolean" ? this.fs.exists(pluginDir) : await this.fs.exists(pluginDir);
+      if (!exists) {
+        continue;
+      }
+      const pluginSkills = await this.discoverInDirectory(pluginDir, "plugin");
+      skills.push(...pluginSkills);
+    }
+    return skills;
+  }
+  /**
+   * Load a single skill from its directory
+   */
+  async loadSkill(skillPath, source) {
+    const skillMdPath = this.fs.join(skillPath, "SKILL.md");
+    const skillMdExists = typeof this.fs.exists === "boolean" ? this.fs.exists(skillMdPath) : await this.fs.exists(skillMdPath);
+    if (!skillMdExists) {
+      throw new SkillDiscoveryError("SKILL.md not found", skillPath);
+    }
+    const content = await this.fs.readFile(skillMdPath);
+    const { metadata, content: instructions } = this.parseSkillMd(content);
+    const files = /* @__PURE__ */ new Map();
+    let totalSize = 0;
+    const entries = await this.fs.readdir(skillPath);
+    for (const entry of entries) {
+      if (entry.name === "SKILL.md") {
+        continue;
+      }
+      const filePath = this.fs.join(skillPath, entry.name);
+      if (entry.isFile) {
+        if (isBinaryFile(entry.name)) {
+          continue;
+        }
+        const fileStats = await this.fs.stat(filePath);
+        const fileSize = fileStats.size;
+        if (fileSize > SKILL_LIMITS.MAX_FILE_SIZE) {
+          throw new SkillDiscoveryError(`File size exceeds limit (${fileSize} > ${SKILL_LIMITS.MAX_FILE_SIZE}): ${entry.name}`, skillPath);
+        }
+        if (totalSize + fileSize > SKILL_LIMITS.MAX_SKILL_SIZE) {
+          throw new SkillDiscoveryError(
+            `Total skill size exceeds limit (${totalSize + fileSize} > ${SKILL_LIMITS.MAX_SKILL_SIZE}): ${skillPath}`,
+            skillPath
+          );
+        }
+        const fileContent = await tryReadTextFile(filePath, this.fs);
+        if (fileContent === null) {
+          continue;
+        }
+        totalSize += fileSize;
+        files.set(entry.name, fileContent);
+      } else if (entry.isDirectory) {
+        totalSize = await this.loadDirectoryFiles(filePath, entry.name, files, 0, totalSize);
+      }
+    }
+    return {
+      metadata,
+      content: instructions,
+      files,
+      path: skillPath,
+      source
+    };
+  }
+  /**
+   * Parse SKILL.md content and extract frontmatter
+   */
+  parseSkillMd(content) {
+    const frontmatterRegex = /^---\r?\n([\s\S]+?)\r?\n---\r?\n([\s\S]*)$/;
+    const match = content.match(frontmatterRegex);
+    if (!match || match.length < 3) {
+      throw new SkillDiscoveryError(SKILL_ERROR_MESSAGES.MISSING_FRONTMATTER, "");
+    }
+    const frontmatter = match[1] ?? "";
+    const instructions = match[2] ?? "";
+    const metadata = this.parseMetadata(frontmatter);
+    return { metadata, content: instructions };
+  }
+  /**
+   * Parse and validate YAML frontmatter
+   */
+  parseMetadata(frontmatter) {
+    const parsed = parse(frontmatter);
+    return skillMetadataSchema.parse(parsed);
+  }
+  /**
+   * Recursively load files from a directory into the files map
+   * @returns The total size of all files loaded (in bytes)
+   */
+  async loadDirectoryFiles(dirPath, prefix, files, depth = 0, currentTotal = 0) {
+    const { MAX_DEPTH, MAX_FILES } = SKILL_LIMITS;
+    let totalSize = currentTotal;
+    if (depth > MAX_DEPTH) {
+      return totalSize;
+    }
+    if (files.size >= MAX_FILES) {
+      return totalSize;
+    }
+    const currentDirName = prefix.split("/").pop() ?? prefix;
+    if (IGNORED_DIRECTORIES.includes(currentDirName)) {
+      return totalSize;
+    }
+    const entries = await this.fs.readdir(dirPath);
+    for (const entry of entries) {
+      if (files.size >= MAX_FILES) {
+        break;
+      }
+      const filePath = this.fs.join(dirPath, entry.name);
+      const key = `${prefix}/${entry.name}`.replace(/\/+/g, "/");
+      if (entry.isFile) {
+        if (isBinaryFile(entry.name)) {
+          continue;
+        }
+        const fileStats = await this.fs.stat(filePath);
+        const fileSize = fileStats.size;
+        if (fileSize > SKILL_LIMITS.MAX_FILE_SIZE) {
+          throw new SkillDiscoveryError(`File size exceeds limit (${fileSize} > ${SKILL_LIMITS.MAX_FILE_SIZE}): ${key}`, dirPath);
+        }
+        if (totalSize + fileSize > SKILL_LIMITS.MAX_SKILL_SIZE) {
+          throw new SkillDiscoveryError(
+            `Total skill size exceeds limit (${totalSize + fileSize} > ${SKILL_LIMITS.MAX_SKILL_SIZE}): ${dirPath}`,
+            dirPath
+          );
+        }
+        const content = await tryReadTextFile(filePath, this.fs);
+        if (content === null) {
+          continue;
+        }
+        totalSize += fileSize;
+        files.set(key, content);
+      } else if (entry.isDirectory) {
+        if (IGNORED_DIRECTORIES.includes(entry.name)) {
+          continue;
+        }
+        totalSize = await this.loadDirectoryFiles(filePath, key, files, depth + 1, totalSize);
+      }
+    }
+    return totalSize;
+  }
+  /**
+   * Create an initial skill context object
+   */
+  async createContext() {
+    const availableSkills = await this.discoverAll();
+    return {
+      activeSkill: null,
+      availableSkills,
+      skillLoadingHistory: [],
+      loadSkill: async (name) => {
+        const ref = availableSkills.find((s) => s.metadata.name === name);
+        if (!ref) return null;
+        return this.loadSkill(ref.path, ref.source);
+      }
+    };
+  }
+};
+
+// src/skills/validation.ts
+import { join as join2, normalize as normalize2 } from "path";
+function validateSkillSecurity(skill) {
+  const { MAX_FILE_SIZE, MAX_SKILL_SIZE } = SKILL_LIMITS;
+  let totalSize = 0;
+  const contentSize = Buffer.byteLength(skill.content, "utf8");
+  if (contentSize > MAX_FILE_SIZE) {
+    throw new SkillValidationError(`SKILL.md content exceeds size limit (${contentSize} > ${MAX_FILE_SIZE})`, join2(skill.path, "SKILL.md"));
+  }
+  totalSize += contentSize;
+  for (const [filename, content] of skill.files) {
+    const fileSize = Buffer.byteLength(content, "utf8");
+    if (fileSize > MAX_FILE_SIZE) {
+      throw new SkillValidationError(`File ${filename} exceeds size limit (${fileSize} > ${MAX_FILE_SIZE})`, join2(skill.path, filename));
+    }
+    totalSize += fileSize;
+  }
+  if (totalSize > MAX_SKILL_SIZE) {
+    throw new SkillValidationError(`Skill total size exceeds limit (${totalSize} > ${MAX_SKILL_SIZE})`, skill.path);
+  }
+  validateContentSecurity(skill.content, skill.path);
+  for (const [filename, content] of skill.files) {
+    validateContentSecurity(content, join2(skill.path, filename));
+  }
+}
+function validateContentSecurity(content, path) {
+  for (const pattern of SUSPICIOUS_PATTERNS) {
+    if (pattern.test(content)) {
+      throw new SkillValidationError("Suspicious content detected", path);
+    }
+  }
+}
+function validateSkillReferences(skill) {
+  const warnings = [];
+  const externalRefs = skill.content.match(/https?:\/\/[^\s\])]+/g) || [];
+  if (externalRefs.length > 0 && !skill.metadata.description.toLowerCase().includes("external")) {
+    warnings.push(
+      `Skill '${skill.metadata.name}' contains external references. Consider adding 'external' to description for transparency.`
+    );
+  }
+  const codeBlocks = skill.content.match(/```[\s\S]*?```/g) || [];
+  for (const block of codeBlocks) {
+    const pathsInCode = block.match(/\/[a-zA-Z][\w./-]*/g) || [];
+    for (const path of pathsInCode) {
+      if (!path.startsWith("/dev") && !path.startsWith("/proc") && !path.startsWith("/sys") && !path.startsWith("//")) {
+        warnings.push(`Skill '${skill.metadata.name}' contains possible absolute path '${path}'. Use relative paths instead.`);
+      }
+    }
+  }
+  const linkRegex = /\[[^\]]+\]\(([^)]+(?:\s+[^)]+)*)\)/g;
+  let match;
+  match = linkRegex.exec(skill.content);
+  while (match !== null) {
+    const filepath = match[1];
+    match = linkRegex.exec(skill.content);
+    if (filepath.startsWith("http://") || filepath.startsWith("https://") || filepath.startsWith("#")) {
+      continue;
+    }
+    const normalizedPath = normalize2(filepath).replace(/^\.?\//, "").replace(/\\/g, "/");
+    if (!skill.files.has(normalizedPath)) {
+      warnings.push(`Referenced file not found: ${filepath}`);
+    }
+  }
+  return warnings;
+}
+function validateSkillMetadata(skill) {
+  const errors = [];
+  if (skill.metadata.description.length < 20) {
+    errors.push(`Description too short: ${skill.metadata.description.length} < 20`);
+  }
+  return errors;
+}
+function getSkillStats(skill) {
+  let totalSize = Buffer.byteLength(skill.content, "utf8");
+  let largestFile = { name: "SKILL.md", size: totalSize };
+  let fileCount = 1;
+  for (const [name, content] of skill.files) {
+    const size = Buffer.byteLength(content, "utf8");
+    totalSize += size;
+    fileCount++;
+    if (size > largestFile.size) {
+      largestFile = { name, size };
+    }
+  }
+  return {
+    totalSize,
+    fileCount,
+    largestFile
+  };
+}
+
+// src/skills/tools/listSkills.ts
+import { z as z3 } from "zod";
+var ListSkillsInputSchema = z3.object({
+  filter: z3.string().optional().describe("Optional filter string to match against skill names and descriptions")
+});
+var ListSkillsOutputSchema = z3.object({
+  skills: z3.array(
+    z3.object({
+      name: z3.string(),
+      description: z3.string(),
+      source: z3.enum(["personal", "project", "plugin"])
+    })
+  ),
+  total: z3.number()
+});
+async function listSkills(input, context) {
+  const { filter } = input;
+  let skills = context.availableSkills;
+  if (filter) {
+    const filterLower = filter.toLowerCase();
+    skills = skills.filter((s) => s.metadata.name.includes(filterLower) || s.metadata.description.toLowerCase().includes(filterLower));
+  }
+  return {
+    skills: skills.map((s) => ({
+      name: s.metadata.name,
+      description: s.metadata.description,
+      source: s.source
+    })),
+    total: skills.length
+  };
+}
+var listSkillsToolInfo = {
+  name: "listSkills",
+  description: "List all available skills with their descriptions. Use this to discover what specialized capabilities are available.",
+  parameters: ListSkillsInputSchema,
+  returns: ListSkillsOutputSchema
+};
+
+// src/skills/tools/loadSkill.ts
+import { z as z4 } from "zod";
+var LoadSkillInputSchema = z4.object({
+  skillName: z4.string().describe("The name of the skill to load")
+});
+var LoadSkillOutputSchema = z4.object({
+  success: z4.boolean(),
+  skill: z4.object({
+    name: z4.string(),
+    description: z4.string(),
+    content: z4.string(),
+    availableFiles: z4.array(z4.string())
+  }).optional(),
+  error: z4.string().optional(),
+  warnings: z4.array(z4.string()).optional()
+});
+async function loadSkill(input, context) {
+  const { skillName } = input;
+  const skillRef = context.availableSkills.find((s) => s.metadata.name === skillName);
+  if (!skillRef) {
+    return {
+      success: false,
+      error: `Skill '${skillName}' not found`
+    };
+  }
+  try {
+    const skill = await context.loadSkill(skillName);
+    if (!skill) {
+      return {
+        success: false,
+        error: `Failed to load skill '${skillName}'`
+      };
+    }
+    validateSkillSecurity(skill);
+    const warnings = validateSkillReferences(skill);
+    context.activeSkill = skill;
+    context.skillLoadingHistory.push(skillName);
+    return {
+      success: true,
+      skill: {
+        name: skill.metadata.name,
+        description: skill.metadata.description,
+        content: skill.content,
+        availableFiles: Array.from(skill.files.keys())
+      },
+      warnings: warnings.length > 0 ? warnings : void 0
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: `Failed to load skill '${skillName}': ${message}`
+    };
+  }
+}
+var loadSkillToolInfo = {
+  name: "loadSkill",
+  description: "Load a skill by name to access its instructions and resources. Use this when you need specialized knowledge or capabilities for a specific task.",
+  parameters: LoadSkillInputSchema,
+  returns: LoadSkillOutputSchema
+};
+
+// src/skills/tools/readSkillFile.ts
+import { z as z5 } from "zod";
+var ReadSkillFileInputSchema = z5.object({
+  skillName: z5.string().describe("The name of the skill"),
+  filename: z5.string().describe('The name of the file to read (e.g., "reference.md", "scripts/helper.py")')
+});
+var ReadSkillFileOutputSchema = z5.object({
+  success: z5.boolean(),
+  content: z5.string().optional(),
+  error: z5.string().optional()
+});
+async function readSkillFile(input, context) {
+  const { skillName, filename } = input;
+  let skill = context.activeSkill && context.activeSkill.metadata.name === skillName ? context.activeSkill : null;
+  if (!skill) {
+    try {
+      skill = await context.loadSkill(skillName);
+    } catch (_error) {
+    }
+  }
+  if (!skill) {
+    return {
+      success: false,
+      error: `Skill '${skillName}' not found or could not be loaded. Use loadSkill first.`
+    };
+  }
+  if (!skill.files.has(filename)) {
+    const availableFiles = Array.from(skill.files.keys()).sort();
+    return {
+      success: false,
+      error: `File '${filename}' not found in skill '${skillName}'. Available files: ${availableFiles.join(", ") || "none"}`
+    };
+  }
+  const content = skill.files.get(filename);
+  return {
+    success: true,
+    content
+  };
+}
+var readSkillFileToolInfo = {
+  name: "readSkillFile",
+  description: "Read a supporting file from a skill. Use this to access reference documentation, examples, scripts, or templates bundled with a skill. First use loadSkill to see available files, then use this tool to read specific files.",
+  parameters: ReadSkillFileInputSchema,
+  returns: ReadSkillFileOutputSchema
+};
+
+// src/tools/askFollowupQuestion.ts
+import { z as z6 } from "zod";
+var questionObject = z6.object({
+  prompt: z6.string().describe("The text of the question.").meta({ usageValue: "question text here" }),
+  options: z6.array(z6.string()).default([]).describe("Ordered list of suggested answers (omit if none).").meta({ usageValue: "suggested answer here" })
 });
 var toolInfo = {
   name: "askFollowupQuestion",
   description: "Call this when vital details are missing. Pose each follow-up as one direct, unambiguous question. If it speeds the reply, add up to five short, mutually-exclusive answer options. Group any related questions in the same call to avoid a back-and-forth chain.",
-  parameters: z2.object({
-    questions: z2.array(questionObject).describe("One or more follow-up questions you need answered before you can continue.").meta({ usageValue: "questions here" })
+  parameters: z6.object({
+    questions: z6.array(questionObject).describe("One or more follow-up questions you need answered before you can continue.").meta({ usageValue: "questions here" })
   }).meta({
     examples: [
       {
@@ -263,7 +958,7 @@ var toolInfo = {
 var handler = async (provider, args) => {
   if (!provider.askFollowupQuestion) {
     return {
-      type: "Error" /* Error */,
+      success: false,
       message: {
         type: "error-text",
         value: "Not possible to ask followup question."
@@ -273,7 +968,7 @@ var handler = async (provider, args) => {
   const { questions } = toolInfo.parameters.parse(args);
   if (questions.length === 0) {
     return {
-      type: "Error" /* Error */,
+      success: false,
       message: {
         type: "error-text",
         value: "No questions provided"
@@ -289,7 +984,7 @@ ${answer}
 </ask_followup_question_answer>`);
   }
   return {
-    type: "Reply" /* Reply */,
+    success: true,
     message: {
       type: "text",
       value: answers.join("\n")
@@ -302,20 +997,41 @@ var askFollowupQuestion_default = {
 };
 
 // src/tools/executeCommand.ts
-import { z as z3 } from "zod";
+import { z as z7 } from "zod";
+
+// src/tools/utils.ts
+function createProviderError(action) {
+  return {
+    success: false,
+    message: {
+      type: "error-text",
+      value: `Not possible to ${action}.`
+    }
+  };
+}
+function preprocessBoolean(val) {
+  return typeof val === "string" ? val.toLowerCase() === "true" : val;
+}
+function createFileElement(tagName, path, content, attrs) {
+  const allAttrs = { path, ...attrs };
+  const attrStr = Object.entries(allAttrs).map(([k, v]) => ` ${k}="${v}"`).join("");
+  if (content === void 0) {
+    return `<${tagName}${attrStr} />`;
+  }
+  const isEmpty = content.trim().length === 0;
+  if (isEmpty) {
+    return `<${tagName}${attrStr} is_empty="true" />`;
+  }
+  return `<${tagName}${attrStr}>${content}</${tagName}>`;
+}
+
+// src/tools/executeCommand.ts
 var toolInfo2 = {
   name: "executeCommand",
   description: "Run a single CLI command. The command is always executed in the project-root working directory (regardless of earlier commands). Prefer one-off shell commands over wrapper scripts for flexibility. **IMPORTANT**: After an `execute_command` call, you MUST stop and NOT allowed to make further tool calls in the same message.",
-  parameters: z3.object({
-    command: z3.string().describe("The exact command to run  (valid for the current OS). It must be correctly formatted and free of harmful instructions.").meta({ usageValue: "your-command-here" }),
-    requiresApproval: z3.preprocess((val) => {
-      if (typeof val === "string") {
-        const lower = val.toLowerCase();
-        if (lower === "false") return false;
-        if (lower === "true") return true;
-      }
-      return val;
-    }, z3.boolean().optional().default(false)).describe(
+  parameters: z7.object({
+    command: z7.string().describe("The exact command to run  (valid for the current OS). It must be correctly formatted and free of harmful instructions.").meta({ usageValue: "your-command-here" }),
+    requiresApproval: z7.preprocess(preprocessBoolean, z7.boolean().optional().default(false)).describe(
       "Set to `true` for commands that install/uninstall software, modify or delete files, change system settings, perform network operations, or have other side effects. Use `false` for safe, read-only, or purely local development actions (e.g., listing files, make a build, running tests)."
     ).meta({ usageValue: "true | false" })
   }).meta({
@@ -332,13 +1048,7 @@ var toolInfo2 = {
 };
 var handler2 = async (provider, args) => {
   if (!provider.executeCommand) {
-    return {
-      type: "Error" /* Error */,
-      message: {
-        type: "error-text",
-        value: "Not possible to execute command. Abort."
-      }
-    };
+    return createProviderError("execute command. Abort");
   }
   const { command, requiresApproval } = toolInfo2.parameters.parse(args);
   try {
@@ -362,7 +1072,7 @@ ${result.stderr}
     }
     if (result.exitCode === 0) {
       return {
-        type: "Reply" /* Reply */,
+        success: true,
         message: {
           type: "text",
           value: message
@@ -370,7 +1080,7 @@ ${result.stderr}
       };
     }
     return {
-      type: "Error" /* Error */,
+      success: false,
       message: {
         type: "error-text",
         value: message
@@ -378,7 +1088,7 @@ ${result.stderr}
     };
   } catch (error) {
     return {
-      type: "Error" /* Error */,
+      success: false,
       message: {
         type: "error-text",
         value: error instanceof Error ? error.message : String(error)
@@ -392,16 +1102,16 @@ var executeCommand_default = {
 };
 
 // src/tools/fetchUrl.ts
-import { z as z4 } from "zod";
+import { z as z8 } from "zod";
 var toolInfo3 = {
   name: "fetchUrl",
   description: "Fetch the content located at one or more HTTP(S) URLs and return it in Markdown format. This works for standard web pages as well as raw files (e.g. README.md, source code) hosted on platforms like GitHub.",
-  parameters: z4.object({
-    url: z4.preprocess((val) => {
+  parameters: z8.object({
+    url: z8.preprocess((val) => {
       if (!val) return [];
       const values = Array.isArray(val) ? val : [val];
       return values.flatMap((i) => typeof i === "string" ? i.split(",") : []).filter((s) => s.length > 0);
-    }, z4.array(z4.string())).describe("One or more URLs to fetch, separated by commas if multiple.").meta({ usageValue: "url" })
+    }, z8.array(z8.string())).describe("One or more URLs to fetch, separated by commas if multiple.").meta({ usageValue: "url" })
   }).meta({
     examples: [
       {
@@ -428,7 +1138,7 @@ var toolInfo3 = {
 var handler3 = async (provider, args) => {
   if (!provider.fetchUrl) {
     return {
-      type: "Error" /* Error */,
+      success: false,
       message: {
         type: "error-text",
         value: "Not possible to fetch url."
@@ -438,7 +1148,7 @@ var handler3 = async (provider, args) => {
   const { url: urls } = toolInfo3.parameters.parse(args);
   if (urls.length === 0) {
     return {
-      type: "Error" /* Error */,
+      success: false,
       message: {
         type: "error-text",
         value: "No URLs provided. Please provide at least one URL to fetch."
@@ -457,7 +1167,7 @@ var handler3 = async (provider, args) => {
   }
   const resolvedResults = await Promise.all(results);
   return {
-    type: "Reply" /* Reply */,
+    success: true,
     message: {
       type: "text",
       value: resolvedResults.join("\n")
@@ -469,64 +1179,16 @@ var fetchUrl_default = {
   handler: handler3
 };
 
-// src/tools/getTodoItem.ts
-import { z as z5 } from "zod";
-var toolInfo4 = {
-  name: "getTodoItem",
-  description: "Get a to-do item by its ID.",
-  parameters: z5.object({
-    id: z5.string().describe("The ID of the to-do item.")
-  })
-};
-var handler4 = async (provider, args) => {
-  if (!provider.getTodoItem) {
-    return {
-      type: "Error" /* Error */,
-      message: {
-        type: "error-text",
-        value: "Not possible to get a to-do item."
-      }
-    };
-  }
-  const { id } = toolInfo4.parameters.parse(args);
-  const item = await provider.getTodoItem(id);
-  return {
-    type: "Reply" /* Reply */,
-    message: {
-      type: "json",
-      value: item ?? null
-    }
-  };
-};
-var getTodoItem_default = {
-  ...toolInfo4,
-  handler: handler4
-};
-
 // src/tools/listFiles.ts
-import { z as z6 } from "zod";
-var toolInfo5 = {
+import { z as z9 } from "zod";
+var toolInfo4 = {
   name: "listFiles",
   description: "Request to list files and directories within the specified directory. If recursive is true, it will list all files and directories recursively. If recursive is false or not provided, it will only list the top-level contents. Do not use this tool to confirm the existence of files you may have created, as the user will let you know if the files were created successfully or not.",
-  parameters: z6.object({
-    path: z6.string().describe("The path of the directory to list contents for (relative to the current working directory)").meta({ usageValue: "Directory path here" }),
-    maxCount: z6.coerce.number().optional().default(2e3).describe("The maximum number of files to list. Default to 2000").meta({ usageValue: "Maximum number of files to list (optional)" }),
-    recursive: z6.preprocess((val) => {
-      if (typeof val === "string") {
-        const lower = val.toLowerCase();
-        if (lower === "false") return false;
-        if (lower === "true") return true;
-      }
-      return val;
-    }, z6.boolean().optional().default(true)).describe("Whether to list files recursively. Use true for recursive listing, false or omit for top-level only.").meta({ usageValue: "true or false (optional)" }),
-    includeIgnored: z6.preprocess((val) => {
-      if (typeof val === "string") {
-        const lower = val.toLowerCase();
-        if (lower === "false") return false;
-        if (lower === "true") return true;
-      }
-      return val;
-    }, z6.boolean().optional().default(false)).describe("Whether to include ignored files. Use true to include files ignored by .gitignore.").meta({ usageValue: "true or false (optional)" })
+  parameters: z9.object({
+    path: z9.string().describe("The path of the directory to list contents for (relative to the current working directory)").meta({ usageValue: "Directory path here" }),
+    maxCount: z9.coerce.number().optional().default(2e3).describe("The maximum number of files to list. Default to 2000").meta({ usageValue: "Maximum number of files to list (optional)" }),
+    recursive: z9.preprocess(preprocessBoolean, z9.boolean().optional().default(true)).describe("Whether to list files recursively. Use true for recursive listing, false or omit for top-level only.").meta({ usageValue: "true or false (optional)" }),
+    includeIgnored: z9.preprocess(preprocessBoolean, z9.boolean().optional().default(false)).describe("Whether to include ignored files. Use true to include files ignored by .gitignore.").meta({ usageValue: "true or false (optional)" })
   }).meta({
     examples: [
       {
@@ -539,20 +1201,14 @@ var toolInfo5 = {
     ]
   })
 };
-var handler5 = async (provider, args) => {
+var handler4 = async (provider, args) => {
   if (!provider.listFiles) {
-    return {
-      type: "Error" /* Error */,
-      message: {
-        type: "error-text",
-        value: "Not possible to list files."
-      }
-    };
+    return createProviderError("list files");
   }
-  const { path, maxCount, recursive, includeIgnored } = toolInfo5.parameters.parse(args);
+  const { path, maxCount, recursive, includeIgnored } = toolInfo4.parameters.parse(args);
   const [files, limitReached] = await provider.listFiles(path, recursive, maxCount, includeIgnored);
   return {
-    type: "Reply" /* Reply */,
+    success: true,
     message: {
       type: "text",
       value: `<list_files_path>${path}</list_files_path>
@@ -564,110 +1220,8 @@ ${files.join("\n")}
   };
 };
 var listFiles_default = {
-  ...toolInfo5,
-  handler: handler5
-};
-
-// src/tools/listMemoryTopics.ts
-import { z as z7 } from "zod";
-var toolInfo6 = {
-  name: "listMemoryTopics",
-  description: "Lists all topics in memory. Use this to see what information has been stored and which topics are available to read from.",
-  parameters: z7.object({})
-};
-var handler6 = async (provider, _args) => {
-  const topics = await provider.listMemoryTopics();
-  if (!topics.length) {
-    return { type: "Reply" /* Reply */, message: { type: "text", value: "No topics found." } };
-  }
-  return {
-    type: "Reply" /* Reply */,
-    message: {
-      type: "text",
-      value: `Memory topics:
-${topics.join("\n")}`
-    }
-  };
-};
-var listMemoryTopics_default = {
-  ...toolInfo6,
-  handler: handler6
-};
-
-// src/tools/listTodoItems.ts
-import { z as z9 } from "zod";
-
-// src/tools/todo.ts
-import { z as z8 } from "zod";
-var TodoStatus = z8.enum(["open", "completed", "closed"]);
-var TodoItemSchema = z8.object({
-  id: z8.string(),
-  title: z8.string(),
-  description: z8.string(),
-  status: TodoStatus
-});
-var UpdateTodoItemInputSchema = z8.object({
-  operation: z8.enum(["add", "update"]),
-  id: z8.string().nullish(),
-  parentId: z8.string().nullish(),
-  title: z8.string().nullish(),
-  description: z8.string().nullish(),
-  status: TodoStatus.nullish()
-}).superRefine((data, ctx) => {
-  if (data.operation === "add") {
-    if (!data.title) {
-      ctx.addIssue({
-        code: "custom",
-        message: 'Title is required for "add" operation',
-        path: ["title"]
-      });
-    }
-  } else if (data.operation === "update") {
-    if (!data.id) {
-      ctx.addIssue({
-        code: "custom",
-        message: 'ID is required for "update" operation',
-        path: ["id"]
-      });
-    }
-  }
-});
-var UpdateTodoItemOutputSchema = z8.object({
-  id: z8.string()
-});
-
-// src/tools/listTodoItems.ts
-var toolInfo7 = {
-  name: "listTodoItems",
-  description: "List all to-do items, sorted by id. If an id is provided, it lists all sub-items for that id. Can be filtered by status.",
-  parameters: z9.object({
-    id: z9.string().nullish(),
-    status: TodoStatus.nullish()
-  })
-};
-var handler7 = async (provider, args) => {
-  if (!provider.listTodoItems) {
-    return {
-      type: "Error" /* Error */,
-      message: {
-        type: "error-text",
-        value: "Not possible to list to-do items."
-      }
-    };
-  }
-  const { id, status } = toolInfo7.parameters.parse(args);
-  const items = await provider.listTodoItems(id, status);
-  return {
-    type: "Reply" /* Reply */,
-    message: {
-      type: "json",
-      value: items
-    }
-  };
-};
-var listTodoItems_default = {
-  ...toolInfo7,
-  handler: handler7
+  ...toolInfo4,
+  handler: handler4
 };
 
 // src/tools/provider.ts
@@ -733,28 +1287,28 @@ var MockProvider = class {
 
 // src/tools/readBinaryFile.ts
 import { z as z10 } from "zod";
-var toolInfo8 = {
+var toolInfo5 = {
   name: "readBinaryFile",
   description: "Read a binary file from a URL or local path. Use file:// prefix to access local files. This can be used to access non-text files such as PDFs or images.",
   parameters: z10.object({
     url: z10.string().describe("The URL or local path of the file to read.")
   })
 };
-var handler8 = async (provider, args) => {
+var handler5 = async (provider, args) => {
   if (!provider.readBinaryFile) {
     return {
-      type: "Error" /* Error */,
+      success: false,
       message: {
         type: "error-text",
         value: "Not possible to fetch files. Abort."
       }
     };
   }
-  const { url } = toolInfo8.parameters.parse(args);
+  const { url } = toolInfo5.parameters.parse(args);
   try {
     const filePart = await provider.readBinaryFile(url);
     return {
-      type: "Reply" /* Reply */,
+      success: true,
       message: {
         type: "content",
         value: [
@@ -770,7 +1324,7 @@ var handler8 = async (provider, args) => {
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : "Unknown error";
     return {
-      type: "Error" /* Error */,
+      success: false,
       message: {
         type: "error-text",
         value: `Error fetching file from ${url}: ${errorMessage}`
@@ -779,13 +1333,13 @@ var handler8 = async (provider, args) => {
   }
 };
 var readBinaryFile_default = {
-  ...toolInfo8,
-  handler: handler8
+  ...toolInfo5,
+  handler: handler5
 };
 
 // src/tools/readFile.ts
 import { z as z11 } from "zod";
-var toolInfo9 = {
+var toolInfo6 = {
   name: "readFile",
   description: "Request to read the contents of one or multiple files at the specified paths. Use comma separated paths to read multiple files. Use this when you need to examine the contents of an existing file you do not know the contents of, for example to analyze code, review text files, or extract information from configuration files. May not be suitable for other types of binary files, as it returns the raw content as a string. Try to list all the potential files are relevent to the task, and then use this tool to read all the relevant files.",
   parameters: z11.object({
@@ -794,14 +1348,7 @@ var toolInfo9 = {
       const values = Array.isArray(val) ? val : [val];
       return values.flatMap((i) => typeof i === "string" ? i.split(",") : []).filter((s) => s.length > 0);
     }, z11.array(z11.string())).describe("The path of the file to read").meta({ usageValue: "Comma separated paths here" }),
-    includeIgnored: z11.preprocess((val) => {
-      if (typeof val === "string") {
-        const lower = val.toLowerCase();
-        if (lower === "false") return false;
-        if (lower === "true") return true;
-      }
-      return val;
-    }, z11.boolean().nullish().default(false)).describe("Whether to include ignored files. Use true to include files ignored by .gitignore.").meta({ usageValue: "true or false (optional)" })
+    includeIgnored: z11.preprocess(preprocessBoolean, z11.boolean().nullish().default(false)).describe("Whether to include ignored files. Use true to include files ignored by .gitignore.").meta({ usageValue: "true or false (optional)" })
   }).meta({
     examples: [
       {
@@ -819,33 +1366,22 @@ var toolInfo9 = {
     ]
   })
 };
-var handler9 = async (provider, args) => {
+var handler6 = async (provider, args) => {
   if (!provider.readFile) {
-    return {
-      type: "Error" /* Error */,
-      message: {
-        type: "error-text",
-        value: "Not possible to read file."
-      }
-    };
+    return createProviderError("read file");
   }
-  const { path: paths, includeIgnored } = toolInfo9.parameters.parse(args);
+  const { path: paths, includeIgnored } = toolInfo6.parameters.parse(args);
   const resp = [];
   for (const path of paths) {
     const fileContent = await provider.readFile(path, includeIgnored ?? false);
     if (!fileContent) {
-      resp.push(`<read_file_file_content path="${path}" file_not_found="true" />`);
+      resp.push(createFileElement("read_file_file_content", path, void 0, { file_not_found: "true" }));
     } else {
-      const isEmpty = fileContent.trim().length === 0;
-      if (isEmpty) {
-        resp.push(`<read_file_file_content path="${path}" is_empty="true" />`);
-      } else {
-        resp.push(`<read_file_file_content path="${path}">${fileContent}</read_file_file_content>`);
-      }
+      resp.push(createFileElement("read_file_file_content", path, fileContent));
     }
   }
   return {
-    type: "Reply" /* Reply */,
+    success: true,
     message: {
       type: "text",
       value: resp.join("\n")
@@ -853,53 +1389,17 @@ var handler9 = async (provider, args) => {
   };
 };
 var readFile_default = {
-  ...toolInfo9,
-  handler: handler9
-};
-
-// src/tools/readMemory.ts
-import { z as z12 } from "zod";
-var toolInfo10 = {
-  name: "readMemory",
-  description: "Reads content from a memory topic. Use this to retrieve information stored in previous steps. If no topic is specified, reads from the default topic.",
-  parameters: z12.object({
-    topic: z12.string().nullish().describe('The topic to read from memory. Defaults to ":default:".')
-  })
-};
-var handler10 = async (provider, args) => {
-  const { topic } = toolInfo10.parameters.parse(args);
-  const content = await provider.readMemory(topic ?? void 0);
-  if (content) {
-    return {
-      type: "Reply" /* Reply */,
-      message: {
-        type: "text",
-        value: `<memory${topic ? ` topic="${topic}"` : ""}>
-${content}
-</memory>`
-      }
-    };
-  }
-  return {
-    type: "Reply" /* Reply */,
-    message: {
-      type: "text",
-      value: `<memory ${topic ? `topic="${topic}"` : ""} isEmpty="true" />`
-    }
-  };
-};
-var readMemory_default = {
-  ...toolInfo10,
-  handler: handler10
+  ...toolInfo6,
+  handler: handler6
 };
 
 // src/tools/removeFile.ts
-import { z as z13 } from "zod";
-var toolInfo11 = {
+import { z as z12 } from "zod";
+var toolInfo7 = {
   name: "removeFile",
   description: "Request to remove a file at the specified path.",
-  parameters: z13.object({
-    path: z13.string().describe("The path of the file to remove").meta({ usageValue: "File path here" })
+  parameters: z12.object({
+    path: z12.string().describe("The path of the file to remove").meta({ usageValue: "File path here" })
   }).meta({
     examples: [
       {
@@ -911,20 +1411,14 @@ var toolInfo11 = {
     ]
   })
 };
-var handler11 = async (provider, args) => {
+var handler7 = async (provider, args) => {
   if (!provider.removeFile) {
-    return {
-      type: "Error" /* Error */,
-      message: {
-        type: "error-text",
-        value: "Not possible to remove file."
-      }
-    };
+    return createProviderError("remove file");
   }
-  const parsed = toolInfo11.parameters.safeParse(args);
+  const parsed = toolInfo7.parameters.safeParse(args);
   if (!parsed.success) {
     return {
-      type: "Error" /* Error */,
+      success: false,
       message: {
         type: "error-text",
         value: `Invalid arguments for removeFile: ${parsed.error.message}`
@@ -934,7 +1428,7 @@ var handler11 = async (provider, args) => {
   const { path } = parsed.data;
   await provider.removeFile(path);
   return {
-    type: "Reply" /* Reply */,
+    success: true,
     message: {
       type: "text",
       value: `<remove_file_path>${path}</remove_file_path><status>Success</status>`
@@ -942,18 +1436,18 @@ var handler11 = async (provider, args) => {
   };
 };
 var removeFile_default = {
-  ...toolInfo11,
-  handler: handler11
+  ...toolInfo7,
+  handler: handler7
 };
 
 // src/tools/renameFile.ts
-import { z as z14 } from "zod";
-var toolInfo12 = {
+import { z as z13 } from "zod";
+var toolInfo8 = {
   name: "renameFile",
   description: "Request to rename a file from source path to target path.",
-  parameters: z14.object({
-    source_path: z14.string().describe("The current path of the file").meta({ usageValue: "Source file path here" }),
-    target_path: z14.string().describe("The new path for the file").meta({ usageValue: "Target file path here" })
+  parameters: z13.object({
+    source_path: z13.string().describe("The current path of the file").meta({ usageValue: "Source file path here" }),
+    target_path: z13.string().describe("The new path for the file").meta({ usageValue: "Target file path here" })
   }).meta({
     examples: [
       {
@@ -966,20 +1460,20 @@ var toolInfo12 = {
     ]
   })
 };
-var handler12 = async (provider, args) => {
+var handler8 = async (provider, args) => {
   if (!provider.renameFile) {
     return {
-      type: "Error" /* Error */,
+      success: false,
       message: {
         type: "error-text",
         value: "Not possible to rename file."
       }
     };
   }
-  const { source_path, target_path } = toolInfo12.parameters.parse(args);
+  const { source_path, target_path } = toolInfo8.parameters.parse(args);
   await provider.renameFile(source_path, target_path);
   return {
-    type: "Reply" /* Reply */,
+    success: true,
     message: {
       type: "text",
       value: `<rename_file_path>${target_path}</rename_file_path><status>Success</status>`
@@ -987,12 +1481,12 @@ var handler12 = async (provider, args) => {
   };
 };
 var renameFile_default = {
-  ...toolInfo12,
-  handler: handler12
+  ...toolInfo8,
+  handler: handler8
 };
 
 // src/tools/replaceInFile.ts
-import { z as z15 } from "zod";
+import { z as z14 } from "zod";
 
 // src/tools/utils/replaceInFile.ts
 var replaceInFile = (fileContent, diff) => {
@@ -1035,10 +1529,27 @@ var replaceInFile = (fileContent, diff) => {
         }
         runningIndex++;
       }
-      const strippedSearch = trimmedSearch.replace(/\s+/g, "");
-      const endPos = actualPos;
-      const startPos = endPos - strippedSearch.length;
-      return content.slice(0, startPos) + replace + content.slice(endPos);
+      const searchWords = trimmedSearch.replace(/\s+/g, " ").split(" ").filter((w) => w.length > 0);
+      let matchStartPos = -1;
+      let matchEndPos = -1;
+      if (searchWords.length > 0) {
+        const firstWordPos = content.indexOf(searchWords[0], offset);
+        if (firstWordPos !== -1) {
+          matchStartPos = firstWordPos;
+          matchEndPos = firstWordPos + searchWords[0].length;
+          for (let i = 1; i < searchWords.length; i++) {
+            const nextWordPos = content.indexOf(searchWords[i], matchEndPos);
+            if (nextWordPos === -1 || nextWordPos > matchEndPos + 100) {
+              matchStartPos = -1;
+              break;
+            }
+            matchEndPos = nextWordPos + searchWords[i].length;
+          }
+        }
+      }
+      if (matchStartPos !== -1 && matchEndPos !== -1) {
+        return content.slice(0, matchStartPos) + replace + content.slice(matchEndPos);
+      }
     }
     return null;
   };
@@ -1069,12 +1580,12 @@ var replaceInFile = (fileContent, diff) => {
 };
 
 // src/tools/replaceInFile.ts
-var toolInfo13 = {
+var toolInfo9 = {
   name: "replaceInFile",
   description: "Request to replace sections of content in an existing file using SEARCH/REPLACE blocks that define exact changes to specific parts of the file. This tool should be used when you need to make targeted changes to specific parts of a file.",
-  parameters: z15.object({
-    path: z15.string().describe("The path of the file to modify").meta({ usageValue: "File path here" }),
-    diff: z15.string().describe(
+  parameters: z14.object({
+    path: z14.string().describe("The path of the file to modify").meta({ usageValue: "File path here" }),
+    diff: z14.string().describe(
       `One or more SEARCH/REPLACE blocks following this exact format:
 \`\`\`
 <<<<<<< SEARCH
@@ -1181,20 +1692,20 @@ function oldFeature() {
     ]
   })
 };
-var handler13 = async (provider, args) => {
+var handler9 = async (provider, args) => {
   if (!provider.readFile || !provider.writeFile) {
     return {
-      type: "Error" /* Error */,
+      success: false,
       message: {
         type: "error-text",
         value: "Not possible to replace in file."
       }
     };
   }
-  const parsed = toolInfo13.parameters.safeParse(args);
+  const parsed = toolInfo9.parameters.safeParse(args);
   if (!parsed.success) {
     return {
-      type: "Error" /* Error */,
+      success: false,
       message: {
         type: "error-text",
         value: `Invalid arguments for replaceInFile: ${parsed.error.message}`
@@ -1206,7 +1717,7 @@ var handler13 = async (provider, args) => {
     const fileContent = await provider.readFile(path, false);
     if (fileContent == null) {
       return {
-        type: "Error" /* Error */,
+        success: false,
         message: {
           type: "error-text",
           value: `<replace_in_file_result path="${path}" status="failed" message="File not found" />`
@@ -1216,7 +1727,7 @@ var handler13 = async (provider, args) => {
     const result = replaceInFile(fileContent, diff);
     if (result.status === "no_diff_applied") {
       return {
-        type: "Error" /* Error */,
+        success: false,
         message: {
           type: "error-text",
           value: `<replace_in_file_result path="${path}" status="failed" message="Unable to apply changes">
@@ -1228,7 +1739,7 @@ var handler13 = async (provider, args) => {
     await provider.writeFile(path, result.content);
     if (result.status === "some_diff_applied") {
       return {
-        type: "Reply" /* Reply */,
+        success: true,
         message: {
           type: "text",
           value: `<replace_in_file_result path="${path}" status="some_diff_applied" applied_count="${result.appliedCount}" total_count="${result.totalCount}">
@@ -1238,7 +1749,7 @@ var handler13 = async (provider, args) => {
       };
     }
     return {
-      type: "Reply" /* Reply */,
+      success: true,
       message: {
         type: "text",
         value: `<replace_in_file_result path="${path}" status="all_diff_applied" />`
@@ -1246,7 +1757,7 @@ var handler13 = async (provider, args) => {
     };
   } catch (error) {
     return {
-      type: "Error" /* Error */,
+      success: false,
       message: {
         type: "error-text",
         value: `Invalid arguments for replaceInFile: ${error}`
@@ -1255,17 +1766,17 @@ var handler13 = async (provider, args) => {
   }
 };
 var replaceInFile_default = {
-  ...toolInfo13,
-  handler: handler13
+  ...toolInfo9,
+  handler: handler9
 };
 
 // src/tools/search.ts
-import { z as z16 } from "zod";
-var toolInfo14 = {
+import { z as z15 } from "zod";
+var toolInfo10 = {
   name: "search",
   description: "Search the web for information using Google Search. Use this tool to find current information, facts, news, documentation, or research that is not available in your training data. Returns comprehensive search results with relevant content extracted from the web.",
-  parameters: z16.object({
-    query: z16.string().describe("The query to search for").meta({ usageValue: "Your search query here" })
+  parameters: z15.object({
+    query: z15.string().describe("The query to search for").meta({ usageValue: "Your search query here" })
   }).meta({
     examples: [
       {
@@ -1289,11 +1800,11 @@ var toolInfo14 = {
     ]
   })
 };
-var handler14 = async (provider, args) => {
-  const { query } = toolInfo14.parameters.parse(args);
+var handler10 = async (provider, args) => {
+  const { query } = toolInfo10.parameters.parse(args);
   if (!provider.search) {
     return {
-      type: "Error" /* Error */,
+      success: false,
       message: {
         type: "text",
         value: "This tool requires a web provider to be installed."
@@ -1302,7 +1813,7 @@ var handler14 = async (provider, args) => {
   }
   const result = await provider.search(query);
   return {
-    type: "Reply" /* Reply */,
+    success: true,
     message: {
       type: "text",
       value: result
@@ -1310,23 +1821,23 @@ var handler14 = async (provider, args) => {
   };
 };
 var search_default = {
-  ...toolInfo14,
-  handler: handler14
+  ...toolInfo10,
+  handler: handler10
 };
 
 // src/tools/searchFiles.ts
-import { z as z17 } from "zod";
-var toolInfo15 = {
+import { z as z16 } from "zod";
+var toolInfo11 = {
   name: "searchFiles",
   description: "Request to perform a regex search across files in a specified directory, outputting context-rich results that include surrounding lines. This tool searches for patterns or specific content across multiple files, displaying each match with encapsulating context.",
-  parameters: z17.object({
-    path: z17.string().describe(
+  parameters: z16.object({
+    path: z16.string().describe(
       "The path of the directory to search in (relative to the current working directory). This directory will be recursively searched."
     ).meta({ usageValue: "Directory path here" }),
-    regex: z17.string().describe("The regular expression pattern to search for. Uses Rust regex syntax.").meta({
+    regex: z16.string().describe("The regular expression pattern to search for. Uses Rust regex syntax.").meta({
       usageValue: "Your regex pattern here"
     }),
-    filePattern: z17.string().optional().describe(
+    filePattern: z16.string().optional().describe(
       'Comma-separated glob pattern to filter files (e.g., "*.ts" for TypeScript files or "*.ts,*.js" for both TypeScript and JavaScript files). If not provided, it will search all files (*).'
     ).meta({
       usageValue: "file pattern here (optional)"
@@ -1344,20 +1855,20 @@ var toolInfo15 = {
     ]
   })
 };
-var handler15 = async (provider, args) => {
+var handler11 = async (provider, args) => {
   if (!provider.searchFiles) {
     return {
-      type: "Error" /* Error */,
+      success: false,
       message: {
         type: "error-text",
         value: "Not possible to search files."
       }
     };
   }
-  const parsed = toolInfo15.parameters.safeParse(args);
+  const parsed = toolInfo11.parameters.safeParse(args);
   if (!parsed.success) {
     return {
-      type: "Error" /* Error */,
+      success: false,
       message: {
         type: "error-text",
         value: `Invalid arguments for searchFiles: ${parsed.error.message}`
@@ -1368,7 +1879,7 @@ var handler15 = async (provider, args) => {
   try {
     const files = await provider.searchFiles(path, regex, filePattern ?? "*");
     return {
-      type: "Reply" /* Reply */,
+      success: true,
       message: {
         type: "text",
         value: `<search_files_path>${path}</search_files_path>
@@ -1382,7 +1893,7 @@ ${files.join("\n")}
     };
   } catch (error) {
     return {
-      type: "Error" /* Error */,
+      success: false,
       message: {
         type: "error-text",
         value: `Error searching files: ${error}`
@@ -1391,122 +1902,57 @@ ${files.join("\n")}
   }
 };
 var searchFiles_default = {
-  ...toolInfo15,
-  handler: handler15
+  ...toolInfo11,
+  handler: handler11
 };
 
-// src/tools/updateMemory.ts
-import { z as z18 } from "zod";
-var toolInfo16 = {
-  name: "updateMemory",
-  description: 'Appends, replaces, or removes content from a memory topic. Use "append" to add to existing content, "replace" to overwrite entirely, or "remove" to delete a topic. Memory persists across tool calls within a workflow.',
-  parameters: z18.object({
-    operation: z18.enum(["append", "replace", "remove"]).describe("The operation to perform."),
-    topic: z18.string().nullish().describe('The topic to update in memory. Defaults to ":default:".'),
-    content: z18.string().nullish().describe("The content for append or replace operations. Must be omitted for remove operation.")
-  }).superRefine((data, ctx) => {
-    if (data.operation === "append" || data.operation === "replace") {
-      if (data.content === void 0) {
-        ctx.addIssue({
-          code: "custom",
-          message: 'Content is required for "append" and "replace" operations.',
-          path: ["content"]
-        });
-      }
-    } else if (data.operation === "remove") {
-      if (data.content !== void 0) {
-        ctx.addIssue({
-          code: "custom",
-          message: 'Content must not be provided for "remove" operation.',
-          path: ["content"]
-        });
-      }
+// src/tools/todo.ts
+import { z as z17 } from "zod";
+var TodoStatus = z17.enum(["open", "completed", "closed"]);
+var TodoItemSchema = z17.object({
+  id: z17.string(),
+  title: z17.string(),
+  description: z17.string(),
+  status: TodoStatus
+});
+var UpdateTodoItemInputSchema = z17.object({
+  operation: z17.enum(["add", "update"]),
+  id: z17.string().nullish(),
+  parentId: z17.string().nullish(),
+  title: z17.string().nullish(),
+  description: z17.string().nullish(),
+  status: TodoStatus.nullish()
+}).superRefine((data, ctx) => {
+  if (data.operation === "add") {
+    if (!data.title) {
+      ctx.addIssue({
+        code: "custom",
+        message: 'Title is required for "add" operation',
+        path: ["title"]
+      });
     }
-  })
-};
-var handler16 = async (provider, args) => {
-  if (!provider.updateMemory) {
-    return {
-      type: "Error" /* Error */,
-      message: {
-        type: "error-text",
-        value: "Memory operations are not supported by the current provider."
-      }
-    };
-  }
-  const params = toolInfo16.parameters.parse(args);
-  await provider.updateMemory(params.operation, params.topic ?? void 0, params.content ?? void 0);
-  switch (params.operation) {
-    case "append":
-      return {
-        type: "Reply" /* Reply */,
-        message: {
-          type: "text",
-          value: `Content appended to memory topic '${params.topic || ":default:"}'.`
-        }
-      };
-    case "replace":
-      return {
-        type: "Reply" /* Reply */,
-        message: {
-          type: "text",
-          value: `Memory topic '${params.topic || ":default:"}' replaced.`
-        }
-      };
-    case "remove":
-      return {
-        type: "Reply" /* Reply */,
-        message: {
-          type: "text",
-          value: `Memory topic '${params.topic || ":default:"}' removed.`
-        }
-      };
-  }
-};
-var updateMemory_default = {
-  ...toolInfo16,
-  handler: handler16
-};
-
-// src/tools/updateTodoItem.ts
-var toolInfo17 = {
-  name: "updateTodoItem",
-  description: "Add or update a to-do item.",
-  parameters: UpdateTodoItemInputSchema
-};
-var handler17 = async (provider, args) => {
-  if (!provider.updateTodoItem) {
-    return {
-      type: "Error" /* Error */,
-      message: {
-        type: "error-text",
-        value: "Not possible to update a to-do item."
-      }
-    };
-  }
-  const input = toolInfo17.parameters.parse(args);
-  const result = await provider.updateTodoItem(input);
-  return {
-    type: "Reply" /* Reply */,
-    message: {
-      type: "json",
-      value: result
+  } else if (data.operation === "update") {
+    if (!data.id) {
+      ctx.addIssue({
+        code: "custom",
+        message: 'ID is required for "update" operation',
+        path: ["id"]
+      });
     }
-  };
-};
-var updateTodoItem_default = {
-  ...toolInfo17,
-  handler: handler17
-};
+  }
+});
+var UpdateTodoItemOutputSchema = z17.object({
+  id: z17.string()
+});
 
 // src/tools/writeToFile.ts
-import { z as z19 } from "zod";
-var toolInfo18 = {
+import { z as z18 } from "zod";
+var toolInfo12 = {
   name: "writeToFile",
   description: "Request to write content to a file at the specified path. If the file exists, it will be overwritten with the provided content. If the file doesn't exist, it will be created. This tool will automatically create any directories needed to write the file. Ensure that the output content does not include incorrect escaped character patterns such as `&lt;`, `&gt;`, or `&amp;`. Also ensure there is no unwanted CDATA tags in the content.",
-  parameters: z19.object({
-    path: z19.string().describe("The path of the file to write to").meta({ usageValue: "File path here" }),
-    content: z19.string().describe(
+  parameters: z18.object({
+    path: z18.string().describe("The path of the file to write to").meta({ usageValue: "File path here" }),
+    content: z18.string().describe(
       "The content to write to the file. ALWAYS provide the COMPLETE intended content of the file, without any truncation or omissions. You MUST include ALL parts of the file, even if they haven't been modified."
     ).meta({ usageValue: "Your file content here" })
   }).meta({
@@ -1532,20 +1978,14 @@ export default App;
     ]
   })
 };
-var handler18 = async (provider, args) => {
+var handler12 = async (provider, args) => {
   if (!provider.writeFile) {
-    return {
-      type: "Error" /* Error */,
-      message: {
-        type: "error-text",
-        value: "Not possible to write file."
-      }
-    };
+    return createProviderError("write file");
   }
-  const parsed = toolInfo18.parameters.safeParse(args);
+  const parsed = toolInfo12.parameters.safeParse(args);
   if (!parsed.success) {
     return {
-      type: "Error" /* Error */,
+      success: false,
       message: {
         type: "error-text",
         value: `Invalid arguments for writeToFile: ${parsed.error.message}`
@@ -1554,10 +1994,10 @@ var handler18 = async (provider, args) => {
   }
   let { path, content } = parsed.data;
   const trimmedContent = content.trim();
-  if (trimmedContent.startsWith("<![CDATA[") && content.endsWith("]]>")) content = trimmedContent.slice(9, -3);
+  if (trimmedContent.startsWith("<![CDATA[") && trimmedContent.endsWith("]]>")) content = trimmedContent.slice(9, -3);
   await provider.writeFile(path, content);
   return {
-    type: "Reply" /* Reply */,
+    success: true,
     message: {
       type: "text",
       value: `<write_to_file_path>${path}</write_to_file_path><status>Success</status>`
@@ -1565,8 +2005,8 @@ var handler18 = async (provider, args) => {
   };
 };
 var writeToFile_default = {
-  ...toolInfo18,
-  handler: handler18
+  ...toolInfo12,
+  handler: handler12
 };
 
 // src/UsageMeter.ts
@@ -1591,7 +2031,7 @@ var UsageMeter = class {
     this.#maxMessages = opts.maxMessages ?? 1e3;
     this.#maxCost = opts.maxCost ?? 100;
   }
-  #calculageUsage(usage, providerMetadata, modelInfo) {
+  #calculateUsage(usage, providerMetadata, modelInfo) {
     const providerMetadataKey = Object.keys(providerMetadata ?? {})[0];
     const metadata = providerMetadata?.[providerMetadataKey] ?? {};
     switch (providerMetadataKey) {
@@ -1649,7 +2089,7 @@ var UsageMeter = class {
       cacheReadsPrice: 0
     };
     const usage = "totalUsage" in resp ? resp.totalUsage : resp.usage;
-    const result = this.#calculageUsage(usage, resp.providerMetadata, modelInfo);
+    const result = this.#calculateUsage(usage, resp.providerMetadata, modelInfo);
     this.#totals.input += result.input || 0;
     this.#totals.output += result.output || 0;
     this.#totals.cachedRead += result.cachedRead || 0;
@@ -1719,7 +2159,7 @@ var UsageMeter = class {
 
 // src/workflow/agent.workflow.ts
 import { jsonSchema } from "ai";
-import { toJSONSchema, z as z20 } from "zod";
+import { toJSONSchema, z as z19 } from "zod";
 
 // src/workflow/types.ts
 var TaskEventKind = /* @__PURE__ */ ((TaskEventKind2) => {
@@ -1739,11 +2179,11 @@ var TaskEventKind = /* @__PURE__ */ ((TaskEventKind2) => {
 // src/workflow/agent.workflow.ts
 var agentWorkflow = async (input, { step, tools, logger }) => {
   const event = (name, event2) => step(name, () => tools.taskEvent(event2));
-  const { tools: toolInfo19, maxToolRoundTrips = 200 } = input;
+  const { tools: toolInfo13, maxToolRoundTrips = 200 } = input;
   const messages = "systemPrompt" in input ? [{ role: "system", content: input.systemPrompt }] : input.messages;
   await event("start-task", { kind: "StartTask" /* StartTask */, systemPrompt: "systemPrompt" in input ? input.systemPrompt : "" });
   const toolSet = {};
-  for (const tool of toolInfo19) {
+  for (const tool of toolInfo13) {
     toolSet[tool.name] = {
       description: tool.description,
       inputSchema: jsonSchema(toJSONSchema(tool.parameters))
@@ -1791,9 +2231,9 @@ var agentWorkflow = async (input, { step, tools, logger }) => {
     await event(`end-round-${i}`, { kind: "EndRequest" /* EndRequest */, message: textContent });
     if (toolCalls.length === 0) {
       if (!input.outputSchema) {
-        const exitReason2 = { type: "Exit", message: textContent, messages };
-        await event("end-task", { kind: "EndTask" /* EndTask */, exitReason: exitReason2 });
-        return exitReason2;
+        const exitReason3 = { type: "Exit", message: textContent, messages };
+        await event("end-task", { kind: "EndTask" /* EndTask */, exitReason: exitReason3 });
+        return exitReason3;
       }
       const parsed = parseJsonFromMarkdown(textContent);
       if (!parsed.success) {
@@ -1803,13 +2243,13 @@ var agentWorkflow = async (input, { step, tools, logger }) => {
       }
       const validated = input.outputSchema.safeParse(parsed.data);
       if (!validated.success) {
-        const errorMessage = `Output validation failed. Error: ${z20.prettifyError(validated.error)}. Please correct the output.`;
+        const errorMessage = `Output validation failed. Error: ${z19.prettifyError(validated.error)}. Please correct the output.`;
         nextMessage = [{ role: "user", content: errorMessage }];
         continue;
       }
-      const exitReason = { type: "Exit", message: textContent, object: validated.data, messages };
-      await event("end-task", { kind: "EndTask" /* EndTask */, exitReason });
-      return exitReason;
+      const exitReason2 = { type: "Exit", message: textContent, object: validated.data, messages };
+      await event("end-task", { kind: "EndTask" /* EndTask */, exitReason: exitReason2 });
+      return exitReason2;
     }
     const toolResults = [];
     for (const toolCall of toolCalls) {
@@ -1844,128 +2284,277 @@ var agentWorkflow = async (input, { step, tools, logger }) => {
           input: toolCall.input
         });
       });
-      switch (toolResponse.type) {
-        case "Reply" /* Reply */:
-          await event(`event-tool-reply-${toolCall.toolName}-${toolCall.toolCallId}`, {
-            kind: "ToolReply" /* ToolReply */,
-            tool: toolCall.toolName,
-            content: toolResponse.message
-          });
-          toolResults.push({
-            toolCallId: toolCall.toolCallId,
-            toolName: toolCall.toolName,
-            output: toolResponse.message
-          });
-          break;
-        case "Error" /* Error */:
-          await event(`event-tool-error-${toolCall.toolName}-${toolCall.toolCallId}`, {
-            kind: "ToolError" /* ToolError */,
-            tool: toolCall.toolName,
-            error: toolResponse.message ?? "Unknown error"
-          });
-          toolResults.push({
-            toolCallId: toolCall.toolCallId,
-            toolName: toolCall.toolName,
-            output: toolResponse.message
-          });
-          break;
-        case "Exit": {
-          if (toolCalls.length > 1) {
-            toolResults.push({
-              toolCallId: toolCall.toolCallId,
-              toolName: toolCall.toolName,
-              output: {
-                type: "error-text",
-                value: `Error: The tool '${toolCall.toolName}' must be called alone, but it was called with other tools.`
-              }
-            });
-            break;
-          }
-          if (toolResults.length > 0) {
-            break;
-          }
-          const exitReason = { ...toolResponse, messages };
-          await event("end-task", { kind: "EndTask" /* EndTask */, exitReason });
-          return exitReason;
-        }
-      }
-    }
-    nextMessage = [
-      {
-        role: "tool",
-        content: toolResults.map((r) => ({
-          type: "tool-result",
+      if (toolResponse.success) {
+        await event(`event-tool-reply-${toolCall.toolName}-${toolCall.toolCallId}`, {
+          kind: "ToolReply" /* ToolReply */,
+          tool: toolCall.toolName,
+          content: toolResponse.message
+        });
+        toolResults.push({
+          toolCallId: toolCall.toolCallId,
+          toolName: toolCall.toolName,
+          output: toolResponse.message
+        });
+      } else {
+        await event(`event-tool-error-${toolCall.toolName}-${toolCall.toolCallId}`, {
+          kind: "ToolError" /* ToolError */,
+          tool: toolCall.toolName,
+          error: toolResponse.message ?? "Unknown error"
+        });
+        toolResults.push({
+          toolCallId: toolCall.toolCallId,
+          toolName: toolCall.toolName,
+          output: toolResponse.message
+        });
+      }
+    }
+    nextMessage = [
+      {
+        role: "tool",
+        content: toolResults.map((r) => ({
+          type: "tool-result",
           ...r
         }))
       }
     ];
   }
-  await event("end-task", { kind: "EndTask" /* EndTask */, exitReason: { type: "UsageExceeded", messages } });
-  throw new Error("Maximum number of tool round trips reached.");
+  const exitReason = { type: "UsageExceeded", messages };
+  await event("end-task", { kind: "EndTask" /* EndTask */, exitReason });
+  return exitReason;
 };
 
 // src/workflow/dynamic.ts
-import { parse } from "yaml";
-import { z as z22 } from "zod";
+import { parse as parse2 } from "yaml";
+import { z as z21 } from "zod";
 
 // src/workflow/dynamic-types.ts
-import { z as z21 } from "zod";
-var WorkflowInputDefinitionSchema = z21.object({
-  id: z21.string(),
-  description: z21.string().nullish(),
-  default: z21.any().nullish()
+import { z as z20 } from "zod";
+var WorkflowInputDefinitionSchema = z20.object({
+  id: z20.string(),
+  description: z20.string().nullish(),
+  default: z20.any().nullish()
 });
-var WorkflowStepDefinitionSchema = z21.object({
-  id: z21.string(),
-  tools: z21.array(z21.string()).nullish(),
-  task: z21.string(),
-  output: z21.string().nullish(),
-  expected_outcome: z21.string().nullish(),
-  /**
-   * Persisted JavaScript/TypeScript (JS-compatible) async function body.
-   * The code is wrapped as: `async (ctx) => { <code> }`.
-   */
-  code: z21.string().nullish(),
+var WorkflowStepDefinitionSchema = z20.object({
+  id: z20.string(),
+  tools: z20.array(z20.string()).nullish(),
+  task: z20.string(),
+  output: z20.string().nullish(),
+  expected_outcome: z20.string().nullish(),
   /**
    * Optional JSON schema or other metadata for future structured outputs.
    * Not interpreted by core today.
    */
-  outputSchema: z21.any().nullish(),
+  outputSchema: z20.any().nullish(),
   /**
    * Optional timeout in milliseconds. Step execution will be aborted if it exceeds this duration.
    */
-  timeout: z21.number().positive().nullish()
+  timeout: z20.number().positive().nullish()
 });
-var WorkflowDefinitionSchema = z21.object({
-  task: z21.string(),
-  inputs: z21.array(WorkflowInputDefinitionSchema).nullish(),
-  steps: z21.array(WorkflowStepDefinitionSchema),
-  output: z21.string().nullish()
+var WhileLoopStepSchema = z20.object({
+  id: z20.string(),
+  while: z20.object({
+    condition: z20.string().describe("JavaScript expression that evaluates to true/false"),
+    steps: z20.array(z20.lazy(() => WorkflowControlFlowStepSchema))
+  }),
+  output: z20.string().nullish()
 });
-var WorkflowFileSchema = z21.object({
-  workflows: z21.record(z21.string(), WorkflowDefinitionSchema)
+var IfElseStepSchema = z20.object({
+  id: z20.string(),
+  if: z20.object({
+    condition: z20.string().describe("JavaScript expression that evaluates to true/false"),
+    thenBranch: z20.array(z20.lazy(() => WorkflowControlFlowStepSchema)),
+    elseBranch: z20.array(z20.lazy(() => WorkflowControlFlowStepSchema)).optional()
+  }),
+  output: z20.string().nullish()
+});
+var BreakStepSchema = z20.object({
+  break: z20.literal(true)
+});
+var ContinueStepSchema = z20.object({
+  continue: z20.literal(true)
+});
+var TryCatchStepSchema = z20.object({
+  id: z20.string(),
+  try: z20.object({
+    trySteps: z20.array(z20.lazy(() => WorkflowControlFlowStepSchema)),
+    catchSteps: z20.array(z20.lazy(() => WorkflowControlFlowStepSchema))
+  }),
+  output: z20.string().nullish()
+});
+var WorkflowControlFlowStepSchema = z20.union([
+  WorkflowStepDefinitionSchema,
+  WhileLoopStepSchema,
+  IfElseStepSchema,
+  BreakStepSchema,
+  ContinueStepSchema,
+  TryCatchStepSchema
+]);
+var WorkflowDefinitionSchema = z20.object({
+  task: z20.string(),
+  inputs: z20.array(WorkflowInputDefinitionSchema).nullish(),
+  steps: z20.array(WorkflowControlFlowStepSchema),
+  output: z20.string().nullish()
+});
+var WorkflowFileSchema = z20.object({
+  workflows: z20.record(z20.string(), WorkflowDefinitionSchema)
 });
 
 // src/workflow/dynamic.ts
+var MAX_WHILE_LOOP_ITERATIONS = 1e3;
+function convertJsonSchemaToZod(schema) {
+  if (schema.enum) {
+    return z21.enum(schema.enum.map((v) => String(v)));
+  }
+  if (Array.isArray(schema.type)) {
+    const types = schema.type;
+    if (types.includes("null") && types.length === 2) {
+      const nonNullType = types.find((t) => t !== "null");
+      if (nonNullType === "string") return z21.string().nullable();
+      if (nonNullType === "number") return z21.number().nullable();
+      if (nonNullType === "integer")
+        return z21.number().refine((val) => Number.isInteger(val)).nullable();
+      if (nonNullType === "boolean") return z21.boolean().nullable();
+      if (nonNullType === "object") {
+        const shape = {};
+        if (schema.properties) {
+          for (const [propName, propSchema] of Object.entries(schema.properties)) {
+            const propZod = convertJsonSchemaToZod(propSchema);
+            const isRequired = schema.required?.includes(propName);
+            shape[propName] = isRequired ? propZod : propZod.optional();
+          }
+        }
+        return z21.object(shape).nullable();
+      }
+      if (nonNullType === "array") return z21.array(z21.any()).nullable();
+    }
+    return z21.any();
+  }
+  const type = schema.type;
+  switch (type) {
+    case "string":
+      return z21.string();
+    case "number":
+      return z21.number();
+    case "integer":
+      return z21.number().refine((val) => Number.isInteger(val), { message: "Expected an integer" });
+    case "boolean":
+      return z21.boolean();
+    case "null":
+      return z21.null();
+    case "object": {
+      const shape = {};
+      if (schema.properties) {
+        for (const [propName, propSchema] of Object.entries(schema.properties)) {
+          const propZod = convertJsonSchemaToZod(propSchema);
+          const isRequired = schema.required?.includes(propName);
+          shape[propName] = isRequired ? propZod : propZod.optional();
+        }
+      }
+      let objectSchema = z21.object(shape);
+      if (schema.additionalProperties === true) {
+        objectSchema = objectSchema.and(z21.any());
+      } else if (typeof schema.additionalProperties === "object") {
+        const additionalSchema = convertJsonSchemaToZod(schema.additionalProperties);
+        objectSchema = objectSchema.and(z21.record(z21.string(), additionalSchema));
+      }
+      return objectSchema;
+    }
+    case "array": {
+      if (!schema.items) {
+        return z21.array(z21.any());
+      }
+      const itemSchema = convertJsonSchemaToZod(schema.items);
+      return z21.array(itemSchema);
+    }
+    default:
+      return z21.any();
+  }
+}
+var TOOL_GROUPS = {
+  readonly: ["readFile", "readBinaryFile", "listFiles", "searchFiles"],
+  readwrite: ["readFile", "readBinaryFile", "listFiles", "searchFiles", "writeToFile", "replaceInFile", "removeFile", "renameFile"],
+  internet: ["fetchUrl", "search"]
+};
+function validateWorkflowFile(definition) {
+  const errors = [];
+  for (const [workflowId, workflow] of Object.entries(definition.workflows)) {
+    if (!workflow.steps || workflow.steps.length === 0) {
+      errors.push(`Workflow '${workflowId}' has no steps`);
+      continue;
+    }
+    const checkBreakOutsideLoop = (steps, inLoop, path) => {
+      for (const step of steps) {
+        if (isBreakStep(step) || isContinueStep(step)) {
+          if (!inLoop) {
+            errors.push(`${path} has break/continue outside of a loop`);
+          }
+        }
+        if (isWhileLoopStep(step)) {
+          checkBreakOutsideLoop(step.while.steps, true, `${path}/${step.id}`);
+        }
+        if (isIfElseStep(step)) {
+          if (step.if.thenBranch) {
+            checkBreakOutsideLoop(step.if.thenBranch, inLoop, `${path}/${step.id}/then`);
+          }
+          if (step.if.elseBranch) {
+            checkBreakOutsideLoop(step.if.elseBranch, inLoop, `${path}/${step.id}/else`);
+          }
+        }
+        if (isTryCatchStep(step)) {
+          checkBreakOutsideLoop(step.try.trySteps, inLoop, `${path}/${step.id}/try`);
+          checkBreakOutsideLoop(step.try.catchSteps, inLoop, `${path}/${step.id}/catch`);
+        }
+      }
+    };
+    checkBreakOutsideLoop(workflow.steps, false, workflowId);
+    const findRunWorkflowCalls = (steps, path) => {
+      for (const step of steps) {
+        if (isWhileLoopStep(step)) {
+          findRunWorkflowCalls(step.while.steps, `${path}/${step.id}`);
+        }
+        if (isIfElseStep(step)) {
+          if (step.if.thenBranch) {
+            findRunWorkflowCalls(step.if.thenBranch, `${path}/${step.id}/then`);
+          }
+          if (step.if.elseBranch) {
+            findRunWorkflowCalls(step.if.elseBranch, `${path}/${step.id}/else`);
+          }
+        }
+        if (isTryCatchStep(step)) {
+          findRunWorkflowCalls(step.try.trySteps, `${path}/${step.id}/try`);
+          findRunWorkflowCalls(step.try.catchSteps, `${path}/${step.id}/catch`);
+        }
+      }
+    };
+    findRunWorkflowCalls(workflow.steps, workflowId);
+  }
+  if (errors.length > 0) {
+    return { success: false, errors };
+  }
+  return { success: true };
+}
 function parseDynamicWorkflowDefinition(source) {
   try {
-    const raw = parse(source);
+    const raw = parse2(source);
     const validated = WorkflowFileSchema.safeParse(raw);
     if (!validated.success) {
-      return { success: false, error: z22.prettifyError(validated.error) };
+      return { success: false, error: z21.prettifyError(validated.error) };
+    }
+    const validation = validateWorkflowFile(validated.data);
+    if (!validation.success) {
+      return { success: false, error: `Workflow validation failed:
+${validation.errors.map((e) => `  - ${e}`).join("\n")}` };
     }
     return { success: true, definition: validated.data };
   } catch (error) {
     return { success: false, error: error instanceof Error ? error.message : String(error) };
   }
 }
-var AsyncFunction = Object.getPrototypeOf(async () => {
-}).constructor;
 function validateAndApplyDefaults(workflowId, workflow, input) {
   if (!workflow.inputs || workflow.inputs.length === 0) {
     return input;
   }
-  const validatedInput = {};
+  const validatedInput = { ...input };
   const errors = [];
   for (const inputDef of workflow.inputs) {
     const providedValue = input[inputDef.id];
@@ -1983,36 +2572,217 @@ ${errors.map((e) => `  - ${e}`).join("\n")}`);
   }
   return validatedInput;
 }
+function evaluateCondition(condition, input, state, allowUnsafeCodeExecution = false) {
+  if (allowUnsafeCodeExecution) {
+    const functionBody = `
+      try {
+        return ${condition};
+      } catch (error) {
+        throw new Error('Condition evaluation failed: ' + (error instanceof Error ? error.message : String(error)));
+      }
+    `;
+    try {
+      const fn = new Function("input", "state", functionBody);
+      const result = fn(input, state);
+      return Boolean(result);
+    } catch (error) {
+      throw new Error(`Failed to evaluate condition: ${condition}. Error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  } else {
+    return evaluateConditionSafe(condition, input, state);
+  }
+}
+function evaluateConditionSafe(condition, input, state) {
+  condition = condition.trim();
+  if (condition === "true") return true;
+  if (condition === "false") return false;
+  const orIndex = findTopLevelOperator(condition, "||");
+  if (orIndex !== -1) {
+    const left = condition.slice(0, orIndex).trim();
+    const right = condition.slice(orIndex + 2).trim();
+    return evaluateConditionSafe(left, input, state) || evaluateConditionSafe(right, input, state);
+  }
+  const andIndex = findTopLevelOperator(condition, "&&");
+  if (andIndex !== -1) {
+    const left = condition.slice(0, andIndex).trim();
+    const right = condition.slice(andIndex + 2).trim();
+    return evaluateConditionSafe(left, input, state) && evaluateConditionSafe(right, input, state);
+  }
+  const comparisonOps = ["===", "!==", "==", "!=", ">=", "<=", ">", "<"];
+  for (const op of comparisonOps) {
+    const opIndex = findTopLevelOperator(condition, op);
+    if (opIndex !== -1) {
+      const left = evaluateValue(condition.slice(0, opIndex).trim(), input, state);
+      const right = evaluateValue(condition.slice(opIndex + op.length).trim(), input, state);
+      return compareValues(left, right, op);
+    }
+  }
+  if (condition.startsWith("!")) {
+    return !evaluateConditionSafe(condition.slice(1).trim(), input, state);
+  }
+  if (hasEnclosingParens(condition)) {
+    const inner = condition.slice(1, -1);
+    return evaluateConditionSafe(inner, input, state);
+  }
+  const value = evaluateValue(condition, input, state);
+  return Boolean(value);
+}
+function findTopLevelOperator(expr, op) {
+  let parenDepth = 0;
+  let inString = false;
+  let stringChar = "";
+  let escapeNext = false;
+  for (let i = 0; i <= expr.length - op.length; i++) {
+    const char = expr[i];
+    if (escapeNext) {
+      escapeNext = false;
+      continue;
+    }
+    if (char === "\\") {
+      escapeNext = true;
+      continue;
+    }
+    if (!inString && (char === '"' || char === "'")) {
+      inString = true;
+      stringChar = char;
+      continue;
+    }
+    if (inString && char === stringChar) {
+      inString = false;
+      stringChar = "";
+      continue;
+    }
+    if (inString) continue;
+    if (char === "(") parenDepth++;
+    if (char === ")") parenDepth--;
+    if (parenDepth === 0 && expr.slice(i, i + op.length) === op) {
+      return i;
+    }
+  }
+  return -1;
+}
+function hasEnclosingParens(expr) {
+  expr = expr.trim();
+  if (!expr.startsWith("(") || !expr.endsWith(")")) {
+    return false;
+  }
+  let depth = 0;
+  let inString = false;
+  let stringChar = "";
+  let escapeNext = false;
+  for (let i = 0; i < expr.length; i++) {
+    const char = expr[i];
+    if (escapeNext) {
+      escapeNext = false;
+      continue;
+    }
+    if (char === "\\") {
+      escapeNext = true;
+      continue;
+    }
+    if (!inString && (char === '"' || char === "'")) {
+      inString = true;
+      stringChar = char;
+      continue;
+    }
+    if (inString && char === stringChar) {
+      inString = false;
+      stringChar = "";
+      continue;
+    }
+    if (inString) continue;
+    if (char === "(") {
+      depth++;
+      if (i === 0) depth = 1;
+    }
+    if (char === ")") {
+      depth--;
+      if (depth === 0 && i === expr.length - 1) {
+        return true;
+      }
+      if (depth === 0 && i < expr.length - 1) {
+        return false;
+      }
+    }
+  }
+  return false;
+}
+function evaluateValue(expr, input, state) {
+  expr = expr.trim();
+  const stringMatch = expr.match(/^(["'])(?:(?=(\\?))\2.)*?\1$/);
+  if (stringMatch) {
+    const quote = stringMatch[1];
+    if (quote === '"') {
+      try {
+        return JSON.parse(expr);
+      } catch (error) {
+        throw new Error(`Invalid string literal: "${expr}". Error: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    } else {
+      let inner = expr.slice(1, -1);
+      inner = inner.replace(/\\'/g, "'");
+      inner = inner.replace(/\\"/g, '"');
+      const converted = `"${inner.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+      try {
+        return JSON.parse(converted);
+      } catch (error) {
+        throw new Error(`Invalid string literal: "${expr}". Error: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
+  if (/^-?\d*\.?\d+(?:[eE][+-]?\d+)?$/.test(expr)) {
+    return Number.parseFloat(expr);
+  }
+  if (expr === "true") return true;
+  if (expr === "false") return false;
+  if (expr === "null") return null;
+  if (expr.startsWith("input.")) {
+    return getNestedProperty(input, expr.slice(6));
+  }
+  if (expr.startsWith("state.")) {
+    return getNestedProperty(state, expr.slice(6));
+  }
+  throw new Error(
+    `Unrecognized expression in condition: "${expr}". Valid expressions are: string literals, numbers, boolean literals, null, or property access like "input.foo" or "state.bar"`
+  );
+}
+function getNestedProperty(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current == null) return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function compareValues(left, right, op) {
+  switch (op) {
+    case "===":
+      return left === right;
+    case "!==":
+      return left !== right;
+    case "==":
+      return Object.is(left, right);
+    case "!=":
+      return !Object.is(left, right);
+    case ">=":
+      return left >= right;
+    case "<=":
+      return left <= right;
+    case ">":
+      return left > right;
+    case "<":
+      return left < right;
+    default:
+      throw new Error(`Unknown comparison operator: ${op}`);
+  }
+}
 function createRunWorkflowFn(args) {
   return async (subWorkflowId, subInput) => {
     const mergedInput = { ...args.input, ...args.state, ...subInput ?? {} };
     return await args.runInternal(subWorkflowId, mergedInput, args.context, args.state);
   };
 }
-function compileStep(stepDef, workflowId, compiledSteps) {
-  const key = `${workflowId}.${stepDef.id}`;
-  const existing = compiledSteps.get(key);
-  if (existing) {
-    return existing;
-  }
-  if (!stepDef.code) {
-    throw new Error(`Step '${stepDef.id}' in workflow '${workflowId}' has no code`);
-  }
-  try {
-    const fn = new AsyncFunction("ctx", stepDef.code);
-    compiledSteps.set(key, fn);
-    return fn;
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : String(error);
-    const codePreview = stepDef.code.length > 200 ? `${stepDef.code.substring(0, 200)}...` : stepDef.code;
-    throw new Error(
-      `Failed to compile code for step '${stepDef.id}' in workflow '${workflowId}':
-  Error: ${errorMsg}
-  Code:
-${codePreview.split("\n").map((line) => `    ${line}`).join("\n")}`
-    );
-  }
-}
 async function executeStepWithAgent(stepDef, workflowId, input, state, context, options, runInternal) {
   const tools = context.tools;
   if (typeof tools.generateText !== "function" || typeof tools.invokeTool !== "function" || typeof tools.taskEvent !== "function") {
@@ -2025,18 +2795,42 @@ async function executeStepWithAgent(stepDef, workflowId, input, state, context,
       `Step '${stepDef.id}' in workflow '${workflowId}' requires agent execution, but no toolInfo was provided to DynamicWorkflowRunner.`
     );
   }
-  const allowedToolNames = stepDef.tools;
-  const toolsForAgent = allowedToolNames ? options.toolInfo.filter((t) => allowedToolNames.includes(t.name)) : [...options.toolInfo];
-  if (!allowedToolNames || allowedToolNames.includes("runWorkflow")) {
+  const rawAllowedToolNames = stepDef.tools;
+  let toolsForAgent;
+  if (rawAllowedToolNames) {
+    const expandedToolNames = /* @__PURE__ */ new Set();
+    let includeAll = false;
+    for (const name of rawAllowedToolNames) {
+      if (name === "all") {
+        includeAll = true;
+        break;
+      }
+      if (Object.hasOwn(TOOL_GROUPS, name)) {
+        for (const tool of TOOL_GROUPS[name]) {
+          expandedToolNames.add(tool);
+        }
+      } else {
+        expandedToolNames.add(name);
+      }
+    }
+    if (includeAll) {
+      toolsForAgent = [...options.toolInfo];
+    } else {
+      toolsForAgent = options.toolInfo.filter((t) => expandedToolNames.has(t.name));
+    }
+  } else {
+    toolsForAgent = [...options.toolInfo];
+  }
+  if (!rawAllowedToolNames || rawAllowedToolNames.includes("all") || rawAllowedToolNames.includes("runWorkflow")) {
     toolsForAgent.push({
       name: "runWorkflow",
       description: "Run a named sub-workflow defined in the current workflow file.",
-      parameters: z22.object({
-        workflowId: z22.string().describe("Sub-workflow id to run"),
-        input: z22.any().nullish().describe("Optional input object for the sub-workflow")
+      parameters: z21.object({
+        workflowId: z21.string().describe("Sub-workflow id to run"),
+        input: z21.any().nullish().describe("Optional input object for the sub-workflow")
       }),
       handler: async () => {
-        return { type: "Error" /* Error */, message: { type: "error-text", value: "runWorkflow is virtual." } };
+        return { success: false, message: { type: "error-text", value: "runWorkflow is virtual." } };
       }
     });
   }
@@ -2066,7 +2860,7 @@ async function executeStepWithAgent(stepDef, workflowId, input, state, context,
     invokeTool: async ({ toolName, input: toolInput }) => {
       if (!allowedToolNameSet.has(toolName)) {
         return {
-          type: "Error" /* Error */,
+          success: false,
           message: { type: "error-text", value: `Tool '${toolName}' is not allowed in this step.` }
         };
       }
@@ -2075,17 +2869,17 @@ async function executeStepWithAgent(stepDef, workflowId, input, state, context,
         const subInput = toolInput?.input;
         if (typeof subWorkflowId !== "string") {
           return {
-            type: "Error" /* Error */,
+            success: false,
             message: { type: "error-text", value: "runWorkflow.workflowId must be a string." }
           };
         }
         try {
           const output = await runWorkflow(subWorkflowId, subInput);
           const jsonResult = { type: "json", value: output };
-          return { type: "Reply" /* Reply */, message: jsonResult };
+          return { success: true, message: jsonResult };
         } catch (error) {
           return {
-            type: "Error" /* Error */,
+            success: false,
             message: { type: "error-text", value: error instanceof Error ? error.message : String(error) }
           };
         }
@@ -2123,29 +2917,11 @@ async function executeStepWithAgent(stepDef, workflowId, input, state, context,
   if (result.type === "UsageExceeded") {
     throw new Error(`Agent step '${stepDef.id}' in workflow '${workflowId}' exceeded usage limits (tokens or rounds)`);
   }
-  throw new Error(`Agent step '${stepDef.id}' in workflow '${workflowId}' exited unexpectedly with type: ${result.type}`);
+  const _exhaustiveCheck = result;
+  throw new Error(`Agent step '${stepDef.id}' in workflow '${workflowId}' exited unexpectedly with unhandled type`);
 }
-async function executeStepWithTimeout(stepDef, workflowId, input, state, context, options, compiledSteps, runInternal) {
+async function executeStepWithTimeout(stepDef, workflowId, input, state, context, options, runInternal) {
   const executeStepLogic = async () => {
-    if (stepDef.code && options.allowUnsafeCodeExecution) {
-      context.logger.debug(`[Step] Executing step '${stepDef.id}' with compiled code`);
-      const fn = compileStep(stepDef, workflowId, compiledSteps);
-      const runWorkflow = createRunWorkflowFn({ input, state, context, runInternal });
-      const runtimeCtx = {
-        workflowId,
-        stepId: stepDef.id,
-        input,
-        state,
-        tools: context.tools,
-        logger: context.logger,
-        step: context.step,
-        runWorkflow,
-        toolInfo: options.toolInfo
-      };
-      const result2 = await fn(runtimeCtx);
-      context.logger.debug(`[Step] Compiled code execution completed for step '${stepDef.id}'`);
-      return result2;
-    }
     context.logger.debug(`[Step] Executing step '${stepDef.id}' with agent`);
     const result = await executeStepWithAgent(stepDef, workflowId, input, state, context, options, runInternal);
     context.logger.debug(`[Step] Agent execution completed for step '${stepDef.id}'`);
@@ -2168,22 +2944,19 @@ async function executeStepWithTimeout(stepDef, workflowId, input, state, context
   }
   return await executeStepLogic();
 }
-async function executeStep(stepDef, workflowId, input, state, context, options, compiledSteps, runInternal) {
-  const result = await executeStepWithTimeout(stepDef, workflowId, input, state, context, options, compiledSteps, runInternal);
+async function executeStep(stepDef, workflowId, input, state, context, options, runInternal) {
+  const result = await executeStepWithTimeout(stepDef, workflowId, input, state, context, options, runInternal);
   if (stepDef.outputSchema) {
     try {
-      const _schema = z22.any();
-      if (typeof stepDef.outputSchema === "object") {
-        context.logger.debug(`[Step] Validating output for step '${stepDef.id}' against schema`);
-        if (stepDef.outputSchema.type === "object") {
-          if (typeof result !== "object" || result === null || Array.isArray(result)) {
-            throw new Error(`Expected object output, got ${Array.isArray(result) ? "array" : result === null ? "null" : typeof result}`);
-          }
-        }
-        if (stepDef.outputSchema.type === "array" && !Array.isArray(result)) {
-          throw new Error(`Expected array output, got ${typeof result}`);
-        }
-      }
+      context.logger.debug(`[Step] Validating output for step '${stepDef.id}' against schema`);
+      const zodSchema = convertJsonSchemaToZod(stepDef.outputSchema);
+      const validationResult = zodSchema.safeParse(result);
+      if (!validationResult.success) {
+        const errorDetails = validationResult.error.issues.map((e) => `  - ${e.path.join(".") || "root"}: ${e.message}`).join("\n");
+        throw new Error(`Output does not match expected schema:
+${errorDetails}`);
+      }
+      context.logger.debug(`[Step] Output validation successful for step '${stepDef.id}'`);
     } catch (error) {
       throw new Error(
         `Step '${stepDef.id}' in workflow '${workflowId}' output validation failed: ${error instanceof Error ? error.message : String(error)}`
@@ -2192,6 +2965,204 @@ async function executeStep(stepDef, workflowId, input, state, context, options,
   }
   return result;
 }
+function isBreakStep(step) {
+  return typeof step === "object" && step !== null && "break" in step && step.break === true;
+}
+function isContinueStep(step) {
+  return typeof step === "object" && step !== null && "continue" in step && step.continue === true;
+}
+function isWhileLoopStep(step) {
+  return typeof step === "object" && step !== null && "while" in step;
+}
+function isIfElseStep(step) {
+  return typeof step === "object" && step !== null && "if" in step;
+}
+function isTryCatchStep(step) {
+  return typeof step === "object" && step !== null && "try" in step;
+}
+function storeStepOutput(step, result, state) {
+  if ("id" in step && step.output) {
+    const outputKey = step.output;
+    state[outputKey] = result;
+  }
+}
+function getStepId(step) {
+  if ("id" in step && step.id) {
+    return step.id;
+  }
+  if (isWhileLoopStep(step)) {
+    return "while";
+  }
+  if (isIfElseStep(step)) {
+    return "if";
+  }
+  if (isTryCatchStep(step)) {
+    return "try";
+  }
+  return "control";
+}
+async function executeControlFlowStep(step, workflowId, input, state, context, options, runInternal, loopDepth, breakFlag, continueFlag) {
+  if (isBreakStep(step)) {
+    if (loopDepth === 0) {
+      throw new Error(`'break' statement found outside of a loop in workflow '${workflowId}'`);
+    }
+    context.logger.debug(`[ControlFlow] Executing break statement (loop depth: ${loopDepth})`);
+    return { result: void 0, shouldBreak: true, shouldContinue: false };
+  }
+  if (isContinueStep(step)) {
+    if (loopDepth === 0) {
+      throw new Error(`'continue' statement found outside of a loop in workflow '${workflowId}'`);
+    }
+    context.logger.debug(`[ControlFlow] Executing continue statement (loop depth: ${loopDepth})`);
+    return { result: void 0, shouldBreak: false, shouldContinue: true };
+  }
+  if (isWhileLoopStep(step)) {
+    context.logger.info(`[ControlFlow] Executing while loop '${step.id}'`);
+    context.logger.debug(`[ControlFlow] Condition: ${step.while.condition}`);
+    context.logger.debug(`[ControlFlow] Loop body has ${step.while.steps.length} step(s)`);
+    let iterationCount = 0;
+    let loopResult;
+    while (true) {
+      iterationCount++;
+      if (iterationCount > MAX_WHILE_LOOP_ITERATIONS) {
+        throw new Error(
+          `While loop '${step.id}' in workflow '${workflowId}' exceeded maximum iteration limit of ${MAX_WHILE_LOOP_ITERATIONS}`
+        );
+      }
+      const conditionResult = evaluateCondition(step.while.condition, input, state, options.allowUnsafeCodeExecution);
+      context.logger.debug(`[ControlFlow] While loop '${step.id}' iteration ${iterationCount}: condition = ${conditionResult}`);
+      if (!conditionResult) {
+        context.logger.info(`[ControlFlow] While loop '${step.id}' terminated after ${iterationCount - 1} iteration(s)`);
+        break;
+      }
+      for (const bodyStep of step.while.steps) {
+        const { result, shouldBreak, shouldContinue } = await executeControlFlowStep(
+          bodyStep,
+          workflowId,
+          input,
+          state,
+          context,
+          options,
+          runInternal,
+          loopDepth + 1,
+          breakFlag,
+          continueFlag
+        );
+        if (shouldBreak) {
+          context.logger.debug(`[ControlFlow] Breaking from while loop '${step.id}'`);
+          breakFlag.value = false;
+          return { result: loopResult, shouldBreak: false, shouldContinue: false };
+        }
+        if (shouldContinue) {
+          context.logger.debug(`[ControlFlow] Continuing to next iteration of while loop '${step.id}'`);
+          continueFlag.value = false;
+          break;
+        }
+        storeStepOutput(bodyStep, result, state);
+        loopResult = result;
+      }
+    }
+    const outputKey = step.output ?? step.id;
+    state[outputKey] = loopResult;
+    context.logger.debug(`[ControlFlow] While loop '${step.id}' stored output as '${outputKey}'`);
+    return { result: loopResult, shouldBreak: false, shouldContinue: false };
+  }
+  if (isIfElseStep(step)) {
+    const ifStep = step;
+    context.logger.info(`[ControlFlow] Executing if/else branch '${ifStep.id}'`);
+    context.logger.debug(`[ControlFlow] Condition: ${ifStep.if.condition}`);
+    context.logger.debug(`[ControlFlow] Then branch has ${ifStep.if.thenBranch.length} step(s)`);
+    if (ifStep.if.elseBranch) {
+      context.logger.debug(`[ControlFlow] Else branch has ${ifStep.if.elseBranch.length} step(s)`);
+    }
+    const conditionResult = evaluateCondition(ifStep.if.condition, input, state, options.allowUnsafeCodeExecution);
+    context.logger.debug(`[ControlFlow] If/else '${ifStep.id}' condition = ${conditionResult}`);
+    const branchSteps = conditionResult ? ifStep.if.thenBranch : ifStep.if.elseBranch ?? [];
+    const branchName = conditionResult ? "then" : ifStep.if.elseBranch ? "else" : "else (empty)";
+    context.logger.info(`[ControlFlow] Taking '${branchName}' branch of '${ifStep.id}'`);
+    let branchResult;
+    for (const branchStep of branchSteps) {
+      const { result, shouldBreak, shouldContinue } = await executeControlFlowStep(
+        branchStep,
+        workflowId,
+        input,
+        state,
+        context,
+        options,
+        runInternal,
+        loopDepth,
+        breakFlag,
+        continueFlag
+      );
+      if (shouldBreak || shouldContinue) {
+        return { result, shouldBreak, shouldContinue };
+      }
+      storeStepOutput(branchStep, result, state);
+      branchResult = result;
+    }
+    const outputKey = ifStep.output ?? ifStep.id;
+    state[outputKey] = branchResult;
+    context.logger.debug(`[ControlFlow] If/else '${ifStep.id}' stored output as '${outputKey}'`);
+    return { result: branchResult, shouldBreak: false, shouldContinue: false };
+  }
+  if (isTryCatchStep(step)) {
+    const tryStep = step;
+    context.logger.info(`[ControlFlow] Executing try/catch block '${tryStep.id}'`);
+    context.logger.debug(`[ControlFlow] Try block has ${tryStep.try.trySteps.length} step(s)`);
+    context.logger.debug(`[ControlFlow] Catch block has ${tryStep.try.catchSteps.length} step(s)`);
+    let tryResult;
+    let caughtError;
+    try {
+      for (const tryStepItem of tryStep.try.trySteps) {
+        const { result } = await executeControlFlowStep(
+          tryStepItem,
+          workflowId,
+          input,
+          state,
+          context,
+          options,
+          runInternal,
+          loopDepth,
+          breakFlag,
+          continueFlag
+        );
+        storeStepOutput(tryStepItem, result, state);
+        tryResult = result;
+      }
+      const outputKey = tryStep.output ?? tryStep.id;
+      state[outputKey] = tryResult;
+      context.logger.debug(`[ControlFlow] Try/catch '${tryStep.id}' completed successfully`);
+      return { result: tryResult, shouldBreak: false, shouldContinue: false };
+    } catch (error) {
+      caughtError = error instanceof Error ? error : new Error(String(error));
+      context.logger.warn(`[ControlFlow] Try/catch '${tryStep.id}' caught error: ${caughtError.message}`);
+      let catchResult;
+      for (const catchStepItem of tryStep.try.catchSteps) {
+        const { result } = await executeControlFlowStep(
+          catchStepItem,
+          workflowId,
+          input,
+          state,
+          context,
+          options,
+          runInternal,
+          loopDepth,
+          breakFlag,
+          continueFlag
+        );
+        storeStepOutput(catchStepItem, result, state);
+        catchResult = result;
+      }
+      const outputKey = tryStep.output ?? tryStep.id;
+      state[outputKey] = catchResult;
+      context.logger.debug(`[ControlFlow] Try/catch '${tryStep.id}' caught error and executed catch block`);
+      return { result: catchResult, shouldBreak: false, shouldContinue: false };
+    }
+  }
+  const stepDef = step;
+  const stepResult = await executeStep(stepDef, workflowId, input, state, context, options, runInternal);
+  return { result: stepResult, shouldBreak: false, shouldContinue: false };
+}
 function createDynamicWorkflow(definition, options = {}) {
   if (typeof definition === "string") {
     const res = parseDynamicWorkflowDefinition(definition);
@@ -2200,36 +3171,49 @@ function createDynamicWorkflow(definition, options = {}) {
     }
     definition = res.definition;
   }
-  const compiledSteps = /* @__PURE__ */ new Map();
   const runInternal = async (workflowId, input, context, inheritedState) => {
     const workflow = definition.workflows[workflowId];
     if (!workflow) {
+      const builtIn = options.builtInWorkflows?.[workflowId];
+      if (builtIn) {
+        context.logger.info(`[Workflow] Delegating to built-in workflow '${workflowId}'`);
+        return await builtIn(input, context);
+      }
       throw new Error(`Workflow '${workflowId}' not found`);
     }
     const validatedInput = validateAndApplyDefaults(workflowId, workflow, input);
     context.logger.info(`[Workflow] Starting workflow '${workflowId}'`);
     context.logger.debug(`[Workflow] Input: ${JSON.stringify(validatedInput)}`);
     context.logger.debug(`[Workflow] Inherited state: ${JSON.stringify(inheritedState)}`);
-    context.logger.debug(`[Workflow] Steps: ${workflow.steps.map((s) => s.id).join(", ")}`);
+    context.logger.debug(`[Workflow] Steps: ${workflow.steps.map((s) => "id" in s ? s.id : "<control flow>").join(", ")}`);
     const state = { ...inheritedState };
     let lastOutput;
+    const breakFlag = { value: false };
+    const continueFlag = { value: false };
     for (let i = 0; i < workflow.steps.length; i++) {
       const stepDef = workflow.steps[i];
-      const stepName = `${workflowId}.${stepDef.id}`;
-      context.logger.info(`[Workflow] Step ${i + 1}/${workflow.steps.length}: ${stepDef.id}`);
-      context.logger.debug(`[Workflow] Step task: ${stepDef.task}`);
-      if (stepDef.expected_outcome) {
-        context.logger.debug(`[Workflow] Expected outcome: ${stepDef.expected_outcome}`);
-      }
-      context.logger.debug(`[Workflow] Current state keys: ${Object.keys(state).join(", ")}`);
-      lastOutput = await context.step(stepName, async () => {
-        return await executeStep(stepDef, workflowId, validatedInput, state, context, options, compiledSteps, runInternal);
-      });
-      const outputKey = stepDef.output ?? stepDef.id;
-      state[outputKey] = lastOutput;
-      context.logger.debug(
-        `[Workflow] Step output stored as '${outputKey}': ${typeof lastOutput === "object" ? JSON.stringify(lastOutput).substring(0, 200) : lastOutput}`
+      const stepId = getStepId(stepDef);
+      context.logger.info(`[Workflow] Step ${i + 1}/${workflow.steps.length}: ${stepId}`);
+      const { result } = await executeControlFlowStep(
+        stepDef,
+        workflowId,
+        validatedInput,
+        state,
+        context,
+        options,
+        runInternal,
+        0,
+        // loop depth
+        breakFlag,
+        continueFlag
       );
+      lastOutput = result;
+      storeStepOutput(stepDef, result, state);
+      if ("id" in stepDef && stepDef.output) {
+        context.logger.debug(
+          `[Workflow] Step output stored as '${stepDef.output}': ${typeof lastOutput === "object" ? JSON.stringify(lastOutput).substring(0, 200) : lastOutput}`
+        );
+      }
     }
     context.logger.info(`[Workflow] Completed workflow '${workflowId}'`);
     if (workflow.output) {
@@ -2244,595 +3228,6 @@ function createDynamicWorkflow(definition, options = {}) {
   };
 }
 
-// src/workflow/dynamic-generator.workflow.ts
-import { z as z23 } from "zod";
-var GenerateWorkflowDefinitionInputSchema = z23.object({
-  prompt: z23.string(),
-  availableTools: z23.array(
-    z23.object({
-      name: z23.string(),
-      description: z23.string()
-    })
-  ).optional()
-});
-var GenerateWorkflowCodeInputSchema = z23.object({
-  workflow: WorkflowFileSchema
-});
-var WORKFLOW_DEFINITION_SYSTEM_PROMPT = `You are an expert workflow architect.
-Your task is to create a JSON workflow definition based on the user's request.
-
-The workflow definition must follow this structure:
-{
-  "workflows": {
-    "workflowName": {
-      "task": "Description of the workflow",
-      "inputs": [
-        { "id": "inputName", "description": "Description", "default": "optionalDefault" }
-      ],
-      "steps": [
-        {
-          "id": "stepId",
-          "task": "Description of the step",
-          "tools": ["toolName1", "toolName2"], // Optional: restrict which tools can be used
-          "output": "outputVariableName", // Optional: defaults to step id
-          "timeout": 30000, // Optional: timeout in milliseconds
-          "expected_outcome": "What this step produces", // Optional: documentation
-          "outputSchema": { "type": "object" } // Optional: validation schema
-        }
-      ],
-      "output": "outputVariableName" // Optional
-    }
-  }
-}
-
-Constraints:
-- You MUST always include a workflow named 'main'. This is the entry point.
-- The 'main' workflow input must be either empty (no input) or a single string input.
-- Break down complex tasks into logical steps.
-- Define clear inputs and outputs.
-
-Quality Guidelines:
-- Add "timeout" field (in milliseconds) for steps that might take long (file I/O, API calls, searches)
-- Use "expected_outcome" field to document what each step should produce
-- Use descriptive step IDs (e.g., "validateInput", "fetchUserData", not "step1", "step2")
-- Design steps to be focused - one responsibility per step
-- For steps that process multiple items, consider creating a sub-workflow
-- Add "outputSchema" with type information for validation-critical steps
-- Order steps logically with clear data flow
-
-Example 1:
-User: "Research a topic and summarize it."
-Output:
-\`\`\`json
-{
-  "workflows": {
-    "main": {
-      "task": "Research a topic and provide a summary",
-      "inputs": [
-        { "id": "topic", "description": "The topic to research" }
-      ],
-      "steps": [
-        {
-          "id": "search",
-          "task": "Search for information about the topic",
-          "tools": ["search"],
-          "output": "searchResults"
-        },
-        {
-          "id": "summarize",
-          "task": "Summarize the search results",
-          "tools": ["generateText"],
-          "output": "summary"
-        }
-      ],
-      "output": "summary"
-    }
-  }
-}
-\`\`\`
-
-Example 2:
-User: "Review urgent PRs. For each PR, run the review workflow."
-Output:
-\`\`\`json
-{
-  "workflows": {
-    "main": {
-      "task": "Fetch urgent PRs and review them",
-      "inputs": [],
-      "steps": [
-        {
-          "id": "fetchPRs",
-          "task": "Fetch list of urgent PRs",
-          "tools": ["github_list_prs"],
-          "output": "prs"
-        },
-        {
-          "id": "reviewEachPR",
-          "task": "Run review workflow for each PR",
-          "tools": [],
-          "output": "reviews"
-        }
-      ],
-      "output": "reviews"
-    },
-    "reviewPR": {
-      "task": "Review a single PR",
-      "inputs": [
-        { "id": "prId", "description": "ID of the PR to review" }
-      ],
-      "steps": [
-        {
-          "id": "getDiff",
-          "task": "Get PR diff",
-          "tools": ["github_get_diff"],
-          "output": "diff"
-        },
-        {
-          "id": "analyze",
-          "task": "Analyze the diff",
-          "tools": ["generateText"],
-          "output": "analysis"
-        }
-      ],
-      "output": "analysis"
-    }
-  }
-}
-\`\`\`
-`;
-var WORKFLOW_CODE_SYSTEM_PROMPT = `You are an expert TypeScript developer.
-Your task is to implement the TypeScript code for the steps in the provided workflow definition.
-
-You will receive a JSON workflow definition where the "code" field is null.
-You must fill in the "code" field for each step with valid TypeScript code.
-
-CRITICAL: Each step "code" field must contain ONLY the function body statements (the code inside the curly braces).
-DO NOT include function declaration, arrow function syntax, async keyword, parameter list, or outer curly braces.
-
-The code will be wrapped automatically in: \`async (ctx) => { YOUR_CODE_HERE }\`
-
-Example of CORRECT code field:
-	\`\`\`ts
-	const result = await ctx.tools.readFile({ path: 'README.md' })
-	if (!result) throw new Error('File not found')
-	return result
-	\`\`\`
-
-Example of INCORRECT code field (DO NOT DO THIS):
-	\`\`\`ts
-	async (ctx) => {
-	  const result = await ctx.tools.readFile({ path: 'README.md' })
-	  return result
-	}
-	\`\`\`
-
-Example of INCORRECT code field (DO NOT DO THIS):
-	\`\`\`ts
-	(ctx) => {
-	  return 'hello'
-	}
-	\`\`\`
-
-	## Runtime context (ctx)
-	\`\`\`ts
-	// Runtime types (for reference)
-	type Logger = {
-	  debug: (...args: any[]) => void
-	  info: (...args: any[]) => void
-	  warn: (...args: any[]) => void
-	  error: (...args: any[]) => void
-	}
-
-	type StepFn = {
-	  <T>(name: string, fn: () => Promise<T>): Promise<T>
-	  <T>(name: string, options: { retry?: number }, fn: () => Promise<T>): Promise<T>
-	}
-
-	type JsonModelMessage = { role: 'system' | 'user' | 'assistant' | 'tool'; content: any }
-	type JsonResponseMessage = { role: 'assistant' | 'tool'; content: any }
-	type ToolSet = Record<string, any>
-
-	type ToolResponseResult =
-	  | { type: 'text'; value: string }
-	  | { type: 'json'; value: any }
-	  | { type: 'error-text'; value: string }
-	  | { type: 'error-json'; value: any }
-	  | { type: 'content'; value: any[] }
-
-	type AgentToolResponse =
-	  | { type: 'Reply'; message: ToolResponseResult }
-	  | { type: 'Exit'; message: string; object?: any }
-	  | { type: 'Error'; message: ToolResponseResult }
-
-	type ExitReason =
-	  | { type: 'UsageExceeded' }
-	  | { type: 'Exit'; message: string; object?: any }
-	  | { type: 'Error'; error: { message: string; stack?: string } }
-
-	type FullAgentToolInfo = { name: string; description: string; parameters: any; handler: any }
-
-	// Tools available on ctx.tools in dynamic steps
-	type DynamicWorkflowTools = {
-	  // LLM + agent helpers
-	  generateText: (input: { messages: JsonModelMessage[]; tools: ToolSet }) => Promise<JsonResponseMessage[]>
-	  runAgent: (input: {
-	    tools: Readonly<FullAgentToolInfo[]>
-	    maxToolRoundTrips?: number
-	    userMessage: readonly JsonModelMessage[]
-	  } & ({ messages: JsonModelMessage[] } | { systemPrompt: string })) => Promise<ExitReason>
-
-	  // Generic bridge to "agent tools" by name
-	  invokeTool: (input: { toolName: string; input: any }) => Promise<AgentToolResponse>
-
-	  // File + command helpers (direct)
-	  readFile: (input: { path: string }) => Promise<string | null>
-	  writeToFile: (input: { path: string; content: string }) => Promise<void>
-	  executeCommand: (input: { command: string; pipe?: boolean } & ({ args: string[]; shell?: false } | { shell: true })) => Promise<{
-	    exitCode: number
-	    stdout: string
-	    stderr: string
-	  }>
-
-	  // CLI UX helpers
-	  confirm: (input: { message: string }) => Promise<boolean>
-	  input: (input: { message: string; default?: string }) => Promise<string>
-	  select: (input: { message: string; choices: { name: string; value: string }[] }) => Promise<string>
-	}
-
-	type DynamicStepRuntimeContext = {
-	  workflowId: string
-	  stepId: string
-	  input: Record<string, any>
-	  state: Record<string, any>
-	  tools: DynamicWorkflowTools
-	  logger: Logger
-	  step: StepFn
-	  runWorkflow: (workflowId: string, input?: Record<string, any>) => Promise<any>
-	  toolInfo?: ReadonlyArray<FullAgentToolInfo>
-	}
-	\`\`\`
-
-- \`ctx.input\`: workflow inputs (read-only).
-- \`ctx.state\`: shared state between steps (previous step outputs are stored here).
-- \`ctx.tools\`: async tool functions. Call tools as \`await ctx.tools.someTool({ ... })\`.
-- \`ctx.runWorkflow\`: run a sub-workflow by id.
-
-	## Guidelines
-	- Use \`await\` for all async operations.
-	- Return the output value for the step (this becomes the step output).
-	- Access inputs via \`ctx.input.<inputId>\`.
-	- Access previous step outputs via \`ctx.state.<stepOutputKey>\` (defaults to the step \`output\` or \`id\`).
-
-	## Quality Guidelines for Code Implementation
-
-	### Error Handling
-	- ALWAYS validate inputs at the start of steps
-	- Use try-catch for operations that might fail (file I/O, parsing, API calls)
-	- Preserve stack traces: re-throw original errors rather than creating new ones
-	- Use error type guards: \`const err = error instanceof Error ? error : new Error(String(error))\`
-	- Check for null/undefined before using values
-	- Handle edge cases (empty arrays, missing files, invalid data)
-
-	### Logging
-	- Use \`ctx.logger.info()\` for important progress updates
-	- Use \`ctx.logger.debug()\` for detailed information
-	- Use \`ctx.logger.warn()\` for recoverable issues
-	- Use \`ctx.logger.error()\` before throwing errors
-	- Log when starting and completing significant operations
-	- Use template literals for readability: \`ctx.logger.info(\\\`Processing \${items.length} items...\\\`)\`
-
-	### User Experience
-	- Provide progress feedback for long operations
-	- Return structured data (objects/arrays), not strings when possible
-	- Include helpful metadata in results (counts, timestamps, status)
-	- For batch operations, report progress: \`Processed 5/10 items\`
-
-	### Data Validation
-	- Validate required fields exist before accessing
-	- Check data types match expectations
-	- Validate array lengths before iteration
-	- Example: \`if (!data?.users || !Array.isArray(data.users)) throw new Error('Invalid data format')\`
-
-	### Best Practices
-	- Use meaningful variable names
-	- Avoid nested callbacks - use async/await
-	- Clean up resources (close files, clear timeouts)
-	- Return consistent data structures across similar steps
-	- For iteration, consider batching or rate limiting
-
-	### When to Simplify
-	- Simple transformation steps (e.g., formatting strings) need only basic error handling
-	- Internal sub-workflow steps with validated inputs from parent can skip redundant validation
-	- Minimal logging is fine for fast steps (<100ms) that don't perform I/O or external calls
-	- Use judgment: match error handling complexity to the step's failure risk and impact
-
-	## Tool calling examples (every tool)
-
-	### Direct ctx.tools methods
-	\`\`\`ts
-	// readFile
-	const readme = await ctx.tools.readFile({ path: 'README.md' })
-	if (readme == null) throw new Error('README.md not found')
-
-	// writeToFile
-	await ctx.tools.writeToFile({ path: 'notes.txt', content: 'hello\\n' })
-
-	// executeCommand (args form)
-	const rg = await ctx.tools.executeCommand({ command: 'rg', args: ['-n', 'TODO', '.'] })
-	if (rg.exitCode !== 0) throw new Error(rg.stderr)
-
-	// executeCommand (shell form)
-	await ctx.tools.executeCommand({ command: 'ls -la', shell: true, pipe: true })
-
-	// generateText (LLM call; pass tools: {})
-	const msgs = await ctx.tools.generateText({
-	  messages: [
-	    { role: 'system', content: 'Summarize the following text.' },
-	    { role: 'user', content: readme },
-	  ],
-	  tools: {},
-	})
-	const last = msgs[msgs.length - 1]
-	const lastText = typeof last?.content === 'string' ? last.content : JSON.stringify(last?.content)
-
-	// runAgent (nested agent; use ctx.toolInfo as the tool list)
-	const agentRes = await ctx.tools.runAgent({
-	  systemPrompt: 'You are a helpful assistant.',
-	  userMessage: [{ role: 'user', content: 'Summarize README.md in 3 bullets.' }],
-	  tools: (ctx.toolInfo ?? []) as any,
-	})
-	if (agentRes.type !== 'Exit') throw new Error('runAgent failed')
-
-	// confirm / input / select (interactive)
-	const ok = await ctx.tools.confirm({ message: 'Proceed?' })
-	const name = await ctx.tools.input({ message: 'Name?', default: 'main' })
-	const flavor = await ctx.tools.select({
-	  message: 'Pick one',
-	  choices: [
-	    { name: 'A', value: 'a' },
-	    { name: 'B', value: 'b' },
-	  ],
-	})
-
-	\`\`\`
-
-	### Agent tools via ctx.tools.invokeTool (toolName examples)
-	\`\`\`ts
-	// Helper to unwrap a successful tool reply
-	function unwrapToolValue(resp: any) {
-	  if (!resp || resp.type !== 'Reply') {
-	    const msg = resp?.message?.value
-	    throw new Error(typeof msg === 'string' ? msg : JSON.stringify(resp))
-	  }
-	  return resp.message.value
-	}
-
-	// askFollowupQuestion
-	const answersText = unwrapToolValue(
-	  await ctx.tools.invokeTool({
-	    toolName: 'askFollowupQuestion',
-	    input: { questions: [{ prompt: 'Which directory?', options: ['src', 'packages'] }] },
-	  }),
-	)
-
-	// listFiles
-	const filesText = unwrapToolValue(
-	  await ctx.tools.invokeTool({
-	    toolName: 'listFiles',
-	    input: { path: 'src', recursive: true, maxCount: 2000, includeIgnored: false },
-	  }),
-	)
-
-	// searchFiles
-	const hitsText = unwrapToolValue(
-	  await ctx.tools.invokeTool({
-	    toolName: 'searchFiles',
-	    input: { path: '.', regex: 'generateWorkflowCodeWorkflow', filePattern: '*.ts' },
-	  }),
-	)
-
-	// fetchUrl
-	const pageText = unwrapToolValue(await ctx.tools.invokeTool({ toolName: 'fetchUrl', input: { url: 'https://example.com' } }))
-
-	// search (web search)
-	const webResults = unwrapToolValue(
-	  await ctx.tools.invokeTool({ toolName: 'search', input: { query: 'TypeScript zod schema examples' } }),
-	)
-
-	// executeCommand (provider-backed; may require approval in some environments)
-	const cmdText = unwrapToolValue(
-	  await ctx.tools.invokeTool({ toolName: 'executeCommand', input: { command: 'bun test', requiresApproval: false } }),
-	)
-
-	// readFile / writeToFile (provider-backed)
-	const fileText = unwrapToolValue(
-	  await ctx.tools.invokeTool({ toolName: 'readFile', input: { path: 'README.md', includeIgnored: false } }),
-	)
-	const writeText = unwrapToolValue(await ctx.tools.invokeTool({ toolName: 'writeToFile', input: { path: 'out.txt', content: 'hi' } }))
-
-	// replaceInFile
-	const diff = ['<<<<<<< SEARCH', 'old', '=======', 'new', '>>>>>>> REPLACE'].join('\\n')
-	const replaceText = unwrapToolValue(await ctx.tools.invokeTool({ toolName: 'replaceInFile', input: { path: 'out.txt', diff } }))
-
-	// removeFile / renameFile
-	const rmText = unwrapToolValue(await ctx.tools.invokeTool({ toolName: 'removeFile', input: { path: 'out.txt' } }))
-	const mvText = unwrapToolValue(
-	  await ctx.tools.invokeTool({ toolName: 'renameFile', input: { source_path: 'a.txt', target_path: 'b.txt' } }),
-	)
-
-	// readBinaryFile (returns { type: 'content', value: [...] } in resp.message)
-	const binResp = await ctx.tools.invokeTool({ toolName: 'readBinaryFile', input: { url: 'file://path/to/image.png' } })
-	\`\`\`
-
-	### Sub-workflow example (ctx.runWorkflow)
-	\`\`\`ts
-	const results: any[] = []
-	for (const pr of ctx.state.prs ?? []) {
-	  results.push(await ctx.runWorkflow('reviewPR', { prId: pr.id }))
-	}
-	return results
-	\`\`\`
-
-	## Complete Example: High-Quality Step Implementation
-
-	This example demonstrates all quality guidelines in a single step:
-
-	\`\`\`ts
-	// Step: processUserData
-	// Task: Read, validate, and process user data from a file
-
-	// Input validation
-	if (!ctx.input.dataFile) {
-	  throw new Error('Missing required input: dataFile')
-	}
-
-	ctx.logger.info(\`Starting user data processing for: \${ctx.input.dataFile}\`)
-
-	// Read file with error handling
-	let rawData
-	try {
-	  ctx.logger.debug(\`Reading file: \${ctx.input.dataFile}\`)
-	  rawData = await ctx.tools.readFile({ path: ctx.input.dataFile })
-
-	  if (!rawData) {
-	    throw new Error(\`File not found or empty: \${ctx.input.dataFile}\`)
-	  }
-	} catch (error) {
-	  const err = error instanceof Error ? error : new Error(String(error))
-	  ctx.logger.error(\`Failed to read file: \${err.message}\`)
-	  throw err  // Preserve original stack trace
-	}
-
-	// Parse and validate data
-	let users
-	try {
-	  ctx.logger.debug('Parsing JSON data')
-	  const parsed = JSON.parse(rawData)
-
-	  if (!parsed?.users || !Array.isArray(parsed.users)) {
-	    throw new Error('Invalid data format: expected {users: [...]}')
-	  }
-
-	  users = parsed.users
-	  ctx.logger.info(\`Found \${users.length} users to process\`)
-	} catch (error) {
-	  const err = error instanceof Error ? error : new Error(String(error))
-	  ctx.logger.error(\`Data parsing failed: \${err.message}\`)
-	  throw err  // Preserve original stack trace
-	}
-
-	// Process each user with progress reporting
-	const results = []
-	for (let i = 0; i < users.length; i++) {
-	  const user = users[i]
-
-	  // Validate each user object
-	  if (!user?.id || !user?.email) {
-	    ctx.logger.warn(\`Skipping invalid user at index \${i}: missing id or email\`)
-	    continue
-	  }
-
-	  // Process user
-	  const processed = {
-	    id: user.id,
-	    email: user.email.toLowerCase().trim(),
-	    name: user.name?.trim() || 'Unknown',
-	    processedAt: new Date().toISOString(),
-	    status: 'active'
-	  }
-
-	  results.push(processed)
-
-	  // Progress feedback every 10 items
-	  if ((i + 1) % 10 === 0) {
-	    ctx.logger.info(\`Processed \${i + 1}/\${users.length} users\`)
-	  }
-	}
-
-	ctx.logger.info(\`Successfully processed \${results.length}/\${users.length} users\`)
-
-	// Return structured result with metadata
-	return {
-	  users: results,
-	  metadata: {
-	    totalInput: users.length,
-	    totalProcessed: results.length,
-	    skipped: users.length - results.length,
-	    processedAt: new Date().toISOString()
-	  }
-	}
-	\`\`\`
-
-	Key features demonstrated:
-	- Input validation at start
-	- Comprehensive error handling with try-catch that preserves stack traces
-	- Logging at info, debug, warn, and error levels
-	- Progress reporting for long operations (every 10 items)
-	- Data validation throughout (null checks, type checks, array validation)
-	- Structured return value with metadata for observability
-	- Descriptive error messages with context
-	- Meaningful variable names (rawData, users, processed)
-	- Clean async/await usage
-	- Template literals for readable string interpolation
-	- Proper error type guards (error instanceof Error)
-
-	## Final Instructions
-
-	REMEMBER: The "code" field must be ONLY the function body statements.
-	- DO NOT wrap code in arrow functions: \`(ctx) => { ... }\`
-	- DO NOT wrap code in async functions: \`async (ctx) => { ... }\`
-	- DO NOT include outer curly braces
-	- DO include a return statement if the step should produce output
-	- Each "code" field should be a string containing multiple statements separated by newlines
-
-	Return the complete workflow JSON with the "code" fields populated.
-	`;
-var generateWorkflowDefinitionWorkflow = async (input, ctx) => {
-  let systemPrompt = WORKFLOW_DEFINITION_SYSTEM_PROMPT;
-  if (input.availableTools && input.availableTools.length > 0) {
-    const toolsList = input.availableTools.map((t) => `- ${t.name}: ${t.description}`).join("\n");
-    systemPrompt += `
-
-Available Tools:
-${toolsList}
-
-Use these tools when appropriate.`;
-  }
-  const result = await ctx.step("generate-workflow-definition", async () => {
-    return agentWorkflow(
-      {
-        systemPrompt,
-        userMessage: [{ role: "user", content: input.prompt }],
-        tools: [],
-        outputSchema: WorkflowFileSchema
-      },
-      ctx
-    );
-  });
-  if (result.type === "Exit" && result.object) {
-    return result.object;
-  }
-  throw new Error("Failed to generate workflow definition");
-};
-var generateWorkflowCodeWorkflow = async (input, ctx) => {
-  const result = await ctx.step("generate-workflow-code", async () => {
-    return agentWorkflow(
-      {
-        systemPrompt: WORKFLOW_CODE_SYSTEM_PROMPT,
-        userMessage: [{ role: "user", content: JSON.stringify(input.workflow, null, 2) }],
-        tools: [],
-        outputSchema: WorkflowFileSchema
-      },
-      ctx
-    );
-  });
-  if (result.type === "Exit" && result.object) {
-    return result.object;
-  }
-  throw new Error("Failed to generate workflow code");
-};
-
 // src/workflow/json-ai-types.ts
 var toJsonDataContent = (data) => {
   if (data instanceof URL) {
@@ -3031,16 +3426,35 @@ var makeStepFn = () => {
   };
 };
 export {
-  GenerateWorkflowCodeInputSchema,
-  GenerateWorkflowDefinitionInputSchema,
+  BreakStepSchema,
+  ContinueStepSchema,
+  IGNORED_DIRECTORIES,
+  IfElseStepSchema,
+  ListSkillsInputSchema,
+  ListSkillsOutputSchema,
+  LoadSkillInputSchema,
+  LoadSkillOutputSchema,
   MockProvider,
+  NodeFileSystemProvider,
+  ReadSkillFileInputSchema,
+  ReadSkillFileOutputSchema,
+  SKILL_ERROR_MESSAGES,
+  SKILL_LIMITS,
+  SOURCE_ICONS,
+  SUSPICIOUS_PATTERNS,
+  SkillDiscoveryError,
+  SkillDiscoveryService,
+  SkillValidationError,
+  TOOL_GROUPS,
   TaskEventKind,
   TodoItemSchema,
   TodoStatus,
-  ToolResponseType,
+  TryCatchStepSchema,
   UpdateTodoItemInputSchema,
   UpdateTodoItemOutputSchema,
   UsageMeter,
+  WhileLoopStepSchema,
+  WorkflowControlFlowStepSchema,
   WorkflowDefinitionSchema,
   WorkflowFileSchema,
   WorkflowInputDefinitionSchema,
@@ -3054,29 +3468,36 @@ export {
   executeCommand_default as executeCommand,
   fetchUrl_default as fetchUrl,
   fromJsonModelMessage,
-  generateWorkflowCodeWorkflow,
-  generateWorkflowDefinitionWorkflow,
-  getTodoItem_default as getTodoItem,
+  getSkillStats,
   listFiles_default as listFiles,
-  listMemoryTopics_default as listMemoryTopics,
-  listTodoItems_default as listTodoItems,
+  listSkills,
+  listSkillsToolInfo,
+  loadSkill,
+  loadSkillToolInfo,
   makeStepFn,
+  mcpServerConfigSchema,
   parseDynamicWorkflowDefinition,
   parseJsonFromMarkdown,
+  providerConfigSchema,
   providerModelSchema,
   readBinaryFile_default as readBinaryFile,
   readFile_default as readFile,
-  readMemory_default as readMemory,
+  readSkillFile,
+  readSkillFileToolInfo,
   removeFile_default as removeFile,
   renameFile_default as renameFile,
   replaceInFile_default as replaceInFile,
   replaceInFile as replaceInFileHelper,
   responsePrompts,
   ruleSchema,
+  scriptSchema,
   search_default as search,
   searchFiles_default as searchFiles,
+  skillMetadataSchema,
   toJsonModelMessage,
-  updateMemory_default as updateMemory,
-  updateTodoItem_default as updateTodoItem,
+  validateSkillMetadata,
+  validateSkillReferences,
+  validateSkillSecurity,
+  validateWorkflowFile,
   writeToFile_default as writeToFile
 };