@kooka/core 0.1.0

package/dist/cjs/index.cjs

@@ -0,0 +1,990 @@
+"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, {
+  COMPACTED_TOOL_PLACEHOLDER: () => COMPACTED_TOOL_PLACEHOLDER,
+  COMPACTION_AUTO_CONTINUE_TEXT: () => COMPACTION_AUTO_CONTINUE_TEXT,
+  COMPACTION_MARKER_TEXT: () => COMPACTION_MARKER_TEXT,
+  COMPACTION_PROMPT_TEXT: () => COMPACTION_PROMPT_TEXT,
+  COMPACTION_SYSTEM_PROMPT: () => COMPACTION_SYSTEM_PROMPT,
+  DEFAULT_BACKGROUND_KILL_GRACE_MS: () => DEFAULT_BACKGROUND_KILL_GRACE_MS,
+  DEFAULT_BACKGROUND_TTL_MS: () => DEFAULT_BACKGROUND_TTL_MS,
+  appendReasoning: () => appendReasoning,
+  appendText: () => appendText,
+  cleanupDeadBackgroundJobs: () => cleanupDeadBackgroundJobs,
+  createAssistantHistoryMessage: () => createAssistantHistoryMessage,
+  createBackgroundJobKey: () => createBackgroundJobKey,
+  createHistoryForModel: () => createHistoryForModel,
+  createUserHistoryMessage: () => createUserHistoryMessage,
+  evaluatePermission: () => evaluatePermission,
+  evaluateShellCommand: () => evaluateShellCommand,
+  expandHome: () => expandHome,
+  extractUsageTokens: () => extractUsageTokens,
+  finalizeStreamingParts: () => finalizeStreamingParts,
+  findExternalPathReferencesInShellCommand: () => findExternalPathReferencesInShellCommand,
+  getBackgroundJob: () => getBackgroundJob,
+  getEffectiveHistory: () => getEffectiveHistory,
+  getMessageText: () => getMessageText,
+  getReservedOutputTokens: () => getReservedOutputTokens,
+  isOverflow: () => isOverflow,
+  isPathInsideWorkspace: () => isPathInsideWorkspace,
+  isPidAlive: () => isPidAlive,
+  isSubPath: () => isSubPath,
+  killProcessTree: () => killProcessTree,
+  listBackgroundJobs: () => listBackgroundJobs,
+  markPrunableToolOutputs: () => markPrunableToolOutputs,
+  mergeRulesets: () => mergeRulesets,
+  normalizeFsPath: () => normalizeFsPath,
+  optionalBoolean: () => optionalBoolean,
+  optionalNumber: () => optionalNumber,
+  optionalString: () => optionalString,
+  refreshBackgroundJob: () => refreshBackgroundJob,
+  registerBackgroundJob: () => registerBackgroundJob,
+  removeBackgroundJob: () => removeBackgroundJob,
+  requireString: () => requireString,
+  setDynamicToolError: () => setDynamicToolError,
+  setDynamicToolOutput: () => setDynamicToolOutput,
+  upsertDynamicToolCall: () => upsertDynamicToolCall,
+  validateToolArgs: () => validateToolArgs,
+  wildcardMatch: () => wildcardMatch
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/fsPath.ts
+var os = __toESM(require("os"), 1);
+var path = __toESM(require("path"), 1);
+function normalizeFsPath(value) {
+  const resolved = path.resolve(value);
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function isSubPath(childPath, parentPath) {
+  const parent = normalizeFsPath(parentPath);
+  const child = normalizeFsPath(childPath);
+  return child === parent || child.startsWith(parent + path.sep);
+}
+function expandHome(p) {
+  const trimmed = (p || "").trim();
+  if (!trimmed) return trimmed;
+  if (trimmed === "~") return os.homedir();
+  if (trimmed.startsWith("~/") || trimmed.startsWith("~\\")) {
+    return path.join(os.homedir(), trimmed.slice(2));
+  }
+  return trimmed;
+}
+
+// src/permission.ts
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function wildcardToRegExp(pattern) {
+  const normalized = String(pattern ?? "").trim();
+  if (!normalized || normalized === "*") return /^.*$/;
+  let re = "^";
+  for (const ch of normalized) {
+    if (ch === "*") {
+      re += ".*";
+    } else if (ch === "?") {
+      re += ".";
+    } else {
+      re += escapeRegExp(ch);
+    }
+  }
+  re += "$";
+  return new RegExp(re);
+}
+function wildcardMatch(pattern, value) {
+  try {
+    return wildcardToRegExp(pattern).test(String(value ?? ""));
+  } catch {
+    return false;
+  }
+}
+function evaluatePermission(permission, pattern, ruleset) {
+  let match;
+  for (const rule of ruleset) {
+    if (!wildcardMatch(rule.permission, permission)) continue;
+    if (!wildcardMatch(rule.pattern, pattern)) continue;
+    match = rule;
+  }
+  return match;
+}
+function mergeRulesets(...rulesets) {
+  const out = [];
+  for (const rs of rulesets) {
+    if (!rs) continue;
+    out.push(...rs);
+  }
+  return out;
+}
+
+// src/shellPaths.ts
+var path2 = __toESM(require("path"), 1);
+function stripPunctuation(token) {
+  let out = token.trim();
+  if (!out) return out;
+  out = out.replace(/^[;|&(){}<>]+/, "");
+  out = out.replace(/[;|&(){}<>]+$/, "");
+  return out.trim();
+}
+function tokenizeShellCommand(command) {
+  const tokens = [];
+  const s = String(command ?? "");
+  let i = 0;
+  const isWs = (ch) => ch === " " || ch === "	" || ch === "\n" || ch === "\r";
+  while (i < s.length) {
+    while (i < s.length && isWs(s[i])) i++;
+    if (i >= s.length) break;
+    let token = "";
+    const start = s[i];
+    if (start === "'") {
+      i++;
+      while (i < s.length && s[i] !== "'") {
+        token += s[i++];
+      }
+      if (i < s.length && s[i] === "'") i++;
+      tokens.push(token);
+      continue;
+    }
+    if (start === '"') {
+      i++;
+      while (i < s.length) {
+        const ch = s[i];
+        if (ch === '"') {
+          i++;
+          break;
+        }
+        if (ch === "\\" && i + 1 < s.length) {
+          token += s[i + 1];
+          i += 2;
+          continue;
+        }
+        token += ch;
+        i++;
+      }
+      tokens.push(token);
+      continue;
+    }
+    while (i < s.length && !isWs(s[i])) {
+      const ch = s[i];
+      if (ch === "\\" && i + 1 < s.length) {
+        token += s[i + 1];
+        i += 2;
+        continue;
+      }
+      token += ch;
+      i++;
+    }
+    if (token) tokens.push(token);
+  }
+  return tokens;
+}
+function resolveCandidatePath(candidate, cwd) {
+  const expanded = expandHome(candidate);
+  return path2.isAbsolute(expanded) ? path2.resolve(expanded) : path2.resolve(cwd, expanded);
+}
+function isUrlLike(token) {
+  return token.includes("://");
+}
+function isPathLikeToken(token) {
+  if (!token) return false;
+  if (token === "-") return false;
+  if (isUrlLike(token)) return false;
+  if (token === "~" || token.startsWith("~/") || token.startsWith("~\\")) return true;
+  if (token.startsWith("/")) return true;
+  if (/^[A-Za-z]:[\\/]/.test(token)) return true;
+  if (token === "." || token === "..") return true;
+  if (token.startsWith("./") || token.startsWith(".\\") || token.startsWith("../") || token.startsWith("..\\")) return true;
+  if (token.includes("/../") || token.includes("\\..\\") || token.includes("/..\\") || token.includes("\\../")) return true;
+  if (token.includes("/") || token.includes("\\")) return true;
+  return false;
+}
+function findExternalPathReferencesInShellCommand(command, options) {
+  const cwd = path2.resolve(options.cwd);
+  const workspaceRoot = path2.resolve(options.workspaceRoot);
+  const tokens = tokenizeShellCommand(command).map(stripPunctuation).filter(Boolean);
+  const candidates = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (!token) continue;
+    if (token === ">" || token === ">>" || token === "<" || token === "<<") {
+      const next = tokens[i + 1];
+      if (next) candidates.push(next);
+      i++;
+      continue;
+    }
+    if (token.startsWith(">") || token.startsWith("<")) {
+      const maybe = token.replace(/^[><]+/, "");
+      if (maybe) candidates.push(maybe);
+      continue;
+    }
+    if (isPathLikeToken(token)) {
+      candidates.push(token);
+    }
+  }
+  const out = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    try {
+      const abs = resolveCandidatePath(candidate, cwd);
+      if (!isSubPath(abs, workspaceRoot)) {
+        out.add(abs);
+      }
+    } catch {
+    }
+  }
+  return [...out];
+}
+function isPathInsideWorkspace(targetPath, workspaceRoot) {
+  try {
+    return isSubPath(path2.resolve(targetPath), path2.resolve(workspaceRoot));
+  } catch {
+    return false;
+  }
+}
+
+// src/validation.ts
+function validateToolArgs(args, schema) {
+  const errors = [];
+  const validated = {};
+  for (const field of schema.required || []) {
+    if (args[field] === void 0 || args[field] === null) {
+      errors.push(`Missing required field: ${field}`);
+    }
+  }
+  for (const [key, propSchema] of Object.entries(schema.properties)) {
+    const value = args[key];
+    if (value === void 0 || value === null) {
+      if (propSchema.default !== void 0) {
+        validated[key] = propSchema.default;
+      }
+      continue;
+    }
+    const typeResult = validateType(value, propSchema, key);
+    if (typeResult.error) {
+      errors.push(typeResult.error);
+    } else {
+      validated[key] = typeResult.value;
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    data: validated
+  };
+}
+function validateType(value, schema, fieldName) {
+  switch (schema.type) {
+    case "string": {
+      if (typeof value !== "string") {
+        return { error: `${fieldName}: expected string, got ${typeof value}` };
+      }
+      if (schema.enum && !schema.enum.includes(value)) {
+        return {
+          error: `${fieldName}: value '${value}' not in allowed values: ${schema.enum.join(", ")}`
+        };
+      }
+      return { value };
+    }
+    case "number": {
+      if (typeof value === "number") {
+        if (isNaN(value)) {
+          return { error: `${fieldName}: expected number, got NaN` };
+        }
+        return { value };
+      }
+      if (typeof value === "string") {
+        const num = parseFloat(value);
+        if (!isNaN(num)) {
+          return { value: num };
+        }
+      }
+      return { error: `${fieldName}: expected number, got ${typeof value}` };
+    }
+    case "boolean": {
+      if (typeof value === "boolean") {
+        return { value };
+      }
+      if (typeof value === "string") {
+        const lower = value.toLowerCase();
+        if (lower === "true" || lower === "1" || lower === "yes") return { value: true };
+        if (lower === "false" || lower === "0" || lower === "no") return { value: false };
+      }
+      return { error: `${fieldName}: expected boolean, got ${typeof value}` };
+    }
+    case "array": {
+      if (!Array.isArray(value)) {
+        return { error: `${fieldName}: expected array, got ${typeof value}` };
+      }
+      if (schema.items) {
+        const validatedItems = [];
+        for (let i = 0; i < value.length; i++) {
+          const itemResult = validateType(value[i], schema.items, `${fieldName}[${i}]`);
+          if (itemResult.error) {
+            return itemResult;
+          }
+          validatedItems.push(itemResult.value);
+        }
+        return { value: validatedItems };
+      }
+      return { value };
+    }
+    case "object": {
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return { error: `${fieldName}: expected object, got ${typeof value}` };
+      }
+      if (schema.properties) {
+        const nestedResult = validateToolArgs(value, {
+          properties: schema.properties,
+          required: schema.required
+        });
+        if (!nestedResult.valid) {
+          return { error: `${fieldName}: ${nestedResult.errors.join(", ")}` };
+        }
+        return { value: nestedResult.data };
+      }
+      return { value };
+    }
+    default:
+      return { value };
+  }
+}
+function requireString(args, field) {
+  const value = args[field];
+  if (typeof value !== "string") {
+    return { error: `${field} is required and must be a string` };
+  }
+  return { value };
+}
+function optionalString(args, field, defaultValue) {
+  const value = args[field];
+  if (value === void 0 || value === null) {
+    return defaultValue;
+  }
+  return typeof value === "string" ? value : defaultValue;
+}
+function optionalNumber(args, field, defaultValue) {
+  const value = args[field];
+  if (value === void 0 || value === null) {
+    return defaultValue;
+  }
+  if (typeof value === "number" && !isNaN(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const num = parseFloat(value);
+    if (!isNaN(num)) {
+      return num;
+    }
+  }
+  return defaultValue;
+}
+function optionalBoolean(args, field, defaultValue) {
+  const value = args[field];
+  if (value === void 0 || value === null) {
+    return defaultValue;
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "string") {
+    const lower = value.toLowerCase();
+    if (lower === "true" || lower === "1" || lower === "yes") return true;
+    if (lower === "false" || lower === "0" || lower === "no") return false;
+  }
+  return defaultValue;
+}
+var SAFE_SHELL_COMMANDS = /* @__PURE__ */ new Set([
+  "ls",
+  "dir",
+  "pwd",
+  "echo",
+  "cat",
+  "head",
+  "tail",
+  "wc",
+  "grep",
+  "find",
+  "git",
+  "npm",
+  "npx",
+  "yarn",
+  "pnpm",
+  "node",
+  "python",
+  "python3",
+  "pip",
+  "cargo",
+  "go",
+  "make",
+  "cmake",
+  "dotnet",
+  "mvn",
+  "gradle",
+  "tsc",
+  "eslint",
+  "prettier",
+  "jest",
+  "mocha",
+  "pytest",
+  "docker",
+  "kubectl",
+  "terraform",
+  "curl",
+  "wget",
+  "jq",
+  "yq"
+]);
+var BLOCKED_SHELL_PATTERNS = [
+  /\brm\s+-rf?\s+[/~]/i,
+  /\bsudo\b/i,
+  /\b(shutdown|reboot|halt)\b/i,
+  /\bdd\s+if=/i,
+  /\bmkfs/i,
+  /\bformat\b/i,
+  />[>&]\s*\/dev\//i
+];
+var SHELL_META_PATTERNS = [
+  /;/,
+  /&&/,
+  /\|\|/,
+  /\|(?!\|)/,
+  /`/,
+  /\$\(/,
+  /\$\{/,
+  /\n/,
+  /\r/
+];
+function evaluateShellCommand(command) {
+  for (const pattern of BLOCKED_SHELL_PATTERNS) {
+    if (pattern.test(command)) {
+      return { verdict: "deny", reason: "Command matches blocked pattern" };
+    }
+  }
+  for (const pattern of SHELL_META_PATTERNS) {
+    if (pattern.test(command)) {
+      return {
+        verdict: "needs_approval",
+        reason: "Command contains shell metacharacters (;, &&, ||, |, `, $()) and requires approval"
+      };
+    }
+  }
+  const baseCommand = command.trim().split(/\s+/)[0]?.split("/").pop() || "";
+  if (SAFE_SHELL_COMMANDS.has(baseCommand)) {
+    return { verdict: "allow" };
+  }
+  return { verdict: "needs_approval", reason: `Command '${baseCommand}' requires approval` };
+}
+
+// src/backgroundJobs.ts
+var cp = __toESM(require("node:child_process"), 1);
+var DEFAULT_BACKGROUND_TTL_MS = 10 * 60 * 1e3;
+var DEFAULT_BACKGROUND_KILL_GRACE_MS = 1500;
+var jobsByScope = /* @__PURE__ */ new Map();
+var exitCleanupRegistered = false;
+var sequence = 0;
+function createBackgroundJobKey(args) {
+  const normalizedCwd = args.cwd.trim();
+  const normalizedCommand = args.command.trim().replace(/\s+/g, " ");
+  return `${normalizedCwd}
+${normalizedCommand}`;
+}
+function isPidAlive(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = err.code;
+    return code === "EPERM";
+  }
+}
+function killProcessTree(pid, signal) {
+  if (!Number.isFinite(pid) || pid <= 0) return;
+  if (process.platform === "win32") {
+    try {
+      cp.execFile("taskkill", ["/pid", String(pid), "/T", "/F"], { windowsHide: true }, () => {
+      });
+    } catch {
+    }
+    return;
+  }
+  try {
+    process.kill(-pid, signal);
+  } catch {
+    try {
+      process.kill(pid, signal);
+    } catch {
+    }
+  }
+}
+function ensureExitCleanup() {
+  if (exitCleanupRegistered) return;
+  exitCleanupRegistered = true;
+  process.once("exit", () => {
+    for (const scopeJobs of jobsByScope.values()) {
+      for (const job of scopeJobs.values()) {
+        killProcessTree(job.pid, "SIGTERM");
+      }
+    }
+  });
+}
+function ensureScope(scope) {
+  let scopeJobs = jobsByScope.get(scope);
+  if (!scopeJobs) {
+    scopeJobs = /* @__PURE__ */ new Map();
+    jobsByScope.set(scope, scopeJobs);
+  }
+  return scopeJobs;
+}
+function clearTimers(entry) {
+  if (entry.ttlTimer) clearTimeout(entry.ttlTimer);
+  if (entry.killTimer) clearTimeout(entry.killTimer);
+}
+function snapshot(entry) {
+  const { ttlTimer: _ttlTimer, killTimer: _killTimer, ...rest } = entry;
+  return rest;
+}
+function getBackgroundJob(scope, key) {
+  const entry = jobsByScope.get(scope)?.get(key);
+  if (!entry) return void 0;
+  return snapshot(entry);
+}
+function listBackgroundJobs(scope) {
+  if (scope) {
+    const scopeJobs = jobsByScope.get(scope);
+    if (!scopeJobs) return [];
+    return [...scopeJobs.values()].map(snapshot);
+  }
+  const jobs = [];
+  for (const scopeJobs of jobsByScope.values()) {
+    jobs.push(...[...scopeJobs.values()].map(snapshot));
+  }
+  return jobs;
+}
+function removeBackgroundJob(scope, key) {
+  const scopeJobs = jobsByScope.get(scope);
+  if (!scopeJobs) return;
+  const entry = scopeJobs.get(key);
+  if (!entry) return;
+  clearTimers(entry);
+  scopeJobs.delete(key);
+  if (scopeJobs.size === 0) {
+    jobsByScope.delete(scope);
+  }
+}
+function expireBackgroundJob(scope, key, jobId) {
+  const scopeJobs = jobsByScope.get(scope);
+  const entry = scopeJobs?.get(key);
+  if (!entry || entry.id !== jobId) return;
+  if (!isPidAlive(entry.pid)) {
+    removeBackgroundJob(scope, key);
+    return;
+  }
+  killProcessTree(entry.pid, "SIGTERM");
+  entry.killTimer = setTimeout(() => {
+    try {
+      if (isPidAlive(entry.pid)) {
+        killProcessTree(entry.pid, "SIGKILL");
+      }
+    } finally {
+      removeBackgroundJob(scope, key);
+    }
+  }, DEFAULT_BACKGROUND_KILL_GRACE_MS);
+  entry.killTimer.unref?.();
+}
+function refreshBackgroundJob(scope, key, ttlMs) {
+  const entry = jobsByScope.get(scope)?.get(key);
+  if (!entry) return void 0;
+  const newTtlMs = ttlMs ?? entry.ttlMs;
+  entry.ttlMs = newTtlMs;
+  entry.expiresAt = Date.now() + newTtlMs;
+  if (entry.ttlTimer) clearTimeout(entry.ttlTimer);
+  if (newTtlMs > 0) {
+    entry.ttlTimer = setTimeout(() => {
+      expireBackgroundJob(scope, key, entry.id);
+    }, newTtlMs);
+    entry.ttlTimer.unref?.();
+  } else {
+    entry.ttlTimer = void 0;
+  }
+  return snapshot(entry);
+}
+function registerBackgroundJob(args) {
+  ensureExitCleanup();
+  const scopeJobs = ensureScope(args.scope);
+  const existing = scopeJobs.get(args.key);
+  if (existing) {
+    clearTimers(existing);
+  }
+  const ttlMs = Number.isFinite(args.ttlMs) && args.ttlMs >= 0 ? Math.floor(args.ttlMs) : DEFAULT_BACKGROUND_TTL_MS;
+  const createdAt = Date.now();
+  const id = `${createdAt.toString(36)}-${(++sequence).toString(36)}`;
+  const entry = {
+    id,
+    scope: args.scope,
+    key: args.key,
+    command: args.command,
+    cwd: args.cwd,
+    pid: args.pid,
+    createdAt,
+    ttlMs,
+    expiresAt: createdAt + ttlMs
+  };
+  scopeJobs.set(args.key, entry);
+  if (ttlMs > 0) {
+    entry.ttlTimer = setTimeout(() => {
+      expireBackgroundJob(args.scope, args.key, entry.id);
+    }, ttlMs);
+    entry.ttlTimer.unref?.();
+  }
+  return snapshot(entry);
+}
+function cleanupDeadBackgroundJobs(scope) {
+  const scopes = scope ? [scope] : [...jobsByScope.keys()];
+  for (const s of scopes) {
+    const scopeJobs = jobsByScope.get(s);
+    if (!scopeJobs) continue;
+    for (const [key, entry] of scopeJobs.entries()) {
+      if (!isPidAlive(entry.pid)) {
+        removeBackgroundJob(s, key);
+      }
+    }
+  }
+}
+
+// src/history.ts
+function createUserHistoryMessage(text, options) {
+  const metadata = {};
+  if (options?.synthetic) {
+    metadata.synthetic = true;
+  }
+  if (options?.compaction) {
+    metadata.compaction = options.compaction;
+  }
+  return {
+    id: crypto.randomUUID(),
+    role: "user",
+    ...Object.keys(metadata).length > 0 ? { metadata } : {},
+    parts: [{ type: "text", text }]
+  };
+}
+function createAssistantHistoryMessage() {
+  return {
+    id: crypto.randomUUID(),
+    role: "assistant",
+    parts: []
+  };
+}
+function getMessageText(message) {
+  return message.parts.filter((part) => part.type === "text").map((part) => part.text).join("");
+}
+function appendText(message, delta) {
+  if (!delta) return;
+  const last = message.parts.at(-1);
+  if (last && last.type === "text" && last.state !== "done") {
+    last.text += delta;
+    last.state = "streaming";
+    return;
+  }
+  message.parts.push({ type: "text", text: delta, state: "streaming" });
+}
+function appendReasoning(message, delta) {
+  if (!delta) return;
+  const last = message.parts.at(-1);
+  if (last && last.type === "reasoning" && last.state !== "done") {
+    last.text += delta;
+    last.state = "streaming";
+    return;
+  }
+  message.parts.push({ type: "reasoning", text: delta, state: "streaming" });
+}
+function upsertDynamicToolCall(message, params) {
+  const existing = message.parts.find(
+    (p) => p.type === "dynamic-tool" && p.toolCallId === params.toolCallId
+  );
+  if (existing) {
+    if (existing.state === "input-streaming") {
+      existing.state = "input-available";
+    }
+    existing.input = params.input;
+    existing.toolName = params.toolName;
+    return existing;
+  }
+  const part = {
+    type: "dynamic-tool",
+    toolName: params.toolName,
+    toolCallId: params.toolCallId,
+    state: "input-available",
+    input: params.input
+  };
+  message.parts.push(part);
+  return part;
+}
+function setDynamicToolOutput(message, params) {
+  const part = upsertDynamicToolCall(message, {
+    toolName: params.toolName,
+    toolCallId: params.toolCallId,
+    input: params.input
+  });
+  part.state = "output-available";
+  part.output = params.output;
+  delete part.errorText;
+}
+function setDynamicToolError(message, params) {
+  const part = upsertDynamicToolCall(message, {
+    toolName: params.toolName,
+    toolCallId: params.toolCallId,
+    input: params.input
+  });
+  part.state = "output-available";
+  part.output = { success: false, error: params.errorText };
+  delete part.errorText;
+}
+function finalizeStreamingParts(message) {
+  for (const part of message.parts) {
+    if (part.type === "text" || part.type === "reasoning") {
+      if (part.state === "streaming") {
+        part.state = "done";
+      }
+    }
+  }
+}
+
+// src/compaction.ts
+var COMPACTION_MARKER_TEXT = "What did we do so far?";
+var COMPACTION_PROMPT_TEXT = "Provide a detailed prompt for continuing our conversation above. Focus on information that would be helpful for continuing the conversation, including what we did, what we are doing, which files we are working on, and what we should do next. Assume a new session will not have access to the previous conversation.";
+var COMPACTION_AUTO_CONTINUE_TEXT = "Continue if you have next steps.";
+var COMPACTED_TOOL_PLACEHOLDER = "[Old tool result content cleared]";
+var COMPACTION_SYSTEM_PROMPT = "You are a helpful AI assistant tasked with summarizing conversations.\n\nWhen asked to summarize, provide a detailed but concise summary of the conversation.\nFocus on information that would be helpful for continuing the conversation, including:\n- What was done\n- What is currently being worked on\n- Which files are being modified\n- What needs to be done next\n- Key user requests, constraints, or preferences that should persist\n- Important technical decisions and why they were made\n\nYour summary should be comprehensive enough to provide context but concise enough to be quickly understood.";
+function asFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function getReservedOutputTokens(params) {
+  const maxOutputTokens = Math.max(0, Math.floor(params.maxOutputTokens));
+  const modelOutput = params.modelLimit?.output;
+  if (typeof modelOutput === "number" && Number.isFinite(modelOutput) && modelOutput > 0) {
+    return Math.min(Math.floor(modelOutput), maxOutputTokens);
+  }
+  return maxOutputTokens;
+}
+function extractUsageTokens(usage) {
+  if (!usage || typeof usage !== "object") return void 0;
+  const inputTokens = usage.inputTokens;
+  const outputTokens = usage.outputTokens;
+  if (typeof inputTokens === "number" || inputTokens === void 0) {
+    const inputTotal2 = asFiniteNumber(inputTokens);
+    const details = usage.inputTokenDetails;
+    const inputNoCache2 = asFiniteNumber(details?.noCacheTokens);
+    const cacheRead2 = asFiniteNumber(details?.cacheReadTokens);
+    const cacheWrite2 = asFiniteNumber(details?.cacheWriteTokens);
+    const outputTotal2 = asFiniteNumber(outputTokens);
+    const input2 = inputNoCache2 ?? inputTotal2;
+    const computedTotal = (inputNoCache2 !== void 0 ? (inputNoCache2 || 0) + (cacheRead2 || 0) : inputTotal2 || 0) + (outputTotal2 || 0);
+    const total2 = asFiniteNumber(usage.totalTokens) ?? computedTotal;
+    return {
+      input: input2,
+      output: outputTotal2,
+      cacheRead: cacheRead2,
+      cacheWrite: cacheWrite2,
+      total: total2,
+      raw: usage.raw
+    };
+  }
+  const inputTotal = asFiniteNumber(inputTokens?.total);
+  const inputNoCache = asFiniteNumber(inputTokens?.noCache);
+  const cacheRead = asFiniteNumber(inputTokens?.cacheRead);
+  const cacheWrite = asFiniteNumber(inputTokens?.cacheWrite);
+  const outputTotal = asFiniteNumber(outputTokens?.total);
+  const input = inputNoCache ?? inputTotal;
+  const output = outputTotal;
+  const total = (inputNoCache !== void 0 ? (inputNoCache || 0) + (cacheRead || 0) : inputTotal || 0) + (outputTotal || 0);
+  return {
+    input,
+    output,
+    cacheRead,
+    cacheWrite,
+    total,
+    raw: usage.raw
+  };
+}
+function getEffectiveHistory(history) {
+  for (let i = history.length - 1; i >= 0; i--) {
+    const msg = history[i];
+    if (msg.role === "assistant" && msg.metadata?.summary) {
+      const maybeMarker = i > 0 ? history[i - 1] : void 0;
+      if (maybeMarker?.role === "user" && maybeMarker.metadata?.compaction) {
+        return history.slice(i - 1);
+      }
+      return history.slice(i);
+    }
+  }
+  return history;
+}
+function estimateTokensFromString(text) {
+  return Math.ceil(text.length / 4);
+}
+function estimateTokensFromUnknown(value) {
+  if (value === void 0 || value === null) return 0;
+  if (typeof value === "string") return estimateTokensFromString(value);
+  try {
+    return estimateTokensFromString(JSON.stringify(value));
+  } catch {
+    return estimateTokensFromString(String(value));
+  }
+}
+function isCompletedToolPart(part) {
+  if (!part || typeof part !== "object") return false;
+  if (part.type !== "dynamic-tool") return false;
+  const state = String(part.state || "");
+  return state === "output-available";
+}
+function getToolOutputTokens(part) {
+  return estimateTokensFromUnknown(part.output);
+}
+function markPrunableToolOutputs(history, config) {
+  if (!config.prune) {
+    return { totalToolOutputTokens: 0, prunedTokens: 0, markedParts: 0 };
+  }
+  let total = 0;
+  let pruned = 0;
+  let turns = 0;
+  const toMark = [];
+  for (let msgIndex = history.length - 1; msgIndex >= 0; msgIndex--) {
+    const msg = history[msgIndex];
+    if (msg.role === "user") turns++;
+    if (turns < 2) continue;
+    if (msg.role === "assistant" && msg.metadata?.summary) break;
+    for (let partIndex = msg.parts.length - 1; partIndex >= 0; partIndex--) {
+      const part = msg.parts[partIndex];
+      if (!isCompletedToolPart(part)) continue;
+      if (part.compactedAt) {
+        msgIndex = -1;
+        break;
+      }
+      const estimate = getToolOutputTokens(part);
+      total += estimate;
+      if (total > config.pruneProtectTokens) {
+        pruned += estimate;
+        toMark.push({ msgIndex, partIndex, tokens: estimate });
+      }
+    }
+  }
+  if (pruned <= config.pruneMinimumTokens) {
+    return { totalToolOutputTokens: total, prunedTokens: 0, markedParts: 0 };
+  }
+  const now = Date.now();
+  for (const item of toMark) {
+    const msg = history[item.msgIndex];
+    const part = msg.parts[item.partIndex];
+    if (!part || !isCompletedToolPart(part)) continue;
+    part.compactedAt = now;
+  }
+  return { totalToolOutputTokens: total, prunedTokens: pruned, markedParts: toMark.length };
+}
+function createHistoryForModel(history) {
+  return history.map((msg) => {
+    const copied = {
+      ...msg,
+      metadata: msg.metadata ? { ...msg.metadata } : void 0,
+      parts: msg.parts.map((part) => {
+        if (part.type !== "dynamic-tool") return part;
+        const anyPart = part;
+        if (!anyPart.compactedAt) return part;
+        if (anyPart.output === void 0) return part;
+        const output = anyPart.output;
+        const replacement = output && typeof output === "object" && typeof output.success === "boolean" ? {
+          ...output,
+          data: COMPACTED_TOOL_PLACEHOLDER,
+          metadata: { ...output.metadata || {}, compacted: true }
+        } : COMPACTED_TOOL_PLACEHOLDER;
+        return { ...anyPart, output: replacement };
+      })
+    };
+    return copied;
+  });
+}
+function isOverflow(params) {
+  if (!params.config.auto) return false;
+  const context = params.modelLimit?.context;
+  if (!context || context <= 0) return false;
+  const usable = context - Math.max(0, params.reservedOutputTokens);
+  if (usable <= 0) return false;
+  const used = params.lastTokens?.total;
+  if (!used || used <= 0) return false;
+  return used > usable;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  COMPACTED_TOOL_PLACEHOLDER,
+  COMPACTION_AUTO_CONTINUE_TEXT,
+  COMPACTION_MARKER_TEXT,
+  COMPACTION_PROMPT_TEXT,
+  COMPACTION_SYSTEM_PROMPT,
+  DEFAULT_BACKGROUND_KILL_GRACE_MS,
+  DEFAULT_BACKGROUND_TTL_MS,
+  appendReasoning,
+  appendText,
+  cleanupDeadBackgroundJobs,
+  createAssistantHistoryMessage,
+  createBackgroundJobKey,
+  createHistoryForModel,
+  createUserHistoryMessage,
+  evaluatePermission,
+  evaluateShellCommand,
+  expandHome,
+  extractUsageTokens,
+  finalizeStreamingParts,
+  findExternalPathReferencesInShellCommand,
+  getBackgroundJob,
+  getEffectiveHistory,
+  getMessageText,
+  getReservedOutputTokens,
+  isOverflow,
+  isPathInsideWorkspace,
+  isPidAlive,
+  isSubPath,
+  killProcessTree,
+  listBackgroundJobs,
+  markPrunableToolOutputs,
+  mergeRulesets,
+  normalizeFsPath,
+  optionalBoolean,
+  optionalNumber,
+  optionalString,
+  refreshBackgroundJob,
+  registerBackgroundJob,
+  removeBackgroundJob,
+  requireString,
+  setDynamicToolError,
+  setDynamicToolOutput,
+  upsertDynamicToolCall,
+  validateToolArgs,
+  wildcardMatch
+});