@polka-codes/core 0.9.89 → 0.9.91

package/dist/index.js

@@ -126,14 +126,47 @@ function computeRateLimitBackoffSeconds(count, baseSeconds = 2, capSeconds = 60)
 }
 
 // src/config.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
-// src/config/memory.ts
+// src/config/base.ts
 import { z } from "zod";
-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")
+var baseModelConfigSchema = z.object({
+  provider: z.string().optional(),
+  model: z.string().optional(),
+  parameters: z.record(z.string(), z.unknown()).optional()
+});
+var baseApprovalConfigSchema = z.object({
+  level: z.enum(["none", "destructive", "commits", "all"]).optional(),
+  autoApprove: z.boolean().optional(),
+  maxCost: z.number().positive().optional()
+});
+var providerConfigSchema = z.object({
+  apiKey: z.string().optional(),
+  defaultModel: z.string().optional(),
+  defaultParameters: z.record(z.string(), z.unknown()).optional(),
+  location: z.string().optional(),
+  project: z.string().optional(),
+  keyFile: z.string().optional(),
+  baseUrl: z.string().optional(),
+  name: z.string().optional()
+});
+var modelConfigSchema = baseModelConfigSchema.extend({
+  budget: z.number().positive().optional(),
+  rules: z.union([z.string(), z.array(z.string()).optional()]).optional()
+});
+var toolConfigSchema = z.union([
+  z.boolean(),
+  // Simple enable/disable
+  baseModelConfigSchema
+  // Model override for this tool
+]);
+
+// src/config/memory.ts
+import { z as z2 } from "zod";
+var memoryConfigSchema = z2.object({
+  enabled: z2.boolean().optional().default(true),
+  type: z2.enum(["sqlite", "memory"]).optional().default("sqlite"),
+  path: z2.string().optional().default("~/.config/polka-codes/memory.sqlite")
 }).strict().optional();
 var DEFAULT_MEMORY_CONFIG = {
   enabled: true,
@@ -142,170 +175,191 @@ var DEFAULT_MEMORY_CONFIG = {
 };
 function resolveHomePath(path) {
   if (path.startsWith("~")) {
-    return `${process.env.HOME}${path.slice(1)}`;
+    const home = process.env.HOME || process.env.USERPROFILE || ".";
+    if (home === ".") {
+      throw new Error("Cannot resolve home directory: HOME and USERPROFILE environment variables are not set");
+    }
+    return `${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()
+var ruleSchema = z3.union([
+  z3.string(),
+  z3.object({ path: z3.string() }).strict(),
+  z3.object({ url: z3.string() }).strict(),
+  z3.object({
+    repo: z3.string(),
+    path: z3.string(),
+    tag: z3.string().optional(),
+    commit: z3.string().optional(),
+    branch: z3.string().optional()
   }).strict()
 ]);
-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 = 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 providerModelSchema = z3.object({
+  provider: z3.string().optional(),
+  model: z3.string().optional(),
+  parameters: z3.record(z3.string(), z3.unknown()).optional(),
+  budget: z3.number().positive().optional(),
+  rules: z3.array(ruleSchema).optional().or(z3.string()).optional()
 });
-var scriptSchema = z2.union([
+var scriptSchema = z3.union([
   // Type 1: Simple shell command (backward compatible)
-  z2.string(),
+  z3.string(),
   // Type 2: Object with command and description (backward compatible)
-  z2.object({
-    command: z2.string(),
-    description: z2.string()
+  z3.object({
+    command: z3.string(),
+    description: z3.string()
   }).strict(),
   // Type 3: Reference to dynamic workflow YAML
-  z2.object({
-    workflow: z2.string(),
+  z3.object({
+    workflow: z3.string(),
     // Path to .yml workflow file
-    description: z2.string().optional(),
-    input: z2.record(z2.string(), z2.any()).optional()
+    description: z3.string().optional(),
+    input: z3.record(z3.string(), z3.unknown()).optional()
     // Default workflow input
   }).strict(),
   // Type 4: TypeScript script file (NEW)
-  z2.object({
-    script: z2.string(),
+  z3.object({
+    script: z3.string(),
     // Path to .ts file
-    description: z2.string().optional(),
-    permissions: z2.object({
-      fs: z2.enum(["read", "write", "none"]).optional(),
-      network: z2.boolean().optional(),
-      subprocess: z2.boolean().optional()
+    description: z3.string().optional(),
+    permissions: z3.object({
+      fs: z3.enum(["read", "write", "none"]).optional(),
+      network: z3.boolean().optional(),
+      subprocess: z3.boolean().optional()
     }).optional(),
-    timeout: z2.number().int().positive().max(36e5).optional(),
+    timeout: z3.number().int().positive().max(36e5).optional(),
     // Max 1 hour in milliseconds
-    memory: z2.number().int().positive().min(64).max(8192).optional()
+    memory: z3.number().int().positive().min(64).max(8192).optional()
     // 64MB-8GB in MB
   }).strict()
 ]);
-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()
+var mcpServerConfigSchema = z3.object({
+  command: z3.string(),
+  args: z3.array(z3.string()).optional(),
+  env: z3.record(z3.string(), z3.string()).optional(),
+  tools: z3.record(
+    z3.string(),
+    z3.boolean().or(
+      z3.object({
+        provider: z3.string().optional(),
+        model: z3.string().optional(),
+        parameters: z3.record(z3.string(), z3.unknown()).optional()
       }).strict()
     )
   ).optional()
 }).strict();
-var agentContinuousImprovementSchema = z2.object({
-  sleepTimeOnNoTasks: z2.number().int().optional(),
-  sleepTimeBetweenTasks: z2.number().int().optional(),
-  maxCycles: z2.number().int().optional()
+var agentContinuousImprovementSchema = z3.object({
+  sleepTimeOnNoTasks: z3.number().int().optional(),
+  sleepTimeBetweenTasks: z3.number().int().optional(),
+  maxCycles: z3.number().int().optional()
 }).strict().optional();
-var agentDiscoverySchema = z2.object({
-  enabledStrategies: z2.array(z2.string()).optional(),
-  cacheTime: z2.number().int().optional(),
-  checkChanges: z2.boolean().optional()
+var agentDiscoverySchema = z3.object({
+  enabledStrategies: z3.array(z3.string()).optional(),
+  cacheTime: z3.number().int().optional(),
+  checkChanges: z3.boolean().optional()
 }).strict().optional();
-var agentSafetySchema = z2.object({
-  enabledChecks: z2.array(z2.string()).optional(),
-  blockDestructive: z2.boolean().optional(),
-  maxFileSize: z2.number().int().optional()
+var agentSafetySchema = z3.object({
+  enabledChecks: z3.array(z3.string()).optional(),
+  blockDestructive: z3.boolean().optional(),
+  maxFileSize: z3.number().int().optional()
 }).strict().optional();
-var agentHealthCheckSchema = z2.object({
-  enabled: z2.boolean().optional(),
-  interval: z2.number().int().optional()
+var agentHealthCheckSchema = z3.object({
+  enabled: z3.boolean().optional(),
+  interval: z3.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()
+var agentApprovalSchema = z3.object({
+  level: z3.enum(["none", "destructive", "commits", "all"]).optional(),
+  autoApproveSafeTasks: z3.boolean().optional(),
+  maxAutoApprovalCost: z3.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(),
+var agentSchema = z3.object({
+  preset: z3.string().optional(),
+  strategy: z3.enum(["goal-directed", "continuous-improvement"]).optional(),
+  continueOnCompletion: z3.boolean().optional(),
+  maxIterations: z3.number().int().optional(),
+  timeout: z3.number().int().optional(),
+  requireApprovalFor: z3.enum(["none", "destructive", "commits", "all"]).optional(),
+  autoApproveSafeTasks: z3.boolean().optional(),
+  maxAutoApprovalCost: z3.number().optional(),
+  pauseOnError: z3.boolean().optional(),
+  workingBranch: z3.string().optional(),
+  destructiveOperations: z3.array(z3.string()).optional(),
+  maxConcurrency: z3.number().int().optional(),
+  autoSaveInterval: z3.number().int().optional(),
+  workingDir: z3.string().optional(),
   continuousImprovement: agentContinuousImprovementSchema,
   discovery: agentDiscoverySchema,
   safety: agentSafetySchema,
   healthCheck: agentHealthCheckSchema,
   approval: agentApprovalSchema
 }).strict().optional();
-var configSchema = z2.object({
-  prices: z2.record(
-    z2.string(),
+var configSchema = z3.object({
+  prices: z3.record(
+    z3.string(),
     // provider
-    z2.record(
-      z2.string(),
+    z3.record(
+      z3.string(),
       // model
-      z2.object({
-        inputPrice: z2.number().optional(),
-        outputPrice: z2.number().optional(),
-        cacheWritesPrice: z2.number().optional(),
-        cacheReadsPrice: z2.number().optional()
+      z3.object({
+        inputPrice: z3.number().optional(),
+        outputPrice: z3.number().optional(),
+        cacheWritesPrice: z3.number().optional(),
+        cacheReadsPrice: z3.number().optional()
       })
     )
   ).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()
+  providers: z3.record(z3.string(), providerConfigSchema).optional(),
+  defaultProvider: z3.string().optional(),
+  defaultModel: z3.string().optional(),
+  defaultParameters: z3.record(z3.string(), z3.unknown()).optional(),
+  maxMessageCount: z3.number().int().positive().optional(),
+  budget: z3.number().positive().optional(),
+  retryCount: z3.number().int().min(0).optional(),
+  requestTimeoutSeconds: z3.number().int().positive().optional(),
+  summaryThreshold: z3.number().int().positive().optional(),
+  scripts: z3.record(z3.string(), scriptSchema).optional(),
+  commands: z3.record(z3.string(), providerModelSchema).optional(),
+  tools: z3.object({
+    search: providerModelSchema.or(z3.boolean()).optional()
   }).optional(),
-  mcpServers: z2.record(z2.string(), mcpServerConfigSchema).optional(),
-  rules: z2.array(ruleSchema).optional().or(z2.string()).optional(),
-  excludeFiles: z2.array(z2.string()).optional(),
+  mcpServers: z3.record(z3.string(), mcpServerConfigSchema).optional(),
+  rules: z3.array(ruleSchema).optional().or(z3.string()).optional(),
+  excludeFiles: z3.array(z3.string()).optional(),
   agent: agentSchema,
   memory: memoryConfigSchema
 }).strict().nullish();
 
+// src/errors/base.ts
+var BaseError = class extends Error {
+  constructor(name, message, cause) {
+    super(message);
+    this.name = name;
+    this.cause = cause;
+    this.name = name;
+    if (cause) {
+      this.cause = cause;
+    }
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+};
+function createErrorClass(name, template) {
+  class NamedError extends BaseError {
+    constructor(...args) {
+      const message = template(args);
+      const lastArg = args[args.length - 1];
+      const cause = lastArg instanceof Error ? lastArg : void 0;
+      super(name, message, cause);
+    }
+  }
+  Object.defineProperty(NamedError, "name", { value: name });
+  return NamedError;
+}
+
 // src/fs/node-provider.ts
 import { existsSync } from "fs";
 import { readdir, readFile, stat } from "fs/promises";
@@ -406,11 +460,11 @@ import { parse } from "yaml";
 import { ZodError } from "zod";
 
 // src/skills/types.ts
-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()
+import { z as z4 } from "zod";
+var skillMetadataSchema = z4.object({
+  name: z4.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: z4.string().max(1024, "Description must be at most 1024 characters"),
+  allowedTools: z4.array(z4.string()).optional()
 });
 var SkillDiscoveryError = class extends Error {
   constructor(message, path) {
@@ -824,19 +878,19 @@ function getSkillStats(skill) {
 }
 
 // src/skills/tools/listSkills.ts
-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")
+import { z as z5 } from "zod";
+var ListSkillsInputSchema = z5.object({
+  filter: z5.string().optional().describe("Optional filter string to match against skill names and descriptions")
 });
-var ListSkillsOutputSchema = z4.object({
-  skills: z4.array(
-    z4.object({
-      name: z4.string(),
-      description: z4.string(),
-      source: z4.enum(["personal", "project", "plugin"])
+var ListSkillsOutputSchema = z5.object({
+  skills: z5.array(
+    z5.object({
+      name: z5.string(),
+      description: z5.string(),
+      source: z5.enum(["personal", "project", "plugin"])
     })
   ),
-  total: z4.number()
+  total: z5.number()
 });
 async function listSkills(input, context) {
   const { filter } = input;
@@ -862,20 +916,20 @@ var listSkillsToolInfo = {
 };
 
 // src/skills/tools/loadSkill.ts
-import { z as z5 } from "zod";
-var LoadSkillInputSchema = z5.object({
-  skillName: z5.string().describe("The name of the skill to load")
+import { z as z6 } from "zod";
+var LoadSkillInputSchema = z6.object({
+  skillName: z6.string().describe("The name of the skill to load")
 });
-var LoadSkillOutputSchema = z5.object({
-  success: z5.boolean(),
-  skill: z5.object({
-    name: z5.string(),
-    description: z5.string(),
-    content: z5.string(),
-    availableFiles: z5.array(z5.string())
+var LoadSkillOutputSchema = z6.object({
+  success: z6.boolean(),
+  skill: z6.object({
+    name: z6.string(),
+    description: z6.string(),
+    content: z6.string(),
+    availableFiles: z6.array(z6.string())
   }).optional(),
-  error: z5.string().optional(),
-  warnings: z5.array(z5.string()).optional()
+  error: z6.string().optional(),
+  warnings: z6.array(z6.string()).optional()
 });
 async function loadSkill(input, context) {
   const { skillName } = input;
@@ -924,15 +978,15 @@ var loadSkillToolInfo = {
 };
 
 // src/skills/tools/readSkillFile.ts
-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")')
+import { z as z7 } from "zod";
+var ReadSkillFileInputSchema = z7.object({
+  skillName: z7.string().describe("The name of the skill"),
+  filename: z7.string().describe('The name of the file to read (e.g., "reference.md", "scripts/helper.py")')
 });
-var ReadSkillFileOutputSchema = z6.object({
-  success: z6.boolean(),
-  content: z6.string().optional(),
-  error: z6.string().optional()
+var ReadSkillFileOutputSchema = z7.object({
+  success: z7.boolean(),
+  content: z7.string().optional(),
+  error: z7.string().optional()
 });
 async function readSkillFile(input, context) {
   const { skillName, filename } = input;
@@ -970,16 +1024,16 @@ var readSkillFileToolInfo = {
 };
 
 // src/tools/askFollowupQuestion.ts
-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" })
+import { z as z8 } from "zod";
+var questionObject = z8.object({
+  prompt: z8.string().describe("The text of the question.").meta({ usageValue: "question text here" }),
+  options: z8.array(z8.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: z7.object({
-    questions: z7.array(questionObject).describe("One or more follow-up questions you need answered before you can continue.").meta({ usageValue: "questions here" })
+  parameters: z8.object({
+    questions: z8.array(questionObject).describe("One or more follow-up questions you need answered before you can continue.").meta({ usageValue: "questions here" })
   }).meta({
     examples: [
       {
@@ -1067,7 +1121,7 @@ var askFollowupQuestion_default = {
 };
 
 // src/tools/executeCommand.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/tools/response-builders.ts
 function createSuccessResponse(value, type = "text") {
@@ -1122,9 +1176,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: 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(
+  parameters: z9.object({
+    command: z9.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: z9.preprocess(preprocessBoolean, z9.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({
@@ -1195,16 +1249,16 @@ var executeCommand_default = {
 };
 
 // src/tools/fetchUrl.ts
-import { z as z9 } from "zod";
+import { z as z10 } 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: z9.object({
-    url: z9.preprocess((val) => {
+  parameters: z10.object({
+    url: z10.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);
-    }, z9.array(z9.string())).describe("One or more URLs to fetch, separated by commas if multiple.").meta({ usageValue: "url" })
+    }, z10.array(z10.string())).describe("One or more URLs to fetch, separated by commas if multiple.").meta({ usageValue: "url" })
   }).meta({
     examples: [
       {
@@ -1273,15 +1327,15 @@ var fetchUrl_default = {
 };
 
 // src/tools/listFiles.ts
-import { z as z10 } from "zod";
+import { z as z11 } 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: 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)" })
+  parameters: z11.object({
+    path: z11.string().describe("The path of the directory to list contents for (relative to the current working directory)").meta({ usageValue: "Directory path here" }),
+    maxCount: z11.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: z11.preprocess(preprocessBoolean, z11.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: z11.preprocess(preprocessBoolean, z11.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: [
       {
@@ -1379,12 +1433,12 @@ var MockProvider = class {
 };
 
 // src/tools/readBinaryFile.ts
-import { z as z11 } from "zod";
+import { z as z12 } 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: z11.object({
-    url: z11.string().describe("The URL or local path of the file to read.")
+  parameters: z12.object({
+    url: z12.string().describe("The URL or local path of the file to read.")
   })
 };
 var handler5 = async (provider, args) => {
@@ -1431,7 +1485,7 @@ var readBinaryFile_default = {
 };
 
 // src/tools/readFile.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var toolInfo6 = {
   name: "readFile",
   description: `Request to read the contents of one or multiple files at the specified paths.
@@ -1457,17 +1511,17 @@ Features:
 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) => {
+  parameters: z13.object({
+    path: z13.preprocess((val) => {
       if (!val) return [];
       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)" })
+    }, z13.array(z13.string())).describe("The path of the file to read").meta({ usageValue: "Comma separated paths here" }),
+    offset: z13.number().optional().describe("Skip first N lines (for partial file reading)").meta({ usageValue: "100" }),
+    limit: z13.number().optional().describe("Read at most N lines (for partial file reading)").meta({ usageValue: "50" }),
+    includeIgnored: z13.preprocess(preprocessBoolean, z13.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: [
       {
@@ -1543,12 +1597,12 @@ var readFile_default = {
 };
 
 // src/tools/removeFile.ts
-import { z as z13 } from "zod";
+import { z as z14 } 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: z14.object({
+    path: z14.string().describe("The path of the file to remove").meta({ usageValue: "File path here" })
   }).meta({
     examples: [
       {
@@ -1590,13 +1644,13 @@ var removeFile_default = {
 };
 
 // src/tools/renameFile.ts
-import { z as z14 } from "zod";
+import { z as z15 } 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: z15.object({
+    source_path: z15.string().describe("The current path of the file").meta({ usageValue: "Source file path here" }),
+    target_path: z15.string().describe("The new path for the file").meta({ usageValue: "Target file path here" })
   }).meta({
     examples: [
       {
@@ -1635,7 +1689,7 @@ var renameFile_default = {
 };
 
 // src/tools/replaceInFile.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 
 // src/tools/utils/replaceInFile.ts
 var replaceInFile = (fileContent, diff) => {
@@ -1768,9 +1822,9 @@ 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(
+  parameters: z16.object({
+    path: z16.string().describe("The path of the file to modify").meta({ usageValue: "File path here" }),
+    diff: z16.string().describe(
       `One or more SEARCH/REPLACE blocks following this exact format:
 \`\`\`
 <<<<<<< SEARCH
@@ -1956,12 +2010,12 @@ var replaceInFile_default = {
 };
 
 // src/tools/search.ts
-import { z as z16 } from "zod";
+import { z as z17 } 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: z17.object({
+    query: z17.string().describe("The query to search for").meta({ usageValue: "Your search query here" })
   }).meta({
     examples: [
       {
@@ -2011,18 +2065,18 @@ var search_default = {
 };
 
 // src/tools/searchFiles.ts
-import { z as z17 } from "zod";
+import { z as z18 } 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: z18.object({
+    path: z18.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: z18.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: z18.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)"
@@ -2092,20 +2146,20 @@ var searchFiles_default = {
 };
 
 // src/tools/todo.ts
-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(),
+import { z as z19 } from "zod";
+var TodoStatus = z19.enum(["open", "completed", "closed"]);
+var TodoItemSchema = z19.object({
+  id: z19.string(),
+  title: z19.string(),
+  description: z19.string(),
   status: TodoStatus
 });
-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(),
+var UpdateTodoItemInputSchema = z19.object({
+  operation: z19.enum(["add", "update"]),
+  id: z19.string().nullish(),
+  parentId: z19.string().nullish(),
+  title: z19.string().nullish(),
+  description: z19.string().nullish(),
   status: TodoStatus.nullish()
 }).superRefine((data, ctx) => {
   if (data.operation === "add") {
@@ -2126,12 +2180,12 @@ var UpdateTodoItemInputSchema = z18.object({
     }
   }
 });
-var UpdateTodoItemOutputSchema = z18.object({
-  id: z18.string()
+var UpdateTodoItemOutputSchema = z19.object({
+  id: z19.string()
 });
 
 // src/tools/writeToFile.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var toolInfo12 = {
   name: "writeToFile",
   description: `Request to write content to a file at the specified path.
@@ -2155,9 +2209,9 @@ 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(
+  parameters: z20.object({
+    path: z20.string().describe("The path of the file to write to").meta({ usageValue: "File path here" }),
+    content: z20.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({
@@ -2360,9 +2414,22 @@ var UsageMeter = class {
   }
 };
 
+// src/utils/merge.ts
+function deepMerge(base, override, deepPaths) {
+  const result = { ...base, ...override };
+  for (const path of deepPaths) {
+    const baseValue = base[path];
+    const overrideValue = override[path];
+    if (typeof baseValue === "object" && baseValue !== null && !Array.isArray(baseValue) && typeof overrideValue === "object" && overrideValue !== null && !Array.isArray(overrideValue)) {
+      result[path] = { ...baseValue, ...overrideValue };
+    }
+  }
+  return result;
+}
+
 // src/workflow/agent.workflow.ts
 import { jsonSchema } from "ai";
-import { toJSONSchema, z as z20 } from "zod";
+import { toJSONSchema, z as z21 } from "zod";
 
 // src/workflow/types.ts
 var TaskEventKind = /* @__PURE__ */ ((TaskEventKind2) => {
@@ -2446,7 +2513,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: ${z21.prettifyError(validated.error)}. Please correct the output.`;
         nextMessage = [{ role: "user", content: errorMessage }];
         continue;
       }
@@ -2528,63 +2595,63 @@ var agentWorkflow = async (input, { step, tools, logger }) => {
 
 // src/workflow/dynamic.ts
 import { parse as parse2 } from "yaml";
-import { z as z22 } from "zod";
+import { z as z23 } 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 z22 } from "zod";
+var WorkflowInputDefinitionSchema = z22.object({
+  id: z22.string(),
+  description: z22.string().nullish(),
+  default: z22.unknown().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 = z22.object({
+  id: z22.string(),
+  tools: z22.array(z22.string()).nullish(),
+  task: z22.string(),
+  output: z22.string().nullish(),
+  expected_outcome: z22.string().nullish(),
   /**
    * Optional JSON schema or other metadata for future structured outputs.
    * Not interpreted by core today.
    */
-  outputSchema: z21.any().nullish(),
+  outputSchema: z22.unknown().nullish(),
   /**
    * Optional timeout in milliseconds. Step execution will be aborted if it exceeds this duration.
    */
-  timeout: z21.number().positive().nullish()
+  timeout: z22.number().positive().nullish()
 });
-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))
+var WhileLoopStepSchema = z22.object({
+  id: z22.string(),
+  while: z22.object({
+    condition: z22.string().describe("JavaScript expression that evaluates to true/false"),
+    steps: z22.array(z22.lazy(() => WorkflowControlFlowStepSchema))
   }),
-  output: z21.string().nullish()
+  output: z22.string().nullish()
 });
-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()
+var IfElseStepSchema = z22.object({
+  id: z22.string(),
+  if: z22.object({
+    condition: z22.string().describe("JavaScript expression that evaluates to true/false"),
+    thenBranch: z22.array(z22.lazy(() => WorkflowControlFlowStepSchema)),
+    elseBranch: z22.array(z22.lazy(() => WorkflowControlFlowStepSchema)).optional()
   }),
-  output: z21.string().nullish()
+  output: z22.string().nullish()
 });
-var BreakStepSchema = z21.object({
-  break: z21.literal(true)
+var BreakStepSchema = z22.object({
+  break: z22.literal(true)
 });
-var ContinueStepSchema = z21.object({
-  continue: z21.literal(true)
+var ContinueStepSchema = z22.object({
+  continue: z22.literal(true)
 });
-var TryCatchStepSchema = z21.object({
-  id: z21.string(),
-  try: z21.object({
-    trySteps: z21.array(z21.lazy(() => WorkflowControlFlowStepSchema)),
-    catchSteps: z21.array(z21.lazy(() => WorkflowControlFlowStepSchema))
+var TryCatchStepSchema = z22.object({
+  id: z22.string(),
+  try: z22.object({
+    trySteps: z22.array(z22.lazy(() => WorkflowControlFlowStepSchema)),
+    catchSteps: z22.array(z22.lazy(() => WorkflowControlFlowStepSchema))
   }),
-  output: z21.string().nullish()
+  output: z22.string().nullish()
 });
-var WorkflowControlFlowStepSchema = z21.union([
+var WorkflowControlFlowStepSchema = z22.union([
   WorkflowStepDefinitionSchema,
   WhileLoopStepSchema,
   IfElseStepSchema,
@@ -2592,14 +2659,14 @@ var WorkflowControlFlowStepSchema = z21.union([
   ContinueStepSchema,
   TryCatchStepSchema
 ]);
-var WorkflowDefinitionSchema = z21.object({
-  task: z21.string(),
-  inputs: z21.array(WorkflowInputDefinitionSchema).nullish(),
-  steps: z21.array(WorkflowControlFlowStepSchema),
-  output: z21.string().nullish()
+var WorkflowDefinitionSchema = z22.object({
+  task: z22.string(),
+  inputs: z22.array(WorkflowInputDefinitionSchema).nullish(),
+  steps: z22.array(WorkflowControlFlowStepSchema),
+  output: z22.string().nullish()
 });
-var WorkflowFileSchema = z21.object({
-  workflows: z21.record(z21.string(), WorkflowDefinitionSchema)
+var WorkflowFileSchema = z22.object({
+  workflows: z22.record(z22.string(), WorkflowDefinitionSchema)
 });
 
 // src/workflow/dynamic.ts
@@ -2608,26 +2675,26 @@ function convertJsonSchemaToZod(schema) {
   if (schema.enum) {
     const enumValues = schema.enum;
     if (enumValues.length === 0) {
-      return z22.never();
+      return z23.never();
     }
     if (enumValues.every((v) => typeof v === "string")) {
-      return z22.enum(enumValues);
+      return z23.enum(enumValues);
     }
-    const literals = enumValues.map((v) => z22.literal(v));
+    const literals = enumValues.map((v) => z23.literal(v));
     if (literals.length === 1) {
       return literals[0];
     }
-    return z22.union([literals[0], literals[1], ...literals.slice(2)]);
+    return z23.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 z22.string().nullable();
-      if (nonNullType === "number") return z22.number().nullable();
+      if (nonNullType === "string") return z23.string().nullable();
+      if (nonNullType === "number") return z23.number().nullable();
       if (nonNullType === "integer")
-        return z22.number().refine((val) => Number.isInteger(val)).nullable();
-      if (nonNullType === "boolean") return z22.boolean().nullable();
+        return z23.number().refine((val) => Number.isInteger(val)).nullable();
+      if (nonNullType === "boolean") return z23.boolean().nullable();
       if (nonNullType === "object") {
         const shape = {};
         if (schema.properties) {
@@ -2637,24 +2704,24 @@ function convertJsonSchemaToZod(schema) {
             shape[propName] = isRequired ? propZod : propZod.optional();
           }
         }
-        return z22.object(shape).nullable();
+        return z23.object(shape).nullable();
       }
-      if (nonNullType === "array") return z22.array(z22.any()).nullable();
+      if (nonNullType === "array") return z23.array(z23.any()).nullable();
     }
-    return z22.any();
+    return z23.any();
   }
   const type = schema.type;
   switch (type) {
     case "string":
-      return z22.string();
+      return z23.string();
     case "number":
-      return z22.number();
+      return z23.number();
     case "integer":
-      return z22.number().refine((val) => Number.isInteger(val), { message: "Expected an integer" });
+      return z23.number().refine((val) => Number.isInteger(val), { message: "Expected an integer" });
     case "boolean":
-      return z22.boolean();
+      return z23.boolean();
     case "null":
-      return z22.null();
+      return z23.null();
     case "object": {
       const shape = {};
       if (schema.properties) {
@@ -2665,23 +2732,23 @@ function convertJsonSchemaToZod(schema) {
         }
       }
       if (schema.additionalProperties === true) {
-        return z22.object(shape).passthrough();
+        return z23.object(shape).passthrough();
       }
       if (typeof schema.additionalProperties === "object") {
         const additionalSchema = convertJsonSchemaToZod(schema.additionalProperties);
-        return z22.intersection(z22.object(shape), z22.record(z22.string(), additionalSchema));
+        return z23.intersection(z23.object(shape), z23.record(z23.string(), additionalSchema));
       }
-      return z22.object(shape);
+      return z23.object(shape);
     }
     case "array": {
       if (!schema.items) {
-        return z22.array(z22.any());
+        return z23.array(z23.any());
       }
       const itemSchema = convertJsonSchemaToZod(schema.items);
-      return z22.array(itemSchema);
+      return z23.array(itemSchema);
     }
     default:
-      return z22.any();
+      return z23.any();
   }
 }
 var TOOL_GROUPS = {
@@ -2752,7 +2819,7 @@ function parseDynamicWorkflowDefinition(source) {
     const raw = parse2(source);
     const validated = WorkflowFileSchema.safeParse(raw);
     if (!validated.success) {
-      return { success: false, error: z22.prettifyError(validated.error) };
+      return { success: false, error: z23.prettifyError(validated.error) };
     }
     const validation = validateWorkflowFile(validated.data);
     if (!validation.success) {
@@ -3045,9 +3112,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: z22.object({
-        workflowId: z22.string().describe("Sub-workflow id to run"),
-        input: z22.any().nullish().describe("Optional input object for the sub-workflow")
+      parameters: z23.object({
+        workflowId: z23.string().describe("Sub-workflow id to run"),
+        input: z23.any().nullish().describe("Optional input object for the sub-workflow")
       }),
       handler: async () => {
         return { success: false, message: { type: "error-text", value: "runWorkflow is virtual." } };
@@ -3647,6 +3714,7 @@ var makeStepFn = () => {
   };
 };
 export {
+  BaseError,
   BreakStepSchema,
   ContinueStepSchema,
   DEFAULT_MEMORY_CONFIG,
@@ -3683,15 +3751,19 @@ export {
   WorkflowStepDefinitionSchema,
   agentWorkflow,
   askFollowupQuestion_default as askFollowupQuestion,
+  baseApprovalConfigSchema,
+  baseModelConfigSchema,
   computeRateLimitBackoffSeconds,
   configSchema,
   convertJsonSchemaToZod,
   createContext,
   createDynamicWorkflow,
+  createErrorClass,
   createErrorResponse,
   createProviderErrorResponse,
   createSuccessResponse,
   createValidationErrorResponse,
+  deepMerge,
   executeCommand_default as executeCommand,
   fetchUrl_default as fetchUrl,
   fromJsonModelMessage,
@@ -3704,6 +3776,7 @@ export {
   makeStepFn,
   mcpServerConfigSchema,
   memoryConfigSchema,
+  modelConfigSchema,
   parseDynamicWorkflowDefinition,
   parseJsonFromMarkdown,
   providerConfigSchema,
@@ -3724,6 +3797,7 @@ export {
   searchFiles_default as searchFiles,
   skillMetadataSchema,
   toJsonModelMessage,
+  toolConfigSchema,
   validateSkillMetadata,
   validateSkillReferences,
   validateSkillSecurity,