@kiturone/kapibala 0.0.1

package/dist/index.cjs

@@ -0,0 +1,1940 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AbortError: () => AbortError,
+  AgentLoop: () => AgentLoop,
+  AgentSession: () => AgentSession,
+  DEFAULT_CONTEXT_WINDOW_TOKENS: () => DEFAULT_CONTEXT_WINDOW_TOKENS,
+  FatalError: () => FatalError,
+  HookRegistry: () => HookRegistry,
+  JSONLMessageStore: () => JSONLMessageStore,
+  KapibalaError: () => KapibalaError,
+  ModelError: () => ModelError,
+  OpenAICompatibleProvider: () => OpenAICompatibleProvider,
+  PathSandbox: () => PathSandbox,
+  PromptAssembler: () => PromptAssembler,
+  SessionBusyError: () => SessionBusyError,
+  SimpleModelRouter: () => SimpleModelRouter,
+  ToolError: () => ToolError,
+  ToolExecutor: () => ToolExecutor,
+  ToolNotFound: () => ToolNotFound,
+  ToolRegistry: () => ToolRegistry,
+  TransportError: () => TransportError,
+  builtinTools: () => builtinTools,
+  defineTool: () => defineTool,
+  editFileTool: () => editFileTool,
+  globTool: () => globTool,
+  grepTool: () => grepTool,
+  isTextBlock: () => isTextBlock,
+  isThinkingBlock: () => isThinkingBlock,
+  isToolResultBlock: () => isToolResultBlock,
+  isToolUseBlock: () => isToolUseBlock,
+  readFileTool: () => readFileTool,
+  resolveContextWindow: () => resolveContextWindow,
+  toToolDefinition: () => toToolDefinition,
+  writeFileTool: () => writeFileTool
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types/index.ts
+function isTextBlock(block) {
+  return block.type === "text";
+}
+function isToolUseBlock(block) {
+  return block.type === "tool_use";
+}
+function isToolResultBlock(block) {
+  return block.type === "tool_result";
+}
+function isThinkingBlock(block) {
+  return block.type === "thinking";
+}
+
+// src/errors/index.ts
+var KapibalaError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "KapibalaError";
+  }
+};
+var ModelError = class extends KapibalaError {
+  status;
+  retryable;
+  constructor(message, options) {
+    super(message);
+    this.name = "ModelError";
+    this.status = options?.status;
+    this.retryable = options?.retryable ?? (options?.status ? [429, 500, 502, 503, 504, 529].includes(options.status) : false);
+  }
+};
+var TransportError = class extends KapibalaError {
+  retryable;
+  constructor(message, retryable = true) {
+    super(message);
+    this.name = "TransportError";
+    this.retryable = retryable;
+  }
+};
+var ToolError = class extends KapibalaError {
+  constructor(message) {
+    super(message);
+    this.name = "ToolError";
+  }
+};
+var ToolNotFound = class extends KapibalaError {
+  toolName;
+  availableTools;
+  constructor(toolName, availableTools = []) {
+    super(`Tool '${toolName}' not found. Available tools: ${availableTools.join(", ") || "none"}`);
+    this.name = "ToolNotFound";
+    this.toolName = toolName;
+    this.availableTools = availableTools;
+  }
+};
+var AbortError = class extends KapibalaError {
+  constructor(message = "Execution aborted by user") {
+    super(message);
+    this.name = "AbortError";
+  }
+};
+var FatalError = class extends KapibalaError {
+  constructor(message) {
+    super(message);
+    this.name = "FatalError";
+  }
+};
+var SessionBusyError = class extends KapibalaError {
+  constructor(operation) {
+    super(`Session is already running; cannot ${operation}`);
+    this.name = "SessionBusyError";
+  }
+};
+
+// src/security/sandbox.ts
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path = __toESM(require("path"), 1);
+function tryRealpath(target) {
+  try {
+    return import_node_fs.default.realpathSync(target);
+  } catch {
+    return void 0;
+  }
+}
+var PathSandbox = class {
+  rootDir;
+  allowSymlinks;
+  cachedRealRootDir;
+  constructor(config) {
+    this.rootDir = import_node_path.default.resolve(config.rootDir);
+    this.allowSymlinks = config.allowSymlinks ?? false;
+  }
+  /**
+   * rootDir 的物理路径。rootDir 自身可能是一个符号链接(如 macOS 的 /var → /private/var)，
+   * 必须先归一化，否则物理路径与 rootDir 比较时会产生误判。
+   */
+  get realRootDir() {
+    if (this.cachedRealRootDir === void 0) {
+      this.cachedRealRootDir = tryRealpath(this.rootDir) ?? this.rootDir;
+    }
+    return this.cachedRealRootDir;
+  }
+  /**
+   * 检查并解析安全路径
+   * 1. 解析相对路径为相对于 rootDir 的绝对路径
+   * 2. 词法检查：`..` 归一化后必须仍在 rootDir 内
+   * 3. 物理检查：解析符号链接后的真实路径必须仍在 rootDir 内
+   */
+  resolveSafePath(targetPath) {
+    if (!targetPath || typeof targetPath !== "string") {
+      throw new ToolError("Invalid path: path must be a non-empty string");
+    }
+    const resolvedPath = import_node_path.default.isAbsolute(targetPath) ? import_node_path.default.resolve(targetPath) : import_node_path.default.resolve(this.rootDir, targetPath);
+    const relative = import_node_path.default.relative(this.rootDir, resolvedPath);
+    if (relative.startsWith("..") || import_node_path.default.isAbsolute(relative)) {
+      throw new ToolError(
+        `Access denied: path '${targetPath}' escapes root directory '${this.rootDir}'`
+      );
+    }
+    const physicalPath = this.toPhysicalPath(resolvedPath);
+    const physicalRelative = import_node_path.default.relative(this.realRootDir, physicalPath);
+    if (physicalRelative.startsWith("..") || import_node_path.default.isAbsolute(physicalRelative)) {
+      throw new ToolError(
+        `Access denied: path '${targetPath}' resolves outside root directory '${this.rootDir}' (via symlink)`
+      );
+    }
+    return resolvedPath;
+  }
+  /**
+   * 把词法路径映射为物理路径。
+   *
+   * 关键点在于**向上回溯到最近一个真实存在的祖先**再取 realpath，然后把尚未存在的尾段拼回去：
+   * - 目标已存在 → 直接 realpath，符号链接立刻被展开；
+   * - 目标不存在(典型场景：write_file 新建文件) → 若只看目标本身，所有校验都会被跳过，
+   *   于是 `write_file('linkDir/new.txt')` 可以借道指向外部的 linkDir 越界写入。
+   *   回溯到 linkDir 取 realpath 即可识破这种穿透。
+   */
+  toPhysicalPath(resolvedPath) {
+    const pendingSegments = [];
+    let probe = resolvedPath;
+    while (true) {
+      let stat;
+      try {
+        stat = import_node_fs.default.lstatSync(probe);
+      } catch {
+        stat = void 0;
+      }
+      if (stat) {
+        const real = tryRealpath(probe);
+        if (real === void 0) {
+          throw new ToolError(
+            `Access denied: cannot resolve real path for '${resolvedPath}' (broken or unresolvable symlink)`
+          );
+        }
+        return pendingSegments.length > 0 ? import_node_path.default.join(real, ...pendingSegments) : real;
+      }
+      const parent = import_node_path.default.dirname(probe);
+      if (parent === probe) {
+        return resolvedPath;
+      }
+      pendingSegments.unshift(import_node_path.default.basename(probe));
+      probe = parent;
+    }
+  }
+};
+
+// src/tools/index.ts
+function defineTool(tool) {
+  return tool;
+}
+function toToolDefinition(tool) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.parameters
+  };
+}
+
+// src/tools/registry.ts
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  toolSources = /* @__PURE__ */ new Map();
+  // toolName -> source
+  conflictPolicy;
+  constructor(options) {
+    this.conflictPolicy = options?.conflictPolicy ?? "error";
+  }
+  register(tool, opts) {
+    const source = opts?.source ?? tool.metadata?.source ?? "builtin";
+    const existing = this.tools.get(tool.name);
+    if (existing) {
+      if (this.conflictPolicy === "error") {
+        throw new Error(
+          `Tool name conflict: '${tool.name}' is already registered by '${this.toolSources.get(tool.name)}'`
+        );
+      }
+      if (this.conflictPolicy === "prefer-builtin" && this.toolSources.get(tool.name) === "builtin") {
+        return;
+      }
+    }
+    this.tools.set(tool.name, tool);
+    this.toolSources.set(tool.name, source);
+  }
+  registerSource(source, tools) {
+    for (const tool of tools) {
+      this.register(tool, { source });
+    }
+  }
+  unregisterSource(source) {
+    for (const [name, s] of this.toolSources.entries()) {
+      if (s === source) {
+        this.tools.delete(name);
+        this.toolSources.delete(name);
+      }
+    }
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  resolve(name) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      throw new ToolNotFound(name, Array.from(this.tools.keys()));
+    }
+    return tool;
+  }
+  list() {
+    return Array.from(this.tools.values());
+  }
+  definitions() {
+    return this.list().map(toToolDefinition);
+  }
+};
+
+// src/tools/builtin/fs.ts
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+var sandboxCache = /* @__PURE__ */ new Map();
+function getSandbox(rootDir) {
+  let sandbox = sandboxCache.get(rootDir);
+  if (!sandbox) {
+    sandbox = new PathSandbox({ rootDir });
+    sandboxCache.set(rootDir, sandbox);
+  }
+  return sandbox;
+}
+var readFileTool = defineTool({
+  name: "read_file",
+  description: "Read the text contents of a file at the specified path.",
+  metadata: {
+    source: "builtin",
+    permissions: ["fs:read"]
+  },
+  parameters: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "The path of the file to read (relative to workspace or absolute)."
+      },
+      startLine: {
+        type: "integer",
+        description: "Optional 1-based start line to read from."
+      },
+      endLine: {
+        type: "integer",
+        description: "Optional 1-based end line to read to (inclusive)."
+      }
+    },
+    required: ["path"]
+  },
+  async execute(input, ctx) {
+    const sandbox = getSandbox(ctx.rootDir);
+    const safePath = sandbox.resolveSafePath(input.path);
+    if (!import_node_fs2.default.existsSync(safePath)) {
+      throw new ToolError(`File not found: ${input.path}`);
+    }
+    const stat = import_node_fs2.default.statSync(safePath);
+    if (stat.isDirectory()) {
+      throw new ToolError(`Target path is a directory, not a file: ${input.path}`);
+    }
+    const maxReadBytes = 512 * 1024;
+    const hasLineRange = input.startLine !== void 0 || input.endLine !== void 0;
+    if (stat.size > maxReadBytes && !hasLineRange) {
+      throw new ToolError(
+        `File too large to read in one call: ${input.path} (${stat.size} bytes > ${maxReadBytes}). Use startLine/endLine to read in chunks, or narrow the file first.`
+      );
+    }
+    const prefixSize = Math.min(stat.size, 8192);
+    const prefix = Buffer.alloc(prefixSize);
+    const fileDescriptor = import_node_fs2.default.openSync(safePath, "r");
+    try {
+      import_node_fs2.default.readSync(fileDescriptor, prefix, 0, prefixSize, 0);
+    } finally {
+      import_node_fs2.default.closeSync(fileDescriptor);
+    }
+    if (prefix.includes(0)) {
+      throw new ToolError(`Cannot read binary file: ${input.path}`);
+    }
+    if (hasLineRange) {
+      return readFileLineRange(
+        safePath,
+        Math.max(1, input.startLine ?? 1),
+        input.endLine,
+        maxReadBytes
+      );
+    }
+    return import_node_fs2.default.readFileSync(safePath, "utf-8");
+  }
+});
+async function readFileLineRange(filePath, startLine, endLine, maxReadBytes) {
+  if (endLine !== void 0 && endLine < startLine) return "";
+  const selectedLines = [];
+  let selectedBytes = 0;
+  let currentLine = 1;
+  let pending = "";
+  let reachedEnd = false;
+  const stream = import_node_fs2.default.createReadStream(filePath, { encoding: "utf-8" });
+  const selectLine = (line) => {
+    if (currentLine >= startLine && (endLine === void 0 || currentLine <= endLine)) {
+      const addedBytes = Buffer.byteLength(line, "utf-8") + (selectedLines.length > 0 ? 1 : 0);
+      if (selectedBytes + addedBytes > maxReadBytes) {
+        throw new ToolError(
+          `Requested line range exceeds ${maxReadBytes} bytes. Use a narrower startLine/endLine range.`
+        );
+      }
+      selectedLines.push(line);
+      selectedBytes += addedBytes;
+    }
+    if (Buffer.byteLength(line, "utf-8") > maxReadBytes) {
+      throw new ToolError(`File line exceeds ${maxReadBytes} byte limit`);
+    }
+    currentLine++;
+    reachedEnd = endLine !== void 0 && currentLine > endLine;
+  };
+  try {
+    for await (const chunk of stream) {
+      pending += chunk;
+      let newlineIndex = pending.indexOf("\n");
+      while (newlineIndex >= 0) {
+        selectLine(pending.slice(0, newlineIndex));
+        pending = pending.slice(newlineIndex + 1);
+        if (reachedEnd) break;
+        newlineIndex = pending.indexOf("\n");
+      }
+      if (Buffer.byteLength(pending, "utf-8") > maxReadBytes) {
+        throw new ToolError(`File line exceeds ${maxReadBytes} byte limit`);
+      }
+      if (reachedEnd) break;
+    }
+    if (!reachedEnd) selectLine(pending);
+  } finally {
+    stream.destroy();
+  }
+  return selectedLines.join("\n");
+}
+var writeFileTool = defineTool({
+  name: "write_file",
+  description: "Create a new file or overwrite an existing file with new content.",
+  metadata: {
+    source: "builtin",
+    permissions: ["fs:write"]
+  },
+  parameters: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "The path of the file to write to."
+      },
+      content: {
+        type: "string",
+        description: "The full text content to write into the file."
+      }
+    },
+    required: ["path", "content"]
+  },
+  async execute(input, ctx) {
+    const sandbox = getSandbox(ctx.rootDir);
+    const safePath = sandbox.resolveSafePath(input.path);
+    const dir = import_node_path2.default.dirname(safePath);
+    if (!import_node_fs2.default.existsSync(dir)) {
+      import_node_fs2.default.mkdirSync(dir, { recursive: true });
+    }
+    import_node_fs2.default.writeFileSync(safePath, input.content, "utf-8");
+    return `Successfully wrote ${Buffer.byteLength(input.content, "utf-8")} bytes to ${input.path}`;
+  }
+});
+var editFileTool = defineTool({
+  name: "edit_file",
+  description: "Perform an exact string replacement in a file.",
+  metadata: {
+    source: "builtin",
+    permissions: ["fs:write"]
+  },
+  parameters: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "The path of the file to edit."
+      },
+      targetContent: {
+        type: "string",
+        description: "The exact string snippet in the file to be replaced."
+      },
+      replacementContent: {
+        type: "string",
+        description: "The new replacement content to put in place of targetContent."
+      }
+    },
+    required: ["path", "targetContent", "replacementContent"]
+  },
+  async execute(input, ctx) {
+    const sandbox = getSandbox(ctx.rootDir);
+    const safePath = sandbox.resolveSafePath(input.path);
+    if (!import_node_fs2.default.existsSync(safePath)) {
+      throw new ToolError(`File not found: ${input.path}`);
+    }
+    if (!input.targetContent) {
+      throw new ToolError("Target content must not be empty");
+    }
+    const content = import_node_fs2.default.readFileSync(safePath, "utf-8");
+    if (!content.includes(input.targetContent)) {
+      throw new ToolError(
+        `Target content not found in ${input.path}. Ensure exact indentation and characters.`
+      );
+    }
+    const occurrences = content.split(input.targetContent).length - 1;
+    if (occurrences > 1) {
+      throw new ToolError(
+        `Target content occurs ${occurrences} times in ${input.path}. Please provide more surrounding context to match uniquely.`
+      );
+    }
+    const newContent = content.replace(input.targetContent, () => input.replacementContent);
+    import_node_fs2.default.writeFileSync(safePath, newContent, "utf-8");
+    return `Successfully replaced target content in ${input.path}`;
+  }
+});
+var globTool = defineTool({
+  name: "glob",
+  description: "Search for files matching a pattern within a directory.",
+  metadata: {
+    source: "builtin",
+    permissions: ["fs:read"]
+  },
+  parameters: {
+    type: "object",
+    properties: {
+      pattern: {
+        type: "string",
+        description: 'A glob pattern or filename prefix/suffix to match (e.g. "*.ts", "src/**").'
+      },
+      subDirectory: {
+        type: "string",
+        description: "Optional sub-directory to restrict search within."
+      }
+    },
+    required: ["pattern"]
+  },
+  async execute(input, ctx) {
+    const sandbox = getSandbox(ctx.rootDir);
+    const searchRoot = input.subDirectory ? sandbox.resolveSafePath(input.subDirectory) : ctx.rootDir;
+    if (!import_node_fs2.default.existsSync(searchRoot)) {
+      throw new ToolError(`Directory not found: ${input.subDirectory ?? "."}`);
+    }
+    const results = [];
+    const maxResults = 100;
+    function walk(currentDir) {
+      if (results.length >= maxResults) return;
+      const entries = import_node_fs2.default.readdirSync(currentDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist") {
+          continue;
+        }
+        const fullPath = import_node_path2.default.join(currentDir, entry.name);
+        const relPath = import_node_path2.default.relative(ctx.rootDir, fullPath).replace(/\\/g, "/");
+        if (entry.isDirectory()) {
+          walk(fullPath);
+        } else {
+          if (simpleMatch(entry.name, input.pattern) || simpleMatch(relPath, input.pattern)) {
+            results.push(relPath);
+            if (results.length >= maxResults) return;
+          }
+        }
+      }
+    }
+    walk(searchRoot);
+    return results.length > 0 ? results.join("\n") : "No matching files found.";
+  }
+});
+var grepTool = defineTool({
+  name: "grep",
+  description: "Search for case-insensitive literal text in files within workspace.",
+  metadata: {
+    source: "builtin",
+    permissions: ["fs:read"]
+  },
+  parameters: {
+    type: "object",
+    properties: {
+      pattern: {
+        type: "string",
+        description: "Literal text to search for. Regular-expression characters have no special meaning."
+      },
+      path: {
+        type: "string",
+        description: "File or directory path to search within."
+      }
+    },
+    required: ["pattern"]
+  },
+  async execute(input, ctx) {
+    if (ctx.signal?.aborted) throw new AbortError();
+    const sandbox = getSandbox(ctx.rootDir);
+    const target = input.path ? sandbox.resolveSafePath(input.path) : ctx.rootDir;
+    if (!import_node_fs2.default.existsSync(target)) {
+      throw new ToolError(`Path not found: ${input.path ?? "."}`);
+    }
+    if (!input.pattern.trim()) throw new ToolError("Search pattern must not be empty");
+    const needle = input.pattern.toLowerCase();
+    const matches = [];
+    const maxMatches = 50;
+    let outputBytes = 0;
+    async function searchFile(filePath) {
+      if (matches.length >= maxMatches) return;
+      const maxLineBytes = 512 * 1024;
+      const maxOutputBytes = 512 * 1024;
+      const stream = import_node_fs2.default.createReadStream(filePath, { encoding: "utf-8" });
+      const relPath = import_node_path2.default.relative(ctx.rootDir, filePath).replace(/\\/g, "/");
+      let lineNumber = 0;
+      let pending = "";
+      let skippingLongLine = false;
+      const inspectLine = (line) => {
+        lineNumber++;
+        if (skippingLongLine || Buffer.byteLength(line, "utf-8") > maxLineBytes) {
+          skippingLongLine = false;
+          if (line.toLowerCase().includes(needle)) {
+            throw new ToolError(`Search line exceeds ${maxLineBytes} byte limit`);
+          }
+          return;
+        }
+        if (!line.toLowerCase().includes(needle)) return;
+        const match = `${relPath}:${lineNumber}: ${line.trim()}`;
+        const bytes = Buffer.byteLength(match, "utf-8") + (matches.length > 0 ? 1 : 0);
+        if (outputBytes + bytes > maxOutputBytes) {
+          throw new ToolError(`Search results exceed ${maxOutputBytes} byte limit`);
+        }
+        matches.push(match);
+        outputBytes += bytes;
+      };
+      try {
+        for await (const chunk of stream) {
+          if (ctx.signal?.aborted) throw new AbortError();
+          pending += chunk;
+          let newlineIndex = pending.indexOf("\n");
+          while (newlineIndex >= 0) {
+            inspectLine(pending.slice(0, newlineIndex).replace(/\r$/, ""));
+            pending = pending.slice(newlineIndex + 1);
+            if (matches.length >= maxMatches) return;
+            newlineIndex = pending.indexOf("\n");
+          }
+          if (Buffer.byteLength(pending, "utf-8") > maxLineBytes) {
+            if (pending.toLowerCase().includes(needle)) {
+              throw new ToolError(`Search line exceeds ${maxLineBytes} byte limit`);
+            }
+            skippingLongLine = true;
+            pending = needle.length > 1 ? pending.slice(1 - needle.length) : "";
+          }
+        }
+        if (pending.length > 0) inspectLine(pending.replace(/\r$/, ""));
+      } catch (error) {
+        if (error instanceof AbortError || error instanceof ToolError) throw error;
+      } finally {
+        stream.destroy();
+      }
+    }
+    async function walk(dirPath) {
+      if (matches.length >= maxMatches) return;
+      const entries = import_node_fs2.default.readdirSync(dirPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (ctx.signal?.aborted) throw new AbortError();
+        if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist") {
+          continue;
+        }
+        if (entry.isSymbolicLink()) continue;
+        const fullPath = import_node_path2.default.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+          await walk(fullPath);
+        } else {
+          await searchFile(fullPath);
+        }
+        if (matches.length >= maxMatches) return;
+      }
+    }
+    const stat = import_node_fs2.default.statSync(target);
+    if (stat.isFile()) {
+      await searchFile(target);
+    } else {
+      await walk(target);
+    }
+    return matches.length > 0 ? matches.join("\n") : "No matches found.";
+  }
+});
+function simpleMatch(str, pattern) {
+  if (pattern === "*" || pattern === "**") return true;
+  const escaped = pattern.replace(
+    /[.+?^${}()|[\]\\]|\*{1,2}/g,
+    (match) => match === "**" ? ".*" : match === "*" ? "[^/]*" : `\\${match}`
+  );
+  return new RegExp(`^${escaped}$`, "i").test(str);
+}
+var builtinTools = [readFileTool, writeFileTool, editFileTool, globTool, grepTool];
+
+// src/hooks/registry.ts
+var HookRegistry = class {
+  hooks = {};
+  on(point, handler) {
+    if (!this.hooks[point]) {
+      this.hooks[point] = [];
+    }
+    this.hooks[point].push(handler);
+  }
+  get(point) {
+    return this.hooks[point] ?? [];
+  }
+  async emit(point, ctx, ...args) {
+    const handlers = this.get(point);
+    for (const handler of handlers) {
+      await handler(ctx, ...args);
+    }
+  }
+};
+
+// src/executor/index.ts
+var DEFAULT_TOOL_TIMEOUT_MS = 12e4;
+var ToolExecutor = class {
+  tools;
+  hooks;
+  rootDir;
+  signal;
+  logger;
+  toolTimeoutMs;
+  constructor(options) {
+    this.tools = options.tools;
+    this.hooks = options.hooks;
+    this.rootDir = options.rootDir;
+    this.signal = options.signal;
+    this.logger = options.logger;
+    this.toolTimeoutMs = options.toolTimeoutMs ?? DEFAULT_TOOL_TIMEOUT_MS;
+  }
+  async runAll(calls) {
+    const results = [];
+    for (const call of calls) {
+      if (this.signal?.aborted) {
+        results.push({
+          type: "tool_result",
+          toolUseId: call.id,
+          content: "Tool execution aborted",
+          isError: true
+        });
+        continue;
+      }
+      results.push(await this.executeOne(call));
+    }
+    return results;
+  }
+  async executeOne(call) {
+    const startedAt = Date.now();
+    const hookCtx = { signal: this.signal, logger: this.logger };
+    let currentInput = call.input;
+    const beforeHooks = this.hooks.get("tool:before");
+    for (const hook of beforeHooks) {
+      const decision = await hook(hookCtx, { id: call.id, name: call.name, input: currentInput });
+      if (decision.action === "skip") {
+        return {
+          type: "tool_result",
+          toolUseId: call.id,
+          content: decision.result,
+          isError: decision.isError ?? false,
+          durationMs: Math.max(0, Date.now() - startedAt)
+        };
+      }
+      if (decision.action === "modify") {
+        currentInput = decision.input;
+      }
+    }
+    let outputStr;
+    let isError = false;
+    try {
+      const tool = this.tools.resolve(call.name);
+      const executionController = new AbortController();
+      const abortFromSession = () => executionController.abort();
+      if (this.signal?.aborted) {
+        executionController.abort();
+      } else {
+        this.signal?.addEventListener("abort", abortFromSession, { once: true });
+      }
+      const toolCtx = {
+        rootDir: this.rootDir,
+        signal: executionController.signal,
+        logger: this.logger
+      };
+      try {
+        const rawResult = await this.withTimeout(
+          tool.execute(currentInput, toolCtx),
+          call.name,
+          executionController
+        );
+        outputStr = typeof rawResult === "string" ? rawResult : JSON.stringify(rawResult, null, 2);
+      } finally {
+        this.signal?.removeEventListener("abort", abortFromSession);
+      }
+    } catch (err) {
+      isError = true;
+      outputStr = err instanceof Error ? err.message : String(err);
+    }
+    const resultBlock = {
+      type: "tool_result",
+      toolUseId: call.id,
+      content: outputStr,
+      isError
+    };
+    const afterHooks = this.hooks.get("tool:after");
+    for (const hook of afterHooks) {
+      await hook(
+        hookCtx,
+        { id: call.id, name: call.name, input: currentInput },
+        { output: outputStr, isError }
+      );
+    }
+    resultBlock.durationMs = Math.max(0, Date.now() - startedAt);
+    return resultBlock;
+  }
+  /**
+   * 给工具执行加超时护栏：Promise.race 在超时后reject，循环拿到 isError 结果继续运转，
+   * 不会因某个异步工具(如未来接入的网络/exec 工具)挂起而永久卡死。
+   *
+   * 局限：同步 CPU 密集型实现会阻塞事件循环，timer 同样无法触发；
+   * 因此内置工具仍需避免执行用户可控的同步高复杂度计算。
+   */
+  withTimeout(promise, toolName, executionController) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        const error = new ToolError(`Tool '${toolName}' timed out after ${this.toolTimeoutMs}ms`);
+        reject(error);
+        executionController.abort(error);
+      }, this.toolTimeoutMs);
+    });
+    return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+  }
+};
+
+// src/models/router.ts
+var DEFAULT_CONTEXT_WINDOW_TOKENS = 1e6;
+function resolveContextWindow(value) {
+  if (value === void 0) {
+    return { tokens: DEFAULT_CONTEXT_WINDOW_TOKENS, estimated: true };
+  }
+  let tokens;
+  if (typeof value === "number") {
+    tokens = value;
+  } else {
+    const match = /^([0-9]+(?:\.[0-9]+)?)([km])$/i.exec(value.trim());
+    const unit = match?.[2]?.toLowerCase();
+    const fractionDigits = match?.[1]?.split(".")[1]?.length ?? 0;
+    const maxFractionDigits = unit === "m" ? 6 : 3;
+    if (!match || fractionDigits > maxFractionDigits) {
+      throw new RangeError(
+        `Invalid contextWindow '${value}': expected a positive integer or K/M value`
+      );
+    }
+    const multiplier = unit === "m" ? 1e6 : 1e3;
+    tokens = Number(match[1]) * multiplier;
+  }
+  if (!Number.isSafeInteger(tokens) || tokens <= 0) {
+    throw new RangeError(
+      `Invalid contextWindow '${value}': token count must be a positive integer`
+    );
+  }
+  return { tokens, estimated: false };
+}
+var SimpleModelRouter = class {
+  providers = /* @__PURE__ */ new Map();
+  profiles = /* @__PURE__ */ new Map();
+  defaultRole = "default";
+  constructor(defaultProfile, defaultProvider) {
+    this.setRole("default", defaultProfile, defaultProvider);
+  }
+  setRole(role, profile, provider) {
+    this.profiles.set(role, profile);
+    this.providers.set(role, provider);
+  }
+  resolve(role = "default") {
+    return this.providers.get(role) ?? this.providers.get("default");
+  }
+  getProfile(role = "default") {
+    return this.profiles.get(role) ?? this.profiles.get("default");
+  }
+};
+
+// src/models/openai-compatible/sse.ts
+async function* parseSSEStream(stream) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split(/\r?\n/);
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith(":")) {
+          continue;
+        }
+        if (trimmed.startsWith("data:")) {
+          const dataContent = trimmed.slice(5).trim();
+          if (dataContent === "[DONE]") {
+            return;
+          }
+          yield dataContent;
+        }
+      }
+    }
+    if (buffer.trim().startsWith("data:")) {
+      const dataContent = buffer.trim().slice(5).trim();
+      if (dataContent !== "[DONE]") {
+        yield dataContent;
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// src/models/openai-compatible/index.ts
+var DEFAULT_CONNECT_TIMEOUT_MS = 6e4;
+var OpenAICompatibleProvider = class {
+  name = "openai-compatible";
+  baseURL;
+  apiKey;
+  modelName;
+  supportsThinking;
+  connectTimeoutMs;
+  constructor(options) {
+    this.baseURL = options.baseURL.replace(/\/+$/, "");
+    this.apiKey = options.apiKey;
+    this.modelName = options.modelName;
+    this.supportsThinking = options.supportsThinking ?? false;
+    this.connectTimeoutMs = options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
+  }
+  async *create(req) {
+    const url = `${this.baseURL}/chat/completions`;
+    const wireMessages = this.translateMessagesToWire(req.messages, req.systemPrompt);
+    const wireTools = req.tools && req.tools.length > 0 ? req.tools.map((t) => ({
+      type: "function",
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters
+      }
+    })) : void 0;
+    const payload = {
+      model: this.modelName,
+      messages: wireMessages,
+      stream: true,
+      stream_options: { include_usage: true },
+      temperature: req.temperature ?? 0.7
+    };
+    if (wireTools) {
+      payload.tools = wireTools;
+    }
+    if (req.maxTokens) {
+      payload.max_tokens = req.maxTokens;
+    }
+    let response;
+    const timeoutController = new AbortController();
+    const timeoutTimer = setTimeout(() => timeoutController.abort(), this.connectTimeoutMs);
+    const onOuterAbort = () => timeoutController.abort();
+    if (req.signal?.aborted) {
+      timeoutController.abort();
+    } else {
+      req.signal?.addEventListener("abort", onOuterAbort, { once: true });
+    }
+    try {
+      try {
+        response = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.apiKey}`
+          },
+          body: JSON.stringify(payload),
+          signal: timeoutController.signal
+        });
+      } catch (err) {
+        if (req.signal?.aborted) {
+          throw err;
+        }
+        if (timeoutController.signal.aborted) {
+          throw new ModelError(`Connection to ${url} timed out after ${this.connectTimeoutMs}ms`, {
+            status: 408,
+            retryable: true
+          });
+        }
+        throw new ModelError(`Failed to connect to ${url}: ${err.message}`);
+      } finally {
+        clearTimeout(timeoutTimer);
+      }
+      if (!response.ok) {
+        const errorText = await response.text();
+        let errorMsg = `API request failed with status ${response.status}: ${response.statusText}`;
+        try {
+          const errorJson = JSON.parse(errorText);
+          if (errorJson.error?.message) {
+            errorMsg = errorJson.error.message;
+          }
+        } catch {
+          if (errorText) errorMsg += ` - ${errorText.slice(0, 300)}`;
+        }
+        throw new ModelError(errorMsg, { status: response.status });
+      }
+      if (!response.body) {
+        throw new ModelError("Response body is null");
+      }
+      const pendingToolCalls = /* @__PURE__ */ new Map();
+      let usage;
+      const requestStartTime = Date.now();
+      let ttftMs;
+      for await (const chunk of parseSSEStream(response.body)) {
+        if (req.signal?.aborted) return;
+        if (!chunk) continue;
+        let json;
+        try {
+          json = JSON.parse(chunk);
+        } catch {
+          continue;
+        }
+        if (json.error) {
+          const message = typeof json.error.message === "string" ? json.error.message : "Model API stream error";
+          const details = [json.error.type, json.error.code].filter((value) => typeof value === "string" && value.length > 0).join(", ");
+          throw new ModelError(details ? `${message} (${details})` : message);
+        }
+        if (json.usage) {
+          usage = {
+            promptTokens: json.usage.prompt_tokens ?? 0,
+            completionTokens: json.usage.completion_tokens ?? 0,
+            totalTokens: json.usage.total_tokens ?? 0
+          };
+        }
+        const choice = json.choices?.[0];
+        if (!choice) continue;
+        const delta = choice.delta;
+        if (!delta) continue;
+        if ((delta.content || delta.reasoning_content || delta.tool_calls && delta.tool_calls.length > 0) && ttftMs === void 0) {
+          ttftMs = Date.now() - requestStartTime;
+        }
+        if (delta.content) {
+          yield { type: "text_delta", text: delta.content };
+        }
+        if (delta.reasoning_content) {
+          yield { type: "thinking_delta", thinking: delta.reasoning_content };
+        }
+        if (delta.tool_calls && Array.isArray(delta.tool_calls)) {
+          for (const tc of delta.tool_calls) {
+            const index = tc.index ?? 0;
+            let entry = pendingToolCalls.get(index);
+            if (!entry) {
+              entry = {
+                id: tc.id ?? `call_${Date.now()}_${index}`,
+                name: tc.function?.name ?? "",
+                argumentChunks: []
+              };
+              pendingToolCalls.set(index, entry);
+              yield { type: "tool_call_start", id: entry.id, name: entry.name };
+            }
+            if (tc.function?.name && !entry.name) {
+              entry.name = tc.function.name;
+            }
+            if (tc.function?.arguments) {
+              entry.argumentChunks.push(tc.function.arguments);
+              yield {
+                type: "tool_call_delta",
+                id: entry.id,
+                argumentChunk: tc.function.arguments
+              };
+            }
+          }
+        }
+      }
+      for (const [, tc] of pendingToolCalls.entries()) {
+        const fullArgs = tc.argumentChunks.join("");
+        let parsedInput = {};
+        let parseError;
+        try {
+          parsedInput = fullArgs.trim() ? JSON.parse(fullArgs) : {};
+        } catch {
+          parsedInput = { _raw: fullArgs };
+          parseError = true;
+        }
+        yield {
+          type: "tool_call_finish",
+          id: tc.id,
+          name: tc.name,
+          input: parsedInput,
+          parseError
+        };
+      }
+      const durationMs = Date.now() - requestStartTime;
+      yield { type: "message_stop", usage, ttftMs, durationMs };
+    } finally {
+      req.signal?.removeEventListener("abort", onOuterAbort);
+    }
+  }
+  assembleToolResults(results) {
+    return results.map((r) => ({
+      role: "tool",
+      content: [r],
+      timestamp: Date.now()
+    }));
+  }
+  translateMessagesToWire(messages, systemPrompt) {
+    const wire = [];
+    if (systemPrompt?.trim()) {
+      wire.push({ role: "system", content: systemPrompt.trim() });
+    }
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        const text = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+        if (text) wire.push({ role: "system", content: text });
+      } else if (msg.role === "user") {
+        const text = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+        const previous = wire[wire.length - 1];
+        if (previous?.role === "user" && typeof previous.content === "string") {
+          previous.content = [previous.content, text].filter(Boolean).join("\n\n");
+        } else {
+          wire.push({ role: "user", content: text });
+        }
+      } else if (msg.role === "assistant") {
+        const text = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+        const toolCalls = [];
+        for (const block of msg.content) {
+          if (block.type === "tool_use") {
+            toolCalls.push({
+              id: block.id,
+              type: "function",
+              function: {
+                name: block.name,
+                arguments: JSON.stringify(block.input)
+              }
+            });
+          }
+        }
+        if (!text && toolCalls.length === 0) continue;
+        wire.push({
+          role: "assistant",
+          content: text || null,
+          tool_calls: toolCalls.length > 0 ? toolCalls : void 0
+        });
+      } else if (msg.role === "tool") {
+        for (const block of msg.content) {
+          if (block.type === "tool_result") {
+            wire.push({
+              role: "tool",
+              tool_call_id: block.toolUseId,
+              content: block.content
+            });
+          }
+        }
+      }
+    }
+    return wire;
+  }
+};
+
+// src/store/jsonl.ts
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+var JSONLMessageStore = class {
+  filePath;
+  constructor(filePath) {
+    this.filePath = import_node_path3.default.resolve(filePath);
+    const dir = import_node_path3.default.dirname(this.filePath);
+    if (!import_node_fs3.default.existsSync(dir)) {
+      import_node_fs3.default.mkdirSync(dir, { recursive: true });
+    }
+  }
+  async append(message) {
+    const record = {
+      ts: message.timestamp ?? Date.now(),
+      role: message.role,
+      content: message.content
+    };
+    import_node_fs3.default.appendFileSync(this.filePath, `${JSON.stringify(record)}
+`, "utf-8");
+  }
+  async load() {
+    if (!import_node_fs3.default.existsSync(this.filePath)) {
+      return [];
+    }
+    const content = import_node_fs3.default.readFileSync(this.filePath, "utf-8");
+    const lines = content.split("\n");
+    const messages = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const record = JSON.parse(trimmed);
+        if (record.role && record.content) {
+          messages.push({
+            role: record.role,
+            content: record.content,
+            timestamp: record.ts
+          });
+        }
+      } catch {
+      }
+    }
+    this.healDanglingToolCalls(messages);
+    return messages;
+  }
+  async clear() {
+    if (import_node_fs3.default.existsSync(this.filePath)) {
+      import_node_fs3.default.unlinkSync(this.filePath);
+    }
+  }
+  /**
+   * 历史自愈(设计文档 §4.4)：逐条扫描 assistant 的 tool_use，
+   * 若其后的 tool 消息未完整覆盖这些 tool_use，就地补一条 is_error 的 tool_result。
+   *
+   * 之所以做**全历史扫描**而非只看末条：崩溃可能发生在任意一轮工具执行中途，
+   * 悬挂的 tool_use 未必位于历史末尾(例如中断后用户又继续提了问)。
+   * 只看末条会漏掉夹在中间的悬挂，下一次请求仍会因上下文非法而 400。
+   */
+  healDanglingToolCalls(messages) {
+    const healed = [];
+    let pending = /* @__PURE__ */ new Map();
+    const closePending = () => {
+      if (pending.size === 0) return;
+      healed.push({
+        role: "tool",
+        content: Array.from(pending.values()).map(
+          (toolUse) => ({
+            type: "tool_result",
+            toolUseId: toolUse.id,
+            content: "Tool execution was interrupted or crashed in previous session",
+            isError: true
+          })
+        ),
+        timestamp: Date.now()
+      });
+      pending = /* @__PURE__ */ new Map();
+    };
+    for (const msg of messages) {
+      if (msg.role === "tool") {
+        const valid = msg.content.filter((block) => {
+          if (!isToolResultBlock(block) || !pending.has(block.toolUseId)) return false;
+          pending.delete(block.toolUseId);
+          return true;
+        });
+        if (valid.length === 0) continue;
+        healed.push(valid.length === msg.content.length ? msg : { ...msg, content: valid });
+        continue;
+      }
+      closePending();
+      healed.push(msg);
+      if (msg.role !== "assistant") continue;
+      const toolUses = msg.content.filter(isToolUseBlock);
+      if (toolUses.length === 0) continue;
+      pending = new Map(toolUses.map((toolUse) => [toolUse.id, toolUse]));
+    }
+    closePending();
+    messages.length = 0;
+    messages.push(...healed);
+  }
+};
+
+// src/prompt/index.ts
+var import_node_os = __toESM(require("os"), 1);
+var PromptAssembler = class {
+  tools;
+  rootDir;
+  agentName;
+  customInstructions;
+  constructor(options) {
+    this.tools = options.tools;
+    this.rootDir = options.rootDir;
+    this.agentName = options.agentName ?? "Kapibala";
+    this.customInstructions = options.customInstructions;
+  }
+  assemble() {
+    const sections = [];
+    sections.push(this.getL1Behavior());
+    if (this.tools) {
+      sections.push(this.getL2Tools());
+    }
+    sections.push(this.getL3Environment());
+    if (this.customInstructions?.trim()) {
+      sections.push(this.customInstructions.trim());
+    }
+    return sections.filter(Boolean).join("\n\n---\n\n");
+  }
+  getL1Behavior() {
+    return `You are ${this.agentName}, an intelligent and dependable AI software engineering assistant.
+Your goal is to solve tasks efficiently and accurately by reasoning step-by-step and calling available tools when needed.
+Follow these key behavioral rules:
+1. Ground your answers in reality by inspecting files before making assumptions.
+2. When calling tools, ensure parameters conform strictly to the schema.
+3. When the user provides an exact file path, read it directly instead of searching for it first.
+4. Do not broaden a successful exact lookup with wildcard searches or duplicate read-only calls.
+5. Stop calling tools once you have enough evidence to answer the user's request.
+6. If a tool call fails, analyze the error before self-correcting. Do not repeat an identical failed tool call.
+7. Keep answers concise, clear, and focused on user requirements. Do not add unrelated analysis unless requested.`;
+  }
+  getL2Tools() {
+    if (!this.tools) return "";
+    const tools = this.tools.list();
+    if (tools.length === 0) return "";
+    const lines = ["# Available Tools:"];
+    for (const tool of tools) {
+      lines.push(`- **${tool.name}**: ${tool.description}`);
+    }
+    return lines.join("\n");
+  }
+  getL3Environment() {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const platform = import_node_os.default.platform();
+    return `# Environment Context:
+- Current Working Directory (Workspace Root): ${this.rootDir}
+- Operating System: ${platform}
+- Current Date/Time: ${now}`;
+  }
+};
+
+// src/loop/index.ts
+var AgentLoop = class {
+  provider;
+  executor;
+  tools;
+  hooks;
+  systemPrompt;
+  maxSteps;
+  maxConsecutiveErrors;
+  signal;
+  constructor(options) {
+    this.provider = options.provider;
+    this.executor = options.executor;
+    this.tools = options.tools;
+    this.hooks = options.hooks;
+    this.systemPrompt = options.systemPrompt;
+    this.maxSteps = options.maxSteps ?? 20;
+    this.maxConsecutiveErrors = options.maxConsecutiveErrors ?? 3;
+    this.signal = options.signal;
+  }
+  async *run(history) {
+    let step = 0;
+    let consecutiveErrors = 0;
+    let completed = false;
+    while (step < this.maxSteps) {
+      step++;
+      const turnStartTime = Date.now();
+      yield { type: "turn_start", turn: step };
+      if (this.signal?.aborted) {
+        throw new AbortError();
+      }
+      let request = {
+        systemPrompt: this.systemPrompt,
+        messages: history,
+        tools: this.tools.definitions(),
+        signal: this.signal
+      };
+      const beforeModelHooks = this.hooks.get("model:before");
+      const hookCtx = { signal: this.signal };
+      for (const hook of beforeModelHooks) {
+        request = await hook(hookCtx, request);
+      }
+      yield {
+        type: "step_log",
+        log: {
+          timestamp: Date.now(),
+          turn: step,
+          stage: "model_request_start",
+          message: `Sending request to model with ${request.messages.length} messages and ${request.tools?.length ?? 0} tools`
+        }
+      };
+      let accumulatedText = "";
+      let accumulatedThinking = "";
+      const toolCalls = [];
+      let turnUsage;
+      let turnTtftMs;
+      const modelStartTime = Date.now();
+      let firstTokenReceived = false;
+      const buildMetrics = (modelDurationMs2, toolDurationMs2, toolCallsCount) => {
+        const endTime = Date.now();
+        return {
+          turn: step,
+          startTime: turnStartTime,
+          endTime,
+          totalDurationMs: endTime - turnStartTime,
+          ttftMs: turnTtftMs,
+          modelDurationMs: modelDurationMs2,
+          toolDurationMs: toolDurationMs2,
+          promptTokens: turnUsage?.promptTokens ?? 0,
+          completionTokens: turnUsage?.completionTokens ?? 0,
+          totalTokens: turnUsage?.totalTokens ?? 0,
+          toolCallsCount
+        };
+      };
+      try {
+        for await (const event of this.provider.create(request)) {
+          if (this.signal?.aborted) throw new AbortError();
+          if (!firstTokenReceived && (event.type === "text_delta" || event.type === "thinking_delta" || event.type === "tool_call_start")) {
+            firstTokenReceived = true;
+            turnTtftMs = Date.now() - modelStartTime;
+            yield {
+              type: "step_log",
+              log: {
+                timestamp: Date.now(),
+                turn: step,
+                stage: "first_token",
+                message: `First token received (TTFT: ${turnTtftMs}ms)`,
+                durationMs: turnTtftMs
+              }
+            };
+          }
+          if (event.type === "text_delta") {
+            accumulatedText += event.text;
+            yield { type: "text_delta", text: event.text };
+          } else if (event.type === "thinking_delta") {
+            accumulatedThinking += event.thinking;
+            yield { type: "thinking_delta", thinking: event.thinking };
+          } else if (event.type === "tool_call_finish") {
+            const toolUse = {
+              type: "tool_use",
+              id: event.id,
+              name: event.name,
+              input: event.input
+            };
+            toolCalls.push(toolUse);
+          } else if (event.type === "message_stop") {
+            turnUsage = event.usage;
+            if (event.ttftMs && turnTtftMs === void 0) {
+              turnTtftMs = event.ttftMs;
+            }
+          }
+        }
+      } catch (err) {
+        if (err instanceof AbortError || this.signal?.aborted) {
+          throw new AbortError();
+        }
+        const modelError = err instanceof Error ? err : new Error(String(err));
+        await this.hooks.emit("error", hookCtx, modelError);
+        yield { type: "error", error: modelError };
+        yield {
+          type: "turn_finish",
+          turn: step,
+          metrics: buildMetrics(Date.now() - modelStartTime, 0, 0)
+        };
+        completed = true;
+        break;
+      }
+      const modelDurationMs = Date.now() - modelStartTime;
+      yield {
+        type: "step_log",
+        log: {
+          timestamp: Date.now(),
+          turn: step,
+          stage: "model_stream_finish",
+          message: `Model streaming completed in ${modelDurationMs}ms (prompt: ${turnUsage?.promptTokens ?? 0}, completion: ${turnUsage?.completionTokens ?? 0})`,
+          durationMs: modelDurationMs,
+          metadata: { usage: turnUsage, ttftMs: turnTtftMs }
+        }
+      };
+      const contentBlocks = [];
+      if (accumulatedThinking) {
+        contentBlocks.push({ type: "thinking", thinking: accumulatedThinking });
+      }
+      if (accumulatedText) {
+        contentBlocks.push({ type: "text", text: accumulatedText });
+      }
+      for (const tc of toolCalls) {
+        contentBlocks.push(tc);
+      }
+      const assistantMessage = {
+        role: "assistant",
+        content: contentBlocks,
+        timestamp: Date.now()
+      };
+      await this.hooks.emit("model:after", hookCtx, { message: assistantMessage });
+      if (toolCalls.length === 0) {
+        history.push(assistantMessage);
+        yield {
+          type: "message_stop",
+          message: assistantMessage,
+          usage: turnUsage,
+          ttftMs: turnTtftMs,
+          durationMs: modelDurationMs
+        };
+        const metrics2 = buildMetrics(modelDurationMs, 0, 0);
+        yield {
+          type: "step_log",
+          log: {
+            timestamp: metrics2.endTime,
+            turn: step,
+            stage: "turn_finish",
+            message: `Turn ${step} finished in ${metrics2.totalDurationMs}ms (TTFT: ${metrics2.ttftMs ?? 0}ms, Tokens: ${metrics2.totalTokens})`,
+            durationMs: metrics2.totalDurationMs,
+            metadata: { metrics: metrics2 }
+          }
+        };
+        yield { type: "turn_finish", turn: step, usage: turnUsage, metrics: metrics2 };
+        completed = true;
+        break;
+      }
+      yield {
+        type: "step_log",
+        log: {
+          timestamp: Date.now(),
+          turn: step,
+          stage: "tool_execution_start",
+          message: `Executing ${toolCalls.length} tool(s): ${toolCalls.map((c) => c.name).join(", ")}`
+        }
+      };
+      for (const call of toolCalls) {
+        yield { type: "tool_start", id: call.id, name: call.name, input: call.input };
+      }
+      const toolStartTime = Date.now();
+      const toolResults = await this.executor.runAll(toolCalls);
+      const toolDurationMs = Date.now() - toolStartTime;
+      const hasError = toolResults.some((result) => result.isError);
+      const metrics = buildMetrics(modelDurationMs, toolDurationMs, toolCalls.length);
+      const toolMessages = this.provider.assembleToolResults(toolResults);
+      history.push(assistantMessage, ...toolMessages);
+      yield {
+        type: "message_stop",
+        message: assistantMessage,
+        usage: turnUsage,
+        ttftMs: turnTtftMs,
+        durationMs: modelDurationMs
+      };
+      for (const res of toolResults) {
+        const matchingCall = toolCalls.find((c) => c.id === res.toolUseId);
+        yield {
+          type: "tool_finish",
+          id: res.toolUseId,
+          name: matchingCall?.name ?? "unknown",
+          result: res.content,
+          isError: res.isError ?? false,
+          durationMs: res.durationMs
+        };
+      }
+      yield {
+        type: "step_log",
+        log: {
+          timestamp: Date.now(),
+          turn: step,
+          stage: "tool_execution_finish",
+          message: `Tools execution finished in ${toolDurationMs}ms (${hasError ? "with errors" : "success"})`,
+          durationMs: toolDurationMs
+        }
+      };
+      yield { type: "tool_messages", messages: toolMessages };
+      if (hasError) {
+        consecutiveErrors++;
+        if (consecutiveErrors >= this.maxConsecutiveErrors) {
+          const breakerError = new Error(
+            `Circuit breaker triggered: ${consecutiveErrors} consecutive tool failures`
+          );
+          await this.hooks.emit("error", hookCtx, breakerError);
+          yield { type: "error", error: breakerError };
+          yield { type: "turn_finish", turn: step, usage: turnUsage, metrics };
+          completed = true;
+          break;
+        }
+      } else {
+        consecutiveErrors = 0;
+      }
+      yield {
+        type: "step_log",
+        log: {
+          timestamp: metrics.endTime,
+          turn: step,
+          stage: "turn_finish",
+          message: `Turn ${step} completed in ${metrics.totalDurationMs}ms (tool duration: ${toolDurationMs}ms). Continuing loop.`,
+          durationMs: metrics.totalDurationMs,
+          metadata: { metrics }
+        }
+      };
+      yield { type: "turn_finish", turn: step, usage: turnUsage, metrics };
+    }
+    if (!completed) {
+      yield {
+        type: "error",
+        error: new Error(
+          `Reached max steps limit (${this.maxSteps}); loop terminated before a final answer was produced`
+        )
+      };
+    }
+  }
+};
+
+// src/session/index.ts
+var AgentSession = class {
+  rootDir;
+  tools;
+  hooks;
+  router;
+  store;
+  customSystemPrompt;
+  maxSteps;
+  logger;
+  history = [];
+  totalTurns = 0;
+  usageStats = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+  lastMetrics;
+  lastRunMetrics;
+  initialized = false;
+  destroyed = false;
+  activeRun = false;
+  plugins = [];
+  constructor(config) {
+    resolveContextWindow(config.defaultProfile.contextWindow);
+    this.rootDir = config.rootDir ?? process.cwd();
+    this.tools = new ToolRegistry();
+    this.hooks = new HookRegistry();
+    this.router = new SimpleModelRouter(config.defaultProfile, config.defaultProvider);
+    this.store = config.store;
+    this.customSystemPrompt = config.systemPrompt;
+    this.maxSteps = config.maxSteps ?? 20;
+    this.logger = config.logger;
+  }
+  async init() {
+    if (this.initialized) return;
+    if (this.store) {
+      this.history = await this.store.load();
+    }
+    await this.hooks.emit("session:start", { logger: this.logger });
+    this.initialized = true;
+  }
+  async use(plugin) {
+    if (this.destroyed) {
+      throw new Error(`Cannot mount plugin '${plugin.name}': session already destroyed`);
+    }
+    this.assertIdle(`mount plugin '${plugin.name}'`);
+    await plugin.setup({
+      tools: this.tools,
+      hooks: this.hooks,
+      rootDir: this.rootDir,
+      logger: this.logger
+    });
+    this.plugins.push(plugin);
+  }
+  switchModel(profile, role = "default", provider) {
+    this.assertIdle("switch models");
+    resolveContextWindow(profile.contextWindow);
+    if (!provider) {
+      provider = this.router.resolve(role);
+    }
+    this.router.setRole(role, profile, provider);
+    this.logger?.(`Switched model for role [${role}] to ${profile.name} (${profile.modelName})`);
+  }
+  getActiveProfile(role = "default") {
+    return this.router.getProfile(role);
+  }
+  getHistory() {
+    return [...this.history];
+  }
+  getStats() {
+    return {
+      totalTurns: this.totalTurns,
+      totalTokens: { ...this.usageStats },
+      activeModel: this.router.getProfile("default").name,
+      loadedToolsCount: this.tools.list().length,
+      lastMetrics: this.lastMetrics,
+      lastRunMetrics: this.lastRunMetrics,
+      contextUsage: this.lastRunMetrics?.contextUsage ?? this.createContextUsage()
+    };
+  }
+  getLastMetrics() {
+    return this.lastMetrics;
+  }
+  getLastRunMetrics() {
+    return this.lastRunMetrics;
+  }
+  async reset() {
+    this.assertIdle("reset session");
+    this.history = [];
+    this.totalTurns = 0;
+    this.usageStats = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+    this.lastMetrics = void 0;
+    this.lastRunMetrics = void 0;
+    if (this.store) {
+      await this.store.clear();
+    }
+    this.logger?.("Session context cleared");
+  }
+  /**
+   * 执行一次用户输入，并以宿主无关的语义事件流返回全过程。
+   *
+   * Core 不负责终端或图形界面渲染；CLI、TUI、GUI 与其它宿主应消费同一组
+   * {@link SessionEvent}，分别完成展示、交互和中止控制。
+   *
+   * @param userInput 用户本轮输入。
+   * @param options 可选的中止信号。
+   * @returns 文本、思考、工具、指标和错误等结构化事件的异步流。
+   * @throws {SessionBusyError} 当前会话已有正在执行的 run 时抛出。
+   */
+  async *run(userInput, options) {
+    this.assertIdle("start another run");
+    resolveContextWindow(this.router.getProfile("default").contextWindow);
+    this.activeRun = true;
+    const runStartTime = Date.now();
+    const aggregate = {
+      modelDurationMs: 0,
+      toolDurationMs: 0,
+      promptTokens: 0,
+      completionTokens: 0,
+      totalTokens: 0,
+      turns: 0,
+      toolCalls: 0,
+      ttftMs: void 0
+    };
+    let lastPromptTokens;
+    let runStatus = "completed";
+    let runFinalized = false;
+    const finalizeRun = (status) => {
+      const endTime = Date.now();
+      return {
+        startTime: runStartTime,
+        endTime,
+        totalDurationMs: endTime - runStartTime,
+        ...aggregate,
+        status,
+        contextUsage: this.createContextUsage(lastPromptTokens)
+      };
+    };
+    try {
+      if (!this.initialized) {
+        await this.init();
+      }
+      this.totalTurns++;
+      const userMessage = {
+        role: "user",
+        content: [{ type: "text", text: userInput }],
+        timestamp: Date.now()
+      };
+      this.history.push(userMessage);
+      if (this.store) {
+        await this.store.append(userMessage);
+      }
+      const promptAssembler = new PromptAssembler({
+        tools: this.tools,
+        rootDir: this.rootDir,
+        customInstructions: this.customSystemPrompt
+      });
+      const assembledSystemPrompt = promptAssembler.assemble();
+      const executor = new ToolExecutor({
+        tools: this.tools,
+        hooks: this.hooks,
+        rootDir: this.rootDir,
+        signal: options?.signal,
+        logger: this.logger
+      });
+      const loop = new AgentLoop({
+        provider: this.router.resolve("default"),
+        executor,
+        tools: this.tools,
+        hooks: this.hooks,
+        systemPrompt: assembledSystemPrompt,
+        maxSteps: this.maxSteps,
+        signal: options?.signal
+      });
+      let pendingAssistant;
+      let pendingEvents = [];
+      let pendingClosedInMemory = false;
+      let pendingAssistantPersisted = false;
+      let pendingPersistenceStarted = false;
+      let pendingToolMessages = [];
+      try {
+        for await (const event of loop.run(this.history)) {
+          if (event.type === "step_log") {
+            this.logger?.(`[Turn ${event.log.turn} | ${event.log.stage}] ${event.log.message}`);
+          }
+          if (event.type === "turn_finish") {
+            this.lastMetrics = event.metrics;
+            aggregate.modelDurationMs += event.metrics.modelDurationMs;
+            aggregate.toolDurationMs += event.metrics.toolDurationMs;
+            aggregate.promptTokens += event.metrics.promptTokens;
+            aggregate.completionTokens += event.metrics.completionTokens;
+            aggregate.totalTokens += event.metrics.totalTokens;
+            lastPromptTokens = event.usage?.promptTokens;
+            aggregate.turns++;
+            aggregate.toolCalls += event.metrics.toolCallsCount;
+            aggregate.ttftMs ??= event.metrics.ttftMs;
+          }
+          if (event.type === "error") {
+            runStatus = "failed";
+          }
+          if (event.type === "message_stop" && event.message.content.some((block) => block.type === "tool_use")) {
+            pendingAssistant = event;
+            pendingEvents = [event];
+            pendingToolMessages = this.findClosedToolMessages(event);
+            pendingClosedInMemory = pendingToolMessages.length > 0;
+            pendingAssistantPersisted = false;
+            pendingPersistenceStarted = false;
+            continue;
+          }
+          if (pendingAssistant) {
+            pendingEvents.push(event);
+            if (event.type !== "tool_messages") continue;
+            pendingClosedInMemory = true;
+            pendingToolMessages = event.messages;
+            pendingPersistenceStarted = true;
+            await this.persistAssistant(pendingAssistant);
+            pendingAssistantPersisted = true;
+            await this.persistToolMessages(event.messages);
+            const releasable = pendingEvents;
+            pendingAssistant = void 0;
+            pendingEvents = [];
+            for (const buffered of releasable) yield buffered;
+            continue;
+          }
+          if (event.type === "message_stop") {
+            await this.persistAssistant(event);
+          } else if (event.type === "tool_messages") {
+            await this.persistToolMessages(event.messages);
+          }
+          yield event;
+        }
+      } catch (error) {
+        if (pendingAssistant && !pendingPersistenceStarted) {
+          const interruptedMessages = pendingClosedInMemory ? pendingToolMessages : this.closeInterruptedToolCalls(pendingAssistant, error);
+          if (!pendingAssistantPersisted) {
+            await this.persistAssistant(pendingAssistant);
+          }
+          await this.persistToolMessages(interruptedMessages);
+          for (const buffered of pendingEvents) yield buffered;
+          yield { type: "tool_messages", messages: interruptedMessages };
+        }
+        throw error;
+      }
+      const metrics = finalizeRun(runStatus);
+      this.lastRunMetrics = metrics;
+      runFinalized = true;
+      yield { type: "run_finish", metrics };
+    } catch (error) {
+      const status = error instanceof AbortError || options?.signal?.aborted ? "aborted" : "failed";
+      const metrics = finalizeRun(status);
+      this.lastRunMetrics = metrics;
+      runFinalized = true;
+      yield { type: "run_finish", metrics };
+      throw error;
+    } finally {
+      this.activeRun = false;
+      if (!runFinalized) {
+        this.lastRunMetrics = finalizeRun("aborted");
+      }
+    }
+  }
+  async destroy() {
+    if (this.destroyed) return;
+    this.assertIdle("destroy session");
+    this.destroyed = true;
+    for (const plugin of this.plugins) {
+      try {
+        await plugin.teardown?.();
+      } catch (err) {
+        this.logger?.(`Plugin '${plugin.name}' teardown failed: ${err.message}`);
+      }
+    }
+    this.plugins.length = 0;
+    await this.hooks.emit("session:end", { logger: this.logger });
+  }
+  assertIdle(operation) {
+    if (this.activeRun) throw new SessionBusyError(operation);
+  }
+  /**
+   * 计算最近一次内部模型请求的上下文占用。
+   * run 累计 promptTokens 会重复计算每一步都重发的历史，不能用于窗口占用率。
+   */
+  createContextUsage(usedTokens) {
+    const contextWindow = resolveContextWindow(this.router.getProfile("default").contextWindow);
+    return {
+      usedTokens,
+      limitTokens: contextWindow.tokens,
+      percent: usedTokens === void 0 ? void 0 : usedTokens / contextWindow.tokens * 100,
+      estimatedLimit: contextWindow.estimated
+    };
+  }
+  async persistAssistant(event) {
+    if (this.store) await this.store.append(event.message);
+    if (event.usage) {
+      this.usageStats.promptTokens += event.usage.promptTokens;
+      this.usageStats.completionTokens += event.usage.completionTokens;
+      this.usageStats.totalTokens += event.usage.totalTokens;
+    }
+  }
+  async persistToolMessages(messages) {
+    if (!this.store) return;
+    for (const message of messages) await this.store.append(message);
+  }
+  closeInterruptedToolCalls(assistantEvent, error) {
+    const message = {
+      role: "tool",
+      content: assistantEvent.message.content.filter((block) => block.type === "tool_use").map((toolUse) => ({
+        type: "tool_result",
+        toolUseId: toolUse.id,
+        content: `Tool execution interrupted before completion: ${error instanceof Error ? error.message : String(error)}`,
+        isError: true
+      })),
+      timestamp: Date.now()
+    };
+    this.history.push(message);
+    return [message];
+  }
+  findClosedToolMessages(assistantEvent) {
+    const assistantIndex = this.history.lastIndexOf(assistantEvent.message);
+    if (assistantIndex < 0) return [];
+    const expected = new Set(
+      assistantEvent.message.content.filter((block) => block.type === "tool_use").map((toolUse) => toolUse.id)
+    );
+    const messages = [];
+    for (let index = assistantIndex + 1; index < this.history.length; index++) {
+      const message = this.history[index];
+      if (message.role !== "tool") break;
+      messages.push(message);
+      for (const block of message.content) {
+        if (block.type === "tool_result") expected.delete(block.toolUseId);
+      }
+    }
+    return expected.size === 0 ? messages : [];
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AbortError,
+  AgentLoop,
+  AgentSession,
+  DEFAULT_CONTEXT_WINDOW_TOKENS,
+  FatalError,
+  HookRegistry,
+  JSONLMessageStore,
+  KapibalaError,
+  ModelError,
+  OpenAICompatibleProvider,
+  PathSandbox,
+  PromptAssembler,
+  SessionBusyError,
+  SimpleModelRouter,
+  ToolError,
+  ToolExecutor,
+  ToolNotFound,
+  ToolRegistry,
+  TransportError,
+  builtinTools,
+  defineTool,
+  editFileTool,
+  globTool,
+  grepTool,
+  isTextBlock,
+  isThinkingBlock,
+  isToolResultBlock,
+  isToolUseBlock,
+  readFileTool,
+  resolveContextWindow,
+  toToolDefinition,
+  writeFileTool
+});
+//# sourceMappingURL=index.cjs.map