@promptev/context-engine 0.0.0

package/dist/hono.cjs

@@ -0,0 +1,3183 @@
+'use strict';
+
+var module$1 = require('module');
+var zod = require('zod');
+var crypto = require('crypto');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/errors.ts
+var EngineActionError, ApprovalNotPending, ApprovalExpired, ExtraMissingError;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    EngineActionError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "EngineActionError";
+      }
+    };
+    ApprovalNotPending = class extends Error {
+      constructor(message = "approval is not pending") {
+        super(message);
+        this.name = "ApprovalNotPending";
+      }
+    };
+    ApprovalExpired = class extends Error {
+      constructor(message = "approval has expired") {
+        super(message);
+        this.name = "ApprovalExpired";
+      }
+    };
+    ExtraMissingError = class extends Error {
+      constructor(extra, pkg, what) {
+        super(`${what} requires the '${pkg}' package (optional extra: ${extra}): npm install ${pkg}`);
+        this.name = "ExtraMissingError";
+      }
+    };
+  }
+});
+
+// src/tools/executors/db.ts
+var db_exports = {};
+__export(db_exports, {
+  MAX_ROWS: () => MAX_ROWS,
+  buildConnectionUrl: () => buildConnectionUrl,
+  executeDb: () => executeDb,
+  executeQuery: () => executeQuery,
+  fetchSchema: () => fetchSchema,
+  getSchemaText: () => getSchemaText,
+  stripSqlNoise: () => stripSqlNoise,
+  testConnection: () => testConnection
+});
+function stripSqlNoise(sql) {
+  return sql.replace(SQL_NOISE_RE, (m) => " ".repeat(m.length));
+}
+function hasKeyword(sqlUpper, keyword) {
+  return new RegExp(`\\b${keyword}\\b`).test(sqlUpper);
+}
+function buildConnectionUrl(config) {
+  const engine = String(config.engine ?? "postgresql");
+  if (engine === "sqlite") return `sqlite:///${config.database ?? ""}`;
+  const host = String(config.host ?? "localhost");
+  const port = Number(config.port ?? 5432);
+  const database = String(config.database ?? "");
+  const username = String(config.username ?? "");
+  const password = encodeURIComponent(String(config.password ?? ""));
+  if (engine === "oracle") {
+    const serviceName = String(config.service_name ?? database);
+    return `oracle://${username}:${password}@${host}:${port}/?service_name=${serviceName}`;
+  }
+  if (engine === "snowflake") {
+    const schemaName = String(config.schema_name ?? "PUBLIC");
+    const warehouse = String(config.warehouse ?? "");
+    let url = `snowflake://${username}:${password}@${host}/${database}/${schemaName}`;
+    if (warehouse) url += `?warehouse=${warehouse}`;
+    return url;
+  }
+  if (engine === "clickhouse") {
+    const secure = [9440, 8443, 443].includes(port);
+    return `clickhouse://${username}:${password}@${host}:${port}/${database}${secure ? "?secure=True" : ""}`;
+  }
+  if (engine === "mysql" || engine === "mariadb") {
+    return `mysql://${username}:${password}@${host}:${port}/${database}`;
+  }
+  if (engine === "mssql") {
+    return `mssql://${username}:${password}@${host}:${port}/${database}`;
+  }
+  return `postgresql://${username}:${password}@${host}:${port}/${database}`;
+}
+function rowsToText(rows) {
+  if (!rows.length) return "";
+  const columns = Object.keys(rows[0]);
+  const lines = [columns.join("	")];
+  for (const row of rows) {
+    lines.push(columns.map((col) => String(row[col] ?? "")).join("	"));
+  }
+  return lines.join("\n");
+}
+async function runOnPostgres(config, sql, maxRows, readOnly = false) {
+  let pg;
+  try {
+    pg = require2("pg");
+  } catch {
+    throw new ExtraMissingError("postgres", "pg", "database tool executor");
+  }
+  const url = buildConnectionUrl({ ...config, engine: "postgresql" });
+  const client = new pg.Client({
+    connectionString: url,
+    connectionTimeoutMillis: CONNECT_TIMEOUT * 1e3,
+    statement_timeout: QUERY_TIMEOUT_MS
+  });
+  await client.connect();
+  try {
+    await client.query("BEGIN");
+    if (readOnly) {
+      try {
+        await client.query("SET TRANSACTION READ ONLY");
+      } catch (exc) {
+        await client.query("ROLLBACK");
+        console.warn(
+          "[context-engine] db executor: engine rejected SET TRANSACTION READ ONLY; read-only mode is enforced by statement inspection alone for this query",
+          exc
+        );
+        await client.query("BEGIN");
+      }
+    }
+    const result = await client.query(sql);
+    await client.query("COMMIT");
+    const columns = result.fields?.map((f) => f.name) ?? (result.rows[0] ? Object.keys(result.rows[0]) : []);
+    const rows = result.rows.slice(0, maxRows).map((r) => ({ ...r }));
+    return { columns, rows, rowCount: result.rowCount ?? rows.length };
+  } catch (e) {
+    try {
+      await client.query("ROLLBACK");
+    } catch {
+    }
+    throw e;
+  } finally {
+    await client.end();
+  }
+}
+async function runOnMysql(config, sql, maxRows) {
+  let mysql;
+  try {
+    mysql = require2("mysql2/promise");
+  } catch {
+    throw new ExtraMissingError("mysql", "mysql2", "MySQL/MariaDB tool executor");
+  }
+  const conn = await mysql.createConnection({
+    host: config.host ?? "localhost",
+    port: Number(config.port ?? 3306),
+    user: config.username ?? "",
+    password: config.password ?? "",
+    database: config.database ?? "",
+    connectTimeout: CONNECT_TIMEOUT * 1e3
+  });
+  try {
+    const [rows, fields] = await conn.query(sql);
+    const list = Array.isArray(rows) ? rows : [];
+    const columns = (fields ?? []).map((f) => f.name);
+    return { columns, rows: list.slice(0, maxRows), rowCount: list.length };
+  } finally {
+    await conn.end();
+  }
+}
+async function executeRaw(config, sql, maxRows, readOnly = false) {
+  const engine = String(config.engine ?? "postgresql");
+  if (engine === "postgresql") return runOnPostgres(config, sql, maxRows, readOnly);
+  if (engine === "mysql" || engine === "mariadb") return runOnMysql(config, sql, maxRows);
+  throw new Error(
+    `db executor: engine ${JSON.stringify(engine)} is not supported in the JS port (supported: postgresql, mysql, mariadb)`
+  );
+}
+function executeQuery(config, sql, maxRows = MAX_ROWS, accessMode = "readonly") {
+  return executeQueryAsync(config, sql, maxRows, accessMode);
+}
+async function executeQueryAsync(config, sql, maxRows, accessModeRaw) {
+  const accessMode = accessModeRaw || "readonly";
+  if (!ALLOWED_ACCESS_MODES.includes(accessMode)) {
+    throw new Error(
+      `Invalid access_mode ${JSON.stringify(accessModeRaw)}; must be one of ${ALLOWED_ACCESS_MODES}`
+    );
+  }
+  const sqlUpper = stripSqlNoise(sql).trim().toUpperCase();
+  for (const keyword of ALWAYS_BLOCKED) {
+    if (hasKeyword(sqlUpper, keyword)) {
+      return { success: false, error: `${keyword} queries are not allowed` };
+    }
+  }
+  if (accessMode === "readonly") {
+    if (!sqlUpper.startsWith("SELECT") && !sqlUpper.startsWith("WITH")) {
+      return { success: false, error: "Only SELECT queries are allowed in read-only mode" };
+    }
+    for (const keyword of READONLY_BLOCKED) {
+      if (hasKeyword(sqlUpper, keyword)) {
+        return { success: false, error: `${keyword} queries are not allowed in read-only mode` };
+      }
+    }
+  } else if (accessMode === "readwrite") {
+    for (const keyword of READWRITE_BLOCKED) {
+      if (hasKeyword(sqlUpper, keyword)) {
+        return { success: false, error: `${keyword} queries are not allowed in read-write mode` };
+      }
+    }
+  }
+  try {
+    const result = await executeRaw(config, sql, maxRows, accessMode === "readonly");
+    if (!sqlUpper.startsWith("SELECT") && !sqlUpper.startsWith("WITH")) {
+      return {
+        success: true,
+        columns: [],
+        rows: [],
+        row_count: result.rowCount,
+        affected_rows: result.rowCount,
+        truncated: false
+      };
+    }
+    return {
+      success: true,
+      columns: result.columns,
+      rows: result.rows,
+      row_count: result.rows.length,
+      truncated: result.rows.length >= maxRows,
+      text: rowsToText(result.rows)
+    };
+  } catch (e) {
+    return { success: false, error: String(e) };
+  }
+}
+async function executeDb(config, sql) {
+  const maxRows = Number(config.max_rows ?? MAX_ROWS);
+  const accessMode = String(config.access_mode ?? "readonly");
+  return executeQueryAsync(config, sql, maxRows, accessMode);
+}
+async function testConnection(config) {
+  const engineType = String(config.engine ?? "postgresql");
+  const versionQueries = {
+    postgresql: "SELECT version()",
+    mysql: "SELECT version()",
+    mariadb: "SELECT version()",
+    mssql: "SELECT @@VERSION",
+    sqlite: "SELECT sqlite_version()",
+    oracle: "SELECT banner FROM v$version WHERE ROWNUM = 1",
+    clickhouse: "SELECT version()",
+    snowflake: "SELECT CURRENT_VERSION()"
+  };
+  const q = versionQueries[engineType] ?? "SELECT version()";
+  const result = await executeQueryAsync(config, q, 1, "readonly");
+  if (!result.success) return { success: false, error: result.error };
+  const version = result.rows?.[0] ? Object.values(result.rows[0])[0] : null;
+  return {
+    success: true,
+    version: String(version),
+    host: config.host,
+    database: config.database,
+    engine: engineType
+  };
+}
+async function fetchSchema(config, selectedTables) {
+  const engine = String(config.engine ?? "postgresql");
+  if (engine !== "postgresql") {
+    return { success: false, error: `schema introspection is implemented for postgresql (got ${engine})` };
+  }
+  let pg;
+  try {
+    pg = require2("pg");
+  } catch {
+    throw new ExtraMissingError("postgres", "pg", "database tool executor");
+  }
+  const client = new pg.Client({ connectionString: buildConnectionUrl(config) });
+  await client.connect();
+  try {
+    const schemaName = String(config.schema_name ?? "public");
+    const tablesRes = await client.query(
+      `SELECT table_name, table_type FROM information_schema.tables WHERE table_schema = $1`,
+      [schemaName]
+    );
+    let items = tablesRes.rows.map((r) => ({
+      name: String(r.table_name),
+      type: String(r.table_type).toLowerCase().includes("view") ? "view" : "table"
+    }));
+    if (selectedTables?.length) {
+      const selected = new Set(selectedTables);
+      items = items.filter((i) => selected.has(i.name));
+    }
+    const tables = [];
+    for (const item of items) {
+      const cols = await client.query(
+        `SELECT column_name, data_type, is_nullable FROM information_schema.columns
+         WHERE table_schema = $1 AND table_name = $2 ORDER BY ordinal_position`,
+        [schemaName, item.name]
+      );
+      tables.push({
+        name: item.name,
+        type: item.type,
+        columns: cols.rows.map((c) => ({
+          name: c.column_name,
+          type: c.data_type,
+          nullable: c.is_nullable === "YES"
+        })),
+        row_count: 0
+      });
+    }
+    return {
+      success: true,
+      database: config.database,
+      schema: schemaName,
+      tables,
+      table_count: tables.length,
+      all_tables: items.map((i) => i.name)
+    };
+  } finally {
+    await client.end();
+  }
+}
+async function getSchemaText(config, selectedTables) {
+  const schema = await fetchSchema(config, selectedTables);
+  const schemaRows = [];
+  for (const table of schema.tables ?? []) {
+    const kind = table.type ?? "table";
+    for (const c of table.columns ?? []) {
+      schemaRows.push({
+        table: table.name,
+        table_type: kind,
+        column: c.name,
+        type: String(c.type).toUpperCase(),
+        pk: c.pk ?? false,
+        fk: c.fk ?? "",
+        rows: table.row_count
+      });
+    }
+  }
+  return rowsToText(schemaRows);
+}
+var require2, MAX_ROWS, CONNECT_TIMEOUT, QUERY_TIMEOUT_MS, ALWAYS_BLOCKED, READONLY_BLOCKED, READWRITE_BLOCKED, ALLOWED_ACCESS_MODES, SQL_NOISE_RE;
+var init_db = __esm({
+  "src/tools/executors/db.ts"() {
+    init_errors();
+    require2 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('hono.cjs', document.baseURI).href)));
+    MAX_ROWS = 1e3;
+    CONNECT_TIMEOUT = 10;
+    QUERY_TIMEOUT_MS = 3e4;
+    ALWAYS_BLOCKED = ["GRANT", "REVOKE"];
+    READONLY_BLOCKED = ["INSERT", "UPDATE", "DELETE", "DROP", "ALTER", "CREATE", "TRUNCATE"];
+    READWRITE_BLOCKED = ["DELETE", "DROP", "TRUNCATE"];
+    ALLOWED_ACCESS_MODES = ["readonly", "readwrite", "full"];
+    SQL_NOISE_RE = /'(?:[^']|'')*'|\$([A-Za-z_]\w*)?\$.*?\$\1?\$|--[^\n]*|\/\*[\s\S]*?\*\//g;
+  }
+});
+
+// src/hono.ts
+init_errors();
+
+// src/sentinels.ts
+var TrustedSentinel = class {
+  [Symbol.toStringTag] = "TRUSTED";
+  toString() {
+    return "TRUSTED";
+  }
+  valueOf() {
+    return true;
+  }
+};
+var TRUSTED = Object.freeze(new TrustedSentinel());
+
+// src/routing-core.ts
+var HandlerError = class extends Error {
+  status;
+  detail;
+  constructor(status, detail) {
+    super(typeof detail === "string" ? detail : JSON.stringify(detail));
+    this.name = "HandlerError";
+    this.status = status;
+    this.detail = detail;
+  }
+};
+var ingestJsonRequestSchema = zod.z.object({
+  text: zod.z.string(),
+  name: zod.z.string(),
+  source_id: zod.z.string().nullable().optional(),
+  external_id: zod.z.string().nullable().optional(),
+  description: zod.z.string().nullable().optional(),
+  meta_data: zod.z.record(zod.z.unknown()).nullable().optional(),
+  acl: zod.z.array(zod.z.string()).nullable().optional(),
+  mode: zod.z.enum(["hybrid", "graph"]).nullable().optional(),
+  extract_structured: zod.z.boolean().optional().default(false),
+  batch: zod.z.boolean().optional().default(false)
+}).strip();
+var documentPatchSchema = zod.z.object({
+  acl: zod.z.array(zod.z.string()).nullable().optional(),
+  name: zod.z.string().nullable().optional(),
+  description: zod.z.string().nullable().optional(),
+  meta_data: zod.z.record(zod.z.unknown()).nullable().optional()
+}).strict();
+var searchRequestSchema = zod.z.object({
+  query: zod.z.string(),
+  source_ids: zod.z.array(zod.z.string()).nullable().optional(),
+  top_k: zod.z.number().int().optional().default(10),
+  mode: zod.z.enum(["hybrid", "graph"]).optional().default("hybrid"),
+  compress_to_tokens: zod.z.number().int().nullable().optional()
+}).strip();
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function requireValidUuid(documentId) {
+  if (!UUID_RE.test(String(documentId))) {
+    throw new HandlerError(400, `invalid document id: ${JSON.stringify(documentId)}`);
+  }
+}
+function formBool(value) {
+  if (typeof value === "boolean") return value;
+  if (value == null) return false;
+  return ["1", "true", "yes", "on"].includes(String(value).trim().toLowerCase());
+}
+function formJson(value) {
+  if (value === void 0 || value === null || value === "") return null;
+  if (typeof value === "object") return value;
+  try {
+    return JSON.parse(String(value));
+  } catch {
+    throw new HandlerError(400, `invalid JSON in field: ${JSON.stringify(value)}`);
+  }
+}
+function formStr(value) {
+  return value === void 0 || value === null || value === "" ? null : String(value);
+}
+function resolveRequestPrincipals(value, opts) {
+  if (value === TRUSTED) return null;
+  if (value == null) {
+    throw new HandlerError(
+      500,
+      `${opts.surface}: the \`principals\` dependency returned null, which means TRUSTED CALLER \u2014 it disables ACL filtering and skips the check that stops a caller filing documents under groups it does not hold. This mount is misconfigured: return [] for an unauthenticated caller, or pass TRUSTED explicitly (from @promptev/context-engine) if the surface really is trusted.`
+    );
+  }
+  return value;
+}
+function authorizeAcl(requested, principals) {
+  if (requested == null || principals == null) return;
+  if (!Array.isArray(requested)) {
+    throw new HandlerError(422, "acl must be a list of principal strings");
+  }
+  const held = new Set(principals);
+  const ungranted = [...new Set(requested.map(String))].filter((p) => !held.has(p)).sort();
+  if (ungranted.length) {
+    throw new HandlerError(403, `cannot grant access to principals you do not hold: ${ungranted}`);
+  }
+}
+function asDict(obj) {
+  if (obj == null) return obj;
+  if (typeof obj === "object" && typeof obj.toJSON === "function") {
+    return obj.toJSON();
+  }
+  return obj;
+}
+function zodError(err) {
+  return new HandlerError(
+    422,
+    err.issues.map((i) => ({ loc: i.path, msg: i.message, type: i.code }))
+  );
+}
+async function runIngest(engine, kwargs) {
+  try {
+    return asDict(await engine.ingest(kwargs));
+  } catch (exc) {
+    if (exc instanceof TypeError || exc instanceof Error && exc.name === "TypeError") {
+      throw new HandlerError(400, String(exc));
+    }
+    if (exc instanceof Error && exc.name === "Error" && /invalid|required/i.test(exc.message)) {
+      throw new HandlerError(400, String(exc));
+    }
+    throw exc;
+  }
+}
+async function handleIngestJson(engine, payload, principals) {
+  const resolved = resolveRequestPrincipals(principals, { surface: "handle_ingest_json" });
+  const parsed = ingestJsonRequestSchema.safeParse(payload);
+  if (!parsed.success) throw zodError(parsed.error);
+  const body = parsed.data;
+  authorizeAcl(body.acl, resolved);
+  return runIngest(engine, {
+    text: body.text,
+    name: body.name,
+    description: body.description,
+    sourceId: body.source_id,
+    externalId: body.external_id,
+    metaData: body.meta_data,
+    acl: body.acl,
+    mode: body.mode,
+    extractStructured: body.extract_structured,
+    batch: body.batch
+  });
+}
+async function handleIngestFile(engine, opts) {
+  const resolved = resolveRequestPrincipals(opts.principals, { surface: "handle_ingest_file" });
+  const form = opts.form instanceof Map ? Object.fromEntries(opts.form) : opts.form;
+  const acl = formJson(form.acl);
+  authorizeAcl(acl, resolved);
+  return runIngest(engine, {
+    content: opts.content,
+    filename: opts.filename,
+    name: formStr(form.name) || opts.filename,
+    description: formStr(form.description),
+    sourceId: formStr(form.source_id),
+    externalId: formStr(form.external_id),
+    metaData: formJson(form.meta_data),
+    acl,
+    mode: formStr(form.mode),
+    extractStructured: formBool(form.extract_structured),
+    batch: formBool(form.batch)
+  });
+}
+async function handleListDocuments(engine, opts) {
+  const resolved = resolveRequestPrincipals(opts.principals, { surface: "handle_list_documents" });
+  let parsedCursor = null;
+  if (opts.cursor) {
+    try {
+      parsedCursor = JSON.parse(opts.cursor);
+    } catch {
+      throw new HandlerError(400, `invalid cursor: ${JSON.stringify(opts.cursor)}`);
+    }
+  }
+  return engine.listDocuments({
+    sourceId: opts.sourceId ?? null,
+    principals: resolved,
+    cursor: parsedCursor,
+    limit: opts.limit
+  });
+}
+async function handleGetDocument(engine, documentId, principals) {
+  const resolved = resolveRequestPrincipals(principals, { surface: "handle_get_document" });
+  requireValidUuid(documentId);
+  try {
+    return await engine.getDocument(documentId, { principals: resolved });
+  } catch (exc) {
+    if (exc instanceof Error && (exc.name === "DocumentNotFoundError" || exc instanceof TypeError === false)) {
+      const msg = String(exc);
+      if (/not found/i.test(msg) || exc.name === "DocumentNotFoundError") {
+        throw new HandlerError(404, msg.replace(/^Error:\s*/, ""));
+      }
+    }
+    throw exc;
+  }
+}
+async function handleDeleteDocument(engine, documentId, principals) {
+  const resolved = resolveRequestPrincipals(principals, { surface: "handle_delete_document" });
+  requireValidUuid(documentId);
+  try {
+    await engine.deleteDocument(documentId, { principals: resolved });
+  } catch (exc) {
+    const msg = String(exc);
+    if (/not found/i.test(msg) || exc instanceof Error && exc.name === "DocumentNotFoundError") {
+      throw new HandlerError(404, msg.replace(/^Error:\s*/, ""));
+    }
+    throw exc;
+  }
+  return { deleted: documentId };
+}
+async function handleUpdateDocument(engine, documentId, payload, principals) {
+  const resolved = resolveRequestPrincipals(principals, { surface: "handle_update_document" });
+  requireValidUuid(documentId);
+  const parsed = documentPatchSchema.safeParse(payload);
+  if (!parsed.success) throw zodError(parsed.error);
+  const provided = {};
+  const raw = payload;
+  for (const key of ["acl", "name", "description", "meta_data"]) {
+    if (Object.hasOwn(raw, key)) {
+      provided[key === "meta_data" ? "metaData" : key] = raw[key];
+    }
+  }
+  if ("acl" in provided) authorizeAcl(provided.acl, resolved);
+  try {
+    const changed = await engine.updateDocument(documentId, { principals: resolved, ...provided });
+    return { changed };
+  } catch (exc) {
+    const msg = String(exc);
+    if (/not found/i.test(msg) || exc instanceof Error && exc.name === "DocumentNotFoundError") {
+      throw new HandlerError(404, msg.replace(/^Error:\s*/, ""));
+    }
+    throw exc;
+  }
+}
+async function handleSearch(engine, payload, principals) {
+  const resolved = resolveRequestPrincipals(principals, { surface: "handle_search" });
+  const parsed = searchRequestSchema.safeParse(payload);
+  if (!parsed.success) throw zodError(parsed.error);
+  const body = parsed.data;
+  try {
+    const result = await engine.search(body.query, {
+      sourceIds: body.source_ids,
+      principals: resolved,
+      topK: body.top_k,
+      mode: body.mode,
+      compressToTokens: body.compress_to_tokens
+    });
+    const hits = (result.hits ?? []).map((hit) => asDict(hit));
+    return { hits, usage: result.usage };
+  } catch (exc) {
+    if (exc instanceof Error && /invalid|required|graph/i.test(exc.message)) {
+      throw new HandlerError(400, String(exc));
+    }
+    throw exc;
+  }
+}
+async function handleStats(engine, sourceId) {
+  return engine.stats(sourceId ?? null);
+}
+
+// src/tools/router.ts
+init_errors();
+
+// src/tools/acl.ts
+function aclVisible(acl, principals) {
+  if (principals === null) return true;
+  if (acl == null) return true;
+  if (!acl.length) return false;
+  const held = new Set(principals ?? []);
+  return acl.some((p) => held.has(p));
+}
+
+// src/tools/approval.ts
+init_errors();
+var DEFAULT_TIMEOUT_MINUTES = 60;
+var DEFAULT_LIST_LIMIT = 50;
+var MAX_LIST_LIMIT = 200;
+var CONDITION_RE = /^\s*(?<field>[A-Za-z_][A-Za-z0-9_.]*)\s*(?<op>>=|<=|==|!=|>|<)\s*(?<value>.+?)\s*$/;
+function coerceValue(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.length >= 2 && trimmed[0] === trimmed[trimmed.length - 1] && (trimmed[0] === "'" || trimmed[0] === '"')) {
+    return trimmed.slice(1, -1);
+  }
+  if (/^-?\d+$/.test(trimmed)) return Number.parseInt(trimmed, 10);
+  if (/^-?\d+\.\d+$/.test(trimmed)) return Number.parseFloat(trimmed);
+  return trimmed;
+}
+function evaluateCondition(condition, args) {
+  if (typeof condition !== "string") return true;
+  const match = CONDITION_RE.exec(condition);
+  if (!match?.groups) return true;
+  const fieldName = match.groups.field;
+  const op = match.groups.op;
+  if (!(fieldName in args)) return true;
+  const left = args[fieldName];
+  const right = coerceValue(match.groups.value);
+  try {
+    switch (op) {
+      case ">":
+        return left > right;
+      case ">=":
+        return left >= right;
+      case "<":
+        return left < right;
+      case "<=":
+        return left <= right;
+      case "==":
+        return left === right;
+      case "!=":
+        return left !== right;
+      default:
+        return true;
+    }
+  } catch {
+    return true;
+  }
+}
+function shouldRequireApproval(ct, args) {
+  if (ct.requiresApproval) return true;
+  const policy = ct.approvalPolicy ?? {};
+  const condition = policy.condition;
+  if (!condition) return false;
+  return evaluateCondition(condition, args ?? {});
+}
+function rowToRecord(row) {
+  return {
+    id: String(row.id),
+    toolName: String(row.tool_name),
+    toolArgsFrozen: row.tool_args_frozen ?? {},
+    sourceId: row.source_id ?? null,
+    principals: row.principals,
+    status: String(row.status),
+    approver: row.approver ?? null,
+    approverMeta: row.approver_meta ?? null,
+    expiresAt: row.expires_at ? new Date(String(row.expires_at)) : null,
+    resolvedAt: row.resolved_at ? new Date(String(row.resolved_at)) : null,
+    createdAt: row.created_at ? new Date(String(row.created_at)) : null
+  };
+}
+function visibilitySql(principals, paramIndex) {
+  if (principals === null) return { sql: "TRUE", params: [] };
+  if (!principals.length) {
+    return { sql: `(principals IS NULL OR principals = 'null'::jsonb)`, params: [] };
+  }
+  return {
+    sql: `(principals IS NULL OR principals = 'null'::jsonb OR principals ?| $${paramIndex}::text[])`,
+    params: [principals]
+  };
+}
+async function createPending(engine, opts) {
+  const policy = opts.policy ?? {};
+  const frozen = structuredClone(opts.args);
+  const createdAt = opts.now ?? /* @__PURE__ */ new Date();
+  const timeout = Number(policy.timeout_minutes ?? DEFAULT_TIMEOUT_MINUTES);
+  const expiresAt = new Date(createdAt.getTime() + timeout * 6e4);
+  const id = crypto.randomUUID();
+  await engine.pool.query(
+    `INSERT INTO context_engine_tool_approvals
+      (id, tool_name, tool_args_frozen, source_id, principals, status, expires_at, created_at)
+     VALUES ($1,$2,$3::jsonb,$4,$5::jsonb,'pending',$6,$7)`,
+    [
+      id,
+      opts.toolName,
+      JSON.stringify(frozen),
+      opts.sourceId ?? null,
+      opts.principals === void 0 ? null : JSON.stringify(opts.principals),
+      expiresAt,
+      createdAt
+    ]
+  );
+  return {
+    id,
+    toolName: opts.toolName,
+    toolArgsFrozen: frozen,
+    sourceId: opts.sourceId ?? null,
+    principals: opts.principals ?? null,
+    status: "pending",
+    approver: null,
+    approverMeta: null,
+    expiresAt,
+    resolvedAt: null,
+    createdAt
+  };
+}
+async function resolveApproval(engine, approvalId, decision, approver, meta = null, opts = {}) {
+  if (decision !== "approved" && decision !== "rejected") {
+    throw new Error(`invalid decision: ${JSON.stringify(decision)} (expected 'approved' or 'rejected')`);
+  }
+  const principals = opts.principals === void 0 ? null : opts.principals;
+  const vis = visibilitySql(principals, 5);
+  const result = await engine.pool.query(
+    `UPDATE context_engine_tool_approvals
+     SET status = $1, approver = $2, approver_meta = $3::jsonb, resolved_at = now()
+     WHERE id = $4 AND status = 'pending'
+       AND (expires_at IS NULL OR expires_at > now())
+       AND ${vis.sql}
+     RETURNING *`,
+    [decision, approver, JSON.stringify(meta ?? {}), approvalId, ...vis.params]
+  );
+  if (result.rowCount === 1) return rowToRecord(result.rows[0]);
+  const existing = await engine.pool.query(`SELECT * FROM context_engine_tool_approvals WHERE id = $1`, [
+    approvalId
+  ]);
+  const row = existing.rows[0];
+  const rowPrincipals = row?.principals == null || row.principals === null ? null : row.principals;
+  if (!row || !aclVisible(Array.isArray(rowPrincipals) ? rowPrincipals : null, principals)) {
+    throw new ApprovalNotPending("not_found");
+  }
+  if (row.status === "pending") {
+    await engine.pool.query(
+      `UPDATE context_engine_tool_approvals SET status = 'expired' WHERE id = $1 AND status = 'pending'`,
+      [approvalId]
+    );
+    throw new ApprovalExpired();
+  }
+  throw new ApprovalNotPending(String(row.status));
+}
+async function listApprovals(engine, opts = {}) {
+  const limit = Math.max(1, Math.min(Number(opts.limit || DEFAULT_LIST_LIMIT), MAX_LIST_LIMIT));
+  const principals = opts.principals === void 0 ? null : opts.principals;
+  const params = [];
+  const clauses = [];
+  if (opts.status != null) {
+    params.push(opts.status);
+    clauses.push(`status = $${params.length}`);
+  }
+  if (opts.sourceId != null) {
+    params.push(opts.sourceId);
+    clauses.push(`source_id = $${params.length}`);
+  }
+  const vis = visibilitySql(principals, params.length + 1);
+  clauses.push(vis.sql);
+  params.push(...vis.params);
+  params.push(limit);
+  const result = await engine.pool.query(
+    `SELECT * FROM context_engine_tool_approvals
+     WHERE ${clauses.join(" AND ")}
+     ORDER BY created_at DESC
+     LIMIT $${params.length}`,
+    params
+  );
+  return result.rows.map(rowToRecord);
+}
+
+// src/tools/config.ts
+var KINDS = ["http", "db", "mcp", "function"];
+var ToolConfig = class _ToolConfig {
+  id;
+  name;
+  kind;
+  description;
+  config;
+  sourceId;
+  acl;
+  requiresApproval;
+  approvalPolicy;
+  enabled;
+  constructor(init) {
+    this.id = init.id ?? null;
+    this.name = init.name;
+    this.kind = init.kind;
+    this.description = init.description ?? "";
+    this.config = init.config ?? {};
+    this.sourceId = init.sourceId ?? init.source_id ?? null;
+    this.acl = init.acl ?? null;
+    this.requiresApproval = init.requiresApproval ?? init.requires_approval ?? false;
+    this.approvalPolicy = init.approvalPolicy ?? init.approval_policy ?? {};
+    this.enabled = init.enabled ?? true;
+  }
+  static fromUnknown(body) {
+    if (!body || typeof body !== "object" || Array.isArray(body)) {
+      throw new Error("tool config must be an object");
+    }
+    const b = body;
+    const kind = String(b.kind ?? "");
+    if (!KINDS.includes(kind)) {
+      throw new Error(`canonicalFromConfig does not support kind=${JSON.stringify(b.kind)}`);
+    }
+    const name = String(b.name ?? "").trim();
+    if (!name) throw new Error("name is required");
+    return new _ToolConfig({
+      id: b.id != null ? String(b.id) : null,
+      name,
+      kind,
+      description: b.description != null ? String(b.description) : "",
+      config: b.config ?? {},
+      sourceId: b.sourceId ?? b.source_id,
+      acl: b.acl ?? null,
+      requiresApproval: Boolean(b.requiresApproval ?? b.requires_approval ?? false),
+      approvalPolicy: b.approvalPolicy ?? b.approval_policy ?? {},
+      enabled: b.enabled === void 0 ? true : Boolean(b.enabled)
+    });
+  }
+};
+var SCHEMAS = {
+  http: {
+    type: "object",
+    properties: {
+      url: { type: "string", description: "Endpoint URL, may contain {path} params" },
+      method: {
+        type: "string",
+        enum: ["GET", "POST", "PUT", "PATCH", "DELETE"],
+        default: "GET"
+      },
+      headers: {
+        type: "object",
+        additionalProperties: { type: "string" },
+        writeOnly: true
+      },
+      parameters: {
+        type: "object",
+        description: "Static/user-fixed parameters sent on every call"
+      },
+      llmParameters: {
+        type: "object",
+        description: "JSON-Schema-shaped parameters the LLM fills in per call"
+      },
+      llmQueryParameters: {
+        type: "object",
+        description: "LLM-filled parameters sent as the query string"
+      }
+    },
+    required: ["url", "method"]
+  },
+  db: {
+    type: "object",
+    properties: {
+      engine: {
+        type: "string",
+        enum: ["postgresql", "mysql", "mariadb", "mssql", "sqlite", "oracle", "clickhouse", "snowflake"]
+      },
+      host: { type: "string" },
+      port: { type: "integer" },
+      database: { type: "string" },
+      username: { type: "string" },
+      password: { type: "string", writeOnly: true },
+      access_mode: {
+        type: "string",
+        enum: ["readonly", "readwrite", "full"],
+        default: "readonly"
+      },
+      max_rows: { type: "integer", default: 1e3 },
+      selected_tables: { type: "array", items: { type: "string" } }
+    },
+    required: ["engine", "database"]
+  },
+  mcp: {
+    type: "object",
+    properties: {
+      url: { type: "string" },
+      transport: { type: "string", enum: ["sse", "http", "websocket"] },
+      oauth: {
+        type: "object",
+        description: "Discovered OAuth config, if any",
+        writeOnly: true
+      },
+      headers: {
+        type: "object",
+        additionalProperties: { type: "string" },
+        writeOnly: true
+      }
+    },
+    required: ["url", "transport"]
+  },
+  function: {
+    type: "object",
+    properties: {}
+  }
+};
+function configSchema(kind) {
+  const schema = SCHEMAS[kind];
+  if (!schema) throw new Error(`unknown tool kind: ${JSON.stringify(kind)}`);
+  return schema;
+}
+
+// src/version.ts
+var __version__ = "0.0.0";
+
+// src/tools/executors/mcp-client.ts
+var MCPError = class _MCPError extends Error {
+  code;
+  data;
+  constructor(code, message, data = null) {
+    super(`[${code}] ${message}`);
+    this.name = "MCPError";
+    this.code = code;
+    this.data = data;
+  }
+  static fromJsonrpc(err) {
+    return new _MCPError(Number(err.code ?? -32e3), String(err.message ?? "MCP error"), err.data);
+  }
+};
+function parseSseBuffer(raw) {
+  const dataLines = raw.split("\n").filter((ln) => ln.startsWith("data:")).map((ln) => ln.slice(5).trimStart());
+  if (!dataLines.length) return null;
+  try {
+    const payload = JSON.parse(dataLines.join("\n"));
+    if (payload && typeof payload === "object" && ("result" in payload || "error" in payload)) {
+      return payload;
+    }
+  } catch {
+  }
+  return null;
+}
+var HttpTransport = class {
+  kind = "http";
+  url;
+  baseHeaders;
+  sessionId = null;
+  constructor(url, headers) {
+    this.url = url;
+    this.baseHeaders = {
+      ...headers,
+      "Content-Type": "application/json",
+      Accept: "application/json, text/event-stream"
+    };
+  }
+  async connect() {
+  }
+  async close() {
+    this.sessionId = null;
+  }
+  buildHeaders() {
+    const hdrs = { ...this.baseHeaders };
+    if (this.sessionId) hdrs["Mcp-Session-Id"] = this.sessionId;
+    return hdrs;
+  }
+  async request(msg) {
+    const resp = await fetch(this.url, {
+      method: "POST",
+      headers: this.buildHeaders(),
+      body: JSON.stringify(msg)
+    });
+    const sid = resp.headers.get("Mcp-Session-Id");
+    if (sid) this.sessionId = sid;
+    if (resp.status >= 400) {
+      const body = await resp.text();
+      console.error(`[HTTP Transport] ${resp.status} from ${this.url}: ${body.slice(0, 300)}`);
+      throw new Error(`HTTP ${resp.status}: ${body.slice(0, 300)}`);
+    }
+    const contentType = resp.headers.get("Content-Type") ?? "";
+    if (contentType.includes("text/event-stream")) {
+      const text = await resp.text();
+      let result = {};
+      for (const frame of text.split(/\r?\n\r?\n/)) {
+        const parsed = parseSseBuffer(frame);
+        if (parsed) result = parsed;
+      }
+      return result;
+    }
+    return await resp.json();
+  }
+  async send(msg) {
+    await this.request(msg);
+  }
+  async recv() {
+    return {};
+  }
+  getBaseHeaders() {
+    return { ...this.baseHeaders };
+  }
+};
+var SseTransport = class {
+  kind = "sse";
+  eventsUrl;
+  baseUrl;
+  headers;
+  postUrl = null;
+  queue = [];
+  waiters = [];
+  abort = null;
+  constructor(url, headers) {
+    this.eventsUrl = url.replace(/\/$/, "");
+    if (url.endsWith("/events")) this.baseUrl = url.slice(0, -7);
+    else if (url.endsWith("/sse")) this.baseUrl = url.slice(0, -4);
+    else this.baseUrl = url.replace(/\/$/, "");
+    this.headers = { ...headers };
+  }
+  enqueue(msg) {
+    const waiter = this.waiters.shift();
+    if (waiter) waiter(msg);
+    else this.queue.push(msg);
+  }
+  async connect() {
+    this.abort = new AbortController();
+    void this.listen();
+  }
+  async listen() {
+    const resp = await fetch(this.eventsUrl, {
+      headers: { ...this.headers, Accept: "text/event-stream" },
+      signal: this.abort?.signal
+    });
+    if (!resp.ok) throw new Error(`SSE ${resp.status}`);
+    if (!resp.body) throw new Error("SSE response has no body");
+    const reader = resp.body.getReader();
+    const decoder = new TextDecoder();
+    let buf = "";
+    let eventType = null;
+    const frame = [];
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buf += decoder.decode(value, { stream: true });
+      const lines = buf.split(/\n/);
+      buf = lines.pop() ?? "";
+      for (const line of lines) {
+        if (line === "" || line === "\r") {
+          this.dispatchFrame(frame, eventType);
+          frame.length = 0;
+          eventType = null;
+          continue;
+        }
+        const stripped = line.replace(/\r$/, "");
+        if (stripped.startsWith("event:")) eventType = stripped.slice(6).trim();
+        frame.push(stripped);
+      }
+    }
+  }
+  dispatchFrame(buf, eventType) {
+    const dataLines = buf.filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trimStart());
+    if (!dataLines.length) return;
+    const payload = dataLines.join("\n");
+    if (eventType === "endpoint") {
+      const endpoint = payload.trim();
+      this.postUrl = endpoint.startsWith("/") ? `${this.baseUrl}${endpoint}` : endpoint;
+      return;
+    }
+    try {
+      this.enqueue(JSON.parse(payload));
+    } catch {
+    }
+  }
+  async close() {
+    this.abort?.abort();
+  }
+  async send(msg) {
+    if (!this.postUrl) {
+      for (let i = 0; i < 30; i++) {
+        if (this.postUrl) break;
+        await new Promise((r) => setTimeout(r, 100));
+      }
+    }
+    const postUrl = this.postUrl || this.baseUrl;
+    const resp = await fetch(postUrl, {
+      method: "POST",
+      headers: { ...this.headers, "Content-Type": "application/json" },
+      body: JSON.stringify(msg)
+    });
+    if (!resp.ok) throw new Error(`SSE POST ${resp.status}`);
+    try {
+      const data = await resp.json();
+      if (data && typeof data === "object" && ("result" in data || "error" in data)) {
+        this.enqueue(data);
+      }
+    } catch {
+    }
+  }
+  async recv() {
+    if (this.queue.length) return this.queue.shift();
+    return new Promise((resolve) => this.waiters.push(resolve));
+  }
+};
+var WsTransport = class {
+  kind = "websocket";
+  url;
+  headers;
+  ws = null;
+  queue = [];
+  waiters = [];
+  constructor(url, headers) {
+    this.url = url;
+    this.headers = headers;
+  }
+  async connect() {
+    const WS = globalThis.WebSocket;
+    if (!WS) throw new Error("WebSocket is not available in this runtime");
+    this.ws = new WS(this.url);
+    this.ws.addEventListener("message", (ev) => {
+      try {
+        const data = JSON.parse(String(ev.data));
+        const waiter = this.waiters.shift();
+        if (waiter) waiter(data);
+        else this.queue.push(data);
+      } catch {
+      }
+    });
+    await new Promise((resolve, reject) => {
+      this.ws.addEventListener("open", () => resolve());
+      this.ws.addEventListener("error", () => reject(new Error("WebSocket error")));
+    });
+  }
+  async close() {
+    this.ws?.close();
+    this.ws = null;
+  }
+  async send(msg) {
+    if (!this.ws) throw new Error("Not connected");
+    this.ws.send(JSON.stringify(msg));
+  }
+  async recv() {
+    if (this.queue.length) return this.queue.shift();
+    return new Promise((resolve) => this.waiters.push(resolve));
+  }
+};
+var MCPClient = class _MCPClient {
+  url;
+  transport;
+  connected = false;
+  id = 0;
+  pending = /* @__PURE__ */ new Map();
+  capabilities = {};
+  tools = [];
+  resources = [];
+  headers;
+  constructor(url, headers = null) {
+    this.url = url;
+    this.headers = headers ?? {};
+    this.transport = _MCPClient.createTransport(url, this.headers);
+  }
+  static createTransport(url, headers) {
+    if (url.startsWith("stdio:") || url === "stdio") {
+      throw new Error("stdio MCP transport is not supported (cloud deployments use SSE/HTTP/WebSocket)");
+    }
+    if (url.startsWith("ws://") || url.startsWith("wss://")) return new WsTransport(url, headers);
+    if (url.startsWith("sse+http://") || url.startsWith("sse+https://") || url.endsWith("/events") || url.endsWith("/sse")) {
+      const clean = url.replace("sse+http://", "http://").replace("sse+https://", "https://");
+      return new SseTransport(clean, headers);
+    }
+    if (url.startsWith("http://") || url.startsWith("https://")) return new HttpTransport(url, headers);
+    throw new Error(`Unsupported URL: ${url} (use http(s)://, ws(s)://, or .../sse)`);
+  }
+  nextId() {
+    this.id += 1;
+    return String(this.id);
+  }
+  async recvLoop() {
+    while (this.connected) {
+      const msg = await this.transport.recv();
+      if (!msg) continue;
+      const mid = msg.id != null ? String(msg.id) : null;
+      if (mid && ("result" in msg || "error" in msg)) {
+        const fut = this.pending.get(mid);
+        this.pending.delete(mid);
+        fut?.resolve(msg);
+      }
+    }
+  }
+  async rpc(method, params = null, timeout = 6e4) {
+    const mid = this.nextId();
+    const payload = { jsonrpc: "2.0", id: mid, method, params: params ?? {} };
+    if (this.transport instanceof HttpTransport) {
+      const msg2 = await this.transport.request(payload);
+      if (msg2.error) throw MCPError.fromJsonrpc(msg2.error);
+      return msg2.result ?? {};
+    }
+    const msg = await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(mid);
+        reject(new Error(`MCP RPC '${method}' timed out after ${timeout}ms`));
+      }, timeout);
+      this.pending.set(mid, {
+        resolve: (v) => {
+          clearTimeout(timer);
+          resolve(v);
+        },
+        reject
+      });
+      void this.transport.send(payload).catch((e) => {
+        clearTimeout(timer);
+        this.pending.delete(mid);
+        reject(e);
+      });
+    });
+    if (msg.error) throw MCPError.fromJsonrpc(msg.error);
+    return msg.result ?? {};
+  }
+  async notify(method, params = null) {
+    await this.transport.send({ jsonrpc: "2.0", method, params: params ?? {} });
+  }
+  async connect() {
+    await this.transport.connect();
+    if (!(this.transport instanceof HttpTransport)) {
+      this.connected = true;
+      void this.recvLoop();
+    }
+    try {
+      const init = await this.rpc("initialize", {
+        protocolVersion: "2024-11-05",
+        capabilities: { roots: { listChanged: true }, sampling: {} },
+        clientInfo: { name: "context-engine", version: __version__ }
+      });
+      this.capabilities = init.capabilities ?? {};
+      await this.notify("notifications/initialized");
+      this.connected = true;
+    } catch (e) {
+      await this.close();
+      throw e;
+    }
+  }
+  async close() {
+    this.connected = false;
+    for (const [, fut] of this.pending) fut.reject(new Error("closed"));
+    this.pending.clear();
+    try {
+      await this.transport.close();
+    } catch {
+    }
+  }
+  async listTools() {
+    const res = await this.rpc("tools/list");
+    this.tools = res.tools ?? [];
+    return this.tools;
+  }
+  async listResources() {
+    try {
+      const res = await this.rpc("resources/list", null, 1e4);
+      this.resources = res.resources ?? [];
+    } catch {
+      this.resources = [];
+    }
+    return this.resources;
+  }
+  async callTool(toolName, arguments_, timeout = 12e4) {
+    return this.rpc("tools/call", { name: toolName, arguments: arguments_ }, timeout);
+  }
+  async ping() {
+    try {
+      await this.rpc("ping", {}, 1e4);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async callToolWithReconnect(toolName, arguments_, timeout = 12e4) {
+    try {
+      if (!this.connected) throw new Error("Not connected");
+      return await this.callTool(toolName, arguments_, timeout);
+    } catch (e) {
+      console.warn(`[MCP] Connection issue during call_tool(${toolName}), reconnecting:`, e);
+      try {
+        await this.reconnect();
+        return await this.callTool(toolName, arguments_, timeout);
+      } catch (retryErr) {
+        throw new Error(`Reconnect failed: ${retryErr}`, { cause: e });
+      }
+    }
+  }
+  async reconnect() {
+    const url = this.url;
+    let headers = {};
+    if (this.transport instanceof HttpTransport) {
+      headers = this.transport.getBaseHeaders();
+      delete headers["Content-Type"];
+      delete headers.Accept;
+    } else if (this.transport instanceof SseTransport || this.transport instanceof WsTransport) {
+      headers = { ...this.transport.headers };
+    }
+    try {
+      await this.close();
+    } catch {
+    }
+    this.id = 0;
+    this.pending.clear();
+    this.transport = _MCPClient.createTransport(url, headers);
+    await this.connect();
+    await this.listTools();
+  }
+};
+var MCPRegistry = class {
+  clients = /* @__PURE__ */ new Map();
+  healthTask = null;
+  async connect(name, url, headers = null, token = null) {
+    this.clients.delete(name);
+    const hdrs = { ...headers ?? {} };
+    if (token) hdrs.Authorization = hdrs.Authorization ?? `Bearer ${token}`;
+    const client = new MCPClient(url, hdrs);
+    await client.connect();
+    await client.listTools();
+    this.clients.set(name, client);
+    if (!this.healthTask) {
+      this.healthTask = setInterval(() => void this.healthLoopOnce(), 6e4);
+    }
+  }
+  async healthLoopOnce() {
+    for (const [name, client] of [...this.clients.entries()]) {
+      if (!client.connected) continue;
+      try {
+        const alive = await client.ping();
+        if (!alive) await client.reconnect();
+      } catch (e) {
+        console.warn(`[MCP Health] ${name} health check error:`, e);
+        try {
+          await client.reconnect();
+        } catch {
+          this.clients.delete(name);
+        }
+      }
+    }
+  }
+  get(name) {
+    const c = this.clients.get(name);
+    if (!c) throw new Error(`Unknown MCP server: '${name}'`);
+    return c;
+  }
+  has(name) {
+    return this.clients.has(name);
+  }
+  async disconnect(name) {
+    const c = this.clients.get(name);
+    this.clients.delete(name);
+    if (c) {
+      try {
+        await c.close();
+      } catch {
+      }
+    }
+  }
+  async shutdown() {
+    if (this.healthTask) {
+      clearInterval(this.healthTask);
+      this.healthTask = null;
+    }
+    for (const name of [...this.clients.keys()]) await this.disconnect(name);
+  }
+};
+var PromptevMCP = class {
+  clients = new MCPRegistry();
+  async addServer(name, url, opts = {}) {
+    await this.clients.connect(name, url, opts.headers ?? null, opts.token ?? null);
+  }
+  async shutdown() {
+    await this.clients.shutdown();
+  }
+};
+
+// src/tools/governance.ts
+init_errors();
+
+// src/hooks.ts
+var log = {
+  warn: (...args) => console.warn("[context-engine]", ...args),
+  error: (...args) => console.error("[context-engine]", ...args)
+};
+function emitUsage(hooks, event) {
+  if (!hooks?.onUsage) return;
+  try {
+    hooks.onUsage(event);
+  } catch {
+    log.warn("onUsage callback raised; swallowing");
+  }
+}
+function emitError(hooks, exc, ctx) {
+  log.error("context_engine error:", exc, "| ctx=", ctx);
+  if (!hooks?.onError) return;
+  try {
+    hooks.onError(exc, ctx);
+  } catch {
+    log.warn("onError callback raised; swallowing");
+  }
+}
+function emitToolCall(hooks, event) {
+  if (!hooks?.onToolCall) return;
+  try {
+    hooks.onToolCall(event);
+  } catch {
+    log.warn("onToolCall callback raised; swallowing");
+  }
+}
+function encryptDict(data, key) {
+  const nonce = crypto.randomBytes(12);
+  const cipher = crypto.createCipheriv("aes-256-gcm", key, nonce);
+  const plaintext = Buffer.from(JSON.stringify(data), "utf8");
+  const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return Buffer.concat([nonce, ciphertext, tag]).toString("base64");
+}
+function decryptDict(token, key) {
+  const raw = Buffer.from(token, "base64");
+  const nonce = raw.subarray(0, 12);
+  const tag = raw.subarray(raw.length - 16);
+  const ciphertext = raw.subarray(12, raw.length - 16);
+  const decipher = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+  decipher.setAuthTag(tag);
+  const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+  return JSON.parse(plaintext.toString("utf8"));
+}
+function getSecretKey(config) {
+  const secretKey = config.secretKey;
+  if (!secretKey) {
+    throw new Error(
+      "ContextEngineConfig.secretKey (env CE_SECRET_KEY) is not configured \u2014 a base64url-encoded 32-byte AES key is required to encrypt/decrypt tool configs that hold secrets."
+    );
+  }
+  return Buffer.from(secretKey, "base64url");
+}
+function hmacSha256Hex(key, value) {
+  const k = typeof key === "string" ? Buffer.from(key) : key;
+  return crypto.createHmac("sha256", k).update(value, "utf8").digest("hex");
+}
+
+// src/redaction.ts
+var EMAIL_RE = /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g;
+var PHONE_RE = /\+\d[\d\s-]{7,17}\d/g;
+var SSN_RE = /(?<!\d)\d{3}-\d{2}-\d{4}(?!\d)/g;
+var CARD_RE = /(?<!\d)(?:\d[ -]?){12,18}\d(?!\d)/g;
+var IBAN_RE = /(?<![A-Za-z0-9])[A-Z]{2}\d{2}[A-Z0-9]{10,30}(?![A-Za-z0-9])/g;
+var API_KEY_ALNUM = "A-Za-z0-9_\\-+/=";
+var API_KEY_PREFIX_RE = new RegExp(
+  `(?<![${API_KEY_ALNUM}])(?:(?:AKIA|ASIA)[0-9A-Z]{16}|sk-[A-Za-z0-9]{20,}|gh[opsu]_[A-Za-z0-9]{20,}|xox[baprs]-[A-Za-z0-9\\-]{10,}|AIza[0-9A-Za-z_\\-]{35})(?![${API_KEY_ALNUM}])`,
+  "g"
+);
+var API_KEY_GENERIC_RE = new RegExp(
+  `(?<![${API_KEY_ALNUM}])[${API_KEY_ALNUM}]{24,}(?![${API_KEY_ALNUM}])`,
+  "g"
+);
+var UUID_RE2 = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+function spansFrom(re, text) {
+  const out = [];
+  re.lastIndex = 0;
+  let m = re.exec(text);
+  while (m !== null) {
+    out.push([m.index, m.index + m[0].length]);
+    if (m[0].length === 0) re.lastIndex++;
+    m = re.exec(text);
+  }
+  return out;
+}
+function luhnOk(digits) {
+  let total = 0;
+  const rev = [...digits].reverse();
+  for (let i = 0; i < rev.length; i++) {
+    let d = Number(rev[i]);
+    if (i % 2 === 1) {
+      d *= 2;
+      if (d > 9) d -= 9;
+    }
+    total += d;
+  }
+  return total % 10 === 0;
+}
+function detectCreditCard(text) {
+  const spans = [];
+  for (const [start, end] of spansFrom(CARD_RE, text)) {
+    const digits = text.slice(start, end).replace(/[ -]/g, "");
+    if (digits.length >= 13 && digits.length <= 19 && luhnOk(digits)) {
+      spans.push([start, end]);
+    }
+  }
+  return spans;
+}
+function looksLikeGenericSecret(token) {
+  if (UUID_RE2.test(token)) return false;
+  let hasUpper = false;
+  let hasLower = false;
+  let hasDigit = false;
+  for (const c of token) {
+    if (c >= "A" && c <= "Z") hasUpper = true;
+    else if (c >= "a" && c <= "z") hasLower = true;
+    else if (c >= "0" && c <= "9") hasDigit = true;
+  }
+  return hasUpper && hasLower && hasDigit;
+}
+function detectApiKey(text) {
+  const spans = spansFrom(API_KEY_PREFIX_RE, text);
+  for (const [start, end] of spansFrom(API_KEY_GENERIC_RE, text)) {
+    if (spans.some(([s, e]) => start < e && s < end)) continue;
+    if (looksLikeGenericSecret(text.slice(start, end))) spans.push([start, end]);
+  }
+  return spans;
+}
+var BUILTIN = {
+  email: (t) => spansFrom(EMAIL_RE, t),
+  phone: (t) => spansFrom(PHONE_RE, t),
+  ssn: (t) => spansFrom(SSN_RE, t),
+  credit_card: detectCreditCard,
+  iban: (t) => spansFrom(IBAN_RE, t),
+  api_key: detectApiKey
+};
+function detectBuiltin(name, text) {
+  const detector = BUILTIN[name];
+  if (!detector) throw new Error(`unknown built-in detector: ${name}`);
+  if (!text) return [];
+  return detector(text).sort((a, b) => a[0] - b[0]);
+}
+function ruleApplies(rule, opts) {
+  if (rule.applyAt !== "both" && rule.applyAt !== opts.phase) return false;
+  if (!rule.unless.length) return true;
+  if (opts.principals === null) return false;
+  const held = new Set(opts.principals);
+  return !rule.unless.some((p) => held.has(p));
+}
+function spansForRule(rule, text, policy) {
+  if (rule.pattern !== null) {
+    const re = rule.patternRe() ?? new RegExp(rule.pattern, "g");
+    return spansFrom(re, text);
+  }
+  if (rule.detector !== null) {
+    const custom = policy.customDetectors[rule.detector];
+    if (custom) return [...custom(text)];
+    return detectBuiltin(rule.detector, text);
+  }
+  return [];
+}
+var HASH_TOKEN_CHARS = 16;
+function hashToken(value, secretKey) {
+  const key = Buffer.isBuffer(secretKey) ? secretKey : Buffer.from(String(secretKey ?? ""));
+  return hmacSha256Hex(key, value).slice(0, HASH_TOKEN_CHARS);
+}
+function applyRedaction(text, policy, opts) {
+  if (!text || policy.isEmpty()) return [text, {}];
+  const principals = opts.principals ?? null;
+  const collected = [];
+  const fired = [];
+  const failed = [];
+  for (const rule of policy.rules) {
+    if (!ruleApplies(rule, { phase: opts.phase, principals })) continue;
+    if (rule.action === "hash" && !opts.secretKey) {
+      throw new Error(
+        `rule '${rule.name}': action='hash' requires a non-empty secretKey (an unkeyed HMAC is a reversible pseudonym, not a redaction)`
+      );
+    }
+    try {
+      const raw = spansForRule(rule, text, policy);
+      const ruleSpans = [];
+      let invalid = false;
+      for (const item of raw) {
+        const start = item?.[0];
+        const end = item?.[1];
+        if (typeof start !== "number" || typeof end !== "number") {
+          invalid = true;
+          continue;
+        }
+        if (!(start >= 0 && start < end && end <= text.length)) {
+          invalid = true;
+          continue;
+        }
+        ruleSpans.push([start, end]);
+      }
+      if (invalid) failed.push(rule.name);
+      for (const [s, e] of ruleSpans) collected.push([s, e, rule]);
+    } catch (exc) {
+      failed.push(rule.name);
+      if (opts.hooks) emitError(opts.hooks, exc, { stage: "redaction", rule: rule.name });
+    }
+  }
+  if (!collected.length) {
+    if (failed.length) return [text, { rules_fired: [], spans: 0, rules_failed: failed }];
+    return [text, {}];
+  }
+  collected.sort((a, b) => a[0] - b[0] || b[1] - b[0] - (a[1] - a[0]));
+  const merged = [];
+  for (const [start, end, rule] of collected) {
+    const last = merged[merged.length - 1];
+    if (last && start < last[1]) {
+      if (end > last[1]) last[1] = end;
+      continue;
+    }
+    merged.push([start, end, rule]);
+  }
+  const out = [];
+  let cursor = 0;
+  for (const [start, end, rule] of merged) {
+    out.push(text.slice(cursor, start));
+    const original = text.slice(start, end);
+    if (rule.action === "mask") out.push(rule.effectivePlaceholder());
+    else if (rule.action === "hash") {
+      out.push(`[${rule.name.toUpperCase()}:${hashToken(original, opts.secretKey)}]`);
+    }
+    if (!fired.includes(rule.name)) fired.push(rule.name);
+    cursor = end;
+  }
+  out.push(text.slice(cursor));
+  const note = { rules_fired: fired, spans: merged.length };
+  if (failed.length) note.rules_failed = failed;
+  return [out.join(""), note];
+}
+var MAX_OUTPUT_SIZE = 5e4;
+var MAX_ERROR_MESSAGE_SIZE = 2e3;
+var ToolCallTimer = class {
+  started = null;
+  ended = null;
+  start() {
+    this.started = Date.now();
+    return this;
+  }
+  stop() {
+    this.ended = Date.now();
+    return this;
+  }
+  get durationMs() {
+    if (this.started == null || this.ended == null) return null;
+    return this.ended - this.started;
+  }
+};
+function sanitize(obj) {
+  if (obj == null) return obj;
+  try {
+    return JSON.parse(JSON.stringify(obj, (_k, v) => typeof v === "bigint" ? String(v) : v));
+  } catch {
+    return { _raw: String(obj) };
+  }
+}
+function truncateOutput(outputResult) {
+  if (outputResult == null) return [null, false];
+  let serialized;
+  try {
+    serialized = JSON.stringify(outputResult);
+  } catch {
+    serialized = JSON.stringify(String(outputResult));
+  }
+  if (serialized.length <= MAX_OUTPUT_SIZE) {
+    try {
+      return [JSON.parse(serialized), false];
+    } catch {
+      return [outputResult, false];
+    }
+  }
+  return [{ _truncated: serialized.slice(0, MAX_OUTPUT_SIZE), _original_size: serialized.length }, true];
+}
+function errorMessage(error) {
+  if (error == null) return null;
+  const text = error instanceof Error ? error.message : String(error);
+  return text.slice(0, MAX_ERROR_MESSAGE_SIZE);
+}
+async function logToolCall(engine, row) {
+  const event = {
+    tool_id: row.toolId != null ? String(row.toolId) : null,
+    tool_name: row.toolName,
+    kind: row.kind,
+    actor_type: row.actorType ?? null,
+    actor_id: row.actorId != null ? String(row.actorId) : null,
+    source: row.source ?? null,
+    input_args: row.inputArgs ?? {},
+    output_result: row.outputResult,
+    success: row.success ?? null,
+    error: row.error != null ? String(row.error) : null,
+    duration_ms: row.durationMs ?? null,
+    units: row.units ?? null,
+    approval_id: row.approvalId ?? null
+  };
+  try {
+    emitToolCall(engine.hooks, event);
+  } catch {
+  }
+  try {
+    const [stored, truncated] = truncateOutput(row.outputResult);
+    const args = sanitize(row.inputArgs ?? {}) ?? {};
+    await engine.pool.query(
+      `INSERT INTO context_engine_tool_calls
+        (id, tool_id, tool_name, kind, actor_type, actor_id, source, input_args, output_result,
+         output_truncated, success, error_message, duration_ms, units, approval_id)
+       VALUES ($1,$2,$3,$4,$5,$6,$7,$8::jsonb,$9::jsonb,$10,$11,$12,$13,$14,$15)`,
+      [
+        crypto.randomUUID(),
+        row.toolId ?? null,
+        row.toolName,
+        row.kind,
+        row.actorType ?? null,
+        row.actorId != null ? String(row.actorId) : null,
+        row.source ?? "api",
+        JSON.stringify(args),
+        JSON.stringify(stored),
+        truncated,
+        row.success ?? null,
+        errorMessage(row.error),
+        row.durationMs ?? null,
+        row.units ?? 1,
+        row.approvalId ?? null
+      ]
+    );
+  } catch {
+  }
+}
+
+// src/tools/governance.ts
+init_db();
+
+// src/tools/executors/http.ts
+var TIMEOUT_MS = 3e4;
+var SENSITIVE_RESPONSE_HEADERS = /* @__PURE__ */ new Set([
+  "set-cookie",
+  "set-cookie2",
+  "authorization",
+  "proxy-authenticate",
+  "www-authenticate"
+]);
+function percentEncode(value) {
+  return encodeURIComponent(value).replace(
+    /[!'()*]/g,
+    (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`
+  );
+}
+function extract(schema, args) {
+  if (!schema) return {};
+  const properties = schema.properties ?? {};
+  const required = schema.required ?? [];
+  const values = {};
+  for (const key of Object.keys(properties)) {
+    const value = args[key];
+    if (required.includes(key) && (value === void 0 || value === null || value === "")) {
+      throw new Error(`Missing required LLM parameter: ${key}`);
+    }
+    if (value !== void 0 && value !== null) values[key] = value;
+  }
+  return values;
+}
+function withQuery(url, params) {
+  const usp = new URLSearchParams();
+  for (const [k, v] of Object.entries(params)) {
+    if (v === void 0 || v === null) continue;
+    usp.set(k, String(v));
+  }
+  const q = usp.toString();
+  if (!q) return url;
+  return url.includes("?") ? `${url}&${q}` : `${url}?${q}`;
+}
+async function defaultRequest(init) {
+  let url = init.url;
+  if (init.params) url = withQuery(url, init.params);
+  const headers = { ...init.headers ?? {} };
+  let body;
+  if (init.json !== void 0) {
+    headers["Content-Type"] = headers["Content-Type"] ?? headers["content-type"] ?? "application/json";
+    body = JSON.stringify(init.json);
+  } else if (init.content !== void 0) {
+    body = init.content;
+  }
+  const resp = await fetch(url, {
+    method: init.method,
+    headers,
+    body,
+    redirect: "follow",
+    signal: AbortSignal.timeout(TIMEOUT_MS)
+  });
+  const respHeaders = {};
+  resp.headers.forEach((v, k) => {
+    respHeaders[k] = v;
+  });
+  const text = await resp.text();
+  return {
+    status: resp.status,
+    headers: respHeaders,
+    async json() {
+      return JSON.parse(text);
+    },
+    async text() {
+      return text;
+    }
+  };
+}
+async function executeHttp(config, args, opts = {}) {
+  const method = String(config.method ?? "GET").toUpperCase();
+  let url = config.url;
+  const headers = { ...config.headers ?? {} };
+  const staticParams = { ...config.parameters ?? {} };
+  const body = config.body;
+  const runtimeArgs = args ?? {};
+  const queryValues = extract(config.llmQueryParameters, runtimeArgs);
+  const bodyValues = extract(config.llmParameters, runtimeArgs);
+  if (url?.includes("{{")) {
+    for (const source of [queryValues, bodyValues]) {
+      for (const key of Object.keys(source)) {
+        const placeholder = `{{${key}}}`;
+        if (url.includes(placeholder)) {
+          url = url.replaceAll(placeholder, percentEncode(String(source[key])));
+          delete source[key];
+        }
+      }
+    }
+  }
+  const requestInit = {
+    method,
+    url: url ?? "",
+    headers
+  };
+  if (method === "GET" || method === "DELETE") {
+    const query = { ...staticParams, ...queryValues, ...bodyValues };
+    if (Object.keys(query).length) requestInit.params = query;
+  } else {
+    const query = { ...staticParams, ...queryValues };
+    if (Object.keys(query).length) requestInit.params = query;
+    let jsonBody = {};
+    if (body !== void 0 && body !== null) {
+      if (typeof body === "object" && !Array.isArray(body)) {
+        jsonBody = { ...body };
+      } else if (typeof body === "string") {
+        try {
+          const parsed = JSON.parse(body);
+          if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            jsonBody = parsed;
+          }
+        } catch {
+        }
+      }
+    }
+    Object.assign(jsonBody, bodyValues);
+    if (Object.keys(jsonBody).length) {
+      requestInit.json = jsonBody;
+    } else if (body !== void 0 && body !== null) {
+      const contentType2 = headers["Content-Type"] ?? headers["content-type"] ?? "";
+      if (typeof body === "string" && !contentType2.includes("application/json")) {
+        requestInit.content = body;
+      }
+    }
+  }
+  const client = opts.client;
+  const resp = client ? await client.request(requestInit) : await defaultRequest(requestInit);
+  const contentType = resp.headers["content-type"] ?? resp.headers["Content-Type"] ?? "";
+  let data;
+  try {
+    data = contentType.includes("application/json") ? await resp.json() : await resp.text();
+  } catch {
+    data = await resp.text();
+  }
+  const safeHeaders = {};
+  for (const [k, v] of Object.entries(resp.headers)) {
+    if (!SENSITIVE_RESPONSE_HEADERS.has(k.toLowerCase())) safeHeaders[k] = v;
+  }
+  return {
+    status_code: resp.status,
+    headers: safeHeaders,
+    data
+  };
+}
+
+// src/tools/registry.ts
+function httpParamsSchema(config) {
+  const properties = {};
+  const required = [];
+  for (const key of ["llmParameters", "llmQueryParameters"]) {
+    const src = config[key] ?? {};
+    if (!src || typeof src !== "object") continue;
+    Object.assign(properties, src.properties ?? {});
+    const req = src.required;
+    if (Array.isArray(req)) required.push(...req.map(String));
+  }
+  return { type: "object", properties, required };
+}
+function expandMcpTools(tc) {
+  const config = tc.config ?? {};
+  const discovered = config.discovered_tools ?? [];
+  if (!discovered.length) {
+    return [
+      {
+        id: tc.id ?? null,
+        kind: "mcp",
+        callName: `mcp_${tc.name}`,
+        displayName: tc.name,
+        description: tc.description || "MCP tool",
+        paramsSchema: { type: "object", properties: {}, required: [] },
+        requiresApproval: tc.requiresApproval,
+        approvalPolicy: tc.approvalPolicy,
+        sourceId: tc.sourceId,
+        acl: tc.acl,
+        raw: config
+      }
+    ];
+  }
+  const tools = [];
+  for (const dt of discovered) {
+    if (dt.enabled === false) continue;
+    const name = String(dt.name ?? "unknown");
+    const schema = dt.inputSchema ?? dt.input_schema ?? {
+      type: "object",
+      properties: {},
+      required: []
+    };
+    const toolApproval = dt.requires_approval;
+    const toolApprovalPolicy = dt.approval_policy;
+    tools.push({
+      id: tc.id ?? null,
+      kind: "mcp",
+      callName: `mcp_${name}`,
+      displayName: name,
+      description: String(dt.description ?? `MCP tool: ${name}`),
+      paramsSchema: schema,
+      requiresApproval: toolApproval !== void 0 ? Boolean(toolApproval) : tc.requiresApproval,
+      approvalPolicy: toolApprovalPolicy ?? tc.approvalPolicy,
+      sourceId: tc.sourceId,
+      acl: tc.acl,
+      raw: { ...config, tool_name: name }
+    });
+  }
+  return tools;
+}
+function canonicalFromConfig(tc) {
+  if (tc.kind === "http") {
+    return [
+      {
+        id: tc.id ?? null,
+        kind: "http",
+        callName: `http_${tc.name}`,
+        displayName: tc.name,
+        description: tc.description || `Execute HTTP request: ${tc.name}`,
+        paramsSchema: httpParamsSchema(tc.config ?? {}),
+        requiresApproval: tc.requiresApproval,
+        approvalPolicy: tc.approvalPolicy,
+        sourceId: tc.sourceId,
+        acl: tc.acl,
+        raw: tc.config ?? {}
+      }
+    ];
+  }
+  if (tc.kind === "db") {
+    return [
+      {
+        id: tc.id ?? null,
+        kind: "db",
+        callName: `db_${tc.name}`,
+        displayName: tc.name,
+        description: tc.description || `Query database: ${tc.name}`,
+        paramsSchema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "Either 'describe:table1,table2' to get column details, or a SQL query to execute"
+            }
+          },
+          required: ["query"]
+        },
+        requiresApproval: tc.requiresApproval,
+        approvalPolicy: tc.approvalPolicy,
+        sourceId: tc.sourceId,
+        acl: tc.acl,
+        raw: tc.config ?? {}
+      }
+    ];
+  }
+  if (tc.kind === "mcp") return expandMcpTools(tc);
+  throw new Error(
+    `canonicalFromConfig does not support kind=${JSON.stringify(tc.kind)}; function tools have no serializable config \u2014 build them with functionTool(fn) instead`
+  );
+}
+function findTool(tools, callName) {
+  return tools.find((t) => t.callName === callName);
+}
+
+// src/tools/governance.ts
+var RESULT_MAX_CHARS = 8e3;
+var RESULT_MAX_ROWS = 100;
+var UPDATABLE_COLUMNS = /* @__PURE__ */ new Set([
+  "name",
+  "kind",
+  "description",
+  "sourceId",
+  "source_id",
+  "acl",
+  "requiresApproval",
+  "requires_approval",
+  "approvalPolicy",
+  "approval_policy",
+  "enabled"
+]);
+function toolVisible(ct, principals) {
+  return aclVisible(ct.acl, principals);
+}
+function stripUnderscoreArgs(args) {
+  const out = {};
+  for (const [k, v] of Object.entries(args ?? {})) {
+    if (!String(k).startsWith("_")) out[k] = v;
+  }
+  return out;
+}
+function shapeResult(result, opts = {}) {
+  const maxChars = opts.maxChars ?? RESULT_MAX_CHARS;
+  const maxRows = opts.maxRows ?? RESULT_MAX_ROWS;
+  let truncated = false;
+  let shaped = result;
+  if (result && typeof result === "object" && Array.isArray(result.rows) && result.rows.length > maxRows) {
+    const rows = result.rows;
+    const kept = rows.slice(0, maxRows);
+    shaped = {
+      ...result,
+      rows: kept,
+      _result_shaping: { rows_returned: kept.length, rows_omitted: rows.length - kept.length }
+    };
+    truncated = true;
+  }
+  let serialized;
+  try {
+    serialized = JSON.stringify(shaped);
+  } catch {
+    serialized = JSON.stringify(String(shaped));
+  }
+  if (serialized.length > maxChars) {
+    return [
+      {
+        _truncated: serialized.slice(0, maxChars),
+        _original_size: serialized.length,
+        _note: "tool result exceeded the context budget and was truncated"
+      },
+      true
+    ];
+  }
+  return [shaped, truncated];
+}
+function redactToolResult(result, policy, opts) {
+  if (policy.isEmpty()) return [result, {}];
+  const fired = [];
+  const failed = [];
+  let total = 0;
+  const walk = (node) => {
+    if (typeof node === "string") {
+      const [text, note2] = applyRedaction(node, policy, {
+        phase: "output",
+        principals: opts.principals ?? null,
+        secretKey: opts.secretKey,
+        hooks: opts.hooks
+      });
+      if (note2 && Object.keys(note2).length) {
+        total += note2.spans ?? 0;
+        for (const name of note2.rules_fired ?? []) {
+          if (!fired.includes(name)) fired.push(name);
+        }
+        for (const name of note2.rules_failed ?? []) {
+          if (!failed.includes(name)) failed.push(name);
+        }
+      }
+      return text;
+    }
+    if (node && typeof node === "object") {
+      if (Array.isArray(node)) return node.map(walk);
+      const out = {};
+      for (const [k, v] of Object.entries(node)) out[k] = walk(v);
+      return out;
+    }
+    return node;
+  };
+  const redacted = walk(result);
+  if (!fired.length && !failed.length) return [redacted, {}];
+  const note = { rules_fired: fired, spans: total };
+  if (failed.length) note.rules_failed = failed;
+  return [redacted, note];
+}
+function rowToToolConfig(row, engine) {
+  let config = {};
+  if (row.config_encrypted) {
+    config = decryptDict(String(row.config_encrypted), getSecretKey(engine.config));
+  }
+  return new ToolConfig({
+    id: String(row.id),
+    name: String(row.name),
+    kind: row.kind,
+    description: String(row.description ?? ""),
+    config,
+    sourceId: row.source_id ?? null,
+    acl: row.acl != null ? [...row.acl] : null,
+    requiresApproval: Boolean(row.requires_approval),
+    approvalPolicy: row.approval_policy ?? {},
+    enabled: Boolean(row.enabled)
+  });
+}
+async function loadPersistedCanonicals(engine, sourceId) {
+  const params = [];
+  let sql = `SELECT * FROM context_engine_tools WHERE enabled IS TRUE`;
+  if (sourceId != null) {
+    params.push(sourceId);
+    sql += ` AND source_id = $1`;
+  }
+  const result = await engine.pool.query(sql, params);
+  const canonicals = [];
+  for (const row of result.rows) {
+    canonicals.push(...canonicalFromConfig(rowToToolConfig(row, engine)));
+  }
+  return canonicals;
+}
+async function mergedTools(engine, sourceId) {
+  const persisted = await loadPersistedCanonicals(engine, sourceId);
+  const functions = Object.values(engine._functionTools ?? {});
+  return [...persisted, ...functions];
+}
+async function registerTool(engine, tc) {
+  canonicalFromConfig(tc);
+  const config = tc.config ?? {};
+  const configEncrypted = Object.keys(config).length ? encryptDict(config, getSecretKey(engine.config)) : null;
+  const id = crypto.randomUUID();
+  await engine.pool.query(
+    `INSERT INTO context_engine_tools
+       (id, name, kind, description, source_id, acl, config_encrypted,
+        requires_approval, approval_policy, enabled)
+     VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9::jsonb, $10)`,
+    [
+      id,
+      tc.name,
+      tc.kind,
+      tc.description || "",
+      tc.sourceId,
+      tc.acl,
+      configEncrypted,
+      tc.requiresApproval,
+      JSON.stringify(tc.approvalPolicy ?? {}),
+      tc.enabled
+    ]
+  );
+  return id;
+}
+async function updateTool(engine, id, opts) {
+  const { principals = null, ...fields } = opts;
+  const existing = await engine.pool.query(`SELECT * FROM context_engine_tools WHERE id = $1`, [id]);
+  const row = existing.rows[0];
+  if (!row || !aclVisible(row.acl != null ? [...row.acl] : null, principals)) {
+    throw new EngineActionError(`tool not found: ${id}`);
+  }
+  const sets = [];
+  const params = [];
+  let i = 1;
+  for (const [key, value] of Object.entries(fields)) {
+    if (key === "config") {
+      sets.push(`config_encrypted = $${i++}`);
+      params.push(value ? encryptDict(value, getSecretKey(engine.config)) : null);
+    } else if (UPDATABLE_COLUMNS.has(key)) {
+      const col = key === "sourceId" ? "source_id" : key === "requiresApproval" ? "requires_approval" : key === "approvalPolicy" ? "approval_policy" : key;
+      sets.push(`${col} = $${i++}`);
+      params.push(col === "approval_policy" ? JSON.stringify(value ?? {}) : value);
+    }
+  }
+  sets.push(`updated_at = now()`);
+  params.push(id);
+  const updated = await engine.pool.query(
+    `UPDATE context_engine_tools SET ${sets.join(", ")} WHERE id = $${i} RETURNING *`,
+    params
+  );
+  return rowToToolConfig(updated.rows[0], engine);
+}
+async function deleteTool(engine, id, opts = {}) {
+  const existing = await engine.pool.query(`SELECT * FROM context_engine_tools WHERE id = $1`, [id]);
+  const row = existing.rows[0];
+  if (!row || !aclVisible(row.acl != null ? [...row.acl] : null, opts.principals ?? null)) {
+    throw new EngineActionError(`tool not found: ${id}`);
+  }
+  await engine.pool.query(`DELETE FROM context_engine_tools WHERE id = $1`, [id]);
+}
+var PROBE_AUTH = [
+  "authentication failed",
+  "pg_hba",
+  "permission denied",
+  "access denied",
+  "password",
+  "unauthorized",
+  "forbidden",
+  "401",
+  "403",
+  "invalid credentials"
+];
+var PROBE_UNREACHABLE = [
+  "connection refused",
+  "could not connect",
+  "name or service not known",
+  "nodename nor servname",
+  "no route to host",
+  "network is unreachable",
+  "temporary failure in name resolution",
+  "getaddrinfo",
+  "connection reset",
+  "fetch failed",
+  "econnrefused",
+  "enotfound"
+];
+var PROBE_TIMEOUT = ["timed out", "timeout", "aborted"];
+var PROBE_MISCONFIGURED = [
+  "does not exist",
+  "invalid",
+  "unknown database",
+  "syntax error",
+  "no such",
+  "missing",
+  "not supported",
+  "unsupported"
+];
+function classifyProbeError(exc) {
+  if (exc instanceof DOMException && exc.name === "TimeoutError") return "timeout";
+  const name = exc instanceof Error ? exc.name : "";
+  if (name.includes("Timeout")) return "timeout";
+  if (["ConnectError", "ConnectionError", "NetworkError", "TypeError"].some((t) => name.includes(t))) {
+    if (name === "TypeError" && !String(exc).toLowerCase().includes("fetch")) ; else if (name !== "TypeError") return "unreachable";
+  }
+  if (["Auth", "Permission", "Forbidden", "Unauthorized"].some((t) => name.includes(t))) return "auth_failed";
+  const text = String(exc).toLowerCase();
+  if (PROBE_TIMEOUT.some((t) => text.includes(t))) return "timeout";
+  if (PROBE_AUTH.some((t) => text.includes(t))) return "auth_failed";
+  if (PROBE_UNREACHABLE.some((t) => text.includes(t))) return "unreachable";
+  if (PROBE_MISCONFIGURED.some((t) => text.includes(t))) return "misconfigured";
+  return "error";
+}
+function probeFailure(exc, kind) {
+  const category = classifyProbeError(exc);
+  console.warn(`test_tool(kind=${kind}) failed:`, exc, "->", category);
+  return { ok: false, error: category };
+}
+async function testTool(_engine, tc) {
+  const kind = tc.kind;
+  const config = tc.config ?? {};
+  if (kind === "http") {
+    const url = config.url;
+    if (!url) return { ok: false, error: "http config missing 'url'" };
+    try {
+      const resp = await fetch(url, {
+        method: "HEAD",
+        headers: config.headers ?? {},
+        redirect: "follow",
+        signal: AbortSignal.timeout(1e4)
+      });
+      return { ok: resp.status < 500, status_code: resp.status };
+    } catch (exc) {
+      return probeFailure(exc, "http");
+    }
+  }
+  if (kind === "db") {
+    try {
+      const { testConnection: testConnection2 } = await Promise.resolve().then(() => (init_db(), db_exports));
+      const result = await testConnection2(config);
+      return { ok: Boolean(result.success ?? result.ok), ...result };
+    } catch (exc) {
+      return probeFailure(exc, "db");
+    }
+  }
+  if (kind === "mcp") {
+    const url = config.url;
+    if (!url) return { ok: false, error: "mcp config missing 'url'" };
+    const token = config.oauth_token ?? config.bearer ?? config.access_token;
+    const mcp = new PromptevMCP();
+    try {
+      await mcp.addServer(tc.name, url, { token: token ?? null });
+      const client = mcp.clients.get(tc.name);
+      return { ok: true, tools: client.tools.map((t) => t.name) };
+    } catch (exc) {
+      return probeFailure(exc, "mcp");
+    } finally {
+      await mcp.shutdown();
+    }
+  }
+  return { ok: false, error: `test_tool does not support kind=${JSON.stringify(kind)}` };
+}
+async function findAndClaimApproved(engine, toolName, args, sourceId) {
+  const claimedAt = /* @__PURE__ */ new Date();
+  const candidates = await engine.pool.query(
+    `SELECT * FROM context_engine_tool_approvals WHERE tool_name = $1 AND status = 'approved'`,
+    [toolName]
+  );
+  for (const row of candidates.rows) {
+    if ((row.source_id ?? null) !== (sourceId ?? null)) continue;
+    const frozen = row.tool_args_frozen ?? {};
+    if (JSON.stringify(frozen) !== JSON.stringify(args)) continue;
+    const result = await engine.pool.query(
+      `UPDATE context_engine_tool_approvals
+       SET status = 'executed', resolved_at = $1
+       WHERE id = $2 AND status = 'approved'
+       RETURNING id`,
+      [claimedAt, row.id]
+    );
+    if (result.rowCount === 1) return String(row.id);
+  }
+  return null;
+}
+async function dispatchMcp(ct, config, args) {
+  const url = config.url;
+  if (!url) throw new EngineActionError(`mcp tool ${ct.callName} config missing 'url'`);
+  const headers = { ...config.headers ?? {} };
+  const token = config.oauth_token ?? config.bearer ?? config.access_token;
+  const apiKey = config.api_key;
+  if (token) headers.Authorization = `Bearer ${token}`;
+  else if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+  const toolName = String(ct.raw?.tool_name ?? ct.displayName);
+  const mcp = new PromptevMCP();
+  try {
+    await mcp.addServer(ct.callName, url, { headers: Object.keys(headers).length ? headers : null });
+    const client = mcp.clients.get(ct.callName);
+    return await client.callToolWithReconnect(toolName, args);
+  } finally {
+    await mcp.shutdown();
+  }
+}
+async function dispatch(engine, ct, config, args) {
+  if (ct.kind === "http") {
+    return executeHttp(config, args, { client: engine._toolHttpClient ?? null });
+  }
+  if (ct.kind === "db") {
+    const query = String(args.query ?? "");
+    if (query.trim().toLowerCase().startsWith("describe:")) {
+      const tables = query.slice(query.indexOf(":") + 1).split(",").map((t) => t.trim()).filter(Boolean);
+      const schemaText = await getSchemaText(config, tables.length ? tables : null);
+      return { success: true, schema: schemaText };
+    }
+    const result = await executeDb(config, query);
+    if (result && typeof result === "object" && result.success === false) {
+      throw new EngineActionError(String(result.error || "database query failed"));
+    }
+    return result;
+  }
+  if (ct.kind === "mcp") return dispatchMcp(ct, config, args);
+  if (ct.kind === "function") {
+    const fn = ct.raw?.callable;
+    if (!fn) throw new EngineActionError(`function tool ${ct.callName} has no callable`);
+    return await fn(...namedArgs(fn, args));
+  }
+  throw new EngineActionError(`unsupported tool kind: ${JSON.stringify(ct.kind)}`);
+}
+function namedArgs(fn, args) {
+  const src = Function.prototype.toString.call(fn);
+  const match = src.match(/\(([^)]*)\)/);
+  const names = (match?.[1] ?? "").split(",").map((p) => p.trim().split(/\s*=/)[0]?.trim()).filter(Boolean);
+  if (!names.length) return Object.values(args);
+  return names.map((n) => args[n]);
+}
+async function decryptCtConfig(engine, toolId) {
+  const result = await engine.pool.query(`SELECT config_encrypted FROM context_engine_tools WHERE id = $1`, [
+    toolId
+  ]);
+  const row = result.rows[0];
+  if (!row?.config_encrypted) return {};
+  return decryptDict(String(row.config_encrypted), getSecretKey(engine.config));
+}
+async function executeTool(engine, callName, args, opts = {}) {
+  const runtimeArgs = args ?? {};
+  const ct = findTool(await mergedTools(engine, opts.sourceId ?? null), callName);
+  if (!ct) throw new EngineActionError(`tool not found: ${callName}`);
+  if (!toolVisible(ct, opts.principals ?? null)) {
+    throw new EngineActionError(`tool not found: ${callName}`);
+  }
+  const publicArgs = stripUnderscoreArgs(runtimeArgs);
+  let approvalId = null;
+  if (shouldRequireApproval(ct, publicArgs)) {
+    approvalId = await findAndClaimApproved(engine, ct.callName, publicArgs, opts.sourceId ?? null);
+    if (approvalId == null) {
+      const record = await createPending(engine, {
+        toolName: ct.callName,
+        args: publicArgs,
+        sourceId: opts.sourceId ?? null,
+        principals: opts.principals ?? null,
+        policy: ct.approvalPolicy ?? {}
+      });
+      const reason = ct.requiresApproval ? "tool requires approval" : `approval policy condition met: ${ct.approvalPolicy?.condition}`;
+      return {
+        approval_required: {
+          approval_id: String(record.id),
+          tool_name: ct.callName,
+          args: publicArgs,
+          reason
+        }
+      };
+    }
+  }
+  let config = {};
+  if (ct.kind !== "function" && ct.id != null) {
+    config = await decryptCtConfig(engine, ct.id);
+  }
+  const actorType = opts.actor?.type ?? null;
+  const actorId = opts.actor?.id ?? null;
+  let rawResult = null;
+  let exc = null;
+  const timer = new ToolCallTimer().start();
+  try {
+    rawResult = await dispatch(engine, ct, config, publicArgs);
+  } catch (e) {
+    exc = e;
+  }
+  timer.stop();
+  let success = exc == null;
+  let shaped = null;
+  let truncated = false;
+  if (success) {
+    try {
+      const [redacted] = redactToolResult(rawResult, engine.config.redaction, {
+        principals: opts.principals ?? null,
+        secretKey: engine.config.secretKey,
+        hooks: engine.hooks
+      });
+      rawResult = redacted;
+      [shaped, truncated] = shapeResult(rawResult);
+    } catch (e) {
+      exc = e;
+      success = false;
+    }
+  }
+  await logToolCall(engine, {
+    toolId: ct.id,
+    toolName: ct.callName,
+    kind: ct.kind,
+    actorType,
+    actorId,
+    source: opts.source ?? "api",
+    inputArgs: publicArgs,
+    outputResult: success ? rawResult : null,
+    success,
+    error: exc,
+    durationMs: timer.durationMs,
+    units: success ? 1 : 0,
+    approvalId
+  });
+  if (!success) {
+    throw new EngineActionError(`tool execution failed: ${ct.callName}: ${exc}`);
+  }
+  const usage = {
+    kind: "tool",
+    units: 1,
+    detail: { tool_name: ct.callName, kind: ct.kind, truncated }
+  };
+  emitUsage(engine.hooks, usage);
+  return {
+    result: shaped,
+    usage: { units: 1, kind: "tool", tool_name: ct.callName, truncated }
+  };
+}
+var STATE_TTL_SECONDS = 600;
+var DISCOVERY_TIMEOUT_MS = 1e4;
+var TOKEN_TIMEOUT_MS = 15e3;
+var PROBE_TIMEOUT_MS = 5e3;
+var REGISTER_TIMEOUT_MS = 1e4;
+function report(hooks, exc, ctx) {
+  if (hooks) emitError(hooks, exc, ctx);
+  else console.error("[context-engine] mcp_oauth error:", exc, "| ctx=", ctx);
+}
+var InMemoryPendingStore = class {
+  store = /* @__PURE__ */ new Map();
+  cleanupExpired() {
+    const now = Date.now() / 1e3;
+    for (const [k, v] of this.store) {
+      if (v.expiresAt <= now) this.store.delete(k);
+    }
+  }
+  put(state, data, ttlSeconds = STATE_TTL_SECONDS) {
+    this.cleanupExpired();
+    this.store.set(state, { data, expiresAt: Date.now() / 1e3 + ttlSeconds });
+  }
+  pop(state) {
+    this.cleanupExpired();
+    const entry = this.store.get(state);
+    this.store.delete(state);
+    if (!entry) return null;
+    if (entry.expiresAt <= Date.now() / 1e3) return null;
+    return entry.data;
+  }
+};
+async function fetchJson(url, opts = {}) {
+  const resp = await fetch(url, {
+    method: opts.method ?? "GET",
+    headers: opts.headers,
+    body: opts.body,
+    redirect: opts.redirect ?? "follow",
+    signal: AbortSignal.timeout(opts.timeout ?? DISCOVERY_TIMEOUT_MS)
+  });
+  return {
+    status: resp.status,
+    json: () => resp.json(),
+    text: () => resp.text()
+  };
+}
+async function discoverOauthMetadata(serverUrl, opts = {}) {
+  const parsed = new URL(serverUrl);
+  const base = `${parsed.protocol}//${parsed.host}`;
+  const wellKnownUrl = `${base}/.well-known/oauth-authorization-server`;
+  try {
+    const resp = await fetchJson(wellKnownUrl, { timeout: DISCOVERY_TIMEOUT_MS });
+    if (resp.status === 200) {
+      const data = await resp.json();
+      if (data.authorization_endpoint && data.token_endpoint) {
+        return {
+          authorization_endpoint: data.authorization_endpoint,
+          token_endpoint: data.token_endpoint,
+          registration_endpoint: data.registration_endpoint,
+          scopes_supported: data.scopes_supported ?? [],
+          response_types_supported: data.response_types_supported ?? [],
+          code_challenge_methods_supported: data.code_challenge_methods_supported ?? ["S256"],
+          issuer: data.issuer ?? base
+        };
+      }
+    }
+  } catch (e) {
+    if (!(e instanceof TypeError) && !(e instanceof DOMException)) {
+      report(opts.hooks, e, { stage: "discover_oauth_metadata_8414", url: wellKnownUrl });
+    }
+  }
+  const oidcUrl = `${base}/.well-known/openid-configuration`;
+  try {
+    const resp = await fetchJson(oidcUrl, { timeout: DISCOVERY_TIMEOUT_MS });
+    if (resp.status === 200) {
+      const data = await resp.json();
+      if (data.authorization_endpoint && data.token_endpoint) {
+        return {
+          authorization_endpoint: data.authorization_endpoint,
+          token_endpoint: data.token_endpoint,
+          registration_endpoint: data.registration_endpoint,
+          scopes_supported: data.scopes_supported ?? [],
+          code_challenge_methods_supported: data.code_challenge_methods_supported ?? ["S256"],
+          issuer: data.issuer ?? base
+        };
+      }
+    }
+  } catch {
+  }
+  for (const [authPath, tokenPath] of [
+    ["/oauth/authorize", "/oauth/token"],
+    ["/authorize", "/token"],
+    ["/oauth2/authorize", "/oauth2/token"]
+  ]) {
+    try {
+      const resp = await fetchJson(`${base}${authPath}`, {
+        timeout: PROBE_TIMEOUT_MS,
+        redirect: "manual"
+      });
+      if ([200, 302, 303, 400].includes(resp.status)) {
+        return {
+          authorization_endpoint: `${base}${authPath}`,
+          token_endpoint: `${base}${tokenPath}`,
+          issuer: base,
+          scopes_supported: [],
+          code_challenge_methods_supported: ["S256"]
+        };
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function registerOauthClient(registrationEndpoint, redirectUri, clientName = "Promptev Context Engine", opts = {}) {
+  const payload = {
+    client_name: clientName,
+    redirect_uris: [redirectUri],
+    grant_types: ["authorization_code", "refresh_token"],
+    response_types: ["code"],
+    token_endpoint_auth_method: "none"
+  };
+  let resp;
+  try {
+    resp = await fetchJson(registrationEndpoint, {
+      method: "POST",
+      timeout: REGISTER_TIMEOUT_MS,
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+  } catch (e) {
+    report(opts.hooks, e, { stage: "register_oauth_client", registration_endpoint: registrationEndpoint });
+    throw new Error(`Cannot reach registration endpoint: ${e}`);
+  }
+  if (resp.status !== 200 && resp.status !== 201) {
+    const error = new Error(`Client registration failed: ${resp.status}`);
+    report(opts.hooks, error, {
+      stage: "register_oauth_client",
+      registration_endpoint: registrationEndpoint,
+      status_code: resp.status
+    });
+    throw error;
+  }
+  return await resp.json();
+}
+async function buildAuthorizeUrl(metadata, serverUrl, toolId, redirectUri, store, opts = {}) {
+  const authEndpoint = metadata.authorization_endpoint;
+  const tokenEndpoint = metadata.token_endpoint;
+  if (!authEndpoint) throw new Error("OAuth metadata missing 'authorization_endpoint'");
+  if (!tokenEndpoint) throw new Error("OAuth metadata missing 'token_endpoint'");
+  const codeVerifier = crypto.randomBytes(64).toString("base64url").slice(0, 128);
+  const digest = crypto.createHash("sha256").update(codeVerifier, "ascii").digest();
+  const codeChallenge = digest.toString("base64url");
+  const state = crypto.randomBytes(32).toString("base64url");
+  await Promise.resolve(
+    store.put(
+      state,
+      {
+        server_url: serverUrl,
+        code_verifier: codeVerifier,
+        tool_id: toolId,
+        redirect_uri: redirectUri,
+        token_endpoint: tokenEndpoint,
+        client_id: opts.clientId ?? null,
+        client_secret: opts.clientSecret ?? null
+      },
+      opts.ttlSeconds ?? STATE_TTL_SECONDS
+    )
+  );
+  const params = new URLSearchParams({
+    response_type: "code",
+    state,
+    redirect_uri: redirectUri,
+    code_challenge: codeChallenge,
+    code_challenge_method: "S256"
+  });
+  if (opts.clientId) params.set("client_id", opts.clientId);
+  if (opts.scopes) params.set("scope", opts.scopes);
+  return { authorize_url: `${authEndpoint}?${params.toString()}`, state };
+}
+async function exchangeCodeForToken(state, code, store, opts = {}) {
+  const pending = await Promise.resolve(store.pop(state));
+  if (!pending) throw new Error("Invalid or expired OAuth state \u2014 please try connecting again");
+  const tokenEndpoint = pending.token_endpoint;
+  if (!tokenEndpoint) throw new Error("No token_endpoint in stored OAuth state");
+  const body = new URLSearchParams({
+    grant_type: "authorization_code",
+    code,
+    redirect_uri: String(pending.redirect_uri),
+    code_verifier: String(pending.code_verifier)
+  });
+  if (pending.client_id) body.set("client_id", String(pending.client_id));
+  const secret = opts.clientSecret || pending.client_secret;
+  if (secret) body.set("client_secret", String(secret));
+  let resp;
+  try {
+    resp = await fetchJson(tokenEndpoint, {
+      method: "POST",
+      timeout: TOKEN_TIMEOUT_MS,
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body
+    });
+  } catch (e) {
+    report(opts.hooks, e, { stage: "exchange_code_for_token", token_endpoint: tokenEndpoint });
+    throw new Error(`Could not reach token endpoint: ${e}`);
+  }
+  if (resp.status !== 200) {
+    const error = new Error(`Token exchange failed: ${resp.status}`);
+    report(opts.hooks, error, {
+      stage: "exchange_code_for_token",
+      token_endpoint: tokenEndpoint,
+      status_code: resp.status
+    });
+    throw error;
+  }
+  let tokenData;
+  try {
+    tokenData = await resp.json();
+  } catch {
+    const text = await resp.text();
+    tokenData = Object.fromEntries(new URLSearchParams(text));
+  }
+  const accessToken = tokenData.access_token;
+  if (!accessToken) {
+    const error = new Error("Token response missing access_token");
+    report(opts.hooks, error, { stage: "exchange_code_for_token", token_endpoint: tokenEndpoint });
+    throw error;
+  }
+  return {
+    access_token: accessToken,
+    refresh_token: tokenData.refresh_token,
+    token_type: tokenData.token_type ?? "Bearer",
+    expires_in: tokenData.expires_in,
+    scope: tokenData.scope,
+    tool_id: pending.tool_id,
+    server_url: pending.server_url
+  };
+}
+
+// src/tools/router.ts
+var MCP_OAUTH_CALLBACK_PATH = "/mcp/oauth/callback";
+var UUID_RE3 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function coerceUuid(value) {
+  if (!UUID_RE3.test(String(value))) {
+    throw new HandlerError(400, `invalid id: ${JSON.stringify(value)}`);
+  }
+  return value;
+}
+function toolRowPublic(row) {
+  return {
+    id: String(row.id),
+    name: row.name,
+    kind: row.kind,
+    description: row.description || "",
+    source_id: row.source_id,
+    acl: row.acl != null ? [...row.acl] : null,
+    requires_approval: row.requires_approval,
+    approval_policy: row.approval_policy ?? {},
+    enabled: row.enabled
+  };
+}
+function resolveCaller(value, surface) {
+  return resolveRequestPrincipals(value, { surface });
+}
+function recordToDict(record) {
+  return {
+    id: record.id,
+    tool_name: record.toolName,
+    tool_args_frozen: record.toolArgsFrozen,
+    source_id: record.sourceId,
+    principals: record.principals,
+    status: record.status,
+    approver: record.approver,
+    approver_meta: record.approverMeta,
+    expires_at: record.expiresAt?.toISOString() ?? null,
+    resolved_at: record.resolvedAt?.toISOString() ?? null,
+    created_at: record.createdAt?.toISOString() ?? null
+  };
+}
+function popupCloseHtml(success, message, targetOrigin, tokenData = null) {
+  const status = success ? "success" : "error";
+  const payload = { type: `mcp-oauth-${status}`, message };
+  if (tokenData && success) payload.token = tokenData;
+  const encoded = Buffer.from(JSON.stringify(payload), "utf8").toString("base64");
+  const title = success ? "Connected" : "Failed";
+  return `<!DOCTYPE html><html><head><title>Context Engine MCP OAuth</title></head><body style="font-family:system-ui;text-align:center;padding:40px;"><h2>${title}</h2><p>${message}</p><p style="font-size:12px;">This window will close automatically&hellip;</p><script>try {  var d = JSON.parse(atob("${encoded}"));  if (window.opener) window.opener.postMessage(d, "${targetOrigin}");} catch (e) { console.error('postMessage error', e); }setTimeout(function () { window.close(); }, 1500);</script></body></html>`;
+}
+function createToolsHandlers(engine, opts = {}) {
+  const store = opts.pendingStore ?? new InMemoryPendingStore();
+  const redirectBaseUrl = (opts.redirectBaseUrl ?? "").replace(/\/$/, "");
+  let targetOrigin = "";
+  try {
+    if (redirectBaseUrl) targetOrigin = new URL(redirectBaseUrl).origin;
+  } catch {
+    targetOrigin = "";
+  }
+  const redirectUri = redirectBaseUrl ? `${redirectBaseUrl}${MCP_OAUTH_CALLBACK_PATH}` : "";
+  return {
+    async createTool(body, principals) {
+      const caller = resolveCaller(principals, "POST /tools");
+      const tc = ToolConfig.fromUnknown(body);
+      authorizeAcl(tc.acl, caller);
+      try {
+        const toolId = engine.registerTool ? await engine.registerTool(tc) : await registerTool(engine, tc);
+        return { id: toolId };
+      } catch (exc) {
+        if (exc instanceof Error && /canonicalFromConfig|kind=/.test(exc.message)) {
+          throw new HandlerError(400, String(exc));
+        }
+        throw exc;
+      }
+    },
+    async listToolsAdmin(query, principals) {
+      const caller = resolveCaller(principals, "GET /tools");
+      const params = [];
+      let sql = `SELECT * FROM context_engine_tools`;
+      if (query.source_id != null) {
+        params.push(query.source_id);
+        sql += ` WHERE source_id = $1`;
+      }
+      const result = await engine.pool.query(sql, params);
+      const tools = result.rows.filter((row) => aclVisible(row.acl != null ? [...row.acl] : null, caller)).map(toolRowPublic);
+      return { tools };
+    },
+    async getTool(toolId, principals) {
+      const caller = resolveCaller(principals, "GET /tools/{tool_id}");
+      const parsedId = coerceUuid(toolId);
+      const result = await engine.pool.query(`SELECT * FROM context_engine_tools WHERE id = $1`, [parsedId]);
+      const row = result.rows[0];
+      if (!row || !aclVisible(row.acl != null ? [...row.acl] : null, caller)) {
+        throw new HandlerError(404, `tool not found: ${toolId}`);
+      }
+      return toolRowPublic(row);
+    },
+    async updateToolRoute(toolId, body, principals) {
+      const caller = resolveCaller(principals, "PATCH /tools/{tool_id}");
+      coerceUuid(toolId);
+      const fields = {};
+      const map = {
+        name: "name",
+        kind: "kind",
+        description: "description",
+        config: "config",
+        source_id: "sourceId",
+        acl: "acl",
+        requires_approval: "requiresApproval",
+        approval_policy: "approvalPolicy",
+        enabled: "enabled"
+      };
+      for (const [k, dest] of Object.entries(map)) {
+        if (Object.hasOwn(body, k)) fields[dest] = body[k];
+      }
+      if ("acl" in fields) authorizeAcl(fields.acl, caller);
+      try {
+        const updated = engine.updateTool ? await engine.updateTool(toolId, { principals: caller, ...fields }) : await updateTool(engine, toolId, { principals: caller, ...fields });
+        return {
+          id: updated.id,
+          name: updated.name,
+          kind: updated.kind,
+          description: updated.description,
+          source_id: updated.sourceId,
+          acl: updated.acl,
+          requires_approval: updated.requiresApproval,
+          approval_policy: updated.approvalPolicy,
+          enabled: updated.enabled
+        };
+      } catch (exc) {
+        if (exc instanceof EngineActionError) throw new HandlerError(404, String(exc.message));
+        throw exc;
+      }
+    },
+    async deleteToolRoute(toolId, principals) {
+      const caller = resolveCaller(principals, "DELETE /tools/{tool_id}");
+      coerceUuid(toolId);
+      try {
+        if (engine.deleteTool) await engine.deleteTool(toolId, { principals: caller });
+        else await deleteTool(engine, toolId, { principals: caller });
+      } catch (exc) {
+        if (exc instanceof EngineActionError) throw new HandlerError(404, String(exc.message));
+        throw exc;
+      }
+      return { deleted: toolId };
+    },
+    async testToolRoute(body) {
+      const tc = ToolConfig.fromUnknown(body);
+      return engine.testTool ? engine.testTool(tc) : testTool(engine, tc);
+    },
+    toolSchemaRoute(kind) {
+      try {
+        return configSchema(kind);
+      } catch {
+        throw new HandlerError(404, `unknown tool kind: ${JSON.stringify(kind)}`);
+      }
+    },
+    async executeToolRoute(body, principals) {
+      const caller = resolveCaller(principals, "POST /tools/execute");
+      if (!body.call_name) throw new HandlerError(422, "call_name is required");
+      try {
+        const exec = engine.executeTool ?? ((n, a, o) => executeTool(engine, n, a, o));
+        return await exec(body.call_name, body.args ?? null, {
+          sourceId: body.source_id,
+          principals: caller
+        });
+      } catch (exc) {
+        if (exc instanceof EngineActionError) throw new HandlerError(404, String(exc.message));
+        throw exc;
+      }
+    },
+    async mcpConnectAndList(body) {
+      const mcp = new PromptevMCP();
+      try {
+        await mcp.addServer(body.server_name, body.url, { token: body.token, headers: body.headers });
+        const client = mcp.clients.get(body.server_name);
+        const tools = await client.listTools();
+        const resources = body.include_resources ? await client.listResources() : null;
+        return {
+          server: body.server_name,
+          url: client.url,
+          transport: client.transport.kind,
+          tools,
+          resources,
+          requires_oauth: false
+        };
+      } catch (exc) {
+        const msg = String(exc);
+        const statusMatch = /HTTP (401|403)/.exec(msg);
+        if (statusMatch || /401|403/.test(msg)) {
+          const metadata = await discoverOauthMetadata(body.url, { hooks: engine.hooks });
+          if (metadata) {
+            return {
+              server: body.server_name,
+              url: body.url,
+              transport: "pending_oauth",
+              tools: [],
+              resources: null,
+              requires_oauth: true
+            };
+          }
+          throw new HandlerError(
+            502,
+            `MCP server returned ${statusMatch?.[1] ?? "401/403"}. No OAuth endpoint found \u2014 provide a Bearer token instead.`
+          );
+        }
+        if (exc instanceof MCPError) throw new HandlerError(502, `MCP protocol error: ${exc}`);
+        throw new HandlerError(502, `Cannot reach MCP server: ${exc}`);
+      } finally {
+        await mcp.shutdown();
+      }
+    },
+    async mcpOauthStart(body) {
+      if (!redirectUri) {
+        throw new HandlerError(500, "redirectBaseUrl is required to start MCP OAuth");
+      }
+      const metadata = await discoverOauthMetadata(body.server_url, { hooks: engine.hooks });
+      if (!metadata) {
+        throw new HandlerError(502, "MCP server does not support OAuth \u2014 no authorization endpoint found");
+      }
+      let clientId = body.client_id ?? null;
+      let clientSecret = body.client_secret ?? null;
+      if (!clientId && metadata.registration_endpoint) {
+        try {
+          const reg = await registerOauthClient(
+            String(metadata.registration_endpoint),
+            redirectUri,
+            "Promptev Context Engine",
+            { hooks: engine.hooks }
+          );
+          clientId = reg.client_id ?? null;
+          clientSecret = reg.client_secret || clientSecret;
+        } catch {
+        }
+      }
+      try {
+        return await buildAuthorizeUrl(metadata, body.server_url, body.tool_id || "", redirectUri, store, {
+          clientId,
+          clientSecret,
+          scopes: body.scopes
+        });
+      } catch (exc) {
+        throw new HandlerError(400, String(exc));
+      }
+    },
+    async mcpOauthCallback(query) {
+      const html = (success, message, token = null) => popupCloseHtml(success, message, targetOrigin, token);
+      if (query.error) {
+        return { html: html(false, query.error_description || query.error), contentType: "text/html" };
+      }
+      if (!query.code || !query.state) {
+        return { html: html(false, "Missing code or state parameter"), contentType: "text/html" };
+      }
+      try {
+        const tokenResult = await exchangeCodeForToken(query.state, query.code, store, {
+          hooks: engine.hooks
+        });
+        return {
+          html: html(true, "Connected successfully", {
+            access_token: tokenResult.access_token,
+            refresh_token: tokenResult.refresh_token,
+            token_type: tokenResult.token_type ?? "Bearer",
+            expires_in: tokenResult.expires_in,
+            scope: tokenResult.scope,
+            tool_id: tokenResult.tool_id
+          }),
+          contentType: "text/html"
+        };
+      } catch (exc) {
+        return { html: html(false, String(exc)), contentType: "text/html" };
+      }
+    },
+    async listApprovalsRoute(query, principals) {
+      const caller = resolveCaller(principals, "GET /approvals");
+      const records = await listApprovals(engine, {
+        status: query.status,
+        sourceId: query.source_id,
+        principals: caller
+      });
+      return { approvals: records.map(recordToDict) };
+    },
+    async resolveApprovalRoute(approvalId, body, principals) {
+      const caller = resolveCaller(principals, "POST /approvals/{approval_id}/resolve");
+      const parsedId = coerceUuid(approvalId);
+      try {
+        const record = await resolveApproval(
+          engine,
+          parsedId,
+          body.decision,
+          body.approver,
+          body.meta ?? null,
+          {
+            principals: caller
+          }
+        );
+        return recordToDict(record);
+      } catch (exc) {
+        if (exc instanceof ApprovalNotPending) {
+          throw new HandlerError(404, `approval not pending: ${exc.message}`);
+        }
+        if (exc instanceof ApprovalExpired) {
+          throw new HandlerError(409, "approval expired");
+        }
+        throw exc;
+      }
+    }
+  };
+}
+
+// src/hono.ts
+var require3 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('hono.cjs', document.baseURI).href)));
+function requireHono() {
+  try {
+    return require3("hono");
+  } catch {
+    throw new ExtraMissingError("hono", "hono", "createHonoRouter");
+  }
+}
+function jsonError(c, exc) {
+  return c.json({ detail: exc.detail }, exc.status);
+}
+async function readForm(c) {
+  const body = await c.req.parseBody({ all: true });
+  const file = body.file;
+  const fields = {};
+  for (const [k, v] of Object.entries(body)) {
+    if (k !== "file") fields[k] = v;
+  }
+  return { file, fields };
+}
+function createHonoRouter(engine, opts) {
+  if (!opts?.auth || !opts?.principals) {
+    throw new TypeError("createHonoRouter requires auth and principals");
+  }
+  const { Hono } = requireHono();
+  const app = new Hono();
+  const tools = createToolsHandlers(engine, { redirectBaseUrl: opts.redirectBaseUrl });
+  app.use("*", async (c, next) => {
+    if (c.req.path === MCP_OAUTH_CALLBACK_PATH) return next();
+    await opts.auth(c);
+    await next();
+  });
+  const wrap = (fn) => async (c) => {
+    try {
+      const result = await fn(c);
+      if (result && typeof result === "object" && "html" in result) {
+        const html = result;
+        return c.html(html.html);
+      }
+      return c.json(result);
+    } catch (exc) {
+      if (exc instanceof HandlerError) return jsonError(c, exc);
+      throw exc;
+    }
+  };
+  app.post(
+    "/documents",
+    wrap(async (c) => {
+      const ct = c.req.header("content-type") ?? "";
+      const principals = await opts.principals(c);
+      if (ct.startsWith("multipart/form-data")) {
+        const { file, fields } = await readForm(c);
+        if (!file) throw new HandlerError(400, "multipart upload requires a 'file' field");
+        const content = file.data ?? Buffer.from([]);
+        return handleIngestFile(engine, {
+          content,
+          filename: file.filename ?? null,
+          form: fields,
+          principals
+        });
+      }
+      if (ct.startsWith("application/json")) {
+        const payload = await c.req.json();
+        return handleIngestJson(engine, payload, principals);
+      }
+      throw new HandlerError(415, "Content-Type must be multipart/form-data or application/json");
+    })
+  );
+  app.get(
+    "/documents",
+    wrap(
+      async (c) => handleListDocuments(engine, {
+        sourceId: c.req.query("source_id") ?? null,
+        limit: Number(c.req.query("limit") ?? 50),
+        cursor: c.req.query("cursor") ?? null,
+        principals: await opts.principals(c)
+      })
+    )
+  );
+  app.get(
+    "/documents/:document_id",
+    wrap(async (c) => handleGetDocument(engine, c.req.param("document_id"), await opts.principals(c)))
+  );
+  app.delete(
+    "/documents/:document_id",
+    wrap(async (c) => handleDeleteDocument(engine, c.req.param("document_id"), await opts.principals(c)))
+  );
+  app.patch(
+    "/documents/:document_id",
+    wrap(
+      async (c) => handleUpdateDocument(engine, c.req.param("document_id"), await c.req.json(), await opts.principals(c))
+    )
+  );
+  app.post(
+    "/search",
+    wrap(async (c) => handleSearch(engine, await c.req.json(), await opts.principals(c)))
+  );
+  app.get(
+    "/stats",
+    wrap(async (c) => handleStats(engine, c.req.query("source_id") ?? null))
+  );
+  app.post(
+    "/tools",
+    wrap(async (c) => tools.createTool(await c.req.json(), await opts.principals(c)))
+  );
+  app.get(
+    "/tools",
+    wrap(
+      async (c) => tools.listToolsAdmin({ source_id: c.req.query("source_id") }, await opts.principals(c))
+    )
+  );
+  app.get(
+    "/tools/schema/:kind",
+    wrap(async (c) => tools.toolSchemaRoute(c.req.param("kind")))
+  );
+  app.post(
+    "/tools/test",
+    wrap(async (c) => tools.testToolRoute(await c.req.json()))
+  );
+  app.post(
+    "/tools/execute",
+    wrap(
+      async (c) => tools.executeToolRoute(await c.req.json(), await opts.principals(c))
+    )
+  );
+  app.get(
+    "/tools/:tool_id",
+    wrap(async (c) => tools.getTool(c.req.param("tool_id"), await opts.principals(c)))
+  );
+  app.patch(
+    "/tools/:tool_id",
+    wrap(
+      async (c) => tools.updateToolRoute(
+        c.req.param("tool_id"),
+        await c.req.json(),
+        await opts.principals(c)
+      )
+    )
+  );
+  app.delete(
+    "/tools/:tool_id",
+    wrap(async (c) => tools.deleteToolRoute(c.req.param("tool_id"), await opts.principals(c)))
+  );
+  app.post(
+    "/mcp/connect-and-list",
+    wrap(async (c) => tools.mcpConnectAndList(await c.req.json()))
+  );
+  app.post(
+    "/mcp/oauth/start",
+    wrap(async (c) => tools.mcpOauthStart(await c.req.json()))
+  );
+  app.get(
+    MCP_OAUTH_CALLBACK_PATH,
+    wrap(async (c) => tools.mcpOauthCallback(c.req.query()))
+  );
+  app.get(
+    "/approvals",
+    wrap(
+      async (c) => tools.listApprovalsRoute(
+        { status: c.req.query("status"), source_id: c.req.query("source_id") },
+        await opts.principals(c)
+      )
+    )
+  );
+  app.post(
+    "/approvals/:approval_id/resolve",
+    wrap(
+      async (c) => tools.resolveApprovalRoute(
+        c.req.param("approval_id"),
+        await c.req.json(),
+        await opts.principals(c)
+      )
+    )
+  );
+  return app;
+}
+var createHonoApp = createHonoRouter;
+
+exports.createHonoApp = createHonoApp;
+exports.createHonoRouter = createHonoRouter;
+//# sourceMappingURL=hono.cjs.map
+//# sourceMappingURL=hono.cjs.map