@polka-codes/core 0.9.86 → 0.9.89

package/dist/index.js

@@ -126,114 +126,184 @@ function computeRateLimitBackoffSeconds(count, baseSeconds = 2, capSeconds = 60)
 }
 
 // src/config.ts
+import { z as z2 } from "zod";
+
+// src/config/memory.ts
 import { z } from "zod";
-var ruleSchema = z.union([
-  z.string(),
-  z.object({ path: z.string() }).strict(),
-  z.object({ url: z.string() }).strict(),
-  z.object({
-    repo: z.string(),
-    path: z.string(),
-    tag: z.string().optional(),
-    commit: z.string().optional(),
-    branch: z.string().optional()
+var memoryConfigSchema = z.object({
+  enabled: z.boolean().optional().default(true),
+  type: z.enum(["sqlite", "memory"]).optional().default("sqlite"),
+  path: z.string().optional().default("~/.config/polka-codes/memory.sqlite")
+}).strict().optional();
+var DEFAULT_MEMORY_CONFIG = {
+  enabled: true,
+  type: "sqlite",
+  path: "~/.config/polka-codes/memory.sqlite"
+};
+function resolveHomePath(path) {
+  if (path.startsWith("~")) {
+    return `${process.env.HOME}${path.slice(1)}`;
+  }
+  return path;
+}
+
+// src/config.ts
+var ruleSchema = z2.union([
+  z2.string(),
+  z2.object({ path: z2.string() }).strict(),
+  z2.object({ url: z2.string() }).strict(),
+  z2.object({
+    repo: z2.string(),
+    path: z2.string(),
+    tag: z2.string().optional(),
+    commit: z2.string().optional(),
+    branch: z2.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 providerConfigSchema = z2.object({
+  apiKey: z2.string().optional(),
+  defaultModel: z2.string().optional(),
+  defaultParameters: z2.record(z2.string(), z2.any()).optional(),
+  location: z2.string().optional(),
+  project: z2.string().optional(),
+  keyFile: z2.string().optional(),
+  baseUrl: z2.string().optional(),
+  name: z2.string().optional()
+  // For OpenAI-compatible providers
 });
-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 providerModelSchema = z2.object({
+  provider: z2.string().optional(),
+  model: z2.string().optional(),
+  parameters: z2.record(z2.string(), z2.any()).optional(),
+  budget: z2.number().positive().optional(),
+  rules: z2.array(ruleSchema).optional().or(z2.string()).optional()
 });
-var scriptSchema = z.union([
+var scriptSchema = z2.union([
   // Type 1: Simple shell command (backward compatible)
-  z.string(),
+  z2.string(),
   // Type 2: Object with command and description (backward compatible)
-  z.object({
-    command: z.string(),
-    description: z.string()
+  z2.object({
+    command: z2.string(),
+    description: z2.string()
   }).strict(),
   // Type 3: Reference to dynamic workflow YAML
-  z.object({
-    workflow: z.string(),
+  z2.object({
+    workflow: z2.string(),
     // Path to .yml workflow file
-    description: z.string().optional(),
-    input: z.record(z.string(), z.any()).optional()
+    description: z2.string().optional(),
+    input: z2.record(z2.string(), z2.any()).optional()
     // Default workflow input
   }).strict(),
   // Type 4: TypeScript script file (NEW)
-  z.object({
-    script: z.string(),
+  z2.object({
+    script: z2.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()
+    description: z2.string().optional(),
+    permissions: z2.object({
+      fs: z2.enum(["read", "write", "none"]).optional(),
+      network: z2.boolean().optional(),
+      subprocess: z2.boolean().optional()
     }).optional(),
-    timeout: z.number().int().positive().max(36e5).optional(),
+    timeout: z2.number().int().positive().max(36e5).optional(),
     // Max 1 hour in milliseconds
-    memory: z.number().int().positive().min(64).max(8192).optional()
+    memory: z2.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()
+var mcpServerConfigSchema = z2.object({
+  command: z2.string(),
+  args: z2.array(z2.string()).optional(),
+  env: z2.record(z2.string(), z2.string()).optional(),
+  tools: z2.record(
+    z2.string(),
+    z2.boolean().or(
+      z2.object({
+        provider: z2.string().optional(),
+        model: z2.string().optional(),
+        parameters: z2.record(z2.string(), z2.unknown()).optional()
       }).strict()
     )
   ).optional()
 }).strict();
-var configSchema = z.object({
-  prices: z.record(
-    z.string(),
+var agentContinuousImprovementSchema = z2.object({
+  sleepTimeOnNoTasks: z2.number().int().optional(),
+  sleepTimeBetweenTasks: z2.number().int().optional(),
+  maxCycles: z2.number().int().optional()
+}).strict().optional();
+var agentDiscoverySchema = z2.object({
+  enabledStrategies: z2.array(z2.string()).optional(),
+  cacheTime: z2.number().int().optional(),
+  checkChanges: z2.boolean().optional()
+}).strict().optional();
+var agentSafetySchema = z2.object({
+  enabledChecks: z2.array(z2.string()).optional(),
+  blockDestructive: z2.boolean().optional(),
+  maxFileSize: z2.number().int().optional()
+}).strict().optional();
+var agentHealthCheckSchema = z2.object({
+  enabled: z2.boolean().optional(),
+  interval: z2.number().int().optional()
+}).strict().optional();
+var agentApprovalSchema = z2.object({
+  level: z2.enum(["none", "destructive", "commits", "all"]).optional(),
+  autoApproveSafeTasks: z2.boolean().optional(),
+  maxAutoApprovalCost: z2.number().optional()
+}).strict().optional();
+var agentSchema = z2.object({
+  preset: z2.string().optional(),
+  strategy: z2.enum(["goal-directed", "continuous-improvement"]).optional(),
+  continueOnCompletion: z2.boolean().optional(),
+  maxIterations: z2.number().int().optional(),
+  timeout: z2.number().int().optional(),
+  requireApprovalFor: z2.enum(["none", "destructive", "commits", "all"]).optional(),
+  autoApproveSafeTasks: z2.boolean().optional(),
+  maxAutoApprovalCost: z2.number().optional(),
+  pauseOnError: z2.boolean().optional(),
+  workingBranch: z2.string().optional(),
+  destructiveOperations: z2.array(z2.string()).optional(),
+  maxConcurrency: z2.number().int().optional(),
+  autoSaveInterval: z2.number().int().optional(),
+  workingDir: z2.string().optional(),
+  continuousImprovement: agentContinuousImprovementSchema,
+  discovery: agentDiscoverySchema,
+  safety: agentSafetySchema,
+  healthCheck: agentHealthCheckSchema,
+  approval: agentApprovalSchema
+}).strict().optional();
+var configSchema = z2.object({
+  prices: z2.record(
+    z2.string(),
     // provider
-    z.record(
-      z.string(),
+    z2.record(
+      z2.string(),
       // model
-      z.object({
-        inputPrice: z.number().optional(),
-        outputPrice: z.number().optional(),
-        cacheWritesPrice: z.number().optional(),
-        cacheReadsPrice: z.number().optional()
+      z2.object({
+        inputPrice: z2.number().optional(),
+        outputPrice: z2.number().optional(),
+        cacheWritesPrice: z2.number().optional(),
+        cacheReadsPrice: z2.number().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(),
-  maxMessageCount: z.number().int().positive().optional(),
-  budget: z.number().positive().optional(),
-  retryCount: z.number().int().min(0).optional(),
-  requestTimeoutSeconds: z.number().int().positive().optional(),
-  summaryThreshold: z.number().int().positive().optional(),
-  scripts: z.record(z.string(), scriptSchema).optional(),
-  commands: z.record(z.string(), providerModelSchema).optional(),
-  tools: z.object({
-    search: providerModelSchema.or(z.boolean()).optional()
+  providers: z2.record(z2.string(), providerConfigSchema).optional(),
+  defaultProvider: z2.string().optional(),
+  defaultModel: z2.string().optional(),
+  defaultParameters: z2.record(z2.string(), z2.any()).optional(),
+  maxMessageCount: z2.number().int().positive().optional(),
+  budget: z2.number().positive().optional(),
+  retryCount: z2.number().int().min(0).optional(),
+  requestTimeoutSeconds: z2.number().int().positive().optional(),
+  summaryThreshold: z2.number().int().positive().optional(),
+  scripts: z2.record(z2.string(), scriptSchema).optional(),
+  commands: z2.record(z2.string(), providerModelSchema).optional(),
+  tools: z2.object({
+    search: providerModelSchema.or(z2.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()
+  mcpServers: z2.record(z2.string(), mcpServerConfigSchema).optional(),
+  rules: z2.array(ruleSchema).optional().or(z2.string()).optional(),
+  excludeFiles: z2.array(z2.string()).optional(),
+  agent: agentSchema,
+  memory: memoryConfigSchema
 }).strict().nullish();
 
 // src/fs/node-provider.ts
@@ -336,11 +406,11 @@ import { parse } from "yaml";
 import { ZodError } from "zod";
 
 // src/skills/types.ts
-import { z as z2 } from "zod";
-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()
+import { z as z3 } from "zod";
+var skillMetadataSchema = z3.object({
+  name: z3.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: z3.string().max(1024, "Description must be at most 1024 characters"),
+  allowedTools: z3.array(z3.string()).optional()
 });
 var SkillDiscoveryError = class extends Error {
   constructor(message, path) {
@@ -754,19 +824,19 @@ function getSkillStats(skill) {
 }
 
 // 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")
+import { z as z4 } from "zod";
+var ListSkillsInputSchema = z4.object({
+  filter: z4.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"])
+var ListSkillsOutputSchema = z4.object({
+  skills: z4.array(
+    z4.object({
+      name: z4.string(),
+      description: z4.string(),
+      source: z4.enum(["personal", "project", "plugin"])
     })
   ),
-  total: z3.number()
+  total: z4.number()
 });
 async function listSkills(input, context) {
   const { filter } = input;
@@ -792,20 +862,20 @@ var listSkillsToolInfo = {
 };
 
 // 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")
+import { z as z5 } from "zod";
+var LoadSkillInputSchema = z5.object({
+  skillName: z5.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())
+var LoadSkillOutputSchema = z5.object({
+  success: z5.boolean(),
+  skill: z5.object({
+    name: z5.string(),
+    description: z5.string(),
+    content: z5.string(),
+    availableFiles: z5.array(z5.string())
   }).optional(),
-  error: z4.string().optional(),
-  warnings: z4.array(z4.string()).optional()
+  error: z5.string().optional(),
+  warnings: z5.array(z5.string()).optional()
 });
 async function loadSkill(input, context) {
   const { skillName } = input;
@@ -854,15 +924,15 @@ var loadSkillToolInfo = {
 };
 
 // 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")')
+import { z as z6 } from "zod";
+var ReadSkillFileInputSchema = z6.object({
+  skillName: z6.string().describe("The name of the skill"),
+  filename: z6.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()
+var ReadSkillFileOutputSchema = z6.object({
+  success: z6.boolean(),
+  content: z6.string().optional(),
+  error: z6.string().optional()
 });
 async function readSkillFile(input, context) {
   const { skillName, filename } = input;
@@ -900,16 +970,16 @@ var readSkillFileToolInfo = {
 };
 
 // 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" })
+import { z as z7 } from "zod";
+var questionObject = z7.object({
+  prompt: z7.string().describe("The text of the question.").meta({ usageValue: "question text here" }),
+  options: z7.array(z7.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: z6.object({
-    questions: z6.array(questionObject).describe("One or more follow-up questions you need answered before you can continue.").meta({ usageValue: "questions here" })
+  parameters: z7.object({
+    questions: z7.array(questionObject).describe("One or more follow-up questions you need answered before you can continue.").meta({ usageValue: "questions here" })
   }).meta({
     examples: [
       {
@@ -997,18 +1067,41 @@ var askFollowupQuestion_default = {
 };
 
 // src/tools/executeCommand.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 
-// src/tools/utils.ts
-function createProviderError(action) {
+// src/tools/response-builders.ts
+function createSuccessResponse(value, type = "text") {
+  return {
+    success: true,
+    message: { type, value }
+  };
+}
+function createErrorResponse(message) {
+  return {
+    success: false,
+    message: { type: "error-text", value: message }
+  };
+}
+function createProviderErrorResponse(capability) {
   return {
     success: false,
     message: {
       type: "error-text",
-      value: `Not possible to ${action}.`
+      value: `Not possible to ${capability}.`
     }
   };
 }
+function createValidationErrorResponse(errors) {
+  return {
+    success: false,
+    message: {
+      type: "error-text",
+      value: `Validation failed: ${errors.message}`
+    }
+  };
+}
+
+// src/tools/utils.ts
 function preprocessBoolean(val) {
   return typeof val === "string" ? val.toLowerCase() === "true" : val;
 }
@@ -1029,9 +1122,9 @@ function createFileElement(tagName, path, content, attrs) {
 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: 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(
+  parameters: z8.object({
+    command: z8.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: z8.preprocess(preprocessBoolean, z8.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({
@@ -1048,7 +1141,7 @@ var toolInfo2 = {
 };
 var handler2 = async (provider, args) => {
   if (!provider.executeCommand) {
-    return createProviderError("execute command. Abort");
+    return createProviderErrorResponse("execute command. Abort");
   }
   const { command, requiresApproval } = toolInfo2.parameters.parse(args);
   try {
@@ -1102,16 +1195,16 @@ var executeCommand_default = {
 };
 
 // src/tools/fetchUrl.ts
-import { z as z8 } from "zod";
+import { z as z9 } 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: z8.object({
-    url: z8.preprocess((val) => {
+  parameters: z9.object({
+    url: z9.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);
-    }, z8.array(z8.string())).describe("One or more URLs to fetch, separated by commas if multiple.").meta({ usageValue: "url" })
+    }, z9.array(z9.string())).describe("One or more URLs to fetch, separated by commas if multiple.").meta({ usageValue: "url" })
   }).meta({
     examples: [
       {
@@ -1180,15 +1273,15 @@ var fetchUrl_default = {
 };
 
 // src/tools/listFiles.ts
-import { z as z9 } from "zod";
+import { z as z10 } 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: 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)" })
+  parameters: z10.object({
+    path: z10.string().describe("The path of the directory to list contents for (relative to the current working directory)").meta({ usageValue: "Directory path here" }),
+    maxCount: z10.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: z10.preprocess(preprocessBoolean, z10.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: z10.preprocess(preprocessBoolean, z10.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: [
       {
@@ -1203,7 +1296,7 @@ var toolInfo4 = {
 };
 var handler4 = async (provider, args) => {
   if (!provider.listFiles) {
-    return createProviderError("list files");
+    return createProviderErrorResponse("list files");
   }
   const { path, maxCount, recursive, includeIgnored } = toolInfo4.parameters.parse(args);
   const [files, limitReached] = await provider.listFiles(path, recursive, maxCount, includeIgnored);
@@ -1286,12 +1379,12 @@ var MockProvider = class {
 };
 
 // src/tools/readBinaryFile.ts
-import { z as z10 } from "zod";
+import { z as z11 } 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: z11.object({
+    url: z11.string().describe("The URL or local path of the file to read.")
   })
 };
 var handler5 = async (provider, args) => {
@@ -1338,17 +1431,43 @@ var readBinaryFile_default = {
 };
 
 // src/tools/readFile.ts
-import { z as z11 } from "zod";
+import { z as z12 } 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) => {
+  description: `Request to read the contents of one or multiple files at the specified paths.
+
+When to use:
+- Examining file contents you don't know
+- Analyzing code, reviewing text files, extracting configuration info
+- Reading multiple files at once (use comma-separated paths)
+- Understanding file structure before editing
+
+When NOT to use:
+- For file existence checks: Use listFiles instead
+- For searching within files: Use grep instead
+- For file name searches: Use searchFiles instead
+- Prefer this tool over executeCommand with cat/head/tail
+
+Features:
+- Supports comma-separated paths for multiple files
+- Line numbers included for easy reference
+- Optional offset/limit for partial file reading
+- Automatically handles different file types
+
+IMPORTANT:
+- Line numbers are included for easy reference
+- Use offset/limit for large files to read specific sections`,
+  parameters: z12.object({
+    path: z12.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(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)" })
+      if (Array.isArray(val)) {
+        return val.filter((s) => typeof s === "string" && s.length > 0);
+      }
+      return val.split(",").filter((s) => s.length > 0);
+    }, z12.array(z12.string())).describe("The path of the file to read").meta({ usageValue: "Comma separated paths here" }),
+    offset: z12.number().optional().describe("Skip first N lines (for partial file reading)").meta({ usageValue: "100" }),
+    limit: z12.number().optional().describe("Read at most N lines (for partial file reading)").meta({ usageValue: "50" }),
+    includeIgnored: z12.preprocess(preprocessBoolean, z12.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: [
       {
@@ -1362,23 +1481,53 @@ var toolInfo6 = {
         input: {
           path: "src/main.js,src/index.js"
         }
+      },
+      {
+        description: "Read partial file (lines 100-150)",
+        input: {
+          path: "src/large-file.ts",
+          offset: 100,
+          limit: 50
+        }
       }
     ]
   })
 };
 var handler6 = async (provider, args) => {
   if (!provider.readFile) {
-    return createProviderError("read file");
+    return createProviderErrorResponse("read file");
+  }
+  const parsed = toolInfo6.parameters.safeParse(args);
+  if (!parsed.success) {
+    return {
+      success: false,
+      message: {
+        type: "error-text",
+        value: `Invalid arguments for readFile: ${parsed.error.message}`
+      }
+    };
   }
-  const { path: paths, includeIgnored } = toolInfo6.parameters.parse(args);
+  const { path: paths, offset, limit, includeIgnored } = parsed.data;
   const resp = [];
   for (const path of paths) {
     const fileContent = await provider.readFile(path, includeIgnored ?? false);
     if (!fileContent) {
       resp.push(createFileElement("read_file_file_content", path, void 0, { file_not_found: "true" }));
-    } else {
-      resp.push(createFileElement("read_file_file_content", path, fileContent));
+      continue;
     }
+    let lines = fileContent.split("\n");
+    const start = offset ?? 0;
+    const end = limit ? start + limit : lines.length;
+    if (offset !== void 0 || limit !== void 0) {
+      lines = lines.slice(start, end);
+    }
+    const lineOffset = offset ?? 0;
+    const numberedContent = lines.map((line, i) => {
+      const lineNumber = lineOffset + i + 1;
+      const paddedNumber = String(lineNumber).padStart(6, " ");
+      return `${paddedNumber}\u2192${line}`;
+    }).join("\n");
+    resp.push(createFileElement("read_file_file_content", path, numberedContent));
   }
   return {
     success: true,
@@ -1394,12 +1543,12 @@ var readFile_default = {
 };
 
 // src/tools/removeFile.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var toolInfo7 = {
   name: "removeFile",
   description: "Request to remove a file at the specified path.",
-  parameters: z12.object({
-    path: z12.string().describe("The path of the file to remove").meta({ usageValue: "File path here" })
+  parameters: z13.object({
+    path: z13.string().describe("The path of the file to remove").meta({ usageValue: "File path here" })
   }).meta({
     examples: [
       {
@@ -1413,7 +1562,7 @@ var toolInfo7 = {
 };
 var handler7 = async (provider, args) => {
   if (!provider.removeFile) {
-    return createProviderError("remove file");
+    return createProviderErrorResponse("remove file");
   }
   const parsed = toolInfo7.parameters.safeParse(args);
   if (!parsed.success) {
@@ -1441,13 +1590,13 @@ var removeFile_default = {
 };
 
 // src/tools/renameFile.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var toolInfo8 = {
   name: "renameFile",
   description: "Request to rename a file from source path to target path.",
-  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" })
+  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" })
   }).meta({
     examples: [
       {
@@ -1486,7 +1635,7 @@ var renameFile_default = {
 };
 
 // src/tools/replaceInFile.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 
 // src/tools/utils/replaceInFile.ts
 var replaceInFile = (fileContent, diff) => {
@@ -1582,10 +1731,46 @@ var replaceInFile = (fileContent, diff) => {
 // src/tools/replaceInFile.ts
 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: z14.object({
-    path: z14.string().describe("The path of the file to modify").meta({ usageValue: "File path here" }),
-    diff: z14.string().describe(
+  description: `Request to replace sections of content in an existing file using
+SEARCH/REPLACE blocks.
+
+When to use:
+- Making targeted changes to specific parts of a file
+- Replacing variable names, function signatures, imports
+- Fixing bugs in existing code
+- When you know the exact content to replace
+
+When NOT to use:
+- For creating new files: Use writeToFile instead
+- For completely replacing file contents: Use writeToFile instead
+- When you don't know the exact content: Read file first
+
+SEARCH/REPLACE FORMAT:
+<<<<<<< SEARCH
+[exact content to find]
+=======
+[new content to replace with]
+>>>>>>> REPLACE
+
+Critical rules:
+1. SEARCH content must match EXACTLY (character-for-character including whitespace)
+2. Each block replaces only first occurrence
+3. Include just enough lines for uniqueness (not too many, not too few)
+4. Keep blocks concise (don't include long unchanged sections)
+5. List blocks in order they appear in file
+6. Use multiple blocks for multiple independent changes
+
+Special operations:
+- Move code: Two blocks (delete from original + insert at new location)
+- Delete code: Empty REPLACE section
+
+IMPORTANT CONSTRAINTS:
+- SEARCH text must match file content exactly
+- Each block is independent (doesn't affect other blocks)
+- Cannot use for appending or inserting without SEARCH context`,
+  parameters: z15.object({
+    path: z15.string().describe("The path of the file to modify").meta({ usageValue: "File path here" }),
+    diff: z15.string().describe(
       `One or more SEARCH/REPLACE blocks following this exact format:
 \`\`\`
 <<<<<<< SEARCH
@@ -1609,7 +1794,7 @@ Critical rules:
     * Each line must be complete. Never truncate lines mid-way through as this can cause matching failures.
 4. Special operations:
     * To move code: Use two SEARCH/REPLACE blocks (one to delete from original + one to insert at new location)
-    * To delete code: Use empty REPLACE section`
+    * To delete code: Empty REPLACE section`
     ).meta({ usageValue: "Search and replace blocks here" })
   }).meta({
     examples: [
@@ -1771,12 +1956,12 @@ var replaceInFile_default = {
 };
 
 // src/tools/search.ts
-import { z as z15 } from "zod";
+import { z as z16 } 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: z15.object({
-    query: z15.string().describe("The query to search for").meta({ usageValue: "Your search query here" })
+  parameters: z16.object({
+    query: z16.string().describe("The query to search for").meta({ usageValue: "Your search query here" })
   }).meta({
     examples: [
       {
@@ -1826,18 +2011,18 @@ var search_default = {
 };
 
 // src/tools/searchFiles.ts
-import { z as z16 } from "zod";
+import { z as z17 } 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: z16.object({
-    path: z16.string().describe(
+  parameters: z17.object({
+    path: z17.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: z16.string().describe("The regular expression pattern to search for. Uses Rust regex syntax.").meta({
+    regex: z17.string().describe("The regular expression pattern to search for. Uses Rust regex syntax.").meta({
       usageValue: "Your regex pattern here"
     }),
-    filePattern: z16.string().optional().describe(
+    filePattern: z17.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)"
@@ -1907,20 +2092,20 @@ var searchFiles_default = {
 };
 
 // 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(),
+import { z as z18 } from "zod";
+var TodoStatus = z18.enum(["open", "completed", "closed"]);
+var TodoItemSchema = z18.object({
+  id: z18.string(),
+  title: z18.string(),
+  description: z18.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(),
+var UpdateTodoItemInputSchema = z18.object({
+  operation: z18.enum(["add", "update"]),
+  id: z18.string().nullish(),
+  parentId: z18.string().nullish(),
+  title: z18.string().nullish(),
+  description: z18.string().nullish(),
   status: TodoStatus.nullish()
 }).superRefine((data, ctx) => {
   if (data.operation === "add") {
@@ -1941,18 +2126,38 @@ var UpdateTodoItemInputSchema = z17.object({
     }
   }
 });
-var UpdateTodoItemOutputSchema = z17.object({
-  id: z17.string()
+var UpdateTodoItemOutputSchema = z18.object({
+  id: z18.string()
 });
 
 // src/tools/writeToFile.ts
-import { z as z18 } from "zod";
+import { z as z19 } 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: z18.object({
-    path: z18.string().describe("The path of the file to write to").meta({ usageValue: "File path here" }),
-    content: z18.string().describe(
+  description: `Request to write content to a file at the specified path.
+
+When to use:
+- Creating new files
+- Completely replacing file contents
+- When you have the complete intended content
+
+When NOT to use:
+- For modifying existing files: Use replaceInFile instead
+- For appending content: Use executeCommand with echo >> instead
+- For targeted edits: Use replaceInFile instead
+
+Features:
+- Automatically creates any directories needed
+- Overwrites existing files completely
+- Must provide complete file content (no truncation)
+
+IMPORTANT CONSTRAINT:
+- Always provide COMPLETE intended content (no omissions)
+- Ensure no incorrect escape sequences (&lt;, &gt;, &amp;)
+- Ensure no unwanted CDATA tags in 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(
       "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({
@@ -1980,7 +2185,7 @@ export default App;
 };
 var handler12 = async (provider, args) => {
   if (!provider.writeFile) {
-    return createProviderError("write file");
+    return createProviderErrorResponse("write file");
   }
   const parsed = toolInfo12.parameters.safeParse(args);
   if (!parsed.success) {
@@ -1992,9 +2197,7 @@ var handler12 = async (provider, args) => {
       }
     };
   }
-  let { path, content } = parsed.data;
-  const trimmedContent = content.trim();
-  if (trimmedContent.startsWith("<![CDATA[") && trimmedContent.endsWith("]]>")) content = trimmedContent.slice(9, -3);
+  const { path, content } = parsed.data;
   await provider.writeFile(path, content);
   return {
     success: true,
@@ -2159,7 +2362,7 @@ var UsageMeter = class {
 
 // src/workflow/agent.workflow.ts
 import { jsonSchema } from "ai";
-import { toJSONSchema, z as z19 } from "zod";
+import { toJSONSchema, z as z20 } from "zod";
 
 // src/workflow/types.ts
 var TaskEventKind = /* @__PURE__ */ ((TaskEventKind2) => {
@@ -2243,7 +2446,7 @@ var agentWorkflow = async (input, { step, tools, logger }) => {
       }
       const validated = input.outputSchema.safeParse(parsed.data);
       if (!validated.success) {
-        const errorMessage = `Output validation failed. Error: ${z19.prettifyError(validated.error)}. Please correct the output.`;
+        const errorMessage = `Output validation failed. Error: ${z20.prettifyError(validated.error)}. Please correct the output.`;
         nextMessage = [{ role: "user", content: errorMessage }];
         continue;
       }
@@ -2325,63 +2528,63 @@ var agentWorkflow = async (input, { step, tools, logger }) => {
 
 // src/workflow/dynamic.ts
 import { parse as parse2 } from "yaml";
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 
 // src/workflow/dynamic-types.ts
-import { z as z20 } from "zod";
-var WorkflowInputDefinitionSchema = z20.object({
-  id: z20.string(),
-  description: z20.string().nullish(),
-  default: z20.any().nullish()
+import { z as z21 } from "zod";
+var WorkflowInputDefinitionSchema = z21.object({
+  id: z21.string(),
+  description: z21.string().nullish(),
+  default: z21.any().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(),
+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(),
   /**
    * Optional JSON schema or other metadata for future structured outputs.
    * Not interpreted by core today.
    */
-  outputSchema: z20.any().nullish(),
+  outputSchema: z21.any().nullish(),
   /**
    * Optional timeout in milliseconds. Step execution will be aborted if it exceeds this duration.
    */
-  timeout: z20.number().positive().nullish()
+  timeout: z21.number().positive().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))
+var WhileLoopStepSchema = z21.object({
+  id: z21.string(),
+  while: z21.object({
+    condition: z21.string().describe("JavaScript expression that evaluates to true/false"),
+    steps: z21.array(z21.lazy(() => WorkflowControlFlowStepSchema))
   }),
-  output: z20.string().nullish()
+  output: z21.string().nullish()
 });
-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()
+var IfElseStepSchema = z21.object({
+  id: z21.string(),
+  if: z21.object({
+    condition: z21.string().describe("JavaScript expression that evaluates to true/false"),
+    thenBranch: z21.array(z21.lazy(() => WorkflowControlFlowStepSchema)),
+    elseBranch: z21.array(z21.lazy(() => WorkflowControlFlowStepSchema)).optional()
   }),
-  output: z20.string().nullish()
+  output: z21.string().nullish()
 });
-var BreakStepSchema = z20.object({
-  break: z20.literal(true)
+var BreakStepSchema = z21.object({
+  break: z21.literal(true)
 });
-var ContinueStepSchema = z20.object({
-  continue: z20.literal(true)
+var ContinueStepSchema = z21.object({
+  continue: z21.literal(true)
 });
-var TryCatchStepSchema = z20.object({
-  id: z20.string(),
-  try: z20.object({
-    trySteps: z20.array(z20.lazy(() => WorkflowControlFlowStepSchema)),
-    catchSteps: z20.array(z20.lazy(() => WorkflowControlFlowStepSchema))
+var TryCatchStepSchema = z21.object({
+  id: z21.string(),
+  try: z21.object({
+    trySteps: z21.array(z21.lazy(() => WorkflowControlFlowStepSchema)),
+    catchSteps: z21.array(z21.lazy(() => WorkflowControlFlowStepSchema))
   }),
-  output: z20.string().nullish()
+  output: z21.string().nullish()
 });
-var WorkflowControlFlowStepSchema = z20.union([
+var WorkflowControlFlowStepSchema = z21.union([
   WorkflowStepDefinitionSchema,
   WhileLoopStepSchema,
   IfElseStepSchema,
@@ -2389,14 +2592,14 @@ var WorkflowControlFlowStepSchema = z20.union([
   ContinueStepSchema,
   TryCatchStepSchema
 ]);
-var WorkflowDefinitionSchema = z20.object({
-  task: z20.string(),
-  inputs: z20.array(WorkflowInputDefinitionSchema).nullish(),
-  steps: z20.array(WorkflowControlFlowStepSchema),
-  output: z20.string().nullish()
+var WorkflowDefinitionSchema = z21.object({
+  task: z21.string(),
+  inputs: z21.array(WorkflowInputDefinitionSchema).nullish(),
+  steps: z21.array(WorkflowControlFlowStepSchema),
+  output: z21.string().nullish()
 });
-var WorkflowFileSchema = z20.object({
-  workflows: z20.record(z20.string(), WorkflowDefinitionSchema)
+var WorkflowFileSchema = z21.object({
+  workflows: z21.record(z21.string(), WorkflowDefinitionSchema)
 });
 
 // src/workflow/dynamic.ts
@@ -2405,26 +2608,26 @@ function convertJsonSchemaToZod(schema) {
   if (schema.enum) {
     const enumValues = schema.enum;
     if (enumValues.length === 0) {
-      return z21.never();
+      return z22.never();
     }
     if (enumValues.every((v) => typeof v === "string")) {
-      return z21.enum(enumValues);
+      return z22.enum(enumValues);
     }
-    const literals = enumValues.map((v) => z21.literal(v));
+    const literals = enumValues.map((v) => z22.literal(v));
     if (literals.length === 1) {
       return literals[0];
     }
-    return z21.union([literals[0], literals[1], ...literals.slice(2)]);
+    return z22.union([literals[0], literals[1], ...literals.slice(2)]);
   }
   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 === "string") return z22.string().nullable();
+      if (nonNullType === "number") return z22.number().nullable();
       if (nonNullType === "integer")
-        return z21.number().refine((val) => Number.isInteger(val)).nullable();
-      if (nonNullType === "boolean") return z21.boolean().nullable();
+        return z22.number().refine((val) => Number.isInteger(val)).nullable();
+      if (nonNullType === "boolean") return z22.boolean().nullable();
       if (nonNullType === "object") {
         const shape = {};
         if (schema.properties) {
@@ -2434,24 +2637,24 @@ function convertJsonSchemaToZod(schema) {
             shape[propName] = isRequired ? propZod : propZod.optional();
           }
         }
-        return z21.object(shape).nullable();
+        return z22.object(shape).nullable();
       }
-      if (nonNullType === "array") return z21.array(z21.any()).nullable();
+      if (nonNullType === "array") return z22.array(z22.any()).nullable();
     }
-    return z21.any();
+    return z22.any();
   }
   const type = schema.type;
   switch (type) {
     case "string":
-      return z21.string();
+      return z22.string();
     case "number":
-      return z21.number();
+      return z22.number();
     case "integer":
-      return z21.number().refine((val) => Number.isInteger(val), { message: "Expected an integer" });
+      return z22.number().refine((val) => Number.isInteger(val), { message: "Expected an integer" });
     case "boolean":
-      return z21.boolean();
+      return z22.boolean();
     case "null":
-      return z21.null();
+      return z22.null();
     case "object": {
       const shape = {};
       if (schema.properties) {
@@ -2462,23 +2665,23 @@ function convertJsonSchemaToZod(schema) {
         }
       }
       if (schema.additionalProperties === true) {
-        return z21.object(shape).passthrough();
+        return z22.object(shape).passthrough();
       }
       if (typeof schema.additionalProperties === "object") {
         const additionalSchema = convertJsonSchemaToZod(schema.additionalProperties);
-        return z21.intersection(z21.object(shape), z21.record(z21.string(), additionalSchema));
+        return z22.intersection(z22.object(shape), z22.record(z22.string(), additionalSchema));
       }
-      return z21.object(shape);
+      return z22.object(shape);
     }
     case "array": {
       if (!schema.items) {
-        return z21.array(z21.any());
+        return z22.array(z22.any());
       }
       const itemSchema = convertJsonSchemaToZod(schema.items);
-      return z21.array(itemSchema);
+      return z22.array(itemSchema);
     }
     default:
-      return z21.any();
+      return z22.any();
   }
 }
 var TOOL_GROUPS = {
@@ -2549,7 +2752,7 @@ function parseDynamicWorkflowDefinition(source) {
     const raw = parse2(source);
     const validated = WorkflowFileSchema.safeParse(raw);
     if (!validated.success) {
-      return { success: false, error: z21.prettifyError(validated.error) };
+      return { success: false, error: z22.prettifyError(validated.error) };
     }
     const validation = validateWorkflowFile(validated.data);
     if (!validation.success) {
@@ -2842,9 +3045,9 @@ async function executeStepWithAgent(stepDef, workflowId, input, state, context,
     toolsForAgent.push({
       name: "runWorkflow",
       description: "Run a named sub-workflow defined in the current workflow file.",
-      parameters: z21.object({
-        workflowId: z21.string().describe("Sub-workflow id to run"),
-        input: z21.any().nullish().describe("Optional input object for the sub-workflow")
+      parameters: z22.object({
+        workflowId: z22.string().describe("Sub-workflow id to run"),
+        input: z22.any().nullish().describe("Optional input object for the sub-workflow")
       }),
       handler: async () => {
         return { success: false, message: { type: "error-text", value: "runWorkflow is virtual." } };
@@ -3446,6 +3649,7 @@ var makeStepFn = () => {
 export {
   BreakStepSchema,
   ContinueStepSchema,
+  DEFAULT_MEMORY_CONFIG,
   IGNORED_DIRECTORIES,
   IfElseStepSchema,
   ListSkillsInputSchema,
@@ -3484,6 +3688,10 @@ export {
   convertJsonSchemaToZod,
   createContext,
   createDynamicWorkflow,
+  createErrorResponse,
+  createProviderErrorResponse,
+  createSuccessResponse,
+  createValidationErrorResponse,
   executeCommand_default as executeCommand,
   fetchUrl_default as fetchUrl,
   fromJsonModelMessage,
@@ -3495,6 +3703,7 @@ export {
   loadSkillToolInfo,
   makeStepFn,
   mcpServerConfigSchema,
+  memoryConfigSchema,
   parseDynamicWorkflowDefinition,
   parseJsonFromMarkdown,
   providerConfigSchema,
@@ -3507,6 +3716,7 @@ export {
   renameFile_default as renameFile,
   replaceInFile_default as replaceInFile,
   replaceInFile as replaceInFileHelper,
+  resolveHomePath,
   responsePrompts,
   ruleSchema,
   scriptSchema,