@polka-codes/core 0.9.79 → 0.9.81

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,13 @@ var ruleSchema = z.union([
     branch: z.string().optional()
   }).strict()
 ]);
+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 configSchema = z.object({
   prices: z.record(
     z.string(),
@@ -196,14 +197,6 @@ var configSchema = z.object({
   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/tools/askFollowupQuestion.ts
 import { z as z2 } from "zod";
 var questionObject = z2.object({
@@ -263,7 +256,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 +266,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 +282,7 @@ ${answer}
 </ask_followup_question_answer>`);
   }
   return {
-    type: "Reply" /* Reply */,
+    success: true,
     message: {
       type: "text",
       value: answers.join("\n")
@@ -333,7 +326,7 @@ var toolInfo2 = {
 var handler2 = async (provider, args) => {
   if (!provider.executeCommand) {
     return {
-      type: "Error" /* Error */,
+      success: false,
       message: {
         type: "error-text",
         value: "Not possible to execute command. Abort."
@@ -362,7 +355,7 @@ ${result.stderr}
     }
     if (result.exitCode === 0) {
       return {
-        type: "Reply" /* Reply */,
+        success: true,
         message: {
           type: "text",
           value: message
@@ -370,7 +363,7 @@ ${result.stderr}
       };
     }
     return {
-      type: "Error" /* Error */,
+      success: false,
       message: {
         type: "error-text",
         value: message
@@ -378,7 +371,7 @@ ${result.stderr}
     };
   } catch (error) {
     return {
-      type: "Error" /* Error */,
+      success: false,
       message: {
         type: "error-text",
         value: error instanceof Error ? error.message : String(error)
@@ -428,7 +421,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 +431,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 +450,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 +462,30 @@ var fetchUrl_default = {
   handler: handler3
 };
 
-// src/tools/getTodoItem.ts
+// src/tools/listFiles.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 = {
   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) => {
+  parameters: z5.object({
+    path: z5.string().describe("The path of the directory to list contents for (relative to the current working directory)").meta({ usageValue: "Directory path here" }),
+    maxCount: z5.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: z5.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) => {
+    }, z5.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: z5.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)" })
+    }, z5.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 +498,20 @@ var toolInfo5 = {
     ]
   })
 };
-var handler5 = async (provider, args) => {
+var handler4 = async (provider, args) => {
   if (!provider.listFiles) {
     return {
-      type: "Error" /* Error */,
+      success: false,
       message: {
         type: "error-text",
         value: "Not possible to 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 +523,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
@@ -732,29 +589,29 @@ var MockProvider = class {
 };
 
 // src/tools/readBinaryFile.ts
-import { z as z10 } from "zod";
-var toolInfo8 = {
+import { z as z6 } from "zod";
+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.")
+  parameters: z6.object({
+    url: z6.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 +627,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,29 +636,29 @@ 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 = {
+import { z as z7 } from "zod";
+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({
-    path: z11.preprocess((val) => {
+  parameters: z7.object({
+    path: z7.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);
-    }, z11.array(z11.string())).describe("The path of the file to read").meta({ usageValue: "Comma separated paths here" }),
-    includeIgnored: z11.preprocess((val) => {
+    }, z7.array(z7.string())).describe("The path of the file to read").meta({ usageValue: "Comma separated paths here" }),
+    includeIgnored: z7.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)" })
+    }, z7.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,17 +676,17 @@ var toolInfo9 = {
     ]
   })
 };
-var handler9 = async (provider, args) => {
+var handler6 = async (provider, args) => {
   if (!provider.readFile) {
     return {
-      type: "Error" /* Error */,
+      success: false,
       message: {
         type: "error-text",
         value: "Not possible to 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);
@@ -845,7 +702,7 @@ var handler9 = async (provider, args) => {
     }
   }
   return {
-    type: "Reply" /* Reply */,
+    success: true,
     message: {
       type: "text",
       value: resp.join("\n")
@@ -853,53 +710,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 z8 } 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: z8.object({
+    path: z8.string().describe("The path of the file to remove").meta({ usageValue: "File path here" })
   }).meta({
     examples: [
       {
@@ -911,20 +732,20 @@ var toolInfo11 = {
     ]
   })
 };
-var handler11 = async (provider, args) => {
+var handler7 = async (provider, args) => {
   if (!provider.removeFile) {
     return {
-      type: "Error" /* Error */,
+      success: false,
       message: {
         type: "error-text",
         value: "Not possible to 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 +755,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 +763,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 z9 } 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: z9.object({
+    source_path: z9.string().describe("The current path of the file").meta({ usageValue: "Source file path here" }),
+    target_path: z9.string().describe("The new path for the file").meta({ usageValue: "Target file path here" })
   }).meta({
     examples: [
       {
@@ -966,20 +787,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 +808,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 z10 } from "zod";
 
 // src/tools/utils/replaceInFile.ts
 var replaceInFile = (fileContent, diff) => {
@@ -1069,12 +890,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: z10.object({
+    path: z10.string().describe("The path of the file to modify").meta({ usageValue: "File path here" }),
+    diff: z10.string().describe(
       `One or more SEARCH/REPLACE blocks following this exact format:
 \`\`\`
 <<<<<<< SEARCH
@@ -1181,20 +1002,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 +1027,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 +1037,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 +1049,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 +1059,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 +1067,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 +1076,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 z11 } 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: z11.object({
+    query: z11.string().describe("The query to search for").meta({ usageValue: "Your search query here" })
   }).meta({
     examples: [
       {
@@ -1289,11 +1110,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 +1123,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 +1131,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 z12 } 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: z12.object({
+    path: z12.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: z12.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: z12.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 +1165,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 +1189,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 +1203,7 @@ ${files.join("\n")}
     };
   } catch (error) {
     return {
-      type: "Error" /* Error */,
+      success: false,
       message: {
         type: "error-text",
         value: `Error searching files: ${error}`
@@ -1391,122 +1212,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 z13 } from "zod";
+var TodoStatus = z13.enum(["open", "completed", "closed"]);
+var TodoItemSchema = z13.object({
+  id: z13.string(),
+  title: z13.string(),
+  description: z13.string(),
+  status: TodoStatus
+});
+var UpdateTodoItemInputSchema = z13.object({
+  operation: z13.enum(["add", "update"]),
+  id: z13.string().nullish(),
+  parentId: z13.string().nullish(),
+  title: z13.string().nullish(),
+  description: z13.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 = z13.object({
+  id: z13.string()
+});
 
 // src/tools/writeToFile.ts
-import { z as z19 } from "zod";
-var toolInfo18 = {
+import { z as z14 } 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: z14.object({
+    path: z14.string().describe("The path of the file to write to").meta({ usageValue: "File path here" }),
+    content: z14.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 +1288,20 @@ export default App;
     ]
   })
 };
-var handler18 = async (provider, args) => {
+var handler12 = async (provider, args) => {
   if (!provider.writeFile) {
     return {
-      type: "Error" /* Error */,
+      success: false,
       message: {
         type: "error-text",
         value: "Not possible to 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}`
@@ -1557,7 +1313,7 @@ var handler18 = async (provider, args) => {
   if (trimmedContent.startsWith("<![CDATA[") && content.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 +1321,8 @@ var handler18 = async (provider, args) => {
   };
 };
 var writeToFile_default = {
-  ...toolInfo18,
-  handler: handler18
+  ...toolInfo12,
+  handler: handler12
 };
 
 // src/UsageMeter.ts
@@ -1719,7 +1475,7 @@ var UsageMeter = class {
 
 // src/workflow/agent.workflow.ts
 import { jsonSchema } from "ai";
-import { toJSONSchema, z as z20 } from "zod";
+import { toJSONSchema, z as z15 } from "zod";
 
 // src/workflow/types.ts
 var TaskEventKind = /* @__PURE__ */ ((TaskEventKind2) => {
@@ -1739,11 +1495,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))
@@ -1803,7 +1559,7 @@ 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: ${z15.prettifyError(validated.error)}. Please correct the output.`;
         nextMessage = [{ role: "user", content: errorMessage }];
         continue;
       }
@@ -1844,50 +1600,28 @@ 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;
-        }
+      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 = [
@@ -1906,49 +1640,58 @@ var agentWorkflow = async (input, { step, tools, logger }) => {
 
 // src/workflow/dynamic.ts
 import { parse } from "yaml";
-import { z as z22 } from "zod";
+import { z as z17 } 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 z16 } from "zod";
+var WorkflowInputDefinitionSchema = z16.object({
+  id: z16.string(),
+  description: z16.string().nullish(),
+  default: z16.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(),
+var WorkflowStepDefinitionSchema = z16.object({
+  id: z16.string(),
+  tools: z16.array(z16.string()).nullish(),
+  task: z16.string(),
+  output: z16.string().nullish(),
+  expected_outcome: z16.string().nullish(),
   /**
    * Persisted JavaScript/TypeScript (JS-compatible) async function body.
    * The code is wrapped as: `async (ctx) => { <code> }`.
    */
-  code: z21.string().nullish(),
+  code: z16.string().nullish(),
   /**
    * Optional JSON schema or other metadata for future structured outputs.
    * Not interpreted by core today.
    */
-  outputSchema: z21.any().nullish()
+  outputSchema: z16.any().nullish(),
+  /**
+   * Optional timeout in milliseconds. Step execution will be aborted if it exceeds this duration.
+   */
+  timeout: z16.number().positive().nullish()
 });
-var WorkflowDefinitionSchema = z21.object({
-  task: z21.string(),
-  inputs: z21.array(WorkflowInputDefinitionSchema).nullish(),
-  steps: z21.array(WorkflowStepDefinitionSchema),
-  output: z21.string().nullish()
+var WorkflowDefinitionSchema = z16.object({
+  task: z16.string(),
+  inputs: z16.array(WorkflowInputDefinitionSchema).nullish(),
+  steps: z16.array(WorkflowStepDefinitionSchema),
+  output: z16.string().nullish()
 });
-var WorkflowFileSchema = z21.object({
-  workflows: z21.record(z21.string(), WorkflowDefinitionSchema)
+var WorkflowFileSchema = z16.object({
+  workflows: z16.record(z16.string(), WorkflowDefinitionSchema)
 });
 
 // src/workflow/dynamic.ts
+var TOOL_GROUPS = {
+  readonly: ["readFile", "readBinaryFile", "listFiles", "searchFiles"],
+  readwrite: ["readFile", "readBinaryFile", "listFiles", "searchFiles", "writeToFile", "replaceInFile", "removeFile", "renameFile"],
+  internet: ["fetchUrl", "search"]
+};
 function parseDynamicWorkflowDefinition(source) {
   try {
     const raw = parse(source);
     const validated = WorkflowFileSchema.safeParse(raw);
     if (!validated.success) {
-      return { success: false, error: z22.prettifyError(validated.error) };
+      return { success: false, error: z17.prettifyError(validated.error) };
     }
     return { success: true, definition: validated.data };
   } catch (error) {
@@ -1957,6 +1700,28 @@ function parseDynamicWorkflowDefinition(source) {
 }
 var AsyncFunction = Object.getPrototypeOf(async () => {
 }).constructor;
+function validateAndApplyDefaults(workflowId, workflow, input) {
+  if (!workflow.inputs || workflow.inputs.length === 0) {
+    return input;
+  }
+  const validatedInput = {};
+  const errors = [];
+  for (const inputDef of workflow.inputs) {
+    const providedValue = input[inputDef.id];
+    if (providedValue !== void 0 && providedValue !== null) {
+      validatedInput[inputDef.id] = providedValue;
+    } else if (inputDef.default !== void 0 && inputDef.default !== null) {
+      validatedInput[inputDef.id] = inputDef.default;
+    } else {
+      errors.push(`Missing required input '${inputDef.id}'${inputDef.description ? `: ${inputDef.description}` : ""}`);
+    }
+  }
+  if (errors.length > 0) {
+    throw new Error(`Workflow '${workflowId}' input validation failed:
+${errors.map((e) => `  - ${e}`).join("\n")}`);
+  }
+  return validatedInput;
+}
 function createRunWorkflowFn(args) {
   return async (subWorkflowId, subInput) => {
     const mergedInput = { ...args.input, ...args.state, ...subInput ?? {} };
@@ -1977,8 +1742,13 @@ function compileStep(stepDef, workflowId, compiledSteps) {
     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 instanceof Error ? error.message : String(error)}`
+      `Failed to compile code for step '${stepDef.id}' in workflow '${workflowId}':
+  Error: ${errorMsg}
+  Code:
+${codePreview.split("\n").map((line) => `    ${line}`).join("\n")}`
     );
   }
 }
@@ -1994,22 +1764,47 @@ 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: z17.object({
+        workflowId: z17.string().describe("Sub-workflow id to run"),
+        input: z17.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." } };
       }
     });
   }
   const allowedToolNameSet = new Set(toolsForAgent.map((t) => t.name));
+  context.logger.debug(`[Agent] Available tools for step '${stepDef.id}': ${toolsForAgent.map((t) => t.name).join(", ")}`);
   const systemPrompt = options.stepSystemPrompt?.({ workflowId, step: stepDef, input, state }) ?? [
     `You are an AI assistant executing a workflow step.`,
     "",
@@ -2034,7 +1829,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.` }
         };
       }
@@ -2043,17 +1838,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) }
           };
         }
@@ -2079,28 +1874,95 @@ async function executeStepWithAgent(stepDef, workflowId, input, state, context,
     if (parsed.success) {
       return parsed.data;
     }
+    if (options.wrapAgentResultInObject) {
+      context.logger.warn(`[Agent] Step '${stepDef.id}' returned plain text instead of JSON. Wrapping in {result: ...}`);
+      return { result: result.message };
+    }
     return result.message;
   }
-  throw new Error(`Agent execution for step '${stepDef.id}' in workflow '${workflowId}' did not exit cleanly.`);
+  if (result.type === "Error") {
+    throw new Error(`Agent step '${stepDef.id}' in workflow '${workflowId}' failed: ${result.error?.message || "Unknown error"}`);
+  }
+  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}`);
+}
+async function executeStepWithTimeout(stepDef, workflowId, input, state, context, options, compiledSteps, 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 agentTools = {};
+      if (options.toolInfo) {
+        for (const tool of options.toolInfo) {
+          if (typeof context.tools[tool.name] === "function") {
+            agentTools[tool.name] = context.tools[tool.name];
+          }
+        }
+      }
+      const runtimeCtx = {
+        workflowId,
+        stepId: stepDef.id,
+        input,
+        state,
+        tools: context.tools,
+        logger: context.logger,
+        step: context.step,
+        runWorkflow,
+        toolInfo: options.toolInfo,
+        agentTools
+      };
+      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}'`);
+    return result;
+  };
+  if (stepDef.timeout && stepDef.timeout > 0) {
+    context.logger.debug(`[Step] Step '${stepDef.id}' has timeout of ${stepDef.timeout}ms`);
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutId = setTimeout(
+        () => reject(new Error(`Step '${stepDef.id}' in workflow '${workflowId}' timed out after ${stepDef.timeout}ms`)),
+        stepDef.timeout
+      );
+    });
+    try {
+      return await Promise.race([executeStepLogic(), timeoutPromise]);
+    } finally {
+      if (timeoutId) clearTimeout(timeoutId);
+    }
+  }
+  return await executeStepLogic();
 }
 async function executeStep(stepDef, workflowId, input, state, context, options, compiledSteps, runInternal) {
-  if (stepDef.code && options.allowUnsafeCodeExecution) {
-    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
-    };
-    return await fn(runtimeCtx);
+  const result = await executeStepWithTimeout(stepDef, workflowId, input, state, context, options, compiledSteps, runInternal);
+  if (stepDef.outputSchema) {
+    try {
+      const _schema = z17.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}`);
+        }
+      }
+    } catch (error) {
+      throw new Error(
+        `Step '${stepDef.id}' in workflow '${workflowId}' output validation failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
   }
-  return await executeStepWithAgent(stepDef, workflowId, input, state, context, options, runInternal);
+  return result;
 }
 function createDynamicWorkflow(definition, options = {}) {
   if (typeof definition === "string") {
@@ -2116,19 +1978,37 @@ function createDynamicWorkflow(definition, options = {}) {
     if (!workflow) {
       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(", ")}`);
     const state = { ...inheritedState };
     let lastOutput;
-    for (const stepDef of workflow.steps) {
+    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, input, state, context, options, compiledSteps, runInternal);
+        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}`
+      );
     }
+    context.logger.info(`[Workflow] Completed workflow '${workflowId}'`);
     if (workflow.output) {
+      context.logger.debug(`[Workflow] Returning output field: ${workflow.output}`);
       return state[workflow.output];
     }
+    context.logger.debug(`[Workflow] Returning full state with keys: ${Object.keys(state).join(", ")}`);
     return state;
   };
   return async (workflowId, input, context) => {
@@ -2137,19 +2017,362 @@ 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()
+import { z as z18 } from "zod";
+
+// src/workflow/prompts/dynamic-generator-prompts.ts
+var RUNTIME_CONTEXT_TYPES = `## 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 ToolResponse =
+  | { 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 FullToolInfo = { name: string; description: string; parameters: any; handler: any }
+
+type AgentTools = {
+  readFile: (input: { path: string }) => Promise<string | null>
+  writeToFile: (input: { path: string; content: string }) => Promise<void>
+  executeCommand: (input: { command: string; pipe?: boolean; requiresApproval?: boolean } & ({ args: string[]; shell?: false } | { shell: true })) => Promise<{
+    exitCode: number
+    stdout: string
+    stderr: string
+  }>
+  searchFiles: (input: { path: string; regex: string; filePattern?: string }) => Promise<string>
+  listFiles: (input: { path: string; recursive?: boolean; maxCount?: number; includeIgnored?: boolean }) => Promise<string>
+  fetchUrl: (input: { url: string[] }) => Promise<string>
+  askFollowupQuestion: (input: { questions: { prompt: string; options?: string[] }[] }) => Promise<any>
+  // ... and other tools available in the environment
+}
+
+// Tools available on ctx.tools in dynamic steps
+type DynamicWorkflowTools = {
+  // LLM + agent helpers
+  runAgent: (input: {
+    tools: Readonly<FullToolInfo[]>
+    maxToolRoundTrips?: number
+    userMessage: readonly JsonModelMessage[]
+  } & ({ messages: JsonModelMessage[] } | { systemPrompt: string })) => Promise<ExitReason>
+
+  // 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
+  agentTools: AgentTools
+  logger: Logger
+  step: StepFn
+  runWorkflow: (workflowId: string, input?: Record<string, any>) => Promise<any>
+  toolInfo?: ReadonlyArray<FullToolInfo>
+}
+\`\`\`
+
+- \`ctx.input\`: workflow inputs (read-only).
+- \`ctx.state\`: shared state between steps (previous step outputs are stored here).
+- \`ctx.agentTools\`: standard tools (readFile, executeCommand, etc.). Call as \`await ctx.agentTools.someTool({ ... })\`.
+- \`ctx.tools\`: workflow helpers (runAgent, confirm, input, select).
+- \`ctx.runWorkflow\`: run a sub-workflow by id.`;
+var CONTEXT_USAGE_GUIDELINES = `## 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\`).`;
+var QUALITY_GUIDELINES = `## 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`;
+var TOOL_CALLING_EXAMPLES = `## Tool calling examples
+
+### Standard tools (ctx.agentTools)
+\`\`\`ts
+// readFile
+const readme = await ctx.agentTools.readFile({ path: 'README.md' })
+if (readme == null) throw new Error('README.md not found')
+
+// writeToFile
+await ctx.agentTools.writeToFile({ path: 'notes.txt', content: 'hello\\n' })
+
+// executeCommand (args form)
+const rg = await ctx.agentTools.executeCommand({ command: 'rg', args: ['-n', 'TODO', '.'] })
+if (rg.exitCode !== 0) throw new Error(rg.stderr)
+
+// executeCommand (shell form)
+await ctx.agentTools.executeCommand({ command: 'ls -la', shell: true, pipe: true })
+\`\`\`
+
+### Workflow helpers (ctx.tools)
+\`\`\`ts
+// 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' },
+  ],
+})
+\`\`\`
+
+### 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
+\`\`\``;
+var COMPLETE_STEP_EXAMPLE = `## 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.agentTools.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)`;
+var CODE_FIELD_CONSTRAINTS = `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`;
+function composeImplementationGuidelines() {
+  return [
+    RUNTIME_CONTEXT_TYPES,
+    "",
+    CONTEXT_USAGE_GUIDELINES,
+    "",
+    QUALITY_GUIDELINES,
+    "",
+    TOOL_CALLING_EXAMPLES,
+    "",
+    COMPLETE_STEP_EXAMPLE
+  ].join("\n");
+}
+
+// src/workflow/dynamic-generator.workflow.ts
+var GenerateWorkflowDefinitionInputSchema = z18.object({
+  prompt: z18.string(),
+  availableTools: z18.array(
+    z18.object({
+      name: z18.string(),
+      description: z18.string()
     })
-  ).optional()
+  ).nullish()
 });
