@moikapy/lich 0.3.0

package/dist/chunk-P52U5M3L.js

@@ -0,0 +1,3431 @@
+// src/tools/builtin/disk_usage.ts
+import { execFile } from "child_process";
+import { readdir } from "fs/promises";
+import path2 from "path";
+
+// src/tools/guard.ts
+import path from "path";
+
+// src/util/json.ts
+function safe_json_parse(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function safe_stringify(value, space) {
+  try {
+    return JSON.stringify(value, null, space) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+function truncate_text(text, max_chars) {
+  if (text.length <= max_chars) {
+    return text;
+  }
+  const omitted = text.length - max_chars;
+  return `${text.slice(0, max_chars)}
+[... truncated, ${omitted} chars omitted ...]`;
+}
+
+// src/tools/guard.ts
+var DEFAULT_MAX_OUTPUT_CHARS = 2e4;
+var DEFAULT_TOOL_TIMEOUT_MS = 3e4;
+function resolve_safe_path(base_dir, target) {
+  const base = path.resolve(base_dir);
+  const resolved = path.resolve(base, target);
+  const relative = path.relative(base, resolved);
+  if (relative.startsWith("..") === true || path.isAbsolute(relative) === true) {
+    throw new Error(`path_escape: ${target} escapes ${base_dir}`);
+  }
+  return resolved;
+}
+function require_string_arg(args, key) {
+  const value = args[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`missing_arg: ${key}`);
+  }
+  return value;
+}
+function optional_string_arg(args, key, fallback) {
+  const value = args[key];
+  if (typeof value === "string" && value.length > 0) {
+    return value;
+  }
+  return fallback;
+}
+function optional_number_arg(args, key, fallback) {
+  const value = args[key];
+  if (typeof value === "number" && Number.isFinite(value) === true) {
+    return value;
+  }
+  return fallback;
+}
+function optional_boolean_arg(args, key, fallback) {
+  const value = args[key];
+  if (typeof value === "boolean") {
+    return value;
+  }
+  return fallback;
+}
+var ToolTimeoutError = class extends Error {
+  constructor(label, timeout_ms) {
+    super(`timeout: ${label} exceeded ${timeout_ms}ms`);
+    this.name = "ToolTimeoutError";
+  }
+};
+function with_timeout(promise_factory, timeout_ms, label) {
+  const controller = new AbortController();
+  const holder = {};
+  const timeout_promise = new Promise((_resolve, reject) => {
+    holder.timer = setTimeout(() => {
+      controller.abort();
+      reject(new ToolTimeoutError(label, timeout_ms));
+    }, timeout_ms);
+  });
+  const raced = promise_factory(controller.signal);
+  raced.catch(() => void 0);
+  return Promise.race([raced, timeout_promise]).finally(() => {
+    const timer = holder.timer;
+    if (timer !== void 0) {
+      clearTimeout(timer);
+    }
+  });
+}
+function clamp_output(text, max_chars = DEFAULT_MAX_OUTPUT_CHARS) {
+  return truncate_text(text, max_chars);
+}
+function is_enoent(err) {
+  if (typeof err !== "object" || err === null) {
+    return false;
+  }
+  const code = err.code;
+  return code === "ENOENT";
+}
+function error_result(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return { ok: false, output: "", error: message };
+}
+async function capture_errors(run) {
+  try {
+    return await run();
+  } catch (err) {
+    return error_result(err);
+  }
+}
+
+// src/tools/builtin/fetch_url.ts
+var DEFAULT_MAX_CHARS = 2e4;
+var MAX_MAX_CHARS = 1e5;
+var DEFAULT_TIMEOUT_MS = 2e4;
+var MAX_TIMEOUT_MS = 6e4;
+var USER_AGENT = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36";
+var parameters = {
+  type: "object",
+  properties: {
+    url: { type: "string", description: "Absolute http:// or https:// URL to GET" },
+    max_chars: { type: "number", description: "Clamp the body to this many chars (default 20000, max 100000)" },
+    timeout_ms: { type: "number", description: "Abort the request after this many ms (default 20000, max 60000)" }
+  },
+  required: ["url"],
+  additionalProperties: false
+};
+function clamp_int_arg(args, key, fallback, max) {
+  return Math.min(max, Math.max(1, Math.floor(optional_number_arg(args, key, fallback))));
+}
+function valid_http_url(raw) {
+  let parsed;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    throw new Error(`invalid_url: ${raw}`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error(`invalid_url: unsupported protocol ${parsed.protocol}`);
+  }
+}
+function compose_abort_signal(timeout_ms, external) {
+  const timeout_signal = AbortSignal.timeout(timeout_ms);
+  return external === void 0 ? timeout_signal : AbortSignal.any([timeout_signal, external]);
+}
+async function run_fetch_url(args, external) {
+  const url = require_string_arg(args, "url");
+  valid_http_url(url);
+  const max_chars = clamp_int_arg(args, "max_chars", DEFAULT_MAX_CHARS, MAX_MAX_CHARS);
+  const timeout_ms = clamp_int_arg(args, "timeout_ms", DEFAULT_TIMEOUT_MS, MAX_TIMEOUT_MS);
+  const response = await fetch(url, {
+    redirect: "follow",
+    headers: { "user-agent": USER_AGENT },
+    signal: compose_abort_signal(timeout_ms, external)
+  });
+  const content_type = response.headers.get("content-type") ?? "";
+  if (response.ok === false) {
+    return { ok: false, output: "", error: `http_${response.status}` };
+  }
+  if (content_type.startsWith("image/") === true || content_type.startsWith("application/octet-stream") === true) {
+    return { ok: false, output: "", error: `unsupported_content_type: ${content_type}` };
+  }
+  const text = await response.text();
+  const marker = content_type.toLowerCase().includes("text/html") === true ? "[html content]\n" : "";
+  const body = clamp_output(`${marker}${text}`, max_chars);
+  return { ok: true, output: `${header_line(response, text)}
+${body}` };
+}
+function header_line(response, text) {
+  const content_type = response.headers.get("content-type") ?? "unknown";
+  const declared = Number.parseInt(response.headers.get("content-length") ?? "", 10);
+  const bytes = Number.isFinite(declared) === true ? declared : Buffer.byteLength(text, "utf8");
+  return `# ${response.status} ${content_type} (${bytes} bytes)`;
+}
+var fetch_url_tool = {
+  name: "fetch_url",
+  description: "GET an http(s) URL and return the response body text with a status header; rejects binary content.",
+  parameters,
+  execute: async (args, context) => capture_errors(async () => run_fetch_url(args, context.signal))
+};
+
+// src/tools/builtin/disk_usage.ts
+var DEFAULT_MAX_ENTRIES = 25;
+var MAX_MAX_ENTRIES = 200;
+var DU_TIMEOUT_MS = 1e4;
+var parameters2 = {
+  type: "object",
+  properties: {
+    path: { type: "string", description: "Directory to measure, relative to the working directory (default .)" },
+    max_entries: { type: "number", description: "Show at most this many entries (default 25, max 200)" }
+  },
+  additionalProperties: false
+};
+function run_du(entry_path) {
+  return new Promise((resolve) => {
+    execFile("du", ["-sb", entry_path], { timeout: DU_TIMEOUT_MS }, (err, stdout) => {
+      if (err !== null) {
+        resolve(-1);
+        return;
+      }
+      const parsed = Number.parseInt(stdout.trim().split("	")[0] ?? "", 10);
+      resolve(Number.isFinite(parsed) === true ? parsed : -1);
+    });
+  });
+}
+async function measure_entries(root) {
+  const entries = await readdir(root, { withFileTypes: true });
+  const measured = [];
+  for (const entry of entries) {
+    const bytes = await run_du(path2.join(root, entry.name));
+    if (bytes < 0) {
+      return null;
+    }
+    measured.push({ name: entry.name, bytes });
+  }
+  return measured;
+}
+function format_usage(usage, max_entries) {
+  const sorted = [...usage].sort((a, b) => b.bytes - a.bytes);
+  const total = sorted.reduce((sum, entry) => sum + entry.bytes, 0);
+  const shown = sorted.slice(0, max_entries);
+  const lines = shown.map((entry) => `${entry.bytes}	${entry.name}`);
+  if (sorted.length > shown.length) {
+    lines.push(`(... ${sorted.length - shown.length} more entries suppressed)`);
+  }
+  lines.push(`TOTAL	${total}`);
+  return lines.join("\n");
+}
+async function run_disk_usage(args, work_dir) {
+  const target = optional_string_arg(args, "path", ".");
+  const max_entries = clamp_int_arg(args, "max_entries", DEFAULT_MAX_ENTRIES, MAX_MAX_ENTRIES);
+  const root = resolve_safe_path(work_dir, target);
+  const usage = await measure_entries(root);
+  if (usage === null) {
+    throw new Error("du_unavailable");
+  }
+  return format_usage(usage, max_entries);
+}
+var disk_usage_tool = {
+  name: "disk_usage",
+  description: "Measure depth-1 directory/file sizes with du -sb and report sorted sizes plus a total.",
+  parameters: parameters2,
+  execute: async (args, context) => capture_errors(async () => ({ ok: true, output: await run_disk_usage(args, context.work_dir) }))
+};
+
+// src/tools/builtin/docs_read.ts
+import { readdirSync, readFileSync, statSync } from "fs";
+import { fileURLToPath } from "url";
+import path3 from "path";
+var MAX_DOC_OUTPUT_CHARS = 3e4;
+var DEFAULT_DOC_LIMIT = 400;
+var DOCS_UNAVAILABLE = "docs_unavailable: set LICH_DOCS_DIR or install the lich package with docs";
+var MAX_AVAILABLE_LISTED = 8;
+var MAX_WALK_DEPTH = 4;
+var PACKAGE_DOCS_CANDIDATES = ["../../docs/", "../docs/"];
+var cached_root;
+var cached_files;
+var parameters3 = {
+  type: "object",
+  properties: {
+    path: { type: "string", description: "Doc path relative to the lich docs root (e.g. index.md or user-guide/cli.md)" },
+    offset: { type: "number", description: "1-based line number to start reading from" },
+    limit: { type: "number", description: "Maximum number of lines to return (default 400)" }
+  },
+  required: ["path"],
+  additionalProperties: false
+};
+function dir_with_index(candidate) {
+  try {
+    if (statSync(candidate).isDirectory() === false) {
+      return void 0;
+    }
+    if (statSync(path3.join(candidate, "index.md")).isFile() === false) {
+      return void 0;
+    }
+    return path3.resolve(candidate);
+  } catch {
+    return void 0;
+  }
+}
+function env_docs_root(value) {
+  if (value === void 0 || value.length === 0) {
+    return void 0;
+  }
+  const nested = dir_with_index(path3.join(value, "docs"));
+  if (nested !== void 0) {
+    return nested;
+  }
+  return dir_with_index(value);
+}
+function package_docs_root() {
+  for (const candidate of PACKAGE_DOCS_CANDIDATES) {
+    try {
+      const found = dir_with_index(fileURLToPath(new URL(candidate, import.meta.url)));
+      if (found !== void 0) {
+        return found;
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+function default_resolve_docs_root(context) {
+  if (cached_root !== void 0) {
+    return cached_root;
+  }
+  const candidates = [
+    env_docs_root(context.env["LICH_DOCS_DIR"]),
+    dir_with_index(path3.join(context.work_dir, "docs")),
+    package_docs_root()
+  ];
+  for (const candidate of candidates) {
+    if (candidate !== void 0) {
+      cached_root = candidate;
+      return candidate;
+    }
+  }
+  return void 0;
+}
+var active_resolver = default_resolve_docs_root;
+function resolve_docs_root(context) {
+  return active_resolver(context);
+}
+function collect_doc_entries(current, root, files, stack) {
+  let entries;
+  try {
+    entries = readdirSync(current.dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const full = path3.join(current.dir, entry.name);
+    if (entry.isDirectory() === true) {
+      if (entry.name !== ".vitepress" && current.depth < MAX_WALK_DEPTH) {
+        stack.push({ dir: full, depth: current.depth + 1 });
+      }
+      continue;
+    }
+    if (entry.isFile() === true && entry.name.endsWith(".md") === true) {
+      files.push(path3.relative(root, full));
+    }
+  }
+}
+function walk_doc_files(root) {
+  const files = [];
+  const stack = [{ dir: path3.resolve(root), depth: 0 }];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current === void 0) {
+      continue;
+    }
+    collect_doc_entries(current, path3.resolve(root), files, stack);
+  }
+  files.sort();
+  return files;
+}
+function list_doc_files(root) {
+  if (cached_root === root && cached_files !== void 0) {
+    return cached_files;
+  }
+  const files = walk_doc_files(root);
+  if (cached_root === root) {
+    cached_files = files;
+  }
+  return files;
+}
+function require_docs_root(context) {
+  const root = resolve_docs_root(context);
+  if (root === void 0) {
+    throw new Error(DOCS_UNAVAILABLE);
+  }
+  return root;
+}
+function not_found_error(target, files) {
+  const listed = files.slice(0, MAX_AVAILABLE_LISTED).join(", ");
+  return `not_found: ${target} (available: ${listed.length > 0 ? listed : "none"})`;
+}
+function resolve_doc_rel(root, files, target) {
+  if (path3.isAbsolute(target) === true) {
+    throw new Error(`path_escape: ${target} is not relative to the docs root`);
+  }
+  const absolute = resolve_safe_path(root, target);
+  const rel = path3.relative(path3.resolve(root), absolute);
+  if (files.includes(rel) === true) {
+    return rel;
+  }
+  if (rel.endsWith(".md") === false && files.includes(`${rel}.md`) === true) {
+    return `${rel}.md`;
+  }
+  return void 0;
+}
+function clamp_line_arg(args, key, fallback) {
+  return Math.max(1, Math.trunc(optional_number_arg(args, key, fallback)));
+}
+function slice_lines(content, offset, limit) {
+  const lines = content.split("\n");
+  const start = Math.min(Math.max(0, offset - 1), lines.length);
+  const end = Math.min(lines.length, start + Math.max(0, limit));
+  const picked = [];
+  for (let index = start; index < end; index += 1) {
+    const line = lines[index];
+    if (line !== void 0) {
+      picked.push(line);
+    }
+  }
+  return picked.join("\n");
+}
+var docs_read_tool = {
+  name: "docs_read",
+  description: "Read one bundled lich doc file, optionally sliced by 1-based line offset and line limit.",
+  parameters: parameters3,
+  execute: async (args, context) => capture_errors(async () => {
+    const root = require_docs_root(context);
+    const target = require_string_arg(args, "path");
+    const files = list_doc_files(root);
+    const rel = resolve_doc_rel(root, files, target);
+    if (rel === void 0) {
+      return { ok: false, output: "", error: not_found_error(target, files) };
+    }
+    try {
+      const content = readFileSync(path3.join(root, rel), "utf8");
+      const body = slice_lines(content, clamp_line_arg(args, "offset", 1), clamp_line_arg(args, "limit", DEFAULT_DOC_LIMIT));
+      return { ok: true, output: clamp_output(`# lich doc: ${rel}
+${body}`, MAX_DOC_OUTPUT_CHARS) };
+    } catch (err) {
+      if (is_enoent(err) === true) {
+        return { ok: false, output: "", error: not_found_error(target, files) };
+      }
+      throw err;
+    }
+  })
+};
+
+// src/tools/builtin/docs_search.ts
+import { readFileSync as readFileSync2 } from "fs";
+import path4 from "path";
+var DEFAULT_MAX_RESULTS = 5;
+var MAX_RESULTS_CAP = 20;
+var SNIPPET_CHARS = 160;
+var MAX_TERM_HITS = 5;
+var PHRASE_BONUS = 10;
+var TITLE_SCORE = 3;
+var FILENAME_SCORE = 2;
+var BODY_SCORE = 1;
+var MAX_DOC_OUTPUT_CHARS2 = 2e4;
+var STOP_WORDS = /* @__PURE__ */ new Set(["the", "a", "an", "is", "how", "to", "in", "for", "of", "and", "or"]);
+var cached_sections;
+var cached_sections_list = [];
+var parameters4 = {
+  type: "object",
+  properties: {
+    query: { type: "string", description: "Words to look for across all lich docs" },
+    max_results: { type: "number", description: "Maximum number of results (default 5, cap 20)" }
+  },
+  required: ["query"],
+  additionalProperties: false
+};
+function split_sections(rel_path, content) {
+  const sections = [];
+  const heading = `# ${rel_path}`;
+  const chunks = content.split(/^## /m);
+  for (let index = 0; index < chunks.length; index += 1) {
+    const chunk = chunks[index];
+    if (chunk === void 0 || chunk.length === 0) {
+      continue;
+    }
+    if (index === 0) {
+      sections.push({ rel_path, heading, body: chunk });
+      continue;
+    }
+    const newline = chunk.indexOf("\n");
+    const title = newline === -1 ? chunk : chunk.slice(0, newline);
+    const body = newline === -1 ? "" : chunk.slice(newline + 1);
+    sections.push({ rel_path, heading: `## ${title}`, body });
+  }
+  return sections;
+}
+function build_section_index(root, files) {
+  const sections = [];
+  for (const rel_path of files) {
+    try {
+      sections.push(...split_sections(rel_path, readFileSync2(path4.join(root, rel_path), "utf8")));
+    } catch {
+    }
+  }
+  return sections;
+}
+function load_sections(root, files) {
+  if (cached_sections === root) {
+    return cached_sections_list;
+  }
+  const sections = build_section_index(root, files);
+  cached_sections = root;
+  cached_sections_list = sections;
+  return sections;
+}
+function query_terms(query) {
+  const terms = [];
+  for (const raw of query.toLowerCase().split(/[^a-z0-9]+/i)) {
+    if (raw.length > 0 && STOP_WORDS.has(raw) === false) {
+      terms.push(raw);
+    }
+  }
+  return terms;
+}
+function count_term(haystack, term) {
+  let count = 0;
+  let position = haystack.indexOf(term);
+  while (position !== -1 && count < MAX_TERM_HITS) {
+    count += 1;
+    position = haystack.indexOf(term, position + term.length);
+  }
+  return count;
+}
+function score_sections(query, sections) {
+  const lower_query = query.toLowerCase();
+  const terms = query_terms(query);
+  const scored = [];
+  for (const section of sections) {
+    let score = 0;
+    const lower_heading = section.heading.toLowerCase();
+    const lower_body = section.body.toLowerCase();
+    for (const term of terms) {
+      if (lower_heading.includes(term) === true) {
+        score += TITLE_SCORE;
+      }
+      if (section.rel_path.toLowerCase().includes(term) === true) {
+        score += FILENAME_SCORE;
+      }
+      score += BODY_SCORE * count_term(lower_body, term);
+    }
+    if (terms.length > 0 && lower_body.includes(lower_query) === true) {
+      score += PHRASE_BONUS;
+    }
+    if (score > 0) {
+      scored.push({ ...section, score });
+    }
+  }
+  scored.sort((left, right) => right.score - left.score);
+  return scored;
+}
+function first_term_match(section, terms) {
+  for (const term of terms) {
+    const position = section.body.toLowerCase().indexOf(term);
+    if (position !== -1) {
+      const start = Math.max(0, position - 40);
+      return section.body.slice(start, start + SNIPPET_CHARS).replace(/\s+/g, " ").trim();
+    }
+  }
+  return section.body.replace(/\s+/g, " ").slice(0, SNIPPET_CHARS).trim();
+}
+function flatten_results(query, sections, max_results) {
+  const scored = score_sections(query, sections);
+  if (scored.length === 0) {
+    return `no results for: ${query}`;
+  }
+  const terms = query_terms(query);
+  const lines = [];
+  for (let index = 0; index < Math.min(scored.length, max_results); index += 1) {
+    const hit = scored[index];
+    if (hit === void 0) {
+      continue;
+    }
+    lines.push(`${index + 1}. ${hit.rel_path} \u2014 ${hit.heading} (score ${hit.score})`);
+    lines.push(`   ${first_term_match(hit, terms)}`);
+  }
+  return lines.join("\n");
+}
+var docs_search_tool = {
+  name: "docs_search",
+  description: "Search across all bundled lich docs; returns scored section matches with short excerpts.",
+  parameters: parameters4,
+  execute: async (args, context) => capture_errors(async () => {
+    const root = require_docs_root(context);
+    const query = require_string_arg(args, "query");
+    const max_results = Math.min(
+      MAX_RESULTS_CAP,
+      Math.max(1, Math.trunc(optional_number_arg(args, "max_results", DEFAULT_MAX_RESULTS)))
+    );
+    const output = flatten_results(query, load_sections(root, list_doc_files(root)), max_results);
+    return { ok: true, output: clamp_output(output, MAX_DOC_OUTPUT_CHARS2) };
+  })
+};
+
+// src/tools/builtin/edit_file.ts
+import { readFile, writeFile } from "fs/promises";
+var parameters5 = {
+  type: "object",
+  properties: {
+    path: { type: "string", description: "File to edit, relative to the working directory" },
+    old_string: { type: "string", description: "Exact text to replace (must be unique unless replace_all)" },
+    new_string: { type: "string", description: "Replacement text" },
+    replace_all: { type: "boolean", description: "Replace every occurrence instead of failing on multiples" }
+  },
+  required: ["path", "old_string", "new_string"],
+  additionalProperties: false
+};
+function count_occurrences(content, needle) {
+  return content.split(needle).length - 1;
+}
+function replacement_for(content, old_string, new_string, replace_all) {
+  if (replace_all === true) {
+    return content.split(old_string).join(new_string);
+  }
+  return content.replace(old_string, new_string);
+}
+async function apply_edit(work_dir, target, old_string, new_string, replace_all) {
+  const file_path = resolve_safe_path(work_dir, target);
+  let content;
+  try {
+    content = await readFile(file_path, "utf8");
+  } catch (err) {
+    if (is_enoent(err) === true) {
+      throw new Error(`not_found: ${target}`);
+    }
+    throw err;
+  }
+  const occurrences = count_occurrences(content, old_string);
+  if (occurrences === 0) {
+    throw new Error("old_string_not_found");
+  }
+  if (occurrences > 1 && replace_all === false) {
+    throw new Error(`old_string_not_unique (${occurrences} occurrences)`);
+  }
+  const updated = replacement_for(content, old_string, new_string, replace_all);
+  await writeFile(file_path, updated, "utf8");
+  const replaced = replace_all === true ? occurrences : 1;
+  return { output: `edited ${target} (replaced ${replaced} occurrence(s))`, replaced };
+}
+var edit_file_tool = {
+  name: "edit_file",
+  description: "Replace an exact string in a text file; fails on missing or non-unique matches unless replace_all.",
+  parameters: parameters5,
+  execute: async (args, context) => capture_errors(async () => {
+    const target = require_string_arg(args, "path");
+    const old_string = require_string_arg(args, "old_string");
+    const new_string = require_string_arg(args, "new_string");
+    const replace_all = optional_boolean_arg(args, "replace_all", false);
+    const result = await apply_edit(context.work_dir, target, old_string, new_string, replace_all);
+    return { ok: true, output: result.output };
+  })
+};
+
+// src/tools/builtin/env_get.ts
+var MAX_KEYS = 50;
+var MAX_VALUE_CHARS = 2e3;
+var SECRET_PATTERN = /(secret|token|password|key|credential|auth)/i;
+var parameters6 = {
+  type: "object",
+  properties: {
+    keys: { type: "array", description: "Up to 50 variable names to inspect", items: { type: "string" } },
+    prefix: { type: "string", description: "Match variable names starting with this prefix" },
+    reveal: { type: "boolean", description: "Show values for non-secret keys (default false)" }
+  },
+  additionalProperties: false
+};
+function read_keys(args) {
+  const raw = args.keys;
+  if (Array.isArray(raw) === false) {
+    return [];
+  }
+  const names = [];
+  for (const item of raw) {
+    if (typeof item === "string" && item.length > 0 && names.length < MAX_KEYS) {
+      names.push(item);
+    }
+  }
+  return names;
+}
+function reveal_line(name) {
+  const value = process.env[name] ?? "";
+  if (SECRET_PATTERN.test(name) === true) {
+    return `${name}=<redacted: ${value.length} chars>`;
+  }
+  return `${name}=${value.slice(0, MAX_VALUE_CHARS)}`;
+}
+function summary_line(name) {
+  const value = process.env[name];
+  if (value === void 0) {
+    return `${name}=<unset>`;
+  }
+  return `${name}=set (${value.length} chars)`;
+}
+function prefix_names(prefix) {
+  const names = [];
+  for (const name of Object.keys(process.env)) {
+    if (name.startsWith(prefix) === true) {
+      names.push(name);
+    }
+  }
+  return names.sort();
+}
+function list_all_names() {
+  const names = Object.keys(process.env).sort();
+  return `${names.length} variables: ${names.join(", ")}`;
+}
+function run_env_get(args) {
+  const reveal = optional_boolean_arg(args, "reveal", false);
+  const prefix = typeof args.prefix === "string" ? args.prefix : "";
+  const keys = read_keys(args);
+  if (keys.length === 0 && prefix.length === 0) {
+    return list_all_names();
+  }
+  const names = keys.length > 0 ? keys : prefix_names(prefix);
+  const lines = names.map((name) => reveal === true ? reveal_line(name) : summary_line(name));
+  return lines.join("\n");
+}
+var env_get_tool = {
+  name: "env_get",
+  description: "Inspect environment variables: names by default, lengths unless reveal=true (secrets always masked).",
+  parameters: parameters6,
+  execute: async (args) => capture_errors(async () => ({ ok: true, output: run_env_get(args) }))
+};
+
+// src/tools/builtin/grep_files.ts
+import { readFile as readFile2, readdir as readdir2, stat } from "fs/promises";
+import path5 from "path";
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", ".lich", ".cursor"]);
+var MAX_FILE_BYTES = 1e6;
+var SNIFF_BYTES = 1e3;
+var DEFAULT_MAX_RESULTS2 = 200;
+var parameters7 = {
+  type: "object",
+  properties: {
+    pattern: { type: "string", description: "Regular expression source to match against each line" },
+    path: { type: "string", description: "Directory or file to search, relative to the working directory (default .)" },
+    glob: { type: "string", description: "Simple filename filter like *.ts (suffix match only)" },
+    max_results: { type: "number", description: "Stop after this many matches (default 200)" }
+  },
+  required: ["pattern"],
+  additionalProperties: false
+};
+function glob_matcher(glob) {
+  const star = glob.indexOf("*");
+  if (star < 0) {
+    return (name) => name === glob;
+  }
+  const prefix = glob.slice(0, star);
+  const suffix = glob.slice(star + 1);
+  return (name) => name.startsWith(prefix) === true && name.endsWith(suffix) === true;
+}
+function is_binary(buffer) {
+  const limit = Math.min(SNIFF_BYTES, buffer.length);
+  for (let index = 0; index < limit; index += 1) {
+    if (buffer[index] === 0) {
+      return true;
+    }
+  }
+  return false;
+}
+async function read_if_text(file_path, size) {
+  if (size >= MAX_FILE_BYTES) {
+    return void 0;
+  }
+  try {
+    const content = await readFile2(file_path);
+    if (is_binary(content) === true) {
+      return void 0;
+    }
+    return content.toString("utf8").split("\n");
+  } catch {
+    return void 0;
+  }
+}
+function match_lines(lines, regex) {
+  const hits = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (line !== void 0 && regex.test(line) === true) {
+      hits.push({ line_no: index + 1, text: line.trim() });
+    }
+  }
+  return hits;
+}
+async function safe_readdir(dir) {
+  try {
+    return await readdir2(dir, { withFileTypes: true });
+    abort_marker: ;
+  } catch {
+    return void 0;
+  }
+}
+async function file_size(file_path) {
+  try {
+    const info = await stat(file_path);
+    return info.size;
+  } catch {
+    return 0;
+  }
+}
+async function scan_dir(frame, matcher) {
+  const files = [];
+  const dirs = [];
+  const entries = await safe_readdir(frame.dir);
+  if (entries === void 0) {
+    return { files, dirs };
+  }
+  for (const entry of entries) {
+    if (SKIP_DIRS.has(entry.name) === true) {
+      continue;
+    }
+    const full = path5.join(frame.dir, entry.name);
+    if (entry.isDirectory() === true) {
+      dirs.push({ dir: full, name: entry.name });
+    } else if (matcher(entry.name) === true) {
+      files.push({ dir: full, name: entry.name });
+    }
+  }
+  return { files, dirs };
+}
+async function search_file(frame, relative_root, regex, collected, max_results) {
+  const size = await file_size(frame.dir);
+  const lines = await read_if_text(frame.dir, size);
+  if (lines === void 0) {
+    return false;
+  }
+  const relative = path5.relative(relative_root, frame.dir);
+  for (const hit of match_lines(lines, regex)) {
+    collected.push(`${relative}:${hit.line_no}: ${hit.text}`);
+    if (collected.length >= max_results) {
+      return true;
+    }
+  }
+  return false;
+}
+async function search_tree(root, regex, matcher, max_results) {
+  const collected = [];
+  const stack = [{ dir: root, name: root }];
+  while (stack.length > 0 && collected.length < max_results) {
+    const frame = stack.pop();
+    if (frame === void 0) {
+      break;
+    }
+    const found = await scan_dir(frame, matcher);
+    for (const file of found.files) {
+      const hit_cap = await search_file(file, root, regex, collected, max_results);
+      if (hit_cap === true) {
+        break;
+      }
+    }
+    for (const dir of found.dirs) {
+      stack.push(dir);
+    }
+  }
+  return collected;
+}
+function finalize_output(matches, max_results) {
+  if (matches.length > max_results) {
+    const shown = matches.slice(0, max_results);
+    const suppressed = matches.length - max_results;
+    return shown.join("\n") + `
+(... ${suppressed} more matches suppressed)`;
+  }
+  return matches.join("\n");
+}
+function search_file_direct(file_path, regex, collected, max_results) {
+  return search_file({ dir: file_path, name: path5.basename(file_path) }, path5.dirname(file_path), regex, collected, max_results);
+}
+async function collect_file_matches(root, regex, matcher, max_results) {
+  const collected = [];
+  if (matcher(path5.basename(root)) === true) {
+    await search_file_direct(root, regex, collected, max_results);
+  }
+  return collected;
+}
+async function run_grep(args, work_dir) {
+  const pattern = require_string_arg(args, "pattern");
+  const target = optional_string_arg(args, "path", ".");
+  const max_results = Math.max(1, Math.floor(optional_number_arg(args, "max_results", DEFAULT_MAX_RESULTS2)));
+  const glob = optional_string_arg(args, "glob", "");
+  let regex;
+  try {
+    regex = new RegExp(pattern);
+  } catch {
+    throw new Error(`invalid_regex: ${pattern}`);
+  }
+  const matcher = glob.length > 0 ? glob_matcher(glob) : () => true;
+  const root = resolve_safe_path(work_dir, target);
+  const root_stat = await stat(root);
+  const cap = max_results + 1;
+  const matches = root_stat.isDirectory() === true ? await search_tree(root, regex, matcher, cap) : await collect_file_matches(root, regex, matcher, cap);
+  return finalize_output(matches, max_results);
+}
+var grep_files_tool = {
+  name: "grep_files",
+  description: "Search files line-by-line with a regex, skipping node_modules/.git/dist and binary files.",
+  parameters: parameters7,
+  execute: async (args, context) => capture_errors(async () => {
+    const output = await run_grep(args, context.work_dir);
+    return { ok: true, output };
+  })
+};
+
+// src/tools/builtin/http_request.ts
+var DEFAULT_TIMEOUT_MS2 = 3e4;
+var MAX_TIMEOUT_MS2 = 12e4;
+var DEFAULT_MAX_CHARS2 = 2e4;
+var MAX_MAX_CHARS2 = 1e5;
+var METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
+var REPORTED_HEADERS = ["content-length", "ratelimit-remaining", "retry-after"];
+var parameters8 = {
+  type: "object",
+  properties: {
+    url: { type: "string", description: "Absolute http:// or https:// URL to call" },
+    method: { type: "string", description: "HTTP method: GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS (default GET)" },
+    headers: { type: "object", description: "Request headers as name/value pairs (values stringified)" },
+    body: { type: "string", description: "Request body text (ignored for GET/HEAD)" },
+    timeout_ms: { type: "number", description: "Abort the request after this many ms (default 30000, max 120000)" },
+    max_chars: { type: "number", description: "Clamp the body to this many chars (default 20000, max 100000)" }
+  },
+  required: ["url"],
+  additionalProperties: false
+};
+function read_method(args) {
+  const method = optional_string_arg(args, "method", "GET").toUpperCase();
+  if (METHODS.has(method) === false) {
+    throw new Error(`invalid_method: ${method}`);
+  }
+  return method;
+}
+function read_headers(args) {
+  const raw = args.headers;
+  const headers = {};
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw) === true) {
+    return headers;
+  }
+  for (const [name, value] of Object.entries(raw)) {
+    if (value !== void 0 && value !== null) {
+      headers[name] = String(value);
+    }
+  }
+  return headers;
+}
+function header_lines(response) {
+  const lines = [];
+  for (const name of REPORTED_HEADERS) {
+    const value = response.headers.get(name);
+    if (value !== null) {
+      lines.push(`# header ${name}: ${value}`);
+    }
+  }
+  return lines;
+}
+async function run_http(args, external) {
+  const url = require_string_arg(args, "url");
+  valid_http_url(url);
+  const method = read_method(args);
+  const timeout_ms = clamp_int_arg(args, "timeout_ms", DEFAULT_TIMEOUT_MS2, MAX_TIMEOUT_MS2);
+  const max_chars = clamp_int_arg(args, "max_chars", DEFAULT_MAX_CHARS2, MAX_MAX_CHARS2);
+  const init = {
+    method,
+    headers: read_headers(args),
+    redirect: "follow",
+    signal: compose_abort_signal(timeout_ms, external)
+  };
+  if (method !== "GET" && method !== "HEAD") {
+    const body = optional_string_arg(args, "body", "");
+    if (body.length > 0) {
+      init.body = body;
+    }
+  }
+  const response = await fetch(url, init);
+  const content_type = response.headers.get("content-type") ?? "unknown";
+  const text = await response.text();
+  const sections = [
+    `# status ${response.status}`,
+    `# content-type ${content_type}`,
+    ...header_lines(response),
+    "",
+    clamp_output(text, max_chars)
+  ];
+  return { ok: true, output: sections.join("\n") };
+}
+var http_request_tool = {
+  name: "http_request",
+  description: "Call an http(s) API with a custom method/headers/body and return status, key headers, and the body.",
+  parameters: parameters8,
+  execute: async (args, context) => capture_errors(async () => run_http(args, context.signal))
+};
+
+// src/tools/builtin/list_dir.ts
+import { readdir as readdir3, stat as stat2 } from "fs/promises";
+import path6 from "path";
+var MAX_ENTRIES = 500;
+var MAX_DEPTH = 4;
+var SKIP_ENTRIES = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", ".lich", ".cursor"]);
+var parameters9 = {
+  type: "object",
+  properties: {
+    path: { type: "string", description: "Directory to list, relative to the working directory (default .)" },
+    depth: { type: "number", description: "How many levels deep to list (1-4, default 1)" }
+  },
+  additionalProperties: false
+};
+async function entry_size(file_path) {
+  try {
+    const info = await stat2(file_path);
+    return info.size;
+  } catch {
+    return 0;
+  }
+}
+async function safe_readdir2(dir) {
+  try {
+    return await readdir3(dir, { withFileTypes: true });
+  } catch {
+    return void 0;
+  }
+}
+function sort_entries(entries) {
+  return entries.filter((entry) => SKIP_ENTRIES.has(entry.name) === false).sort((a, b) => {
+    const a_rank = a.isDirectory() === true ? 0 : 1;
+    const b_rank = b.isDirectory() === true ? 0 : 1;
+    if (a_rank !== b_rank) {
+      return a_rank - b_rank;
+    }
+    return a.name.localeCompare(b.name);
+  });
+}
+async function push_entries(lines, queue, entries, current) {
+  for (const entry of sort_entries(entries)) {
+    if (lines.length >= MAX_ENTRIES) {
+      return true;
+    }
+    const full = path6.join(current.dir, entry.name);
+    if (entry.isDirectory() === true) {
+      lines.push(`d ${entry.name}/`);
+      if (current.remaining > 1) {
+        queue.push({ dir: full, remaining: current.remaining - 1 });
+      }
+    } else {
+      lines.push(`- ${entry.name} (${await entry_size(full)} bytes)`);
+    }
+  }
+  return false;
+}
+async function collect_lines(root, max_depth) {
+  const lines = [];
+  const queue = [{ dir: root, remaining: max_depth }];
+  let truncated = false;
+  while (queue.length > 0 && truncated === false) {
+    const current = queue.shift();
+    if (current === void 0) {
+      break;
+    }
+    const entries = await safe_readdir2(current.dir);
+    if (entries === void 0) {
+      continue;
+    }
+    truncated = await push_entries(lines, queue, entries, current);
+  }
+  if (truncated === true) {
+    lines.push(`(... truncated at ${MAX_ENTRIES} entries)`);
+  }
+  return lines;
+}
+function clamp_depth(depth) {
+  return Math.min(MAX_DEPTH, Math.max(1, Math.floor(depth)));
+}
+var list_dir_tool = {
+  name: "list_dir",
+  description: "List a directory tree iteratively (dirs first, sizes for files), skipping node_modules/.git/dist.",
+  parameters: parameters9,
+  execute: async (args, context) => capture_errors(async () => {
+    const target = optional_string_arg(args, "path", ".");
+    const depth = clamp_depth(optional_number_arg(args, "depth", 1));
+    const root = resolve_safe_path(context.work_dir, target);
+    const lines = await collect_lines(root, depth);
+    return { ok: true, output: lines.join("\n") };
+  })
+};
+
+// src/tools/builtin/process_list.ts
+import { readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
+var DEFAULT_MAX_RESULTS3 = 50;
+var MAX_MAX_RESULTS = 500;
+var CMDLINE_MAX_CHARS = 200;
+var PROC_DIR = "/proc";
+var PID_PATTERN = /^[0-9]+$/;
+var parameters10 = {
+  type: "object",
+  properties: {
+    filter: { type: "string", description: "Case-insensitive substring match on the command line" },
+    max_results: { type: "number", description: "Stop after this many processes (default 50, max 500)" }
+  },
+  additionalProperties: false
+};
+function read_proc_text(pid, file) {
+  try {
+    return readFileSync3(`${PROC_DIR}/${pid}/${file}`, "utf8");
+  } catch {
+    return "";
+  }
+}
+function numeric_pids() {
+  const pids = [];
+  for (const name of readdirSync2(PROC_DIR)) {
+    if (PID_PATTERN.test(name) === true) {
+      pids.push(name);
+    }
+  }
+  return pids;
+}
+function cmdline_text(pid) {
+  const raw = read_proc_text(pid, "cmdline");
+  const parts = raw.split("\0").filter((part) => part.length > 0);
+  return parts.join(" ").slice(0, CMDLINE_MAX_CHARS);
+}
+function comm_text(pid) {
+  return read_proc_text(pid, "comm").trim();
+}
+function collect_lines2(filter, max_results) {
+  const lines = [];
+  let total = 0;
+  for (const pid of numeric_pids()) {
+    const comm = comm_text(pid);
+    const cmdline = cmdline_text(pid);
+    const haystack = cmdline.length > 0 ? cmdline : comm;
+    if (filter.length > 0 && haystack.toLowerCase().includes(filter) === false) {
+      continue;
+    }
+    total += 1;
+    if (lines.length < max_results) {
+      lines.push(`${pid}	${comm}	${cmdline}`);
+    }
+  }
+  return { lines, total };
+}
+function run_process_list(args) {
+  const filter = optional_string_arg(args, "filter", "").toLowerCase();
+  const max_results = clamp_int_arg(args, "max_results", DEFAULT_MAX_RESULTS3, MAX_MAX_RESULTS);
+  let listing;
+  try {
+    listing = collect_lines2(filter, max_results);
+  } catch {
+    throw new Error("proc_unavailable");
+  }
+  const lines = [...listing.lines];
+  if (listing.total > listing.lines.length) {
+    lines.push(`(... ${listing.total - listing.lines.length} more processes suppressed)`);
+  }
+  if (lines.length === 0) {
+    lines.push("no matching processes");
+  }
+  return clamp_output(lines.join("\n"));
+}
+var process_list_tool = {
+  name: "process_list",
+  description: "Snapshot running processes from /proc as pid/comm/cmdline rows with an optional filter.",
+  parameters: parameters10,
+  execute: async (args) => capture_errors(async () => ({ ok: true, output: run_process_list(args) }))
+};
+
+// src/tools/builtin/read_file.ts
+import { readFile as readFile3 } from "fs/promises";
+var MAX_READ_CHARS = 256e3;
+var parameters11 = {
+  type: "object",
+  properties: {
+    path: { type: "string", description: "File to read, relative to the working directory" },
+    offset: { type: "number", description: "1-based line number to start reading from" },
+    limit: { type: "number", description: "Maximum number of lines to return" }
+  },
+  required: ["path"],
+  additionalProperties: false
+};
+function slice_lines2(content, offset, limit) {
+  const lines = content.split("\n");
+  const start = Math.max(0, offset - 1);
+  return lines.slice(start, start + Math.max(0, limit)).join("\n");
+}
+async function read_target(args, work_dir, target) {
+  const file_path = resolve_safe_path(work_dir, target);
+  const content = await readFile3(file_path, "utf8");
+  const offset = optional_number_arg(args, "offset", 1);
+  const limit = optional_number_arg(args, "limit", Number.MAX_SAFE_INTEGER);
+  return clamp_output(slice_lines2(content, offset, limit), MAX_READ_CHARS);
+}
+var read_file_tool = {
+  name: "read_file",
+  description: "Read a UTF-8 text file, optionally starting at a 1-based line offset with a line limit.",
+  parameters: parameters11,
+  execute: async (args, context) => capture_errors(async () => {
+    const target = require_string_arg(args, "path");
+    try {
+      const output = await read_target(args, context.work_dir, target);
+      return { ok: true, output };
+    } catch (err) {
+      if (is_enoent(err) === true) {
+        return { ok: false, output: "", error: `not_found: ${target}` };
+      }
+      throw err;
+    }
+  })
+};
+
+// src/tools/builtin/terminal.ts
+import { spawn } from "child_process";
+var MAX_STREAM_CHARS = 5e4;
+var DEFAULT_TIMEOUT_MS3 = 6e4;
+var MAX_TIMEOUT_MS3 = 3e5;
+var parameters12 = {
+  type: "object",
+  properties: {
+    command: { type: "string", description: "Shell command to run via bash -lc" },
+    timeout_ms: { type: "number", description: "Kill the command after this many ms (default 60000, max 300000)" }
+  },
+  required: ["command"],
+  additionalProperties: false
+};
+function stream_chunk(current, chunk) {
+  if (current.text.length >= MAX_STREAM_CHARS) {
+    return;
+  }
+  current.text = current.text + chunk.toString("utf8");
+  if (current.text.length > MAX_STREAM_CHARS) {
+    current.text = current.text.slice(0, MAX_STREAM_CHARS);
+  }
+}
+function clamp_timeout(raw) {
+  return Math.min(MAX_TIMEOUT_MS3, Math.max(1, Math.floor(raw)));
+}
+function wire_kill(child, timeout_signal, external) {
+  timeout_signal.addEventListener("abort", () => child.kill("SIGKILL"), { once: true });
+  external?.addEventListener("abort", () => child.kill("SIGKILL"), { once: true });
+}
+function wait_close(child) {
+  return new Promise((resolve) => {
+    child.on("close", (code) => resolve(code ?? -1));
+    child.on("error", () => resolve(-1));
+  });
+}
+async function run_command(command, work_dir, env, timeout_ms, external) {
+  const stdout = { text: "" };
+  const stderr = { text: "" };
+  const child = spawn("bash", ["-lc", command], { cwd: work_dir, env: { ...process.env, ...env } });
+  child.stdout.on("data", (chunk) => stream_chunk(stdout, chunk));
+  child.stderr.on("data", (chunk) => stream_chunk(stderr, chunk));
+  const close_promise = wait_close(child);
+  let timed_out = false;
+  let exit_code;
+  try {
+    exit_code = await with_timeout((timeout_signal) => {
+      wire_kill(child, timeout_signal, external);
+      return close_promise;
+    }, timeout_ms, "terminal");
+  } catch (err) {
+    if (err instanceof ToolTimeoutError === true) {
+      timed_out = true;
+      exit_code = await close_promise;
+    } else {
+      throw err;
+    }
+  }
+  const output = `${stdout.text}${stderr.text}
+[exit ${exit_code}]`;
+  return { output, exit_code, timed_out, cancelled: external?.aborted === true };
+}
+function terminal_result(outcome) {
+  const result = {
+    ok: outcome.exit_code === 0 && outcome.cancelled === false,
+    output: clamp_output(outcome.output)
+  };
+  if (outcome.cancelled === true) {
+    result.error = "cancelled";
+  } else if (outcome.timed_out === true) {
+    result.error = "timeout";
+  }
+  return result;
+}
+var terminal_tool = {
+  name: "terminal",
+  description: "Run a shell command with bash -lc and capture combined stdout/stderr plus the exit code.",
+  parameters: parameters12,
+  execute: async (args, context) => capture_errors(async () => {
+    const command = require_string_arg(args, "command");
+    const timeout_ms = clamp_timeout(optional_number_arg(args, "timeout_ms", DEFAULT_TIMEOUT_MS3));
+    const outcome = await run_command(command, context.work_dir, context.env, timeout_ms, context.signal);
+    return terminal_result(outcome);
+  })
+};
+
+// src/tools/builtin/web_search.ts
+var DEFAULT_MAX_RESULTS4 = 8;
+var MAX_RESULTS = 20;
+var DEFAULT_TIMEOUT_MS4 = 2e4;
+var MAX_TIMEOUT_MS4 = 6e4;
+var SEARCH_ENDPOINT = "https://html.duckduckgo.com/html/?q=";
+var REDIRECT_PREFIXES = ["//duckduckgo.com/l/?", "/l/?"];
+var RESULT_PATTERN = /<a[^>]+class="result__a"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/g;
+var ENTITY_REPLACEMENTS = [
+  ["&amp;", "&"],
+  ["&lt;", "<"],
+  ["&gt;", ">"],
+  ["&quot;", '"'],
+  ["&#x27;", "'"],
+  ["&#39;", "'"]
+];
+var parameters13 = {
+  type: "object",
+  properties: {
+    query: { type: "string", description: "Search query text" },
+    max_results: { type: "number", description: "Maximum results to return (default 8, max 20)" },
+    timeout_ms: { type: "number", description: "Abort the search after this many ms (default 20000, max 60000)" }
+  },
+  required: ["query"],
+  additionalProperties: false
+};
+function decode_entities(text) {
+  let decoded = text;
+  for (const [entity, replacement] of ENTITY_REPLACEMENTS) {
+    decoded = decoded.split(entity).join(replacement);
+  }
+  return decoded;
+}
+function strip_tags(raw_title) {
+  return decode_entities(raw_title).replace(/<[^>]*>/g, "").trim();
+}
+function unwrap_redirect(href) {
+  for (const prefix of REDIRECT_PREFIXES) {
+    if (href.startsWith(prefix) === false) {
+      continue;
+    }
+    const query = href.slice(prefix.length);
+    const marker_index = query.indexOf("uddg=");
+    if (marker_index < 0) {
+      return href;
+    }
+    const encoded = query.slice(marker_index + 5).split("&")[0] ?? "";
+    try {
+      return decodeURIComponent(encoded);
+    } catch {
+      return encoded;
+    }
+  }
+  return href;
+}
+function parse_results(html, cap) {
+  const hits = [];
+  for (const match of html.matchAll(RESULT_PATTERN)) {
+    const href = match[1];
+    const raw_title = match[2];
+    if (href === void 0 || raw_title === void 0) {
+      continue;
+    }
+    hits.push({ title: strip_tags(raw_title), url: unwrap_redirect(decode_entities(href)) });
+    if (hits.length >= cap) {
+      break;
+    }
+  }
+  return hits;
+}
+function format_results(hits) {
+  const lines = [];
+  for (let index = 0; index < hits.length; index += 1) {
+    const hit = hits[index];
+    if (hit !== void 0) {
+      lines.push(`${index + 1}. ${hit.title}`, `   ${hit.url}`);
+    }
+  }
+  return lines.join("\n");
+}
+async function run_search(args, external) {
+  const query = require_string_arg(args, "query");
+  const max_results = clamp_int_arg(args, "max_results", DEFAULT_MAX_RESULTS4, MAX_RESULTS);
+  const timeout_ms = clamp_int_arg(args, "timeout_ms", DEFAULT_TIMEOUT_MS4, MAX_TIMEOUT_MS4);
+  try {
+    const response = await fetch(`${SEARCH_ENDPOINT}${encodeURIComponent(query)}`, {
+      headers: { "user-agent": USER_AGENT, "accept-language": "en" },
+      signal: compose_abort_signal(timeout_ms, external)
+    });
+    if (response.ok === false) {
+      return { ok: false, output: "", error: `search_failed: http_${response.status}` };
+    }
+    const hits = parse_results(await response.text(), max_results);
+    return { ok: true, output: hits.length === 0 ? "no results" : format_results(hits) };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, output: "", error: `search_failed: ${message}` };
+  }
+}
+var web_search_tool = {
+  name: "web_search",
+  description: "Search the web via DuckDuckGo's HTML endpoint (no api key) and return numbered title/url results.",
+  parameters: parameters13,
+  execute: async (args, context) => capture_errors(async () => run_search(args, context.signal))
+};
+
+// src/tools/builtin/write_file.ts
+import { mkdir, writeFile as writeFile2 } from "fs/promises";
+import path7 from "path";
+var parameters14 = {
+  type: "object",
+  properties: {
+    path: { type: "string", description: "File to write, relative to the working directory" },
+    content: { type: "string", description: "Full content to write (overwrites existing file)" }
+  },
+  required: ["path", "content"],
+  additionalProperties: false
+};
+function read_content_arg(args) {
+  const content = args.content;
+  if (typeof content !== "string") {
+    throw new Error("missing_arg: content");
+  }
+  return content;
+}
+async function write_target(work_dir, target, content) {
+  const file_path = resolve_safe_path(work_dir, target);
+  await mkdir(path7.dirname(file_path), { recursive: true });
+  await writeFile2(file_path, content, "utf8");
+  return `wrote ${content.length} chars to ${target}`;
+}
+var write_file_tool = {
+  name: "write_file",
+  description: "Write (or overwrite) a UTF-8 text file, creating parent directories as needed.",
+  parameters: parameters14,
+  execute: async (args, context) => capture_errors(async () => {
+    const target = require_string_arg(args, "path");
+    const content = read_content_arg(args);
+    const output = await write_target(context.work_dir, target, content);
+    return { ok: true, output };
+  })
+};
+
+// src/util/log.ts
+var level_order = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
+var current_level = "info";
+function set_log_level(level) {
+  current_level = level;
+}
+function log(level, message, data) {
+  if (level_order[level] < level_order[current_level]) {
+    return;
+  }
+  const line = `[lich:${level}] ${message}`;
+  if (data === void 0) {
+    console.error(line);
+    return;
+  }
+  console.error(line, data);
+}
+var logger = {
+  debug: (message, data) => log("debug", message, data),
+  info: (message, data) => log("info", message, data),
+  warn: (message, data) => log("warn", message, data),
+  error: (message, data) => log("error", message, data)
+};
+
+// src/tools/builtin/index.ts
+var core_tools = [
+  read_file_tool,
+  write_file_tool,
+  edit_file_tool,
+  list_dir_tool,
+  terminal_tool,
+  grep_files_tool,
+  fetch_url_tool,
+  web_search_tool,
+  http_request_tool,
+  process_list_tool,
+  disk_usage_tool,
+  env_get_tool
+];
+function docs_tools(context) {
+  if (resolve_docs_root(context) === void 0) {
+    logger.debug("docs tools skipped: no docs root (LICH_DOCS_DIR, work_dir/docs, or package docs)");
+    return [];
+  }
+  return [docs_read_tool, docs_search_tool];
+}
+function builtin_tools(context) {
+  return [...core_tools, ...docs_tools(context)];
+}
+function register_builtin_tools(registry, context) {
+  const merged_context = context ?? {
+    work_dir: process.cwd(),
+    env: { LICH_DOCS_DIR: process.env["LICH_DOCS_DIR"] ?? "" }
+  };
+  registry.register_toolset({ name: "builtin", tools: builtin_tools(merged_context) });
+}
+
+// src/tools/registry.ts
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  register(tool) {
+    if (this.tools.has(tool.name) === true) {
+      throw new Error(`duplicate_tool: ${tool.name}`);
+    }
+    this.tools.set(tool.name, tool);
+  }
+  register_toolset(toolset) {
+    for (const tool of toolset.tools) {
+      this.register(tool);
+    }
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  has(name) {
+    return this.tools.has(name);
+  }
+  list() {
+    return [...this.tools.values()];
+  }
+  /** Map registered tools onto the provider-facing wire shape. */
+  definitions() {
+    return this.list().map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters
+    }));
+  }
+};
+function default_tool_context(work_dir, env) {
+  return { work_dir, env: env ?? {} };
+}
+
+// src/tools/executor.ts
+function clamp_result(result) {
+  return { ...result, output: clamp_output(result.output) };
+}
+function failure_result(err, context) {
+  if (context.signal?.aborted === true) {
+    return { ok: false, output: "", error: "cancelled" };
+  }
+  return error_result(err);
+}
+var ToolExecutor = class {
+  registry;
+  defaults;
+  constructor(registry, defaults) {
+    this.registry = registry;
+    this.defaults = defaults ?? {};
+  }
+  async execute(name, args, context) {
+    const tool = this.registry.get(name);
+    if (tool === void 0) {
+      return { ok: false, output: "", error: `unknown_tool: ${name}` };
+    }
+    const resolved = context ?? default_tool_context(this.defaults.work_dir ?? process.cwd(), this.defaults.env);
+    if (resolved.signal?.aborted === true) {
+      return { ok: false, output: "", error: "cancelled" };
+    }
+    return this.run_tool(tool, args, resolved);
+  }
+  async run_tool(tool, args, context) {
+    const combined = new AbortController();
+    const link_external = () => {
+      combined.abort();
+    };
+    context.signal?.addEventListener("abort", link_external, { once: true });
+    logger.debug(`tool_call_start: ${tool.name}`);
+    try {
+      const result = await with_timeout(
+        (timeout_signal) => {
+          timeout_signal.addEventListener("abort", () => {
+            combined.abort();
+          }, { once: true });
+          return tool.execute(args, { ...context, signal: combined.signal });
+        },
+        DEFAULT_TOOL_TIMEOUT_MS,
+        `tool:${tool.name}`
+      );
+      logger.debug(`tool_call_end: ${tool.name}`);
+      return clamp_result(result);
+    } catch (err) {
+      logger.debug(`tool_call_error: ${tool.name}`);
+      return failure_result(err, context);
+    } finally {
+      context.signal?.removeEventListener("abort", link_external);
+    }
+  }
+  /** Render a result for a tool-role message: JSON on error, raw output otherwise. */
+  static format_result(result) {
+    if (result.error !== void 0 && result.error.length > 0) {
+      return safe_stringify({ ok: result.ok, output: result.output, error: result.error });
+    }
+    return result.output;
+  }
+};
+
+// src/plugins/hooks.ts
+var SUMMARY_MAX_CHARS = 300;
+function clamp_summary(text) {
+  return text.length > SUMMARY_MAX_CHARS ? text.slice(0, SUMMARY_MAX_CHARS) : text;
+}
+function pick_defined(hooks, pick) {
+  const defined = [];
+  for (const hooks_entry of hooks) {
+    const hook = pick(hooks_entry);
+    if (hook !== void 0) {
+      defined.push(hook);
+    }
+  }
+  return defined;
+}
+var HookedToolRunner = class {
+  wrapped;
+  before_hooks;
+  after_hooks;
+  run_start_hooks;
+  run_end_hooks;
+  constructor(wrapped, hooks) {
+    this.wrapped = wrapped;
+    this.before_hooks = pick_defined(hooks, (entry) => entry.before_tool_call);
+    this.after_hooks = pick_defined(hooks, (entry) => entry.after_tool_call);
+    this.run_start_hooks = pick_defined(hooks, (entry) => entry.on_run_start);
+    this.run_end_hooks = pick_defined(hooks, (entry) => entry.on_run_end);
+  }
+  /** Run before hooks in order; the first {block: true} verdict wins. */
+  async run_before_hooks(info, ctx) {
+    for (const hook of this.before_hooks) {
+      try {
+        const verdict = await hook(info, ctx);
+        if (verdict?.block === true) {
+          return verdict;
+        }
+      } catch (hook_error) {
+        logger.warn(`plugin before_tool_call hook threw for ${info.tool_name}; continuing`, hook_error);
+      }
+    }
+    return {};
+  }
+  /** Fire-and-forget in spirit but awaited here so runs settle cleanly. */
+  async run_after_hooks(info, ctx) {
+    for (const hook of this.after_hooks) {
+      try {
+        await hook(info, ctx);
+      } catch (hook_error) {
+        logger.warn(`plugin after_tool_call hook threw for ${info.tool_name}; continuing`, hook_error);
+      }
+    }
+  }
+  async execute(name, args, context) {
+    const info = { tool_name: name, args };
+    const ctx = { work_dir: context?.work_dir ?? process.cwd() };
+    const verdict = await this.run_before_hooks(info, ctx);
+    if (verdict.block === true) {
+      const reason = verdict.reason ?? "plugin-less";
+      logger.info(`plugin blocked tool ${name}: ${reason}`);
+      return { ok: false, output: "", error: `blocked_by_plugin: ${reason}` };
+    }
+    const result = await this.wrapped.execute(name, args, context);
+    const after_info = {
+      ...info,
+      result_summary: clamp_summary(result.error ?? result.output)
+    };
+    await this.run_after_hooks(after_info, ctx);
+    return result;
+  }
+  /** Best-effort on_run_start fan-out used by Agent.run; never throws. */
+  async call_run_start(info, ctx) {
+    for (const hook of this.run_start_hooks) {
+      try {
+        await hook(info, ctx);
+      } catch (hook_error) {
+        logger.warn("plugin on_run_start hook threw; continuing", hook_error);
+      }
+    }
+  }
+  /** Best-effort on_run_end fan-out used by Agent.run; never throws. */
+  async call_run_end(info, ctx) {
+    for (const hook of this.run_end_hooks) {
+      try {
+        await hook(info, ctx);
+      } catch (hook_error) {
+        logger.warn("plugin on_run_end hook threw; continuing", hook_error);
+      }
+    }
+  }
+};
+
+// src/plugins/loader.ts
+import { pathToFileURL } from "url";
+import path8 from "path";
+var MODULE_QUERY = /(\.mjs|\.js|\.ts|\.mts|\.cts|\.jsx|\.tsx)$/;
+function describe_error(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function is_object_with_name(candidate) {
+  if (typeof candidate !== "object" || candidate === null) {
+    return false;
+  }
+  const plugin = candidate;
+  return typeof plugin.name === "string" && plugin.name.length > 0;
+}
+function is_plugin_module(candidate) {
+  if (is_object_with_name(candidate) === false) {
+    return false;
+  }
+  const plugin = candidate;
+  return plugin.tools !== void 0 || plugin.hooks !== void 0;
+}
+function extract_plugin(mod) {
+  const module = mod;
+  for (const candidate of [module?.default, module?.plugin]) {
+    if (is_object_with_name(candidate) === true) {
+      return candidate;
+    }
+  }
+  if (is_plugin_module(mod) === true) {
+    return mod;
+  }
+  return void 0;
+}
+async function load_one_entry(entry, base_dir) {
+  const abs = path8.resolve(base_dir, entry);
+  if (MODULE_QUERY.test(abs) === false) {
+    throw new Error(`plugin_entry_not_a_module: ${entry}`);
+  }
+  const mod = await import(pathToFileURL(abs).href);
+  const plugin = extract_plugin(mod);
+  if (plugin === void 0) {
+    throw new Error(`plugin_module_has_no_plugin_export: ${entry}`);
+  }
+  return { plugin, entry };
+}
+async function load_plugins(entries, base_dir) {
+  const plugins = [];
+  const errors = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (entry.length === 0) {
+      continue;
+    }
+    try {
+      const loaded = await load_one_entry(entry, base_dir);
+      if (seen.has(loaded.plugin.name) === true) {
+        errors.push({ entry, error_message: `duplicate_plugin_name: ${loaded.plugin.name}` });
+        continue;
+      }
+      seen.add(loaded.plugin.name);
+      plugins.push(loaded);
+    } catch (error) {
+      errors.push({ entry, error_message: describe_error(error) });
+    }
+  }
+  return { plugins, errors };
+}
+function plugin_errors_summary(errors) {
+  return errors.map((error) => `${error.entry}: ${error.error_message}`).join("; ");
+}
+
+// src/providers/types.ts
+var ProviderError = class extends Error {
+  kind;
+  provider_name;
+  status;
+  retry_after_ms;
+  constructor(params) {
+    super(params.message);
+    this.name = "ProviderError";
+    this.kind = params.kind;
+    this.provider_name = params.provider_name;
+    this.status = params.status;
+    this.retry_after_ms = params.retry_after_ms;
+    if (params.cause !== void 0) {
+      this.cause = params.cause;
+    }
+  }
+};
+
+// src/agent/config.ts
+import { z } from "zod";
+var provider_schema = z.object({
+  kind: z.enum(["openai_compat", "anthropic", "ollama"]),
+  name: z.string().min(1),
+  model: z.string().min(1),
+  base_url: z.string().optional(),
+  api_key: z.string().optional(),
+  api_key_env: z.string().optional(),
+  timeout_ms: z.number().int().positive().optional(),
+  /** Injectable fetch, mainly for tests; passes through untouched. */
+  fetch_fn: z.custom(() => true).optional()
+}).passthrough();
+var agent_config_schema = z.object({
+  system_prompt: z.string().optional(),
+  max_turns: z.number().int().min(1).default(25),
+  providers: z.array(provider_schema).min(1),
+  work_dir: z.string().optional(),
+  tools_enabled: z.union([z.literal("all"), z.array(z.string())]).default("all"),
+  temperature: z.number().min(0).max(2).optional(),
+  max_tokens: z.number().int().positive().optional(),
+  context_budget_tokens: z.number().int().positive().default(1e5),
+  compress_threshold: z.number().min(0.1).max(0.95).default(0.8),
+  session_dir: z.string().optional(),
+  terminal_timeout_ms: z.number().int().positive().default(6e4),
+  /** Plugin entry module specifiers, relative to work_dir or absolute. */
+  plugins: z.array(z.string()).default([]),
+  log_level: z.enum(["debug", "info", "warn", "error"]).default("info")
+}).transform((config) => {
+  const work_dir = config.work_dir ?? process.cwd();
+  return {
+    ...config,
+    work_dir,
+    providers: config.providers,
+    session_dir: config.session_dir ?? `${work_dir}/.lich/sessions`
+  };
+});
+function freeze_config(config) {
+  Object.freeze(config);
+  Object.freeze(config.providers);
+  for (const provider of config.providers) {
+    Object.freeze(provider);
+  }
+  return config;
+}
+function parse_agent_config(raw) {
+  const config = agent_config_schema.parse(raw);
+  const frozen = freeze_config(config);
+  set_log_level(frozen.log_level);
+  return frozen;
+}
+
+// src/agent/events.ts
+var AgentEmitter = class {
+  handlers = /* @__PURE__ */ new Set();
+  on(handler) {
+    this.handlers.add(handler);
+    return () => {
+      this.handlers.delete(handler);
+    };
+  }
+  emit(event) {
+    for (const handler of [...this.handlers]) {
+      try {
+        handler(event);
+      } catch (handler_error) {
+        logger.error("agent event handler threw", handler_error);
+      }
+    }
+  }
+  clear() {
+    this.handlers.clear();
+  }
+};
+
+// src/util/sleep.ts
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted === true) {
+      reject(new Error("sleep_aborted"));
+      return;
+    }
+    const on_abort = () => {
+      clearTimeout(timer);
+      reject(new Error("sleep_aborted"));
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", on_abort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", on_abort, { once: true });
+  });
+}
+
+// src/providers/failover.ts
+var DEFAULT_BACKOFF_BASE_MS = 500;
+var DEFAULT_BACKOFF_MAX_MS = 8e3;
+function classify_error(error) {
+  if (error instanceof ProviderError) {
+    return error.kind;
+  }
+  if (is_abort_like(error) === true || is_type_error(error) === true) {
+    return "network";
+  }
+  return "unknown";
+}
+function compute_backoff_ms(attempt, base_ms = DEFAULT_BACKOFF_BASE_MS, max_ms = DEFAULT_BACKOFF_MAX_MS) {
+  const exponential = Math.floor(base_ms * 2 ** attempt);
+  const jitter = Math.floor(base_ms * attempt / 2);
+  return Math.min(exponential + jitter, max_ms);
+}
+async function run_with_retries(fn, params) {
+  const outcome = await execute_retry_loop(fn, params);
+  if (outcome.ok === true) {
+    return outcome.value;
+  }
+  throw outcome.error;
+}
+async function execute_retry_loop(fn, params) {
+  let attempt = 1;
+  while (attempt <= Math.max(params.max_attempts, 1)) {
+    const outcome = await run_attempt(fn, attempt);
+    if (outcome.ok === true) {
+      return outcome;
+    }
+    if (caller_aborted(params.signal) === true) {
+      return { ok: false, error: make_abort_error(outcome.error) };
+    }
+    const kind = classify_error(outcome.error);
+    if (is_retryable_kind(kind) === false || attempt >= params.max_attempts) {
+      return outcome;
+    }
+    const delay_ms = delay_for_error(outcome.error, attempt);
+    params.on_retry?.(kind, attempt, delay_ms);
+    await wait_out_delay(delay_ms, params.signal);
+    if (params.signal?.aborted === true) {
+      return { ok: false, error: make_abort_error(outcome.error) };
+    }
+    attempt += 1;
+  }
+  return { ok: false, error: make_abort_error(void 0) };
+}
+async function run_attempt(fn, attempt) {
+  try {
+    return { ok: true, value: await fn(attempt) };
+  } catch (error) {
+    return { ok: false, error };
+  }
+}
+function is_retryable_kind(kind) {
+  return kind === "rate_limit" || kind === "network";
+}
+function caller_aborted(signal) {
+  return signal?.aborted === true;
+}
+function delay_for_error(error, attempt) {
+  const backoff = compute_backoff_ms(attempt);
+  if (error instanceof ProviderError && error.retry_after_ms !== void 0 && error.retry_after_ms > backoff) {
+    return error.retry_after_ms;
+  }
+  return backoff;
+}
+async function wait_out_delay(delay_ms, signal) {
+  if (delay_ms <= 0) {
+    return;
+  }
+  try {
+    await sleep(delay_ms, signal);
+  } catch {
+  }
+}
+function make_abort_error(cause) {
+  const error = new Error("operation aborted before completion");
+  error.name = "AbortError";
+  if (cause !== void 0) {
+    error.cause = cause;
+  }
+  return error;
+}
+function is_type_error(error) {
+  return error instanceof TypeError;
+}
+function error_name(error) {
+  if (typeof error === "object" && error !== null && "name" in error) {
+    const name = error.name;
+    return typeof name === "string" ? name : void 0;
+  }
+  return void 0;
+}
+function is_abort_like(error) {
+  const name = error_name(error);
+  return name === "AbortError" || name === "TimeoutError";
+}
+
+// src/providers/anthropic.ts
+var DEFAULT_BASE_URL = "https://api.anthropic.com";
+var ANTHROPIC_VERSION = "2023-06-01";
+var DEFAULT_KEY_ENV = "ANTHROPIC_API_KEY";
+var MAX_ERROR_BODY_CHARS = 500;
+var OVERFLOW_BODY_PATTERN = /context|token|maximum/i;
+var OVERLOADED_STATUS = 529;
+var UNPARSEABLE_ARGS_NOTE = "[unparseable tool arguments]";
+var DEFAULT_MAX_TOKENS = 4096;
+var AnthropicProvider = class {
+  name;
+  model;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.name = config.name;
+    this.model = config.model;
+  }
+  async chat(messages, tools, options) {
+    const api_key = resolve_api_key(this.config);
+    if (api_key === void 0) {
+      throw new ProviderError({
+        kind: "auth",
+        provider_name: this.config.name,
+        message: `missing api key for provider "${this.config.name}" (set api_key or api_key_env, e.g. ${DEFAULT_KEY_ENV})`
+      });
+    }
+    const response = await do_fetch(
+      this.config.fetch_fn ?? fetch,
+      build_endpoint(this.config),
+      build_request_init(
+        api_key,
+        safe_stringify(build_request_body(this.config.model, messages, tools, options)),
+        build_abort_signal(options, this.config.timeout_ms)
+      ),
+      this.config.name
+    );
+    if (response.ok === false) {
+      throw await to_http_error(response, this.config.name);
+    }
+    return parse_chat_response(await read_success_json(response, this.config.name), this.config);
+  }
+};
+function resolve_api_key(config) {
+  const direct = config.api_key;
+  if (direct !== void 0 && direct.length > 0) {
+    return direct;
+  }
+  const env_name = config.api_key_env ?? DEFAULT_KEY_ENV;
+  const from_env = process.env[env_name];
+  if (from_env !== void 0 && from_env.length > 0) {
+    return from_env;
+  }
+  return void 0;
+}
+function build_endpoint(config) {
+  const base = config.base_url ?? DEFAULT_BASE_URL;
+  return base.endsWith("/") === true ? `${base}v1/messages` : `${base}/v1/messages`;
+}
+function build_headers(api_key) {
+  return {
+    "content-type": "application/json",
+    "x-api-key": api_key,
+    "anthropic-version": ANTHROPIC_VERSION
+  };
+}
+function build_abort_signal(options, timeout_ms) {
+  const signals = [];
+  if (timeout_ms !== void 0 && timeout_ms > 0) {
+    signals.push(AbortSignal.timeout(timeout_ms));
+  }
+  if (options?.signal !== void 0) {
+    signals.push(options.signal);
+  }
+  const [only_signal] = signals;
+  if (only_signal !== void 0 && signals.length === 1) {
+    return only_signal;
+  }
+  return AbortSignal.any(signals);
+}
+function build_request_body(model, messages, tools, options) {
+  const body = {
+    model,
+    max_tokens: options?.max_tokens ?? DEFAULT_MAX_TOKENS,
+    messages: to_anthropic_turns(messages)
+  };
+  const system_text = collect_system_text(messages);
+  if (system_text !== void 0) {
+    body.system = system_text;
+  }
+  if (tools.length > 0) {
+    body.tools = to_anthropic_tools(tools);
+  }
+  if (options?.temperature !== void 0) {
+    body.temperature = options.temperature;
+  }
+  return body;
+}
+function collect_system_text(messages) {
+  const parts = [];
+  for (const message of messages) {
+    if (message.role === "system") {
+      parts.push(message.content);
+    }
+  }
+  const joined = parts.join("\n");
+  return joined.length === 0 ? void 0 : joined;
+}
+function to_anthropic_turns(messages) {
+  const turns = [];
+  const pending_tool_results = [];
+  for (const message of messages) {
+    if (message.role === "system") {
+      continue;
+    }
+    if (message.role === "tool") {
+      pending_tool_results.push(tool_message_to_block(message));
+      continue;
+    }
+    flush_tool_results(turns, pending_tool_results);
+    if (message.role === "user") {
+      turns.push({ role: "user", content: [{ type: "text", text: message.content }] });
+    } else {
+      turns.push({ role: "assistant", content: assistant_to_blocks(message) });
+    }
+  }
+  flush_tool_results(turns, pending_tool_results);
+  return turns;
+}
+function flush_tool_results(turns, pending_tool_results) {
+  if (pending_tool_results.length === 0) {
+    return;
+  }
+  turns.push({ role: "user", content: pending_tool_results.splice(0, pending_tool_results.length) });
+}
+function tool_message_to_block(message) {
+  const block = {
+    type: "tool_result",
+    tool_use_id: message.tool_call_id,
+    content: [{ type: "text", text: message.content }]
+  };
+  if (message.is_error === true) {
+    return { ...block, is_error: true };
+  }
+  return block;
+}
+function assistant_to_blocks(message) {
+  const blocks = [];
+  if (message.content.length > 0) {
+    blocks.push({ type: "text", text: message.content });
+  }
+  for (const tool_call of message.tool_calls ?? []) {
+    blocks.push({ type: "tool_use", id: tool_call.id, name: tool_call.name, input: tool_call.args });
+  }
+  if (blocks.length === 0) {
+    blocks.push({ type: "text", text: "" });
+  }
+  return blocks;
+}
+function to_anthropic_tools(tools) {
+  return tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    input_schema: tool.parameters
+  }));
+}
+function build_request_init(api_key, body, signal) {
+  return {
+    method: "POST",
+    headers: build_headers(api_key),
+    body,
+    ...signal !== void 0 ? { signal } : {}
+  };
+}
+async function do_fetch(fetch_fn, url, init, provider_name) {
+  try {
+    return await fetch_fn(url, init);
+  } catch (error) {
+    const label = is_abort_like2(error) === true ? "request aborted or timed out" : "fetch failed";
+    throw new ProviderError({
+      kind: "network",
+      provider_name,
+      message: `${label}: ${describe_error2(error)}`,
+      cause: error
+    });
+  }
+}
+async function read_response_text(response, provider_name) {
+  try {
+    return await response.text();
+  } catch (error) {
+    throw new ProviderError({
+      kind: "network",
+      provider_name,
+      message: `failed to read response body: ${describe_error2(error)}`,
+      cause: error
+    });
+  }
+}
+async function read_success_json(response, provider_name) {
+  const text = await read_response_text(response, provider_name);
+  const dto = safe_json_parse(text);
+  if (dto === void 0) {
+    throw new ProviderError({
+      kind: "bad_request",
+      provider_name,
+      message: `unparseable success response: ${truncate_text(text, MAX_ERROR_BODY_CHARS)}`
+    });
+  }
+  return dto;
+}
+function parse_retry_after_ms(response) {
+  const raw = response.headers.get("retry-after");
+  if (raw === null) {
+    return void 0;
+  }
+  const seconds = Number(raw);
+  if (Number.isFinite(seconds) === false || seconds < 0) {
+    return void 0;
+  }
+  return Math.round(seconds * 1e3);
+}
+function status_to_error_kind(status, body_text) {
+  if (status === 401 || status === 403) {
+    return "auth";
+  }
+  if (status === 429 || status === OVERLOADED_STATUS || status >= 500) {
+    return "rate_limit";
+  }
+  if (status === 400 && OVERFLOW_BODY_PATTERN.test(body_text) === true) {
+    return "overflow";
+  }
+  return "bad_request";
+}
+async function to_http_error(response, provider_name) {
+  const body_text = truncate_text(await read_response_text(response, provider_name), MAX_ERROR_BODY_CHARS);
+  const retry_after_ms = parse_retry_after_ms(response);
+  return new ProviderError({
+    kind: status_to_error_kind(response.status, body_text),
+    provider_name,
+    message: `${provider_name} http ${response.status}: ${body_text}`,
+    status: response.status,
+    ...retry_after_ms !== void 0 ? { retry_after_ms } : {}
+  });
+}
+function parse_chat_response(dto, config) {
+  return {
+    message: parse_assistant_message(dto.content ?? []),
+    usage: parse_usage(dto.usage),
+    finish_reason: map_stop_reason(dto.stop_reason),
+    model: dto.model ?? config.model,
+    provider_name: config.name
+  };
+}
+function parse_assistant_message(blocks) {
+  const text_parts = [];
+  const tool_calls = [];
+  for (const block of blocks) {
+    if (block.type === "text") {
+      text_parts.push(block.text ?? "");
+    } else if (block.type === "tool_use") {
+      tool_calls.push(tool_use_to_call(block, text_parts));
+    }
+  }
+  return {
+    role: "assistant",
+    content: text_parts.filter((part) => part.length > 0).join("\n"),
+    ...tool_calls.length > 0 ? { tool_calls } : {}
+  };
+}
+function tool_use_to_call(block, text_parts) {
+  const args = block.input;
+  if (is_record(args) === true) {
+    return { id: block.id ?? "", name: block.name ?? "", args };
+  }
+  text_parts.push(UNPARSEABLE_ARGS_NOTE);
+  return { id: block.id ?? "", name: block.name ?? "", args: {} };
+}
+function parse_usage(dto) {
+  const prompt_tokens = dto?.input_tokens ?? 0;
+  const completion_tokens = dto?.output_tokens ?? 0;
+  return {
+    prompt_tokens,
+    completion_tokens,
+    total_tokens: prompt_tokens + completion_tokens
+  };
+}
+function map_stop_reason(raw) {
+  if (raw === "end_turn") {
+    return "stop";
+  }
+  if (raw === "tool_use") {
+    return "tool_calls";
+  }
+  if (raw === "max_tokens") {
+    return "length";
+  }
+  return "unknown";
+}
+function is_record(value) {
+  return typeof value === "object" && value !== null;
+}
+function describe_error2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function error_name2(error) {
+  if (typeof error === "object" && error !== null && "name" in error) {
+    const name = error.name;
+    return typeof name === "string" ? name : void 0;
+  }
+  return void 0;
+}
+function is_abort_like2(error) {
+  const name = error_name2(error);
+  return name === "AbortError" || name === "TimeoutError";
+}
+
+// src/providers/ollama.ts
+var DEFAULT_BASE_URL2 = "http://localhost:11434";
+var MAX_ERROR_BODY_CHARS2 = 500;
+var OVERFLOW_BODY_PATTERN2 = /context|token|maximum|too long/i;
+var UNPARSEABLE_ARGS_NOTE2 = "[unparseable tool arguments]";
+var tool_call_counter = 0;
+var OllamaProvider = class {
+  name;
+  model;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.name = config.name;
+    this.model = config.model;
+  }
+  async chat(messages, tools, options) {
+    const response = await do_fetch2(
+      this.config.fetch_fn ?? fetch,
+      build_endpoint2(this.config),
+      build_request_init2(
+        resolve_api_key2(this.config),
+        safe_stringify(build_request_body2(this.config, messages, tools, options)),
+        build_abort_signal2(options, this.config.timeout_ms)
+      ),
+      this.config.name
+    );
+    if (response.ok === false) {
+      throw await to_http_error2(response, this.config.name);
+    }
+    return to_chat_response(await read_success_json2(response, this.config.name), this.config);
+  }
+};
+function create_ollama_provider(config) {
+  return new OllamaProvider(config);
+}
+function resolve_api_key2(config) {
+  const from_named_env = config.api_key_env === void 0 ? void 0 : process.env[config.api_key_env];
+  return first_non_empty([config.api_key, from_named_env]);
+}
+function first_non_empty(values) {
+  for (const value of values) {
+    if (value !== void 0 && value.length > 0) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function build_endpoint2(config) {
+  const base = config.base_url ?? DEFAULT_BASE_URL2;
+  return base.endsWith("/") === true ? `${base}api/chat` : `${base}/api/chat`;
+}
+function build_headers2(api_key) {
+  const headers = { "content-type": "application/json" };
+  if (api_key !== void 0) {
+    headers.authorization = `Bearer ${api_key}`;
+  }
+  return headers;
+}
+function build_abort_signal2(options, timeout_ms) {
+  const signals = [];
+  if (timeout_ms !== void 0 && timeout_ms > 0) {
+    signals.push(AbortSignal.timeout(timeout_ms));
+  }
+  if (options?.signal !== void 0) {
+    signals.push(options.signal);
+  }
+  const [only_signal] = signals;
+  if (only_signal !== void 0 && signals.length === 1) {
+    return only_signal;
+  }
+  return AbortSignal.any(signals);
+}
+function to_ollama_messages(messages) {
+  const wire = [];
+  for (const message of messages) {
+    if (message.role === "system") {
+      wire.push({ role: "system", content: message.content });
+    } else if (message.role === "user") {
+      wire.push({ role: "user", content: message.content });
+    } else if (message.role === "assistant") {
+      wire.push(assistant_to_wire(message));
+    } else {
+      wire.push(tool_to_wire(message));
+    }
+  }
+  return wire;
+}
+function assistant_to_wire(message) {
+  const wire_calls = (message.tool_calls ?? []).map((tool_call) => ({
+    type: "function",
+    function: { name: tool_call.name, arguments: tool_call.args }
+  }));
+  if (wire_calls.length === 0) {
+    return { role: "assistant", content: message.content };
+  }
+  return { role: "assistant", content: message.content, tool_calls: wire_calls };
+}
+function tool_to_wire(message) {
+  return { role: "tool", tool_name: message.name, content: message.content };
+}
+function to_ollama_tools(tools) {
+  return tools.map((tool) => ({
+    type: "function",
+    function: { name: tool.name, description: tool.description, parameters: tool.parameters }
+  }));
+}
+function build_request_body2(config, messages, tools, options) {
+  const body = { model: config.model, messages: to_ollama_messages(messages), stream: false };
+  const wire_tools = to_ollama_tools(tools);
+  if (wire_tools.length > 0) {
+    body.tools = wire_tools;
+  }
+  const wire_options = build_wire_options(options);
+  if (wire_options !== void 0) {
+    body.options = wire_options;
+  }
+  if (options?.think === true || config.think === true) {
+    body.think = true;
+  }
+  if (config.keep_alive !== void 0) {
+    body.keep_alive = config.keep_alive;
+  }
+  return body;
+}
+function build_wire_options(options) {
+  const wire_options = {};
+  if (options?.temperature !== void 0) {
+    wire_options.temperature = options.temperature;
+  }
+  if (options?.max_tokens !== void 0) {
+    wire_options.num_predict = options.max_tokens;
+  }
+  const has_any = wire_options.temperature !== void 0 || wire_options.num_predict !== void 0;
+  return has_any === true ? wire_options : void 0;
+}
+function build_request_init2(api_key, body, signal) {
+  return {
+    method: "POST",
+    headers: build_headers2(api_key),
+    body,
+    ...signal !== void 0 ? { signal } : {}
+  };
+}
+async function do_fetch2(fetch_fn, url, init, provider_name) {
+  try {
+    return await fetch_fn(url, init);
+  } catch (error) {
+    const label = is_abort_like3(error) === true ? "request aborted or timed out" : "fetch failed";
+    throw new ProviderError({
+      kind: "network",
+      provider_name,
+      message: `${label}: ${describe_error3(error)}`,
+      cause: error
+    });
+  }
+}
+async function read_response_text2(response, provider_name) {
+  try {
+    return await response.text();
+  } catch (error) {
+    throw new ProviderError({
+      kind: "network",
+      provider_name,
+      message: `failed to read response body: ${describe_error3(error)}`,
+      cause: error
+    });
+  }
+}
+async function read_success_json2(response, provider_name) {
+  const text = await read_response_text2(response, provider_name);
+  const dto = safe_json_parse(text);
+  if (dto === void 0) {
+    throw new ProviderError({
+      kind: "bad_request",
+      provider_name,
+      message: `unparseable success response: ${truncate_text(text, MAX_ERROR_BODY_CHARS2)}`
+    });
+  }
+  return dto;
+}
+function parse_retry_after_ms2(response) {
+  const raw = response.headers.get("retry-after");
+  if (raw === null) {
+    return void 0;
+  }
+  const seconds = Number(raw);
+  if (Number.isFinite(seconds) === false || seconds < 0) {
+    return void 0;
+  }
+  return Math.round(seconds * 1e3);
+}
+function status_to_error_kind2(status, body_text) {
+  if (status === 401 || status === 403) {
+    return "auth";
+  }
+  if (status === 429 || status >= 500) {
+    return "rate_limit";
+  }
+  if (status === 400 && OVERFLOW_BODY_PATTERN2.test(body_text) === true) {
+    return "overflow";
+  }
+  return "bad_request";
+}
+async function to_http_error2(response, provider_name) {
+  const body_text = truncate_text(await read_response_text2(response, provider_name), MAX_ERROR_BODY_CHARS2);
+  const retry_after_ms = parse_retry_after_ms2(response);
+  return new ProviderError({
+    kind: status_to_error_kind2(response.status, body_text),
+    provider_name,
+    message: `${provider_name} http ${response.status}: ${body_text}`,
+    status: response.status,
+    ...retry_after_ms !== void 0 ? { retry_after_ms } : {}
+  });
+}
+function to_chat_response(dto, config) {
+  if (dto.error !== void 0 && dto.error.length > 0) {
+    throw new ProviderError({
+      kind: "bad_request",
+      provider_name: config.name,
+      message: `ollama reported an error in a 200 response: ${truncate_text(dto.error, MAX_ERROR_BODY_CHARS2)}`
+    });
+  }
+  if (dto.message === void 0) {
+    throw new ProviderError({
+      kind: "bad_request",
+      provider_name: config.name,
+      message: "provider returned a success response without a message"
+    });
+  }
+  const content_parts = [];
+  const message_content = dto.message.content ?? "";
+  if (message_content.length > 0) {
+    content_parts.push(message_content);
+  }
+  const parsed_calls = parse_tool_calls(dto.message.tool_calls ?? [], content_parts);
+  const has_tool_calls = parsed_calls.length > 0;
+  return {
+    message: {
+      role: "assistant",
+      content: content_parts.join("\n"),
+      ...has_tool_calls === true ? { tool_calls: parsed_calls } : {}
+    },
+    usage: parse_usage2(dto),
+    finish_reason: map_done_reason(dto.done_reason, has_tool_calls),
+    model: dto.model ?? config.model,
+    provider_name: config.name
+  };
+}
+function next_tool_call_id() {
+  tool_call_counter += 1;
+  return `ollama_${Date.now().toString(36)}_${tool_call_counter}`;
+}
+function normalize_tool_arguments(raw_arguments, content_parts) {
+  if (is_record2(raw_arguments) === true) {
+    return raw_arguments;
+  }
+  if (typeof raw_arguments === "string") {
+    const parsed = safe_json_parse(raw_arguments);
+    if (is_record2(parsed) === true) {
+      return parsed;
+    }
+  }
+  content_parts.push(UNPARSEABLE_ARGS_NOTE2);
+  return {};
+}
+function parse_tool_calls(raw_calls, content_parts) {
+  const tool_calls = [];
+  for (const raw_call of raw_calls) {
+    const name = raw_call.function?.name ?? "";
+    tool_calls.push({
+      id: next_tool_call_id(),
+      name,
+      args: normalize_tool_arguments(raw_call.function?.arguments, content_parts)
+    });
+  }
+  return tool_calls;
+}
+function parse_usage2(dto) {
+  const prompt_tokens = dto.prompt_eval_count ?? 0;
+  const completion_tokens = dto.eval_count ?? 0;
+  return { prompt_tokens, completion_tokens, total_tokens: prompt_tokens + completion_tokens };
+}
+function map_done_reason(done_reason, has_tool_calls) {
+  if (has_tool_calls === true) {
+    return "tool_calls";
+  }
+  if (done_reason === "stop" || done_reason === "end_turn") {
+    return "stop";
+  }
+  if (done_reason === "length" || done_reason === "max_tokens") {
+    return "length";
+  }
+  return "unknown";
+}
+function is_record2(value) {
+  return typeof value === "object" && value !== null;
+}
+function describe_error3(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function error_name3(error) {
+  if (typeof error === "object" && error !== null && "name" in error) {
+    const name = error.name;
+    return typeof name === "string" ? name : void 0;
+  }
+  return void 0;
+}
+function is_abort_like3(error) {
+  const name = error_name3(error);
+  return name === "AbortError" || name === "TimeoutError";
+}
+
+// src/providers/openai.ts
+var DEFAULT_BASE_URL3 = "https://api.openai.com/v1";
+var WELL_KNOWN_HOST = "api.openai.com";
+var WELL_KNOWN_KEY_ENV = "OPENAI_API_KEY";
+var MAX_ERROR_BODY_CHARS3 = 500;
+var OVERFLOW_BODY_PATTERN3 = /context|token|length/i;
+var UNPARSEABLE_ARGS_NOTE3 = "[unparseable tool arguments]";
+var OpenAICompatProvider = class {
+  name;
+  model;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.name = config.name;
+    this.model = config.model;
+  }
+  async chat(messages, tools, options) {
+    const api_key = resolve_api_key3(this.config);
+    if (requires_api_key(this.config) === true && api_key === void 0) {
+      throw new ProviderError({
+        kind: "auth",
+        provider_name: this.config.name,
+        message: `missing api key for provider "${this.config.name}" (set api_key, api_key_env, or ${WELL_KNOWN_KEY_ENV})`
+      });
+    }
+    const response = await do_fetch3(
+      this.config.fetch_fn ?? fetch,
+      build_endpoint3(this.config),
+      build_request_init3(
+        api_key,
+        safe_stringify(build_request_body3(this.config.model, messages, tools, options)),
+        build_abort_signal3(options, this.config.timeout_ms)
+      ),
+      this.config.name
+    );
+    if (response.ok === false) {
+      throw await to_http_error3(response, this.config.name);
+    }
+    return parse_chat_response2(await read_success_json3(response, this.config.name), this.config);
+  }
+};
+function url_host(url_text) {
+  try {
+    return new URL(url_text).host;
+  } catch {
+    return void 0;
+  }
+}
+function is_well_known_host(config) {
+  return url_host(config.base_url ?? DEFAULT_BASE_URL3) === WELL_KNOWN_HOST;
+}
+function requires_api_key(config) {
+  return is_well_known_host(config);
+}
+function resolve_api_key3(config) {
+  const from_named_env = config.api_key_env === void 0 ? void 0 : process.env[config.api_key_env];
+  const from_well_known_env = is_well_known_host(config) === true ? process.env[WELL_KNOWN_KEY_ENV] : void 0;
+  return first_non_empty2([config.api_key, from_named_env, from_well_known_env]);
+}
+function first_non_empty2(values) {
+  for (const value of values) {
+    if (value !== void 0 && value.length > 0) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function build_endpoint3(config) {
+  const base = config.base_url ?? DEFAULT_BASE_URL3;
+  return base.endsWith("/") === true ? `${base}chat/completions` : `${base}/chat/completions`;
+}
+function build_headers3(api_key) {
+  const headers = { "content-type": "application/json" };
+  if (api_key !== void 0) {
+    headers.authorization = `Bearer ${api_key}`;
+  }
+  return headers;
+}
+function build_abort_signal3(options, timeout_ms) {
+  const signals = [];
+  if (timeout_ms !== void 0 && timeout_ms > 0) {
+    signals.push(AbortSignal.timeout(timeout_ms));
+  }
+  if (options?.signal !== void 0) {
+    signals.push(options.signal);
+  }
+  const [only_signal] = signals;
+  if (only_signal !== void 0 && signals.length === 1) {
+    return only_signal;
+  }
+  return AbortSignal.any(signals);
+}
+function to_openai_messages(messages) {
+  const wire = [];
+  for (const message of messages) {
+    if (message.role === "system") {
+      wire.push({ role: "system", content: message.content });
+    } else if (message.role === "user") {
+      wire.push({ role: "user", content: message.content });
+    } else if (message.role === "assistant") {
+      wire.push(assistant_to_wire2(message));
+    } else {
+      wire.push(tool_to_wire2(message));
+    }
+  }
+  return wire;
+}
+function assistant_to_wire2(message) {
+  const wire_calls = (message.tool_calls ?? []).map((tool_call) => ({
+    id: tool_call.id,
+    type: "function",
+    function: { name: tool_call.name, arguments: safe_stringify(tool_call.args) }
+  }));
+  if (wire_calls.length === 0) {
+    return { role: "assistant", content: message.content };
+  }
+  return { role: "assistant", content: message.content, tool_calls: wire_calls };
+}
+function tool_to_wire2(message) {
+  return { role: "tool", tool_call_id: message.tool_call_id, content: message.content };
+}
+function to_openai_tools(tools) {
+  return tools.map((tool) => ({
+    type: "function",
+    function: { name: tool.name, description: tool.description, parameters: tool.parameters }
+  }));
+}
+function build_request_body3(model, messages, tools, options) {
+  const body = { model, messages: to_openai_messages(messages) };
+  const wire_tools = to_openai_tools(tools);
+  if (wire_tools.length > 0) {
+    body.tools = wire_tools;
+  }
+  if (options?.temperature !== void 0) {
+    body.temperature = options.temperature;
+  }
+  if (options?.max_tokens !== void 0) {
+    body.max_tokens = options.max_tokens;
+  }
+  return body;
+}
+function build_request_init3(api_key, body, signal) {
+  return {
+    method: "POST",
+    headers: build_headers3(api_key),
+    body,
+    ...signal !== void 0 ? { signal } : {}
+  };
+}
+async function do_fetch3(fetch_fn, url, init, provider_name) {
+  try {
+    return await fetch_fn(url, init);
+  } catch (error) {
+    const label = is_abort_like4(error) === true ? "request aborted or timed out" : "fetch failed";
+    throw new ProviderError({
+      kind: "network",
+      provider_name,
+      message: `${label}: ${describe_error4(error)}`,
+      cause: error
+    });
+  }
+}
+async function read_response_text3(response, provider_name) {
+  try {
+    return await response.text();
+  } catch (error) {
+    throw new ProviderError({
+      kind: "network",
+      provider_name,
+      message: `failed to read response body: ${describe_error4(error)}`,
+      cause: error
+    });
+  }
+}
+async function read_success_json3(response, provider_name) {
+  const text = await read_response_text3(response, provider_name);
+  const dto = safe_json_parse(text);
+  if (dto === void 0) {
+    throw new ProviderError({
+      kind: "bad_request",
+      provider_name,
+      message: `unparseable success response: ${truncate_text(text, MAX_ERROR_BODY_CHARS3)}`
+    });
+  }
+  return dto;
+}
+function parse_retry_after_ms3(response) {
+  const raw = response.headers.get("retry-after");
+  if (raw === null) {
+    return void 0;
+  }
+  const seconds = Number(raw);
+  if (Number.isFinite(seconds) === false || seconds < 0) {
+    return void 0;
+  }
+  return Math.round(seconds * 1e3);
+}
+function status_to_error_kind3(status, body_text) {
+  if (status === 401 || status === 403) {
+    return "auth";
+  }
+  if (status === 429 || status >= 500) {
+    return "rate_limit";
+  }
+  if (status === 400 && OVERFLOW_BODY_PATTERN3.test(body_text) === true) {
+    return "overflow";
+  }
+  return "bad_request";
+}
+async function to_http_error3(response, provider_name) {
+  const body_text = truncate_text(await read_response_text3(response, provider_name), MAX_ERROR_BODY_CHARS3);
+  const retry_after_ms = parse_retry_after_ms3(response);
+  return new ProviderError({
+    kind: status_to_error_kind3(response.status, body_text),
+    provider_name,
+    message: `${provider_name} http ${response.status}: ${body_text}`,
+    status: response.status,
+    ...retry_after_ms !== void 0 ? { retry_after_ms } : {}
+  });
+}
+function parse_chat_response2(dto, config) {
+  const choice = dto.choices?.[0];
+  if (choice === void 0 || choice.message === void 0) {
+    throw new ProviderError({
+      kind: "bad_request",
+      provider_name: config.name,
+      message: "provider returned a success response without choices"
+    });
+  }
+  return {
+    message: parse_assistant_message2(choice.message),
+    usage: parse_usage3(dto.usage),
+    finish_reason: map_finish_reason(choice.finish_reason),
+    model: dto.model ?? config.model,
+    provider_name: config.name
+  };
+}
+function parse_assistant_message2(dto) {
+  const content_parts = [];
+  if (dto.content !== void 0 && dto.content !== null && dto.content.length > 0) {
+    content_parts.push(dto.content);
+  }
+  const tool_calls = [];
+  for (const raw_call of dto.tool_calls ?? []) {
+    const raw_arguments = raw_call.function?.arguments ?? "";
+    const parsed_arguments = raw_arguments.length === 0 ? {} : safe_json_parse(raw_arguments);
+    if (is_record3(parsed_arguments) === true) {
+      tool_calls.push({ id: raw_call.id ?? "", name: raw_call.function?.name ?? "", args: parsed_arguments });
+    } else {
+      tool_calls.push({ id: raw_call.id ?? "", name: raw_call.function?.name ?? "", args: {} });
+      content_parts.push(UNPARSEABLE_ARGS_NOTE3);
+    }
+  }
+  return {
+    role: "assistant",
+    content: content_parts.filter((part) => part.length > 0).join("\n"),
+    ...tool_calls.length > 0 ? { tool_calls } : {}
+  };
+}
+function parse_usage3(dto) {
+  const prompt_tokens = dto?.prompt_tokens ?? 0;
+  const completion_tokens = dto?.completion_tokens ?? 0;
+  const total_tokens = dto?.total_tokens ?? prompt_tokens + completion_tokens;
+  return { prompt_tokens, completion_tokens, total_tokens };
+}
+function map_finish_reason(raw) {
+  if (raw === "stop") {
+    return "stop";
+  }
+  if (raw === "tool_calls") {
+    return "tool_calls";
+  }
+  if (raw === "length") {
+    return "length";
+  }
+  return "unknown";
+}
+function is_record3(value) {
+  return typeof value === "object" && value !== null;
+}
+function describe_error4(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function error_name4(error) {
+  if (typeof error === "object" && error !== null && "name" in error) {
+    const name = error.name;
+    return typeof name === "string" ? name : void 0;
+  }
+  return void 0;
+}
+function is_abort_like4(error) {
+  const name = error_name4(error);
+  return name === "AbortError" || name === "TimeoutError";
+}
+
+// src/providers/router.ts
+var FAILOVER_MAX_ATTEMPTS = 3;
+var ProviderRouter = class {
+  configs;
+  cache = /* @__PURE__ */ new Map();
+  constructor(configs) {
+    if (configs.length === 0) {
+      throw new Error("at least one provider is required");
+    }
+    this.configs = [...configs];
+  }
+  get(name) {
+    if (this.cache.has(name) === true) {
+      return this.cache.get(name);
+    }
+    const config = this.find_config(name);
+    if (config === void 0) {
+      return void 0;
+    }
+    const provider = build_provider(config);
+    this.cache.set(name, provider);
+    return provider;
+  }
+  list() {
+    const providers = [];
+    for (const config of this.configs) {
+      const provider = this.get(config.name);
+      if (provider !== void 0) {
+        providers.push(provider);
+      }
+    }
+    return providers;
+  }
+  default_provider() {
+    const [first_config] = this.configs;
+    if (first_config === void 0) {
+      throw new Error("at least one provider is required");
+    }
+    const provider = this.get(first_config.name);
+    if (provider === void 0) {
+      throw new Error(`provider config "${first_config.name}" could not be built`);
+    }
+    return provider;
+  }
+  chat_with_failover(messages, tools, options) {
+    return chat_with_failover(this, messages, tools, options);
+  }
+  find_config(name) {
+    for (const config of this.configs) {
+      if (config.name === name) {
+        return config;
+      }
+    }
+    return void 0;
+  }
+};
+function build_provider(config) {
+  if (config.kind === "anthropic") {
+    return new AnthropicProvider(config);
+  }
+  if (config.kind === "ollama") {
+    return create_ollama_provider(config);
+  }
+  return new OpenAICompatProvider(config);
+}
+async function chat_with_failover(router, messages, tools, options) {
+  let last_error;
+  for (const provider of router.list()) {
+    if (options?.signal?.aborted === true) {
+      throw last_error ?? make_router_abort_error();
+    }
+    const result = await attempt_provider(provider, messages, tools, options);
+    if (result.ok === true) {
+      return result.value;
+    }
+    last_error = result.error;
+    log_fail_over(result.error);
+  }
+  throw last_error ?? new Error("no providers configured for failover");
+}
+function log_fail_over(error) {
+  if (error.kind === "rate_limit" || error.kind === "network") {
+    return;
+  }
+  logger.warn(`provider "${error.provider_name}" failed with ${error.kind}; failing over to next provider`);
+}
+function make_router_abort_error() {
+  return new ProviderError({
+    kind: "unknown",
+    provider_name: "router",
+    message: "aborted before any provider succeeded"
+  });
+}
+async function attempt_provider(provider, messages, tools, options) {
+  try {
+    return {
+      ok: true,
+      value: await run_with_retries(() => provider.chat(messages, tools, options), {
+        max_attempts: FAILOVER_MAX_ATTEMPTS,
+        signal: options?.signal,
+        on_retry: (kind, attempt, delay_ms) => {
+          logger.warn(
+            `provider "${provider.name}" ${kind} on attempt ${attempt}; retrying in ${delay_ms}ms`
+          );
+        }
+      })
+    };
+  } catch (error) {
+    return { ok: false, error: to_provider_error(error, provider.name) };
+  }
+}
+function to_provider_error(error, fallback_name) {
+  if (error instanceof ProviderError) {
+    return error;
+  }
+  return new ProviderError({
+    kind: "unknown",
+    provider_name: fallback_name,
+    message: error instanceof Error ? error.message : String(error),
+    cause: error
+  });
+}
+
+// src/session/store.ts
+import { appendFile, mkdir as mkdir2, readFile as readFile4 } from "fs/promises";
+import path9 from "path";
+var counter_state = { value: 0 };
+function slugify_label(label) {
+  const slug = label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
+  return slug.length > 0 ? `-${slug}` : "";
+}
+async function open_session(dir, label) {
+  await mkdir2(dir, { recursive: true });
+  counter_state.value += 1;
+  const label_part = label === void 0 ? "" : slugify_label(label);
+  const id = `${Date.now().toString(36)}-${counter_state.value}${label_part}`;
+  const file_path = path9.join(dir, `${id}.jsonl`);
+  return {
+    id,
+    path: file_path,
+    append: async (record) => {
+      await appendFile(file_path, `${safe_stringify(record)}
+`, "utf8");
+    }
+  };
+}
+
+// src/context/tokens.ts
+var TOOL_MESSAGE_OVERHEAD_TOKENS = 8;
+function estimate_text_tokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function estimate_message_tokens(message) {
+  const content_tokens = estimate_text_tokens(message.content);
+  if (message.role === "assistant" && message.tool_calls !== void 0) {
+    return content_tokens + estimate_text_tokens(safe_stringify(message.tool_calls));
+  }
+  if (message.role === "tool") {
+    return content_tokens + TOOL_MESSAGE_OVERHEAD_TOKENS;
+  }
+  return content_tokens;
+}
+function estimate_messages_tokens(messages) {
+  return messages.reduce((total, message) => total + estimate_message_tokens(message), 0);
+}
+
+// src/context/compressor.ts
+var COMPRESSION_SYSTEM_PROMPT = "You compress agent conversation history into terse factual summaries. Preserve: goals, decisions, file paths, commands run, errors, open questions. Output plain text only.";
+var MAX_TRANSCRIPT_CHARS = 24e3;
+function should_compress(messages, budget_tokens, threshold) {
+  return estimate_messages_tokens(messages) >= budget_tokens * threshold;
+}
+function format_history_line(message) {
+  const rendered_calls = message.role === "assistant" && message.tool_calls !== void 0 ? ` tool_calls=${safe_stringify(message.tool_calls)}` : "";
+  return `[${message.role}] ${message.content}${rendered_calls}`;
+}
+function build_summary_request(older, model_hint) {
+  const transcript = older.map((message) => format_history_line(message)).join("\n");
+  const hint = model_hint === void 0 ? "" : `
+(Continuing agent run as model: ${model_hint})`;
+  return {
+    role: "user",
+    content: "Summarize the following earlier conversation so the agent can continue the task from the summary alone.\n\n" + truncate_text(transcript, MAX_TRANSCRIPT_CHARS)
+  };
+}
+function log_compression_failure(error) {
+  if (error instanceof ProviderError) {
+    logger.warn(`context compression failed kind=${error.kind} provider=${error.provider_name}`, error);
+    return;
+  }
+  logger.warn("context compression failed", error);
+}
+async function compress_messages(deps, messages, params) {
+  const system_messages = messages.filter((message) => message.role === "system");
+  const non_system = messages.filter((message) => message.role !== "system");
+  const keep_recent = Math.max(0, params.keep_recent);
+  const recent = non_system.slice(-keep_recent);
+  const older = non_system.slice(0, Math.max(0, non_system.length - recent.length));
+  if (older.length === 0) {
+    return { messages: [...messages], summary_chars: 0 };
+  }
+  try {
+    const result = await deps.chat(
+      [{ role: "system", content: COMPRESSION_SYSTEM_PROMPT }, build_summary_request(older, params.model_hint)],
+      [],
+      { signal: params.signal }
+    );
+    const summary = result.message.content;
+    const summary_message = {
+      role: "user",
+      content: `[context summary of earlier turns]
+${summary}
+[end summary]`
+    };
+    return { messages: [...system_messages, summary_message, ...recent], summary_chars: summary.length };
+  } catch (error) {
+    log_compression_failure(error);
+    return { messages: [...messages], summary_chars: 0 };
+  }
+}
+
+// src/agent/loop.ts
+var DEFAULT_COMPRESS_THRESHOLD = 0.8;
+var KEEP_RECENT_TURNS = 8;
+function turn_range(max_turns) {
+  return Array.from({ length: Math.max(0, max_turns) }, (_unused, index) => index + 1);
+}
+function seed_system_prompt(messages, system_prompt) {
+  const history = [...messages];
+  if (system_prompt === void 0) {
+    return history;
+  }
+  const system_index = history.findIndex((message) => message.role === "system");
+  if (system_index === -1) {
+    const seeded = { role: "system", content: system_prompt };
+    return [seeded, ...history];
+  }
+  const existing = history[system_index];
+  if (existing !== void 0 && existing.content === system_prompt) {
+    return history;
+  }
+  const replaced = { role: "system", content: system_prompt };
+  return [...history.slice(0, system_index), replaced, ...history.slice(system_index + 1)];
+}
+function format_tool_result_content(result) {
+  if (result.error !== void 0) {
+    return JSON.stringify({ ok: false, output: result.output, error: result.error });
+  }
+  return result.output;
+}
+async function run_tool_calls(deps, history, turn, calls, emitter) {
+  for (const call of calls) {
+    emitter?.emit({ type: "tool_call_start", turn, call });
+    const result = await deps.tools.execute(call.name, call.args);
+    const tool_message = {
+      role: "tool",
+      tool_call_id: call.id,
+      name: call.name,
+      content: format_tool_result_content(result)
+    };
+    if (result.ok !== true) {
+      tool_message.is_error = true;
+    }
+    history.push(tool_message);
+    emitter?.emit({ type: "tool_call_end", turn, call, result });
+  }
+}
+async function call_chat(deps, history, params, emitter) {
+  try {
+    return await deps.chat(history, deps.definitions(), {
+      temperature: params.temperature,
+      max_tokens: params.max_tokens,
+      signal: params.signal
+    });
+  } catch (error) {
+    if (error instanceof ProviderError) {
+      logger.error(`provider error kind=${error.kind} provider=${error.provider_name}`, error);
+    } else {
+      logger.error("agent chat call failed", error);
+    }
+    emitter?.emit({ type: "error", error });
+    throw error;
+  }
+}
+async function compress_if_needed(deps, history, params, emitter) {
+  const budget_tokens = params.context_budget_tokens;
+  if (budget_tokens === void 0) {
+    return;
+  }
+  const threshold = params.compress_threshold ?? DEFAULT_COMPRESS_THRESHOLD;
+  if (!should_compress(history, budget_tokens, threshold)) {
+    return;
+  }
+  const non_system_count = history.filter((message) => message.role !== "system").length;
+  if (non_system_count <= KEEP_RECENT_TURNS) {
+    return;
+  }
+  emitter?.emit({ type: "compress_start", estimated_tokens: estimate_messages_tokens(history) });
+  const outcome = await compress_messages(
+    { chat: deps.chat },
+    history,
+    { budget_tokens, keep_recent: KEEP_RECENT_TURNS, signal: params.signal }
+  );
+  history.length = 0;
+  for (const message of outcome.messages) {
+    history.push(message);
+  }
+  emitter?.emit({ type: "compress_end", summary_chars: outcome.summary_chars });
+}
+function find_last_assistant(messages) {
+  return [...messages].reverse().find((message) => message.role === "assistant");
+}
+async function run_conversation(deps, messages, params) {
+  const history = seed_system_prompt(messages, params.system_prompt);
+  const emitter = deps.emitter;
+  for (const turn of turn_range(params.max_turns)) {
+    if (params.signal?.aborted === true) {
+      emitter?.emit({ type: "error", error: new DOMException("agent loop aborted", "AbortError") });
+      return {
+        messages: history,
+        final: find_last_assistant(history),
+        result: void 0,
+        turns_used: turn - 1,
+        stopped_reason: "aborted"
+      };
+    }
+    emitter?.emit({ type: "turn_start", turn });
+    await compress_if_needed(deps, history, params, emitter);
+    emitter?.emit({ type: "llm_start", turn });
+    const result = await call_chat(deps, history, params, emitter);
+    emitter?.emit({ type: "llm_end", turn, result });
+    history.push(result.message);
+    const calls = result.message.tool_calls ?? [];
+    if (calls.length === 0) {
+      emitter?.emit({ type: "final", message: result.message, result });
+      emitter?.emit({ type: "turn_end", turn });
+      return { messages: history, final: result.message, result, turns_used: turn, stopped_reason: "final" };
+    }
+    await run_tool_calls(deps, history, turn, calls, emitter);
+  }
+  emitter?.emit({ type: "budget_exhausted", turns_used: params.max_turns });
+  emitter?.emit({ type: "turn_end", turn: params.max_turns });
+  return {
+    messages: history,
+    final: find_last_assistant(history),
+    result: void 0,
+    turns_used: params.max_turns,
+    stopped_reason: "budget"
+  };
+}
+
+// src/agent/agent.ts
+var DEFAULT_AGENT_SYSTEM_PROMPT = "You are a capable, concise assistant. Use the available tools whenever they help you complete the user's task accurately, and report results plainly.";
+function filter_registry(base, enabled) {
+  if (enabled === "all") {
+    return base;
+  }
+  const allowed = new Set(enabled);
+  const filtered = new ToolRegistry();
+  for (const tool of base.list()) {
+    if (allowed.has(tool.name) === true) {
+      filtered.register(tool);
+    }
+  }
+  return filtered;
+}
+function collect_usage(total) {
+  return (event) => {
+    if (event.type === "llm_end") {
+      total.prompt_tokens += event.result.usage.prompt_tokens;
+      total.completion_tokens += event.result.usage.completion_tokens;
+      total.total_tokens += event.result.usage.total_tokens;
+    }
+  };
+}
+function append_meta(handle, meta) {
+  return handle.append({ ts: (/* @__PURE__ */ new Date()).toISOString(), kind: "meta", meta });
+}
+function register_plugin_tools(registry, plugins) {
+  for (const loaded of plugins) {
+    for (const tool of loaded.plugin.tools ?? []) {
+      if (registry.has(tool.name) === true) {
+        logger.warn(`plugin ${loaded.plugin.name} tool ${tool.name} already registered; skipping`);
+        continue;
+      }
+      registry.register(tool);
+      logger.info(`plugin ${loaded.plugin.name} registered tool ${tool.name}`);
+    }
+  }
+}
+function merge_plugin_hooks(plugins) {
+  const hooks = [];
+  for (const loaded of plugins) {
+    if (loaded.plugin.hooks !== void 0) {
+      hooks.push(loaded.plugin.hooks);
+    }
+  }
+  return hooks;
+}
+var Agent = class {
+  events;
+  config;
+  router;
+  registry;
+  executor;
+  hook_runner;
+  constructor(config, plugins = []) {
+    this.config = config;
+    this.events = new AgentEmitter();
+    this.router = new ProviderRouter(config.providers);
+    const base_registry = new ToolRegistry();
+    register_builtin_tools(base_registry);
+    this.registry = filter_registry(base_registry, config.tools_enabled);
+    register_plugin_tools(this.registry, plugins);
+    const base_executor = new ToolExecutor(this.registry, {
+      work_dir: config.work_dir,
+      env: { LICH_TERMINAL_TIMEOUT_MS: String(config.terminal_timeout_ms) }
+    });
+    const merged_hooks = merge_plugin_hooks(plugins);
+    if (merged_hooks.length > 0) {
+      this.hook_runner = new HookedToolRunner(base_executor, merged_hooks);
+      this.executor = this.hook_runner;
+    } else {
+      this.hook_runner = void 0;
+      this.executor = base_executor;
+    }
+  }
+  async run(options) {
+    const usage_total = { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
+    const stop_collecting = this.events.on(collect_usage(usage_total));
+    await this.call_plugin_run_start(options.input);
+    let outcome;
+    try {
+      const seed_messages = [...options.history ?? []];
+      seed_messages.push({ role: "user", content: options.input });
+      outcome = await run_conversation(this.loop_deps(), seed_messages, {
+        system_prompt: this.config.system_prompt ?? DEFAULT_AGENT_SYSTEM_PROMPT,
+        max_turns: this.config.max_turns,
+        temperature: this.config.temperature,
+        max_tokens: this.config.max_tokens,
+        context_budget_tokens: this.config.context_budget_tokens,
+        compress_threshold: this.config.compress_threshold,
+        signal: options.signal
+      });
+    } finally {
+      stop_collecting();
+      if (outcome !== void 0) {
+        await this.call_plugin_run_end(outcome);
+      }
+    }
+    const session_path = await this.persist_session(outcome, options);
+    const full_messages = [...options.history ?? [], ...outcome.messages];
+    return { outcome, messages: full_messages, usage_total, session_path };
+  }
+  loop_deps() {
+    return {
+      chat: (messages, tools, chat_options) => this.router.chat_with_failover(messages, tools, chat_options),
+      tools: this.executor,
+      definitions: () => this.registry.definitions(),
+      emitter: this.events
+    };
+  }
+  /** Best-effort on_run_start fan-out; hook errors are logged, never fatal. */
+  async call_plugin_run_start(input) {
+    if (this.hook_runner === void 0) {
+      return;
+    }
+    const ctx = { work_dir: this.config.work_dir };
+    await this.hook_runner.call_run_start({ input_chars: input.length }, ctx);
+  }
+  /** Best-effort on_run_end fan-out; hook errors are logged, never fatal. */
+  async call_plugin_run_end(outcome) {
+    if (this.hook_runner === void 0) {
+      return;
+    }
+    const ctx = { work_dir: this.config.work_dir };
+    await this.hook_runner.call_run_end(
+      { stopped_reason: outcome.stopped_reason, turns_used: outcome.turns_used },
+      ctx
+    );
+  }
+  /** Best-effort JSONL transcript: never fails the run, returns undefined path on error. */
+  async persist_session(outcome, options) {
+    try {
+      const handle = await open_session(this.config.session_dir, options.label);
+      await append_meta(handle, { event: "run_start", input_chars: options.input.length, history_size: outcome.messages.length });
+      for (const message of outcome.messages) {
+        await handle.append({ ts: (/* @__PURE__ */ new Date()).toISOString(), kind: "message", message });
+      }
+      if (outcome.stopped_reason === "budget") {
+        await append_meta(handle, { event: "budget_exhausted" });
+      }
+      return handle.path;
+    } catch (error) {
+      logger.warn("session persistence failed; continuing without transcript", error);
+      return void 0;
+    }
+  }
+};
+function create_agent(raw_config) {
+  return new Agent(parse_agent_config(raw_config));
+}
+async function create_agent_with_plugins(raw_config) {
+  const config = parse_agent_config(raw_config);
+  const { plugins, errors } = await load_plugins(config.plugins, config.work_dir);
+  if (errors.length > 0) {
+    logger.warn(`plugin load errors: ${plugin_errors_summary(errors)}`);
+  }
+  return new Agent(config, plugins);
+}
+async function run_agent(raw_config, input, options) {
+  const agent = create_agent(raw_config);
+  return agent.run({ input, signal: options?.signal, label: options?.label });
+}
+
+export {
+  safe_json_parse,
+  truncate_text,
+  logger,
+  register_builtin_tools,
+  ToolRegistry,
+  ToolExecutor,
+  HookedToolRunner,
+  load_plugins,
+  plugin_errors_summary,
+  sleep,
+  ProviderError,
+  parse_agent_config,
+  AgentEmitter,
+  Agent,
+  create_agent,
+  create_agent_with_plugins,
+  run_agent
+};
+//# sourceMappingURL=chunk-P52U5M3L.js.map