@ddlqhd/agent-sdk 0.1.0 → 0.2.0

package/dist/{chunk-OHXW2YM6.js → chunk-MEJHTQJM.js}

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import { zodToJsonSchema } from './chunk-WH3APNQ5.js';
+import { zodToJsonSchema } from './chunk-LOYIGOBZ.js';
 import { mkdir, writeFile, readFile } from 'fs/promises';
-import { join, dirname } from 'path';
+import { join, dirname, win32 } from 'path';
 import { homedir } from 'os';
-import { z } from 'zod';
 import iconv from 'iconv-lite';
 import fg from 'fast-glob';
+import { z } from 'zod';
 import { analyse } from 'chardet';
 import { execSync, spawn } from 'child_process';
 import { existsSync } from 'fs';
@@ -223,16 +223,20 @@ var OutputHandler = class {
 function createOutputHandler(userBasePath) {
   return new OutputHandler(userBasePath);
 }
+
+// src/tools/registry.ts
 var ToolRegistry = class {
   tools = /* @__PURE__ */ new Map();
   categories = /* @__PURE__ */ new Map();
   outputHandler;
   hookManager = null;
   executionPolicy;
+  hookObserver;
   constructor(config) {
     const enableOutputHandler = config?.enableOutputHandler !== false;
     this.outputHandler = enableOutputHandler ? createOutputHandler(config?.userBasePath) : null;
     this.executionPolicy = config?.executionPolicy;
+    this.hookObserver = config?.hookObserver;
   }
   /**
    * 工具名是否在 {@link ToolExecutionPolicy.disallowedTools} 中（无策略时为 false）。
@@ -299,6 +303,14 @@ var ToolRegistry = class {
       ...extra
     };
   }
+  hookObserverCtx(eventType, name, options) {
+    return {
+      eventType,
+      toolName: name,
+      toolCallId: options?.toolCallId,
+      projectDir: options?.projectDir
+    };
+  }
   /**
    * 注册工具
    */
@@ -369,6 +381,11 @@ var ToolRegistry = class {
     }
     const tool = this.tools.get(name);
     if (!tool) {
+      if (hookMgr) {
+        this.hookObserver?.onHookStart?.(
+          this.hookObserverCtx("postToolUseFailure", name, options)
+        );
+      }
       const ctx = this.buildHookContext("postToolUseFailure", name, rawArgsObj, options, {
         errorMessage: `Tool "${name}" not found`,
         failureKind: "tool_error"
@@ -381,32 +398,56 @@ var ToolRegistry = class {
     }
     let workingInput = rawArgsObj;
     try {
-      workingInput = tool.parameters.parse(args);
+      const initial = tool.parameters.safeParse(args);
+      if (!initial.success) {
+        const msg = `Invalid arguments for tool "${name}": ${initial.error.issues.map((i) => i.message).join(", ")}`;
+        if (hookMgr) {
+          this.hookObserver?.onHookStart?.(
+            this.hookObserverCtx("postToolUseFailure", name, options)
+          );
+        }
+        await hookMgr?.executePostToolUseFailure(
+          this.buildHookContext("postToolUseFailure", name, rawArgsObj, options, {
+            errorMessage: msg,
+            failureKind: "validation"
+          })
+        );
+        return { content: msg, isError: true };
+      }
+      workingInput = initial.data;
       if (hookMgr) {
+        this.hookObserver?.onHookStart?.(
+          this.hookObserverCtx("preToolUse", name, options)
+        );
         const pre = await hookMgr.executePreToolUse(
           this.buildHookContext("preToolUse", name, workingInput, options)
         );
+        this.hookObserver?.onHookDecision?.({
+          ...this.hookObserverCtx("preToolUse", name, options),
+          allowed: pre.allowed,
+          reason: pre.reason
+        });
         if (!pre.allowed) {
           return {
             content: pre.reason ?? "Blocked by hook",
             isError: true
           };
         }
-        try {
-          workingInput = tool.parameters.parse(pre.updatedInput ?? workingInput);
-        } catch (err) {
-          if (err instanceof z.ZodError) {
-            const msg = `Invalid arguments after hook merge for tool "${name}": ${err.errors.map((e) => e.message).join(", ")}`;
-            await hookMgr.executePostToolUseFailure(
-              this.buildHookContext("postToolUseFailure", name, workingInput, options, {
-                errorMessage: msg,
-                failureKind: "validation"
-              })
-            );
-            return { content: msg, isError: true };
-          }
-          throw err;
+        const merged = tool.parameters.safeParse(pre.updatedInput ?? workingInput);
+        if (!merged.success) {
+          const msg = `Invalid arguments after hook merge for tool "${name}": ${merged.error.issues.map((i) => i.message).join(", ")}`;
+          this.hookObserver?.onHookStart?.(
+            this.hookObserverCtx("postToolUseFailure", name, options)
+          );
+          await hookMgr.executePostToolUseFailure(
+            this.buildHookContext("postToolUseFailure", name, workingInput, options, {
+              errorMessage: msg,
+              failureKind: "validation"
+            })
+          );
+          return { content: msg, isError: true };
         }
+        workingInput = merged.data;
       }
       const handlerArgs = workingInput;
       const executionContext = {
@@ -417,6 +458,11 @@ var ToolRegistry = class {
       const result = await tool.handler(handlerArgs, executionContext);
       const toolResultRaw = result;
       if (result.isError) {
+        if (hookMgr) {
+          this.hookObserver?.onHookStart?.(
+            this.hookObserverCtx("postToolUseFailure", name, options)
+          );
+        }
         await hookMgr?.executePostToolUseFailure(
           this.buildHookContext("postToolUseFailure", name, workingInput, options, {
             errorMessage: result.content,
@@ -434,6 +480,11 @@ var ToolRegistry = class {
           { args: handlerArgs }
         );
       }
+      if (hookMgr) {
+        this.hookObserver?.onHookStart?.(
+          this.hookObserverCtx("postToolUse", name, options)
+        );
+      }
       await hookMgr?.executePostToolUse(
         this.buildHookContext("postToolUse", name, workingInput, options, {
           toolResultRaw,
@@ -442,20 +493,12 @@ var ToolRegistry = class {
       );
       return finalResult;
     } catch (error) {
-      if (error instanceof z.ZodError) {
-        const msg2 = `Invalid arguments for tool "${name}": ${error.errors.map((e) => e.message).join(", ")}`;
-        await hookMgr?.executePostToolUseFailure(
-          this.buildHookContext("postToolUseFailure", name, rawArgsObj, options, {
-            errorMessage: msg2,
-            failureKind: "validation"
-          })
+      const msg = `Error executing tool "${name}": ${error instanceof Error ? error.message : String(error)}`;
+      if (hookMgr) {
+        this.hookObserver?.onHookStart?.(
+          this.hookObserverCtx("postToolUseFailure", name, options)
         );
-        return {
-          content: msg2,
-          isError: true
-        };
       }
-      const msg = `Error executing tool "${name}": ${error instanceof Error ? error.message : String(error)}`;
       await hookMgr?.executePostToolUseFailure(
         this.buildHookContext("postToolUseFailure", name, workingInput, options, {
           errorMessage: msg,
@@ -802,10 +845,94 @@ var MAX_LINE_LENGTH = 2e3;
 var MAX_LINE_SUFFIX = `... (line truncated to ${MAX_LINE_LENGTH} chars)`;
 var MAX_BYTES = 50 * 1024;
 var MAX_BYTES_LABEL = `${MAX_BYTES / 1024} KB`;
+var EDIT_MAX_FILE_BYTES = 1024 ** 3;
+function detectDominantEol(content) {
+  let crlf = 0;
+  for (let i = 0; i < content.length - 1; i++) {
+    if (content[i] === "\r" && content[i + 1] === "\n") {
+      crlf++;
+    }
+  }
+  let nl = 0;
+  for (let i = 0; i < content.length; i++) {
+    if (content[i] === "\n") {
+      nl++;
+    }
+  }
+  const bareLf = nl - crlf;
+  if (crlf > bareLf) {
+    return "\r\n";
+  }
+  return "\n";
+}
+function normalizeNewStringEols(text, eol) {
+  const unified = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  if (eol === "\n") {
+    return unified;
+  }
+  return unified.replace(/\n/g, "\r\n");
+}
+function buildNeedleCandidates(oldString, dominantEol) {
+  const out = [oldString];
+  if (dominantEol === "\r\n") {
+    if (!oldString.includes("\r")) {
+      const v = oldString.replace(/\n/g, "\r\n");
+      if (v !== oldString) {
+        out.push(v);
+      }
+    }
+  } else {
+    if (oldString.includes("\r\n")) {
+      const v = oldString.replace(/\r\n/g, "\n");
+      if (v !== oldString) {
+        out.push(v);
+      }
+    } else if (oldString.includes("\r")) {
+      const v = oldString.replace(/\r/g, "\n");
+      if (v !== oldString) {
+        out.push(v);
+      }
+    }
+  }
+  return out;
+}
+function countOccurrences(haystack, needle) {
+  if (needle.length === 0) {
+    return 0;
+  }
+  let n = 0;
+  let from = 0;
+  let i = 0;
+  while ((i = haystack.indexOf(needle, from)) !== -1) {
+    n++;
+    from = i + needle.length;
+  }
+  return n;
+}
+function replaceNonOverlapping(content, needle, replacement, replaceAll) {
+  if (!replaceAll) {
+    const i2 = content.indexOf(needle);
+    if (i2 === -1) {
+      throw new Error("Edit: needle not found after resolution (internal inconsistency)");
+    }
+    return content.slice(0, i2) + replacement + content.slice(i2 + needle.length);
+  }
+  let out = "";
+  let from = 0;
+  let i = 0;
+  while ((i = content.indexOf(needle, from)) !== -1) {
+    out += content.slice(from, i) + replacement;
+    from = i + needle.length;
+  }
+  out += content.slice(from);
+  return out;
+}
 var readFileTool = createTool({
   name: "Read",
   category: "filesystem",
-  description: `Reads a file from the local filesystem. You can access any file directly by using this tool.
+  description: `Reads human-readable text from the local filesystem: source code, configuration, logs, Markdown, and structured text (JSON, XML, YAML, etc.).
+
+Do NOT use Read for binary formats. This tool decodes the file as text; for binaries the result is garbage or misleading. Examples: images (png, jpg, gif, webp, ico), Office/OpenXML (xlsx, docx, pptx), PDF, audio/video, archives (zip, gz, etc.), and compiled binaries. Prefer format-specific tooling, a small script or library in the user's environment, or ask the user for an exported/plain-text view.
 
 Usage:
 - The file_path parameter must be an absolute path, not a relative path
@@ -814,10 +941,12 @@ Usage:
 - Results are returned using cat -n style, with line numbers starting at 1
 - Lines longer than 2000 characters are truncated
 - Use the offset and limit parameters to read specific line ranges of large files
-- If you read a file that exists but has empty contents you will receive an error message
+- An empty file (no lines) returns successfully with no numbered lines and a suffix noting zero total lines\u2014it is not an error
 - Text encoding is detected automatically from the file (BOM, UTF-8 validity, charset analysis). You rarely need to set encoding; use it only to override detection (e.g. gbk, gb18030, cp936 maps to gbk)`,
   parameters: z.object({
-    file_path: z.string().describe("The absolute path to the file to read"),
+    file_path: z.string().describe(
+      "Absolute path to a text or text-decodable source file (not binary formats such as images, xlsx, or pdf)."
+    ),
     encoding: z.string().optional().describe(
       'Optional. Omit or use "auto" for automatic detection (default). Set only to force a specific encoding (utf8, gbk, gb18030, latin1, etc.; cp936 is treated as gbk).'
     ),
@@ -988,7 +1117,9 @@ var editTool = createTool({
 
 Usage:
 - You must use the Read tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file
+- Files at or above 1 GiB cannot be edited with this tool (use another workflow for huge files)
 - When editing text from Read tool output, ensure you preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix format is: line number + tab. Everything after that is the actual file content to match. Never include any part of the line number prefix in the old_string or new_string
+- old_string may use \\n line breaks; CRLF files are matched and new_string is rewritten to the file's dominant line ending style (\\r\\n vs \\n)
 - ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required
 - Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked
 - The edit will FAIL if old_string is not unique in the file. Either provide a larger string with more surrounding context to make it unique or use replace_all to change every instance of old_string
@@ -996,7 +1127,7 @@ Usage:
 - For non-UTF-8 files, set encoding to the same value you used with Read (default is utf8)`,
   parameters: z.object({
     file_path: z.string().describe("The absolute path to the file to modify"),
-    old_string: z.string().describe("The text to replace"),
+    old_string: z.string().min(1).describe("The text to replace (non-empty)"),
     new_string: z.string().describe("The text to replace it with (must be different from old_string)"),
     replace_all: z.boolean().default(false).describe("Replace all occurrences of old_string (default false)"),
     encoding: z.string().optional().describe(
@@ -1018,25 +1149,46 @@ Usage:
           isError: true
         };
       }
+      const fs = await import('fs/promises');
+      const stat = await fs.stat(file_path);
+      if (!stat.isFile()) {
+        return {
+          content: `Error: ${file_path} is not a file`,
+          isError: true
+        };
+      }
+      if (stat.size >= EDIT_MAX_FILE_BYTES) {
+        return {
+          content: `Error: file is too large to edit (${stat.size} bytes). Maximum size is ${EDIT_MAX_FILE_BYTES} bytes (1 GiB). Use a different tool or split the work.`,
+          isError: true
+        };
+      }
       const content = await readFileAsUnicodeString(file_path, normalized);
-      if (!content.includes(old_string)) {
+      const dominantEol = detectDominantEol(content);
+      const candidates = buildNeedleCandidates(old_string, dominantEol);
+      let needle = null;
+      for (const c of candidates) {
+        if (countOccurrences(content, c) > 0) {
+          needle = c;
+          break;
+        }
+      }
+      if (needle === null) {
         return {
           content: `old_string not found in ${file_path}`,
           isError: true
         };
       }
-      if (!replace_all) {
-        const occurrences2 = content.split(old_string).length - 1;
-        if (occurrences2 > 1) {
-          return {
-            content: `Found ${occurrences2} matches for old_string. Provide more context to make it unique, or set replace_all to true.`,
-            isError: true
-          };
-        }
+      const occurrences = countOccurrences(content, needle);
+      if (!replace_all && occurrences > 1) {
+        return {
+          content: `Found ${occurrences} matches for old_string. Provide more context to make it unique, or set replace_all to true.`,
+          isError: true
+        };
       }
-      const newContent = replace_all ? content.replaceAll(old_string, new_string) : content.replace(old_string, new_string);
+      const normalizedNew = normalizeNewStringEols(new_string, dominantEol);
+      const newContent = replaceNonOverlapping(content, needle, normalizedNew, replace_all);
       await writeFileFromUnicodeString(file_path, newContent, normalized);
-      const occurrences = replace_all ? content.split(old_string).length - 1 : 1;
       return {
         content: `Successfully edited ${file_path} (${occurrences} replacement${occurrences > 1 ? "s" : ""})`
       };
@@ -1118,6 +1270,53 @@ function findInPath(executable) {
     return null;
   }
 }
+function findGitBashNextToGitExe(gitExe) {
+  if (!existsSync(gitExe)) {
+    return null;
+  }
+  const dir = win32.dirname(gitExe);
+  const siblingBash = win32.join(dir, "bash.exe");
+  if (existsSync(siblingBash)) {
+    return siblingBash;
+  }
+  let walk = dir;
+  for (let i = 0; i < 4; i++) {
+    const bashPath = win32.join(walk, "bin", "bash.exe");
+    if (existsSync(bashPath)) {
+      return bashPath;
+    }
+    const parent = win32.dirname(walk);
+    if (parent === walk) {
+      break;
+    }
+    walk = parent;
+  }
+  return null;
+}
+function findBashViaGitInstall() {
+  const gitExe = findInPath("git");
+  if (!gitExe) {
+    return null;
+  }
+  return findGitBashNextToGitExe(gitExe);
+}
+function findGitBashInDefaultInstallDirs() {
+  const drives = ["C", "D", "E"];
+  const relatives = [
+    ["Program Files", "Git", "bin", "bash.exe"],
+    ["Program Files (x86)", "Git", "bin", "bash.exe"]
+  ];
+  for (const drive of drives) {
+    const root = `${drive}:\\`;
+    for (const parts of relatives) {
+      const p = win32.join(root, ...parts);
+      if (existsSync(p)) {
+        return p;
+      }
+    }
+  }
+  return null;
+}
 function getShellPath() {
   if (cachedShellPath !== null) {
     return cachedShellPath;
@@ -1128,15 +1327,15 @@ function getShellPath() {
       cachedShellPath = bashPath;
       return bashPath;
     }
-    const gitBashPaths = [
-      "C:\\Program Files\\Git\\bin\\bash.exe",
-      "C:\\Program Files (x86)\\Git\\bin\\bash.exe"
-    ];
-    for (const path of gitBashPaths) {
-      if (existsSync(path)) {
-        cachedShellPath = path;
-        return path;
-      }
+    const viaGit = findBashViaGitInstall();
+    if (viaGit) {
+      cachedShellPath = viaGit;
+      return viaGit;
+    }
+    const fromDirs = findGitBashInDefaultInstallDirs();
+    if (fromDirs) {
+      cachedShellPath = fromDirs;
+      return fromDirs;
     }
     const pwshPath = findInPath("pwsh");
     if (pwshPath) {
@@ -1960,128 +2159,52 @@ var webSearchTool = createTool({
 function getWebTools() {
   return [webFetchTool, webSearchTool];
 }
-var tasks = /* @__PURE__ */ new Map();
-var nextId = 1;
-var taskCreateTool = createTool({
-  name: "TaskCreate",
+var todoStatusEnum = z.enum(["pending", "in_progress", "completed"]);
+var todoWriteTool = createTool({
+  name: "TodoWrite",
   category: "planning",
-  description: `Use this tool to create a structured task list for your current coding session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
+  description: `MUST USE for multi-step tasks. Creates a structured task list to track progress. Call this tool FIRST before executing any complex task.
 
-## When to Use This Tool
+Any number of tasks may be "in_progress" when work runs in parallel. Zero in_progress is fine (e.g. all pending or all completed).
 
-- Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
-- Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
-- User explicitly requests todo list - When the user directly asks you to use the task list
-- User provides multiple tasks - When users provide a list of things to be done
+**Before you finish your assistant response for a multi-step request**, call \`TodoWrite\` again so **every** item in the list has status \`completed\`, unless you are explicitly pausing mid-work for a follow-up turn. Do not leave dangling \`pending\` or \`in_progress\` items when the work for this request is done.
 
-## When NOT to Use
+**Replanning:** If execution shows the earlier plan was wrong, incomplete, or no longer fits (wrong order, missing steps, obsolete items), call \`TodoWrite\` anytime with an updated full list\u2014add, remove, merge, or rewrite steps as needed.
 
-- There is only a single, straightforward task
-- The task is trivial and tracking it provides no organizational benefit
-- The task can be completed in less than 3 trivial steps
-
-All tasks are created with status pending.`,
+Triggers: multi-step tasks, multiple files/components, user provides task list.
+Skip: single simple task, informational questions.`,
   parameters: z.object({
-    subject: z.string().describe("A brief title for the task"),
-    description: z.string().describe("What needs to be done"),
-    activeForm: z.string().optional().describe('Present continuous form shown in spinner when in_progress (e.g., "Running tests")')
-  }),
-  handler: async ({ subject, description, activeForm }) => {
-    const id = String(nextId++);
-    const task = {
-      id,
-      subject,
-      description,
-      status: "pending",
-      ...activeForm && { activeForm }
-    };
-    tasks.set(id, task);
-    return {
-      content: `Task created [${id}]: ${subject}`,
-      metadata: { task }
-    };
-  }
-});
-var taskUpdateTool = createTool({
-  name: "TaskUpdate",
-  category: "planning",
-  description: `Use this tool to update a task in the task list.
-
-## When to Use This Tool
-
-**Mark tasks as completed:**
-- When you have completed the work described in a task
-- IMPORTANT: Always mark your assigned tasks as completed when you finish them
-
-**Delete tasks:**
-- When a task is no longer relevant or was created in error
-
-## Status Workflow
-
-Status progresses: pending \u2192 in_progress \u2192 completed`,
-  parameters: z.object({
-    taskId: z.string().describe("The ID of the task to update"),
-    status: z.enum(["pending", "in_progress", "completed", "deleted"]).optional().describe("New status for the task"),
-    subject: z.string().optional().describe("New subject for the task"),
-    description: z.string().optional().describe("New description for the task"),
-    activeForm: z.string().optional().describe("Present continuous form shown in spinner when in_progress")
+    todos: z.array(
+      z.object({
+        content: z.string().describe('Brief description of the task in imperative form (e.g., "Run tests")'),
+        activeForm: z.string().optional().describe(
+          'Optional present-continuous label for in-progress UI (e.g., "Running tests"). Omit if not needed.'
+        ),
+        status: todoStatusEnum.describe("Task status: pending, in_progress, or completed")
+      })
+    ).min(1).describe(
+      "Full updated todo list. Refresh this whenever progress or the plan changes. When finishing the multi-step work, all entries should be completed."
+    )
   }),
-  handler: async ({ taskId, status, subject, description, activeForm }) => {
-    const task = tasks.get(taskId);
-    if (!task) {
-      return {
-        content: `Task ${taskId} not found`,
-        isError: true
-      };
-    }
-    if (status === "deleted") {
-      tasks.delete(taskId);
-      return { content: `Task ${taskId} deleted` };
-    }
-    if (status) task.status = status;
-    if (subject) task.subject = subject;
-    if (description) task.description = description;
-    if (activeForm) task.activeForm = activeForm;
-    const icon = task.status === "completed" ? "x" : task.status === "in_progress" ? ">" : " ";
-    return {
-      content: `Task [${taskId}] updated: [${icon}] ${task.subject}`,
-      metadata: { task }
-    };
-  }
-});
-var taskListTool = createTool({
-  name: "TaskList",
-  category: "planning",
-  description: `Use this tool to list all tasks in the task list.
-
-## Output
-
-Returns a summary of each task:
-- id: Task identifier (use with TaskUpdate)
-- subject: Brief description of the task
-- status: pending, in_progress, or completed`,
-  parameters: z.object({}),
-  handler: async () => {
-    if (tasks.size === 0) {
-      return { content: "No tasks in the list." };
-    }
+  handler: async ({ todos }) => {
     const lines = [];
-    for (const [, task] of tasks) {
-      const icon = task.status === "completed" ? "x" : task.status === "in_progress" ? ">" : " ";
-      lines.push(`[${icon}] [${task.id}] ${task.subject}`);
+    for (const todo of todos) {
+      const icon = todo.status === "completed" ? "x" : todo.status === "in_progress" ? ">" : " ";
+      lines.push(`[${icon}] ${todo.content}`);
     }
-    const pending = [...tasks.values()].filter((t) => t.status === "pending").length;
-    const inProgress = [...tasks.values()].filter((t) => t.status === "in_progress").length;
-    const completed = [...tasks.values()].filter((t) => t.status === "completed").length;
+    const pending = todos.filter((todo) => todo.status === "pending").length;
+    const inProgress = todos.filter((todo) => todo.status === "in_progress").length;
+    const completed = todos.filter((todo) => todo.status === "completed").length;
     return {
-      content: `Tasks (${completed} completed, ${inProgress} in progress, ${pending} pending):
+      content: `Task list updated (${completed} completed, ${inProgress} in progress, ${pending} pending):
 
-${lines.join("\n")}`
+${lines.join("\n")}`,
+      metadata: { todos }
     };
   }
 });
-function getTaskTools() {
-  return [taskCreateTool, taskUpdateTool, taskListTool];
+function getPlanningTools() {
+  return [todoWriteTool];
 }
 var questionsSchema = z.object({
   questions: z.array(
@@ -2292,7 +2415,7 @@ function getAllBuiltinTools(skillRegistry, interactionOptions) {
     ...getShellTools(),
     ...getGrepTools(),
     ...getWebTools(),
-    ...getTaskTools(),
+    ...getPlanningTools(),
     ...getInteractionTools(interactionOptions),
     ...getSubagentTools(),
     ...getSkillTools(skillRegistry)
@@ -2703,6 +2826,6 @@ function createFunctionHook(config) {
   };
 }
 
-export { DEFAULT_GREP_HEAD_LIMIT, FileStorageStrategy, HookManager, MAX_LINE_LENGTH2 as MAX_LINE_LENGTH, OUTPUT_CONFIG, OutputHandler, PaginationHintStrategy, SmartTruncateStrategy, ToolRegistry, agentTool, bashTool, buildHookEnv, createAgentTool, createAskUserQuestionTool, createFunctionHook, createOutputHandler, createSkillTool, createTool, editTool, formatAnswerSummary, formatAskUserQuestionPrompt, formatEnvironmentSection, getAllBuiltinTools, getEnvironmentInfo, getFileSystemTools, getGlobalRegistry, getGrepTools, getInteractionTools, getSafeBuiltinTools, getShellTools, getSkillTools, getSubagentTools, getTaskTools, getWebTools, globTool, grepTool, loadHooksSettingsFromProject, loadHooksSettingsFromUser, matchTool, mergeCommandHookLayers, parseHooksSettingsFile, questionTool, readFileTool, subagentRequestSchema, taskCreateTool, taskListTool, taskUpdateTool, truncateMatchLineForDisplay, webFetchTool, webSearchTool, writeFileTool };
-//# sourceMappingURL=chunk-OHXW2YM6.js.map
-//# sourceMappingURL=chunk-OHXW2YM6.js.map
+export { DEFAULT_GREP_HEAD_LIMIT, FileStorageStrategy, HookManager, MAX_LINE_LENGTH2 as MAX_LINE_LENGTH, OUTPUT_CONFIG, OutputHandler, PaginationHintStrategy, SmartTruncateStrategy, ToolRegistry, agentTool, bashTool, buildHookEnv, createAgentTool, createAskUserQuestionTool, createFunctionHook, createOutputHandler, createSkillTool, createTool, editTool, formatAnswerSummary, formatAskUserQuestionPrompt, formatEnvironmentSection, getAllBuiltinTools, getEnvironmentInfo, getFileSystemTools, getGlobalRegistry, getGrepTools, getInteractionTools, getPlanningTools, getSafeBuiltinTools, getShellTools, getSkillTools, getSubagentTools, getWebTools, globTool, grepTool, loadHooksSettingsFromProject, loadHooksSettingsFromUser, matchTool, mergeCommandHookLayers, parseHooksSettingsFile, questionTool, readFileTool, subagentRequestSchema, todoWriteTool, truncateMatchLineForDisplay, webFetchTool, webSearchTool, writeFileTool };
+//# sourceMappingURL=chunk-MEJHTQJM.js.map
+//# sourceMappingURL=chunk-MEJHTQJM.js.map