@polka-codes/core 0.10.11 → 0.10.16

package/dist/index.js

@@ -1,4123 +1,21 @@
-// src/Agent/parseJsonFromMarkdown.ts
-var parseJsonFromMarkdown = (markdown) => {
-  const jsonRegex = /```(?:json)?\n([\s\S]*?)\n```/;
-  const match = markdown.match(jsonRegex);
-  const tryParse = (str) => {
-    try {
-      let parsed = JSON.parse(str);
-      if (typeof parsed === "string") {
-        try {
-          parsed = JSON.parse(parsed);
-        } catch {
-        }
-      }
-      return { success: true, data: parsed };
-    } catch (e) {
-      const error = e instanceof Error ? e.message : String(e);
-      return { success: false, error: `Failed to parse JSON: ${error}` };
-    }
-  };
-  if (match?.[1]) {
-    const content = match[1].trim();
-    return tryParse(content);
-  }
-  const parseResult = tryParse(markdown);
-  if (parseResult.success) {
-    return parseResult;
-  }
-  return { success: false, error: "No JSON object found in the string." };
-};
-
-// src/Agent/prompts.ts
-var NO_REASON_PROVIDED = "No reason provided";
-var responsePrompts = {
-  errorInvokeTool: (tool, error) => `An error occurred while invoking the tool "${tool}": ${error}`,
-  requireUseTool: `Error: No tool use detected. You MUST use a tool before proceeding.
-e.g. <tool_tool_name>tool_name</tool_tool_name>
-
-Ensure the opening and closing tags are correctly nested and closed, and that you are using the correct tool name.
-Avoid unnecessary text or symbols before or after the tool use.
-Avoid unnecessary escape characters or special characters.
-`,
-  requireUseToolNative: `Error: No tool use detected. You MUST use a tool before proceeding.
-`,
-  toolResults: (tool, result) => {
-    switch (result.type) {
-      case "text":
-        return [
-          {
-            type: "text",
-            text: `<tool_response name=${tool}>${result.value}</tool_response>`
-          }
-        ];
-      case "error-text":
-        return [
-          {
-            type: "text",
-            text: `<tool_response_error name=${tool}>${result.value}</tool_response_error>`
-          }
-        ];
-      case "json":
-        return [
-          {
-            type: "text",
-            text: `<tool_response_json name=${tool}>${JSON.stringify(result.value)}</tool_response_json>`
-          }
-        ];
-      case "error-json":
-        return [
-          {
-            type: "text",
-            text: `<tool_response_error_json name=${tool}>${JSON.stringify(result.value)}</tool_response_error_json>`
-          }
-        ];
-      case "content":
-        return [
-          {
-            type: "text",
-            text: `<tool_response name=${tool}>`
-          },
-          ...result.value.map((part) => {
-            if (part.type === "text") {
-              return part;
-            }
-            if ("mediaType" in part && "data" in part && part.mediaType.startsWith("image/")) {
-              return {
-                type: "image",
-                mediaType: part.mediaType,
-                image: part.data
-              };
-            }
-            if ("mediaType" in part && "data" in part) {
-              return {
-                type: "file",
-                mediaType: part.mediaType,
-                data: part.data
-              };
-            }
-            return {
-              type: "text",
-              text: JSON.stringify(part)
-            };
-          }),
-          {
-            type: "text",
-            text: "</tool_response>"
-          }
-        ];
-      case "execution-denied":
-        return [
-          {
-            type: "text",
-            text: `<tool_response_error name=${tool}>Execution denied: ${result.reason ?? NO_REASON_PROVIDED}</tool_response_error>`
-          }
-        ];
-      default: {
-        return [
-          {
-            type: "text",
-            text: `<tool_response_error name=${tool}>Unknown result type: ${JSON.stringify(result)}</tool_response_error>`
-          }
-        ];
-      }
-    }
-  },
-  commandResult: (command, exitCode, stdout, stderr) => `<command>${command}</command>
-<command_exit_code>${exitCode}</command_exit_code>
-<command_stdout>
-${stdout}
-</command_stdout>
-<command_stderr>
-${stderr}
-</command_stderr>`
-};
-
-// src/Agent/backoff.ts
-function computeRateLimitBackoffSeconds(count, baseSeconds = 2, capSeconds = 60) {
-  if (!Number.isFinite(count) || count <= 0) {
-    count = 1;
-  }
-  if (!Number.isFinite(baseSeconds) || baseSeconds <= 0) {
-    baseSeconds = 2;
-  }
-  if (!Number.isFinite(capSeconds) || capSeconds <= 0) {
-    capSeconds = 60;
-  }
-  const delay = baseSeconds * 2 ** (count - 1);
-  return Math.min(delay, capSeconds);
-}
-
-// src/config.ts
-import { z as z3 } from "zod";
-
-// src/config/base.ts
-import { z } from "zod";
-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/polkacodes/memory/memory.sqlite")
-}).strict().optional();
-var DEFAULT_MEMORY_CONFIG = {
-  enabled: true,
-  type: "sqlite",
-  path: "~/.config/polkacodes/memory/memory.sqlite"
-};
-function resolveHomePath(path) {
-  if (path.startsWith("~")) {
-    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 = 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 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 = z3.union([
-  // Type 1: Simple shell command (backward compatible)
-  z3.string(),
-  // Type 2: Object with command and description (backward compatible)
-  z3.object({
-    command: z3.string(),
-    description: z3.string()
-  }).strict(),
-  // Type 3: Reference to dynamic workflow YAML
-  z3.object({
-    workflow: z3.string(),
-    // Path to .yml workflow file
-    description: z3.string().optional(),
-    input: z3.record(z3.string(), z3.unknown()).optional()
-    // Default workflow input
-  }).strict(),
-  // Type 4: TypeScript script file (NEW)
-  z3.object({
-    script: z3.string(),
-    // Path to .ts file
-    description: z3.string().optional(),
-    permissions: z3.object({
-      fs: z3.enum(["read", "write", "none"]).optional(),
-      network: z3.boolean().optional(),
-      subprocess: z3.boolean().optional()
-    }).optional(),
-    timeout: z3.number().int().positive().max(36e5).optional(),
-    // Max 1 hour in milliseconds
-    memory: z3.number().int().positive().min(64).max(8192).optional()
-    // 64MB-8GB in MB
-  }).strict()
-]);
-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 = z3.object({
-  sleepTimeOnNoTasks: z3.number().int().optional(),
-  sleepTimeBetweenTasks: z3.number().int().optional(),
-  maxCycles: z3.number().int().optional()
-}).strict().optional();
-var agentDiscoverySchema = z3.object({
-  enabledStrategies: z3.array(z3.string()).optional(),
-  cacheTime: z3.number().int().optional(),
-  checkChanges: z3.boolean().optional()
-}).strict().optional();
-var agentSafetySchema = z3.object({
-  enabledChecks: z3.array(z3.string()).optional(),
-  blockDestructive: z3.boolean().optional(),
-  maxFileSize: z3.number().int().optional()
-}).strict().optional();
-var agentHealthCheckSchema = z3.object({
-  enabled: z3.boolean().optional(),
-  interval: z3.number().int().optional()
-}).strict().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 = 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 = z3.object({
-  prices: z3.record(
-    z3.string(),
-    // provider
-    z3.record(
-      z3.string(),
-      // model
-      z3.object({
-        inputPrice: z3.number().optional(),
-        outputPrice: z3.number().optional(),
-        cacheWritesPrice: z3.number().optional(),
-        cacheReadsPrice: z3.number().optional()
-      })
-    )
-  ).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: 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,
-  loadRules: z3.record(z3.string(), z3.boolean()).optional()
-}).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";
-import { join, normalize } from "path";
-var NodeFileSystemProvider = class {
-  constructor(_options = {}) {
-    this._options = _options;
-  }
-  exists(path) {
-    return existsSync(path);
-  }
-  async readdir(path) {
-    const entries = await readdir(path, { withFileTypes: true });
-    return entries.map((entry) => ({
-      name: entry.name,
-      isDirectory: entry.isDirectory(),
-      isFile: entry.isFile()
-    }));
-  }
-  async readFile(path) {
-    return readFile(path, "utf-8");
-  }
-  async readFileAsBuffer(path) {
-    const buffer = await readFile(path);
-    return new Uint8Array(buffer);
-  }
-  async stat(path) {
-    const stats = await stat(path);
-    return {
-      size: stats.size,
-      isDirectory: stats.isDirectory(),
-      isFile: stats.isFile()
-    };
-  }
-  join(...paths) {
-    return join(...paths);
-  }
-  normalize(path) {
-    return normalize(path);
-  }
-};
-
-// src/pricing/pricing-service.ts
-import { randomUUID } from "crypto";
-import { mkdir, readFile as readFile2, rename, writeFile } from "fs/promises";
-import { homedir } from "os";
-import { dirname, join as join2 } from "path";
-
-// src/pricing/converter.ts
-function convertPortkeyToModelInfo(portkey) {
-  return {
-    inputPrice: (portkey.request_token?.price ?? 0) * 10,
-    outputPrice: (portkey.response_token?.price ?? 0) * 10,
-    cacheWritesPrice: (portkey.cache_write_input_token?.price ?? 0) * 10,
-    cacheReadsPrice: (portkey.cache_read_input_token?.price ?? 0) * 10
-  };
-}
-
-// src/pricing/portkey-client.ts
-var PORTKEY_BASE_URL = "https://api.portkey.ai/model-configs/pricing";
-var TIMEOUT_MS = 5e3;
-var MAX_RETRIES = 2;
-async function fetchWithTimeout(url, timeoutMs) {
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const response = await fetch(url, { signal: controller.signal });
-    return response;
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-async function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function shouldRetry(response, error) {
-  if (error) return true;
-  if (response.status >= 500) return true;
-  return false;
-}
-async function fetchPricing(provider, model) {
-  const url = `${PORTKEY_BASE_URL}/${provider}/${model}`;
-  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-    try {
-      const response = await fetchWithTimeout(url, TIMEOUT_MS);
-      if (!response.ok) {
-        if (!shouldRetry(response, null)) {
-          return null;
-        }
-        if (attempt < MAX_RETRIES) {
-          await sleep(2 ** attempt * 1e3);
-          continue;
-        }
-        return null;
-      }
-      const data = await response.json();
-      return data;
-    } catch (error) {
-      if (attempt < MAX_RETRIES && shouldRetry(new Response(null, { status: 500 }), error)) {
-        await sleep(2 ** attempt * 1e3);
-        continue;
-      }
-      return null;
-    }
-  }
-  return null;
-}
-
-// src/pricing/pricing-service.ts
-var CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
-var PricingService = class {
-  #fallbackPrices;
-  #cacheFile;
-  #cache = null;
-  #loadPromise = null;
-  constructor(fallbackPrices = {}) {
-    const normalized = {};
-    for (const [provider, providerInfo] of Object.entries(fallbackPrices)) {
-      const normalizedProvider = provider.split("-")[0];
-      normalized[normalizedProvider] = {};
-      for (const [model, modelInfo] of Object.entries(providerInfo)) {
-        const normalizedModel = model.replace(/[.-]/g, "");
-        normalized[normalizedProvider][normalizedModel] = {
-          inputPrice: modelInfo.inputPrice ?? 0,
-          outputPrice: modelInfo.outputPrice ?? 0,
-          cacheWritesPrice: modelInfo.cacheWritesPrice ?? 0,
-          cacheReadsPrice: modelInfo.cacheReadsPrice ?? 0
-        };
-      }
-    }
-    this.#fallbackPrices = normalized;
-    this.#cacheFile = join2(homedir(), ".config", "polkacodes", "pricing-cache.json");
-  }
-  async #load() {
-    if (this.#loadPromise) {
-      return this.#loadPromise;
-    }
-    this.#loadPromise = (async () => {
-      this.#cache = /* @__PURE__ */ new Map();
-      try {
-        const content = await readFile2(this.#cacheFile, "utf-8");
-        const data = JSON.parse(content);
-        for (const [key, value] of Object.entries(data)) {
-          this.#cache.set(key, value);
-        }
-      } catch {
-      }
-    })();
-    return this.#loadPromise;
-  }
-  async #get(provider, model) {
-    await this.#load();
-    const key = `${provider}:${model}`;
-    const entry = this.#cache?.get(key);
-    if (!entry) {
-      return null;
-    }
-    if (Date.now() - entry.timestamp > CACHE_TTL_MS) {
-      this.#cache?.delete(key);
-      return null;
-    }
-    return entry.pricing;
-  }
-  async #set(provider, model, pricing) {
-    await this.#load();
-    const key = `${provider}:${model}`;
-    this.#cache?.set(key, {
-      pricing,
-      timestamp: Date.now()
-    });
-    await this.#save();
-  }
-  async #save() {
-    if (!this.#cache) {
-      return;
-    }
-    try {
-      const dir = dirname(this.#cacheFile);
-      await mkdir(dir, { recursive: true });
-      const data = {};
-      for (const [key, value] of this.#cache.entries()) {
-        data[key] = value;
-      }
-      const tempFile = `${this.#cacheFile}.${randomUUID()}.tmp`;
-      await writeFile(tempFile, JSON.stringify(data, null, 2), "utf-8");
-      await rename(tempFile, this.#cacheFile);
-    } catch {
-    }
-  }
-  async getPricing(provider, model) {
-    const normalizedProvider = provider.split("-")[0];
-    const normalizedModel = model.replace(/[.-]/g, "");
-    const cached = await this.#get(normalizedProvider, normalizedModel);
-    if (cached) {
-      return cached;
-    }
-    const fallbackPrice = this.#fallbackPrices[normalizedProvider]?.[normalizedModel];
-    if (fallbackPrice) {
-      return fallbackPrice;
-    }
-    const portkeyPricing = await fetchPricing(normalizedProvider, model);
-    if (portkeyPricing) {
-      const modelInfo = convertPortkeyToModelInfo(portkeyPricing);
-      await this.#set(normalizedProvider, normalizedModel, modelInfo);
-      return modelInfo;
-    }
-    return {
-      inputPrice: 0,
-      outputPrice: 0,
-      cacheWritesPrice: 0,
-      cacheReadsPrice: 0
-    };
-  }
-};
-
-// src/skills/constants.ts
-var SKILL_LIMITS = {
-  MAX_FILE_SIZE: 1024 * 1024,
-  // 1MB per file
-  MAX_SKILL_SIZE: 10 * 1024 * 1024,
-  // 10MB total
-  MAX_DEPTH: 10,
-  // Maximum directory recursion depth
-  MAX_FILES: 500,
-  // Maximum files to load per skill
-  MIN_DESCRIPTION_LENGTH: 20,
-  // Minimum description length
-  MAX_DESCRIPTION_LENGTH: 1024,
-  // Maximum description length
-  MAX_NAME_LENGTH: 64
-  // Maximum skill name length
-};
-var IGNORED_DIRECTORIES = [
-  ".git",
-  "node_modules",
-  ".next",
-  ".turbo",
-  "dist",
-  "build",
-  "coverage",
-  ".cache",
-  ".vscode",
-  ".idea",
-  "tmp",
-  "temp",
-  ".DS_Store"
-];
-var SUSPICIOUS_PATTERNS = [
-  /<script[^>]*>[\s\S]*?<\/script>/i,
-  // Script tags (with dotAll for multiline)
-  /javascript:/i,
-  // JavaScript URLs
-  /on\w+\s*=/i
-  // Event handlers (onclick, onload, etc.)
-];
-var SKILL_ERROR_MESSAGES = {
-  MISSING_FRONTMATTER: "SKILL.md must begin with YAML frontmatter enclosed in ---",
-  FRONTMATTER_INVALID: "Invalid frontmatter: {message}",
-  SKILL_NOT_FOUND: "Skill not found",
-  CONTEXT_NOT_INITIALIZED: "Skill context not initialized"
-};
-var SOURCE_ICONS = {
-  project: "\u{1F4C1}",
-  personal: "\u{1F3E0}",
-  plugin: "\u{1F50C}"
-};
-
-// src/skills/discovery.ts
-import { homedir as homedir2 } from "os";
-import { parse } from "yaml";
-import { ZodError } from "zod";
-
-// src/skills/types.ts
-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) {
-    super(message);
-    this.path = path;
-    this.name = "SkillDiscoveryError";
-  }
-};
-var SkillValidationError = class extends Error {
-  constructor(message, path) {
-    super(message);
-    this.path = path;
-    this.name = "SkillValidationError";
-  }
-};
-
-// src/skills/discovery.ts
-var BINARY_EXTENSIONS = [
-  ".png",
-  ".jpg",
-  ".jpeg",
-  ".gif",
-  ".bmp",
-  ".ico",
-  ".webp",
-  ".pdf",
-  ".zip",
-  ".tar",
-  ".gz",
-  ".exe",
-  ".dll",
-  ".so",
-  ".dylib",
-  ".bin",
-  ".dat",
-  ".db",
-  ".sqlite",
-  ".woff",
-  ".woff2",
-  ".ttf",
-  ".eot"
-];
-function isBinaryFile(filename) {
-  const ext = filename.toLowerCase().slice(filename.lastIndexOf("."));
-  return BINARY_EXTENSIONS.includes(ext);
-}
-function isBinaryContent(buffer) {
-  const checkLength = Math.min(buffer.length, 8192);
-  for (let i = 0; i < checkLength; i++) {
-    if (buffer[i] === 0) {
-      return true;
-    }
-  }
-  return false;
-}
-async function tryReadTextFile(filePath, fs) {
-  try {
-    const buffer = await fs.readFileAsBuffer(filePath);
-    if (isBinaryContent(buffer)) {
-      return null;
-    }
-    try {
-      return new TextDecoder("utf-8", { fatal: true }).decode(buffer);
-    } catch (_decodeError) {
-      return null;
-    }
-  } catch (error) {
-    if (error && typeof error === "object" && "code" in error && (error.code === "EINVAL" || error.code === "EISDIR")) {
-      return null;
-    }
-    throw error;
-  }
-}
-var SkillDiscoveryService = class {
-  fs;
-  personalSkillsDir;
-  projectSkillsDir;
-  pluginSkillsDirs;
-  constructor(options) {
-    this.fs = options.fs ?? new NodeFileSystemProvider();
-    this.personalSkillsDir = options.personalSkillsDir ?? this.fs.join(homedir2(), ".claude", "skills");
-    this.projectSkillsDir = this.fs.join(options.cwd, ".claude", "skills");
-    this.pluginSkillsDirs = options.pluginSkillsDirs ?? [];
-  }
-  /**
-   * Discover all available skills from all sources
-   * Removes duplicates (project skills take priority over personal/plugin)
-   */
-  async discoverAll() {
-    const skills = [];
-    const results = await Promise.allSettled([
-      this.discoverInDirectory(this.projectSkillsDir, "project"),
-      this.discoverInDirectory(this.personalSkillsDir, "personal"),
-      this.discoverPlugins()
-    ]);
-    const projectSkills = results[0].status === "fulfilled" ? results[0].value : [];
-    const personalSkills = results[1].status === "fulfilled" ? results[1].value : [];
-    const pluginSkills = results[2].status === "fulfilled" ? results[2].value : [];
-    if (results[0].status === "rejected") {
-      console.warn(`Failed to load project skills: ${results[0].reason}`);
-    }
-    if (results[1].status === "rejected") {
-      console.warn(`Failed to load personal skills: ${results[1].reason}`);
-    }
-    if (results[2].status === "rejected") {
-      console.warn(`Failed to load plugin skills: ${results[2].reason}`);
-    }
-    const seenNames = /* @__PURE__ */ new Set();
-    const allSkills = [...projectSkills, ...personalSkills, ...pluginSkills];
-    for (const skill of allSkills) {
-      if (!seenNames.has(skill.metadata.name)) {
-        seenNames.add(skill.metadata.name);
-        skills.push(skill);
-      }
-    }
-    return skills;
-  }
-  /**
-   * Discover skills in a specific directory
-   */
-  async discoverInDirectory(dir, source) {
-    const exists = typeof this.fs.exists === "boolean" ? this.fs.exists(dir) : await this.fs.exists(dir);
-    if (!exists) {
-      return [];
-    }
-    const skills = [];
-    const entries = await this.fs.readdir(dir);
-    for (const entry of entries) {
-      if (!entry.isDirectory) {
-        continue;
-      }
-      const skillPath = this.fs.join(dir, entry.name);
-      const skillMdPath = this.fs.join(skillPath, "SKILL.md");
-      const skillMdExists = typeof this.fs.exists === "boolean" ? this.fs.exists(skillMdPath) : await this.fs.exists(skillMdPath);
-      if (!skillMdExists) {
-        continue;
-      }
-      try {
-        const content = await this.fs.readFile(skillMdPath);
-        const { metadata } = this.parseSkillMd(content);
-        skills.push({
-          metadata,
-          path: skillPath,
-          source
-        });
-      } catch (error) {
-        let message = "Unknown error";
-        let path = skillPath;
-        if (error instanceof SkillDiscoveryError) {
-          message = error.message;
-          path = error.path;
-        } else if (error instanceof ZodError) {
-          message = error.issues[0]?.message ?? "Invalid skill metadata";
-        } else if (error instanceof Error) {
-          message = error.message;
-        }
-        console.warn(`Warning: Failed to load skill at ${path}: ${message}`);
-      }
-    }
-    return skills;
-  }
-  /**
-   * Discover skills from plugin directories (node_modules)
-   */
-  async discoverPlugins() {
-    const skills = [];
-    for (const pluginDir of this.pluginSkillsDirs) {
-      const exists = typeof this.fs.exists === "boolean" ? this.fs.exists(pluginDir) : await this.fs.exists(pluginDir);
-      if (!exists) {
-        continue;
-      }
-      const pluginSkills = await this.discoverInDirectory(pluginDir, "plugin");
-      skills.push(...pluginSkills);
-    }
-    return skills;
-  }
-  /**
-   * Load a single skill from its directory
-   */
-  async loadSkill(skillPath, source) {
-    const skillMdPath = this.fs.join(skillPath, "SKILL.md");
-    const skillMdExists = typeof this.fs.exists === "boolean" ? this.fs.exists(skillMdPath) : await this.fs.exists(skillMdPath);
-    if (!skillMdExists) {
-      throw new SkillDiscoveryError("SKILL.md not found", skillPath);
-    }
-    const content = await this.fs.readFile(skillMdPath);
-    const { metadata, content: instructions } = this.parseSkillMd(content);
-    const files = /* @__PURE__ */ new Map();
-    let totalSize = 0;
-    const entries = await this.fs.readdir(skillPath);
-    for (const entry of entries) {
-      if (entry.name === "SKILL.md") {
-        continue;
-      }
-      const filePath = this.fs.join(skillPath, entry.name);
-      if (entry.isFile) {
-        if (isBinaryFile(entry.name)) {
-          continue;
-        }
-        const fileStats = await this.fs.stat(filePath);
-        const fileSize = fileStats.size;
-        if (fileSize > SKILL_LIMITS.MAX_FILE_SIZE) {
-          throw new SkillDiscoveryError(`File size exceeds limit (${fileSize} > ${SKILL_LIMITS.MAX_FILE_SIZE}): ${entry.name}`, skillPath);
-        }
-        if (totalSize + fileSize > SKILL_LIMITS.MAX_SKILL_SIZE) {
-          throw new SkillDiscoveryError(
-            `Total skill size exceeds limit (${totalSize + fileSize} > ${SKILL_LIMITS.MAX_SKILL_SIZE}): ${skillPath}`,
-            skillPath
-          );
-        }
-        const fileContent = await tryReadTextFile(filePath, this.fs);
-        if (fileContent === null) {
-          continue;
-        }
-        totalSize += fileSize;
-        files.set(entry.name, fileContent);
-      } else if (entry.isDirectory) {
-        totalSize = await this.loadDirectoryFiles(filePath, entry.name, files, 0, totalSize);
-      }
-    }
-    return {
-      metadata,
-      content: instructions,
-      files,
-      path: skillPath,
-      source
-    };
-  }
-  /**
-   * Parse SKILL.md content and extract frontmatter
-   */
-  parseSkillMd(content) {
-    const frontmatterRegex = /^---\r?\n([\s\S]+?)\r?\n---\r?\n([\s\S]*)$/;
-    const match = content.match(frontmatterRegex);
-    if (!match || match.length < 3) {
-      throw new SkillDiscoveryError(SKILL_ERROR_MESSAGES.MISSING_FRONTMATTER, "");
-    }
-    const frontmatter = match[1] ?? "";
-    const instructions = match[2] ?? "";
-    const metadata = this.parseMetadata(frontmatter);
-    return { metadata, content: instructions };
-  }
-  /**
-   * Parse and validate YAML frontmatter
-   */
-  parseMetadata(frontmatter) {
-    const parsed = parse(frontmatter);
-    return skillMetadataSchema.parse(parsed);
-  }
-  /**
-   * Recursively load files from a directory into the files map
-   * @returns The total size of all files loaded (in bytes)
-   */
-  async loadDirectoryFiles(dirPath, prefix, files, depth = 0, currentTotal = 0) {
-    const { MAX_DEPTH, MAX_FILES } = SKILL_LIMITS;
-    let totalSize = currentTotal;
-    if (depth > MAX_DEPTH) {
-      return totalSize;
-    }
-    if (files.size >= MAX_FILES) {
-      return totalSize;
-    }
-    const currentDirName = prefix.split("/").pop() ?? prefix;
-    if (IGNORED_DIRECTORIES.includes(currentDirName)) {
-      return totalSize;
-    }
-    const entries = await this.fs.readdir(dirPath);
-    for (const entry of entries) {
-      if (files.size >= MAX_FILES) {
-        break;
-      }
-      const filePath = this.fs.join(dirPath, entry.name);
-      const key = `${prefix}/${entry.name}`.replace(/\/+/g, "/");
-      if (entry.isFile) {
-        if (isBinaryFile(entry.name)) {
-          continue;
-        }
-        const fileStats = await this.fs.stat(filePath);
-        const fileSize = fileStats.size;
-        if (fileSize > SKILL_LIMITS.MAX_FILE_SIZE) {
-          throw new SkillDiscoveryError(`File size exceeds limit (${fileSize} > ${SKILL_LIMITS.MAX_FILE_SIZE}): ${key}`, dirPath);
-        }
-        if (totalSize + fileSize > SKILL_LIMITS.MAX_SKILL_SIZE) {
-          throw new SkillDiscoveryError(
-            `Total skill size exceeds limit (${totalSize + fileSize} > ${SKILL_LIMITS.MAX_SKILL_SIZE}): ${dirPath}`,
-            dirPath
-          );
-        }
-        const content = await tryReadTextFile(filePath, this.fs);
-        if (content === null) {
-          continue;
-        }
-        totalSize += fileSize;
-        files.set(key, content);
-      } else if (entry.isDirectory) {
-        if (IGNORED_DIRECTORIES.includes(entry.name)) {
-          continue;
-        }
-        totalSize = await this.loadDirectoryFiles(filePath, key, files, depth + 1, totalSize);
-      }
-    }
-    return totalSize;
-  }
-  /**
-   * Create an initial skill context object
-   */
-  async createContext() {
-    const availableSkills = await this.discoverAll();
-    return {
-      activeSkill: null,
-      availableSkills,
-      skillLoadingHistory: [],
-      loadSkill: async (name) => {
-        const ref = availableSkills.find((s) => s.metadata.name === name);
-        if (!ref) return null;
-        return this.loadSkill(ref.path, ref.source);
-      }
-    };
-  }
-};
-
-// src/skills/validation.ts
-import { join as join3, normalize as normalize2 } from "path";
-function validateSkillSecurity(skill) {
-  const { MAX_FILE_SIZE, MAX_SKILL_SIZE } = SKILL_LIMITS;
-  let totalSize = 0;
-  const contentSize = Buffer.byteLength(skill.content, "utf8");
-  if (contentSize > MAX_FILE_SIZE) {
-    throw new SkillValidationError(`SKILL.md content exceeds size limit (${contentSize} > ${MAX_FILE_SIZE})`, join3(skill.path, "SKILL.md"));
-  }
-  totalSize += contentSize;
-  for (const [filename, content] of skill.files) {
-    const fileSize = Buffer.byteLength(content, "utf8");
-    if (fileSize > MAX_FILE_SIZE) {
-      throw new SkillValidationError(`File ${filename} exceeds size limit (${fileSize} > ${MAX_FILE_SIZE})`, join3(skill.path, filename));
-    }
-    totalSize += fileSize;
-  }
-  if (totalSize > MAX_SKILL_SIZE) {
-    throw new SkillValidationError(`Skill total size exceeds limit (${totalSize} > ${MAX_SKILL_SIZE})`, skill.path);
-  }
-  validateContentSecurity(skill.content, skill.path);
-  for (const [filename, content] of skill.files) {
-    validateContentSecurity(content, join3(skill.path, filename));
-  }
-}
-function validateContentSecurity(content, path) {
-  for (const pattern of SUSPICIOUS_PATTERNS) {
-    if (pattern.test(content)) {
-      throw new SkillValidationError("Suspicious content detected", path);
-    }
-  }
-}
-function validateSkillReferences(skill) {
-  const warnings = [];
-  const externalRefs = skill.content.match(/https?:\/\/[^\s\])]+/g) || [];
-  if (externalRefs.length > 0 && !skill.metadata.description.toLowerCase().includes("external")) {
-    warnings.push(
-      `Skill '${skill.metadata.name}' contains external references. Consider adding 'external' to description for transparency.`
-    );
-  }
-  const codeBlocks = skill.content.match(/```[\s\S]*?```/g) || [];
-  for (const block of codeBlocks) {
-    const pathsInCode = block.match(/\/[a-zA-Z][\w./-]*/g) || [];
-    for (const path of pathsInCode) {
-      if (!path.startsWith("/dev") && !path.startsWith("/proc") && !path.startsWith("/sys") && !path.startsWith("//")) {
-        warnings.push(`Skill '${skill.metadata.name}' contains possible absolute path '${path}'. Use relative paths instead.`);
-      }
-    }
-  }
-  const linkRegex = /\[[^\]]+\]\(([^)]+(?:\s+[^)]+)*)\)/g;
-  let match;
-  match = linkRegex.exec(skill.content);
-  while (match !== null) {
-    const filepath = match[1];
-    match = linkRegex.exec(skill.content);
-    if (filepath.startsWith("http://") || filepath.startsWith("https://") || filepath.startsWith("#")) {
-      continue;
-    }
-    const normalizedPath = normalize2(filepath).replace(/^\.?\//, "").replace(/\\/g, "/");
-    if (!skill.files.has(normalizedPath)) {
-      warnings.push(`Referenced file not found: ${filepath}`);
-    }
-  }
-  return warnings;
-}
-function validateSkillMetadata(skill) {
-  const errors = [];
-  if (skill.metadata.description.length < 20) {
-    errors.push(`Description too short: ${skill.metadata.description.length} < 20`);
-  }
-  return errors;
-}
-function getSkillStats(skill) {
-  let totalSize = Buffer.byteLength(skill.content, "utf8");
-  let largestFile = { name: "SKILL.md", size: totalSize };
-  let fileCount = 1;
-  for (const [name, content] of skill.files) {
-    const size = Buffer.byteLength(content, "utf8");
-    totalSize += size;
-    fileCount++;
-    if (size > largestFile.size) {
-      largestFile = { name, size };
-    }
-  }
-  return {
-    totalSize,
-    fileCount,
-    largestFile
-  };
-}
-
-// src/skills/tools/listSkills.ts
-import { z as z5 } from "zod";
-var ListSkillsInputSchema = z5.object({
-  filter: z5.string().optional().describe("Optional filter string to match against skill names and descriptions")
-});
-var ListSkillsOutputSchema = z5.object({
-  skills: z5.array(
-    z5.object({
-      name: z5.string(),
-      description: z5.string(),
-      source: z5.enum(["personal", "project", "plugin"])
-    })
-  ),
-  total: z5.number()
-});
-async function listSkills(input, context) {
-  const { filter } = input;
-  let skills = context.availableSkills;
-  if (filter) {
-    const filterLower = filter.toLowerCase();
-    skills = skills.filter((s) => s.metadata.name.includes(filterLower) || s.metadata.description.toLowerCase().includes(filterLower));
-  }
-  return {
-    skills: skills.map((s) => ({
-      name: s.metadata.name,
-      description: s.metadata.description,
-      source: s.source
-    })),
-    total: skills.length
-  };
-}
-var listSkillsToolInfo = {
-  name: "listSkills",
-  description: "List all available skills with their descriptions. Use this to discover what specialized capabilities are available.",
-  parameters: ListSkillsInputSchema,
-  returns: ListSkillsOutputSchema
-};
-
-// src/skills/tools/loadSkill.ts
-import { z as z6 } from "zod";
-var LoadSkillInputSchema = z6.object({
-  skillName: z6.string().describe("The name of the skill to load")
-});
-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: z6.string().optional(),
-  warnings: z6.array(z6.string()).optional()
-});
-async function loadSkill(input, context) {
-  const { skillName } = input;
-  const skillRef = context.availableSkills.find((s) => s.metadata.name === skillName);
-  if (!skillRef) {
-    return {
-      success: false,
-      error: `Skill '${skillName}' not found`
-    };
-  }
-  try {
-    const skill = await context.loadSkill(skillName);
-    if (!skill) {
-      return {
-        success: false,
-        error: `Failed to load skill '${skillName}'`
-      };
-    }
-    validateSkillSecurity(skill);
-    const warnings = validateSkillReferences(skill);
-    context.activeSkill = skill;
-    context.skillLoadingHistory.push(skillName);
-    return {
-      success: true,
-      skill: {
-        name: skill.metadata.name,
-        description: skill.metadata.description,
-        content: skill.content,
-        availableFiles: Array.from(skill.files.keys())
-      },
-      warnings: warnings.length > 0 ? warnings : void 0
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-      success: false,
-      error: `Failed to load skill '${skillName}': ${message}`
-    };
-  }
-}
-var loadSkillToolInfo = {
-  name: "loadSkill",
-  description: "Load a skill by name to access its instructions and resources. Use this when you need specialized knowledge or capabilities for a specific task.",
-  parameters: LoadSkillInputSchema,
-  returns: LoadSkillOutputSchema
-};
-
-// src/skills/tools/readSkillFile.ts
-import { z as 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 = z7.object({
-  success: z7.boolean(),
-  content: z7.string().optional(),
-  error: z7.string().optional()
-});
-async function readSkillFile(input, context) {
-  const { skillName, filename } = input;
-  let skill = context.activeSkill && context.activeSkill.metadata.name === skillName ? context.activeSkill : null;
-  if (!skill) {
-    try {
-      skill = await context.loadSkill(skillName);
-    } catch (_error) {
-    }
-  }
-  if (!skill) {
-    return {
-      success: false,
-      error: `Skill '${skillName}' not found or could not be loaded. Use loadSkill first.`
-    };
-  }
-  if (!skill.files.has(filename)) {
-    const availableFiles = Array.from(skill.files.keys()).sort();
-    return {
-      success: false,
-      error: `File '${filename}' not found in skill '${skillName}'. Available files: ${availableFiles.join(", ") || "none"}`
-    };
-  }
-  const content = skill.files.get(filename);
-  return {
-    success: true,
-    content
-  };
-}
-var readSkillFileToolInfo = {
-  name: "readSkillFile",
-  description: "Read a supporting file from a skill. Use this to access reference documentation, examples, scripts, or templates bundled with a skill. First use loadSkill to see available files, then use this tool to read specific files.",
-  parameters: ReadSkillFileInputSchema,
-  returns: ReadSkillFileOutputSchema
-};
-
-// src/tools/askFollowupQuestion.ts
-import { z as 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: 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: [
-      {
-        description: "Single clarifying question (no options)",
-        input: {
-          questions: [{ prompt: "What is the target deployment environment?" }]
-        }
-      },
-      {
-        description: "Single question with multiple-choice options",
-        input: {
-          questions: [
-            {
-              prompt: "Which frontend framework are you using?",
-              options: ["React", "Angular", "Vue", "Svelte"]
-            }
-          ]
-        }
-      },
-      {
-        description: "Two related questions in one call",
-        input: {
-          questions: [
-            { prompt: "What type of application are you building?" },
-            {
-              prompt: "Preferred programming language?",
-              options: ["JavaScript", "TypeScript", "Python", "Java"]
-            }
-          ]
-        }
-      },
-      {
-        description: "Binary (yes/no) confirmation",
-        input: {
-          questions: [
-            {
-              prompt: "Is it acceptable to refactor existing tests to improve performance?",
-              options: ["Yes", "No"]
-            }
-          ]
-        }
-      }
-    ]
-  })
-};
-var handler = async (provider, args) => {
-  if (!provider.askFollowupQuestion) {
-    return {
-      success: false,
-      message: {
-        type: "error-text",
-        value: "Not possible to ask followup question."
-      }
-    };
-  }
-  const { questions } = toolInfo.parameters.parse(args);
-  if (questions.length === 0) {
-    return {
-      success: false,
-      message: {
-        type: "error-text",
-        value: "No questions provided"
-      }
-    };
-  }
-  const answers = [];
-  for (const question of questions) {
-    const { prompt, options } = question;
-    const answer = await provider.askFollowupQuestion(prompt, options);
-    answers.push(`<ask_followup_question_answer question="${prompt}">
-${answer}
-</ask_followup_question_answer>`);
-  }
-  return {
-    success: true,
-    message: {
-      type: "text",
-      value: answers.join("\n")
-    }
-  };
-};
-var askFollowupQuestion_default = {
-  ...toolInfo,
-  handler
-};
-
-// src/tools/executeCommand.ts
-import { z as z9 } from "zod";
-
-// 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 ${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;
-}
-function createFileElement(tagName, path, content, attrs) {
-  const allAttrs = { path, ...attrs };
-  const attrStr = Object.entries(allAttrs).map(([k, v]) => ` ${k}="${v}"`).join("");
-  if (content === void 0) {
-    return `<${tagName}${attrStr} />`;
-  }
-  const isEmpty = content.trim().length === 0;
-  if (isEmpty) {
-    return `<${tagName}${attrStr} is_empty="true" />`;
-  }
-  return `<${tagName}${attrStr}>${content}</${tagName}>`;
-}
-
-// src/tools/executeCommand.ts
-var toolInfo2 = {
-  name: "executeCommand",
-  description: "Run a single CLI command. The command is always executed in the project-root working directory (regardless of earlier commands). Prefer one-off shell commands over wrapper scripts for flexibility. **IMPORTANT**: After an `execute_command` call, you MUST stop and NOT allowed to make further tool calls in the same message.",
-  parameters: 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({
-    examples: [
-      {
-        description: "Make a build",
-        input: {
-          command: "npm run build",
-          requiresApproval: "false"
-        }
-      }
-    ]
-  })
-};
-var handler2 = async (provider, args) => {
-  if (!provider.executeCommand) {
-    return createProviderErrorResponse("execute command. Abort");
-  }
-  const { command, requiresApproval } = toolInfo2.parameters.parse(args);
-  try {
-    const result = await provider.executeCommand(command, requiresApproval);
-    let message = `<command>${command}</command>
-<command_exit_code>${result.exitCode}</command_exit_code>
-`;
-    if (result.summary) {
-      message += `<command_output_summary>
-${result.summary}
-</command_output_summary>
-`;
-    } else {
-      message += `<command_stdout>
-${result.stdout}
-</command_stdout>
-<command_stderr>
-${result.stderr}
-</command_stderr>
-`;
-    }
-    if (result.exitCode === 0) {
-      return {
-        success: true,
-        message: {
-          type: "text",
-          value: message
-        }
-      };
-    }
-    return {
-      success: false,
-      message: {
-        type: "error-text",
-        value: message
-      }
-    };
-  } catch (error) {
-    return {
-      success: false,
-      message: {
-        type: "error-text",
-        value: error instanceof Error ? error.message : String(error)
-      }
-    };
-  }
-};
-var executeCommand_default = {
-  ...toolInfo2,
-  handler: handler2
-};
-
-// src/tools/fetchUrl.ts
-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: 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);
-    }, z10.array(z10.string())).describe("One or more URLs to fetch, separated by commas if multiple.").meta({ usageValue: "url" })
-  }).meta({
-    examples: [
-      {
-        description: "Fetch a single webpage",
-        input: {
-          url: "https://example.com"
-        }
-      },
-      {
-        description: "Fetch multiple webpages",
-        input: {
-          url: "https://example.com,https://developer.mozilla.org/en-US/docs/Web/HTTP"
-        }
-      },
-      {
-        description: "Fetch a raw file from GitHub",
-        input: {
-          url: "https://raw.githubusercontent.com/user/repo/main/README.md"
-        }
-      }
-    ]
-  })
-};
-var handler3 = async (provider, args) => {
-  if (!provider.fetchUrl) {
-    return {
-      success: false,
-      message: {
-        type: "error-text",
-        value: "Not possible to fetch url."
-      }
-    };
-  }
-  const { url: urls } = toolInfo3.parameters.parse(args);
-  if (urls.length === 0) {
-    return {
-      success: false,
-      message: {
-        type: "error-text",
-        value: "No URLs provided. Please provide at least one URL to fetch."
-      }
-    };
-  }
-  const results = [];
-  for (const url of urls) {
-    try {
-      const content = provider.fetchUrl(url).then((res) => `<fetch_url_content url="${url}">${res}</fetch_url_content>`);
-      results.push(content);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      results.push(Promise.resolve(`<fetch_url_error url="${url}">${errorMessage}</fetch_url_error>`));
-    }
-  }
-  const resolvedResults = await Promise.all(results);
-  return {
-    success: true,
-    message: {
-      type: "text",
-      value: resolvedResults.join("\n")
-    }
-  };
-};
-var fetchUrl_default = {
-  ...toolInfo3,
-  handler: handler3
-};
-
-// src/tools/listFiles.ts
-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: 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: [
-      {
-        description: "Request to list files",
-        input: {
-          path: "src",
-          maxCount: "100"
-        }
-      }
-    ]
-  })
-};
-var handler4 = async (provider, args) => {
-  if (!provider.listFiles) {
-    return createProviderErrorResponse("list files");
-  }
-  const { path, maxCount, recursive, includeIgnored } = toolInfo4.parameters.parse(args);
-  const [files, limitReached] = await provider.listFiles(path, recursive, maxCount, includeIgnored);
-  return {
-    success: true,
-    message: {
-      type: "text",
-      value: `<list_files_path>${path}</list_files_path>
-<list_files_files>
-${files.join("\n")}
-</list_files_files>
-<list_files_truncated>${limitReached}</list_files_truncated>`
-    }
-  };
-};
-var listFiles_default = {
-  ...toolInfo4,
-  handler: handler4
-};
-
-// src/tools/provider.ts
-var MockProvider = class {
-  async listTodoItems(id, _status) {
-    if (id) {
-      return [{ id: `${id}-1`, title: "mock sub item", status: "open", description: "" }];
-    }
-    return [{ id: "1", title: "mock item", status: "open", description: "" }];
-  }
-  async getTodoItem(id) {
-    return {
-      id,
-      title: "mock item",
-      description: "mock desc",
-      status: "open",
-      subItems: []
-    };
-  }
-  async updateTodoItem(input) {
-    if (input.operation === "add") {
-      return { id: "2" };
-    }
-    return { id: input.id };
-  }
-  async readFile(_path, _includeIgnored) {
-    return "mock content";
-  }
-  async writeFile(_path, _content) {
-    return;
-  }
-  async removeFile(_path) {
-    return;
-  }
-  async renameFile(_sourcePath, _targetPath) {
-    return;
-  }
-  async listFiles(_path, _recursive, _maxCount, _includeIgnored) {
-    return [["mock-file.txt"], false];
-  }
-  async searchFiles(_path, _regex, _filePattern) {
-    return ["mock-file.txt"];
-  }
-  async executeCommand(_command, _needApprove) {
-    return { stdout: "mock output", stderr: "", exitCode: 0 };
-  }
-  async askFollowupQuestion(_question, _options) {
-    return "mock answer";
-  }
-  async search(_query) {
-    return "mock search result";
-  }
-  async listMemoryTopics() {
-    return ["default"];
-  }
-  async readMemory(_topic) {
-    return "mock memory content";
-  }
-  async updateMemory(_operation, _topic, _content) {
-    return;
-  }
-};
-
-// src/tools/readBinaryFile.ts
-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: z12.object({
-    url: z12.string().describe("The URL or local path of the file to read.")
-  })
-};
-var handler5 = async (provider, args) => {
-  if (!provider.readBinaryFile) {
-    return {
-      success: false,
-      message: {
-        type: "error-text",
-        value: "Not possible to fetch files. Abort."
-      }
-    };
-  }
-  const { url } = toolInfo5.parameters.parse(args);
-  try {
-    const filePart = await provider.readBinaryFile(url);
-    return {
-      success: true,
-      message: {
-        type: "content",
-        value: [
-          {
-            type: "media",
-            url,
-            data: filePart.base64Data,
-            mediaType: filePart.mediaType
-          }
-        ]
-      }
-    };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : "Unknown error";
-    return {
-      success: false,
-      message: {
-        type: "error-text",
-        value: `Error fetching file from ${url}: ${errorMessage}`
-      }
-    };
-  }
-};
-var readBinaryFile_default = {
-  ...toolInfo5,
-  handler: handler5
-};
-
-// src/tools/readFile.ts
-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.
-
-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: 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);
-    }, 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: [
-      {
-        description: "Request to read the contents of a file",
-        input: {
-          path: "src/main.js"
-        }
-      },
-      {
-        description: "Request to read multiple files",
-        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 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, 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" }));
-      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,
-    message: {
-      type: "text",
-      value: resp.join("\n")
-    }
-  };
-};
-var readFile_default = {
-  ...toolInfo6,
-  handler: handler6
-};
-
-// src/tools/removeFile.ts
-import { z as z14 } from "zod";
-var toolInfo7 = {
-  name: "removeFile",
-  description: "Request to remove a file at the specified path.",
-  parameters: z14.object({
-    path: z14.string().describe("The path of the file to remove").meta({ usageValue: "File path here" })
-  }).meta({
-    examples: [
-      {
-        description: "Request to remove a file",
-        input: {
-          path: "src/main.js"
-        }
-      }
-    ]
-  })
-};
-var handler7 = async (provider, args) => {
-  if (!provider.removeFile) {
-    return createProviderErrorResponse("remove file");
-  }
-  const parsed = toolInfo7.parameters.safeParse(args);
-  if (!parsed.success) {
-    return {
-      success: false,
-      message: {
-        type: "error-text",
-        value: `Invalid arguments for removeFile: ${parsed.error.message}`
-      }
-    };
-  }
-  const { path } = parsed.data;
-  await provider.removeFile(path);
-  return {
-    success: true,
-    message: {
-      type: "text",
-      value: `<remove_file_path>${path}</remove_file_path><status>Success</status>`
-    }
-  };
-};
-var removeFile_default = {
-  ...toolInfo7,
-  handler: handler7
-};
-
-// src/tools/renameFile.ts
-import { z as z15 } from "zod";
-var toolInfo8 = {
-  name: "renameFile",
-  description: "Request to rename a file from source path to target path.",
-  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: [
-      {
-        description: "Request to rename a file",
-        input: {
-          source_path: "src/old-name.js",
-          target_path: "src/new-name.js"
-        }
-      }
-    ]
-  })
-};
-var handler8 = async (provider, args) => {
-  if (!provider.renameFile) {
-    return {
-      success: false,
-      message: {
-        type: "error-text",
-        value: "Not possible to rename file."
-      }
-    };
-  }
-  const { source_path, target_path } = toolInfo8.parameters.parse(args);
-  await provider.renameFile(source_path, target_path);
-  return {
-    success: true,
-    message: {
-      type: "text",
-      value: `<rename_file_path>${target_path}</rename_file_path><status>Success</status>`
-    }
-  };
-};
-var renameFile_default = {
-  ...toolInfo8,
-  handler: handler8
-};
-
-// src/tools/replaceInFile.ts
-import { z as z16 } from "zod";
-
-// src/tools/utils/replaceInFile.ts
-var replaceInFile = (fileContent, diff) => {
-  const blockPattern = /^\s*<<<<<+\s*SEARCH>?\s*\r?\n([\s\S]*?)\r?\n=======[ \t]*\r?\n([\s\S]*?)\r?\n?>>>>>+\s*REPLACE\s*$/gm;
-  const blocks = [];
-  for (let match = blockPattern.exec(diff); match !== null; match = blockPattern.exec(diff)) {
-    blocks.push({ search: match[1], replace: match[2] });
-  }
-  if (blocks.length === 0) {
-    throw new Error("No valid diff blocks found.");
-  }
-  const findAndReplace = (content, search, replace) => {
-    let index = content.indexOf(search);
-    if (index !== -1) {
-      return content.slice(0, index) + replace + content.slice(index + search.length);
-    }
-    const trimmedSearch = search.trim();
-    const trimmedContent = content.trim();
-    const offset = content.indexOf(trimmedContent);
-    index = trimmedContent.indexOf(trimmedSearch);
-    if (index !== -1) {
-      const absoluteIndex = offset + index;
-      return content.slice(0, absoluteIndex) + replace + content.slice(absoluteIndex + trimmedSearch.length);
-    }
-    const normalizedSearch = trimmedSearch.replace(/\s+/g, " ");
-    const normalizedContent = trimmedContent.replace(/\s+/g, " ");
-    index = normalizedContent.indexOf(normalizedSearch);
-    if (index !== -1) {
-      let runningIndex = 0;
-      let actualPos = offset;
-      for (const segment of trimmedSearch.replace(/\s+/g, " ").split(" ")) {
-        const segIndex = content.indexOf(segment, actualPos);
-        if (segIndex === -1) {
-          break;
-        }
-        if (runningIndex === 0) {
-          actualPos = segIndex;
-        } else {
-          actualPos = segIndex + segment.length;
-        }
-        runningIndex++;
-      }
-      const searchWords = trimmedSearch.replace(/\s+/g, " ").split(" ").filter((w) => w.length > 0);
-      let matchStartPos = -1;
-      let matchEndPos = -1;
-      if (searchWords.length > 0) {
-        const firstWordPos = content.indexOf(searchWords[0], offset);
-        if (firstWordPos !== -1) {
-          matchStartPos = firstWordPos;
-          matchEndPos = firstWordPos + searchWords[0].length;
-          for (let i = 1; i < searchWords.length; i++) {
-            const nextWordPos = content.indexOf(searchWords[i], matchEndPos);
-            if (nextWordPos === -1 || nextWordPos > matchEndPos + 100) {
-              matchStartPos = -1;
-              break;
-            }
-            matchEndPos = nextWordPos + searchWords[i].length;
-          }
-        }
-      }
-      if (matchStartPos !== -1 && matchEndPos !== -1) {
-        return content.slice(0, matchStartPos) + replace + content.slice(matchEndPos);
-      }
-    }
-    return null;
-  };
-  let updatedFile = fileContent;
-  let appliedCount = 0;
-  const totalCount = blocks.length;
-  for (const { search, replace } of blocks) {
-    const result = findAndReplace(updatedFile, search, replace);
-    if (result !== null) {
-      updatedFile = result;
-      appliedCount++;
-    }
-  }
-  let status;
-  if (appliedCount === 0) {
-    status = "no_diff_applied";
-  } else if (appliedCount < totalCount) {
-    status = "some_diff_applied";
-  } else {
-    status = "all_diff_applied";
-  }
-  return {
-    content: updatedFile,
-    status,
-    appliedCount,
-    totalCount
-  };
-};
-
-// src/tools/replaceInFile.ts
-var toolInfo9 = {
-  name: "replaceInFile",
-  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: 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
-[exact content to find]
-=======
-[new content to replace with]
->>>>>>> REPLACE
-\`\`\`
-Critical rules:
-1. SEARCH content must match the associated file section to find EXACTLY:
-    * Match character-for-character including whitespace, indentation, line endings
-    * Include all comments, docstrings, etc.
-2. SEARCH/REPLACE blocks will ONLY replace the first match occurrence.
-    * Including multiple unique SEARCH/REPLACE blocks if you need to make multiple changes.
-    * Include *just* enough lines in each SEARCH section to uniquely match each set of lines that need to change.
-    * When using multiple SEARCH/REPLACE blocks, list them in the order they appear in the file.
-3. Keep SEARCH/REPLACE blocks concise:
-    * Break large SEARCH/REPLACE blocks into a series of smaller blocks that each change a small portion of the file.
-    * Include just the changing lines, and a few surrounding lines if needed for uniqueness.
-    * Do not include long runs of unchanging lines in SEARCH/REPLACE blocks.
-    * 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: Empty REPLACE section`
-    ).meta({ usageValue: "Search and replace blocks here" })
-  }).meta({
-    examples: [
-      {
-        description: "Request to replace sections of content in a file",
-        input: {
-          path: "src/main.js",
-          diff: `<<<<<<< SEARCH
-import React from 'react';
-=======
-import React, { useState } from 'react';
->>>>>>> REPLACE
-
-<<<<<<< SEARCH
-function handleSubmit() {
-  saveData();
-  setLoading(false);
-}
-
-=======
->>>>>>> REPLACE
-
-<<<<<<< SEARCH
-return (
-  <div>
-=======
-function handleSubmit() {
-  saveData();
-  setLoading(false);
-}
-
-return (
-  <div>
->>>>>>> REPLACE`
-        }
-      },
-      {
-        description: "Request to perform a simple, single-line replacement",
-        input: {
-          path: "src/config.js",
-          diff: `<<<<<<< SEARCH
-const API_URL = 'https://api.example.com';
-=======
-const API_URL = 'https://api.staging.example.com';
->>>>>>> REPLACE`
-        }
-      },
-      {
-        description: "Request to add a new function to a file",
-        input: {
-          path: "src/utils.js",
-          diff: `<<<<<<< SEARCH
-function helperA() {
-  // ...
-}
-=======
-function helperA() {
-  // ...
-}
-
-function newHelper() {
-  // implementation
-}
->>>>>>> REPLACE`
-        }
-      },
-      {
-        description: "Request to delete a block of code from a file",
-        input: {
-          path: "src/app.js",
-          diff: `<<<<<<< SEARCH
-function oldFeature() {
-  // This is no longer needed
-}
-
-=======
->>>>>>> REPLACE`
-        }
-      }
-    ]
-  })
-};
-var handler9 = async (provider, args) => {
-  if (!provider.readFile || !provider.writeFile) {
-    return {
-      success: false,
-      message: {
-        type: "error-text",
-        value: "Not possible to replace in file."
-      }
-    };
-  }
-  const parsed = toolInfo9.parameters.safeParse(args);
-  if (!parsed.success) {
-    return {
-      success: false,
-      message: {
-        type: "error-text",
-        value: `Invalid arguments for replaceInFile: ${parsed.error.message}`
-      }
-    };
-  }
-  const { path, diff } = parsed.data;
-  try {
-    const fileContent = await provider.readFile(path, false);
-    if (fileContent == null) {
-      return {
-        success: false,
-        message: {
-          type: "error-text",
-          value: `<replace_in_file_result path="${path}" status="failed" message="File not found" />`
-        }
-      };
-    }
-    const result = replaceInFile(fileContent, diff);
-    if (result.status === "no_diff_applied") {
-      return {
-        success: false,
-        message: {
-          type: "error-text",
-          value: `<replace_in_file_result path="${path}" status="failed" message="Unable to apply changes">
-  <file_content path="${path}">${fileContent}</file_content>
-</replace_in_file_result>`
-        }
-      };
-    }
-    await provider.writeFile(path, result.content);
-    if (result.status === "some_diff_applied") {
-      return {
-        success: true,
-        message: {
-          type: "text",
-          value: `<replace_in_file_result path="${path}" status="some_diff_applied" applied_count="${result.appliedCount}" total_count="${result.totalCount}">
-  <file_content path="${path}">${result.content}</file_content>
-</replace_in_file_result>`
-        }
-      };
-    }
-    return {
-      success: true,
-      message: {
-        type: "text",
-        value: `<replace_in_file_result path="${path}" status="all_diff_applied" />`
-      }
-    };
-  } catch (error) {
-    return {
-      success: false,
-      message: {
-        type: "error-text",
-        value: `Invalid arguments for replaceInFile: ${error}`
-      }
-    };
-  }
-};
-var replaceInFile_default = {
-  ...toolInfo9,
-  handler: handler9
-};
-
-// src/tools/search.ts
-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: z17.object({
-    query: z17.string().describe("The query to search for").meta({ usageValue: "Your search query here" })
-  }).meta({
-    examples: [
-      {
-        description: "Search for current events or news",
-        input: {
-          query: "latest developments in AI language models 2024"
-        }
-      },
-      {
-        description: "Look up technical documentation",
-        input: {
-          query: "TypeScript advanced type system features"
-        }
-      },
-      {
-        description: "Research specific information",
-        input: {
-          query: "Node.js performance optimization best practices"
-        }
-      }
-    ]
-  })
-};
-var handler10 = async (provider, args) => {
-  const { query } = toolInfo10.parameters.parse(args);
-  if (!provider.search) {
-    return {
-      success: false,
-      message: {
-        type: "text",
-        value: "This tool requires a web provider to be installed."
-      }
-    };
-  }
-  const result = await provider.search(query);
-  return {
-    success: true,
-    message: {
-      type: "text",
-      value: result
-    }
-  };
-};
-var search_default = {
-  ...toolInfo10,
-  handler: handler10
-};
-
-// src/tools/searchFiles.ts
-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: 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: z18.string().describe("The regular expression pattern to search for. Uses Rust regex syntax.").meta({
-      usageValue: "Your regex pattern here"
-    }),
-    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)"
-    })
-  }).meta({
-    examples: [
-      {
-        description: "Request to perform a regex search across files",
-        input: {
-          path: "src",
-          regex: "^components/",
-          filePattern: "*.ts,*.tsx"
-        }
-      }
-    ]
-  })
-};
-var handler11 = async (provider, args) => {
-  if (!provider.searchFiles) {
-    return {
-      success: false,
-      message: {
-        type: "error-text",
-        value: "Not possible to search files."
-      }
-    };
-  }
-  const parsed = toolInfo11.parameters.safeParse(args);
-  if (!parsed.success) {
-    return {
-      success: false,
-      message: {
-        type: "error-text",
-        value: `Invalid arguments for searchFiles: ${parsed.error.message}`
-      }
-    };
-  }
-  const { path, regex, filePattern } = parsed.data;
-  try {
-    const files = await provider.searchFiles(path, regex, filePattern ?? "*");
-    return {
-      success: true,
-      message: {
-        type: "text",
-        value: `<search_files_path>${path}</search_files_path>
-<search_files_regex>${regex}</search_files_regex>
-<search_files_file_pattern>${filePattern}</search_files_file_pattern>
-<search_files_files>
-${files.join("\n")}
-</search_files_files>
-`
-      }
-    };
-  } catch (error) {
-    return {
-      success: false,
-      message: {
-        type: "error-text",
-        value: `Error searching files: ${error}`
-      }
-    };
-  }
-};
-var searchFiles_default = {
-  ...toolInfo11,
-  handler: handler11
-};
-
-// src/tools/todo.ts
-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 = 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") {
-    if (!data.title) {
-      ctx.addIssue({
-        code: "custom",
-        message: 'Title is required for "add" operation',
-        path: ["title"]
-      });
-    }
-  } else if (data.operation === "update") {
-    if (!data.id) {
-      ctx.addIssue({
-        code: "custom",
-        message: 'ID is required for "update" operation',
-        path: ["id"]
-      });
-    }
-  }
-});
-var UpdateTodoItemOutputSchema = z19.object({
-  id: z19.string()
-});
-
-// src/tools/writeToFile.ts
-import { z as z20 } from "zod";
-var toolInfo12 = {
-  name: "writeToFile",
-  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: 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({
-    examples: [
-      {
-        description: "Request to write content to a file",
-        input: {
-          path: "src/main.js",
-          content: `import React from 'react';
-
-function App() {
-  return (
-    <div>
-      <h1>Hello, World!</h1>
-    </div>
-  );
-}
-
-export default App;
-`
-        }
-      }
-    ]
-  })
-};
-var handler12 = async (provider, args) => {
-  if (!provider.writeFile) {
-    return createProviderErrorResponse("write file");
-  }
-  const parsed = toolInfo12.parameters.safeParse(args);
-  if (!parsed.success) {
-    return {
-      success: false,
-      message: {
-        type: "error-text",
-        value: `Invalid arguments for writeToFile: ${parsed.error.message}`
-      }
-    };
-  }
-  const { path, content } = parsed.data;
-  await provider.writeFile(path, content);
-  return {
-    success: true,
-    message: {
-      type: "text",
-      value: `<write_to_file_path>${path}</write_to_file_path><status>Success</status>`
-    }
-  };
-};
-var writeToFile_default = {
-  ...toolInfo12,
-  handler: handler12
-};
-
-// src/UsageMeter.ts
-var ZERO_PRICING = {
-  inputPrice: 0,
-  outputPrice: 0,
-  cacheWritesPrice: 0,
-  cacheReadsPrice: 0
-};
-var TOKENS_PER_UNIT = 1e6;
-var MAX_METADATA_ENTRIES = 1e3;
-var UsageMeter = class {
-  #totals = { input: 0, output: 0, cachedRead: 0, cost: 0, messageCount: 0 };
-  #providerMetadataEntries = [];
-  #pendingUpdates = /* @__PURE__ */ new Set();
-  #modelInfos;
-  #maxMessages;
-  #maxCost;
-  #pricingService;
-  constructor(modelInfos = {}, opts = {}) {
-    const infos = {};
-    for (const [provider, providerInfo] of Object.entries(modelInfos)) {
-      for (const [model, modelInfo] of Object.entries(providerInfo)) {
-        infos[`${provider.split("-")[0]}:${model.replace(/[.-]/g, "")}`] = {
-          inputPrice: modelInfo.inputPrice ?? 0,
-          outputPrice: modelInfo.outputPrice ?? 0,
-          cacheWritesPrice: modelInfo.cacheWritesPrice ?? 0,
-          cacheReadsPrice: modelInfo.cacheReadsPrice ?? 0
-        };
-      }
-    }
-    this.#modelInfos = infos;
-    this.#maxMessages = opts.maxMessages ?? 1e3;
-    this.#maxCost = opts.maxCost ?? 100;
-    this.#pricingService = opts.pricingService;
-  }
-  #calculateUsageV3(usage, providerMetadata, modelInfo) {
-    if (!usage?.inputTokens || !usage?.outputTokens) {
-      return { input: 0, output: 0, cachedRead: 0, cost: 0 };
-    }
-    const providerMetadataKey = Object.keys(providerMetadata ?? {})[0];
-    const metadata = providerMetadata?.[providerMetadataKey] ?? {};
-    const inputTokens = usage.inputTokens.noCache ?? usage.inputTokens.total ?? 0;
-    const cachedReadTokens = usage.inputTokens.cacheRead ?? 0;
-    const cachedWriteTokens = usage.inputTokens.cacheWrite ?? 0;
-    const outputTokens = usage.outputTokens.total ?? usage.outputTokens.text ?? 0;
-    return this.#calculateCost(inputTokens, outputTokens, cachedReadTokens, cachedWriteTokens, providerMetadataKey, metadata, modelInfo);
-  }
-  #calculateUsageAiPackage(usage, providerMetadata, modelInfo) {
-    if (!usage?.inputTokens || !usage?.outputTokens) {
-      return { input: 0, output: 0, cachedRead: 0, cost: 0 };
-    }
-    const providerMetadataKey = Object.keys(providerMetadata ?? {})[0];
-    const metadata = providerMetadata?.[providerMetadataKey] ?? {};
-    const details = usage.inputTokenDetails;
-    const outputDetails = usage.outputTokenDetails;
-    const inputTokens = details?.noCacheTokens ?? usage.inputTokens ?? 0;
-    const cachedReadTokens = details?.cacheReadTokens ?? 0;
-    const cachedWriteTokens = details?.cacheWriteTokens ?? 0;
-    const outputTokens = outputDetails?.textTokens ?? usage.outputTokens ?? 0;
-    return this.#calculateCost(inputTokens, outputTokens, cachedReadTokens, cachedWriteTokens, providerMetadataKey, metadata, modelInfo);
-  }
-  #calculateCost(inputTokens, outputTokens, cachedReadTokens, cachedWriteTokens, providerMetadataKey, metadata, modelInfo) {
-    const getNumber = (obj, key) => {
-      const value = obj[key];
-      return typeof value === "number" ? value : void 0;
-    };
-    switch (providerMetadataKey) {
-      case "openrouter": {
-        const usage = metadata.usage;
-        const cost = typeof usage === "object" && usage !== null && "cost" in usage && typeof usage.cost === "number" ? usage.cost : 0;
-        return {
-          input: inputTokens,
-          output: outputTokens,
-          cachedRead: cachedReadTokens,
-          cost
-        };
-      }
-      case "anthropic": {
-        const cacheWrite = getNumber(metadata, "promptCacheMissTokens") ?? cachedWriteTokens;
-        return {
-          input: inputTokens + cacheWrite + cachedReadTokens,
-          output: outputTokens,
-          cachedRead: cachedReadTokens,
-          cost: (inputTokens * modelInfo.inputPrice + outputTokens * modelInfo.outputPrice + cacheWrite * modelInfo.cacheWritesPrice + cachedReadTokens * modelInfo.cacheReadsPrice) / TOKENS_PER_UNIT
-        };
-      }
-      case "deepseek": {
-        const cacheWrite = getNumber(metadata, "promptCacheMissTokens") ?? cachedWriteTokens;
-        return {
-          input: inputTokens,
-          output: outputTokens,
-          cachedRead: cachedReadTokens,
-          cost: (outputTokens * modelInfo.outputPrice + cacheWrite * modelInfo.inputPrice + cachedReadTokens * modelInfo.cacheReadsPrice) / TOKENS_PER_UNIT
-        };
-      }
-      default: {
-        return {
-          input: inputTokens,
-          output: outputTokens,
-          cachedRead: cachedReadTokens,
-          cost: (inputTokens * modelInfo.inputPrice + outputTokens * modelInfo.outputPrice) / TOKENS_PER_UNIT
-        };
-      }
-    }
-  }
-  addUsage(llm, resp, options = {}) {
-    const provider = llm.provider.split(".")[0];
-    const normalizedModel = llm.modelId.replace(/[.-]/g, "");
-    const key = `${provider}:${normalizedModel}`;
-    let modelInfo = options.modelInfo ?? this.#modelInfos[key];
-    const updatePromise = (async () => {
-      try {
-        if (!modelInfo && this.#pricingService) {
-          modelInfo = await this.#pricingService.getPricing(provider, llm.modelId);
-          this.#modelInfos[key] = modelInfo;
-        }
-      } catch {
-        modelInfo = ZERO_PRICING;
-      }
-      modelInfo = modelInfo ?? ZERO_PRICING;
-      const usage = "totalUsage" in resp ? resp.totalUsage : resp.usage;
-      let result;
-      if ("inputTokenDetails" in usage || typeof usage.inputTokens === "number") {
-        result = this.#calculateUsageAiPackage(usage, resp.providerMetadata, modelInfo);
-      } else {
-        result = this.#calculateUsageV3(usage, resp.providerMetadata, modelInfo);
-      }
-      this.#totals.input += result.input;
-      this.#totals.output += result.output;
-      this.#totals.cachedRead += result.cachedRead;
-      this.#totals.cost += result.cost;
-      this.#totals.messageCount += 1;
-      if (resp.providerMetadata && Object.keys(resp.providerMetadata).length > 0) {
-        const providerKey = Object.keys(resp.providerMetadata)[0] || llm.provider;
-        const metadata = resp.providerMetadata[providerKey];
-        if (typeof metadata === "object" && metadata !== null && !Array.isArray(metadata)) {
-          this.#providerMetadataEntries.push({
-            provider: providerKey,
-            model: llm.modelId,
-            metadata,
-            timestamp: Date.now()
-          });
-        }
-        if (this.#providerMetadataEntries.length > MAX_METADATA_ENTRIES) {
-          this.#providerMetadataEntries.splice(0, this.#providerMetadataEntries.length - MAX_METADATA_ENTRIES);
-        }
-      }
-    })();
-    this.#pendingUpdates.add(updatePromise);
-    updatePromise.finally(() => {
-      this.#pendingUpdates.delete(updatePromise);
-    });
-    return updatePromise;
-  }
-  /** Override the running totals (e.g., restore from saved state). */
-  setUsage(newUsage, options = {}) {
-    if (newUsage.input != null) this.#totals.input = newUsage.input;
-    if (newUsage.output != null) this.#totals.output = newUsage.output;
-    if (newUsage.cachedRead != null) this.#totals.cachedRead = newUsage.cachedRead;
-    if (newUsage.cost != null) this.#totals.cost = newUsage.cost;
-    if (newUsage.messageCount != null) this.#totals.messageCount = newUsage.messageCount;
-    if (options.clearMetadata) {
-      this.#providerMetadataEntries = [];
-    }
-  }
-  /** Manually bump the message count (useful if you record some messages without token info). */
-  incrementMessageCount(n = 1) {
-    this.#totals.messageCount += n;
-  }
-  /** Reset the running totals. */
-  resetUsage() {
-    this.#totals = { input: 0, output: 0, cachedRead: 0, cost: 0, messageCount: 0 };
-    this.#providerMetadataEntries = [];
-  }
-  /** Return true once either messages or cost exceed the configured caps. */
-  isLimitExceeded() {
-    const messageCount = this.#maxMessages > 0 && this.#totals.messageCount >= this.#maxMessages;
-    const cost = this.#maxCost > 0 && this.#totals.cost >= this.#maxCost;
-    return {
-      messageCount,
-      maxMessages: this.#maxMessages,
-      cost,
-      maxCost: this.#maxCost,
-      result: messageCount || cost
-    };
-  }
-  /** Same as isLimitExceeded but throws an error if a limit is hit. */
-  checkLimit() {
-    const result = this.isLimitExceeded();
-    if (result.result) {
-      throw new Error(
-        `Usage limit exceeded. Message count: ${result.messageCount}/${result.maxMessages}, cost: ${result.cost}/${result.maxCost}`
-      );
-    }
-  }
-  /** Getter for the aggregated totals (immutable copy). */
-  get usage() {
-    return { ...this.#totals };
-  }
-  /** Getter for provider metadata entries (immutable copy). */
-  get providerMetadata() {
-    return [...this.#providerMetadataEntries];
-  }
-  /** Calculate cache statistics from stored metadata entries. */
-  get cacheStats() {
-    const entries = this.#providerMetadataEntries;
-    const totalRequests = entries.length;
-    let totalCachedTokens = 0;
-    let requestsWithCache = 0;
-    for (const entry of entries) {
-      const metadata = entry.metadata;
-      const getValueAsNumber = (key) => {
-        const value = metadata[key];
-        return typeof value === "number" ? value : void 0;
-      };
-      const cachedTokens = getValueAsNumber("cachedPromptTokens") ?? getValueAsNumber("cacheReadTokens") ?? getValueAsNumber("prompt_cache_hit_tokens") ?? 0;
-      if (cachedTokens > 0) {
-        totalCachedTokens += cachedTokens;
-        requestsWithCache++;
-      }
-    }
-    const cacheHitRate = totalRequests > 0 ? requestsWithCache / totalRequests : 0;
-    return {
-      totalCachedTokens,
-      totalRequests,
-      requestsWithCache,
-      cacheHitRate,
-      entries: [...this.#providerMetadataEntries]
-    };
-  }
-  /** Clear stored provider metadata entries. */
-  clearProviderMetadata() {
-    this.#providerMetadataEntries = [];
-  }
-  /** Merge another UsageMeter's totals into this one. */
-  merge(other) {
-    const otherUsage = other.usage;
-    this.#totals.input += otherUsage.input;
-    this.#totals.output += otherUsage.output;
-    this.#totals.cachedRead += otherUsage.cachedRead;
-    this.#totals.cost += otherUsage.cost;
-    this.#totals.messageCount += otherUsage.messageCount;
-    this.#providerMetadataEntries.push(...other.providerMetadata);
-  }
-  /** Wait for all pending usage updates to complete. */
-  async waitForPending() {
-    const pending = Array.from(this.#pendingUpdates);
-    await Promise.allSettled(pending);
-  }
-  getUsageText() {
-    const u = this.usage;
-    return `Usage - messages: ${u.messageCount}, input: ${u.input}, cached: ${u.cachedRead}, output: ${u.output}, cost: $${u.cost.toFixed(4)}`;
-  }
-  onFinishHandler(llm) {
-    return async (evt) => {
-      await this.addUsage(llm, evt);
-    };
-  }
-};
-
-// 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 z21 } from "zod";
-
-// src/workflow/types.ts
-var TaskEventKind = /* @__PURE__ */ ((TaskEventKind2) => {
-  TaskEventKind2["StartTask"] = "StartTask";
-  TaskEventKind2["StartRequest"] = "StartRequest";
-  TaskEventKind2["EndRequest"] = "EndRequest";
-  TaskEventKind2["Text"] = "Text";
-  TaskEventKind2["Reasoning"] = "Reasoning";
-  TaskEventKind2["ToolUse"] = "ToolUse";
-  TaskEventKind2["ToolReply"] = "ToolReply";
-  TaskEventKind2["ToolError"] = "ToolError";
-  TaskEventKind2["UsageExceeded"] = "UsageExceeded";
-  TaskEventKind2["EndTask"] = "EndTask";
-  return TaskEventKind2;
-})(TaskEventKind || {});
-
-// src/workflow/agent.workflow.ts
-function isValidToolResultOutput(value) {
-  return typeof value === "object" && value !== null && "type" in value && (value.type === "text" || value.type === "content" || value.type === "execution-denied");
-}
-var agentWorkflow = async (input, { step, tools, logger }) => {
-  const event = (name, event2) => step(name, () => tools.taskEvent(event2));
-  const { tools: toolInfo13, maxToolRoundTrips = 200 } = input;
-  const messages = "systemPrompt" in input ? [{ role: "system", content: input.systemPrompt }] : input.messages;
-  await event("start-task", { kind: "StartTask" /* StartTask */, systemPrompt: "systemPrompt" in input ? input.systemPrompt : "" });
-  const toolSet = {};
-  for (const tool of toolInfo13) {
-    toolSet[tool.name] = {
-      description: tool.description,
-      inputSchema: jsonSchema(toJSONSchema(tool.parameters))
-    };
-  }
-  let nextMessage = input.userMessage;
-  for (let i = 0; i < maxToolRoundTrips; i++) {
-    messages.push(...nextMessage);
-    await event(`start-round-${i}`, { kind: "StartRequest" /* StartRequest */, userMessage: nextMessage });
-    const assistantMessage = await step(`agent-round-${i}`, { retry: 2 }, async () => {
-      return await tools.generateText({
-        messages,
-        tools: toolSet,
-        model: input.model
-      });
-    });
-    messages.push(...assistantMessage);
-    const toolCalls = [];
-    for (const msg of assistantMessage) {
-      if (typeof msg.content === "string") {
-        continue;
-      }
-      if (msg.content) {
-        for (const part of msg.content) {
-          if (part.type === "tool-call") {
-            toolCalls.push(part);
-          }
-        }
-      }
-    }
-    const textContent = assistantMessage.flatMap((m) => {
-      if (typeof m.content === "string") {
-        return [m.content];
-      }
-      if (m.role === "assistant" && Array.isArray(m.content)) {
-        return m.content.map((part) => {
-          if (part.type === "text") {
-            return part.text;
-          }
-          return "";
-        });
-      }
-      return [];
-    }).join("\n");
-    await event(`end-round-${i}`, { kind: "EndRequest" /* EndRequest */, message: textContent });
-    if (toolCalls.length === 0) {
-      if (!input.outputSchema) {
-        const exitReason3 = { type: "Exit", message: textContent, messages };
-        await event("end-task", { kind: "EndTask" /* EndTask */, exitReason: exitReason3 });
-        return exitReason3;
-      }
-      const parsed = parseJsonFromMarkdown(textContent);
-      if (!parsed.success) {
-        const errorMessage = `Failed to parse JSON from markdown. Error: ${parsed.error}. Please correct the output. It MUST be in valid JSON format.`;
-        nextMessage = [{ role: "user", content: errorMessage }];
-        continue;
-      }
-      const validated = input.outputSchema.safeParse(parsed.data);
-      if (!validated.success) {
-        const errorMessage = `Output validation failed. Error: ${z21.prettifyError(validated.error)}. Please correct the output.`;
-        nextMessage = [{ role: "user", content: errorMessage }];
-        continue;
-      }
-      const exitReason2 = { type: "Exit", message: textContent, object: validated.data, messages };
-      await event("end-task", { kind: "EndTask" /* EndTask */, exitReason: exitReason2 });
-      return exitReason2;
-    }
-    const toolResults = [];
-    for (const toolCall of toolCalls) {
-      if (!toolSet[toolCall.toolName]) {
-        logger.warn("Tool not found.", toolCall);
-        await event(`event-tool-error-${toolCall.toolName}-${toolCall.toolCallId}`, {
-          kind: "ToolError" /* ToolError */,
-          tool: toolCall.toolName,
-          error: {
-            type: "error-text",
-            value: `Tool '${toolCall.toolName}' not found.`
-          }
-        });
-        toolResults.push({
-          toolCallId: toolCall.toolCallId,
-          toolName: toolCall.toolName,
-          output: {
-            type: "error-text",
-            value: `Error: Tool '${toolCall.toolName}' not found.`
-          }
-        });
-        continue;
-      }
-      await event(`event-tool-use-${toolCall.toolName}-${toolCall.toolCallId}`, {
-        kind: "ToolUse" /* ToolUse */,
-        tool: toolCall.toolName,
-        params: toolCall.input
-      });
-      const toolResponse = await step(`invoke-tool-${toolCall.toolName}-${toolCall.toolCallId}`, async () => {
-        return await tools.invokeTool({
-          toolName: toolCall.toolName,
-          input: toolCall.input
-        });
-      });
-      if (toolResponse.success) {
-        await event(`event-tool-reply-${toolCall.toolName}-${toolCall.toolCallId}`, {
-          kind: "ToolReply" /* ToolReply */,
-          tool: toolCall.toolName,
-          content: toolResponse.message
-        });
-        if (!isValidToolResultOutput(toolResponse.message)) {
-          throw new Error(`Invalid tool result format from ${toolCall.toolName}`);
-        }
-        toolResults.push({
-          toolCallId: toolCall.toolCallId,
-          toolName: toolCall.toolName,
-          output: toolResponse.message
-        });
-      } else {
-        await event(`event-tool-error-${toolCall.toolName}-${toolCall.toolCallId}`, {
-          kind: "ToolError" /* ToolError */,
-          tool: toolCall.toolName,
-          error: toolResponse.message ?? "Unknown error"
-        });
-        if (!isValidToolResultOutput(toolResponse.message)) {
-          throw new Error(`Invalid tool result format from ${toolCall.toolName}`);
-        }
-        toolResults.push({
-          toolCallId: toolCall.toolCallId,
-          toolName: toolCall.toolName,
-          output: toolResponse.message
-        });
-      }
-    }
-    nextMessage = [
-      {
-        role: "tool",
-        content: toolResults.map((r) => ({
-          type: "tool-result",
-          ...r
-        }))
-      }
-    ];
-  }
-  const exitReason = { type: "UsageExceeded", messages };
-  await event("end-task", { kind: "EndTask" /* EndTask */, exitReason });
-  return exitReason;
-};
-
-// src/workflow/dynamic.ts
-import { parse as parse2 } from "yaml";
-import { z as z23 } from "zod";
-
-// src/workflow/dynamic-types.ts
-import { z as z22 } from "zod";
-var WorkflowInputDefinitionSchema = z22.object({
-  id: z22.string(),
-  description: z22.string().nullish(),
-  default: z22.unknown().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: z22.unknown().nullish(),
-  /**
-   * Optional timeout in milliseconds. Step execution will be aborted if it exceeds this duration.
-   */
-  timeout: z22.number().positive().nullish()
-});
-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: z22.string().nullish()
-});
-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: z22.string().nullish()
-});
-var BreakStepSchema = z22.object({
-  break: z22.literal(true)
-});
-var ContinueStepSchema = z22.object({
-  continue: z22.literal(true)
-});
-var TryCatchStepSchema = z22.object({
-  id: z22.string(),
-  try: z22.object({
-    trySteps: z22.array(z22.lazy(() => WorkflowControlFlowStepSchema)),
-    catchSteps: z22.array(z22.lazy(() => WorkflowControlFlowStepSchema))
-  }),
-  output: z22.string().nullish()
-});
-var WorkflowControlFlowStepSchema = z22.union([
-  WorkflowStepDefinitionSchema,
-  WhileLoopStepSchema,
-  IfElseStepSchema,
-  BreakStepSchema,
-  ContinueStepSchema,
-  TryCatchStepSchema
-]);
-var WorkflowDefinitionSchema = z22.object({
-  task: z22.string(),
-  inputs: z22.array(WorkflowInputDefinitionSchema).nullish(),
-  steps: z22.array(WorkflowControlFlowStepSchema),
-  output: z22.string().nullish()
-});
-var WorkflowFileSchema = z22.object({
-  workflows: z22.record(z22.string(), WorkflowDefinitionSchema)
-});
-
-// src/workflow/dynamic.ts
-var MAX_WHILE_LOOP_ITERATIONS = 1e3;
-function convertJsonSchemaToZod(schema) {
-  if (schema.enum) {
-    const enumValues = schema.enum;
-    if (enumValues.length === 0) {
-      return z23.never();
-    }
-    if (enumValues.every((v) => typeof v === "string")) {
-      return z23.enum(enumValues);
-    }
-    const literals = enumValues.map((v) => z23.literal(v));
-    if (literals.length === 1) {
-      return literals[0];
-    }
-    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 z23.string().nullable();
-      if (nonNullType === "number") return z23.number().nullable();
-      if (nonNullType === "integer")
-        return z23.number().refine((val) => Number.isInteger(val)).nullable();
-      if (nonNullType === "boolean") return z23.boolean().nullable();
-      if (nonNullType === "object") {
-        const shape = {};
-        if (schema.properties) {
-          for (const [propName, propSchema] of Object.entries(schema.properties)) {
-            const propZod = convertJsonSchemaToZod(propSchema);
-            const isRequired = schema.required?.includes(propName);
-            shape[propName] = isRequired ? propZod : propZod.optional();
-          }
-        }
-        return z23.object(shape).nullable();
-      }
-      if (nonNullType === "array") return z23.array(z23.any()).nullable();
-    }
-    return z23.any();
-  }
-  const type = schema.type;
-  switch (type) {
-    case "string":
-      return z23.string();
-    case "number":
-      return z23.number();
-    case "integer":
-      return z23.number().refine((val) => Number.isInteger(val), { message: "Expected an integer" });
-    case "boolean":
-      return z23.boolean();
-    case "null":
-      return z23.null();
-    case "object": {
-      const shape = {};
-      if (schema.properties) {
-        for (const [propName, propSchema] of Object.entries(schema.properties)) {
-          const propZod = convertJsonSchemaToZod(propSchema);
-          const isRequired = schema.required?.includes(propName);
-          shape[propName] = isRequired ? propZod : propZod.optional();
-        }
-      }
-      if (schema.additionalProperties === true) {
-        return z23.object(shape).passthrough();
-      }
-      if (typeof schema.additionalProperties === "object") {
-        const additionalSchema = convertJsonSchemaToZod(schema.additionalProperties);
-        return z23.intersection(z23.object(shape), z23.record(z23.string(), additionalSchema));
-      }
-      return z23.object(shape);
-    }
-    case "array": {
-      if (!schema.items) {
-        return z23.array(z23.any());
-      }
-      const itemSchema = convertJsonSchemaToZod(schema.items);
-      return z23.array(itemSchema);
-    }
-    default:
-      return z23.any();
-  }
-}
-var TOOL_GROUPS = {
-  readonly: ["readFile", "readBinaryFile", "listFiles", "searchFiles"],
-  readwrite: ["readFile", "readBinaryFile", "listFiles", "searchFiles", "writeToFile", "replaceInFile", "removeFile", "renameFile"],
-  internet: ["fetchUrl", "search"]
-};
-function validateWorkflowFile(definition) {
-  const errors = [];
-  for (const [workflowId, workflow] of Object.entries(definition.workflows)) {
-    if (!workflow.steps || workflow.steps.length === 0) {
-      errors.push(`Workflow '${workflowId}' has no steps`);
-      continue;
-    }
-    const checkBreakOutsideLoop = (steps, inLoop, path) => {
-      for (const step of steps) {
-        if (isBreakStep(step) || isContinueStep(step)) {
-          if (!inLoop) {
-            errors.push(`${path} has break/continue outside of a loop`);
-          }
-        }
-        if (isWhileLoopStep(step)) {
-          checkBreakOutsideLoop(step.while.steps, true, `${path}/${step.id}`);
-        }
-        if (isIfElseStep(step)) {
-          if (step.if.thenBranch) {
-            checkBreakOutsideLoop(step.if.thenBranch, inLoop, `${path}/${step.id}/then`);
-          }
-          if (step.if.elseBranch) {
-            checkBreakOutsideLoop(step.if.elseBranch, inLoop, `${path}/${step.id}/else`);
-          }
-        }
-        if (isTryCatchStep(step)) {
-          checkBreakOutsideLoop(step.try.trySteps, inLoop, `${path}/${step.id}/try`);
-          checkBreakOutsideLoop(step.try.catchSteps, inLoop, `${path}/${step.id}/catch`);
-        }
-      }
-    };
-    checkBreakOutsideLoop(workflow.steps, false, workflowId);
-    const findRunWorkflowCalls = (steps, path) => {
-      for (const step of steps) {
-        if (isWhileLoopStep(step)) {
-          findRunWorkflowCalls(step.while.steps, `${path}/${step.id}`);
-        }
-        if (isIfElseStep(step)) {
-          if (step.if.thenBranch) {
-            findRunWorkflowCalls(step.if.thenBranch, `${path}/${step.id}/then`);
-          }
-          if (step.if.elseBranch) {
-            findRunWorkflowCalls(step.if.elseBranch, `${path}/${step.id}/else`);
-          }
-        }
-        if (isTryCatchStep(step)) {
-          findRunWorkflowCalls(step.try.trySteps, `${path}/${step.id}/try`);
-          findRunWorkflowCalls(step.try.catchSteps, `${path}/${step.id}/catch`);
-        }
-      }
-    };
-    findRunWorkflowCalls(workflow.steps, workflowId);
-  }
-  if (errors.length > 0) {
-    return { success: false, errors };
-  }
-  return { success: true };
-}
-function parseDynamicWorkflowDefinition(source) {
-  try {
-    const raw = parse2(source);
-    const validated = WorkflowFileSchema.safeParse(raw);
-    if (!validated.success) {
-      return { success: false, error: z23.prettifyError(validated.error) };
-    }
-    const validation = validateWorkflowFile(validated.data);
-    if (!validation.success) {
-      return { success: false, error: `Workflow validation failed:
-${validation.errors.map((e) => `  - ${e}`).join("\n")}` };
-    }
-    return { success: true, definition: validated.data };
-  } catch (error) {
-    return { success: false, error: error instanceof Error ? error.message : String(error) };
-  }
-}
-function validateAndApplyDefaults(workflowId, workflow, input) {
-  if (!workflow.inputs || workflow.inputs.length === 0) {
-    return input;
-  }
-  const validatedInput = { ...input };
-  const errors = [];
-  for (const inputDef of workflow.inputs) {
-    const providedValue = input[inputDef.id];
-    if (providedValue !== void 0 && providedValue !== null) {
-      validatedInput[inputDef.id] = providedValue;
-    } else if (inputDef.default !== void 0 && inputDef.default !== null) {
-      validatedInput[inputDef.id] = inputDef.default;
-    } else {
-      errors.push(`Missing required input '${inputDef.id}'${inputDef.description ? `: ${inputDef.description}` : ""}`);
-    }
-  }
-  if (errors.length > 0) {
-    throw new Error(`Workflow '${workflowId}' input validation failed:
-${errors.map((e) => `  - ${e}`).join("\n")}`);
-  }
-  return validatedInput;
-}
-function evaluateCondition(condition, input, state, allowUnsafeCodeExecution = false, logger) {
-  if (allowUnsafeCodeExecution) {
-    if (logger) {
-      logger.warn(
-        `[SECURITY] Executing unsafe code evaluation for condition: ${condition}. This allows arbitrary JavaScript execution and should only be used for trusted workflows.`
-      );
-    }
-    const functionBody = `
-      try {
-        return ${condition};
-      } catch (error) {
-        throw new Error('Condition evaluation failed: ' + (error instanceof Error ? error.message : String(error)));
-      }
-    `;
-    try {
-      const fn = new Function("input", "state", functionBody);
-      const result = fn(input, state);
-      return Boolean(result);
-    } catch (error) {
-      throw new Error(`Failed to evaluate condition: ${condition}. Error: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  } else {
-    return evaluateConditionSafe(condition, input, state);
-  }
-}
-function evaluateConditionSafe(condition, input, state) {
-  condition = condition.trim();
-  if (condition === "true") return true;
-  if (condition === "false") return false;
-  const orIndex = findTopLevelOperator(condition, "||");
-  if (orIndex !== -1) {
-    const left = condition.slice(0, orIndex).trim();
-    const right = condition.slice(orIndex + 2).trim();
-    return evaluateConditionSafe(left, input, state) || evaluateConditionSafe(right, input, state);
-  }
-  const andIndex = findTopLevelOperator(condition, "&&");
-  if (andIndex !== -1) {
-    const left = condition.slice(0, andIndex).trim();
-    const right = condition.slice(andIndex + 2).trim();
-    return evaluateConditionSafe(left, input, state) && evaluateConditionSafe(right, input, state);
-  }
-  const comparisonOps = ["===", "!==", "==", "!=", ">=", "<=", ">", "<"];
-  for (const op of comparisonOps) {
-    const opIndex = findTopLevelOperator(condition, op);
-    if (opIndex !== -1) {
-      const left = evaluateValue(condition.slice(0, opIndex).trim(), input, state);
-      const right = evaluateValue(condition.slice(opIndex + op.length).trim(), input, state);
-      return compareValues(left, right, op);
-    }
-  }
-  if (condition.startsWith("!")) {
-    return !evaluateConditionSafe(condition.slice(1).trim(), input, state);
-  }
-  if (hasEnclosingParens(condition)) {
-    const inner = condition.slice(1, -1);
-    return evaluateConditionSafe(inner, input, state);
-  }
-  const value = evaluateValue(condition, input, state);
-  return Boolean(value);
-}
-function findTopLevelOperator(expr, op) {
-  let parenDepth = 0;
-  let inString = false;
-  let stringChar = "";
-  let escapeNext = false;
-  for (let i = 0; i <= expr.length - op.length; i++) {
-    const char = expr[i];
-    if (escapeNext) {
-      escapeNext = false;
-      continue;
-    }
-    if (char === "\\") {
-      escapeNext = true;
-      continue;
-    }
-    if (!inString && (char === '"' || char === "'")) {
-      inString = true;
-      stringChar = char;
-      continue;
-    }
-    if (inString && char === stringChar) {
-      inString = false;
-      stringChar = "";
-      continue;
-    }
-    if (inString) continue;
-    if (char === "(") parenDepth++;
-    if (char === ")") parenDepth--;
-    if (parenDepth === 0 && expr.slice(i, i + op.length) === op) {
-      return i;
-    }
-  }
-  return -1;
-}
-function hasEnclosingParens(expr) {
-  expr = expr.trim();
-  if (!expr.startsWith("(") || !expr.endsWith(")")) {
-    return false;
-  }
-  let depth = 0;
-  let inString = false;
-  let stringChar = "";
-  let escapeNext = false;
-  for (let i = 0; i < expr.length; i++) {
-    const char = expr[i];
-    if (escapeNext) {
-      escapeNext = false;
-      continue;
-    }
-    if (char === "\\") {
-      escapeNext = true;
-      continue;
-    }
-    if (!inString && (char === '"' || char === "'")) {
-      inString = true;
-      stringChar = char;
-      continue;
-    }
-    if (inString && char === stringChar) {
-      inString = false;
-      stringChar = "";
-      continue;
-    }
-    if (inString) continue;
-    if (char === "(") {
-      depth++;
-      if (i === 0) depth = 1;
-    }
-    if (char === ")") {
-      depth--;
-      if (depth === 0 && i === expr.length - 1) {
-        return true;
-      }
-      if (depth === 0 && i < expr.length - 1) {
-        return false;
-      }
-    }
-  }
-  return false;
-}
-function evaluateValue(expr, input, state) {
-  expr = expr.trim();
-  const stringMatch = expr.match(/^(["'])(?:(?=(\\?))\2.)*?\1$/);
-  if (stringMatch) {
-    const quote = stringMatch[1];
-    if (quote === '"') {
-      try {
-        return JSON.parse(expr);
-      } catch (error) {
-        throw new Error(`Invalid string literal: "${expr}". Error: ${error instanceof Error ? error.message : String(error)}`);
-      }
-    } else {
-      let inner = expr.slice(1, -1);
-      inner = inner.replace(/\\'/g, "'");
-      inner = inner.replace(/\\"/g, '"');
-      const converted = `"${inner.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
-      try {
-        return JSON.parse(converted);
-      } catch (error) {
-        throw new Error(`Invalid string literal: "${expr}". Error: ${error instanceof Error ? error.message : String(error)}`);
-      }
-    }
-  }
-  if (/^-?\d*\.?\d+(?:[eE][+-]?\d+)?$/.test(expr)) {
-    return Number.parseFloat(expr);
-  }
-  if (expr === "true") return true;
-  if (expr === "false") return false;
-  if (expr === "null") return null;
-  if (expr.startsWith("input.")) {
-    return getNestedProperty(input, expr.slice(6));
-  }
-  if (expr.startsWith("state.")) {
-    return getNestedProperty(state, expr.slice(6));
-  }
-  throw new Error(
-    `Unrecognized expression in condition: "${expr}". Valid expressions are: string literals, numbers, boolean literals, null, or property access like "input.foo" or "state.bar"`
-  );
-}
-function getNestedProperty(obj, path) {
-  const parts = path.split(".");
-  let current = obj;
-  for (const part of parts) {
-    if (current == null) return void 0;
-    if (typeof current !== "object") return void 0;
-    current = current[part];
-  }
-  return current;
-}
-function compareValues(left, right, op) {
-  switch (op) {
-    case "===":
-      return left === right;
-    case "!==":
-      return left !== right;
-    case "==":
-      return Object.is(left, right);
-    case "!=":
-      return !Object.is(left, right);
-    case ">=":
-      return left >= right;
-    case "<=":
-      return left <= right;
-    case ">":
-      return left > right;
-    case "<":
-      return left < right;
-    default:
-      throw new Error(`Unknown comparison operator: ${op}`);
-  }
-}
-function createRunWorkflowFn(args) {
-  return async (subWorkflowId, subInput) => {
-    const mergedInput = { ...args.input, ...args.state, ...subInput ?? {} };
-    return await args.runInternal(subWorkflowId, mergedInput, args.context, args.state);
-  };
-}
-async function executeStepWithAgent(stepDef, workflowId, input, state, context, options, runInternal) {
-  const tools = context.tools;
-  if (typeof tools.generateText !== "function" || typeof tools.invokeTool !== "function" || typeof tools.taskEvent !== "function") {
-    throw new Error(
-      `Step '${stepDef.id}' in workflow '${workflowId}' requires agent execution, but AgentToolRegistry tools are not available.`
-    );
-  }
-  if (!options.toolInfo) {
-    throw new Error(
-      `Step '${stepDef.id}' in workflow '${workflowId}' requires agent execution, but no toolInfo was provided to DynamicWorkflowRunner.`
-    );
-  }
-  const rawAllowedToolNames = stepDef.tools;
-  let toolsForAgent;
-  if (rawAllowedToolNames) {
-    const expandedToolNames = /* @__PURE__ */ new Set();
-    let includeAll = false;
-    for (const name of rawAllowedToolNames) {
-      if (name === "all") {
-        includeAll = true;
-        break;
-      }
-      if (Object.hasOwn(TOOL_GROUPS, name)) {
-        for (const tool of TOOL_GROUPS[name]) {
-          expandedToolNames.add(tool);
-        }
-      } else {
-        expandedToolNames.add(name);
-      }
-    }
-    if (includeAll) {
-      toolsForAgent = [...options.toolInfo];
-    } else {
-      toolsForAgent = options.toolInfo.filter((t) => expandedToolNames.has(t.name));
-    }
-  } else {
-    toolsForAgent = [...options.toolInfo];
-  }
-  if (!rawAllowedToolNames || rawAllowedToolNames.includes("all") || rawAllowedToolNames.includes("runWorkflow")) {
-    toolsForAgent.push({
-      name: "runWorkflow",
-      description: "Run a named sub-workflow defined in the current workflow file.",
-      parameters: 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." } };
-      }
-    });
-  }
-  const allowedToolNameSet = new Set(toolsForAgent.map((t) => t.name));
-  context.logger.debug(`[Agent] Available tools for step '${stepDef.id}': ${toolsForAgent.map((t) => t.name).join(", ")}`);
-  const systemPrompt = options.stepSystemPrompt?.({ workflowId, step: stepDef, input, state }) ?? [
-    `You are an AI assistant executing a workflow step.`,
-    "",
-    "# Instructions",
-    "- Execute the task defined in the user message.",
-    "- Use the provided tools to accomplish the task.",
-    "- Return the step output as valid JSON in markdown.",
-    "- Do not ask for user input. If information is missing, make a reasonable assumption or fail."
-  ].filter(Boolean).join("\n");
-  const userContent = [
-    `Workflow: ${workflowId}`,
-    `Step: ${stepDef.id}`,
-    `Task: ${stepDef.task}`,
-    stepDef.expected_outcome ? `Expected outcome: ${stepDef.expected_outcome}` : "",
-    `Workflow Input: ${JSON.stringify(input)}`,
-    `Current State: ${JSON.stringify(state)}`
-  ].filter(Boolean).join("\n");
-  const runWorkflow = createRunWorkflowFn({ input, state, context, runInternal });
-  const agentTools = {
-    generateText: tools.generateText.bind(tools),
-    taskEvent: tools.taskEvent.bind(tools),
-    invokeTool: async ({ toolName, input: toolInput }) => {
-      if (!allowedToolNameSet.has(toolName)) {
-        return {
-          success: false,
-          message: { type: "error-text", value: `Tool '${toolName}' is not allowed in this step.` }
-        };
-      }
-      if (toolName === "runWorkflow") {
-        const runWorkflowInput = toolInput;
-        const subWorkflowId = runWorkflowInput?.workflowId;
-        const subInput = runWorkflowInput?.input;
-        if (typeof subWorkflowId !== "string") {
-          return {
-            success: false,
-            message: { type: "error-text", value: "runWorkflow.workflowId must be a string." }
-          };
-        }
-        try {
-          const output = await runWorkflow(subWorkflowId, subInput);
-          const jsonResult = { type: "json", value: output };
-          return { success: true, message: jsonResult };
-        } catch (error) {
-          return {
-            success: false,
-            message: { type: "error-text", value: error instanceof Error ? error.message : String(error) }
-          };
-        }
-      }
-      return await tools.invokeTool({ toolName, input: toolInput });
-    }
-  };
-  const result = await agentWorkflow(
-    {
-      tools: toolsForAgent,
-      systemPrompt,
-      userMessage: [{ role: "user", content: userContent }],
-      maxToolRoundTrips: options.maxToolRoundTrips,
-      model: options.model
-    },
-    { ...context, tools: agentTools }
-  );
-  if (result.type === "Exit") {
-    if (result.object !== void 0) {
-      return result.object;
-    }
-    const parsed = parseJsonFromMarkdown(result.message);
-    if (parsed.success) {
-      return parsed.data;
-    }
-    if (options.wrapAgentResultInObject) {
-      context.logger.warn(`[Agent] Step '${stepDef.id}' returned plain text instead of JSON. Wrapping in {result: ...}`);
-      return { result: result.message };
-    }
-    return result.message;
-  }
-  if (result.type === "Error") {
-    throw new Error(`Agent step '${stepDef.id}' in workflow '${workflowId}' failed: ${result.error?.message || "Unknown error"}`);
-  }
-  if (result.type === "UsageExceeded") {
-    throw new Error(`Agent step '${stepDef.id}' in workflow '${workflowId}' exceeded usage limits (tokens or rounds)`);
-  }
-  const _exhaustiveCheck = result;
-  throw new Error(`Agent step '${stepDef.id}' in workflow '${workflowId}' exited unexpectedly with unhandled type`);
-}
-async function executeStepWithTimeout(stepDef, workflowId, input, state, context, options, runInternal) {
-  const executeStepLogic = async () => {
-    context.logger.debug(`[Step] Executing step '${stepDef.id}' with agent`);
-    const result = await executeStepWithAgent(stepDef, workflowId, input, state, context, options, runInternal);
-    context.logger.debug(`[Step] Agent execution completed for step '${stepDef.id}'`);
-    return result;
-  };
-  if (stepDef.timeout && stepDef.timeout > 0) {
-    context.logger.debug(`[Step] Step '${stepDef.id}' has timeout of ${stepDef.timeout}ms`);
-    let timeoutId;
-    const timeoutPromise = new Promise((_, reject) => {
-      timeoutId = setTimeout(
-        () => reject(new Error(`Step '${stepDef.id}' in workflow '${workflowId}' timed out after ${stepDef.timeout}ms`)),
-        stepDef.timeout
-      );
-    });
-    try {
-      return await Promise.race([executeStepLogic(), timeoutPromise]);
-    } finally {
-      if (timeoutId) clearTimeout(timeoutId);
-    }
-  }
-  return await executeStepLogic();
-}
-async function executeStep(stepDef, workflowId, input, state, context, options, runInternal) {
-  const result = await executeStepWithTimeout(stepDef, workflowId, input, state, context, options, runInternal);
-  if (stepDef.outputSchema) {
-    try {
-      context.logger.debug(`[Step] Validating output for step '${stepDef.id}' against schema`);
-      const zodSchema = convertJsonSchemaToZod(stepDef.outputSchema);
-      const validationResult = zodSchema.safeParse(result);
-      if (!validationResult.success) {
-        const errorDetails = validationResult.error.issues.map((e) => `  - ${e.path.join(".") || "root"}: ${e.message}`).join("\n");
-        throw new Error(`Output does not match expected schema:
-${errorDetails}`);
-      }
-      context.logger.debug(`[Step] Output validation successful for step '${stepDef.id}'`);
-    } catch (error) {
-      throw new Error(
-        `Step '${stepDef.id}' in workflow '${workflowId}' output validation failed: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  return result;
-}
-function isBreakStep(step) {
-  return typeof step === "object" && step !== null && "break" in step && step.break === true;
-}
-function isContinueStep(step) {
-  return typeof step === "object" && step !== null && "continue" in step && step.continue === true;
-}
-function isWhileLoopStep(step) {
-  return typeof step === "object" && step !== null && "while" in step;
-}
-function isIfElseStep(step) {
-  return typeof step === "object" && step !== null && "if" in step;
-}
-function isTryCatchStep(step) {
-  return typeof step === "object" && step !== null && "try" in step;
-}
-function storeStepOutput(step, result, state) {
-  if ("id" in step && step.output) {
-    const outputKey = step.output;
-    state[outputKey] = result;
-  }
-}
-function getStepId(step) {
-  if ("id" in step && step.id) {
-    return step.id;
-  }
-  if (isWhileLoopStep(step)) {
-    return "while";
-  }
-  if (isIfElseStep(step)) {
-    return "if";
-  }
-  if (isTryCatchStep(step)) {
-    return "try";
-  }
-  return "control";
-}
-async function executeControlFlowStep(step, workflowId, input, state, context, options, runInternal, loopDepth, breakFlag, continueFlag) {
-  if (isBreakStep(step)) {
-    if (loopDepth === 0) {
-      throw new Error(`'break' statement found outside of a loop in workflow '${workflowId}'`);
-    }
-    context.logger.debug(`[ControlFlow] Executing break statement (loop depth: ${loopDepth})`);
-    return { result: void 0, shouldBreak: true, shouldContinue: false };
-  }
-  if (isContinueStep(step)) {
-    if (loopDepth === 0) {
-      throw new Error(`'continue' statement found outside of a loop in workflow '${workflowId}'`);
-    }
-    context.logger.debug(`[ControlFlow] Executing continue statement (loop depth: ${loopDepth})`);
-    return { result: void 0, shouldBreak: false, shouldContinue: true };
-  }
-  if (isWhileLoopStep(step)) {
-    context.logger.info(`[ControlFlow] Executing while loop '${step.id}'`);
-    context.logger.debug(`[ControlFlow] Condition: ${step.while.condition}`);
-    context.logger.debug(`[ControlFlow] Loop body has ${step.while.steps.length} step(s)`);
-    let iterationCount = 0;
-    let loopResult;
-    while (true) {
-      iterationCount++;
-      if (iterationCount > MAX_WHILE_LOOP_ITERATIONS) {
-        throw new Error(
-          `While loop '${step.id}' in workflow '${workflowId}' exceeded maximum iteration limit of ${MAX_WHILE_LOOP_ITERATIONS}`
-        );
-      }
-      const conditionResult = evaluateCondition(step.while.condition, input, state, options.allowUnsafeCodeExecution);
-      context.logger.debug(`[ControlFlow] While loop '${step.id}' iteration ${iterationCount}: condition = ${conditionResult}`);
-      if (!conditionResult) {
-        context.logger.info(`[ControlFlow] While loop '${step.id}' terminated after ${iterationCount - 1} iteration(s)`);
-        break;
-      }
-      for (const bodyStep of step.while.steps) {
-        const { result, shouldBreak, shouldContinue } = await executeControlFlowStep(
-          bodyStep,
-          workflowId,
-          input,
-          state,
-          context,
-          options,
-          runInternal,
-          loopDepth + 1,
-          breakFlag,
-          continueFlag
-        );
-        if (shouldBreak) {
-          context.logger.debug(`[ControlFlow] Breaking from while loop '${step.id}'`);
-          breakFlag.value = false;
-          return { result: loopResult, shouldBreak: false, shouldContinue: false };
-        }
-        if (shouldContinue) {
-          context.logger.debug(`[ControlFlow] Continuing to next iteration of while loop '${step.id}'`);
-          continueFlag.value = false;
-          break;
-        }
-        storeStepOutput(bodyStep, result, state);
-        loopResult = result;
-      }
-    }
-    const outputKey = step.output ?? step.id;
-    state[outputKey] = loopResult;
-    context.logger.debug(`[ControlFlow] While loop '${step.id}' stored output as '${outputKey}'`);
-    return { result: loopResult, shouldBreak: false, shouldContinue: false };
-  }
-  if (isIfElseStep(step)) {
-    const ifStep = step;
-    context.logger.info(`[ControlFlow] Executing if/else branch '${ifStep.id}'`);
-    context.logger.debug(`[ControlFlow] Condition: ${ifStep.if.condition}`);
-    context.logger.debug(`[ControlFlow] Then branch has ${ifStep.if.thenBranch.length} step(s)`);
-    if (ifStep.if.elseBranch) {
-      context.logger.debug(`[ControlFlow] Else branch has ${ifStep.if.elseBranch.length} step(s)`);
-    }
-    const conditionResult = evaluateCondition(ifStep.if.condition, input, state, options.allowUnsafeCodeExecution);
-    context.logger.debug(`[ControlFlow] If/else '${ifStep.id}' condition = ${conditionResult}`);
-    const branchSteps = conditionResult ? ifStep.if.thenBranch : ifStep.if.elseBranch ?? [];
-    const branchName = conditionResult ? "then" : ifStep.if.elseBranch ? "else" : "else (empty)";
-    context.logger.info(`[ControlFlow] Taking '${branchName}' branch of '${ifStep.id}'`);
-    let branchResult;
-    for (const branchStep of branchSteps) {
-      const { result, shouldBreak, shouldContinue } = await executeControlFlowStep(
-        branchStep,
-        workflowId,
-        input,
-        state,
-        context,
-        options,
-        runInternal,
-        loopDepth,
-        breakFlag,
-        continueFlag
-      );
-      if (shouldBreak || shouldContinue) {
-        return { result, shouldBreak, shouldContinue };
-      }
-      storeStepOutput(branchStep, result, state);
-      branchResult = result;
-    }
-    const outputKey = ifStep.output ?? ifStep.id;
-    state[outputKey] = branchResult;
-    context.logger.debug(`[ControlFlow] If/else '${ifStep.id}' stored output as '${outputKey}'`);
-    return { result: branchResult, shouldBreak: false, shouldContinue: false };
-  }
-  if (isTryCatchStep(step)) {
-    const tryStep = step;
-    context.logger.info(`[ControlFlow] Executing try/catch block '${tryStep.id}'`);
-    context.logger.debug(`[ControlFlow] Try block has ${tryStep.try.trySteps.length} step(s)`);
-    context.logger.debug(`[ControlFlow] Catch block has ${tryStep.try.catchSteps.length} step(s)`);
-    let tryResult;
-    let caughtError;
-    try {
-      for (const tryStepItem of tryStep.try.trySteps) {
-        const { result } = await executeControlFlowStep(
-          tryStepItem,
-          workflowId,
-          input,
-          state,
-          context,
-          options,
-          runInternal,
-          loopDepth,
-          breakFlag,
-          continueFlag
-        );
-        storeStepOutput(tryStepItem, result, state);
-        tryResult = result;
-      }
-      const outputKey = tryStep.output ?? tryStep.id;
-      state[outputKey] = tryResult;
-      context.logger.debug(`[ControlFlow] Try/catch '${tryStep.id}' completed successfully`);
-      return { result: tryResult, shouldBreak: false, shouldContinue: false };
-    } catch (error) {
-      caughtError = error instanceof Error ? error : new Error(String(error));
-      context.logger.warn(`[ControlFlow] Try/catch '${tryStep.id}' caught error: ${caughtError.message}`);
-      let catchResult;
-      for (const catchStepItem of tryStep.try.catchSteps) {
-        const { result } = await executeControlFlowStep(
-          catchStepItem,
-          workflowId,
-          input,
-          state,
-          context,
-          options,
-          runInternal,
-          loopDepth,
-          breakFlag,
-          continueFlag
-        );
-        storeStepOutput(catchStepItem, result, state);
-        catchResult = result;
-      }
-      const outputKey = tryStep.output ?? tryStep.id;
-      state[outputKey] = catchResult;
-      context.logger.debug(`[ControlFlow] Try/catch '${tryStep.id}' caught error and executed catch block`);
-      return { result: catchResult, shouldBreak: false, shouldContinue: false };
-    }
-  }
-  const stepDef = step;
-  const stepResult = await executeStep(stepDef, workflowId, input, state, context, options, runInternal);
-  return { result: stepResult, shouldBreak: false, shouldContinue: false };
-}
-function createDynamicWorkflow(definition, options = {}) {
-  if (typeof definition === "string") {
-    const res = parseDynamicWorkflowDefinition(definition);
-    if (!res.success) {
-      throw new Error(res.error);
-    }
-    definition = res.definition;
-  }
-  const runInternal = async (workflowId, input, context, inheritedState) => {
-    const workflow = definition.workflows[workflowId];
-    if (!workflow) {
-      const builtIn = options.builtInWorkflows?.[workflowId];
-      if (builtIn) {
-        context.logger.info(`[Workflow] Delegating to built-in workflow '${workflowId}'`);
-        return await builtIn(input, context);
-      }
-      throw new Error(`Workflow '${workflowId}' not found`);
-    }
-    const validatedInput = validateAndApplyDefaults(workflowId, workflow, input);
-    context.logger.info(`[Workflow] Starting workflow '${workflowId}'`);
-    context.logger.debug(`[Workflow] Input: ${JSON.stringify(validatedInput)}`);
-    context.logger.debug(`[Workflow] Inherited state: ${JSON.stringify(inheritedState)}`);
-    context.logger.debug(`[Workflow] Steps: ${workflow.steps.map((s) => "id" in s ? s.id : "<control flow>").join(", ")}`);
-    const state = { ...inheritedState };
-    let lastOutput;
-    const breakFlag = { value: false };
-    const continueFlag = { value: false };
-    for (let i = 0; i < workflow.steps.length; i++) {
-      const stepDef = workflow.steps[i];
-      const stepId = getStepId(stepDef);
-      context.logger.info(`[Workflow] Step ${i + 1}/${workflow.steps.length}: ${stepId}`);
-      const { result } = await executeControlFlowStep(
-        stepDef,
-        workflowId,
-        validatedInput,
-        state,
-        context,
-        options,
-        runInternal,
-        0,
-        // loop depth
-        breakFlag,
-        continueFlag
-      );
-      lastOutput = result;
-      storeStepOutput(stepDef, result, state);
-      if ("id" in stepDef && stepDef.output) {
-        context.logger.debug(
-          `[Workflow] Step output stored as '${stepDef.output}': ${typeof lastOutput === "object" ? JSON.stringify(lastOutput).substring(0, 200) : lastOutput}`
-        );
-      }
-    }
-    context.logger.info(`[Workflow] Completed workflow '${workflowId}'`);
-    if (workflow.output) {
-      context.logger.debug(`[Workflow] Returning output field: ${workflow.output}`);
-      return state[workflow.output];
-    }
-    context.logger.debug(`[Workflow] Returning full state with keys: ${Object.keys(state).join(", ")}`);
-    return state;
-  };
-  return async (workflowId, input, context) => {
-    return await runInternal(workflowId, input, context, {});
-  };
-}
-
-// src/workflow/json-ai-types.ts
-var toJsonDataContent = (data) => {
-  if (data instanceof URL) {
-    return {
-      type: "url",
-      value: data.toString()
-    };
-  }
-  if (typeof data === "string") {
-    return {
-      type: "base64",
-      value: data
-    };
-  }
-  let buffer;
-  if (data instanceof Uint8Array) {
-    buffer = Buffer.from(data);
-  } else if (data instanceof Buffer) {
-    buffer = data;
-  } else {
-    buffer = Buffer.from(data);
-  }
-  return {
-    type: "base64",
-    value: buffer.toString("base64")
-  };
-};
-var toJsonUserContent = (content) => {
-  if (typeof content === "string") {
-    return content;
-  }
-  return content.map((part) => {
-    switch (part.type) {
-      case "image":
-        return {
-          ...part,
-          image: toJsonDataContent(part.image)
-        };
-      case "file":
-        return {
-          ...part,
-          data: toJsonDataContent(part.data)
-        };
-    }
-    return part;
-  });
-};
-var toJsonAssistantContent = (content) => {
-  if (typeof content === "string") {
-    return content;
-  }
-  return content.map((part) => {
-    switch (part.type) {
-      case "file":
-        return {
-          ...part,
-          data: toJsonDataContent(part.data)
-        };
-      case "tool-call":
-        return {
-          ...part,
-          input: part.input
-        };
-    }
-    return part;
-  });
-};
-var toJsonModelMessage = (msg) => {
-  switch (msg.role) {
-    case "user":
-      return {
-        ...msg,
-        content: toJsonUserContent(msg.content)
-      };
-    case "assistant":
-      return {
-        ...msg,
-        content: toJsonAssistantContent(msg.content)
-      };
-  }
-  return msg;
-};
-var fromJsonDataContent = (data) => {
-  if (data.type === "url") {
-    return new URL(data.value);
-  }
-  return Buffer.from(data.value, "base64");
-};
-var fromJsonUserContent = (content) => {
-  if (typeof content === "string") {
-    return content;
-  }
-  return content.map((part) => {
-    switch (part.type) {
-      case "image":
-        return {
-          ...part,
-          image: fromJsonDataContent(part.image)
-        };
-      case "file":
-        return {
-          ...part,
-          data: fromJsonDataContent(part.data)
-        };
-    }
-    return part;
-  });
-};
-var fromJsonAssistantContent = (content) => {
-  if (typeof content === "string") {
-    return content;
-  }
-  return content.map((part) => {
-    switch (part.type) {
-      case "file":
-        return {
-          ...part,
-          data: fromJsonDataContent(part.data)
-        };
-    }
-    return part;
-  });
-};
-var fromJsonModelMessage = (msg) => {
-  switch (msg.role) {
-    case "system":
-      return msg;
-    case "user":
-      return {
-        ...msg,
-        content: fromJsonUserContent(msg.content)
-      };
-    case "assistant":
-      return {
-        ...msg,
-        content: fromJsonAssistantContent(msg.content)
-      };
-  }
-  return msg;
-};
-
-// src/workflow/workflow.ts
-var silentLogger = {
-  debug: () => {
-  },
-  info: () => {
-  },
-  warn: () => {
-  },
-  error: () => {
-  }
-};
-function createContext(tools, stepFn, logger = silentLogger) {
-  if (!stepFn) {
-    stepFn = async (_name, arg2, arg3) => {
-      const fn = typeof arg2 === "function" ? arg2 : arg3;
-      return fn();
-    };
-  }
-  return { step: stepFn, logger, tools };
-}
-var makeStepFn = () => {
-  const results = /* @__PURE__ */ new Map();
-  const callStack = [];
-  return async (name, arg2, arg3) => {
-    let fn;
-    let options;
-    if (typeof arg2 === "function") {
-      fn = arg2;
-      options = arg3;
-    } else {
-      options = arg2;
-      fn = arg3;
-    }
-    callStack.push(name);
-    const key = callStack.join(">");
-    try {
-      if (results.has(key)) {
-        return results.get(key);
-      }
-      const maxRetryCount = options?.retry ?? 0;
-      let lastError;
-      for (let retryCount = 0; retryCount <= maxRetryCount; retryCount++) {
-        try {
-          const result = await fn();
-          results.set(key, result);
-          return result;
-        } catch (error) {
-          lastError = error;
-        }
-      }
-      throw lastError;
-    } finally {
-      callStack.pop();
-    }
-  };
-};
-export {
-  BaseError,
-  BreakStepSchema,
-  ContinueStepSchema,
-  DEFAULT_MEMORY_CONFIG,
-  IGNORED_DIRECTORIES,
-  IfElseStepSchema,
-  ListSkillsInputSchema,
-  ListSkillsOutputSchema,
-  LoadSkillInputSchema,
-  LoadSkillOutputSchema,
-  MockProvider,
-  NodeFileSystemProvider,
-  PricingService,
-  ReadSkillFileInputSchema,
-  ReadSkillFileOutputSchema,
-  SKILL_ERROR_MESSAGES,
-  SKILL_LIMITS,
-  SOURCE_ICONS,
-  SUSPICIOUS_PATTERNS,
-  SkillDiscoveryError,
-  SkillDiscoveryService,
-  SkillValidationError,
-  TOOL_GROUPS,
-  TaskEventKind,
-  TodoItemSchema,
-  TodoStatus,
-  TryCatchStepSchema,
-  UpdateTodoItemInputSchema,
-  UpdateTodoItemOutputSchema,
-  UsageMeter,
-  WhileLoopStepSchema,
-  WorkflowControlFlowStepSchema,
-  WorkflowDefinitionSchema,
-  WorkflowFileSchema,
-  WorkflowInputDefinitionSchema,
-  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,
-  getSkillStats,
-  listFiles_default as listFiles,
-  listSkills,
-  listSkillsToolInfo,
-  loadSkill,
-  loadSkillToolInfo,
-  makeStepFn,
-  mcpServerConfigSchema,
-  memoryConfigSchema,
-  modelConfigSchema,
-  parseDynamicWorkflowDefinition,
-  parseJsonFromMarkdown,
-  providerConfigSchema,
-  providerModelSchema,
-  readBinaryFile_default as readBinaryFile,
-  readFile_default as readFile,
-  readSkillFile,
-  readSkillFileToolInfo,
-  removeFile_default as removeFile,
-  renameFile_default as renameFile,
-  replaceInFile_default as replaceInFile,
-  replaceInFile as replaceInFileHelper,
-  resolveHomePath,
-  responsePrompts,
-  ruleSchema,
-  scriptSchema,
-  search_default as search,
-  searchFiles_default as searchFiles,
-  skillMetadataSchema,
-  toJsonModelMessage,
-  toolConfigSchema,
-  validateSkillMetadata,
-  validateSkillReferences,
-  validateSkillSecurity,
-  validateWorkflowFile,
-  writeToFile_default as writeToFile
-};
+export * from './Agent';
+export * from './Agent/backoff';
+export * from './config';
+export * from './errors';
+export * from './fs';
+export * from './memory';
+export * from './pricing';
+export * from './skills';
+export * from './skills/tools';
+export * from './tool';
+export * from './tools';
+export { replaceInFile as replaceInFileHelper } from './tools/utils/replaceInFile';
+export * from './UsageMeter';
+export * from './utils';
+export * from './workflow/agent.workflow';
+export * from './workflow/dynamic';
+export * from './workflow/dynamic-types';
+export * from './workflow/json-ai-types';
+export * from './workflow/types';
+export * from './workflow/workflow';
+//# sourceMappingURL=index.js.map