@agentscope-ai/agentscope 0.0.2

package/dist/agent/index.js

@@ -0,0 +1,1412 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/agent/index.ts
+var agent_exports = {};
+__export(agent_exports, {
+  Agent: () => Agent
+});
+module.exports = __toCommonJS(agent_exports);
+
+// src/agent/agent.ts
+var import_zod9 = require("zod");
+
+// src/message/message.ts
+function createMsg({
+  name,
+  content,
+  role,
+  metadata = {},
+  id = crypto.randomUUID(),
+  timestamp = (/* @__PURE__ */ new Date()).toISOString(),
+  usage
+}) {
+  return { id, name, role, content, metadata, timestamp, usage };
+}
+function getContentBlocks(msg, blockType) {
+  if (!blockType) return msg.content;
+  return msg.content.filter((block) => block.type === blockType);
+}
+
+// src/tool/response.ts
+function createToolResponse({
+  content,
+  state,
+  id = crypto.randomUUID(),
+  createdAt = (/* @__PURE__ */ new Date()).toISOString(),
+  metadata = {},
+  stream = false,
+  isLast = true,
+  isInterrupted = false
+}) {
+  return {
+    content,
+    id,
+    createdAt,
+    metadata,
+    state,
+    stream,
+    isLast,
+    isInterrupted
+  };
+}
+function isToolResponse(obj) {
+  return obj && typeof obj === "object" && typeof obj.id === "string" && typeof obj.createdAt === "string" && Array.isArray(obj.content) && typeof obj.metadata === "object" && typeof obj.stream === "boolean" && typeof obj.isLast === "boolean" && typeof obj.isInterrupted === "boolean" && ["success", "error", "interrupted", "running"].includes(obj.state);
+}
+
+// src/tool/toolkit.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var import_json_schema = require("@cfworker/json-schema");
+var import_gray_matter = __toESM(require("gray-matter"));
+var import_zod = require("zod");
+
+// src/_utils/common.ts
+var import_jsonrepair = require("jsonrepair");
+function _jsonLoadsWithRepair(input) {
+  try {
+    const jsonObj = JSON.parse(input);
+    if (typeof jsonObj === "object" && jsonObj !== null && !Array.isArray(jsonObj)) {
+      return jsonObj;
+    } else {
+      return {};
+    }
+  } catch {
+    try {
+      const repairedString = (0, import_jsonrepair.jsonrepair)(input);
+      const jsonObj = JSON.parse(repairedString);
+      if (typeof jsonObj === "object" && jsonObj !== null && !Array.isArray(jsonObj)) {
+        return jsonObj;
+      } else {
+        return {};
+      }
+    } catch (e) {
+      console.error(`Failed to parse JSON "${input}" with error:`, e);
+      return {};
+    }
+  }
+}
+
+// src/tool/toolkit.ts
+var Toolkit = class {
+  tools;
+  skills;
+  skillDirs;
+  // The cache mapping from the skill name to its corresponding tool name in the toolkit.
+  _skillCache;
+  /**
+   * Initializes a new instance of the Toolkit class.
+   * @param config - The configuration object for initializing the toolkit, which can include an array of tools, an array of skill paths, an array of skill directory paths, and a boolean indicating whether to include the built-in skill tool for reading SKILL.md files.
+   * @param config.tools - An array of tool definitions to register in the toolkit.
+   * @param config.skills - An array of file paths pointing to individual skills.
+   * @param config.skillDirs - An array of directory paths, where each directory can contain multiple skills in its subdirectories.
+   * @param config.builtInSkillTool - A boolean flag indicating whether to include the built-in skill tool for reading SKILL.md files.
+   */
+  constructor(config) {
+    const { tools = [], skills = [], skillDirs = [], builtInSkillTool = true } = config || {};
+    this.tools = [];
+    if (builtInSkillTool) {
+      this.tools.push({
+        type: "function",
+        name: "Skill",
+        description: `Retrieves the full content of a skill by reading its SKILL.md file. Skills are packages of domain expertise that extend agent capabilities. Use this tool to access detailed instructions, examples, and guidelines for a specific skill.
+
+Usage:
+- Provide the skill name as the input parameter
+- The tool will return the complete SKILL.md file content for that skill
+- If the skill is not found, an error message with available skills will be returned
+- Available skills are listed in the skills-system section of the agent prompt`,
+        inputSchema: import_zod.z.object({ name: import_zod.z.string().describe("The name of the skill") }),
+        call: this._skillTool.bind(this),
+        requireUserConfirm: false
+      });
+    }
+    tools.map((tool) => {
+      this.tools.push({
+        type: "function",
+        ...tool
+      });
+    });
+    this.skills = skills;
+    this.skillDirs = skillDirs;
+    this._skillCache = {};
+  }
+  /**
+   * Registers a tool function to the toolkit. The function can be either a plain function that adheres to the ToolFunction type, or an instance of a class that extends ToolBase. When registering a plain function, the name, description, and input schema must be provided explicitly. When registering a ToolBase instance, these properties will be extracted from the instance itself.
+   *
+   * @params tool - The tool function to register, which can be either a plain function with explicit properties or an instance of a class that extends ToolBase.
+   * @returns The Toolkit instance with the new tool function registered
+   * @param tool
+   */
+  registerToolFunction(tool) {
+    this.tools.push({
+      type: "function",
+      ...tool
+    });
+    return this;
+  }
+  /**
+   * Registers functions from a given MCP client.
+   *
+   * @param root0
+   * @param root0.client
+   * @param root0.enabledTools
+   * @param root0.disabledTools
+   * @param root0.requireUserConfirm
+   * @returns The Toolkit instance with the new tools registered
+   */
+  async registerMCPClient({
+    client,
+    enabledTools,
+    disabledTools = [],
+    requireUserConfirm = false
+  }) {
+    const tools = await client.listTools();
+    const appendTools = [];
+    tools.filter(
+      (tool) => !(enabledTools && !enabledTools.includes(tool.name)) && !disabledTools.includes(tool.name)
+    ).forEach((tool) => {
+      this.tools.push({
+        type: "mcp",
+        mcpName: client.name,
+        ...tool,
+        requireUserConfirm
+      });
+      appendTools.push(tool.name);
+    });
+    console.log(`Registered tools from MCP client '${client.name}': ${appendTools.join(", ")}`);
+    return this;
+  }
+  /**
+   * Executes a registered tool function based on the provided ToolUseBlock.
+   * Note this method always returns an AsyncGenerator of ToolResponse, regardless of the tool function type.
+   *
+   * @param toolCall - The ToolUseBlock containing the tool name and input arguments
+   * @yields Incremental ToolResponse objects as they are produced by the tool function
+   * @returns The final complete ToolResponse after the tool function execution is finished
+   */
+  async *callToolFunction(toolCall) {
+    const tool = this.tools.find((tool2) => tool2.name === toolCall.name);
+    if (!tool) {
+      const notFoundRes = createToolResponse({
+        content: [
+          {
+            id: crypto.randomUUID(),
+            type: "text",
+            text: `FunctionNotFoundError: Cannot find the function named ${toolCall.name}`
+          }
+        ],
+        state: "error"
+      });
+      yield notFoundRes;
+      return notFoundRes;
+    }
+    let parsedInput;
+    try {
+      parsedInput = _jsonLoadsWithRepair(toolCall.input);
+      if (tool.inputSchema instanceof import_zod.z.ZodObject) {
+        tool.inputSchema.parse(parsedInput);
+      } else {
+        const validator = new import_json_schema.Validator(tool.inputSchema);
+        const validation = validator.validate(parsedInput);
+        if (!validation.valid) {
+          throw new Error(`Invalid input arguments: ${validation.errors}`);
+        }
+      }
+    } catch (error) {
+      const parseErrorRes = createToolResponse({
+        content: [
+          {
+            id: crypto.randomUUID(),
+            type: "text",
+            text: `InvalidArgumentError: ${String(error)}`
+          }
+        ],
+        state: "error"
+      });
+      yield parseErrorRes;
+      return parseErrorRes;
+    }
+    if (!tool.call) {
+      throw new Error(
+        `Cannot execute external tool '${toolCall.name}' because no call method is defined for it in the toolkit.`
+      );
+    }
+    let finalRes = null;
+    try {
+      const res = await tool.call(parsedInput);
+      if (typeof res === "string") {
+        const textRes = createToolResponse({
+          content: [
+            {
+              id: crypto.randomUUID(),
+              type: "text",
+              text: res
+            }
+          ],
+          state: "success"
+        });
+        yield textRes;
+        finalRes = textRes;
+      } else if (isToolResponse(res)) {
+        yield res;
+        finalRes = res;
+      } else if (Symbol.asyncIterator in res) {
+        const accContent = [];
+        let nextResult = await res.next();
+        while (!nextResult.done) {
+          const currentValue = nextResult.value;
+          nextResult = await res.next();
+          const isLastValue = nextResult.done;
+          if (typeof currentValue === "string") {
+            const itemRes = createToolResponse({
+              content: [
+                {
+                  id: crypto.randomUUID(),
+                  type: "text",
+                  text: currentValue
+                }
+              ],
+              isLast: isLastValue,
+              state: "running"
+            });
+            yield itemRes;
+            accContent.push({
+              id: crypto.randomUUID(),
+              type: "text",
+              text: currentValue
+            });
+          } else if (isToolResponse(currentValue)) {
+            currentValue.isLast = currentValue.isLast ?? isLastValue;
+            yield currentValue;
+            accContent.push(...currentValue.content);
+          }
+        }
+        finalRes = createToolResponse({
+          content: accContent,
+          state: "success"
+        });
+      } else if (Symbol.iterator in res) {
+        const accContent = [];
+        let nextResult = res.next();
+        while (!nextResult.done) {
+          const currentValue = nextResult.value;
+          nextResult = res.next();
+          const isLastValue = nextResult.done;
+          if (typeof currentValue === "string") {
+            const itemRes = createToolResponse({
+              content: [
+                {
+                  id: crypto.randomUUID(),
+                  type: "text",
+                  text: currentValue
+                }
+              ],
+              isLast: isLastValue,
+              state: "running"
+            });
+            yield itemRes;
+            accContent.push({
+              id: crypto.randomUUID(),
+              type: "text",
+              text: currentValue
+            });
+          } else if (isToolResponse(currentValue)) {
+            currentValue.isLast = currentValue.isLast ?? isLastValue;
+            yield currentValue;
+            accContent.push(...currentValue.content);
+          }
+        }
+        finalRes = createToolResponse({
+          content: accContent,
+          state: "success"
+        });
+      } else {
+        const invalidRes = createToolResponse({
+          content: [
+            {
+              id: crypto.randomUUID(),
+              type: "text",
+              text: String(res)
+            }
+          ],
+          state: "running"
+        });
+        yield invalidRes;
+        finalRes = invalidRes;
+      }
+    } catch (error) {
+      const errorRes = createToolResponse({
+        content: [
+          {
+            id: crypto.randomUUID(),
+            type: "text",
+            text: `ToolExecutionError: ${String(error)}`
+          }
+        ],
+        state: "error"
+      });
+      yield errorRes;
+      finalRes = errorRes;
+    }
+    if (!finalRes) {
+      return createToolResponse({
+        content: [
+          {
+            id: crypto.randomUUID(),
+            type: "text",
+            text: `Tool ${toolCall.name} executed successfully.`
+          }
+        ],
+        state: "success"
+      });
+    }
+    const cleanedContent = [];
+    let textBuffer = "";
+    for (const block of finalRes.content) {
+      if (block.type === "text") {
+        textBuffer += block.text;
+      } else {
+        if (textBuffer) {
+          cleanedContent.push({
+            id: crypto.randomUUID(),
+            type: "text",
+            text: textBuffer
+          });
+          textBuffer = "";
+        }
+        cleanedContent.push(block);
+      }
+    }
+    if (textBuffer) {
+      cleanedContent.push({
+        id: crypto.randomUUID(),
+        type: "text",
+        text: textBuffer
+      });
+    }
+    return {
+      ...finalRes,
+      content: cleanedContent
+    };
+  }
+  /**
+   * Returns the JSON schemas for all registered tools in a format compatible with LLM APIs.
+   *
+   * @returns An array of ToolJSONSchema objects
+   */
+  getJSONSchemas() {
+    return this.tools.map((tool) => {
+      const inputSchema = tool.inputSchema instanceof import_zod.z.ZodObject ? tool.inputSchema.toJSONSchema({ target: "openapi-3.0" }) : tool.inputSchema;
+      return {
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: inputSchema
+        }
+      };
+    });
+  }
+  /**
+   * Get the instruction prompt for the agent to use the skills.
+   *
+   * @returns A string containing the instruction prompt of the available skills and how to use them.
+   */
+  getSkillsPrompt() {
+    this._skillCache = {};
+    if (this.skills.length === 0 && this.skillDirs.length === 0) return "";
+    if (typeof process !== "undefined" && process.versions && process.versions.node) {
+      const skillsInfo = [];
+      this.skills.forEach((skillPath) => {
+        const absSkillPath = path.resolve(skillPath);
+        if (!fs.existsSync(absSkillPath) || !fs.statSync(absSkillPath).isDirectory()) {
+          return;
+        }
+        const skillMdPath = path.join(absSkillPath, "SKILL.md");
+        if (!fs.existsSync(skillMdPath)) return;
+        try {
+          const content = fs.readFileSync(skillMdPath, "utf-8");
+          const { data } = (0, import_gray_matter.default)(content);
+          const name = data.name || path.basename(skillPath);
+          const description = data.description || "No description provided";
+          skillsInfo.push({
+            name,
+            description,
+            location: absSkillPath
+          });
+          this._skillCache[name] = absSkillPath;
+        } catch (e) {
+          console.error(`Error reading SKILL.md for skill at ${skillPath}:`, e);
+        }
+      });
+      this.skillDirs.forEach((skillDir) => {
+        const absSkillDir = path.resolve(skillDir);
+        if (!fs.existsSync(absSkillDir) || !fs.statSync(absSkillDir).isDirectory()) {
+          return;
+        }
+        const subdirs = fs.readdirSync(absSkillDir).filter((subdir) => {
+          const subdirPath = path.join(absSkillDir, subdir);
+          return fs.statSync(subdirPath).isDirectory();
+        });
+        subdirs.forEach((subdir) => {
+          const skillMdPath = path.join(absSkillDir, subdir, "SKILL.md");
+          if (!fs.existsSync(skillMdPath)) return;
+          try {
+            const content = fs.readFileSync(skillMdPath, "utf-8");
+            const { data } = (0, import_gray_matter.default)(content);
+            const name = data.name || subdir;
+            const description = data.description || "No description provided";
+            skillsInfo.push({
+              name,
+              description,
+              location: path.join(skillDir, subdir)
+            });
+            this._skillCache[name] = path.join(absSkillDir, subdir);
+          } catch (e) {
+            console.error(
+              `Error reading SKILL.md for skill at ${path.join(skillDir, subdir)}:`,
+              e
+            );
+          }
+        });
+      });
+      if (skillsInfo.length === 0) return "";
+      const skillsXml = skillsInfo.map(
+        (skill) => `<skill>
+<name>${skill.name}</name>
+<description>${skill.description}</description>
+<location>${skill.location}</location>
+</skill>`
+      ).reduce((acc, skillInfo) => acc + `
+${skillInfo}
+`, "");
+      return `<skills-system>
+## What are Skills?
+Skills are packages of domain expertise that extend your capabilities.
+
+## Important: How to Use Skills
+**Skill names are NOT callable functions.** You cannot call a skill directly by its name.
+${skillsXml}
+</skills-system>`;
+    }
+    return "";
+  }
+  /**
+   * The agent skill tool to read SKILL.md file content based on the skill name.
+   * @param root0
+   * @param root0.name
+   * @returns The content of the SKILL.md file for the specified skill, or an error message if the skill is not
+   * found or the SKILL.md file cannot be read.
+   */
+  async _skillTool({ name }) {
+    if (this._skillCache[name]) {
+      const skillDir = this._skillCache[name];
+      const skillMdPath = path.join(skillDir, "SKILL.md");
+      if (!fs.existsSync(skillMdPath)) {
+        try {
+          const fileContent = fs.readFileSync(skillMdPath, "utf-8");
+          return createToolResponse({
+            content: [
+              {
+                id: crypto.randomUUID(),
+                type: "text",
+                text: fileContent
+              }
+            ],
+            state: "success"
+          });
+        } catch {
+        }
+      }
+    }
+    this.getSkillsPrompt();
+    const refreshedSkillDir = this._skillCache[name];
+    if (refreshedSkillDir) {
+      const skillMdPath = path.join(refreshedSkillDir, "SKILL.md");
+      try {
+        const fileContent = fs.readFileSync(skillMdPath, "utf-8");
+        return createToolResponse({
+          content: [
+            {
+              id: crypto.randomUUID(),
+              type: "text",
+              text: fileContent
+            }
+          ],
+          state: "success"
+        });
+      } catch {
+      }
+    }
+    return createToolResponse({
+      content: [
+        {
+          id: crypto.randomUUID(),
+          type: "text",
+          text: `SkillNotFoundError: Cannot find the skill named ${name}, current available skills are ${Object.keys(this._skillCache).join(", ")}`
+        }
+      ],
+      state: "error"
+    });
+  }
+  /**
+   * Checks if a tool requires user confirmation before execution based on its name.
+   * @param toolName The name of the tool to check for user confirmation requirement.
+   * @returns A boolean indicating whether the specified tool requires user confirmation before execution. If the tool is not found, it returns false.
+   */
+  requireUserConfirm(toolName) {
+    const tool = this.tools.find((tool2) => tool2.name === toolName);
+    return tool ? tool.requireUserConfirm ?? false : false;
+  }
+  /**
+   * Checks if a tool requires external execution (e.g., by an MCP client) based on its name.
+   * @param toolName
+   * @returns A boolean indicating whether the specified tool requires external execution. If the tool is not found, it returns false.
+   */
+  requireExternalExecution(toolName) {
+    const tool = this.tools.find((tool2) => tool2.name === toolName);
+    return tool ? !tool.call : false;
+  }
+};
+
+// src/tool/bash.ts
+var import_child_process = require("child_process");
+var import_util = require("util");
+var import_zod2 = require("zod");
+var execAsync = (0, import_util.promisify)(import_child_process.exec);
+
+// src/tool/read.ts
+var import_zod3 = require("zod");
+
+// src/tool/write.ts
+var import_zod4 = require("zod");
+
+// src/tool/edit.ts
+var import_zod5 = require("zod");
+
+// src/tool/glob.ts
+var import_zod6 = require("zod");
+
+// src/tool/grep.ts
+var import_zod7 = require("zod");
+
+// src/tool/task.ts
+var import_zod8 = require("zod");
+
+// src/agent/agent.ts
+var DEFAULT_COMPRESSION_PROMPT = "<system-hint>You have been working on the task described above but have not yet completed it. Now write a continuation summary that will allow you to resume work efficiently in a future context window where the conversation history will be replaced with this summary. Your summary should be structured, concise, and actionable.</system-hint>";
+var DEFAULT_SUMMARY_SCHEMA = import_zod9.z.object({
+  task_overview: import_zod9.z.string().max(300).describe(
+    "The user's core request and success criteria. Any clarifications or constraints they specified"
+  ),
+  current_state: import_zod9.z.string().max(300).describe(
+    "What has been completed so far. File created, modified, or analyzed (with paths if relevant). Key outputs or artifacts produced."
+  ),
+  important_discoveries: import_zod9.z.string().max(300).describe(
+    "Technical constraints or requirements uncovered. Decisions made and their rationale. Errors encountered and how they were resolved. What approaches were tried that didn't work (and why)"
+  ),
+  next_steps: import_zod9.z.string().max(200).describe(
+    "Specific actions needed to complete the task. Any blockers or open questions to resolve. Priority order if multiple steps remain"
+  ),
+  context_to_preserve: import_zod9.z.string().max(300).describe(
+    "User preferences or style requirements. Domain-specific details that aren't obvious. Any promises made to the user"
+  )
+});
+var Agent = class {
+  // Agent configuration
+  name;
+  model;
+  maxIters;
+  toolkit;
+  storage;
+  context;
+  _loaded;
+  _sysPrompt;
+  compressionConfig;
+  // Agent state
+  replyId;
+  curIter;
+  confirmedToolCallIds;
+  curSummary;
+  /**
+   * Initialize an agent instance with the given parameters.
+   *
+   * @param options - The agent configuration options.
+   * @param options.name - The name of the agent.
+   * @param options.sysPrompt - The system prompt for the agent.
+   * @param options.model - The chat model to use.
+   * @param options.maxIters - Maximum iterations (default: 5).
+   * @param options.memory - Memory storage (default: InMemoryMemory).
+   * @param options.toolkit - Toolkit for tools (default: Toolkit).
+   */
+  constructor(options) {
+    if (options.maxIters !== void 0 && options.maxIters <= 0) {
+      throw new Error("maxIters must be greater than 0");
+    }
+    this.name = options.name;
+    this._sysPrompt = options.sysPrompt;
+    this.model = options.model;
+    this.maxIters = options.maxIters ?? 20;
+    this.context = [];
+    this.toolkit = options.toolkit ?? new Toolkit();
+    this.storage = options.storage;
+    this.compressionConfig = options.compressionConfig;
+    this._loaded = false;
+    this.replyId = "";
+    this.curIter = 0;
+    this.confirmedToolCallIds = [];
+    this.curSummary = "";
+  }
+  /**
+   * Load the state from the storage if storage is provided and not loaded yet.
+   */
+  async loadState() {
+    if (this._loaded || !this.storage) return;
+    const { context, metadata } = await this.storage.loadAgentState({ agentId: this.name });
+    console.log(`Load state for agent "${this.name}" from storage:`, { context, metadata });
+    this.context = context;
+    this.replyId = metadata.replyId || "";
+    this.curIter = metadata.curIter || 0;
+    this.curSummary = metadata.curSummary || "";
+    this._loaded = true;
+  }
+  /**
+   * Save the state of the current reply session to storage if storage is provided.
+   */
+  async saveState() {
+    if (!this.storage) return;
+    await this.storage.saveAgentState({
+      agentId: this.name,
+      context: this.context,
+      metadata: {
+        replyId: this.replyId,
+        curIter: this.curIter,
+        curSummary: this.curSummary
+      }
+    });
+  }
+  /**
+   * Get the system prompt of the agent.
+   *
+   * @returns The system prompt string.
+   */
+  get sysPrompt() {
+    const skillsPrompt = this.toolkit.getSkillsPrompt();
+    if (skillsPrompt.length > 0) {
+      return this._sysPrompt + "\n\n" + skillsPrompt;
+    }
+    return this._sysPrompt;
+  }
+  /**
+   * Reply to the given message and stream agent events as they are generated.
+   *
+   * @param options - The reply options containing the incoming message.
+   * @returns An async generator that yields agent events and resolves to the final reply message.
+   */
+  async *replyStream(options) {
+    await this.loadState();
+    try {
+      return yield* this._reply(options);
+    } finally {
+      await this.saveState();
+    }
+  }
+  /**
+   * Reply to the given message, consuming all streamed events internally.
+   *
+   * @param options - The reply options containing the incoming message.
+   * @param options.msgs - The incoming message(s) to reply to.
+   * @returns A promise that resolves to the final reply message.
+   */
+  async reply(options) {
+    await this.loadState();
+    try {
+      const res = this._reply(options);
+      while (true) {
+        const { value, done } = await res.next();
+        if (done) {
+          return value;
+        }
+      }
+    } finally {
+      await this.saveState();
+    }
+  }
+  /**
+   * Save the given content blocks into the context as a new block in the last assistant message,
+   * or create a new assistant message if the last message is not from the assistant or has a different name.
+   * @param blocks
+   * @param usage
+   */
+  _saveToContext(blocks, usage) {
+    const lastMsg = this.context.at(-1);
+    if (this.context.length === 0) {
+      this.context.push(
+        createMsg({ name: this.name, content: blocks, role: "assistant", usage })
+      );
+    } else if (lastMsg && lastMsg.role === "assistant" && lastMsg.name === this.name) {
+      lastMsg.content.push(...blocks);
+      if (usage) {
+        if (!lastMsg.usage) {
+          lastMsg.usage = {
+            inputTokens: 0,
+            outputTokens: 0
+          };
+        }
+        lastMsg.usage.inputTokens = lastMsg.usage.inputTokens + usage.inputTokens;
+        lastMsg.usage.outputTokens = lastMsg.usage.outputTokens + usage.outputTokens;
+      }
+    } else {
+      this.context.push(
+        createMsg({ name: this.name, content: blocks, role: "assistant", usage })
+      );
+    }
+  }
+  /**
+   * Get the pending tool calls that have no results yet in the context.
+   * @returns An array of pending `ToolCallBlock`s that are waiting for execution results.
+   */
+  _getPendingToolCalls() {
+    if (this.context.length === 0) return [];
+    const lastMsg = this.context.at(-1);
+    if (!lastMsg) return [];
+    if (lastMsg.role === "assistant") {
+      const toolCalls = getContentBlocks(lastMsg, "tool_call");
+      const toolResults = getContentBlocks(lastMsg, "tool_result");
+      return toolCalls.filter((toolCall) => !toolResults.some((tr) => tr.id === toolCall.id));
+    }
+    return [];
+  }
+  /**
+   * Get the awaiting tool calls that require user confirmation or external execution.
+   * @returns An array of `ToolCallBlock`s that are waiting for user confirmation or external execution.
+   */
+  _getAwaitingToolCalls() {
+    const pendingToolCalls = this._getPendingToolCalls();
+    const preToolCalls = [];
+    for (const [index, toolCall] of pendingToolCalls.entries()) {
+      if (this.toolkit.requireUserConfirm(toolCall.name) && !this.confirmedToolCallIds.includes(toolCall.id)) {
+        toolCall.awaitUserConfirmation = true;
+        let i = index + 1;
+        for (; i < pendingToolCalls.length; i++) {
+          const nextToolCall = pendingToolCalls[i];
+          if (!this.toolkit.requireUserConfirm(nextToolCall.name) || this.confirmedToolCallIds.includes(nextToolCall.id))
+            break;
+          nextToolCall.awaitUserConfirmation = true;
+        }
+        return {
+          awaitingType: "REQUIRE_USER_CONFIRM" /* REQUIRE_USER_CONFIRM */,
+          expectedEventType: "USER_CONFIRM_RESULT" /* USER_CONFIRM_RESULT */,
+          awaitingToolCalls: pendingToolCalls.slice(index, i),
+          preToolCalls
+        };
+      }
+      if (this.toolkit.requireExternalExecution(toolCall.name)) {
+        let i = index + 1;
+        for (; i < pendingToolCalls.length; i++) {
+          const nextToolCall = pendingToolCalls[i];
+          if (!this.toolkit.requireExternalExecution(nextToolCall.name)) break;
+        }
+        return {
+          awaitingType: "REQUIRE_EXTERNAL_EXECUTION" /* REQUIRE_EXTERNAL_EXECUTION */,
+          expectedEventType: "EXTERNAL_EXECUTION_RESULT" /* EXTERNAL_EXECUTION_RESULT */,
+          awaitingToolCalls: pendingToolCalls.slice(index, i),
+          preToolCalls
+        };
+      }
+      preToolCalls.push(toolCall);
+    }
+    return { awaitingToolCalls: [], preToolCalls };
+  }
+  /**
+   * Core reply logic without middlewares. Observes the incoming message, runs
+   * reasoning/acting iterations up to `maxIters`, and returns the final response.
+   *
+   * @param options - The reply options containing the incoming message.
+   * @returns An async generator that yields agent events and resolves to the final reply message.
+   */
+  async *_reply(options) {
+    const { expectedEventType } = this._getAwaitingToolCalls();
+    if (expectedEventType) {
+      if (!options || !options.event || options.event.type !== expectedEventType) {
+        throw new Error(
+          `Agent is awaiting for '${expectedEventType}' confirmation, but received event of type '${options?.event?.type ?? "none"}'.`
+        );
+      }
+      const event = options.event;
+      if (event.type === "EXTERNAL_EXECUTION_RESULT" /* EXTERNAL_EXECUTION_RESULT */) {
+        this._saveToContext(event.executionResults);
+      } else if (event.type === "USER_CONFIRM_RESULT" /* USER_CONFIRM_RESULT */) {
+        for (const result of event.confirmResults) {
+          if (result.confirmed) {
+            this.confirmedToolCallIds.push(result.toolCall.id);
+          } else {
+            const rejectionRes = `<system-info>**Note** the user rejected the execution of tool "${result.toolCall.name}"!</system-info>`;
+            yield {
+              id: crypto.randomUUID(),
+              createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+              type: "TOOL_RESULT_START" /* TOOL_RESULT_START */,
+              replyId: this.replyId,
+              toolCallId: result.toolCall.id
+            };
+            yield {
+              id: crypto.randomUUID(),
+              createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+              type: "TOOL_RESULT_TEXT_DELTA" /* TOOL_RESULT_TEXT_DELTA */,
+              replyId: this.replyId,
+              toolCallId: result.toolCall.id,
+              delta: rejectionRes
+            };
+            yield {
+              id: crypto.randomUUID(),
+              createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+              type: "TOOL_RESULT_END" /* TOOL_RESULT_END */,
+              replyId: this.replyId,
+              toolCallId: result.toolCall.id,
+              state: "interrupted"
+            };
+            this._saveToContext([
+              {
+                type: "tool_result",
+                id: result.toolCall.id,
+                name: result.toolCall.name,
+                output: [
+                  {
+                    id: crypto.randomUUID(),
+                    type: "text",
+                    text: `<system-info>**Note** the user rejected the execution of tool "${result.toolCall.name}"!</system-info>`
+                  }
+                ],
+                state: "interrupted"
+              }
+            ]);
+          }
+        }
+        const processedToolCallIds = event.confirmResults.map((result) => result.toolCall.id);
+        this.context.at(-1)?.content.forEach((content) => {
+          if (content.type === "tool_call" && processedToolCallIds.includes(content.id)) {
+            delete content.awaitUserConfirmation;
+          }
+        });
+      }
+    } else {
+      this.curIter = 0;
+      this.replyId = crypto.randomUUID();
+      this.confirmedToolCallIds = [];
+      yield {
+        id: crypto.randomUUID(),
+        type: "RUN_STARTED" /* RUN_STARTED */,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        sessionId: "",
+        replyId: this.replyId,
+        name: this.name,
+        role: "assistant"
+      };
+    }
+    if (Array.isArray(options?.msgs)) {
+      this.context.push(...options.msgs);
+    } else if (options?.msgs) {
+      this.context.push(options.msgs);
+    }
+    while (this.curIter < this.maxIters) {
+      const pendingToolCalls = this._getPendingToolCalls();
+      if (pendingToolCalls.length === 0) {
+        await this.compressMemoryIfNeeded();
+        const reasoningResponse = yield* this._reasoning({ toolChoice: "auto" });
+        this._saveToContext(reasoningResponse.content, reasoningResponse.usage);
+      }
+      const { awaitingType, awaitingToolCalls, preToolCalls } = this._getAwaitingToolCalls();
+      for (const toolCall of preToolCalls) {
+        const actingContent = yield* this._acting({ toolCall });
+        this._saveToContext([actingContent]);
+        this.confirmedToolCallIds = this.confirmedToolCallIds.filter(
+          (id) => id !== toolCall.id
+        );
+      }
+      if (awaitingType) {
+        yield {
+          id: crypto.randomUUID(),
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          type: awaitingType,
+          replyId: this.replyId,
+          toolCalls: awaitingToolCalls
+        };
+        return createMsg({
+          name: this.name,
+          content: [
+            {
+              id: crypto.randomUUID(),
+              type: "text",
+              text: awaitingType === "REQUIRE_USER_CONFIRM" /* REQUIRE_USER_CONFIRM */ ? "Waiting for user confirmation ..." : "Waiting for external execution ..."
+            }
+          ],
+          role: "assistant"
+        });
+      }
+      if (preToolCalls.length === 0) break;
+      this.curIter += 1;
+    }
+    if (this.context.at(-1)?.content.at(-1)?.type !== "text") {
+      const summaryResponse = yield* this._reasoning({ toolChoice: "none" });
+      this._saveToContext(summaryResponse.content, summaryResponse.usage);
+    }
+    yield {
+      id: crypto.randomUUID(),
+      type: "RUN_FINISHED" /* RUN_FINISHED */,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      sessionId: "",
+      replyId: this.replyId
+    };
+    return createMsg({
+      id: this.replyId,
+      name: this.name,
+      // Must be a string for the final output message
+      content: [this.context.at(-1).content.at(-1)],
+      role: "assistant"
+    });
+  }
+  /**
+   * Core reasoning logic without middlewares. Calls the model with the current
+   * memory and system prompt, converts the response to agent events, and saves
+   * the resulting message to memory.
+   *
+   * @param options - The reasoning options, including tool choice strategy.
+   * @returns An async generator that yields agent events and resolves to the content blocks of the model response.
+   */
+  async *_reasoning(options) {
+    const tools = this.toolkit.getJSONSchemas();
+    yield {
+      id: crypto.randomUUID(),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      type: "MODEL_CALL_STARTED" /* MODEL_CALL_STARTED */,
+      replyId: this.replyId,
+      modelName: this.model.modelName
+    };
+    const res = await this.model.call({
+      messages: [
+        createMsg({
+          name: "system",
+          content: [{ type: "text", text: this.sysPrompt, id: crypto.randomUUID() }],
+          role: "system"
+        }),
+        ...this.curSummary ? [
+          createMsg({
+            name: "user",
+            content: [
+              { type: "text", text: this.curSummary, id: crypto.randomUUID() }
+            ],
+            role: "user"
+          })
+        ] : [],
+        ...this.context
+      ],
+      tools,
+      toolChoice: options.toolChoice
+    });
+    let blockIds = {
+      textBlockId: null,
+      thinkingBlockId: null,
+      toolCallIds: []
+    };
+    let completedResponse;
+    if (this.model.stream) {
+      while (true) {
+        const { value, done } = await res.next();
+        if (done) {
+          completedResponse = value;
+          break;
+        }
+        const chunk = value;
+        yield* this.convertChatResponseToEvent(blockIds, chunk);
+      }
+    } else {
+      completedResponse = res;
+      yield* this.convertChatResponseToEvent(blockIds, res);
+    }
+    if (blockIds.textBlockId) {
+      yield {
+        id: crypto.randomUUID(),
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        type: "TEXT_BLOCK_END" /* TEXT_BLOCK_END */,
+        replyId: this.replyId,
+        blockId: blockIds.textBlockId
+      };
+    }
+    if (blockIds.thinkingBlockId) {
+      yield {
+        id: crypto.randomUUID(),
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        type: "THINKING_BLOCK_END" /* THINKING_BLOCK_END */,
+        replyId: this.replyId,
+        blockId: blockIds.thinkingBlockId
+      };
+    }
+    if (blockIds.toolCallIds.length > 0) {
+      for (const toolCallId of blockIds.toolCallIds) {
+        yield {
+          id: crypto.randomUUID(),
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          type: "TOOL_CALL_END" /* TOOL_CALL_END */,
+          replyId: this.replyId,
+          toolCallId
+        };
+      }
+    }
+    yield {
+      id: crypto.randomUUID(),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      type: "MODEL_CALL_ENDED" /* MODEL_CALL_ENDED */,
+      replyId: this.replyId,
+      inputTokens: completedResponse.usage?.inputTokens || 0,
+      outputTokens: completedResponse.usage?.outputTokens || 0
+    };
+    return completedResponse;
+  }
+  /**
+   * Core acting logic without middlewares. Executes the given tool call, streams
+   * intermediate tool result events, and saves the final tool response to memory.
+   *
+   * @param options - The acting options containing the tool call to execute.
+   * @returns An async generator that yields tool result events.
+   */
+  async *_acting(options) {
+    const res = this.toolkit.callToolFunction(options.toolCall);
+    yield {
+      type: "TOOL_RESULT_START" /* TOOL_RESULT_START */,
+      id: crypto.randomUUID(),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      replyId: this.replyId,
+      toolCallId: options.toolCall.id,
+      toolCallName: options.toolCall.name
+    };
+    while (true) {
+      const { value, done } = await res.next();
+      if (done) {
+        return {
+          type: "tool_result",
+          id: options.toolCall.id,
+          name: options.toolCall.name,
+          output: value.content,
+          state: value.state
+        };
+      }
+      yield* this.convertToolResponseToEvent(options.toolCall, value);
+    }
+  }
+  /**
+   * Receive external observation message(s) and save them into memory.
+   *
+   * @param options - The observe options containing the message to store.
+   * @returns A promise that resolves when the message has been saved to memory.
+   */
+  async _observe(options) {
+    await this.loadState();
+    if (Array.isArray(options.msg)) {
+      this.context.push(...options.msg);
+    } else if (options.msg) {
+      this.context.push(options.msg);
+    }
+  }
+  /**
+   * Convert a `ChatResponse` chunk into a sequence of typed agent events.
+   * Tracks message IDs across calls via the mutable `responseId` object so that
+   * start/content/end events are correctly correlated.
+   *
+   * @param responseId - Mutable object tracking IDs for the current text, thinking, and tool-call messages.
+   * @param responseId.textMessageId - ID of the in-progress text message, or `null` if not yet started.
+   * @param responseId.thinkingMessageId - ID of the in-progress thinking message, or `null` if not yet started.
+   * @param responseId.textBlockId
+   * @param responseId.thinkingBlockId
+   * @param responseId.toolCallIds - List of tool-call IDs seen so far in this response.
+   * @param chunk - The chat response chunk to convert.
+   * @returns An async generator that yields the corresponding agent events.
+   */
+  async *convertChatResponseToEvent(responseId, chunk) {
+    for (const block of chunk.content) {
+      switch (block.type) {
+        case "text":
+          if (responseId.textBlockId === null) {
+            responseId.textBlockId = crypto.randomUUID();
+            yield {
+              id: crypto.randomUUID(),
+              createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+              type: "TEXT_BLOCK_START" /* TEXT_BLOCK_START */,
+              replyId: this.replyId,
+              blockId: responseId.textBlockId
+            };
+          }
+          yield {
+            id: crypto.randomUUID(),
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            type: "TEXT_BLOCK_DELTA" /* TEXT_BLOCK_DELTA */,
+            replyId: this.replyId,
+            blockId: responseId.textBlockId,
+            delta: block.text
+          };
+          break;
+        case "thinking":
+          if (responseId.thinkingBlockId === null) {
+            responseId.thinkingBlockId = crypto.randomUUID();
+            yield {
+              id: crypto.randomUUID(),
+              createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+              type: "THINKING_BLOCK_START" /* THINKING_BLOCK_START */,
+              replyId: this.replyId,
+              blockId: responseId.thinkingBlockId
+            };
+          }
+          yield {
+            id: crypto.randomUUID(),
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            type: "THINKING_BLOCK_DELTA" /* THINKING_BLOCK_DELTA */,
+            replyId: this.replyId,
+            blockId: responseId.thinkingBlockId,
+            delta: block.thinking
+          };
+          break;
+        case "tool_call":
+          if (!responseId.toolCallIds.includes(block.id)) {
+            responseId.toolCallIds.push(block.id);
+            yield {
+              id: crypto.randomUUID(),
+              type: "TOOL_CALL_START" /* TOOL_CALL_START */,
+              createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+              replyId: this.replyId,
+              toolCallId: block.id,
+              toolCallName: block.name
+            };
+          }
+          yield {
+            id: crypto.randomUUID(),
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            type: "TOOL_CALL_DELTA" /* TOOL_CALL_DELTA */,
+            delta: block.input,
+            replyId: this.replyId,
+            toolCallId: block.id
+          };
+      }
+    }
+  }
+  /**
+   * Convert a `ToolResponse` into a sequence of typed agent events, followed by
+   * a final `TOOL_RESULT_END` event.
+   *
+   * @param toolCall - The original tool-use block that triggered this response.
+   * @param toolRes - The tool response containing result content blocks.
+   * @returns An async generator that yields tool result events.
+   */
+  async *convertToolResponseToEvent(toolCall, toolRes) {
+    for (const block of toolRes.content) {
+      switch (block.type) {
+        case "text":
+          yield {
+            id: crypto.randomUUID(),
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            type: "TOOL_RESULT_TEXT_DELTA" /* TOOL_RESULT_TEXT_DELTA */,
+            replyId: this.replyId,
+            toolCallId: toolCall.id,
+            delta: block.text
+          };
+          break;
+        case "data":
+          if (block.source.type === "base64") {
+            yield {
+              id: crypto.randomUUID(),
+              createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+              type: "TOOL_RESULT_BINARY_DELTA" /* TOOL_RESULT_BINARY_DELTA */,
+              replyId: this.replyId,
+              toolCallId: toolCall.id,
+              mediaType: block.source.mediaType,
+              data: block.source.data
+            };
+          } else if (block.source.type === "url") {
+            yield {
+              id: crypto.randomUUID(),
+              createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+              type: "TOOL_RESULT_BINARY_DELTA" /* TOOL_RESULT_BINARY_DELTA */,
+              replyId: this.replyId,
+              toolCallId: toolCall.id,
+              mediaType: block.source.mediaType,
+              url: block.source.url
+            };
+          }
+          break;
+      }
+    }
+    yield {
+      id: crypto.randomUUID(),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      type: "TOOL_RESULT_END" /* TOOL_RESULT_END */,
+      replyId: this.replyId,
+      toolCallId: toolCall.id,
+      state: toolRes.state
+    };
+  }
+  /**
+   * Convert the agent instance to a JSON-serializable object.
+   * @returns An object containing the agent's name and system prompt.
+   */
+  async toJSON() {
+    return {
+      replyId: this.replyId,
+      confirmedToolCallIds: this.confirmedToolCallIds,
+      curIter: this.curIter
+    };
+  }
+  /**
+   * Split the current context into two parts: one part that needs to be compressed and another part that should be reserved based on the compression configuration. The method calculates how many recent "units" (blocks or tool call pairs) to keep uncompressed according to the `keepRecent` setting in the compression configuration, and ensures that tool calls and their corresponding results are not separated during the split.
+   * @returns An object containing the `toCompressedContext` which includes the messages that need to be compressed, and the `reservedContext` which includes the recent messages that should be kept uncompressed.
+   */
+  _splitContextForCompression() {
+    let toCompressedContext = [];
+    let reservedContext = [];
+    const keepRecent = this.compressionConfig.keepRecent ?? 0;
+    const nBlocks = this.context.map((msg) => msg.content.length).reduce((a, b) => a + b, 0);
+    const toCompressedBlockNumber = nBlocks - keepRecent > 0 ? nBlocks - keepRecent : 0;
+    let currentCompressedBlocks = 0;
+    for (const [index, msg] of this.context.entries()) {
+      if (currentCompressedBlocks + msg.content.length <= toCompressedBlockNumber) {
+        toCompressedContext.push(msg);
+        currentCompressedBlocks += msg.content.length;
+      } else {
+        const reservedBlocks = msg.content.slice(
+          toCompressedBlockNumber - currentCompressedBlocks
+        );
+        const unPairedToolResultIds = /* @__PURE__ */ new Set();
+        for (const block of reservedBlocks) {
+          if (block.type == "tool_call") {
+            unPairedToolResultIds.add(block.id);
+          } else if (block.type == "tool_result") {
+            if (unPairedToolResultIds.has(block.id)) {
+              unPairedToolResultIds.delete(block.id);
+            }
+          }
+        }
+        let i = toCompressedBlockNumber - currentCompressedBlocks - 1;
+        for (; i >= 0; i--) {
+          const block = msg.content[i];
+          if (block.type === "tool_call" && unPairedToolResultIds.has(block.id)) {
+            unPairedToolResultIds.delete(block.id);
+          }
+          if (unPairedToolResultIds.size === 0) break;
+        }
+        if (i <= 0) {
+          reservedContext.push(msg);
+          break;
+        }
+        const lastMsg = { ...msg };
+        lastMsg.content = msg.content.slice(0, i);
+        toCompressedContext.push(lastMsg);
+        const reservedMsg = { ...msg };
+        reservedMsg.content = msg.content.slice(i);
+        reservedContext.push(reservedMsg);
+        reservedContext.push(...this.context.slice(index + 1));
+        break;
+      }
+    }
+    return { toCompressedContext, reservedContext };
+  }
+  /**
+   * Compress the agent's memory using the specified compression model (if provided) or the original model.
+   */
+  async compressMemoryIfNeeded() {
+    if (!this.compressionConfig || !this.compressionConfig.enabled) return;
+    const { toCompressedContext, reservedContext } = this._splitContextForCompression();
+    if (toCompressedContext.length <= 0 || toCompressedContext.length === 1 && toCompressedContext.at(0)?.content.length === 1)
+      return;
+    const messages = [
+      createMsg({
+        name: "system",
+        content: [{ type: "text", text: this.sysPrompt, id: crypto.randomUUID() }],
+        role: "system"
+      }),
+      ...toCompressedContext,
+      // instructions to compress the context into a summary
+      createMsg({
+        name: "user",
+        content: [
+          {
+            id: crypto.randomUUID(),
+            type: "text",
+            text: this.compressionConfig.compressionPrompt || DEFAULT_COMPRESSION_PROMPT
+          }
+        ],
+        role: "user"
+      })
+    ];
+    const nTokens = await this.model.countTokens({
+      messages,
+      tools: this.toolkit.getJSONSchemas()
+    });
+    console.debug(`[AGENT ${this.name}] Current context token count: ${nTokens}.`);
+    if (nTokens <= this.compressionConfig.triggerThreshold) return;
+    console.log(
+      `[AGENT ${this.name}] Compressing memory with ${toCompressedContext.length} messages.`
+    );
+    const res = await this.model.callStructured({
+      messages: [
+        createMsg({
+          name: "system",
+          content: [{ type: "text", text: this.sysPrompt, id: crypto.randomUUID() }],
+          role: "system"
+        }),
+        ...toCompressedContext,
+        // instructions to compress the context into a summary
+        createMsg({
+          name: "user",
+          content: [
+            {
+              id: crypto.randomUUID(),
+              type: "text",
+              text: this.compressionConfig.compressionPrompt || DEFAULT_COMPRESSION_PROMPT
+            }
+          ],
+          role: "user"
+        })
+      ],
+      schema: this.compressionConfig.summarySchema || DEFAULT_SUMMARY_SCHEMA
+    });
+    let summaryText = "<system-reminder>Here is a summary of your previous work\n";
+    for (const [key, value] of Object.entries(res.content)) {
+      summaryText += `# ${key}
+${value}
+`;
+    }
+    summaryText += "</system-reminder>";
+    console.debug(`[AGENT ${this.name}] Compression summary: ${summaryText}`);
+    this.context = reservedContext;
+    this.curSummary = summaryText;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Agent
+});
+//# sourceMappingURL=index.js.map