-var GenerateWorkflowCodeInputSchema = z23.object({
-  workflow: WorkflowFileSchema
+var GenerateWorkflowCodeInputSchema = z18.object({
+  workflow: WorkflowFileSchema,
+  skipReview: z18.boolean().nullish()
 });
+var AsyncFunction2 = Object.getPrototypeOf(async () => {
+}).constructor;
+function validateWorkflowDefinition(workflow) {
+  const errors = [];
+  if (!workflow.workflows.main) {
+    errors.push("Missing required 'main' workflow");
+  }
+  for (const [wfId, wf] of Object.entries(workflow.workflows)) {
+    const stepIds = /* @__PURE__ */ new Set();
+    for (const step of wf.steps) {
+      if (stepIds.has(step.id)) {
+        errors.push(`Duplicate step ID '${step.id}' in workflow '${wfId}'`);
+      }
+      stepIds.add(step.id);
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function validateWorkflowCodeSyntax(workflow) {
+  const errors = [];
+  for (const [wfId, wf] of Object.entries(workflow.workflows)) {
+    for (const step of wf.steps) {
+      if (step.code) {
+        try {
+          new AsyncFunction2("ctx", step.code);
+        } catch (e) {
+          const errorMsg = e instanceof Error ? e.message : String(e);
+          errors.push(`Syntax error in ${wfId}.${step.id}: ${errorMsg}`);
+        }
+      }
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
 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.
 
@@ -2165,8 +2388,11 @@ The workflow definition must follow this structure:
         {
           "id": "stepId",
           "task": "Description of the step",
-          "tools": ["toolName1", "toolName2"], // Optional list of tools needed
-          "output": "outputVariableName", // Optional
+          "tools": ["toolName1", "toolName2"], // Optional: restrict which tools can be used. Can use groups: "readonly", "readwrite", "internet", "all".
+          "output": "outputVariableName", // Optional: defaults to step id
+          "timeout": 30000, // Optional: timeout in milliseconds
+          "expected_outcome": "What this step produces", // Optional: documentation for expected results
+          "outputSchema": { "type": "object" } // Optional: validation schema
         }
       ],
       "output": "outputVariableName" // Optional
@@ -2180,7 +2406,24 @@ Constraints:
 - Break down complex tasks into logical steps.
 - Define clear inputs and outputs.
 
-Example 1:
+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 and its format
+- 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
+
+### Using expected_outcome Effectively
+
+The "expected_outcome" field helps document what each step produces. Best practices:
+- Describe the data structure: "Returns an array of { id, name, status } objects"
+- Mention important constraints: "Returns at most 10 results, sorted by date"
+- Note failure modes: "Returns null if file not found"
+- Document side effects: "Creates output directory if it doesn't exist"
+
+Example 1 - Research workflow:
 User: "Research a topic and summarize it."
 Output:
 \`\`\`json
@@ -2196,13 +2439,16 @@ Output:
           "id": "search",
           "task": "Search for information about the topic",
           "tools": ["search"],
-          "output": "searchResults"
+          "output": "searchResults",
+          "timeout": 30000,
+          "expected_outcome": "Returns search results with titles, URLs, and snippets related to the topic"
         },
         {
           "id": "summarize",
           "task": "Summarize the search results",
-          "tools": ["generateText"],
-          "output": "summary"
+          "tools": ["runAgent"],
+          "output": "summary",
+          "expected_outcome": "Returns a concise summary string (2-3 paragraphs) of the key findings"
         }
       ],
       "output": "summary"
@@ -2211,7 +2457,7 @@ Output:
 }
 \`\`\`
 
-Example 2:
+Example 2 - PR review workflow with sub-workflow:
 User: "Review urgent PRs. For each PR, run the review workflow."
 Output:
 \`\`\`json
@@ -2225,13 +2471,16 @@ Output:
           "id": "fetchPRs",
           "task": "Fetch list of urgent PRs",
           "tools": ["github_list_prs"],
-          "output": "prs"
+          "output": "prs",
+          "timeout": 15000,
+          "expected_outcome": "Returns array of PR objects with { id, title, author, url }"
         },
         {
           "id": "reviewEachPR",
           "task": "Run review workflow for each PR",
           "tools": [],
-          "output": "reviews"
+          "output": "reviews",
+          "expected_outcome": "Returns array of review results, one per PR"
         }
       ],
       "output": "reviews"
@@ -2246,13 +2495,16 @@ Output:
           "id": "getDiff",
           "task": "Get PR diff",
           "tools": ["github_get_diff"],
-          "output": "diff"
+          "output": "diff",
+          "timeout": 10000,
+          "expected_outcome": "Returns the unified diff string for the PR"
         },
         {
           "id": "analyze",
-          "task": "Analyze the diff",
-          "tools": ["generateText"],
-          "output": "analysis"
+          "task": "Analyze the diff and provide feedback",
+          "tools": ["runAgent"],
+          "output": "analysis",
+          "expected_outcome": "Returns { summary, issues, suggestions } object with review feedback"
         }
       ],
       "output": "analysis"
@@ -2260,77 +2512,130 @@ Output:
   }
 }
 \`\`\`
+
+Example 3 - File processing with conditional logic:
+User: "Process all JSON files in a directory, validate them, and generate a report."
+Output:
+\`\`\`json
+{
+  "workflows": {
+    "main": {
+      "task": "Process and validate JSON files, then generate a report",
+      "inputs": [
+        { "id": "directory", "description": "Directory containing JSON files", "default": "data" }
+      ],
+      "steps": [
+        {
+          "id": "listJsonFiles",
+          "task": "List all JSON files in the directory",
+          "tools": ["listFiles"],
+          "output": "jsonFiles",
+          "timeout": 5000,
+          "expected_outcome": "Returns array of file paths ending in .json"
+        },
+        {
+          "id": "processFiles",
+          "task": "Process each JSON file using the processFile sub-workflow",
+          "tools": [],
+          "output": "processedResults",
+          "expected_outcome": "Returns array of { file, valid, errors?, data? } for each file"
+        },
+        {
+          "id": "generateReport",
+          "task": "Generate a summary report of all processed files",
+          "tools": ["writeToFile"],
+          "output": "reportPath",
+          "expected_outcome": "Writes report to 'report.md' and returns the file path"
+        }
+      ],
+      "output": "reportPath"
+    },
+    "processFile": {
+      "task": "Process and validate a single JSON file",
+      "inputs": [
+        { "id": "filePath", "description": "Path to the JSON file" }
+      ],
+      "steps": [
+        {
+          "id": "readFile",
+          "task": "Read the JSON file content",
+          "tools": ["readFile"],
+          "output": "content",
+          "timeout": 3000,
+          "expected_outcome": "Returns file content as string, or null if not found"
+        },
+        {
+          "id": "validateJson",
+          "task": "Parse and validate the JSON structure",
+          "tools": [],
+          "output": "validationResult",
+          "expected_outcome": "Returns { valid: boolean, data?: object, errors?: string[] }"
+        }
+      ],
+      "output": "validationResult"
+    }
+  }
+}
+\`\`\`
 `;
+var WORKFLOW_IMPLEMENTATION_GUIDELINES = composeImplementationGuidelines();
 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.
 
-The code will be executed in an async function with the following signature:
-async (ctx) => {
-  // Your code here
-}
+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 \`ctx\` object provides access to:
-- \`ctx.input\`: The workflow inputs.
-- \`ctx.state\`: A shared state object for passing data between steps.
-- \`ctx.tools\`: An object containing available tools.
-- \`ctx.runWorkflow\`: (workflowId: string, input?: any) => Promise<any>. Use this to run other workflows.
-
-Guidelines:
-- Use \`await\` for asynchronous operations.
-- Return the output value of the step.
-- Access inputs via \`ctx.input.inputName\`.
-- Access previous step outputs via \`ctx.state.stepOutputName\`.
-- Use \`ctx.tools.invokeTool({ toolName: 'name', input: { ... } })\` to call tools.
-- Use \`ctx.tools.generateText({ messages: [...] })\` for LLM calls.
-- Use \`ctx.tools.invokeTool({ toolName: 'runAgent', input: { prompt: '...' } })\` for complex sub-tasks that require multiple steps or tools. Prefer this over \`generateText\` for advanced tasks.
-
-Example Code for a step:
-\`\`\`typescript
-const searchResults = await ctx.tools.invokeTool({
-  toolName: 'search',
-  input: { query: ctx.input.topic }
-});
-return searchResults;
-\`\`\`
+Prefer using \`ctx.tools.runAgent\` for complex tasks or when multiple steps/tools are needed. Use \`ctx.agentTools\` for direct tool usage (e.g. \`ctx.agentTools.readFile\`).
 
-Example Code for LLM step:
-\`\`\`typescript
-const summary = await ctx.tools.generateText({
-  messages: [
-    { role: 'system', content: 'Summarize the following text.' },
-    { role: 'user', content: ctx.state.searchResults }
-  ]
-});
-return summary;
-\`\`\`
+The code will be wrapped automatically in: \`async (ctx) => { YOUR_CODE_HERE }\`
 
-Example Code for runAgent:
-\`\`\`typescript
-const result = await ctx.tools.invokeTool({
-  toolName: 'runAgent',
-  input: {
-    prompt: 'Research the history of the internet and write a summary.',
-    tools: ['search', 'generateText']
-  }
-});
-return result;
+Example of CORRECT code field:
+\`\`\`ts
+const result = await ctx.agentTools.readFile({ path: 'README.md' })
+if (!result) throw new Error('File not found')
+return result
 \`\`\`
 
-Example Code for invoking a sub-workflow:
-\`\`\`typescript
-const results = [];
-for (const pr of ctx.state.prs) {
-  const review = await ctx.runWorkflow('reviewPR', { prId: pr.id });
-  results.push(review);
+Example of INCORRECT code field (DO NOT DO THIS):
+\`\`\`ts
+async (ctx) => {
+  const result = await ctx.agentTools.readFile({ path: 'README.md' })
+  return result
 }
-return results;
 \`\`\`
 
+${WORKFLOW_IMPLEMENTATION_GUIDELINES}
+
+## Final Instructions
+
+${CODE_FIELD_CONSTRAINTS}
+
 Return the complete workflow JSON with the "code" fields populated.
 `;
+var WORKFLOW_REVIEW_SYSTEM_PROMPT = `You are an expert TypeScript Code Reviewer.
+Your task is to review the provided workflow definition and its implemented code, and improve it to meet the highest quality standards.
+
+You will receive a JSON workflow definition where the "code" fields are already populated.
+You must review each step's code and improve it if necessary.
+
+Check for:
+- Correct usage of \`ctx.agentTools\` (for standard tools) and \`ctx.tools\` (for workflow helpers).
+- Proper error handling (try-catch, input validation).
+- Meaningful logging.
+- Adherence to the Quality Guidelines.
+- Correct syntax (no outer function wrappers).
+
+${QUALITY_GUIDELINES}
+
+## Final Instructions
+
+Return the complete workflow JSON with the "code" fields improved where necessary.
+Ensure the "code" field still contains ONLY the function body statements.
+`;
+var MAX_GENERATION_ATTEMPTS = 3;
 var generateWorkflowDefinitionWorkflow = async (input, ctx) => {
   let systemPrompt = WORKFLOW_DEFINITION_SYSTEM_PROMPT;
   if (input.availableTools && input.availableTools.length > 0) {
@@ -2353,27 +2658,81 @@ Use these tools when appropriate.`;
       ctx
     );
   });
-  if (result.type === "Exit" && result.object) {
-    return result.object;
-  }
-  throw new Error("Failed to generate workflow definition");
+  if (result.type !== "Exit" || !result.object) {
+    throw new Error("Failed to generate workflow definition");
+  }
+  const workflow = result.object;
+  await ctx.step("validate-workflow-definition", async () => {
+    const validation = validateWorkflowDefinition(workflow);
+    if (!validation.valid) {
+      ctx.logger.warn(`Workflow definition validation warnings: ${validation.errors.join("; ")}`);
+    }
+    return validation;
+  });
+  return workflow;
 };
 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;
+  let lastError = null;
+  let currentWorkflow = input.workflow;
+  for (let attempt = 0; attempt < MAX_GENERATION_ATTEMPTS; attempt++) {
+    const stepName = attempt === 0 ? "generate-workflow-code" : `retry-workflow-code-${attempt}`;
+    const userMessage = lastError ? `Previous attempt had issues: ${lastError}
+
+Please fix the problems in this workflow:
+${JSON.stringify(currentWorkflow, null, 2)}` : JSON.stringify(currentWorkflow, null, 2);
+    const generated = await ctx.step(stepName, async () => {
+      return agentWorkflow(
+        {
+          systemPrompt: WORKFLOW_CODE_SYSTEM_PROMPT,
+          userMessage: [{ role: "user", content: userMessage }],
+          tools: [],
+          outputSchema: WorkflowFileSchema
+        },
+        ctx
+      );
+    });
+    if (generated.type !== "Exit" || !generated.object) {
+      lastError = "Failed to generate workflow code";
+      continue;
+    }
+    const generatedWorkflow = generated.object;
+    const syntaxValidation = await ctx.step(`validate-code-syntax-${attempt}`, async () => {
+      return validateWorkflowCodeSyntax(generatedWorkflow);
+    });
+    if (!syntaxValidation.valid) {
+      lastError = syntaxValidation.errors.join("; ");
+      currentWorkflow = generatedWorkflow;
+      ctx.logger.warn(`Code syntax validation failed (attempt ${attempt + 1}): ${lastError}`);
+      continue;
+    }
+    if (input.skipReview) {
+      return generatedWorkflow;
+    }
+    const reviewed = await ctx.step("review-workflow-code", async () => {
+      return agentWorkflow(
+        {
+          systemPrompt: WORKFLOW_REVIEW_SYSTEM_PROMPT,
+          userMessage: [{ role: "user", content: JSON.stringify(generatedWorkflow, null, 2) }],
+          tools: [],
+          outputSchema: WorkflowFileSchema
+        },
+        ctx
+      );
+    });
+    if (reviewed.type !== "Exit" || !reviewed.object) {
+      throw new Error("Failed to review workflow code");
+    }
+    const reviewedWorkflow = reviewed.object;
+    const reviewSyntaxValidation = await ctx.step("validate-reviewed-code-syntax", async () => {
+      return validateWorkflowCodeSyntax(reviewedWorkflow);
+    });
+    if (!reviewSyntaxValidation.valid) {
+      ctx.logger.warn(`Reviewed code has syntax issues: ${reviewSyntaxValidation.errors.join("; ")}`);
+      return generatedWorkflow;
+    }
+    return reviewedWorkflow;
   }
-  throw new Error("Failed to generate workflow code");
+  throw new Error(`Failed to generate valid workflow code after ${MAX_GENERATION_ATTEMPTS} attempts: ${lastError}`);
 };
 
 // src/workflow/json-ai-types.ts
@@ -2577,10 +2936,10 @@ export {
   GenerateWorkflowCodeInputSchema,
   GenerateWorkflowDefinitionInputSchema,
   MockProvider,
+  TOOL_GROUPS,
   TaskEventKind,
   TodoItemSchema,
   TodoStatus,
-  ToolResponseType,
   UpdateTodoItemInputSchema,
   UpdateTodoItemOutputSchema,
   UsageMeter,
@@ -2599,17 +2958,13 @@ export {
   fromJsonModelMessage,
   generateWorkflowCodeWorkflow,
   generateWorkflowDefinitionWorkflow,
-  getTodoItem_default as getTodoItem,
   listFiles_default as listFiles,
-  listMemoryTopics_default as listMemoryTopics,
-  listTodoItems_default as listTodoItems,
   makeStepFn,
   parseDynamicWorkflowDefinition,
   parseJsonFromMarkdown,
   providerModelSchema,
   readBinaryFile_default as readBinaryFile,
   readFile_default as readFile,
-  readMemory_default as readMemory,
   removeFile_default as removeFile,
   renameFile_default as renameFile,
   replaceInFile_default as replaceInFile,
@@ -2619,7 +2974,7 @@ export {
   search_default as search,
   searchFiles_default as searchFiles,
   toJsonModelMessage,
-  updateMemory_default as updateMemory,
-  updateTodoItem_default as updateTodoItem,
+  validateWorkflowCodeSyntax,
+  validateWorkflowDefinition,
   writeToFile_default as writeToFile
 };