@polka-codes/core 0.9.46 → 0.9.47

package/dist/index.js

@@ -1,29 +1,232 @@
-// src/tools/askFollowupQuestion.ts
+// 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 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 (part.mediaType.startsWith("image/")) {
+              return {
+                type: "image",
+                mediaType: part.mediaType,
+                image: part.data
+              };
+            }
+            return {
+              type: "file",
+              mediaType: part.mediaType,
+              data: part.data
+            };
+          }),
+          {
+            type: "text",
+            text: "</tool_response>"
+          }
+        ];
+    }
+  },
+  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 } from "zod";
+var providerModelSchema = z.object({
+  provider: z.string().optional(),
+  model: z.string().optional(),
+  parameters: z.record(z.string(), z.any()).optional()
+});
+var configSchema = z.object({
+  prices: z.record(
+    z.string(),
+    // provider
+    z.record(
+      z.string(),
+      // model
+      z.object({
+        inputPrice: z.number().optional(),
+        outputPrice: z.number().optional(),
+        cacheWritesPrice: z.number().optional(),
+        cacheReadsPrice: z.number().optional()
+      })
+    )
+  ).optional(),
+  providers: z.record(
+    z.string(),
+    z.object({
+      apiKey: z.string().optional(),
+      defaultModel: z.string().optional(),
+      defaultParameters: z.record(z.string(), z.any()).optional(),
+      location: z.string().optional(),
+      project: z.string().optional(),
+      keyFile: z.string().optional()
+    })
+  ).optional(),
+  defaultProvider: z.string().optional(),
+  defaultModel: z.string().optional(),
+  defaultParameters: z.record(z.string(), z.any()).optional(),
+  maxMessageCount: z.number().int().positive().optional(),
+  budget: z.number().positive().optional(),
+  retryCount: z.number().int().min(0).optional(),
+  requestTimeoutSeconds: z.number().int().positive().optional(),
+  summaryThreshold: z.number().int().positive().optional(),
+  scripts: z.record(
+    z.string(),
+    z.string().or(
+      z.object({
+        command: z.string(),
+        description: z.string()
+      })
+    )
+  ).optional(),
+  commands: z.object({
+    default: providerModelSchema.optional()
+  }).catchall(providerModelSchema).optional(),
+  rules: z.array(z.string()).optional().or(z.string()).optional(),
+  excludeFiles: z.array(z.string()).optional()
+}).strict();
 
 // src/tool.ts
 var ToolResponseType = /* @__PURE__ */ ((ToolResponseType2) => {
   ToolResponseType2["Reply"] = "Reply";
   ToolResponseType2["Exit"] = "Exit";
-  ToolResponseType2["Invalid"] = "Invalid";
   ToolResponseType2["Error"] = "Error";
-  ToolResponseType2["Interrupted"] = "Interrupted";
-  ToolResponseType2["HandOver"] = "HandOver";
-  ToolResponseType2["Delegate"] = "Delegate";
-  ToolResponseType2["Pause"] = "Pause";
   return ToolResponseType2;
 })(ToolResponseType || {});
 
+// src/tools/appendMemory.ts
+import { z as z2 } from "zod";
+var toolInfo = {
+  name: "appendMemory",
+  description: "Appends content to a memory topic.",
+  parameters: z2.object({
+    topic: z2.string().nullish().describe('The topic to append to in memory. Defaults to ":default:".'),
+    content: z2.string().describe("The content to append.")
+  })
+};
+var handler = async (provider, args) => {
+  const { topic, content } = toolInfo.parameters.parse(args);
+  await provider.appendMemory(topic ?? void 0, content);
+  return {
+    type: "Reply" /* Reply */,
+    message: {
+      type: "text",
+      value: `Content appended to memory topic '${topic || ""}'.`
+    }
+  };
+};
+var appendMemory_default = {
+  ...toolInfo,
+  handler
+};
+
 // src/tools/askFollowupQuestion.ts
-var questionObject = z.object({
-  prompt: z.string().describe("The text of the question.").meta({ usageValue: "question text here" }),
-  options: z.array(z.string()).default([]).describe("Ordered list of suggested answers (omit if none).").meta({ usageValue: "suggested answer here" })
+import { z as z3 } from "zod";
+var questionObject = z3.object({
+  prompt: z3.string().describe("The text of the question.").meta({ usageValue: "question text here" }),
+  options: z3.array(z3.string()).default([]).describe("Ordered list of suggested answers (omit if none).").meta({ usageValue: "suggested answer here" })
 });
-var toolInfo = {
-  name: "ask_followup_question",
+var toolInfo2 = {
+  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: z.object({
-    questions: z.array(questionObject).describe("One or more follow-up questions you need answered before you can continue.").meta({ usageValue: "questions here" })
+  parameters: z3.object({
+    questions: z3.array(questionObject).describe("One or more follow-up questions you need answered before you can continue.").meta({ usageValue: "questions here" })
   }).meta({
     examples: [
       {
@@ -69,7 +272,7 @@ var toolInfo = {
     ]
   })
 };
-var handler = async (provider, args) => {
+var handler2 = async (provider, args) => {
   if (!provider.askFollowupQuestion) {
     return {
       type: "Error" /* Error */,
@@ -79,10 +282,10 @@ var handler = async (provider, args) => {
       }
     };
   }
-  const { questions } = toolInfo.parameters.parse(args);
+  const { questions } = toolInfo2.parameters.parse(args);
   if (questions.length === 0) {
     return {
-      type: "Invalid" /* Invalid */,
+      type: "Error" /* Error */,
       message: {
         type: "error-text",
         value: "No questions provided"
@@ -105,132 +308,15 @@ ${answer}
     }
   };
 };
-var isAvailable = (provider) => {
-  return !!provider.askFollowupQuestion;
-};
 var askFollowupQuestion_default = {
-  ...toolInfo,
-  handler,
-  isAvailable
-};
-
-// src/tools/attemptCompletion.ts
-import { z as z2 } from "zod";
-var toolInfo2 = {
-  name: "attempt_completion",
-  description: "Use this tool when you believe the user\u2019s requested task is complete. Indicate that your work is finished, but acknowledge the user may still provide additional instructions or questions if they want to continue. This tool MUST NOT to be used with any other tool.",
-  parameters: z2.object({
-    result: z2.string().describe(
-      "The result of the task. Formulate this result in a way that is final and does not require further input from the user. Don't end your result with questions or offers for further assistance."
-    ).meta({ usageValue: "Your final result description here" })
-  }).meta({
-    examples: [
-      {
-        description: "Request to present the result of the task",
-        input: {
-          result: "Your final result description here"
-        }
-      }
-    ]
-  })
-};
-var handler2 = async (provider, args) => {
-  const parsed = toolInfo2.parameters.safeParse(args);
-  if (!parsed.success) {
-    return {
-      type: "Invalid" /* Invalid */,
-      message: {
-        type: "error-text",
-        value: `Invalid arguments for attempt_completion: ${parsed.error.message}`
-      }
-    };
-  }
-  const { result } = parsed.data;
-  const moreMessage = await provider.attemptCompletion?.(result);
-  if (!moreMessage) {
-    return {
-      type: "Exit" /* Exit */,
-      message: result
-    };
-  }
-  return {
-    type: "Reply" /* Reply */,
-    message: {
-      type: "text",
-      value: `<user_message>${moreMessage}</user_message>`
-    }
-  };
-};
-var isAvailable2 = (_provider) => {
-  return true;
-};
-var attemptCompletion_default = {
   ...toolInfo2,
-  handler: handler2,
-  isAvailable: isAvailable2
-};
-
-// src/tools/delegate.ts
-import { z as z3 } from "zod";
-var toolInfo3 = {
-  name: "delegate",
-  description: "Temporarily delegate a task to another agent and receive the result back. This tool MUST NOT to be used with any other tool.",
-  parameters: z3.object({
-    agentName: z3.string().describe("The name of the agent to delegate the task to").meta({ usageValue: "Name of the target agent" }),
-    task: z3.string().describe("The task to be completed by the target agent").meta({ usageValue: "Task description" }),
-    context: z3.string().describe("The context information for the task").meta({ usageValue: "Context information" }),
-    files: z3.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);
-    }, z3.array(z3.string())).optional().describe("The files relevant to the task. Comma separated paths").meta({ usageValue: "Relevant files" })
-  }).meta({
-    examples: [
-      {
-        description: "Delegate a code analysis task to the analyzer agent",
-        input: {
-          agentName: "analyzer",
-          task: "Analyze the authentication implementation",
-          context: "Need to understand the security implications of the current auth system",
-          files: "src/auth/login.ts,src/auth/types.ts"
-        }
-      }
-    ]
-  })
-};
-var handler3 = async (_provider, args) => {
-  const parsed = toolInfo3.parameters.safeParse(args);
-  if (!parsed.success) {
-    return {
-      type: "Invalid" /* Invalid */,
-      message: {
-        type: "error-text",
-        value: `Invalid arguments for delegate: ${parsed.error.message}`
-      }
-    };
-  }
-  const { agentName, task, context, files } = parsed.data;
-  return {
-    type: "Delegate" /* Delegate */,
-    agentName,
-    task,
-    context,
-    files: files ?? []
-  };
-};
-var isAvailable3 = (_provider) => {
-  return true;
-};
-var delegate_default = {
-  ...toolInfo3,
-  handler: handler3,
-  isAvailable: isAvailable3
+  handler: handler2
 };
 
 // src/tools/executeCommand.ts
 import { z as z4 } from "zod";
-var toolInfo4 = {
-  name: "execute_command",
+var toolInfo3 = {
+  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: z4.object({
     command: z4.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" }),
@@ -256,7 +342,7 @@ var toolInfo4 = {
     ]
   })
 };
-var handler4 = async (provider, args) => {
+var handler3 = async (provider, args) => {
   if (!provider.executeCommand) {
     return {
       type: "Error" /* Error */,
@@ -266,7 +352,7 @@ var handler4 = async (provider, args) => {
       }
     };
   }
-  const { command, requiresApproval } = toolInfo4.parameters.parse(args);
+  const { command, requiresApproval } = toolInfo3.parameters.parse(args);
   try {
     const result = await provider.executeCommand(command, requiresApproval);
     let message = `<command>${command}</command>
@@ -312,19 +398,15 @@ ${result.stderr}
     };
   }
 };
-var isAvailable4 = (provider) => {
-  return !!provider.executeCommand;
-};
 var executeCommand_default = {
-  ...toolInfo4,
-  handler: handler4,
-  isAvailable: isAvailable4
+  ...toolInfo3,
+  handler: handler3
 };
 
 // src/tools/fetchUrl.ts
 import { z as z5 } from "zod";
-var toolInfo5 = {
-  name: "fetch_url",
+var toolInfo4 = {
+  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: z5.object({
     url: z5.preprocess((val) => {
@@ -355,7 +437,7 @@ var toolInfo5 = {
     ]
   })
 };
-var handler5 = async (provider, args) => {
+var handler4 = async (provider, args) => {
   if (!provider.fetchUrl) {
     return {
       type: "Error" /* Error */,
@@ -365,7 +447,7 @@ var handler5 = async (provider, args) => {
       }
     };
   }
-  const { url: urls } = toolInfo5.parameters.parse(args);
+  const { url: urls } = toolInfo4.parameters.parse(args);
   if (urls.length === 0) {
     return {
       type: "Error" /* Error */,
@@ -394,96 +476,35 @@ var handler5 = async (provider, args) => {
     }
   };
 };
-var isAvailable5 = (provider) => {
-  return typeof provider.fetchUrl === "function";
-};
 var fetchUrl_default = {
-  ...toolInfo5,
-  handler: handler5,
-  isAvailable: isAvailable5
+  ...toolInfo4,
+  handler: handler4
 };
 
-// src/tools/handOver.ts
+// src/tools/listFiles.ts
 import { z as z6 } from "zod";
-var toolInfo6 = {
-  name: "hand_over",
-  description: "Hand over the current task to another agent to complete. This tool MUST NOT to be used with any other tool.",
+var toolInfo5 = {
+  name: "listFiles",
+  description: "Request to list files and directories within the specified directory. If recursive is true, it will list all files and directories recursively. If recursive is false or not provided, it will only list the top-level contents. Do not use this tool to confirm the existence of files you may have created, as the user will let you know if the files were created successfully or not.",
   parameters: z6.object({
-    agentName: z6.string().describe("The name of the agent to hand over the task to").meta({ usageValue: "Name of the target agent" }),
-    task: z6.string().describe("The task to be completed by the target agent").meta({ usageValue: "Task description" }),
-    context: z6.string().describe("The context information for the task").meta({ usageValue: "Context information" }),
-    files: z6.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);
-    }, z6.array(z6.string())).optional().describe("The files relevant to the task. Comma separated paths").meta({ usageValue: "Relevant files" })
-  }).meta({
-    examples: [
-      {
-        description: "Hand over a coding task to the coder agent",
-        input: {
-          agentName: "coder",
-          task: "Implement the login feature",
-          context: "We need a secure login system with email and password",
-          files: "src/auth/login.ts,src/auth/types.ts"
-        }
-      }
-    ]
-  })
-};
-var handler6 = async (_provider, args) => {
-  const parsed = toolInfo6.parameters.safeParse(args);
-  if (!parsed.success) {
-    return {
-      type: "Invalid" /* Invalid */,
-      message: {
-        type: "error-text",
-        value: `Invalid arguments for hand_over: ${parsed.error.message}`
-      }
-    };
-  }
-  const { agentName, task, context, files } = parsed.data;
-  return {
-    type: "HandOver" /* HandOver */,
-    agentName,
-    task,
-    context,
-    files: files ?? []
-  };
-};
-var isAvailable6 = (_provider) => {
-  return true;
-};
-var handOver_default = {
-  ...toolInfo6,
-  handler: handler6,
-  isAvailable: isAvailable6
-};
-
-// src/tools/listFiles.ts
-import { z as z7 } from "zod";
-var toolInfo7 = {
-  name: "list_files",
-  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: z7.object({
-    path: z7.string().describe("The path of the directory to list contents for (relative to the current working directory)").meta({ usageValue: "Directory path here" }),
-    maxCount: z7.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: z7.preprocess((val) => {
+    path: z6.string().describe("The path of the directory to list contents for (relative to the current working directory)").meta({ usageValue: "Directory path here" }),
+    maxCount: z6.coerce.number().optional().default(2e3).describe("The maximum number of files to list. Default to 2000").meta({ usageValue: "Maximum number of files to list (optional)" }),
+    recursive: z6.preprocess((val) => {
       if (typeof val === "string") {
         const lower = val.toLowerCase();
         if (lower === "false") return false;
         if (lower === "true") return true;
       }
       return val;
-    }, z7.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: z7.preprocess((val) => {
+    }, z6.boolean().optional().default(true)).describe("Whether to list files recursively. Use true for recursive listing, false or omit for top-level only.").meta({ usageValue: "true or false (optional)" }),
+    includeIgnored: z6.preprocess((val) => {
       if (typeof val === "string") {
         const lower = val.toLowerCase();
         if (lower === "false") return false;
         if (lower === "true") return true;
       }
       return val;
-    }, z7.boolean().optional().default(false)).describe("Whether to include ignored files. Use true to include files ignored by .gitignore.").meta({ usageValue: "true or false (optional)" })
+    }, z6.boolean().optional().default(false)).describe("Whether to include ignored files. Use true to include files ignored by .gitignore.").meta({ usageValue: "true or false (optional)" })
   }).meta({
     examples: [
       {
@@ -496,7 +517,7 @@ var toolInfo7 = {
     ]
   })
 };
-var handler7 = async (provider, args) => {
+var handler5 = async (provider, args) => {
   if (!provider.listFiles) {
     return {
       type: "Error" /* Error */,
@@ -506,7 +527,7 @@ var handler7 = async (provider, args) => {
       }
     };
   }
-  const { path, maxCount, recursive, includeIgnored } = toolInfo7.parameters.parse(args);
+  const { path, maxCount, recursive, includeIgnored } = toolInfo5.parameters.parse(args);
   const [files, limitReached] = await provider.listFiles(path, recursive, maxCount, includeIgnored);
   return {
     type: "Reply" /* Reply */,
@@ -520,13 +541,35 @@ ${files.join("\n")}
     }
   };
 };
-var isAvailable7 = (provider) => {
-  return !!provider.listFiles;
-};
 var listFiles_default = {
-  ...toolInfo7,
-  handler: handler7,
-  isAvailable: isAvailable7
+  ...toolInfo5,
+  handler: handler5
+};
+
+// src/tools/listMemoryTopics.ts
+import { z as z7 } from "zod";
+var toolInfo6 = {
+  name: "listMemoryTopics",
+  description: "Lists all topics in memory.",
+  parameters: z7.object({})
+};
+var handler6 = async (provider, _args) => {
+  const topics = await provider.listMemoryTopics();
+  if (!topics.length) {
+    return { type: "Reply" /* Reply */, message: { type: "text", value: "No topics found." } };
+  }
+  return {
+    type: "Reply" /* Reply */,
+    message: {
+      type: "text",
+      value: `Memory topics:
+${topics.join("\n")}`
+    }
+  };
+};
+var listMemoryTopics_default = {
+  ...toolInfo6,
+  handler: handler6
 };
 
 // src/tools/provider.ts
@@ -555,21 +598,18 @@ var MockProvider = class {
   async askFollowupQuestion(_question, _options) {
     return "mock answer";
   }
-  async attemptCompletion(_result) {
-    return "mock completion";
-  }
 };
 
 // src/tools/readBinaryFile.ts
 import { z as z8 } from "zod";
-var toolInfo8 = {
-  name: "read_binary_file",
+var toolInfo7 = {
+  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: z8.object({
     url: z8.string().describe("The URL or local path of the file to read.")
   })
 };
-var handler8 = async (provider, args) => {
+var handler7 = async (provider, args) => {
   if (!provider.readBinaryFile) {
     return {
       type: "Error" /* Error */,
@@ -579,7 +619,7 @@ var handler8 = async (provider, args) => {
       }
     };
   }
-  const { url } = toolInfo8.parameters.parse(args);
+  const { url } = toolInfo7.parameters.parse(args);
   try {
     const filePart = await provider.readBinaryFile(url);
     return {
@@ -607,19 +647,15 @@ var handler8 = async (provider, args) => {
     };
   }
 };
-var isAvailable8 = (provider) => {
-  return typeof provider.readBinaryFile === "function";
-};
 var readBinaryFile_default = {
-  ...toolInfo8,
-  handler: handler8,
-  isAvailable: isAvailable8
+  ...toolInfo7,
+  handler: handler7
 };
 
 // src/tools/readFile.ts
 import { z as z9 } from "zod";
-var toolInfo9 = {
-  name: "read_file",
+var toolInfo8 = {
+  name: "readFile",
   description: "Request to read the contents of one or multiple files at the specified paths. Use comma separated paths to read multiple files. Use this when you need to examine the contents of an existing file you do not know the contents of, for example to analyze code, review text files, or extract information from configuration files. May not be suitable for other types of binary files, as it returns the raw content as a string. Try to list all the potential files are relevent to the task, and then use this tool to read all the relevant files.",
   parameters: z9.object({
     path: z9.preprocess((val) => {
@@ -652,7 +688,7 @@ var toolInfo9 = {
     ]
   })
 };
-var handler9 = async (provider, args) => {
+var handler8 = async (provider, args) => {
   if (!provider.readFile) {
     return {
       type: "Error" /* Error */,
@@ -662,7 +698,7 @@ var handler9 = async (provider, args) => {
       }
     };
   }
-  const { path: paths, includeIgnored } = toolInfo9.parameters.parse(args);
+  const { path: paths, includeIgnored } = toolInfo8.parameters.parse(args);
   const resp = [];
   for (const path of paths) {
     const fileContent = await provider.readFile(path, includeIgnored);
@@ -685,22 +721,54 @@ var handler9 = async (provider, args) => {
     }
   };
 };
-var isAvailable9 = (provider) => {
-  return !!provider.readFile;
-};
 var readFile_default = {
+  ...toolInfo8,
+  handler: handler8
+};
+
+// src/tools/readMemory.ts
+import { z as z10 } from "zod";
+var toolInfo9 = {
+  name: "readMemory",
+  description: "Reads content from a memory topic.",
+  parameters: z10.object({
+    topic: z10.string().optional().describe('The topic to read from memory. Defaults to ":default:".')
+  })
+};
+var handler9 = async (provider, args) => {
+  const { topic } = toolInfo9.parameters.parse(args);
+  const content = await provider.readMemory(topic);
+  if (content) {
+    return {
+      type: "Reply" /* Reply */,
+      message: {
+        type: "text",
+        value: `<memory${topic ? ` topic="${topic}"` : ""}>
+${content}
+</memory>`
+      }
+    };
+  }
+  return {
+    type: "Reply" /* Reply */,
+    message: {
+      type: "text",
+      value: `<memory ${topic ? `topic="${topic}"` : ""} isEmpty="true" />`
+    }
+  };
+};
+var readMemory_default = {
   ...toolInfo9,
-  handler: handler9,
-  isAvailable: isAvailable9
+  handler: handler9
 };
 
 // src/tools/removeFile.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var toolInfo10 = {
-  name: "remove_file",
+  name: "removeFile",
   description: "Request to remove a file at the specified path.",
-  parameters: z10.object({
-    path: z10.string().describe("The path of the file to remove").meta({ usageValue: "File path here" })
+  parameters: z11.object({
+    path: z11.string().describe("The path of the file to remove").meta({ usageValue: "File path here" })
   }).meta({
     examples: [
       {
@@ -725,10 +793,10 @@ var handler10 = async (provider, args) => {
   const parsed = toolInfo10.parameters.safeParse(args);
   if (!parsed.success) {
     return {
-      type: "Invalid" /* Invalid */,
+      type: "Error" /* Error */,
       message: {
         type: "error-text",
-        value: `Invalid arguments for remove_file: ${parsed.error.message}`
+        value: `Invalid arguments for removeFile: ${parsed.error.message}`
       }
     };
   }
@@ -742,23 +810,44 @@ var handler10 = async (provider, args) => {
     }
   };
 };
-var isAvailable10 = (provider) => {
-  return !!provider.removeFile;
-};
 var removeFile_default = {
   ...toolInfo10,
-  handler: handler10,
-  isAvailable: isAvailable10
+  handler: handler10
 };
 
-// src/tools/renameFile.ts
-import { z as z11 } from "zod";
+// src/tools/removeMemory.ts
+import { z as z12 } from "zod";
 var toolInfo11 = {
-  name: "rename_file",
+  name: "removeMemory",
+  description: "Removes a topic from memory.",
+  parameters: z12.object({
+    topic: z12.string().optional().describe('The topic to remove from memory. Defaults to ":default:".')
+  })
+};
+var handler11 = async (provider, args) => {
+  const { topic } = toolInfo11.parameters.parse(args);
+  await provider.removeMemory(topic);
+  return {
+    type: "Reply" /* Reply */,
+    message: {
+      type: "text",
+      value: `Memory topic '${topic || ""}' removed.`
+    }
+  };
+};
+var removeMemory_default = {
+  ...toolInfo11,
+  handler: handler11
+};
+
+// src/tools/renameFile.ts
+import { z as z13 } from "zod";
+var toolInfo12 = {
+  name: "renameFile",
   description: "Request to rename a file from source path to target path.",
-  parameters: z11.object({
-    source_path: z11.string().describe("The current path of the file").meta({ usageValue: "Source file path here" }),
-    target_path: z11.string().describe("The new path for the file").meta({ usageValue: "Target file path here" })
+  parameters: z13.object({
+    source_path: z13.string().describe("The current path of the file").meta({ usageValue: "Source file path here" }),
+    target_path: z13.string().describe("The new path for the file").meta({ usageValue: "Target file path here" })
   }).meta({
     examples: [
       {
@@ -771,7 +860,7 @@ var toolInfo11 = {
     ]
   })
 };
-var handler11 = async (provider, args) => {
+var handler12 = async (provider, args) => {
   if (!provider.renameFile) {
     return {
       type: "Error" /* Error */,
@@ -781,7 +870,7 @@ var handler11 = async (provider, args) => {
       }
     };
   }
-  const { source_path, target_path } = toolInfo11.parameters.parse(args);
+  const { source_path, target_path } = toolInfo12.parameters.parse(args);
   await provider.renameFile(source_path, target_path);
   return {
     type: "Reply" /* Reply */,
@@ -791,17 +880,13 @@ var handler11 = async (provider, args) => {
     }
   };
 };
-var isAvailable11 = (provider) => {
-  return !!provider.renameFile;
-};
 var renameFile_default = {
-  ...toolInfo11,
-  handler: handler11,
-  isAvailable: isAvailable11
+  ...toolInfo12,
+  handler: handler12
 };
 
 // src/tools/replaceInFile.ts
-import { z as z12 } from "zod";
+import { z as z14 } from "zod";
 
 // src/tools/utils/replaceInFile.ts
 var replaceInFile = (fileContent, diff) => {
@@ -878,12 +963,12 @@ var replaceInFile = (fileContent, diff) => {
 };
 
 // src/tools/replaceInFile.ts
-var toolInfo12 = {
-  name: "replace_in_file",
+var toolInfo13 = {
+  name: "replaceInFile",
   description: "Request to replace sections of content in an existing file using SEARCH/REPLACE blocks that define exact changes to specific parts of the file. This tool should be used when you need to make targeted changes to specific parts of a file.",
-  parameters: z12.object({
-    path: z12.string().describe("The path of the file to modify").meta({ usageValue: "File path here" }),
-    diff: z12.string().describe(
+  parameters: z14.object({
+    path: z14.string().describe("The path of the file to modify").meta({ usageValue: "File path here" }),
+    diff: z14.string().describe(
       `One or more SEARCH/REPLACE blocks following this exact format:
 \`\`\`
 <<<<<<< SEARCH
@@ -990,7 +1075,7 @@ function oldFeature() {
     ]
   })
 };
-var handler12 = async (provider, args) => {
+var handler13 = async (provider, args) => {
   if (!provider.readFile || !provider.writeFile) {
     return {
       type: "Error" /* Error */,
@@ -1000,13 +1085,13 @@ var handler12 = async (provider, args) => {
       }
     };
   }
-  const parsed = toolInfo12.parameters.safeParse(args);
+  const parsed = toolInfo13.parameters.safeParse(args);
   if (!parsed.success) {
     return {
-      type: "Invalid" /* Invalid */,
+      type: "Error" /* Error */,
       message: {
         type: "error-text",
-        value: `Invalid arguments for replace_in_file: ${parsed.error.message}`
+        value: `Invalid arguments for replaceInFile: ${parsed.error.message}`
       }
     };
   }
@@ -1055,36 +1140,58 @@ var handler12 = async (provider, args) => {
     };
   } catch (error) {
     return {
-      type: "Invalid" /* Invalid */,
+      type: "Error" /* Error */,
       message: {
         type: "error-text",
-        value: `Invalid arguments for replace_in_file: ${error}`
+        value: `Invalid arguments for replaceInFile: ${error}`
       }
     };
   }
 };
-var isAvailable12 = (provider) => {
-  return !!provider.readFile && !!provider.writeFile;
-};
 var replaceInFile_default = {
-  ...toolInfo12,
-  handler: handler12,
-  isAvailable: isAvailable12
+  ...toolInfo13,
+  handler: handler13
+};
+
+// src/tools/replaceMemory.ts
+import { z as z15 } from "zod";
+var toolInfo14 = {
+  name: "replaceMemory",
+  description: "Replaces content of a memory topic.",
+  parameters: z15.object({
+    topic: z15.string().optional().describe('The topic to replace in memory. Defaults to ":default:".'),
+    content: z15.string().describe("The new content.")
+  })
+};
+var handler14 = async (provider, args) => {
+  const { topic, content } = toolInfo14.parameters.parse(args);
+  await provider.replaceMemory(topic, content);
+  return {
+    type: "Reply" /* Reply */,
+    message: {
+      type: "text",
+      value: `Memory topic '${topic || ""}' replaced.`
+    }
+  };
+};
+var replaceMemory_default = {
+  ...toolInfo14,
+  handler: handler14
 };
 
 // src/tools/searchFiles.ts
-import { z as z13 } from "zod";
-var toolInfo13 = {
-  name: "search_files",
+import { z as z16 } from "zod";
+var toolInfo15 = {
+  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: z13.object({
-    path: z13.string().describe(
+  parameters: z16.object({
+    path: z16.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: z13.string().describe("The regular expression pattern to search for. Uses Rust regex syntax.").meta({
+    regex: z16.string().describe("The regular expression pattern to search for. Uses Rust regex syntax.").meta({
       usageValue: "Your regex pattern here"
     }),
-    filePattern: z13.string().optional().describe(
+    filePattern: z16.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)"
@@ -1102,7 +1209,7 @@ var toolInfo13 = {
     ]
   })
 };
-var handler13 = async (provider, args) => {
+var handler15 = async (provider, args) => {
   if (!provider.searchFiles) {
     return {
       type: "Error" /* Error */,
@@ -1112,13 +1219,13 @@ var handler13 = async (provider, args) => {
       }
     };
   }
-  const parsed = toolInfo13.parameters.safeParse(args);
+  const parsed = toolInfo15.parameters.safeParse(args);
   if (!parsed.success) {
     return {
-      type: "Invalid" /* Invalid */,
+      type: "Error" /* Error */,
       message: {
         type: "error-text",
-        value: `Invalid arguments for search_files: ${parsed.error.message}`
+        value: `Invalid arguments for searchFiles: ${parsed.error.message}`
       }
     };
   }
@@ -1148,23 +1255,19 @@ ${files.join("\n")}
     };
   }
 };
-var isAvailable13 = (provider) => {
-  return !!provider.searchFiles;
-};
 var searchFiles_default = {
-  ...toolInfo13,
-  handler: handler13,
-  isAvailable: isAvailable13
+  ...toolInfo15,
+  handler: handler15
 };
 
 // src/tools/writeToFile.ts
-import { z as z14 } from "zod";
-var toolInfo14 = {
-  name: "write_to_file",
+import { z as z17 } from "zod";
+var toolInfo16 = {
+  name: "writeToFile",
   description: "Request to write content to a file at the specified path. If the file exists, it will be overwritten with the provided content. If the file doesn't exist, it will be created. This tool will automatically create any directories needed to write the file. Ensure that the output content does not include incorrect escaped character patterns such as `&lt;`, `&gt;`, or `&amp;`. Also ensure there is no unwanted CDATA tags in the content.",
-  parameters: z14.object({
-    path: z14.string().describe("The path of the file to write to").meta({ usageValue: "File path here" }),
-    content: z14.string().describe(
+  parameters: z17.object({
+    path: z17.string().describe("The path of the file to write to").meta({ usageValue: "File path here" }),
+    content: z17.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({
@@ -1190,7 +1293,7 @@ export default App;
     ]
   })
 };
-var handler14 = async (provider, args) => {
+var handler16 = async (provider, args) => {
   if (!provider.writeFile) {
     return {
       type: "Error" /* Error */,
@@ -1200,13 +1303,13 @@ var handler14 = async (provider, args) => {
       }
     };
   }
-  const parsed = toolInfo14.parameters.safeParse(args);
+  const parsed = toolInfo16.parameters.safeParse(args);
   if (!parsed.success) {
     return {
-      type: "Invalid" /* Invalid */,
+      type: "Error" /* Error */,
       message: {
         type: "error-text",
-        value: `Invalid arguments for write_to_file: ${parsed.error.message}`
+        value: `Invalid arguments for writeToFile: ${parsed.error.message}`
       }
     };
   }
@@ -1222,35 +1325,9 @@ var handler14 = async (provider, args) => {
     }
   };
 };
-var isAvailable14 = (provider) => {
-  return !!provider.writeFile;
-};
 var writeToFile_default = {
-  ...toolInfo14,
-  handler: handler14,
-  isAvailable: isAvailable14
-};
-
-// src/getAvailableTools.ts
-var getAvailableTools = ({
-  provider,
-  allTools,
-  hasAgent
-}) => {
-  const tools = [];
-  for (const tool of allTools) {
-    if (!hasAgent) {
-      switch (tool.name) {
-        case handOver_default.name:
-        case delegate_default.name:
-          continue;
-      }
-    }
-    if (tool.isAvailable(provider)) {
-      tools.push(tool);
-    }
-  }
-  return tools;
+  ...toolInfo16,
+  handler: handler16
 };
 
 // src/UsageMeter.ts
@@ -1400,2036 +1477,29 @@ var UsageMeter = class {
     };
   }
 };
-
-// src/Agent/AgentBase.ts
-import { jsonSchema, streamText } from "ai";
-import { camelCase } from "lodash-es";
-import { toJSONSchema } from "zod";
-
-// src/tool-v1-compat.ts
-import { z as z15 } from "zod";
-function zodSchemaToParameters(schema) {
-  const parameters = [];
-  const { shape } = schema;
-  for (const name in shape) {
-    const def = shape[name];
-    const isOptional = def.safeParse(void 0).success;
-    const description = def.description || "";
-    const param = {
-      name,
-      description,
-      required: !isOptional
-    };
-    const usageValue = def.meta()?.usageValue;
-    if (usageValue) {
-      param.usageValue = usageValue;
-    }
-    if (def instanceof z15.ZodObject) {
-      param.children = zodSchemaToParameters(def);
-    } else if (def instanceof z15.ZodArray) {
-      param.allowMultiple = true;
-      const element = def.element;
-      if (element instanceof z15.ZodObject) {
-        param.children = zodSchemaToParameters(element);
-      }
-    }
-    parameters.push(param);
-  }
-  return parameters;
-}
-function toToolInfoV1(tool) {
-  const { parameters: zodSchema, ...rest } = tool;
-  const v1Parameters = zodSchemaToParameters(zodSchema);
-  const examples = zodSchema.meta()?.examples;
-  const v1Tool = {
-    ...rest,
-    parameters: v1Parameters
-  };
-  if (examples) {
-    v1Tool.examples = examples;
-  }
-  return v1Tool;
-}
-
-// 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/Agent/parseAssistantMessage.ts
-function parseNestedParameters(content, parameterPrefix, childrenParams) {
-  const result = {};
-  const nestedParamRegex = new RegExp(`<${parameterPrefix}([^>]+)>([\\s\\S]*?)<\\/${parameterPrefix}\\1>`, "gs");
-  const arrayParams = /* @__PURE__ */ new Set();
-  if (childrenParams) {
-    for (const param of childrenParams) {
-      if (param.allowMultiple) {
-        arrayParams.add(param.name);
-      }
-    }
-  }
-  while (true) {
-    const match = nestedParamRegex.exec(content);
-    if (match === null) break;
-    const paramName = match[1];
-    const paramContent = match[2].trim();
-    const childParam = childrenParams?.find((p) => p.name === paramName);
-    if (paramContent.includes(`<${parameterPrefix}`) && childParam?.children) {
-      const nestedResult = parseNestedParameters(paramContent, parameterPrefix, childParam.children);
-      if (arrayParams.has(paramName)) {
-        if (!result[paramName]) {
-          result[paramName] = [];
-        }
-        if (Array.isArray(result[paramName])) {
-          result[paramName].push(nestedResult);
-        } else {
-          result[paramName] = [nestedResult];
-        }
-      } else {
-        result[paramName] = nestedResult;
-      }
-    } else if (arrayParams.has(paramName)) {
-      if (!result[paramName]) {
-        result[paramName] = [];
-      }
-      if (Array.isArray(result[paramName])) {
-        result[paramName].push(paramContent);
-      } else {
-        result[paramName] = [paramContent];
-      }
-    } else {
-      result[paramName] = paramContent;
-    }
-  }
-  return result;
-}
-function parseAssistantMessage(assistantMessage, tools, toolNamePrefix) {
-  const parameterPrefix = `${toolNamePrefix}parameter_`;
-  const results = [];
-  const toolTags = tools.map((tool) => `${toolNamePrefix}${tool.name}`);
-  const toolPattern = toolTags.join("|");
-  let remainingMessage = assistantMessage;
-  let match;
-  const tagRegex = new RegExp(`<(${toolPattern})>([\\s\\S]*?)<\\/\\1>`, "s");
-  while (true) {
-    match = tagRegex.exec(remainingMessage);
-    if (match === null) break;
-    const beforeTag = remainingMessage.slice(0, match.index).trim();
-    if (beforeTag) {
-      results.push({
-        type: "text",
-        content: beforeTag
-      });
-    }
-    const tagName = match[1];
-    const toolName = tagName.replace(toolNamePrefix, "");
-    const tool = tools.find((t) => t.name === toolName);
-    const fullTagContent = match[0];
-    if (tool) {
-      const params = {};
-      for (const param of tool.parameters) {
-        const paramName = `${parameterPrefix}${param.name}`;
-        const escapedParamName = paramName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-        const paramRegex = new RegExp(`<${escapedParamName}>([\\s\\S]*?)<\\/${escapedParamName}>`, "gs");
-        const paramMatches = [];
-        while (true) {
-          const paramMatch = paramRegex.exec(fullTagContent);
-          if (paramMatch === null) break;
-          paramMatches.push(paramMatch[1].trim());
-        }
-        if (paramMatches.length > 0) {
-          if (paramMatches.length === 1 && !param.allowMultiple) {
-            const paramContent = paramMatches[0];
-            if (paramContent.includes(`<${parameterPrefix}`) && param.children) {
-              params[param.name] = parseNestedParameters(paramContent, parameterPrefix, param.children);
-            } else {
-              params[param.name] = paramContent;
-            }
-          } else {
-            if (param.allowMultiple) {
-              params[param.name] = paramMatches.map((paramContent) => {
-                if (paramContent.includes(`<${parameterPrefix}`) && param.children) {
-                  return parseNestedParameters(paramContent, parameterPrefix, param.children);
-                }
-                return paramContent;
-              });
-            } else {
-              const paramContent = paramMatches[0];
-              if (paramContent.includes(`<${parameterPrefix}`) && param.children) {
-                params[param.name] = parseNestedParameters(paramContent, parameterPrefix, param.children);
-              } else {
-                params[param.name] = paramContent;
-              }
-            }
-          }
-        }
-      }
-      results.push({
-        type: "tool_use",
-        name: toolName,
-        params
-      });
-    } else {
-      results.push({
-        type: "text",
-        content: fullTagContent
-      });
-    }
-    remainingMessage = remainingMessage.slice(match.index + fullTagContent.length);
-  }
-  if (remainingMessage.trim()) {
-    results.push({
-      type: "text",
-      content: remainingMessage.trim()
-    });
-  }
-  if (results.length === 0) {
-    results.push({
-      type: "text",
-      content: assistantMessage
-    });
-  }
-  return results;
-}
-
-// src/Agent/prompts.ts
-var renderParameterValue = (key, value, parameterPrefix) => {
-  if (typeof value === "string") {
-    return `<${parameterPrefix}${key}>${value}</${parameterPrefix}${key}>`;
-  }
-  if (Array.isArray(value)) {
-    return value.map((v) => renderParameterValue(key, v, parameterPrefix)).join("\n");
-  }
-  const inner = Object.entries(value).map(([key2, v]) => renderParameterValue(key2, v, parameterPrefix)).join("\n");
-  return `<${parameterPrefix}${key}>
-${inner}
-</${parameterPrefix}${key}>`;
-};
-var toolInfoPrompt = (tool, toolNamePrefix, parameterPrefix) => `
-## ${toolNamePrefix}${tool.name}
-
-Description: ${tool.description}
-
-Parameters:
-${tool.parameters.map(
-  (param) => `- ${parameterPrefix}${param.name}: (${param.required ? "required" : "optional"})${param.allowMultiple ? " (multiple allowed)" : ""} ${param.description}`
-).join("\n")}
-
-Usage:
-<${toolNamePrefix}${tool.name}>
-${tool.parameters.map(
-  (param) => param.allowMultiple ? `<${parameterPrefix}${param.name}>${param.usageValue}</${parameterPrefix}${param.name}>
-<${parameterPrefix}${param.name}>${param.usageValue}</${parameterPrefix}${param.name}>` : `<${parameterPrefix}${param.name}>${param.usageValue}</${parameterPrefix}${param.name}>`
-).join("\n")}
-</${toolNamePrefix}${tool.name}>`;
-var toolInfoExamplesPrompt = (tool, example, toolNamePrefix, parameterPrefix) => `
-## Example: ${example.description}
-
-<${toolNamePrefix}${tool.name}>
-${Object.entries(example.input).map(([name, value]) => renderParameterValue(name, value, parameterPrefix)).join("\n")}
-</${toolNamePrefix}${tool.name}>
-`;
-var toolUsePrompt = (useNativeTool, tools, toolNamePrefix) => {
-  if (useNativeTool) {
-    return `
-====
-
-TOOL USE
-
-- You MUST use a tool.
-- Batch tool use when feasible; avoid redundant calls.
-`;
-  }
-  if (tools.length === 0) {
-    return "";
-  }
-  const parameterPrefix = `${toolNamePrefix}parameter_`;
-  const v1Tools = tools.map(toToolInfoV1);
-  return `
-====
-
-TOOL USE
-
-You have access to a set of tools that are executed upon the user's approval. You can use up to 5 tool calls per message, and will receive the results of those tool uses in the user's response. You use tools step-by-step to accomplish a given task, with each tool use informed by the result of the previous tool use.
-
-# Tool Use Formatting
-
-Tool use is formatted using XML-style tags. The tool name is enclosed in opening and closing tags, and each parameter is similarly enclosed within its own set of tags. Here's the structure:
-
-<${toolNamePrefix}tool_name>
-<${parameterPrefix}name1>value1</${parameterPrefix}name1>
-<${parameterPrefix}name2>value2</${parameterPrefix}name2>
-...
-</${toolNamePrefix}tool_name>
-
-**It is crucial that all tags are correctly nested and closed.**
-
-## Array Parameters
-
-To create an array of values for a parameter, repeat the parameter tag multiple times:
-
-<${toolNamePrefix}process_file>
-<${parameterPrefix}path>test.ts</${parameterPrefix}path>
-<${parameterPrefix}path>main.ts</${parameterPrefix}path>
-</${toolNamePrefix}process_file>
-
-## Nested Object Parameters
-
-To create nested objects, nest parameter tags within other parameter tags:
-
-<${toolNamePrefix}example_tool>
-<${parameterPrefix}key>
-<${parameterPrefix}key2>value</${parameterPrefix}key2>
-<${parameterPrefix}key3>value2</${parameterPrefix}key3>
-</${parameterPrefix}key>
-</${toolNamePrefix}example_tool>
-
-You can also combine array parameters with nested objects:
-
-<${toolNamePrefix}example_tool>
-<${parameterPrefix}key>
-<${parameterPrefix}key2>value</${parameterPrefix}key2>
-<${parameterPrefix}key3>value2</${parameterPrefix}key3>
-</${parameterPrefix}key>
-<${parameterPrefix}key>
-<${parameterPrefix}key2>value3</${parameterPrefix}key2>
-<${parameterPrefix}key3>value4</${parameterPrefix}key3>
-<${parameterPrefix}key3>value5</${parameterPrefix}key3>
-</${parameterPrefix}key>
-</${toolNamePrefix}example_tool>
-
-Always adhere to this format, ensuring every opening tag has a matching closing tag, to ensure proper parsing and execution.
-
-NEVER surround tool use with triple backticks (\`\`\`).
-
-# Tools
-${v1Tools.map((tool) => toolInfoPrompt(tool, toolNamePrefix, parameterPrefix)).join("\n")}
-
-# Tool Use Examples
-${v1Tools.map((tool) => {
-    let promp = "";
-    for (const example of tool.examples ?? []) {
-      promp += toolInfoExamplesPrompt(tool, example, toolNamePrefix, parameterPrefix);
-    }
-    return promp;
-  }).join("")}
-# Tool Use Guidelines
-
-1. **Wait for Feedback**
-  - After using a tool, wait for the user's response indicating success/failure or any output logs. Do not assume the result of a tool without explicit confirmation.
-2. **Error Handling**
-  - If a tool fails or produces an unexpected result, analyze the error, decide on an alternative approach or tool, and proceed carefully.
-3. **Avoid Repetition**
-  - Do not quote or repeat previous commands or prompts verbatim. Move the conversation forward by focusing on the latest required action.
-4. **Tool Call Limit**
-  - It is **STRIGHTLY FORBIDDEN** to make more than 5 tool calls in a single message.`;
-};
-var agentsPrompt = (agents, name) => `
-====
-
-AVAILABLE AGENTS
-
-The following agents are available for task handover/delegate:
-${agents.map(
-  (agent) => `
-- **${agent.name}**
-  - Responsibilities:
-${agent.responsibilities.map((resp) => `    - ${resp}`).join("\n")}`
-).join("\n")}
-
-- **Current Agent Role**
-  You are currently acting as **${name}**. If you identify the task is beyond your current scope, use the handover or delegate tool to transition to the other agent. Include sufficient context so the new agent can seamlessly continue the work.
-`;
-var capabilities = (_toolNamePrefix) => `
-====
-
-CAPABILITIES
-
-- You have access to a range of tools to aid you in your work. These tools help you effectively accomplish a wide range of tasks.
-- When the user initially gives you a task, a recursive list of all filepaths in the current working directory will be included in context. This provides an overview of the project's file structure, offering key insights into the project from directory/file names (how developers conceptualize and organize their code) and file extensions (the language used). This can also guide decision-making on which files to explore further.`;
-var systemInformation = (info) => `
-====
-
-SYSTEM INFORMATION
-
-Operating System: ${info.os}`;
-var customInstructions = (customInstructions2) => {
-  const joined = customInstructions2.join("\n");
-  if (joined.trim() === "") {
-    return "";
-  }
-  return `
-====
-
-USER'S CUSTOM INSTRUCTIONS
-
-The following additional instructions are provided by the user, and should be followed to the best of your ability without interfering with the TOOL USE guidelines.
-
-${joined}`;
-};
-var customScripts = (commands) => {
-  const joined = Object.entries(commands).map(([name, command]) => {
-    if (typeof command === "string") {
-      return `- ${name}
-  - Command: \`${command}\``;
-    }
-    return `- ${name}
-  - Command: \`${command.command}\`
-  - Description: ${command.description}`;
-  }).join("\n");
-  if (joined.trim() === "") {
-    return "";
-  }
-  return `
-====
-
-USER'S CUSTOM COMMANDS
-
-The following additional commands are provided by the user, and should be followed to the best of your ability without interfering with the TOOL USE guidelines.
-
-${joined}`;
-};
-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 (part.mediaType.startsWith("image/")) {
-              return {
-                type: "image",
-                mediaType: part.mediaType,
-                image: part.data
-              };
-            }
-            return {
-              type: "file",
-              mediaType: part.mediaType,
-              data: part.data
-            };
-          }),
-          {
-            type: "text",
-            text: "</tool_response>"
-          }
-        ];
-    }
-  },
-  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/AgentBase.ts
-var TaskEventKind = /* @__PURE__ */ ((TaskEventKind2) => {
-  TaskEventKind2["StartTask"] = "StartTask";
-  TaskEventKind2["StartRequest"] = "StartRequest";
-  TaskEventKind2["EndRequest"] = "EndRequest";
-  TaskEventKind2["Usage"] = "Usage";
-  TaskEventKind2["Text"] = "Text";
-  TaskEventKind2["Reasoning"] = "Reasoning";
-  TaskEventKind2["ToolUse"] = "ToolUse";
-  TaskEventKind2["ToolReply"] = "ToolReply";
-  TaskEventKind2["ToolInvalid"] = "ToolInvalid";
-  TaskEventKind2["ToolError"] = "ToolError";
-  TaskEventKind2["ToolInterrupted"] = "ToolInterrupted";
-  TaskEventKind2["ToolHandOver"] = "ToolHandOver";
-  TaskEventKind2["ToolDelegate"] = "ToolDelegate";
-  TaskEventKind2["ToolPause"] = "ToolPause";
-  TaskEventKind2["UsageExceeded"] = "UsageExceeded";
-  TaskEventKind2["EndTask"] = "EndTask";
-  return TaskEventKind2;
-})(TaskEventKind || {});
-var AgentBase = class {
-  ai;
-  config;
-  handlers;
-  #policies;
-  #toolSet;
-  #messages = [];
-  #aborted = false;
-  #abortController;
-  constructor(name, ai, config) {
-    this.ai = ai;
-    if (config.agents && config.agents.length > 0) {
-      const agents = agentsPrompt(config.agents, name);
-      config.systemPrompt += `
-${agents}`;
-    }
-    const handlers = {};
-    for (const tool of config.tools) {
-      handlers[tool.name] = tool;
-    }
-    const policies = [];
-    for (const policy of config.policies) {
-      const instance = policy(handlers, config.parameters);
-      if (instance) {
-        policies.push(instance);
-        if (instance.prompt) {
-          config.systemPrompt += `
-${instance.prompt}`;
-        }
-        if (instance.tools) {
-          for (const tool of instance.tools) {
-            handlers[tool.name] = tool;
-          }
-        }
-      }
-    }
-    this.handlers = handlers;
-    this.config = config;
-    this.#policies = policies;
-    this.#messages.push({
-      role: "system",
-      content: this.config.systemPrompt
-    });
-    if (this.config.toolFormat === "native") {
-      const tools = {};
-      for (const tool of Object.values(this.handlers)) {
-        const toolName = camelCase(tool.name);
-        tools[toolName] = {
-          description: tool.description,
-          inputSchema: jsonSchema(toJSONSchema(tool.parameters))
-        };
-        this.handlers[toolName] = tool;
-      }
-      this.#toolSet = tools;
-    } else {
-      this.#toolSet = {};
-    }
-  }
-  abort() {
-    this.#aborted = true;
-    if (this.#abortController) {
-      this.#abortController.abort();
-    }
-  }
-  get parameters() {
-    return this.config.parameters;
-  }
-  get messages() {
-    return this.#messages;
-  }
-  setMessages(messages) {
-    this.#messages = [...messages];
-  }
-  async #callback(event) {
-    await this.config.callback?.(event);
-  }
-  async start(prompt) {
-    this.#callback({ kind: "StartTask" /* StartTask */, systemPrompt: this.config.systemPrompt });
-    return await this.#processLoop(prompt);
-  }
-  async step(message) {
-    if (this.#messages.length === 0) {
-      this.#callback({ kind: "StartTask" /* StartTask */, systemPrompt: this.config.systemPrompt });
-    }
-    return await this.#request(message);
-  }
-  async handleStepResponse(response) {
-    return this.#handleResponse(response);
-  }
-  async #processLoop(userMessage) {
-    let nextRequest = [
-      {
-        role: "user",
-        content: userMessage
-      }
-    ];
-    while (true) {
-      if (this.#aborted) {
-        return { type: "Aborted" };
-      }
-      if (this.config.usageMeter.isLimitExceeded().result) {
-        this.#callback({ kind: "UsageExceeded" /* UsageExceeded */ });
-        return { type: "UsageExceeded" };
-      }
-      const response = await this.#request(nextRequest);
-      if (this.#aborted) {
-        return { type: "Aborted" };
-      }
-      const resp = await this.#handleResponse(response);
-      if (resp.type === "exit") {
-        this.#callback({ kind: "EndTask" /* EndTask */, exitReason: resp.reason });
-        return resp.reason;
-      }
-      nextRequest = resp.message;
-    }
-  }
-  async continueTask(userMessage) {
-    return await this.#processLoop(userMessage);
-  }
-  async #request(userMessage) {
-    if (!userMessage) {
-      throw new Error("userMessage is missing");
-    }
-    await this.#callback({ kind: "StartRequest" /* StartRequest */, userMessage });
-    this.#messages.push(...userMessage);
-    for (const instance of this.#policies) {
-      if (instance.onBeforeRequest) {
-        await instance.onBeforeRequest(this);
-      }
-    }
-    let messages = this.#messages;
-    for (const instance of this.#policies) {
-      if (instance.prepareMessages) {
-        messages = await instance.prepareMessages(this, messages);
-      }
-    }
-    const retryCount = this.config.retryCount ?? 5;
-    const requestTimeoutSeconds = this.config.requestTimeoutSeconds ?? 90;
-    let respMessages = [];
-    let rateLimitErrorCount = 0;
-    for (let i = 0; i < retryCount; i++) {
-      if (this.#aborted) {
-        break;
-      }
-      respMessages = [];
-      let timeout;
-      let requestAbortController;
-      requestAbortController = new AbortController();
-      this.#abortController = requestAbortController;
-      const resetTimeout = () => {
-        if (timeout) {
-          clearTimeout(timeout);
-        }
-        if (requestTimeoutSeconds > 0 && requestAbortController) {
-          timeout = setTimeout(() => {
-            console.error(
-              `
-Request timeout after ${requestTimeoutSeconds} seconds. Canceling current request attempt ${i + 1}/${retryCount}.`
-            );
-            requestAbortController?.abort();
-          }, requestTimeoutSeconds * 1e3);
-        }
-      };
-      try {
-        resetTimeout();
-        const usageMeterOnFinishHandler = this.config.usageMeter.onFinishHandler(this.ai);
-        const streamTextOptions = {
-          model: this.ai,
-          temperature: 0,
-          messages,
-          providerOptions: this.config.parameters?.providerOptions,
-          onChunk: async ({ chunk }) => {
-            resetTimeout();
-            switch (chunk.type) {
-              case "text-delta":
-                await this.#callback({ kind: "Text" /* Text */, newText: chunk.text });
-                break;
-              case "reasoning-delta":
-                await this.#callback({ kind: "Reasoning" /* Reasoning */, newText: chunk.text });
-                break;
-              case "tool-call":
-                break;
-            }
-          },
-          onFinish: (evt) => {
-            usageMeterOnFinishHandler(evt);
-            this.#callback({ kind: "Usage" /* Usage */, usage: evt.totalUsage });
-          },
-          onError: async (error) => {
-            console.error("Error in stream:", error);
-          },
-          abortSignal: requestAbortController.signal
-        };
-        if (this.config.toolFormat === "native") {
-          streamTextOptions.tools = this.#toolSet;
-        }
-        const stream = streamText(streamTextOptions);
-        await stream.consumeStream({
-          onError: (error) => {
-            console.error("Error in stream:", error);
-          }
-        });
-        const resp = await stream.response;
-        respMessages = resp.messages;
-        rateLimitErrorCount = 0;
-        if (timeout) {
-          clearTimeout(timeout);
-          timeout = void 0;
-        }
-      } catch (error) {
-        if (error instanceof Error && error.name === "AbortError") {
-          if (this.#aborted) {
-            break;
-          }
-          console.error(`Request attempt ${i + 1} timed out, will retry`);
-        } else if (error?.error?.error?.code === "rate_limit_exceeded" || error?.error?.code === "rate_limit_exceeded" || error?.code === "rate_limit_exceeded" || error?.status === 429 || error?.error?.status === 429) {
-          rateLimitErrorCount++;
-          const waitSeconds = computeRateLimitBackoffSeconds(rateLimitErrorCount);
-          console.error(`Rate limit exceeded. Waiting ${waitSeconds}s before retrying...`);
-          if (timeout) {
-            clearTimeout(timeout);
-            timeout = void 0;
-          }
-          await new Promise((resolve) => setTimeout(resolve, waitSeconds * 1e3));
-          console.error("Retrying request...");
-        } else {
-          rateLimitErrorCount = 0;
-          console.error("Error in stream:", error);
-        }
-      } finally {
-        if (timeout) {
-          clearTimeout(timeout);
-        }
-      }
-      if (this.config.toolFormat === "native") {
-        if (respMessages.some((m) => {
-          if (m.role === "tool") {
-            return true;
-          }
-          if (typeof m.content === "string") {
-            return true;
-          }
-          return m.content.some((part) => part.type === "tool-call" || part.type === "tool-result" || part.type === "text");
-        })) {
-          break;
-        }
-      } else {
-        if (respMessages.length > 0) {
-          break;
-        }
-      }
-      if (this.#aborted) {
-        break;
-      }
-      if (i < retryCount - 1) {
-        console.error(`
-Retrying request ${i + 2} of ${retryCount}`);
-      }
-    }
-    if (respMessages.length === 0) {
-      if (this.#aborted) {
-        return [];
-      }
-      throw new Error("No assistant message received after all retry attempts");
-    }
-    this.#messages.push(...respMessages);
-    if (this.config.toolFormat === "native") {
-      const assistantText = respMessages.map((msg) => {
-        if (typeof msg.content === "string") {
-          return msg.content;
-        }
-        return msg.content.map((part) => part.type === "text" || part.type === "reasoning" ? part.text : "").join("");
-      }).join("\n");
-      await this.#callback({ kind: "EndRequest" /* EndRequest */, message: assistantText });
-      return respMessages.flatMap((msg) => {
-        if (msg.role === "assistant") {
-          const content = msg.content;
-          if (typeof content === "string") {
-            return [{ type: "text", content }];
-          }
-          return content.flatMap((part) => {
-            if (part.type === "text" || part.type === "reasoning") {
-              return [{ type: "text", content: part.text }];
-            }
-            if (part.type === "tool-call") {
-              return [{ type: "tool_use", id: part.toolCallId, name: part.toolName, params: part.input }];
-            }
-            return [];
-          });
-        }
-        return [];
-      });
-    }
-    const currentAssistantMessage = respMessages.map((msg) => {
-      if (typeof msg.content === "string") {
-        return msg.content;
-      }
-      return msg.content.map((part) => {
-        if (part.type === "text") {
-          return part.text;
-        }
-        return "";
-      });
-    }).join("\n");
-    const ret = parseAssistantMessage(currentAssistantMessage, this.config.tools.map(toToolInfoV1), this.config.toolNamePrefix);
-    await this.#callback({ kind: "EndRequest" /* EndRequest */, message: currentAssistantMessage });
-    return ret;
-  }
-  async #handleResponse(response) {
-    const toolResponses = [];
-    const medias = [];
-    const processResponse = (resp) => {
-      if (resp.type === "content") {
-        return {
-          type: "content",
-          value: resp.value.map((part) => {
-            if (part.type === "media") {
-              medias.push(part);
-              return {
-                type: "text",
-                text: `<media url="${part.url}" media-type="${part.mediaType}" />`
-              };
-            }
-            return part;
-          })
-        };
-      }
-      return resp;
-    };
-    let hasPause = false;
-    const toolUseContents = response.filter((c) => c.type === "tool_use");
-    outer: for (const content of response) {
-      switch (content.type) {
-        case "text":
-          break;
-        case "tool_use": {
-          await this.#callback({ kind: "ToolUse" /* ToolUse */, tool: content.name, params: content.params });
-          const toolResp = await this.#invokeTool(content.name, content.params);
-          switch (toolResp.type) {
-            case "Reply" /* Reply */: {
-              await this.#callback({ kind: "ToolReply" /* ToolReply */, tool: content.name, content: toolResp.message });
-              toolResponses.push({ type: "response", tool: content.name, response: processResponse(toolResp.message), id: content.id });
-              break;
-            }
-            case "Exit" /* Exit */:
-            case "HandOver" /* HandOver */:
-            case "Delegate" /* Delegate */: {
-              if (this.config.toolFormat === "native" && toolUseContents.length > 1) {
-                const message = {
-                  type: "Error" /* Error */,
-                  message: {
-                    type: "error-text",
-                    value: `Error: The tool '${content.name}' must be called alone, but it was called with other tools.`
-                  },
-                  canRetry: false
-                };
-                await this.#callback({ kind: "ToolError" /* ToolError */, tool: content.name, error: message });
-                toolResponses.push({
-                  type: "response",
-                  tool: content.name,
-                  response: processResponse(message.message),
-                  id: content.id
-                });
-                break;
-              }
-              if (toolResponses.length > 0) {
-                break outer;
-              }
-              if (toolResp.type === "Exit" /* Exit */) {
-                return { type: "exit", reason: toolResp };
-              }
-              if (toolResp.type === "HandOver" /* HandOver */) {
-                await this.#callback({
-                  kind: "ToolHandOver" /* ToolHandOver */,
-                  tool: content.name,
-                  agentName: toolResp.agentName,
-                  task: toolResp.task,
-                  context: toolResp.context,
-                  files: toolResp.files
-                });
-                return { type: "exit", reason: toolResp };
-              }
-              if (toolResp.type === "Delegate" /* Delegate */) {
-                await this.#callback({
-                  kind: "ToolDelegate" /* ToolDelegate */,
-                  tool: content.name,
-                  agentName: toolResp.agentName,
-                  task: toolResp.task,
-                  context: toolResp.context,
-                  files: toolResp.files
-                });
-                return { type: "exit", reason: toolResp };
-              }
-              break;
-            }
-            case "Invalid" /* Invalid */: {
-              await this.#callback({ kind: "ToolInvalid" /* ToolInvalid */, tool: content.name, content: toolResp.message });
-              toolResponses.push({ type: "response", tool: content.name, response: processResponse(toolResp.message), id: content.id });
-              if (this.config.toolFormat !== "native") {
-                break outer;
-              }
-              break;
-            }
-            case "Error" /* Error */: {
-              await this.#callback({ kind: "ToolError" /* ToolError */, tool: content.name, error: toolResp.message });
-              toolResponses.push({ type: "response", tool: content.name, response: processResponse(toolResp.message), id: content.id });
-              if (this.config.toolFormat !== "native") {
-                break outer;
-              }
-              break;
-            }
-            case "Pause" /* Pause */: {
-              await this.#callback({ kind: "ToolPause" /* ToolPause */, tool: content.name, object: toolResp.object });
-              toolResponses.push({ type: "pause", tool: content.name, object: toolResp.object, id: content.id });
-              hasPause = true;
-            }
-          }
-          break;
-        }
-      }
-    }
-    if (hasPause) {
-      return { type: "exit", reason: { type: "Pause", responses: toolResponses } };
-    }
-    if (toolResponses.length === 0) {
-      if (this.config.requireToolUse) {
-        return {
-          type: "reply",
-          message: [
-            {
-              role: "user",
-              content: responsePrompts.requireUseToolNative
-            }
-          ]
-        };
-      }
-      return {
-        type: "exit",
-        reason: {
-          type: "Exit" /* Exit */,
-          message: response.filter((c) => c.type === "text").map((c) => c.content).join("")
-        }
-      };
-    }
-    const mediaUserMessage = medias.length > 0 ? [
-      {
-        role: "user",
-        content: medias.map((m) => {
-          if (m.mediaType.startsWith("image/")) {
-            return {
-              type: "image",
-              image: m.base64Data,
-              mediaType: m.mediaType
-            };
-          }
-          return {
-            type: "file",
-            data: m.base64Data,
-            mediaType: m.mediaType,
-            filename: m.url.split("/").pop()
-          };
-        })
-      }
-    ] : [];
-    if (this.config.toolFormat === "native") {
-      const toolResults = toolResponses.filter((resp) => resp.type === "response").map(
-        (resp) => ({
-          type: "tool-result",
-          toolCallId: resp.id,
-          toolName: resp.tool,
-          output: resp.response
-        })
-      );
-      return {
-        type: "reply",
-        message: [
-          {
-            role: "tool",
-            content: toolResults
-          },
-          ...mediaUserMessage
-        ]
-      };
-    }
-    if (toolResponses.length === 0) {
-      if (this.config.requireToolUse) {
-        return {
-          type: "reply",
-          message: [
-            {
-              role: "user",
-              content: responsePrompts.requireUseTool
-            }
-          ]
-        };
-      }
-      return {
-        type: "exit",
-        reason: {
-          type: "Exit" /* Exit */,
-          message: response.filter((c) => c.type === "text").map((c) => c.content).join("")
-        }
-      };
-    }
-    const finalResp = toolResponses.filter((resp) => resp.type === "response").flatMap(({ tool, response: response2 }) => responsePrompts.toolResults(tool, response2));
-    return {
-      type: "reply",
-      message: [
-        {
-          role: "user",
-          content: finalResp
-        },
-        ...mediaUserMessage
-      ]
-    };
-  }
-  async #invokeTool(name, args) {
-    try {
-      const handler15 = this.handlers[name]?.handler;
-      if (!handler15) {
-        return {
-          type: "Error" /* Error */,
-          message: {
-            type: "error-text",
-            value: responsePrompts.errorInvokeTool(name, "Tool not found")
-          },
-          canRetry: false
-        };
-      }
-      for (const instance of this.#policies) {
-        if (instance.onBeforeInvokeTool) {
-          const resp2 = await instance.onBeforeInvokeTool(name, args);
-          if (resp2) {
-            return resp2;
-          }
-        }
-      }
-      const resp = await this.onBeforeInvokeTool(this.handlers[name].name, args);
-      if (resp) {
-        return resp;
-      }
-      return await handler15(this.config.provider, args);
-    } catch (error) {
-      return {
-        type: "Error" /* Error */,
-        message: {
-          type: "error-text",
-          value: responsePrompts.errorInvokeTool(name, error)
-        },
-        canRetry: false
-      };
-    }
-  }
-  get model() {
-    return `${this.ai.provider}:${this.ai.modelId}`;
-  }
-  get usage() {
-    return this.config.usageMeter.usage;
-  }
-};
-
-// src/Agent/AnalyzerAgent/prompts.ts
-var fullSystemPrompt = (info, tools, toolNamePrefix, instructions, scripts, useNativeTool) => `
-# Analyzer Agent
-
-## Role
-You are the **Analyzer** agent, responsible for:
-1. **Project Structure Analysis** \u2013 Understand codebase organization and architecture.
-2. **Code Pattern Analysis** \u2013 Identify common patterns, conventions, and best practices.
-3. **Dependency Analysis** \u2013 Examine project dependencies and their usage.
-4. **Workflow Analysis** \u2013 Understand development tools, scripts, and processes.
-5. **Documentation Review** \u2013 Analyze documentation and code comments.
-
-> **Note**: The **Analyzer** agent focuses on understanding and analyzing the codebase without making modifications. Your role is to provide insights and understanding that can inform development decisions.
-
-## Rules
-1. **Thoroughness**: Conduct comprehensive analysis of relevant project aspects.
-2. **Pattern Recognition**: Identify recurring patterns, conventions, and architectural decisions.
-3. **Dependency Mapping**: Track and understand relationships between components.
-4. **Workflow Understanding**: Analyze build processes, testing approaches, and development tools.
-5. **Documentation Assessment**: Review documentation quality and completeness.
-6. **Non-Modification**: Never modify code or files - focus solely on analysis.
-
-${toolUsePrompt(useNativeTool, tools, toolNamePrefix)}
-${capabilities(toolNamePrefix)}
-${systemInformation(info)}
-${customInstructions(instructions)}
-${customScripts(scripts)}
-`;
-
-// src/Agent/AnalyzerAgent/index.ts
-var agentTools = [attemptCompletion_default, delegate_default, fetchUrl_default, handOver_default, listFiles_default, readBinaryFile_default, readFile_default, searchFiles_default];
-var AnalyzerAgent = class extends AgentBase {
-  constructor(options) {
-    const combinedTools = [...options.additionalTools ?? [], ...agentTools];
-    const tools = getAvailableTools({
-      provider: options.provider,
-      allTools: combinedTools,
-      hasAgent: (options.agents?.length ?? 0) > 0
-    });
-    const toolNamePrefix = options.toolFormat === "native" ? "" : "tool_";
-    const systemPrompt = fullSystemPrompt(
-      {
-        os: options.os
-      },
-      tools,
-      toolNamePrefix,
-      options.customInstructions ?? [],
-      options.scripts ?? {},
-      options.toolFormat === "native"
-    );
-    super(analyzerAgentInfo.name, options.ai, {
-      systemPrompt,
-      tools,
-      toolNamePrefix,
-      provider: options.provider,
-      agents: options.agents,
-      scripts: options.scripts,
-      callback: options.callback,
-      policies: options.policies,
-      toolFormat: options.toolFormat,
-      parameters: options.parameters ?? {},
-      usageMeter: options.usageMeter ?? new UsageMeter(),
-      requestTimeoutSeconds: options.requestTimeoutSeconds,
-      requireToolUse: options.requireToolUse ?? true
-    });
-  }
-  onBeforeInvokeTool() {
-    return Promise.resolve(void 0);
-  }
-};
-var analyzerAgentInfo = {
-  name: "analyzer",
-  responsibilities: [
-    "Analyzing project structure and organization",
-    "Identifying key source code files and their relationships",
-    "Understanding common coding patterns and conventions",
-    "Examining development workflow and tooling",
-    "Analyzing dependencies and their usage patterns"
-  ]
-};
-
-// src/Agent/ArchitectAgent/prompts.ts
-var fullSystemPrompt2 = (info, tools, toolNamePrefix, instructions, scripts, useNativeTool) => `
-# Architect Agent
-
-## Role
-You are the **Architect** agent, responsible for:
-1. **Task Analysis** - Understand requirements.
-2. **File Identification** - Select relevant files.
-3. **File Reading** - Use provided tools to gather information.
-4. **Implementation Plan** - Draft a *code-free* plan (pseudocode/interface stubs permitted).
-5. **Review & Improve** - Refine the plan.
-6. **Handover/Delegate** - Provide the final plan, context, and files to the **Coder** agent.
-
-> **Never** modify project files directly. Only produce the implementation plan; the **Coder** agent performs all code changes.
-
-## Rules
-1. **Consistency** - Align with user objectives.
-2. **Relevance** - Consult only essential files.
-3. **Conciseness** - Be succinct; avoid repetition.
-4. **Accuracy** - Ensure conclusions are verifiable.
-5. **Clarity** - Present information in a structured format.
-6. **Minimal Queries** - Ask questions only when truly needed.
-7. **Completion** - Only use the \`attemptCompletion\` tool if the user's request has been fully satisfied and no coding tasks need to be delegated to the Coder agent.
-
-## Steps
-1. **Analyze Task** - Capture goals, constraints, and success criteria.
-2. **Identify Relevant Files** - List files and justify each choice.
-3. **Read Files via Tools** - Summarize key insights.
-4. **Create Implementation Plan** - Provide a detailed, step-by-step breakdown:
-   * Tasks, resources, and dependencies.
-   * Pseudocode or interface declarations only\u2014no concrete code.
-   * Sufficient detail for the **Coder** to implement without follow-ups.
-5. **Review & Improve** - Confirm the plan is unambiguous and complete.
-6. **Handover/Delegate**
-   - If the plan consists of a single self-contained step, hand it over as one task.
-   - If multiple steps are required, break them into numbered tasks to delegate to the **Coder** agent.
-   - When handing over or delegating, you MUST provide the full implementation plan. Include all necessary context, file references, and clarifications for successful execution.
-
-${toolUsePrompt(useNativeTool, tools, toolNamePrefix)}
-${capabilities(toolNamePrefix)}
-${systemInformation(info)}
-${customInstructions(instructions)}
-${customScripts(scripts)}
-`;
-
-// src/Agent/ArchitectAgent/index.ts
-var agentTools2 = [attemptCompletion_default, delegate_default, fetchUrl_default, handOver_default, listFiles_default, readBinaryFile_default, readFile_default, searchFiles_default];
-var ArchitectAgent = class extends AgentBase {
-  constructor(options) {
-    const combinedTools = [...options.additionalTools ?? [], ...agentTools2];
-    const tools = getAvailableTools({
-      provider: options.provider,
-      allTools: combinedTools,
-      hasAgent: (options.agents?.length ?? 0) > 0
-    });
-    const toolNamePrefix = options.toolFormat === "native" ? "" : "tool_";
-    const systemPrompt = fullSystemPrompt2(
-      {
-        os: options.os
-      },
-      tools,
-      toolNamePrefix,
-      options.customInstructions ?? [],
-      options.scripts ?? {},
-      options.toolFormat === "native"
-    );
-    super(architectAgentInfo.name, options.ai, {
-      systemPrompt,
-      tools,
-      toolNamePrefix,
-      provider: options.provider,
-      agents: options.agents,
-      scripts: options.scripts,
-      callback: options.callback,
-      policies: options.policies,
-      toolFormat: options.toolFormat,
-      parameters: options.parameters ?? {},
-      usageMeter: options.usageMeter ?? new UsageMeter(),
-      requestTimeoutSeconds: options.requestTimeoutSeconds,
-      requireToolUse: options.requireToolUse ?? true
-    });
-  }
-  onBeforeInvokeTool() {
-    return Promise.resolve(void 0);
-  }
-};
-var architectAgentInfo = {
-  name: "architect",
-  responsibilities: [
-    "Analyzing the user\u2019s overall task and requirements.",
-    "Creating plans and making higher-level decisions about system structure and design.",
-    "Reviewing and analyzing existing code or components for maintainability and scalability.",
-    "Laying out the roadmap for implementation."
-  ]
-};
-
-// src/Agent/CodeFixerAgent/prompts.ts
-var basePrompt = `You are a highly skilled software engineer specializing in debugging and fixing code issues. You have extensive experience with:
-- Type systems and type checking
-- Test frameworks and debugging test failures
-- Code quality tools and best practices
-- Systematic debugging approaches`;
-var codeFixingStrategies = `
-====
-
-CODE FIXING STRATEGIES
-
-1. Type Errors
-   - Analyze type error messages carefully
-   - Check type definitions and imports
-   - Consider type assertions only as a last resort
-   - Verify type compatibility across function boundaries
-   - Look for null/undefined handling issues
-
-2. Test Failures
-   - Examine test output and error messages
-   - Check test setup and fixtures
-   - Verify assertions and expectations
-   - Look for async/timing issues
-   - Consider edge cases and input validation
-
-3. Code Quality Issues
-   - Follow project's coding standards
-   - Address linter warnings systematically
-   - Improve code readability
-   - Fix potential runtime issues
-   - Consider performance implications
-
-4. General Approach
-   - Start with the most critical issues
-   - Make minimal necessary changes
-   - Verify fixes don't introduce new issues
-   - Document complex fixes with comments
-   - Track attempted solutions for each issue`;
-var retryGuidelines = `
-====
-
-RETRY GUIDELINES
-
-1. Before Retrying
-   - Analyze previous attempt's failure
-   - Consider alternative approaches
-   - Check if similar issues were fixed
-   - Verify no new issues were introduced
-
-2. When to Retry
-   - Error message changed but issue persists
-   - New information available about the root cause
-   - Different fixing strategy available
-   - Previous attempt partially successful
-
-3. When to Stop
-   - Maximum retry limit reached
-   - Same error occurs repeatedly
-   - Fix would require major refactoring
-   - Issue requires human intervention
-
-4. After Maximum Retries
-   - Document attempted solutions
-   - Explain why the issue remains
-   - Suggest manual intervention steps
-   - Report any partial improvements`;
-var fullSystemPrompt3 = (info, tools, toolNamePrefix, instructions, scripts, useNativeTool) => `
-${basePrompt}
-${toolUsePrompt(useNativeTool, tools, toolNamePrefix)}
-${codeFixingStrategies}
-${retryGuidelines}
-${capabilities(toolNamePrefix)}
-${systemInformation(info)}
-${customInstructions(instructions)}
-${customScripts(scripts)}`;
-
-// src/Agent/CodeFixerAgent/index.ts
-var agentTools3 = [
-  attemptCompletion_default,
-  delegate_default,
-  executeCommand_default,
-  fetchUrl_default,
-  handOver_default,
-  listFiles_default,
-  readBinaryFile_default,
-  readFile_default,
-  removeFile_default,
-  renameFile_default,
-  replaceInFile_default,
-  searchFiles_default,
-  writeToFile_default
-];
-var CodeFixerAgent = class extends AgentBase {
-  #maxRetries;
-  #retryCount = 0;
-  constructor(options) {
-    const combinedTools = [...options.additionalTools ?? [], ...agentTools3];
-    const tools = getAvailableTools({
-      provider: options.provider,
-      allTools: combinedTools,
-      hasAgent: (options.agents?.length ?? 0) > 0
-    });
-    const toolNamePrefix = options.toolFormat === "native" ? "" : "tool_";
-    const systemPrompt = fullSystemPrompt3(
-      {
-        os: options.os
-      },
-      tools,
-      toolNamePrefix,
-      options.customInstructions ?? [],
-      options.scripts ?? {},
-      options.toolFormat === "native"
-    );
-    super(codeFixerAgentInfo.name, options.ai, {
-      systemPrompt,
-      tools,
-      toolNamePrefix,
-      provider: options.provider,
-      agents: options.agents,
-      scripts: options.scripts,
-      callback: options.callback,
-      policies: options.policies,
-      toolFormat: options.toolFormat,
-      parameters: options.parameters ?? {},
-      usageMeter: options.usageMeter ?? new UsageMeter(),
-      requestTimeoutSeconds: options.requestTimeoutSeconds,
-      requireToolUse: options.requireToolUse ?? true
-    });
-    this.#maxRetries = options.maxRetries ?? 5;
-  }
-  async onBeforeInvokeTool(name, _args) {
-    if (name === attemptCompletion_default.name) {
-      if (this.#retryCount > this.#maxRetries) {
-        return;
-      }
-      this.#retryCount++;
-      const executeCommand = this.config.provider.executeCommand;
-      if (!executeCommand) {
-        return;
-      }
-      const check = this.config.scripts?.check;
-      const checkCommand = typeof check === "string" ? check : check?.command;
-      if (checkCommand) {
-        try {
-          const { exitCode, stdout, stderr } = await executeCommand(checkCommand, false);
-          if (exitCode !== 0) {
-            return {
-              type: "Reply" /* Reply */,
-              message: {
-                type: "error-text",
-                value: responsePrompts.commandResult(checkCommand, exitCode, stdout, stderr)
-              }
-            };
-          }
-        } catch (error) {
-          console.warn(`Failed to check code using command: ${checkCommand}`, error);
-        }
-      }
-      const test = this.config.scripts?.test;
-      const testCommand = typeof test === "string" ? test : test?.command;
-      if (testCommand) {
-        try {
-          const { exitCode, stdout, stderr } = await executeCommand(testCommand, false);
-          if (exitCode !== 0) {
-            return {
-              type: "Reply" /* Reply */,
-              message: {
-                type: "error-text",
-                value: responsePrompts.commandResult(testCommand, exitCode, stdout, stderr)
-              }
-            };
-          }
-        } catch (error) {
-          console.warn(`Failed to test code using command: ${testCommand}`, error);
-        }
-      }
-    }
-  }
-};
-var codeFixerAgentInfo = {
-  name: "codefixer",
-  responsibilities: [
-    "Fixing type errors and type-related issues",
-    "Resolving failing tests",
-    "Addressing code quality issues",
-    "Tracking and reporting unfixed issues"
-  ]
-};
-
-// src/Agent/CoderAgent/prompts.ts
-var basePrompt2 = "You are a highly skilled software engineer with extensive knowledge in many programming languages, frameworks, design patterns, and best practices.";
-var editingFilesPrompt = (toolNamePrefix) => `
-====
-
-EDITING FILES
-
-You have two file-manipulation tools: **${toolNamePrefix}write_to_file** (full overwrite) and **${toolNamePrefix}replace_in_file** (targeted anchor-based edits). Choose the smallest safe operation for every change.
-
-# ${toolNamePrefix}write_to_file
-
-## Purpose
-
-- Create a new file, or overwrite the entire contents of an existing file.
-
-## When to Use
-
-- Initial file creation, such as when scaffolding a new project.
-- Overwriting large boilerplate files where you want to replace the entire content at once.
-- When the complexity or number of changes would make ${toolNamePrefix}replace_in_file unwieldy or error-prone.
-- When you need to completely restructure a file's content or change its fundamental organization.
-
-## Important Considerations
-
-- Using ${toolNamePrefix}write_to_file requires providing the file's complete final content.
-- If you only need to make small changes to an existing file, consider using ${toolNamePrefix}replace_in_file instead to avoid unnecessarily rewriting the entire file.
-- While ${toolNamePrefix}write_to_file should not be your default choice, don't hesitate to use it when the situation truly calls for it.
-
-# ${toolNamePrefix}replace_in_file
-
-## Purpose
-
-- Make targeted edits to specific parts of an existing file without overwriting the entire file.
-
-## When to Use
-
-- Small, localized changes like updating a few lines, function implementations, changing variable names, modifying a section of text, etc.
-- Targeted improvements where only specific portions of the file's content needs to be altered.
-- Especially useful for long files where much of the file will remain unchanged.
-
-## Advantages
-
-- More efficient for minor edits, since you don't need to supply the entire file content.
-- Reduces the chance of errors that can occur when overwriting large files.
-
-# Choosing the Appropriate Tool
-
-- **Default to ${toolNamePrefix}replace_in_file** for most changes. It keeps diffs small and reduces risk.
-- **Use ${toolNamePrefix}write_to_file** when:
-  - Creating new files
-  - The changes are so extensive that using ${toolNamePrefix}replace_in_file would be more complex or risky
-  - You need to completely reorganize or restructure a file
-  - The file is relatively small and the changes affect most of its content
-  - You're generating boilerplate or template files
-
-# Workflow Tips
-
-1. Before editing, assess the scope of your changes and decide which tool to use.
-2. For targeted edits, apply ${toolNamePrefix}replace_in_file with carefully crafted before/after text anchors. If you need multiple changes, you can stack multiple operations within a single ${toolNamePrefix}replace_in_file call.
-3. For major overhauls or initial file creation, rely on ${toolNamePrefix}write_to_file.
-4. Once the file has been edited with either ${toolNamePrefix}write_to_file or ${toolNamePrefix}replace_in_file, the system will provide you with the final state of the modified file. Use this updated content as the reference point for any subsequent operations, since it reflects any auto-formatting or user-applied changes.
-
-Picking the right tool keeps edits minimal, safe, and easy to review.
-`;
-var rules = (toolNamePrefix) => `
-====
-
-RULES
-
-- Work only with relative paths; you may \`cd\` into child directories but never use \`cd ..\`, root, or absolute paths.
-- When generating code, tests, or other comment-capable files, prepend a comment describing the file's purpose plus \u201Cgenerated by polka.codes\u201D.
-  For text files (e.g. README.md), append a footer with the same notice.
-- Never describe what changed inside code comments; comments must focus on purpose or usage only.
-- Before using ${toolNamePrefix}execute_command, consider SYSTEM INFORMATION to ensure commands suit the user's OS. If a command must run in a subdirectory, prepend a single \`cd childDir &&\` segment.
-- Use ${toolNamePrefix}search_files for broad analysis, then ${toolNamePrefix}read_file to inspect context, and finally ${toolNamePrefix}replace_in_file or ${toolNamePrefix}write_to_file to modify.
-- Prefer ${toolNamePrefix}replace_in_file for focused edits; choose ${toolNamePrefix}write_to_file for new files or complete rewrites.
-- When creating a new file, look for existing files with similar content or patterns; if found, read them and use their structure or conventions as a reference.
-- Use before/after text anchors in ${toolNamePrefix}replace_in_file to target changes. If multiple operations are needed, list them in file order.
-- Do not guess unseen content. Read existing files first unless creating new ones.
-- Follow existing style, lint, and naming conventions. Ensure all changes compile and pass tests where applicable.
-- ALWAYS wait for the user's confirmation after each tool call before starting the next step.
-- The agent must never invoke more than 5 tools in a single response.
-- Do not end ${toolNamePrefix}attempt_completion output with questions or conversational prompts.
-- Avoid filler words like \u201CGreat\u201D, \u201CCertainly\u201D, \u201COkay\u201D, \u201CSure\u201D at the start of responses; be direct and technical.
-- Keep inline documentation current as you edit.
-`;
-var objectives = (toolNamePrefix) => `
-====
-
-OBJECTIVE
-
-You solve the user's task by working in small, verifiable steps.
-
-1. **Plan** - Parse the task, list clear goals, and order them logically.
-2. **Think** - Wrap private reasoning in <thinking></thinking>.
-   \u2022 Review project context.
-   \u2022 Select the single best tool for the next goal.
-   \u2022 Ensure every required parameter is available or can be inferred.
-3. **Act** - Invoke one tool per step. Wait for the system's response (and user confirmation where required) before continuing.
-4. **Iterate** - Repeat Plan \u2192 Think \u2192 Act until all goals are complete.
-5. **Complete** - Use ${toolNamePrefix}attempt_completion to deliver the final result. Do not invite further discussion unless the user explicitly requests changes.
-`;
-var fullSystemPrompt4 = (info, tools, toolNamePrefix, instructions, scripts, useNativeTool) => `
-${basePrompt2}
-${toolUsePrompt(useNativeTool, tools, toolNamePrefix)}
-${editingFilesPrompt(toolNamePrefix)}
-${capabilities(toolNamePrefix)}
-${rules(toolNamePrefix)}
-${objectives(toolNamePrefix)}
-${systemInformation(info)}
-${customInstructions(instructions)}
-${customScripts(scripts)}
-`;
-
-// src/Agent/CoderAgent/index.ts
-var agentTools4 = [
-  attemptCompletion_default,
-  delegate_default,
-  executeCommand_default,
-  fetchUrl_default,
-  handOver_default,
-  listFiles_default,
-  readBinaryFile_default,
-  readFile_default,
-  removeFile_default,
-  renameFile_default,
-  replaceInFile_default,
-  searchFiles_default,
-  writeToFile_default
-];
-var CoderAgent = class extends AgentBase {
-  constructor(options) {
-    const combinedTools = [...options.additionalTools ?? [], ...agentTools4];
-    const tools = getAvailableTools({
-      provider: options.provider,
-      allTools: combinedTools,
-      hasAgent: (options.agents?.length ?? 0) > 0
-    });
-    const toolNamePrefix = options.toolFormat === "native" ? "" : "tool_";
-    const systemPrompt = fullSystemPrompt4(
-      {
-        os: options.os
-      },
-      tools,
-      toolNamePrefix,
-      options.customInstructions ?? [],
-      options.scripts ?? {},
-      options.toolFormat === "native"
-    );
-    super(coderAgentInfo.name, options.ai, {
-      systemPrompt,
-      tools,
-      toolNamePrefix,
-      provider: options.provider,
-      agents: options.agents,
-      scripts: options.scripts,
-      callback: options.callback,
-      policies: options.policies,
-      toolFormat: options.toolFormat,
-      parameters: options.parameters ?? {},
-      usageMeter: options.usageMeter ?? new UsageMeter(),
-      requestTimeoutSeconds: options.requestTimeoutSeconds,
-      requireToolUse: options.requireToolUse ?? true
-    });
-  }
-  async #runScript(scriptName, shouldReplyWithError) {
-    const executeCommand = this.config.provider.executeCommand;
-    if (!executeCommand) {
-      return;
-    }
-    const script = this.config.scripts?.[scriptName];
-    const command = typeof script === "string" ? script : script?.command;
-    if (command) {
-      try {
-        const { exitCode, stdout, stderr } = await executeCommand(command, false);
-        if (exitCode !== 0 && shouldReplyWithError) {
-          return {
-            type: "Reply" /* Reply */,
-            message: {
-              type: "error-text",
-              value: responsePrompts.commandResult(command, exitCode, stdout, stderr)
-            }
-          };
-        }
-      } catch (error) {
-        console.warn(`Failed to run ${scriptName} using command: ${command}`, error);
-      }
-    }
-  }
-  async onBeforeInvokeTool(name, _args) {
-    if (name !== attemptCompletion_default.name) {
-      return;
-    }
-    await this.#runScript("format", false);
-    const checkResult = await this.#runScript("check", true);
-    if (checkResult) {
-      return checkResult;
-    }
-    const testResult = await this.#runScript("test", true);
-    if (testResult) {
-      return testResult;
-    }
-  }
-};
-var coderAgentInfo = {
-  name: "coder",
-  responsibilities: [
-    "Editing and refactoring existing code.",
-    "Creating new features or modules.",
-    "Running tests and analyzing test results.",
-    "Maintaining coding standards, lint rules, and general code quality."
-  ]
-};
-
-// src/Agent/MultiAgent.ts
-var MultiAgent = class {
-  #config;
-  #agents = [];
-  #originalTask;
-  constructor(config) {
-    this.#config = config;
-  }
-  async #handleTaskResult(exitReason) {
-    switch (exitReason.type) {
-      case "HandOver" /* HandOver */: {
-        this.#agents.pop();
-        const prompt = await this.#config.getPrompt?.(
-          exitReason.agentName,
-          exitReason.task,
-          exitReason.context,
-          exitReason.files,
-          this.#originalTask
-        ) ?? exitReason.task;
-        return await this.#startTask(exitReason.agentName, prompt);
-      }
-      case "Delegate" /* Delegate */: {
-        const prompt = await this.#config.getPrompt?.(
-          exitReason.agentName,
-          exitReason.task,
-          exitReason.context,
-          exitReason.files,
-          this.#originalTask
-        ) ?? exitReason.task;
-        const delegateResult = await this.#startTask(exitReason.agentName, prompt);
-        switch (delegateResult.type) {
-          case "HandOver" /* HandOver */:
-          case "Delegate" /* Delegate */:
-            console.warn("Unexpected exit reason", delegateResult);
-            break;
-          case "Aborted":
-          case "Interrupted" /* Interrupted */:
-            return delegateResult;
-          case "Exit" /* Exit */:
-            return this.continueTask(delegateResult.message);
-        }
-        return delegateResult;
-      }
-      case "Aborted":
-      case "Interrupted" /* Interrupted */:
-      case "Exit" /* Exit */:
-        this.#agents.pop();
-        return exitReason;
-      default:
-        return exitReason;
-    }
-  }
-  async #startTask(agentName, task) {
-    const newAgent = await this.#config.createAgent(agentName);
-    this.#agents.push(newAgent);
-    const exitReason = await newAgent.start(task);
-    return await this.#handleTaskResult(exitReason);
-  }
-  async startTask(options) {
-    if (this.#agents.length > 0) {
-      throw new Error("An active agent already exists");
-    }
-    this.#originalTask = options.task;
-    const userContent = options.files ?? [];
-    userContent.push({
-      type: "text",
-      text: `<task>${options.task}</task>
-<context>${options.context}</context>`
-    });
-    return this.#startTask(options.agentName, userContent);
-  }
-  async continueTask(userMessage) {
-    if (!this.#agents.length) {
-      throw new Error("No active agent");
-    }
-    const exitReason = await this.#agents[this.#agents.length - 1].continueTask(userMessage);
-    return await this.#handleTaskResult(exitReason);
-  }
-  get hasActiveAgent() {
-    return this.#agents.length > 0;
-  }
-  abort() {
-    if (this.hasActiveAgent) {
-      this.#agents[this.#agents.length - 1].abort();
-    }
-  }
-};
-
-// 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/config.ts
-import { z as z16 } from "zod";
-var toolFormatSchema = z16.enum(["native", "polka-codes"]).optional();
-var providerModelSchema = z16.object({
-  provider: z16.string().optional(),
-  model: z16.string().optional(),
-  parameters: z16.record(z16.string(), z16.any()).optional(),
-  toolFormat: toolFormatSchema
-});
-var agentSchema = providerModelSchema.extend({
-  initialContext: z16.object({
-    maxFileCount: z16.number().int().positive().optional(),
-    excludes: z16.array(z16.string()).optional()
-  }).optional(),
-  retryCount: z16.number().int().min(0).optional(),
-  requestTimeoutSeconds: z16.number().int().positive().optional()
-});
-var configSchema = z16.object({
-  agent: z16.string().optional(),
-  prices: z16.record(
-    z16.string(),
-    // provider
-    z16.record(
-      z16.string(),
-      // model
-      z16.object({
-        inputPrice: z16.number().optional(),
-        outputPrice: z16.number().optional(),
-        cacheWritesPrice: z16.number().optional(),
-        cacheReadsPrice: z16.number().optional()
-      })
-    )
-  ).optional(),
-  providers: z16.record(
-    z16.string(),
-    z16.object({
-      apiKey: z16.string().optional(),
-      defaultModel: z16.string().optional(),
-      defaultParameters: z16.record(z16.string(), z16.any()).optional(),
-      location: z16.string().optional(),
-      project: z16.string().optional(),
-      keyFile: z16.string().optional()
-    })
-  ).optional(),
-  defaultProvider: z16.string().optional(),
-  defaultModel: z16.string().optional(),
-  defaultParameters: z16.record(z16.string(), z16.any()).optional(),
-  toolFormat: toolFormatSchema,
-  maxMessageCount: z16.number().int().positive().optional(),
-  budget: z16.number().positive().optional(),
-  retryCount: z16.number().int().min(0).optional(),
-  requestTimeoutSeconds: z16.number().int().positive().optional(),
-  summaryThreshold: z16.number().int().positive().optional(),
-  scripts: z16.record(
-    z16.string(),
-    z16.string().or(
-      z16.object({
-        command: z16.string(),
-        description: z16.string()
-      })
-    )
-  ).optional(),
-  agents: z16.record(z16.string(), agentSchema).optional(),
-  commands: z16.object({
-    default: providerModelSchema.optional()
-  }).catchall(providerModelSchema).optional(),
-  rules: z16.array(z16.string()).optional().or(z16.string()).optional(),
-  excludeFiles: z16.array(z16.string()).optional(),
-  policies: z16.array(z16.string()).optional()
-}).strict();
-var Policies = /* @__PURE__ */ ((Policies2) => {
-  Policies2["TruncateContext"] = "truncatecontext";
-  Policies2["EnableCache"] = "enablecache";
-  return Policies2;
-})(Policies || {});
-
-// src/Agent/policies/EnableCachePolicy.ts
-var CACHEABLE_MODELS = ["sonnet", "opus", "haiku", "gemini"];
-function isCacheableModel(modelId) {
-  return CACHEABLE_MODELS.some((model) => modelId.includes(model));
-}
-function getProviderKey(provider) {
-  if (provider === "openrouter") {
-    return "openrouter";
-  }
-  if (provider.includes("anthropic")) {
-    return "anthropic";
-  }
-  return void 0;
-}
-var EnableCachePolicy = () => {
-  return {
-    name: "enablecache" /* EnableCache */,
-    async prepareMessages(agent, messages) {
-      const providerKey = getProviderKey(agent.ai.provider);
-      if (!providerKey || !isCacheableModel(agent.ai.modelId)) {
-        return messages;
-      }
-      const providerOptions = { [providerKey]: { cacheControl: { type: "ephemeral" } } };
-      const newMessages = messages.slice();
-      let userMessagesToUpdate = 2;
-      for (let i = newMessages.length - 1; i >= 0; i--) {
-        const message = newMessages[i];
-        if (message.role === "user" && userMessagesToUpdate > 0) {
-          newMessages[i] = {
-            ...message,
-            providerOptions: {
-              ...providerOptions,
-              ...message.providerOptions ?? {}
-            }
-          };
-          userMessagesToUpdate--;
-        } else if (message.role === "system") {
-          newMessages[i] = {
-            ...message,
-            providerOptions: {
-              ...providerOptions,
-              ...message.providerOptions ?? {}
-            }
-          };
-          break;
-        }
-      }
-      return newMessages;
-    }
-  };
-};
-
-// src/Agent/policies/TruncateContextPolicy.ts
-var DEFAULT_MAX_TOKENS_ESTIMATE = 32e3;
-function getMaxTokens(agent) {
-  const params = agent.parameters || {};
-  if (params.maxTokens && typeof params.maxTokens === "number" && params.maxTokens > 0) {
-    return params.maxTokens;
-  }
-  return DEFAULT_MAX_TOKENS_ESTIMATE;
-}
-function estimateTokens(text) {
-  return Math.ceil(text.length / 4);
-}
-function estimateMessageTokens(msg) {
-  if (typeof msg.content === "string") {
-    return estimateTokens(msg.content);
-  }
-  if (Array.isArray(msg.content)) {
-    let messageTokens = 0;
-    for (const block of msg.content) {
-      if (typeof block === "object" && "text" in block && typeof block.text === "string") {
-        messageTokens += estimateTokens(block.text);
-      }
-    }
-    return messageTokens;
-  }
-  return 0;
-}
-var TruncateContextPolicy = (() => {
-  return {
-    name: "truncatecontext" /* TruncateContext */,
-    async onBeforeRequest(agent) {
-      const messages = agent.messages;
-      if (messages.length < 3) {
-        return;
-      }
-      let totalTokens = messages.reduce((acc, msg) => acc + estimateMessageTokens(msg), 0);
-      const maxTokens = getMaxTokens(agent);
-      if (totalTokens <= maxTokens) {
-        return;
-      }
-      const protectedIndices = /* @__PURE__ */ new Set();
-      let userMessagesFound = 0;
-      messages.forEach((msg, index) => {
-        if (msg.role === "system") {
-          protectedIndices.add(index);
-        }
-        if (msg.role === "user") {
-          if (userMessagesFound < 2) {
-            protectedIndices.add(index);
-          }
-          userMessagesFound++;
-        }
-      });
-      if (messages.length > 0) {
-        protectedIndices.add(messages.length - 1);
-      }
-      const truncatableIndices = [];
-      for (let i = 0; i < messages.length; i++) {
-        if (!protectedIndices.has(i)) {
-          truncatableIndices.push(i);
-        }
-      }
-      const removedIndices = /* @__PURE__ */ new Set();
-      const initialTotalTokens = totalTokens;
-      while (totalTokens > maxTokens && truncatableIndices.length > 0) {
-        const middleIndex = Math.floor(truncatableIndices.length / 2);
-        const indexToRemove = truncatableIndices.splice(middleIndex, 1)[0];
-        removedIndices.add(indexToRemove);
-        totalTokens -= estimateMessageTokens(messages[indexToRemove]);
-      }
-      if (removedIndices.size === 0) {
-        if (initialTotalTokens > maxTokens) {
-          console.warn("Warning: Protected messages exceed token limit. Cannot truncate further.");
-        }
-        return;
-      }
-      const truncatedMessages = [];
-      let truncationNoticeAdded = false;
-      for (let i = 0; i < messages.length; i++) {
-        if (removedIndices.has(i)) {
-          if (!truncationNoticeAdded) {
-            truncatedMessages.push({
-              role: "user",
-              content: `Note: ${removedIndices.size} messages were truncated from the conversation to prevent context overflow.`
-            });
-            truncationNoticeAdded = true;
-          }
-        } else {
-          truncatedMessages.push(messages[i]);
-        }
-      }
-      console.log(`Truncated context: removed ${removedIndices.size} messages.`);
-      agent.setMessages(truncatedMessages);
-    }
-  };
-});
-
-// src/Agent/index.ts
-var allAgents = [architectAgentInfo, coderAgentInfo, analyzerAgentInfo, codeFixerAgentInfo];
 export {
-  AgentBase,
-  AnalyzerAgent,
-  ArchitectAgent,
-  CodeFixerAgent,
-  CoderAgent,
-  EnableCachePolicy,
   MockProvider,
-  MultiAgent,
-  Policies,
-  TaskEventKind,
   ToolResponseType,
-  TruncateContextPolicy,
   UsageMeter,
-  agentsPrompt,
-  allAgents,
-  analyzerAgentInfo,
-  architectAgentInfo,
+  appendMemory_default as appendMemory,
   askFollowupQuestion_default as askFollowupQuestion,
-  attemptCompletion_default as attemptCompletion,
-  capabilities,
-  codeFixerAgentInfo,
-  coderAgentInfo,
   computeRateLimitBackoffSeconds,
   configSchema,
-  customInstructions,
-  customScripts,
-  delegate_default as delegate,
   executeCommand_default as executeCommand,
   fetchUrl_default as fetchUrl,
-  getAvailableTools,
-  handOver_default as handOver,
   listFiles_default as listFiles,
-  parseAssistantMessage,
+  listMemoryTopics_default as listMemoryTopics,
   parseJsonFromMarkdown,
   readBinaryFile_default as readBinaryFile,
   readFile_default as readFile,
+  readMemory_default as readMemory,
   removeFile_default as removeFile,
+  removeMemory_default as removeMemory,
   renameFile_default as renameFile,
   replaceInFile_default as replaceInFile,
   replaceInFile as replaceInFileHelper,
+  replaceMemory_default as replaceMemory,
   responsePrompts,
   searchFiles_default as searchFiles,
-  systemInformation,
-  toolUsePrompt,
   writeToFile_default as writeToFile
 };