@openbkn/bkn-sdk 0.1.0

package/dist/chunk-4NXAIG4G.js

@@ -0,0 +1,4805 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/types.ts
+var DEFAULT_BUSINESS_DOMAIN = "bd_public";
+var DEFAULT_LIST_LIMIT = 30;
+var DEFAULT_QUERY_LIMIT = 50;
+
+// src/utils/errors.ts
+var HttpError = class extends Error {
+  status;
+  statusText;
+  body;
+  constructor(status2, statusText, body) {
+    super(`HTTP ${status2} ${statusText}`);
+    this.name = "HttpError";
+    this.status = status2;
+    this.statusText = statusText;
+    this.body = body;
+  }
+};
+var InputError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InputError";
+  }
+};
+function toExitCode(err) {
+  if (err instanceof InputError) return 2;
+  if (err instanceof HttpError) {
+    if (err.status === 401 || err.status === 403) return 3;
+    return 1;
+  }
+  return 1;
+}
+function formatError(err) {
+  if (err instanceof HttpError) {
+    if (err.status === 401 || err.status === 403) {
+      return `Not authorized (HTTP ${err.status}). Run \`openbkn auth login\` and retry.`;
+    }
+    const detail = err.body ? `: ${truncate(err.body, 500)}` : "";
+    return `Request failed (HTTP ${err.status} ${err.statusText})${detail}`;
+  }
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+function truncate(s, n) {
+  return s.length > n ? `${s.slice(0, n)}\u2026` : s;
+}
+
+// src/config/store.ts
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+// src/auth/jwt.ts
+function decodeJwt(token) {
+  const parts = token.split(".");
+  if (parts.length < 2 || !parts[1]) return void 0;
+  try {
+    const json = Buffer.from(parts[1], "base64url").toString("utf8");
+    return JSON.parse(json);
+  } catch {
+    return void 0;
+  }
+}
+function isExpired(claims, nowMs = Date.now()) {
+  return claims?.exp !== void 0 && claims.exp * 1e3 < nowMs;
+}
+
+// src/config/store.ts
+var PROFILE_RE = /^[A-Za-z0-9_-]{1,64}$/;
+var IS_WIN = process.platform === "win32";
+function configDir() {
+  return process.env.BKN_CONFIG_DIR ?? join(homedir(), ".bkn");
+}
+function profileName() {
+  const raw = process.env.BKN_PROFILE?.trim();
+  if (!raw) return null;
+  if (!PROFILE_RE.test(raw)) {
+    throw new Error(`BKN_PROFILE='${raw}' is invalid. Use 1-64 chars from [A-Za-z0-9_-].`);
+  }
+  return raw;
+}
+function statePath() {
+  const profile = profileName();
+  return profile ? join(configDir(), "profiles", profile, "state.json") : join(configDir(), "state.json");
+}
+function encodeKey(baseUrl) {
+  return Buffer.from(baseUrl, "utf8").toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function platformDir(baseUrl) {
+  return join(configDir(), "platforms", encodeKey(baseUrl));
+}
+function userDir(baseUrl, userId) {
+  return join(platformDir(baseUrl), "users", userId);
+}
+function userIdFromToken(token) {
+  return decodeJwt(token.idToken ?? "")?.sub ?? decodeJwt(token.accessToken)?.sub ?? "default";
+}
+function readState() {
+  return readJson(statePath()) ?? {};
+}
+function writeState(state) {
+  writeJson(statePath(), state);
+}
+function activePlatform() {
+  return readState().currentPlatform;
+}
+function setActivePlatform(baseUrl) {
+  writeState({ ...readState(), currentPlatform: baseUrl });
+}
+function activeUserId(baseUrl) {
+  return readState().activeUsers?.[baseUrl];
+}
+function setActiveUser(baseUrl, userId) {
+  const state = readState();
+  writeState({ ...state, activeUsers: { ...state.activeUsers, [baseUrl]: userId } });
+}
+function readToken(baseUrl, userId = activeUserId(baseUrl)) {
+  if (!userId) return void 0;
+  return readJson(join(userDir(baseUrl, userId), "token.json")) ?? void 0;
+}
+function writeToken(baseUrl, token) {
+  const userId = userIdFromToken(token);
+  writeJson(join(userDir(baseUrl, userId), "token.json"), token, 384);
+  setActiveUser(baseUrl, userId);
+  return userId;
+}
+function deleteToken(baseUrl, userId = activeUserId(baseUrl)) {
+  if (!userId) return false;
+  const path = join(userDir(baseUrl, userId), "token.json");
+  if (!existsSync(path)) return false;
+  rmSync(path, { force: true });
+  return true;
+}
+function readPlatformConfig(baseUrl, userId = activeUserId(baseUrl)) {
+  if (!userId) return {};
+  return readJson(join(userDir(baseUrl, userId), "config.json")) ?? {};
+}
+function writePlatformConfig(baseUrl, config) {
+  const userId = activeUserId(baseUrl) ?? "default";
+  writeJson(join(userDir(baseUrl, userId), "config.json"), config);
+}
+function listPlatforms() {
+  const root = join(configDir(), "platforms");
+  if (!existsSync(root)) return [];
+  const state = readState();
+  const out = [];
+  for (const key of readdirSync(root)) {
+    const baseUrl = decodeKey(key);
+    if (!baseUrl) continue;
+    const usersRoot = join(root, key, "users");
+    if (!existsSync(usersRoot)) continue;
+    const users = [];
+    for (const userId of readdirSync(usersRoot)) {
+      const token = readJson(join(usersRoot, userId, "token.json"));
+      if (token) users.push({ userId, username: token.username, displayName: token.displayName });
+    }
+    if (users.length > 0) {
+      out.push({ baseUrl, users, activeUserId: state.activeUsers?.[baseUrl] });
+    }
+  }
+  return out;
+}
+function decodeKey(key) {
+  try {
+    const b64 = key.replace(/-/g, "+").replace(/_/g, "/");
+    return Buffer.from(b64, "base64").toString("utf8");
+  } catch {
+    return null;
+  }
+}
+function readJson(path) {
+  if (!existsSync(path)) return void 0;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function writeJson(path, value, mode = 384) {
+  const dir = path.slice(0, path.lastIndexOf("/")) || ".";
+  mkdirSync(dir, { recursive: true, ...IS_WIN ? {} : { mode: 448 } });
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}
+`, IS_WIN ? {} : { mode });
+  if (!IS_WIN) chmodSync(path, mode);
+}
+
+// src/config/resolve.ts
+function resolveContext(opts = {}) {
+  const baseUrl = opts.baseUrl ?? process.env.BKN_BASE_URL ?? activePlatform();
+  if (!baseUrl) {
+    throw new InputError(
+      "No base URL. Pass --base-url, set BKN_BASE_URL, or run `openbkn auth login`."
+    );
+  }
+  const normalized = baseUrl.replace(/\/+$/, "");
+  const stored = readToken(normalized);
+  const token = opts.token ?? process.env.BKN_TOKEN ?? stored?.accessToken;
+  if (!token) {
+    throw new InputError("No access token. Set BKN_TOKEN or run `openbkn auth login`.");
+  }
+  return {
+    baseUrl: normalized,
+    token,
+    businessDomain: opts.businessDomain ?? readPlatformConfig(normalized).businessDomain ?? DEFAULT_BUSINESS_DOMAIN,
+    insecure: opts.insecure ?? stored?.tlsInsecure ?? false
+  };
+}
+
+// src/api/headers.ts
+function buildHeaders(ctx, extra) {
+  return {
+    authorization: `Bearer ${ctx.token}`,
+    token: ctx.token,
+    "x-business-domain": ctx.businessDomain,
+    ...extra
+  };
+}
+
+// src/api/tls.ts
+function applyTls(ctx) {
+  if (ctx.insecure && process.env.NODE_TLS_REJECT_UNAUTHORIZED !== "0") {
+    process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+  }
+}
+
+// src/api/http.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+async function request(ctx, path, init = {}) {
+  const url = new URL(path.startsWith("http") ? path : `${ctx.baseUrl}${path}`);
+  for (const [k, v] of Object.entries(init.query ?? {})) {
+    if (v !== void 0) url.searchParams.set(k, String(v));
+  }
+  applyTls(ctx);
+  const hasBody = init.body !== void 0;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), init.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  try {
+    const res = await fetch(url, {
+      method: init.method ?? (hasBody ? "POST" : "GET"),
+      headers: buildHeaders(ctx, {
+        ...hasBody ? { "content-type": "application/json" } : {},
+        ...init.headers
+      }),
+      body: hasBody ? JSON.stringify(init.body) : void 0,
+      signal: controller.signal
+    });
+    const text = await res.text();
+    if (!res.ok) throw new HttpError(res.status, res.statusText, text);
+    return text ? JSON.parse(text) : void 0;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/api/eacp-crypto.ts
+import {
+  constants,
+  createPrivateKey,
+  createPublicKey,
+  publicEncrypt
+} from "crypto";
+var EACP_MODIFYPWD_PRIVATE_KEY_PEM = `-----BEGIN RSA PRIVATE KEY-----
+MIICXgIBAAKBgQDB2fhLla9rMx+6LWTXajnK11Kdp520s1Q+TfPfIXI/7G9+L2YC
+4RA3M5rgRi32s5+UFQ/CVqUFqMqVuzaZ4lw/uEdk1qHcP0g6LB3E9wkl2FclFR0M
++/HrWmxPoON+0y/tFQxxfNgsUodFzbdh0XY1rIVUIbPLvufUBbLKXHDPpwIDAQAB
+AoGBALCM/H6ajXFs1nCR903aCVicUzoS9qckzI0SIhIOPCfMBp8+PAJTSJl9/ohU
+YnhVj/kmVXwBvboxyJAmOcxdRPWL7iTk5nA1oiVXMer3Wby+tRg/ls91xQbJLVv3
+oGSt7q0CXxJpRH2oYkVVlMMlZUwKz3ovHiLKAnhw+jEsdL2BAkEA9hA97yyeA2eq
+f9dMu/ici99R3WJRRtk4NEI4WShtWPyziDg48d3SOzYmhEJjPuOo3g1ze01os70P
+ApE7d0qcyQJBAMmt+FR8h5MwxPQPAzjh/fTuTttvUfBeMiUDrIycK1I/L96lH+fU
+i4Nu+7TPOzExnPeGO5UJbZxrpIEUB7Zs8O8CQQCLzTCTGiNwxc5eMgH77kVrRudp
+Q7nv6ex/7Hu9VDXEUFbkdyULbj9KuvppPJrMmWZROw04qgNp02mayM8jeLXZAkEA
+o+PM/pMn9TPXiWE9xBbaMhUKXgXLd2KEq1GeAbHS/oY8l1hmYhV1vjwNLbSNrH9d
+yEP73TQJL+jFiONHFTbYXwJAU03Xgum5mLIkX/02LpOrz2QCdfX1IMJk2iKi9osV
+KqfbvHsF0+GvFGg18/FXStG9Kr4TjqLsygQJT76/MnMluw==
+-----END RSA PRIVATE KEY-----`;
+var cachedKey;
+function publicKey() {
+  if (!cachedKey) cachedKey = createPublicKey(createPrivateKey(EACP_MODIFYPWD_PRIVATE_KEY_PEM));
+  return cachedKey;
+}
+function encryptModifyPwd(plain) {
+  const buf = publicEncrypt(
+    { key: publicKey(), padding: constants.RSA_PKCS1_PADDING },
+    Buffer.from(plain, "utf8")
+  );
+  return buf.toString("base64");
+}
+
+// src/api/admin.ts
+var UM = "/api/user-management/v1";
+var AUTHZ = "/api/authorization/v1";
+var ISFWEB = "/isfweb/api/ShareMgnt";
+async function callerUserId(ctx) {
+  const sub = decodeJwt(ctx.token)?.sub;
+  if (sub) return sub;
+  const info = await request(ctx, "/api/eacp/v1/user/get");
+  if (info?.userid) return info.userid;
+  throw new Error(
+    "Cannot resolve the caller user id (token has no JWT `sub` and eacp/v1/user/get returned no `userid`). Re-login."
+  );
+}
+async function shareMgnt(ctx, method, params = []) {
+  try {
+    return await request(ctx, `${ISFWEB}/${method}`, { method: "POST", body: params });
+  } catch (e) {
+    if (e instanceof HttpError) {
+      try {
+        const parsed = JSON.parse(e.body);
+        const err = parsed?.error;
+        if (err?.errMsg) {
+          const m = err.errID !== void 0 ? `${err.errMsg} (errID=${err.errID})` : err.errMsg;
+          throw new Error(`ShareMgnt.${method} failed: ${m}`);
+        }
+      } catch (inner) {
+        if (inner instanceof Error && inner.message.startsWith("ShareMgnt.")) throw inner;
+      }
+    }
+    throw e;
+  }
+}
+var DEPT_FIELDS = "name,code,remark,manager,enabled,parent_deps,email";
+var USER_FIELDS = "name,account,email,enabled,frozen,parent_deps,roles";
+function listDepartments(ctx, opts = {}) {
+  return request(ctx, `${UM}/console/search-departments/${DEPT_FIELDS}`, {
+    query: {
+      role: opts.role ?? "super_admin",
+      offset: opts.offset ?? 0,
+      limit: opts.limit ?? 100,
+      name: opts.name || void 0
+    }
+  });
+}
+async function listAllDepartments(ctx, role = "super_admin", pageSize = 100) {
+  const out = [];
+  let offset = 0;
+  for (; ; ) {
+    const data = await listDepartments(ctx, { role, offset, limit: pageSize });
+    const entries = data.entries ?? [];
+    out.push(...entries);
+    if (entries.length < pageSize) break;
+    if (data.total_count !== void 0 && out.length >= data.total_count) break;
+    offset += pageSize;
+  }
+  return out;
+}
+function listUsers(ctx, opts = {}) {
+  return request(ctx, `${UM}/console/search-users/${USER_FIELDS}`, {
+    query: {
+      role: opts.role ?? "super_admin",
+      offset: opts.offset ?? 0,
+      limit: opts.limit ?? 100,
+      department_id: opts.orgId || void 0,
+      name: opts.name || void 0
+    }
+  });
+}
+function listRoles(ctx, opts = {}) {
+  return request(ctx, `${AUTHZ}/roles`, {
+    query: {
+      offset: opts.offset ?? 0,
+      limit: opts.limit ?? 100,
+      keyword: opts.keyword || void 0
+    }
+  });
+}
+function getRole(ctx, roleId) {
+  return request(ctx, `${AUTHZ}/roles/${encodeURIComponent(roleId)}`);
+}
+function getUser(ctx, userId) {
+  return shareMgnt(ctx, "Usrm_GetUserInfo", [userId]);
+}
+async function getUserRoles(ctx, userId) {
+  try {
+    return await request(ctx, `${AUTHZ}/accessor_roles`, {
+      query: { accessor_id: userId, accessor_type: "user" }
+    });
+  } catch (e) {
+    if (!(e instanceof HttpError) || e.status !== 404) throw e;
+    const rolesPage = await listRoles(ctx, { offset: 0, limit: 200 });
+    const roles = rolesPage.entries ?? [];
+    const matched = [];
+    await Promise.all(
+      roles.map(async (role) => {
+        const members = await listRoleMembers(ctx, role.id, { offset: 0, limit: 500 });
+        if ((members.entries ?? []).some((m) => m.id === userId && (!m.type || m.type === "user"))) {
+          matched.push(role);
+        }
+      })
+    );
+    return {
+      entries: matched,
+      total_count: matched.length,
+      route: "fallback:list-roles+role-members"
+    };
+  }
+}
+async function getDepartment(ctx, deptId) {
+  try {
+    return await shareMgnt(ctx, "Usrm_GetOrgDepartmentById", [deptId]);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (!/部门不存在|errID:?\s*20201|errID=?\s*99|NoneType.+subscriptable/i.test(msg)) throw e;
+    return shareMgnt(ctx, "Usrm_GetDepartmentById", [deptId]);
+  }
+}
+function getDepartmentMembers(ctx, deptId, opts = {}) {
+  return request(ctx, `${UM}/department-members/${encodeURIComponent(deptId)}/users`, {
+    query: { role: opts.role ?? "super_admin", offset: opts.offset ?? 0, limit: opts.limit ?? 100 }
+  });
+}
+async function createDepartment(ctx, input) {
+  const ncTAddDepartParam = {
+    parentId: input.parentId ?? "-1",
+    departName: input.name,
+    managerID: input.managerID ?? null,
+    code: input.code ?? "",
+    remark: input.remark ?? "",
+    status: input.status ?? 1,
+    email: input.email ?? "",
+    ossId: ""
+  };
+  const id = await shareMgnt(ctx, "Usrm_AddDepartment", [{ ncTAddDepartParam }]);
+  return { id };
+}
+async function updateDepartment(ctx, deptId, input) {
+  const p = { departId: deptId };
+  if (input.name !== void 0) p.departName = input.name;
+  if (input.managerID !== void 0) p.managerID = input.managerID;
+  if (input.code !== void 0) p.code = input.code;
+  if (input.remark !== void 0) p.remark = input.remark;
+  if (input.status !== void 0) p.status = input.status;
+  if (input.email !== void 0) p.email = input.email;
+  await shareMgnt(ctx, "Usrm_EditDepartment", [{ ncTEditDepartParam: p }]);
+  return { id: deptId, updated: true };
+}
+async function deleteDepartment(ctx, deptId) {
+  await request(ctx, `${UM}/management/departments/${encodeURIComponent(deptId)}`, {
+    method: "DELETE"
+  });
+  return { id: deptId, deleted: true };
+}
+async function createUser(ctx, input) {
+  const ncTUsrmUserInfo = {
+    loginName: input.loginName,
+    displayName: input.displayName ?? input.loginName,
+    code: input.code ?? "",
+    position: input.position ?? "",
+    managerID: null,
+    managerDisplayName: null,
+    remark: input.remark ?? "",
+    email: input.email ?? "",
+    telNumber: input.telNumber ?? "",
+    idcardNumber: "",
+    departmentIds: input.departmentIds ?? ["-1"],
+    priority: input.priority ?? 999,
+    csfLevel2: null,
+    pwdControl: false,
+    expireTime: -1
+  };
+  if (input.csfLevel !== void 0) ncTUsrmUserInfo.csfLevel = input.csfLevel;
+  const id = await shareMgnt(ctx, "Usrm_AddUser", [
+    { ncTUsrmAddUserInfo: { user: { ncTUsrmUserInfo } } },
+    await callerUserId(ctx)
+  ]);
+  return { id };
+}
+async function updateUser(ctx, userId, input) {
+  const restBody = {};
+  if (input.displayName !== void 0) restBody.display_name = input.displayName;
+  if (input.code !== void 0) restBody.code = input.code;
+  if (input.position !== void 0) restBody.position = input.position;
+  if (input.remark !== void 0) restBody.remark = input.remark;
+  if (input.email !== void 0) restBody.email = input.email;
+  if (input.telNumber !== void 0) restBody.tel_number = input.telNumber;
+  if (input.managerID !== void 0) restBody.manager_id = input.managerID;
+  if (input.priority !== void 0) restBody.priority = input.priority;
+  if (input.csfLevel !== void 0) restBody.csf_level = input.csfLevel;
+  try {
+    const r = await request(ctx, `${UM}/management/users/${encodeURIComponent(userId)}`, {
+      method: "PATCH",
+      body: restBody
+    });
+    return r ?? { id: userId, updated: true, route: "rest" };
+  } catch (e) {
+    if (!(e instanceof HttpError) || e.status !== 404 && e.status !== 405) throw e;
+    const ncTEditUserParam = {
+      id: userId,
+      displayName: input.displayName ?? "",
+      code: input.code ?? "",
+      position: input.position ?? "",
+      managerID: input.managerID ?? "",
+      remark: input.remark ?? "",
+      idcardNumber: null,
+      priority: input.priority ?? 999,
+      csfLevel: input.csfLevel ?? 5,
+      csfLevel2: null,
+      email: input.email ?? "",
+      telNumber: input.telNumber ?? "",
+      expireTime: -1
+    };
+    await shareMgnt(ctx, "Usrm_EditUser", [{ ncTEditUserParam }, await callerUserId(ctx)]);
+    return { id: userId, updated: true, route: "shareMgnt" };
+  }
+}
+async function deleteUser(ctx, userId) {
+  try {
+    await request(ctx, `${UM}/users/${encodeURIComponent(userId)}`, { method: "DELETE" });
+  } catch (e) {
+    if (!(e instanceof HttpError) || e.status !== 404) throw e;
+    await shareMgnt(ctx, "Usrm_DelUser", [userId]);
+  }
+  return { id: userId, deleted: true };
+}
+async function setUserPassword(ctx, userId, newPassword) {
+  await request(ctx, `${UM}/management/users/${encodeURIComponent(userId)}/password`, {
+    method: "PUT",
+    body: { password: encryptModifyPwd(newPassword) }
+  });
+  return { id: userId, passwordReset: true };
+}
+var EACP = "/api/eacp/v1";
+function listAuditLogs(ctx, opts = {}) {
+  return request(ctx, `${EACP}/auth1/login-log`, {
+    method: "POST",
+    body: {
+      page_num: opts.page ?? 1,
+      page_size: opts.size ?? 30,
+      user_name: opts.user || void 0,
+      start_time: opts.start || void 0,
+      end_time: opts.end || void 0
+    }
+  });
+}
+function changePassword(ctx, account, oldPassword, newPassword) {
+  return request(ctx, `${EACP}/auth1/modifypassword`, {
+    method: "POST",
+    body: {
+      account,
+      oldpwd: encryptModifyPwd(oldPassword),
+      newpwd: encryptModifyPwd(newPassword)
+    }
+  });
+}
+function listRoleMembers(ctx, roleId, opts = {}) {
+  return request(ctx, `${AUTHZ}/role-members/${encodeURIComponent(roleId)}`, {
+    query: {
+      offset: opts.offset ?? 0,
+      limit: opts.limit ?? 100,
+      keyword: opts.keyword || void 0
+    }
+  });
+}
+function modifyRoleMembers(ctx, roleId, method, members) {
+  return request(ctx, `${AUTHZ}/role-members/${encodeURIComponent(roleId)}`, {
+    method: "POST",
+    body: { method, members }
+  });
+}
+
+// src/utils/org-tree.ts
+function buildOrgTree(entries) {
+  const nodes = /* @__PURE__ */ new Map();
+  for (const e of entries) nodes.set(e.id, { id: e.id, name: e.name ?? e.id, children: [] });
+  const roots = [];
+  for (const e of entries) {
+    const node = nodes.get(e.id);
+    if (!node) continue;
+    const deps = e.parent_deps;
+    const parentId = deps && deps.length > 0 ? deps[deps.length - 1]?.id : void 0;
+    const parent = parentId ? nodes.get(parentId) : void 0;
+    if (parent) parent.children.push(node);
+    else roots.push(node);
+  }
+  return roots;
+}
+function renderOrgTree(nodes, prefix = "") {
+  const lines = [];
+  nodes.forEach((node, i) => {
+    const last = i === nodes.length - 1;
+    lines.push(`${prefix}${last ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 "}${node.name} (id: ${node.id})`);
+    if (node.children.length) {
+      lines.push(renderOrgTree(node.children, `${prefix}${last ? "    " : "\u2502   "}`));
+    }
+  });
+  return lines.join("\n");
+}
+
+// src/resources/admin.ts
+function admin(ctx) {
+  return {
+    orgList: (opts) => listDepartments(ctx, opts),
+    orgGet: (deptId) => getDepartment(ctx, deptId),
+    orgMembers: (deptId, opts) => getDepartmentMembers(ctx, deptId, opts),
+    orgTree: async (role) => buildOrgTree(await listAllDepartments(ctx, role)),
+    orgCreate: (input) => createDepartment(ctx, input),
+    orgUpdate: (deptId, input) => updateDepartment(ctx, deptId, input),
+    orgDelete: (deptId) => deleteDepartment(ctx, deptId),
+    userList: (opts) => listUsers(ctx, opts),
+    userGet: (userId) => getUser(ctx, userId),
+    userRoles: (userId) => getUserRoles(ctx, userId),
+    userCreate: (input) => createUser(ctx, input),
+    userUpdate: (userId, input) => updateUser(ctx, userId, input),
+    userDelete: (userId) => deleteUser(ctx, userId),
+    userResetPassword: (userId, newPassword) => setUserPassword(ctx, userId, newPassword),
+    roleList: (opts) => listRoles(ctx, opts),
+    roleGet: (roleId) => getRole(ctx, roleId),
+    roleMembers: (roleId, opts) => listRoleMembers(ctx, roleId, opts),
+    addRoleMember: (roleId, id, type = "user") => modifyRoleMembers(ctx, roleId, "POST", [{ id, type }]),
+    removeRoleMember: (roleId, id, type = "user") => modifyRoleMembers(ctx, roleId, "DELETE", [{ id, type }]),
+    auditList: (opts) => listAuditLogs(ctx, opts)
+  };
+}
+
+// src/api/agent-chat.ts
+var FACTORY = "/api/agent-factory";
+async function fetchAgentInfo(ctx, agentId, version = "v0") {
+  const data = await request(
+    ctx,
+    `${FACTORY}/v3/agent-market/agent/${encodeURIComponent(agentId)}/version/${encodeURIComponent(version)}`,
+    { query: { is_visit: true } }
+  );
+  const id = data.id;
+  const key = data.key;
+  if (typeof id !== "string" || !id || typeof key !== "string" || !key) {
+    throw new Error("Agent info response did not include id and key.");
+  }
+  return { id, key, version: typeof data.version === "string" ? data.version : version };
+}
+function getByPath(obj, path) {
+  let cur = obj;
+  for (const k of path) {
+    if (cur === null || typeof cur !== "object") return void 0;
+    cur = cur[k];
+  }
+  return cur;
+}
+function setByPath(obj, path, value) {
+  let cur = obj;
+  for (let i = 0; i < path.length - 1; i += 1) {
+    const k = path[i];
+    if (!(k in cur) || typeof cur[k] !== "object" || cur[k] === null) cur[k] = {};
+    cur = cur[k];
+  }
+  cur[path[path.length - 1]] = value;
+}
+function applyPatch(data, result) {
+  const path = data.key;
+  if (!path || path.length === 0) return;
+  if (data.action === "upsert" && data.content !== void 0) {
+    setByPath(result, path, data.content);
+  } else if (data.action === "append") {
+    const existing = getByPath(result, path);
+    const add = typeof data.content === "string" ? data.content : String(data.content ?? "");
+    setByPath(result, path, typeof existing === "string" ? existing + add : add);
+  } else if (data.action === "remove" && path.length === 1) {
+    delete result[path[0]];
+  }
+}
+function extractText(result) {
+  const content = getByPath(result, ["message", "content"]);
+  if (content) {
+    if (typeof content.text === "string" && content.text) return content.text;
+    const fa = content.final_answer;
+    const ans = fa?.answer;
+    if (typeof ans?.text === "string" && ans.text) return ans.text;
+    if (typeof fa?.text === "string" && fa.text) return fa.text;
+  }
+  const msg = result.message;
+  if (typeof msg?.text === "string" && msg.text) return msg.text;
+  return "";
+}
+async function sendChat(ctx, info, query, opts = {}) {
+  applyTls(ctx);
+  const body = {
+    agent_id: info.id,
+    agent_key: info.key,
+    agent_version: info.version,
+    query,
+    stream: Boolean(opts.stream)
+  };
+  if (opts.conversationId) body.conversation_id = opts.conversationId;
+  const res = await fetch(`${ctx.baseUrl}${FACTORY}/v1/app/${info.key}/chat/completion`, {
+    method: "POST",
+    headers: {
+      ...buildHeaders(ctx),
+      "content-type": "application/json",
+      accept: opts.stream ? "text/event-stream" : "application/json",
+      "x-language": "zh-CN"
+    },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) throw new HttpError(res.status, res.statusText, await res.text());
+  const contentType = res.headers.get("content-type") ?? "";
+  if (opts.stream && contentType.includes("text/event-stream")) {
+    return consumeStream(res, opts.onDelta);
+  }
+  const result = JSON.parse(await res.text());
+  return { text: extractText(result), conversationId: conversationIdOf(result) };
+}
+function conversationIdOf(result) {
+  const id = result.conversation_id;
+  return typeof id === "string" ? id : void 0;
+}
+async function consumeStream(res, onDelta) {
+  const reader = res.body?.getReader();
+  if (!reader) throw new Error("No response body for stream");
+  const decoder = new TextDecoder();
+  const result = {};
+  let buffer = "";
+  let lastText = "";
+  let conversationId;
+  const handle = (line) => {
+    if (!line.startsWith("data:")) return;
+    const payload = line.slice(5).trim();
+    if (payload === "" || payload === "[DONE]") return;
+    let data;
+    try {
+      data = JSON.parse(payload);
+    } catch {
+      return;
+    }
+    applyPatch(data, result);
+    if (data.key?.length === 1 && data.key[0] === "conversation_id") {
+      conversationId = typeof data.content === "string" ? data.content : conversationId;
+    }
+    const text = extractText(result);
+    if (text && text !== lastText) {
+      if (onDelta) onDelta(text.slice(lastText.length));
+      lastText = text;
+    }
+  };
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const ln of lines) handle(ln.replace(/\r$/, ""));
+  }
+  if (buffer.trim()) handle(buffer.trim());
+  return { text: lastText, conversationId: conversationId ?? conversationIdOf(result) };
+}
+
+// src/api/agents.ts
+var BASE = "/api/agent-factory/v3";
+function listAgents(ctx, opts = {}) {
+  return request(ctx, `${BASE}/published/agent`, {
+    method: "POST",
+    body: {
+      offset: opts.offset ?? 0,
+      limit: opts.limit ?? 30,
+      category_id: opts.categoryId ?? "",
+      name: opts.name ?? "",
+      custom_space_id: opts.customSpaceId ?? "",
+      is_to_square: opts.isToSquare ?? 1
+    }
+  });
+}
+function getAgent(ctx, agentId) {
+  return request(ctx, `${BASE}/agent/${encodeURIComponent(agentId)}`);
+}
+function getAgentByKey(ctx, key) {
+  return request(ctx, `${BASE}/agent/by-key/${encodeURIComponent(key)}`);
+}
+function listPersonalAgents(ctx, opts = {}) {
+  return request(ctx, `${BASE}/personal-space/agent-list`, {
+    query: { offset: opts.offset ?? 0, limit: opts.limit ?? 30, name: opts.name || void 0 }
+  });
+}
+function listAgentTemplates(ctx, opts = {}) {
+  return request(ctx, `${BASE}/published/agent-tpl`, {
+    query: { offset: opts.offset ?? 0, limit: opts.limit ?? 30, name: opts.name || void 0 }
+  });
+}
+function getAgentTemplate(ctx, templateId) {
+  return request(ctx, `${BASE}/published/agent-tpl/${encodeURIComponent(templateId)}`);
+}
+function listAgentCategories(ctx) {
+  return request(ctx, `${BASE}/category`);
+}
+function createAgent(ctx, body) {
+  return request(ctx, `${BASE}/agent`, { method: "POST", body });
+}
+function updateAgent(ctx, agentId, body) {
+  return request(ctx, `${BASE}/agent/${encodeURIComponent(agentId)}`, { method: "PUT", body });
+}
+function deleteAgent(ctx, agentId) {
+  return request(ctx, `${BASE}/agent/${encodeURIComponent(agentId)}`, { method: "DELETE" });
+}
+function publishAgent(ctx, agentId) {
+  return request(ctx, `${BASE}/agent/${encodeURIComponent(agentId)}/publish`, { method: "POST" });
+}
+function unpublishAgent(ctx, agentId) {
+  return request(ctx, `${BASE}/agent/${encodeURIComponent(agentId)}/unpublish`, { method: "PUT" });
+}
+var APP = "/api/agent-factory/v1/app";
+function listConversations(ctx, agentKey, opts = {}) {
+  return request(ctx, `${APP}/${encodeURIComponent(agentKey)}/conversation`, {
+    query: { page: opts.page ?? 1, size: opts.size ?? 30 }
+  });
+}
+function listMessages(ctx, agentKey, conversationId) {
+  return request(
+    ctx,
+    `${APP}/${encodeURIComponent(agentKey)}/conversation/${encodeURIComponent(conversationId)}`
+  );
+}
+
+// src/resources/agents.ts
+function skillMembers(agent) {
+  const config = agent.config ?? {};
+  const skills2 = config.skills ?? {};
+  return Array.isArray(skills2.skills) ? skills2.skills : [];
+}
+function setSkillMembers(agent, members) {
+  if (!agent.config || typeof agent.config !== "object") agent.config = {};
+  const config = agent.config;
+  if (!config.skills || typeof config.skills !== "object") config.skills = {};
+  config.skills.skills = members;
+}
+function agents(ctx) {
+  return {
+    list: (opts) => listAgents(ctx, opts),
+    get: (agentId) => getAgent(ctx, agentId),
+    getByKey: (key) => getAgentByKey(ctx, key),
+    personalList: (opts) => listPersonalAgents(ctx, opts),
+    templateList: (opts) => listAgentTemplates(ctx, opts),
+    templateGet: (templateId) => getAgentTemplate(ctx, templateId),
+    categoryList: () => listAgentCategories(ctx),
+    create: (body) => createAgent(ctx, body),
+    update: (agentId, body) => updateAgent(ctx, agentId, body),
+    delete: (agentId) => deleteAgent(ctx, agentId),
+    publish: (agentId) => publishAgent(ctx, agentId),
+    unpublish: (agentId) => unpublishAgent(ctx, agentId),
+    sessions: (agentKey, opts) => listConversations(ctx, agentKey, opts),
+    history: (agentKey, conversationId) => listMessages(ctx, agentKey, conversationId),
+    /** List skill ids attached to an agent (config.skills.skills). */
+    skillList: async (agentId) => {
+      const agent = await getAgent(ctx, agentId);
+      const arr = skillMembers(agent);
+      return arr.map((m) => String(m.skill_id ?? "")).filter(Boolean);
+    },
+    /** Attach skill(s) to an agent (dedup), then persist. */
+    skillAdd: async (agentId, skillIds) => {
+      const agent = await getAgent(ctx, agentId);
+      const arr = skillMembers(agent);
+      const have = new Set(arr.map((m) => String(m.skill_id ?? "")));
+      for (const id of skillIds) if (!have.has(id)) arr.push({ skill_id: id });
+      setSkillMembers(agent, arr);
+      return updateAgent(ctx, agentId, agent);
+    },
+    /** Detach skill(s) from an agent, then persist. */
+    skillRemove: async (agentId, skillIds) => {
+      const agent = await getAgent(ctx, agentId);
+      const drop = new Set(skillIds);
+      const arr = skillMembers(agent).filter(
+        (m) => !drop.has(String(m.skill_id ?? ""))
+      );
+      setSkillMembers(agent, arr);
+      return updateAgent(ctx, agentId, agent);
+    },
+    /** Send a chat turn to an agent (resolves agent id/key/version first). */
+    chat: async (agentId, query, opts = {}) => {
+      const info = await fetchAgentInfo(ctx, agentId, opts.version ?? "v0");
+      return sendChat(ctx, info, query, opts);
+    }
+  };
+}
+
+// src/api/context-loader.ts
+var MCP_PATH = "/api/agent-retrieval/v1/mcp";
+var PROTOCOL = "2024-11-05";
+var SESSION_TTL_MS = 3e5;
+var sessions = /* @__PURE__ */ new Map();
+var rpcId = 0;
+function nextId() {
+  rpcId += 1;
+  return rpcId;
+}
+function mcpUrl(ctx) {
+  return `${ctx.baseUrl}${MCP_PATH}`;
+}
+function headers(ctx, knId, sessionId) {
+  const h = {
+    "content-type": "application/json",
+    accept: "application/json, text/event-stream",
+    "x-kn-id": knId,
+    "mcp-protocol-version": PROTOCOL,
+    authorization: `Bearer ${ctx.token}`
+  };
+  if (sessionId) h["mcp-session-id"] = sessionId;
+  return h;
+}
+function parseBody(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    const data = text.split("\n").filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trim()).join("");
+    if (data) return JSON.parse(data);
+    throw new Error(`Context-loader returned invalid JSON: ${text.slice(0, 200)}`);
+  }
+}
+async function post(ctx, knId, sessionId, body) {
+  applyTls(ctx);
+  const res = await fetch(mcpUrl(ctx), {
+    method: "POST",
+    headers: headers(ctx, knId, sessionId),
+    body: JSON.stringify(body)
+  });
+  const text = await res.text();
+  if (!res.ok) throw new HttpError(res.status, res.statusText, text);
+  return { res, text };
+}
+async function ensureSession(ctx, knId) {
+  const key = `${mcpUrl(ctx)}:${knId}`;
+  const cached = sessions.get(key);
+  if (cached && Date.now() - cached.at < SESSION_TTL_MS) return cached.id;
+  sessions.delete(key);
+  const { res } = await post(ctx, knId, void 0, {
+    jsonrpc: "2.0",
+    id: 1,
+    method: "initialize",
+    params: {
+      protocolVersion: PROTOCOL,
+      capabilities: {},
+      clientInfo: { name: "openbkn", version: "0.1.0" }
+    }
+  });
+  const sessionId = res.headers.get("mcp-session-id") ?? res.headers.get("MCP-Session-Id");
+  if (!sessionId) throw new Error("MCP server did not return a session id.");
+  await post(ctx, knId, sessionId, { jsonrpc: "2.0", method: "notifications/initialized" });
+  sessions.set(key, { id: sessionId, at: Date.now() });
+  return sessionId;
+}
+function unwrap(parsed) {
+  const rpc = parsed;
+  if (rpc.error) throw new Error(`Context-loader error: ${rpc.error.message}`);
+  const result = rpc.result;
+  if (result === void 0) return parsed;
+  const content = result.content;
+  if (Array.isArray(content) && content[0] && typeof content[0].text === "string") {
+    try {
+      return JSON.parse(content[0].text);
+    } catch {
+      return { raw: content[0].text };
+    }
+  }
+  return result;
+}
+async function callTool(ctx, knId, name, args) {
+  const sessionId = await ensureSession(ctx, knId);
+  const { text } = await post(ctx, knId, sessionId, {
+    jsonrpc: "2.0",
+    method: "tools/call",
+    params: { name, arguments: args },
+    id: nextId()
+  });
+  return unwrap(parseBody(text));
+}
+async function callMethod(ctx, knId, method, params = {}) {
+  const sessionId = await ensureSession(ctx, knId);
+  const { text } = await post(ctx, knId, sessionId, {
+    jsonrpc: "2.0",
+    method,
+    params: Object.keys(params).length > 0 ? params : void 0,
+    id: nextId()
+  });
+  const parsed = parseBody(text);
+  if (parsed.error) throw new Error(`Context-loader error: ${parsed.error.message}`);
+  return parsed.result;
+}
+function searchSchema(ctx, knId, query, opts = {}) {
+  const args = { query, response_format: "json" };
+  if (opts.searchScope) args.search_scope = opts.searchScope;
+  if (opts.maxConcepts !== void 0) args.max_concepts = opts.maxConcepts;
+  return callTool(ctx, knId, "search_schema", args);
+}
+function queryObjectInstance(ctx, knId, args) {
+  return callTool(ctx, knId, "query_object_instance", args);
+}
+function findSkills(ctx, knId, objectTypeId, topK) {
+  const args = { object_type_id: objectTypeId };
+  if (topK !== void 0) args.top_k = topK;
+  return callTool(ctx, knId, "find_skills", args);
+}
+function listTools(ctx, knId) {
+  return callMethod(ctx, knId, "tools/list");
+}
+function queryInstanceSubgraph(ctx, knId, args) {
+  return callTool(ctx, knId, "query_instance_subgraph", args);
+}
+function getLogicProperties(ctx, knId, args) {
+  return callTool(ctx, knId, "get_logic_properties_values", args);
+}
+function getActionInfo(ctx, knId, args) {
+  return callTool(ctx, knId, "get_action_info", args);
+}
+function listResources(ctx, knId) {
+  return callMethod(ctx, knId, "resources/list");
+}
+function readResource(ctx, knId, uri) {
+  return callMethod(ctx, knId, "resources/read", { uri });
+}
+function listResourceTemplates(ctx, knId) {
+  return callMethod(ctx, knId, "resources/templates/list");
+}
+function listPrompts(ctx, knId) {
+  return callMethod(ctx, knId, "prompts/list");
+}
+function getPrompt(ctx, knId, name, args = {}) {
+  return callMethod(ctx, knId, "prompts/get", { name, arguments: args });
+}
+
+// src/resources/context-loader.ts
+function context(ctx) {
+  return {
+    searchSchema: (knId, query, opts) => searchSchema(ctx, knId, query, opts),
+    queryObjectInstance: (knId, args) => queryObjectInstance(ctx, knId, args),
+    findSkills: (knId, objectTypeId, topK) => findSkills(ctx, knId, objectTypeId, topK),
+    tools: (knId) => listTools(ctx, knId),
+    toolCall: (knId, name, args) => callTool(ctx, knId, name, args),
+    queryInstanceSubgraph: (knId, args) => queryInstanceSubgraph(ctx, knId, args),
+    logicProperties: (knId, args) => getLogicProperties(ctx, knId, args),
+    actionInfo: (knId, args) => getActionInfo(ctx, knId, args),
+    resources: (knId) => listResources(ctx, knId),
+    resource: (knId, uri) => readResource(ctx, knId, uri),
+    templates: (knId) => listResourceTemplates(ctx, knId),
+    prompts: (knId) => listPrompts(ctx, knId),
+    prompt: (knId, name, args) => getPrompt(ctx, knId, name, args)
+  };
+}
+
+// src/api/dataflow.ts
+var BASE2 = "/api/automation/v2";
+var BASE_V1 = "/api/automation/v1";
+function listDataflows(ctx) {
+  return request(ctx, `${BASE2}/dags`, { query: { type: "data-flow", page: 0, limit: -1 } });
+}
+function createDataflow(ctx, body) {
+  return request(ctx, `${BASE_V1}/data-flow/flow`, { method: "POST", body });
+}
+function runDataflow(ctx, dagId) {
+  return request(ctx, `${BASE_V1}/run-instance/${encodeURIComponent(dagId)}`, {
+    method: "POST",
+    body: {}
+  });
+}
+function deleteDataflow(ctx, dagId) {
+  return request(ctx, `${BASE_V1}/data-flow/flow/${encodeURIComponent(dagId)}`, {
+    method: "DELETE"
+  });
+}
+async function executeDataflow(ctx, body, opts = {}) {
+  const created = await createDataflow(ctx, body);
+  const dagId = String(created.id ?? "");
+  if (!dagId) throw new Error("createDataflow returned no DAG id");
+  try {
+    await runDataflow(ctx, dagId);
+    const interval = opts.intervalMs ?? 2e3;
+    const deadline = opts.timeoutMs ?? 3e5;
+    let waited = 0;
+    for (; ; ) {
+      const res = await request(ctx, `${BASE_V1}/dag/${encodeURIComponent(dagId)}/results`);
+      const status2 = res.results?.[0]?.status;
+      if (status2 === "success" || status2 === "completed") return { dagId, status: status2 };
+      if (status2 === "failed" || status2 === "error") throw new Error(`Dataflow run ${status2}`);
+      if (waited >= deadline) throw new Error(`Dataflow run timed out after ${deadline}ms`);
+      await new Promise((r) => setTimeout(r, interval));
+      waited += interval;
+    }
+  } finally {
+    await deleteDataflow(ctx, dagId).catch(() => {
+    });
+  }
+}
+function listDataflowRuns(ctx, dagId, opts = {}) {
+  return request(ctx, `${BASE2}/dag/${encodeURIComponent(dagId)}/results`, {
+    query: { since: opts.since || void 0 }
+  });
+}
+function runDataflowRemote(ctx, dagId, url, name) {
+  return request(ctx, `${BASE2}/dataflow-doc/trigger/${encodeURIComponent(dagId)}`, {
+    method: "POST",
+    body: { source_from: "remote", url, name }
+  });
+}
+function getDataflowLogs(ctx, dagId, instanceId, opts = {}) {
+  return request(
+    ctx,
+    `${BASE2}/dag/${encodeURIComponent(dagId)}/result/${encodeURIComponent(instanceId)}`,
+    { query: { page: opts.page ?? 0, limit: opts.limit ?? 30 } }
+  );
+}
+
+// src/api/knowledge-networks.ts
+var ONTOLOGY_BASE = "/api/ontology-manager/v1/knowledge-networks";
+var ONTOLOGY_QUERY_BASE = "/api/ontology-query/v1/knowledge-networks";
+var RETRIEVAL_BASE = "/api/agent-retrieval/v1/kn";
+function listKnowledgeNetworks(ctx, opts = {}) {
+  return request(ctx, ONTOLOGY_BASE, {
+    query: {
+      offset: opts.offset ?? 0,
+      limit: opts.limit ?? 30,
+      sort: opts.sort ?? "update_time",
+      direction: opts.direction ?? "desc",
+      name_pattern: opts.namePattern || void 0,
+      tag: opts.tag || void 0
+    }
+  });
+}
+function getKnowledgeNetwork(ctx, knId, opts = {}) {
+  return request(ctx, `${ONTOLOGY_BASE}/${encodeURIComponent(knId)}`, {
+    query: {
+      mode: opts.exportMode ? "export" : void 0,
+      include_statistics: opts.stats ? "true" : void 0
+    }
+  });
+}
+function createKnowledgeNetworkRaw(ctx, body) {
+  return request(ctx, ONTOLOGY_BASE, { method: "POST", body });
+}
+function createKnowledgeNetwork(ctx, opts) {
+  return request(ctx, ONTOLOGY_BASE, {
+    method: "POST",
+    body: { name: opts.name, branch: opts.branch ?? "main", base_branch: opts.baseBranch ?? "" }
+  });
+}
+function deleteKnowledgeNetwork(ctx, knId) {
+  return request(ctx, `${ONTOLOGY_BASE}/${encodeURIComponent(knId)}`, { method: "DELETE" });
+}
+function updateKnowledgeNetwork(ctx, knId, body) {
+  return request(ctx, `${ONTOLOGY_BASE}/${encodeURIComponent(knId)}`, { method: "PUT", body });
+}
+function querySubgraph(ctx, knId, body) {
+  return request(ctx, `${ONTOLOGY_QUERY_BASE}/${encodeURIComponent(knId)}/subgraph`, {
+    method: "POST",
+    body
+  });
+}
+function listActionLogs(ctx, knId, opts = {}) {
+  return request(ctx, `${ONTOLOGY_QUERY_BASE}/${encodeURIComponent(knId)}/action-logs`, {
+    query: {
+      action_type_id: opts.actionTypeId || void 0,
+      status: opts.status || void 0,
+      trigger_type: opts.triggerType || void 0,
+      limit: opts.limit ?? 30,
+      need_total: opts.needTotal ? "true" : void 0
+    }
+  });
+}
+function getActionLog(ctx, knId, logId) {
+  return request(
+    ctx,
+    `${ONTOLOGY_QUERY_BASE}/${encodeURIComponent(knId)}/action-logs/${encodeURIComponent(logId)}`
+  );
+}
+function cancelActionLog(ctx, knId, logId) {
+  return request(
+    ctx,
+    `${ONTOLOGY_QUERY_BASE}/${encodeURIComponent(knId)}/action-logs/${encodeURIComponent(logId)}/cancel`,
+    { method: "POST" }
+  );
+}
+function queryObjectTypeInstances(ctx, knId, otId, body) {
+  return request(
+    ctx,
+    `${ONTOLOGY_QUERY_BASE}/${encodeURIComponent(knId)}/object-types/${encodeURIComponent(otId)}`,
+    { method: "POST", body }
+  );
+}
+function getObjectTypeProperties(ctx, knId, otId) {
+  return request(
+    ctx,
+    `${ONTOLOGY_QUERY_BASE}/${encodeURIComponent(knId)}/object-types/${encodeURIComponent(otId)}/properties`
+  );
+}
+function queryActionType(ctx, knId, atId, body) {
+  return request(
+    ctx,
+    `${ONTOLOGY_QUERY_BASE}/${encodeURIComponent(knId)}/action-types/${encodeURIComponent(atId)}/`,
+    { method: "POST", body }
+  );
+}
+function executeActionType(ctx, knId, atId, body) {
+  return request(
+    ctx,
+    `${ONTOLOGY_QUERY_BASE}/${encodeURIComponent(knId)}/action-types/${encodeURIComponent(atId)}/execute`,
+    { method: "POST", body }
+  );
+}
+function getActionTypeInputs(ctx, knId, atId) {
+  return request(
+    ctx,
+    `${ONTOLOGY_QUERY_BASE}/${encodeURIComponent(knId)}/action-types/${encodeURIComponent(atId)}/inputs`
+  );
+}
+function getActionExecution(ctx, knId, executionId) {
+  return request(
+    ctx,
+    `${ONTOLOGY_QUERY_BASE}/${encodeURIComponent(knId)}/action-executions/${encodeURIComponent(executionId)}`
+  );
+}
+function queryMetricData(ctx, knId, metricId, body) {
+  return request(
+    ctx,
+    `${ONTOLOGY_QUERY_BASE}/${encodeURIComponent(knId)}/metrics/${encodeURIComponent(metricId)}/data`,
+    { method: "POST", body }
+  );
+}
+function dryRunMetric(ctx, knId, body) {
+  return request(ctx, `${ONTOLOGY_QUERY_BASE}/${encodeURIComponent(knId)}/metrics/dry-run`, {
+    method: "POST",
+    body
+  });
+}
+function schemaListQuery(opts) {
+  return { branch: opts.branch ?? "main", limit: String(opts.limit ?? -1) };
+}
+function listObjectTypes(ctx, knId, opts = {}) {
+  return request(ctx, `${ONTOLOGY_BASE}/${encodeURIComponent(knId)}/object-types`, {
+    query: schemaListQuery(opts)
+  });
+}
+function createObjectTypes(ctx, knId, entries, branch = "main") {
+  return request(ctx, `${ONTOLOGY_BASE}/${encodeURIComponent(knId)}/object-types`, {
+    method: "POST",
+    query: { branch },
+    body: { entries }
+  });
+}
+function listRelationTypes(ctx, knId, opts = {}) {
+  return request(ctx, `${ONTOLOGY_BASE}/${encodeURIComponent(knId)}/relation-types`, {
+    query: schemaListQuery(opts)
+  });
+}
+function listActionTypes(ctx, knId, opts = {}) {
+  return request(ctx, `${ONTOLOGY_BASE}/${encodeURIComponent(knId)}/action-types`, {
+    query: schemaListQuery(opts)
+  });
+}
+function getSchemaItem(ctx, knId, kind, id) {
+  return request(
+    ctx,
+    `${ONTOLOGY_BASE}/${encodeURIComponent(knId)}/${kind}/${encodeURIComponent(id)}`
+  );
+}
+function createSchemaItem(ctx, knId, kind, body) {
+  return request(ctx, `${ONTOLOGY_BASE}/${encodeURIComponent(knId)}/${kind}`, {
+    method: "POST",
+    body
+  });
+}
+function updateSchemaItem(ctx, knId, kind, id, body) {
+  return request(
+    ctx,
+    `${ONTOLOGY_BASE}/${encodeURIComponent(knId)}/${kind}/${encodeURIComponent(id)}`,
+    {
+      method: "PUT",
+      body
+    }
+  );
+}
+function deleteSchemaItem(ctx, knId, kind, id) {
+  return request(
+    ctx,
+    `${ONTOLOGY_BASE}/${encodeURIComponent(knId)}/${kind}/${encodeURIComponent(id)}`,
+    {
+      method: "DELETE"
+    }
+  );
+}
+function listMetrics(ctx, knId, opts = {}) {
+  return request(ctx, `${ONTOLOGY_BASE}/${encodeURIComponent(knId)}/metrics`, {
+    query: { branch: opts.branch ?? "main", limit: String(opts.limit ?? -1) }
+  });
+}
+function getMetric(ctx, knId, metricId) {
+  return request(
+    ctx,
+    `${ONTOLOGY_BASE}/${encodeURIComponent(knId)}/metrics/${encodeURIComponent(metricId)}`
+  );
+}
+function createMetric(ctx, knId, body) {
+  return request(ctx, `${ONTOLOGY_BASE}/${encodeURIComponent(knId)}/metrics`, {
+    method: "POST",
+    body
+  });
+}
+function updateMetric(ctx, knId, metricId, body) {
+  return request(
+    ctx,
+    `${ONTOLOGY_BASE}/${encodeURIComponent(knId)}/metrics/${encodeURIComponent(metricId)}`,
+    {
+      method: "PUT",
+      body
+    }
+  );
+}
+function deleteMetric(ctx, knId, metricId) {
+  return request(
+    ctx,
+    `${ONTOLOGY_BASE}/${encodeURIComponent(knId)}/metrics/${encodeURIComponent(metricId)}`,
+    {
+      method: "DELETE"
+    }
+  );
+}
+function searchMetrics(ctx, knId, body) {
+  return request(ctx, `${ONTOLOGY_BASE}/${encodeURIComponent(knId)}/metrics/search`, {
+    method: "POST",
+    body
+  });
+}
+function validateMetric(ctx, knId, body) {
+  return request(ctx, `${ONTOLOGY_BASE}/${encodeURIComponent(knId)}/metrics/validate`, {
+    method: "POST",
+    body
+  });
+}
+function semanticSearch(ctx, knId, query, opts = {}) {
+  return request(ctx, `${RETRIEVAL_BASE}/semantic-search`, {
+    method: "POST",
+    body: {
+      kn_id: knId,
+      query,
+      mode: opts.mode ?? "keyword_vector_retrieval",
+      max_concepts: opts.maxConcepts ?? 10,
+      return_query_understanding: opts.returnQueryUnderstanding ?? false
+    }
+  });
+}
+
+// src/api/resources.ts
+var BASE3 = "/api/vega-backend/v1/resources";
+function listResources2(ctx, opts = {}) {
+  return request(ctx, BASE3, {
+    query: {
+      catalog_id: opts.datasourceId || void 0,
+      name: opts.name || void 0,
+      category: opts.category || void 0,
+      limit: opts.limit && opts.limit > 0 ? opts.limit : void 0
+    }
+  });
+}
+function getResource(ctx, id) {
+  return request(ctx, `${BASE3}/${encodeURIComponent(id)}`);
+}
+function createResourceRaw(ctx, body) {
+  return request(ctx, BASE3, { method: "POST", body });
+}
+function createResource(ctx, opts) {
+  const body = {
+    name: opts.name,
+    catalog_id: opts.catalogId,
+    category: "table",
+    source_identifier: opts.sourceIdentifier
+  };
+  if (opts.fields && opts.fields.length > 0) body.schema_definition = opts.fields;
+  return request(ctx, BASE3, { method: "POST", body });
+}
+function deleteResource(ctx, id) {
+  return request(ctx, `${BASE3}/${encodeURIComponent(id)}`, { method: "DELETE" });
+}
+async function findResource(ctx, name, opts = {}) {
+  const result = await listResources2(ctx, { name, datasourceId: opts.datasourceId });
+  const list = Array.isArray(result) ? result : result.entries ?? [];
+  return opts.exact ? list.filter((r) => r.name === name) : list;
+}
+function queryResource(ctx, id, opts = {}) {
+  return request(ctx, `${BASE3}/${encodeURIComponent(id)}/data`, {
+    method: "POST",
+    body: {
+      limit: opts.limit ?? 50,
+      offset: opts.offset ?? 0,
+      need_total: opts.needTotal ?? false
+    }
+  });
+}
+
+// src/templates/bkn/document/manifest.json
+var manifest_default = {
+  name: "document",
+  type: "bkn",
+  description: "\u6587\u6863\u77E5\u8BC6\u7F51\u7EDC",
+  arguments: [
+    { name: "name", required: true, description: "BKN \u540D\u79F0", type: "string" },
+    {
+      name: "embedding_model_id",
+      required: true,
+      description: "\u5411\u91CF\u5316\u6A21\u578B ID",
+      type: "string"
+    },
+    {
+      name: "content_dataset_id",
+      required: true,
+      description: "\u5185\u5BB9\u6570\u636E\u96C6 ID",
+      type: "string"
+    },
+    {
+      name: "document_dataset_id",
+      required: true,
+      description: "\u6587\u6863\u6570\u636E\u96C6 ID",
+      type: "string"
+    },
+    {
+      name: "element_dataset_id",
+      required: true,
+      description: "\u5143\u7D20\u6570\u636E\u96C6 ID",
+      type: "string"
+    }
+  ]
+};
+
+// src/templates/bkn/document/template.json
+var template_default = {
+  branch: "main",
+  business_domain: "bd_public",
+  color: "#0e5fc5",
+  detail: "---\ntype: knowledge_network\nname: {{name}}\ntags: []\nbranch: main\n---\n\n# {{name}}\n\n\n## Network Overview\n\n",
+  icon: "icon-dip-graph",
+  module_type: "knowledge_network",
+  name: "{{name}}",
+  object_types: [
+    {
+      branch: "main",
+      color: "#0e5fc5",
+      comment: "",
+      data_properties: [
+        {
+          comment: "",
+          condition_operations: [
+            "==",
+            "!=",
+            "in",
+            "not_in",
+            ">",
+            ">=",
+            "<",
+            "<=",
+            "range",
+            "out_range",
+            "regex",
+            "like",
+            "not_like"
+          ],
+          display_name: "deduplication_id",
+          index_config: {
+            fulltext_config: {
+              analyzer: "ik_max_word",
+              enabled: true
+            },
+            keyword_config: {
+              enabled: true,
+              ignore_above_len: 1024
+            },
+            vector_config: {
+              enabled: true,
+              model_id: "{{embedding_model_id}}"
+            }
+          },
+          mapped_field: {
+            display_name: "deduplication_id",
+            name: "deduplication_id",
+            type: "string"
+          },
+          name: "deduplication_id",
+          type: "string"
+        },
+        {
+          comment: "",
+          display_name: "document_id",
+          mapped_field: {
+            display_name: "document_id",
+            name: "document_id",
+            type: "string"
+          },
+          name: "document_id",
+          type: "string"
+        },
+        {
+          comment: "",
+          display_name: "img_path",
+          mapped_field: {
+            display_name: "img_path",
+            name: "img_path",
+            type: "string"
+          },
+          name: "img_path",
+          type: "string"
+        },
+        {
+          comment: "",
+          condition_operations: [
+            "==",
+            "!=",
+            "in",
+            "not_in",
+            ">",
+            ">=",
+            "<",
+            "<=",
+            "range",
+            "out_range",
+            "regex",
+            "like",
+            "not_like"
+          ],
+          display_name: "id",
+          index_config: {
+            fulltext_config: {
+              analyzer: "ik_max_word",
+              enabled: true
+            },
+            keyword_config: {
+              enabled: true,
+              ignore_above_len: 1024
+            },
+            vector_config: {
+              enabled: true,
+              model_id: "{{embedding_model_id}}"
+            }
+          },
+          mapped_field: {
+            display_name: "id",
+            name: "id",
+            type: "string"
+          },
+          name: "id",
+          type: "string"
+        },
+        {
+          comment: "",
+          condition_operations: [
+            "match",
+            "multi_match",
+            "==",
+            "!=",
+            "in",
+            "not_in",
+            ">",
+            ">=",
+            "<",
+            "<=",
+            "range",
+            "out_range",
+            "regex",
+            "like",
+            "not_like"
+          ],
+          display_name: "doc_name",
+          index_config: {
+            fulltext_config: {
+              analyzer: "ik_max_word",
+              enabled: true
+            },
+            keyword_config: {
+              enabled: true,
+              ignore_above_len: 1024
+            },
+            vector_config: {
+              enabled: true,
+              model_id: "{{embedding_model_id}}"
+            }
+          },
+          mapped_field: {
+            display_name: "doc_name",
+            name: "doc_name",
+            type: "text"
+          },
+          name: "doc_name",
+          type: "text"
+        },
+        {
+          comment: "",
+          display_name: "pages",
+          name: "pages",
+          type: "text"
+        },
+        {
+          comment: "",
+          condition_operations: [
+            "match",
+            "multi_match",
+            "==",
+            "!=",
+            "in",
+            "not_in",
+            ">",
+            ">=",
+            "<",
+            "<=",
+            "range",
+            "out_range",
+            "regex",
+            "like",
+            "not_like"
+          ],
+          display_name: "slice_content",
+          index_config: {
+            fulltext_config: {
+              analyzer: "ik_max_word",
+              enabled: true
+            },
+            keyword_config: {
+              enabled: true,
+              ignore_above_len: 1024
+            },
+            vector_config: {
+              enabled: true,
+              model_id: "{{embedding_model_id}}"
+            }
+          },
+          mapped_field: {
+            display_name: "slice_content",
+            name: "slice_content",
+            type: "text"
+          },
+          name: "slice_content",
+          type: "text"
+        },
+        {
+          comment: "",
+          display_name: "segment_id",
+          name: "segment_id",
+          type: "string"
+        },
+        {
+          comment: "",
+          display_name: "updated_at",
+          mapped_field: {
+            display_name: "updated_at",
+            name: "updated_at",
+            type: "datetime"
+          },
+          name: "updated_at",
+          type: "datetime"
+        },
+        {
+          comment: "",
+          display_name: "doc_md5",
+          mapped_field: {
+            display_name: "doc_md5",
+            name: "doc_md5",
+            type: "string"
+          },
+          name: "doc_md5",
+          type: "string"
+        },
+        {
+          comment: "",
+          display_name: "slice_type",
+          mapped_field: {
+            display_name: "slice_type",
+            name: "slice_type",
+            type: "integer"
+          },
+          name: "slice_type",
+          type: "integer"
+        },
+        {
+          comment: "",
+          display_name: "element_ids",
+          name: "element_ids",
+          type: "string"
+        },
+        {
+          comment: "",
+          display_name: "created_at",
+          mapped_field: {
+            display_name: "created_at",
+            name: "created_at",
+            type: "datetime"
+          },
+          name: "created_at",
+          type: "datetime"
+        },
+        {
+          comment: "",
+          display_name: "element_id",
+          name: "element_id",
+          type: "string"
+        },
+        {
+          comment: "",
+          display_name: "slice_md5",
+          mapped_field: {
+            display_name: "slice_md5",
+            name: "slice_md5",
+            type: "string"
+          },
+          name: "slice_md5",
+          type: "string"
+        },
+        {
+          comment: "",
+          display_name: "text_vector",
+          mapped_field: {
+            display_name: "text_vector",
+            name: "text_vector",
+            type: "vector"
+          },
+          name: "text_vector",
+          type: "vector"
+        },
+        {
+          comment: "",
+          display_name: "image_vector",
+          mapped_field: {
+            display_name: "image_vector",
+            name: "image_vector",
+            type: "vector"
+          },
+          name: "image_vector",
+          type: "vector"
+        }
+      ],
+      data_source: {
+        id: "{{content_dataset_id}}",
+        type: "resource"
+      },
+      display_key: "id",
+      icon: "icon-tianshenpi",
+      id: "d6sco6s2mlgikcusgpo0",
+      incremental_key: "",
+      kn_id: "d6scm5c2mlgikcusgpmg",
+      module_type: "object_type",
+      name: "\u6587\u6863\u7279\u5F81\u5BF9\u8C61",
+      primary_keys: ["id"],
+      tags: []
+    },
+    {
+      branch: "main",
+      color: "#0e5fc5",
+      comment: "",
+      data_properties: [
+        {
+          comment: "",
+          condition_operations: [
+            "match",
+            "multi_match",
+            "==",
+            "!=",
+            "in",
+            "not_in",
+            ">",
+            ">=",
+            "<",
+            "<=",
+            "range",
+            "out_range",
+            "regex",
+            "like",
+            "not_like"
+          ],
+          display_name: "doc_name",
+          index_config: {
+            fulltext_config: {
+              analyzer: "ik_max_word",
+              enabled: true
+            },
+            keyword_config: {
+              enabled: true,
+              ignore_above_len: 1024
+            },
+            vector_config: {
+              enabled: true,
+              model_id: "{{embedding_model_id}}"
+            }
+          },
+          mapped_field: {
+            display_name: "doc_name",
+            name: "doc_name",
+            type: "text"
+          },
+          name: "doc_name",
+          type: "text"
+        },
+        {
+          comment: "",
+          condition_operations: [
+            "==",
+            "!=",
+            "in",
+            "not_in",
+            ">",
+            ">=",
+            "<",
+            "<=",
+            "range",
+            "out_range",
+            "regex",
+            "like",
+            "not_like"
+          ],
+          display_name: "document_id",
+          index_config: {
+            fulltext_config: {
+              analyzer: "",
+              enabled: false
+            },
+            keyword_config: {
+              enabled: true,
+              ignore_above_len: 1024
+            },
+            vector_config: {
+              enabled: false,
+              model_id: ""
+            }
+          },
+          mapped_field: {
+            display_name: "document_id",
+            name: "document_id",
+            type: "string"
+          },
+          name: "document_id",
+          type: "string"
+        },
+        {
+          comment: "",
+          display_name: "rev",
+          mapped_field: {
+            display_name: "rev",
+            name: "rev",
+            type: "text"
+          },
+          name: "rev",
+          type: "text"
+        }
+      ],
+      data_source: {
+        id: "{{document_dataset_id}}",
+        type: "resource"
+      },
+      display_key: "doc_name",
+      icon: "icon-tianshenpi",
+      id: "d6scpd42mlgikcusgpp0",
+      incremental_key: "",
+      kn_id: "d6scm5c2mlgikcusgpmg",
+      module_type: "object_type",
+      name: "\u6587\u6863\u5BF9\u8C61",
+      primary_keys: ["document_id"],
+      tags: []
+    },
+    {
+      branch: "main",
+      color: "#0e5fc5",
+      comment: "",
+      data_properties: [
+        {
+          comment: "",
+          display_name: "reading_order",
+          mapped_field: {
+            display_name: "reading_order",
+            name: "reading_order",
+            type: "integer"
+          },
+          name: "reading_order",
+          type: "integer"
+        },
+        {
+          comment: "",
+          display_name: "bbox_height",
+          name: "bbox_height",
+          type: "integer"
+        },
+        {
+          comment: "",
+          display_name: "bbox_x",
+          name: "bbox_x",
+          type: "integer"
+        },
+        {
+          comment: "",
+          display_name: "modal_type",
+          mapped_field: {
+            display_name: "modal_type",
+            name: "modal_type",
+            type: "text"
+          },
+          name: "modal_type",
+          type: "text"
+        },
+        {
+          comment: "",
+          display_name: "bbox_y",
+          name: "bbox_y",
+          type: "integer"
+        },
+        {
+          comment: "",
+          display_name: "page_no",
+          name: "page_no",
+          type: "string"
+        },
+        {
+          comment: "",
+          display_name: "metadata_source_format",
+          name: "metadata_source_format",
+          type: "text"
+        },
+        {
+          comment: "",
+          display_name: "structure_html",
+          name: "structure_html",
+          type: "text"
+        },
+        {
+          comment: "",
+          display_name: "lat_lon",
+          mapped_field: {
+            display_name: "lat_lon",
+            name: "lat_lon",
+            type: "point"
+          },
+          name: "lat_lon",
+          type: "point"
+        },
+        {
+          comment: "",
+          display_name: "metadata_deduplication_id",
+          name: "metadata_deduplication_id",
+          type: "string"
+        },
+        {
+          comment: "",
+          display_name: "element_id",
+          mapped_field: {
+            display_name: "element_id",
+            name: "element_id",
+            type: "string"
+          },
+          name: "element_id",
+          type: "string"
+        },
+        {
+          comment: "",
+          display_name: "level",
+          mapped_field: {
+            display_name: "level",
+            name: "level",
+            type: "integer"
+          },
+          name: "level",
+          type: "integer"
+        },
+        {
+          comment: "",
+          display_name: "element_type",
+          mapped_field: {
+            display_name: "element_type",
+            name: "element_type",
+            type: "text"
+          },
+          name: "element_type",
+          type: "text"
+        },
+        {
+          comment: "",
+          display_name: "bbox_width",
+          name: "bbox_width",
+          type: "string"
+        },
+        {
+          comment: "",
+          display_name: "document_id",
+          mapped_field: {
+            display_name: "document_id",
+            name: "document_id",
+            type: "string"
+          },
+          name: "document_id",
+          type: "string"
+        },
+        {
+          comment: "",
+          condition_operations: [
+            "match",
+            "multi_match",
+            "==",
+            "!=",
+            "in",
+            "not_in",
+            ">",
+            ">=",
+            "<",
+            "<=",
+            "range",
+            "out_range",
+            "regex",
+            "like",
+            "not_like"
+          ],
+          display_name: "content",
+          index_config: {
+            fulltext_config: {
+              analyzer: "ik_max_word",
+              enabled: true
+            },
+            keyword_config: {
+              enabled: false,
+              ignore_above_len: 1024
+            },
+            vector_config: {
+              enabled: true,
+              model_id: "{{embedding_model_id}}"
+            }
+          },
+          mapped_field: {
+            display_name: "content",
+            name: "content",
+            type: "text"
+          },
+          name: "content",
+          type: "text"
+        },
+        {
+          comment: "",
+          display_name: "img_path",
+          name: "img_path",
+          type: "string"
+        },
+        {
+          comment: "",
+          display_name: "parent_element_id",
+          mapped_field: {
+            display_name: "parent_element_id",
+            name: "parent_element_id",
+            type: "string"
+          },
+          name: "parent_element_id",
+          type: "string"
+        },
+        {
+          comment: "",
+          display_name: "@timestamp",
+          mapped_field: {
+            display_name: "@timestamp",
+            name: "@timestamp",
+            type: "integer"
+          },
+          name: "timestamp",
+          type: "integer"
+        },
+        {
+          comment: "",
+          display_name: "style",
+          mapped_field: {
+            display_name: "style",
+            name: "style"
+          },
+          name: "style",
+          type: ""
+        }
+      ],
+      data_source: {
+        id: "{{element_dataset_id}}",
+        type: "resource"
+      },
+      display_key: "element_id",
+      icon: "icon-tianshenpi",
+      id: "d6scrvk2mlgikcusgpq0",
+      incremental_key: "",
+      kn_id: "d6scm5c2mlgikcusgpmg",
+      module_type: "object_type",
+      name: "\u6587\u6863\u89E3\u6790\u6811\u5BF9\u8C61",
+      primary_keys: ["element_id"],
+      tags: []
+    }
+  ],
+  operations: [
+    "task_manage",
+    "import",
+    "export",
+    "create",
+    "delete",
+    "data_query",
+    "view_detail",
+    "modify",
+    "authorize"
+  ],
+  relation_types: [
+    {
+      branch: "main",
+      color: "",
+      comment: "",
+      icon: "",
+      id: "d6se2d42mlgikcusgpr0",
+      kn_id: "d6scm5c2mlgikcusgpmg",
+      mapping_rules: [
+        {
+          source_property: {
+            display_name: "document_id",
+            name: "document_id"
+          },
+          target_property: {
+            display_name: "document_id",
+            name: "document_id"
+          }
+        }
+      ],
+      module_type: "relation_type",
+      name: "\u6587\u6863\u5305\u542B\u7279\u5F81",
+      source_object_type: {
+        branch: "",
+        color: "",
+        icon: "",
+        id: "",
+        name: ""
+      },
+      source_object_type_id: "d6scpd42mlgikcusgpp0",
+      tags: [],
+      target_object_type: {
+        branch: "",
+        color: "",
+        icon: "",
+        id: "",
+        name: ""
+      },
+      target_object_type_id: "d6scrvk2mlgikcusgpq0",
+      type: "direct"
+    },
+    {
+      branch: "main",
+      color: "",
+      comment: "",
+      icon: "",
+      id: "d6se2jc2mlgikcusgps0",
+      kn_id: "d6scm5c2mlgikcusgpmg",
+      mapping_rules: [
+        {
+          source_property: {
+            display_name: "document_id",
+            name: "document_id"
+          },
+          target_property: {
+            display_name: "document_id",
+            name: "document_id"
+          }
+        }
+      ],
+      module_type: "relation_type",
+      name: "\u7279\u5F81\u5173\u8054\u5143\u7D20",
+      source_object_type: {
+        branch: "",
+        color: "",
+        icon: "",
+        id: "",
+        name: ""
+      },
+      source_object_type_id: "d6sco6s2mlgikcusgpo0",
+      tags: [],
+      target_object_type: {
+        branch: "",
+        color: "",
+        icon: "",
+        id: "",
+        name: ""
+      },
+      target_object_type_id: "d6scrvk2mlgikcusgpq0",
+      type: "direct"
+    }
+  ],
+  tags: [],
+  validate_dependency: false
+};
+
+// src/templates/dataflow/unstructured/manifest.json
+var manifest_default2 = {
+  name: "unstructured",
+  type: "dataflow",
+  description: "\u975E\u7ED3\u6784\u5316\u6587\u6863\u5904\u7406\u6D41\u7A0B",
+  arguments: [
+    { name: "title", required: true, description: "\u6570\u636E\u6D41\u6807\u9898", type: "string" },
+    {
+      name: "content_dataset_id",
+      required: true,
+      description: "\u5185\u5BB9\u6570\u636E\u96C6 ID",
+      type: "string"
+    },
+    {
+      name: "document_dataset_id",
+      required: true,
+      description: "\u6587\u6863\u6570\u636E\u96C6 ID",
+      type: "string"
+    },
+    {
+      name: "element_dataset_id",
+      required: true,
+      description: "\u5143\u7D20\u6570\u636E\u96C6 ID",
+      type: "string"
+    }
+  ]
+};
+
+// src/templates/dataflow/unstructured/template.json
+var template_default2 = {
+  title: "{{title}}",
+  steps: [
+    {
+      id: "0",
+      title: "",
+      operator: "@trigger/dataflow-doc"
+    },
+    {
+      id: "1",
+      title: "",
+      operator: "@content/file_parse",
+      parameters: {
+        docid: "{{__0.id}}",
+        model: "embedding",
+        slice_vector: "slice_vector",
+        source_type: "docid",
+        version: "{{__0.rev}}"
+      }
+    },
+    {
+      id: "1001",
+      title: "\u5199\u5165\u5411\u91CF",
+      operator: "@dataset/write-docs",
+      parameters: {
+        dataset_id: "{{content_dataset_id}}",
+        documents: "{{__1.chunks}}"
+      }
+    },
+    {
+      id: "1002",
+      title: "\u5199\u5165\u5143\u7D20",
+      operator: "@dataset/write-docs",
+      parameters: {
+        dataset_id: "{{element_dataset_id}}",
+        documents: "{{__1.content_list}}"
+      }
+    },
+    {
+      id: "1003",
+      title: "\u5199\u5165\u6587\u4EF6\u5143\u4FE1\u606F",
+      operator: "@dataset/write-docs",
+      parameters: {
+        dataset_id: "{{document_dataset_id}}",
+        documents: [
+          {
+            document_id: "{{__0.id}}",
+            doc_name: "{{__0.name}}"
+          }
+        ]
+      }
+    }
+  ],
+  trigger_config: {
+    operator: "@trigger/manual",
+    dataSource: {
+      operator: "",
+      parameters: {
+        accessorid: "00000000-0000-0000-0000-000000000000"
+      }
+    }
+  }
+};
+
+// src/templates/dataset/document-content/manifest.json
+var manifest_default3 = {
+  name: "document-content",
+  type: "dataset",
+  description: "\u6587\u6863\u5207\u7247\u53CA\u5411\u91CF\u6570\u636E\u96C6",
+  arguments: [
+    { name: "name", required: true, description: "\u6570\u636E\u96C6\u540D\u79F0", type: "string" },
+    {
+      name: "catalog_id",
+      required: false,
+      default: "adp_bkn_catalog",
+      description: "\u6240\u5C5E\u76EE\u5F55ID",
+      type: "string"
+    },
+    {
+      name: "source_identifier",
+      required: false,
+      default: "",
+      description: "\u6570\u636E\u6E90\u6807\u8BC6\u7B26\uFF0C\u4E3A\u7A7A\u65F6\u81EA\u52A8\u751F\u6210",
+      type: "string"
+    }
+  ]
+};
+
+// src/templates/dataset/document-content/template.json
+var template_default3 = {
+  catalog_id: "{{catalog_id}}",
+  name: "{{name}}",
+  category: "dataset",
+  status: "active",
+  description: "\u6587\u6863\u5207\u7247\u53CA\u5411\u91CF\u6570\u636E\u96C6",
+  source_identifier: "{{source_identifier}}",
+  schema_definition: [
+    { name: "id", type: "keyword" },
+    { name: "document_id", type: "keyword" },
+    { name: "slice_md5", type: "keyword" },
+    { name: "deduplication_id", type: "keyword" },
+    { name: "segment_id", type: "integer" },
+    { name: "slice_type", type: "integer" },
+    {
+      name: "slice_content",
+      type: "text",
+      features: [
+        {
+          name: "slice_content_fulltext",
+          feature_type: "fulltext",
+          ref_property: "slice_content",
+          config: { analyzer: "standard" }
+        }
+      ]
+    },
+    {
+      name: "text_vector",
+      type: "vector",
+      features: [
+        {
+          name: "text_vector",
+          feature_type: "vector",
+          ref_property: "text_vector",
+          config: {
+            dimension: 768,
+            method: {
+              name: "hnsw",
+              engine: "lucene",
+              parameters: { ef_construction: 256 }
+            }
+          }
+        }
+      ]
+    },
+    { name: "img_path", type: "keyword" },
+    {
+      name: "image_vector",
+      type: "vector",
+      features: [
+        {
+          name: "image_vector",
+          feature_type: "vector",
+          ref_property: "image_vector",
+          config: {
+            dimension: 512,
+            method: {
+              name: "hnsw",
+              engine: "lucene",
+              parameters: { ef_construction: 256 }
+            }
+          }
+        }
+      ]
+    },
+    { name: "created_at", type: "text" },
+    { name: "updated_at", type: "text" },
+    { name: "@timestamp", type: "long" }
+  ]
+};
+
+// src/templates/dataset/document-element/manifest.json
+var manifest_default4 = {
+  name: "document-element",
+  type: "dataset",
+  description: "\u6587\u6863\u7ED3\u6784\u5316\u5143\u7D20\u6570\u636E\u96C6",
+  arguments: [
+    { name: "name", required: true, description: "\u6570\u636E\u96C6\u540D\u79F0", type: "string" },
+    {
+      name: "catalog_id",
+      required: false,
+      default: "adp_bkn_catalog",
+      description: "\u6240\u5C5E\u76EE\u5F55ID",
+      type: "string"
+    },
+    {
+      name: "source_identifier",
+      required: false,
+      default: "",
+      description: "\u6570\u636E\u6E90\u6807\u8BC6\u7B26\uFF0C\u4E3A\u7A7A\u65F6\u81EA\u52A8\u751F\u6210",
+      type: "string"
+    }
+  ]
+};
+
+// src/templates/dataset/document-element/template.json
+var template_default4 = {
+  catalog_id: "{{catalog_id}}",
+  name: "{{name}}",
+  category: "dataset",
+  status: "active",
+  description: "\u6587\u6863\u7ED3\u6784\u5316\u5143\u7D20\u6570\u636E\u96C6",
+  source_identifier: "{{source_identifier}}",
+  schema_definition: [
+    { name: "id", type: "keyword" },
+    { name: "element_id", type: "keyword" },
+    { name: "document_id", type: "keyword" },
+    { name: "element_type", type: "keyword" },
+    { name: "parent_id", type: "keyword" },
+    { name: "level", type: "integer" },
+    {
+      name: "content",
+      type: "text",
+      features: [
+        {
+          name: "content_fulltext",
+          feature_type: "fulltext",
+          ref_property: "content",
+          config: { analyzer: "standard" }
+        }
+      ]
+    },
+    { name: "metadata", type: "object" },
+    { name: "@timestamp", type: "long" }
+  ]
+};
+
+// src/templates/dataset/document/manifest.json
+var manifest_default5 = {
+  name: "document",
+  type: "dataset",
+  description: "\u6587\u6863\u5143\u4FE1\u606F\u6570\u636E\u96C6",
+  arguments: [
+    { name: "name", required: true, description: "\u6570\u636E\u96C6\u540D\u79F0", type: "string" },
+    {
+      name: "catalog_id",
+      required: false,
+      default: "adp_bkn_catalog",
+      description: "\u6240\u5C5E\u76EE\u5F55ID",
+      type: "string"
+    },
+    {
+      name: "source_identifier",
+      required: false,
+      default: "",
+      description: "\u6570\u636E\u6E90\u6807\u8BC6\u7B26\uFF0C\u4E3A\u7A7A\u65F6\u81EA\u52A8\u751F\u6210",
+      type: "string"
+    }
+  ]
+};
+
+// src/templates/dataset/document/template.json
+var template_default5 = {
+  catalog_id: "{{catalog_id}}",
+  name: "{{name}}",
+  category: "dataset",
+  status: "active",
+  description: "\u6587\u6863\u5143\u4FE1\u606F\u6570\u636E\u96C6",
+  source_identifier: "{{source_identifier}}",
+  schema_definition: [
+    { name: "id", type: "keyword" },
+    { name: "document_id", type: "keyword" },
+    {
+      name: "doc_name",
+      type: "text",
+      features: [
+        { name: "doc_name_keyword", feature_type: "keyword", ref_property: "doc_name" },
+        {
+          name: "doc_name_fulltext",
+          feature_type: "fulltext",
+          ref_property: "doc_name",
+          config: { analyzer: "standard" }
+        }
+      ]
+    },
+    { name: "doc_md5", type: "keyword" },
+    { name: "pages", type: "integer" },
+    { name: "file_type", type: "keyword" },
+    { name: "creator_id", type: "keyword" },
+    { name: "created_at", type: "text" },
+    { name: "updated_at", type: "text" },
+    { name: "@timestamp", type: "long" }
+  ]
+};
+
+// src/utils/dataflow-templates.ts
+var REGISTRY = {
+  dataset: {
+    document: {
+      manifest: manifest_default5,
+      template: template_default5
+    },
+    "document-content": {
+      manifest: manifest_default3,
+      template: template_default3
+    },
+    "document-element": {
+      manifest: manifest_default4,
+      template: template_default4
+    }
+  },
+  bkn: {
+    document: {
+      manifest: manifest_default,
+      template: template_default
+    }
+  },
+  dataflow: {
+    unstructured: {
+      manifest: manifest_default2,
+      template: template_default2
+    }
+  }
+};
+function loadTemplate(type, name) {
+  return REGISTRY[type]?.[name] ?? null;
+}
+function listTemplates() {
+  const out = [];
+  for (const type of Object.keys(REGISTRY)) {
+    for (const [name, t] of Object.entries(REGISTRY[type])) {
+      out.push({
+        type,
+        name,
+        description: t.manifest.description,
+        arguments: t.manifest.arguments
+      });
+    }
+  }
+  return out;
+}
+function generateSourceIdentifier(prefix) {
+  return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 12)}`;
+}
+function interpolate(s, values) {
+  return s.replace(
+    /\{\{(\w+)\}\}/g,
+    (_m, k) => values[k] !== void 0 ? String(values[k]) : `{{${k}}}`
+  );
+}
+function deepReplace(obj, values) {
+  if (typeof obj === "string") return interpolate(obj, values);
+  if (Array.isArray(obj)) return obj.map((x) => deepReplace(x, values));
+  if (obj && typeof obj === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(obj))
+      out[k] = deepReplace(v, values);
+    return out;
+  }
+  return obj;
+}
+function renderTemplate(t, args) {
+  const merged = {};
+  const missing = [];
+  for (const arg of t.manifest.arguments) {
+    if (args[arg.name] !== void 0) merged[arg.name] = args[arg.name];
+    else if (arg.default !== void 0) merged[arg.name] = arg.default;
+    else if (arg.required) missing.push(arg.name);
+  }
+  if (missing.length > 0) throw new Error(`Missing required argument(s): ${missing.join(", ")}`);
+  return deepReplace(t.template, merged);
+}
+
+// src/resources/dataflows.ts
+function instantiate(type, name, args) {
+  const t = loadTemplate(type, name);
+  if (!t) throw new Error(`Template not found: ${type}/${name}`);
+  const merged = { ...args };
+  if (type === "dataset" && !merged.source_identifier) {
+    merged.source_identifier = generateSourceIdentifier(`dataflow_${t.manifest.name}`);
+  }
+  return renderTemplate(t, merged);
+}
+function dataflows(ctx) {
+  return {
+    list: () => listDataflows(ctx),
+    runs: (dagId, opts) => listDataflowRuns(ctx, dagId, opts),
+    logs: (dagId, instanceId, opts) => getDataflowLogs(ctx, dagId, instanceId, opts),
+    run: (dagId, url, name) => runDataflowRemote(ctx, dagId, url, name),
+    create: (body) => createDataflow(ctx, body),
+    templates: () => listTemplates(),
+    /** Instantiate a dataset template → create a vega resource. */
+    createDataset: (template, args) => createResourceRaw(ctx, instantiate("dataset", template, args)),
+    /** Instantiate a bkn template → create a knowledge network. */
+    createBkn: (template, args) => createKnowledgeNetworkRaw(ctx, instantiate("bkn", template, args))
+  };
+}
+
+// src/resources/knowledge-networks.ts
+import { mkdirSync as mkdirSync2 } from "fs";
+import { resolve as resolve3 } from "path";
+
+// src/api/bkn-backend.ts
+var BASE4 = "/api/bkn-backend/v1/knowledge-networks";
+var BKNS = "/api/bkn-backend/v1/bkns";
+function knPath(knId, path) {
+  return `${BASE4}/${encodeURIComponent(knId)}/${path}`;
+}
+async function uploadBkn(ctx, tarBuffer, opts = {}) {
+  applyTls(ctx);
+  const url = new URL(`${ctx.baseUrl}${BKNS}`);
+  url.searchParams.set("branch", opts.branch ?? "main");
+  const form = new FormData();
+  form.append(
+    "file",
+    new Blob([new Uint8Array(tarBuffer)], { type: "application/octet-stream" }),
+    "bkn.tar"
+  );
+  const res = await fetch(url, { method: "POST", headers: buildHeaders(ctx), body: form });
+  const text = await res.text();
+  if (!res.ok) throw new HttpError(res.status, res.statusText, text);
+  return text ? JSON.parse(text) : void 0;
+}
+async function downloadBkn(ctx, knId, opts = {}) {
+  applyTls(ctx);
+  const url = new URL(`${ctx.baseUrl}${BKNS}/${encodeURIComponent(knId)}`);
+  url.searchParams.set("branch", opts.branch ?? "main");
+  const res = await fetch(url, { method: "GET", headers: buildHeaders(ctx) });
+  if (!res.ok) throw new HttpError(res.status, res.statusText, await res.text());
+  return Buffer.from(await res.arrayBuffer());
+}
+function listBknResources(ctx) {
+  return request(ctx, "/api/bkn-backend/v1/resources");
+}
+function relationTypePaths(ctx, knId, body) {
+  return request(ctx, knPath(knId, "relation-type-paths"), { method: "POST", body });
+}
+function listConceptGroups(ctx, knId) {
+  return request(ctx, knPath(knId, "concept-groups"));
+}
+function getConceptGroup(ctx, knId, cgId) {
+  return request(ctx, knPath(knId, `concept-groups/${encodeURIComponent(cgId)}`));
+}
+function createConceptGroup(ctx, knId, body) {
+  return request(ctx, knPath(knId, "concept-groups"), { method: "POST", body });
+}
+function updateConceptGroup(ctx, knId, cgId, body) {
+  return request(ctx, knPath(knId, `concept-groups/${encodeURIComponent(cgId)}`), {
+    method: "PUT",
+    body
+  });
+}
+function deleteConceptGroup(ctx, knId, cgId) {
+  return request(ctx, knPath(knId, `concept-groups/${encodeURIComponent(cgId)}`), {
+    method: "DELETE"
+  });
+}
+function addConceptGroupMembers(ctx, knId, cgId, body) {
+  return request(ctx, knPath(knId, `concept-groups/${encodeURIComponent(cgId)}/object-types`), {
+    method: "POST",
+    body
+  });
+}
+function removeConceptGroupMembers(ctx, knId, cgId, otIds) {
+  return request(
+    ctx,
+    knPath(knId, `concept-groups/${encodeURIComponent(cgId)}/object-types/${otIds}`),
+    {
+      method: "DELETE"
+    }
+  );
+}
+function listActionSchedules(ctx, knId) {
+  return request(ctx, knPath(knId, "action-schedules"));
+}
+function getActionSchedule(ctx, knId, scheduleId) {
+  return request(ctx, knPath(knId, `action-schedules/${encodeURIComponent(scheduleId)}`));
+}
+function createActionSchedule(ctx, knId, body) {
+  return request(ctx, knPath(knId, "action-schedules"), { method: "POST", body });
+}
+function updateActionSchedule(ctx, knId, scheduleId, body) {
+  return request(ctx, knPath(knId, `action-schedules/${encodeURIComponent(scheduleId)}`), {
+    method: "PUT",
+    body
+  });
+}
+function setActionScheduleStatus(ctx, knId, scheduleId, body) {
+  return request(ctx, knPath(knId, `action-schedules/${encodeURIComponent(scheduleId)}/status`), {
+    method: "PUT",
+    body
+  });
+}
+function deleteActionSchedules(ctx, knId, ids) {
+  return request(ctx, knPath(knId, `action-schedules/${ids}`), { method: "DELETE" });
+}
+function listJobs(ctx, knId) {
+  return request(ctx, knPath(knId, "jobs"));
+}
+function getJob(ctx, knId, jobId) {
+  return request(ctx, knPath(knId, `jobs/${encodeURIComponent(jobId)}`));
+}
+function getJobTasks(ctx, knId, jobId) {
+  return request(ctx, knPath(knId, `jobs/${encodeURIComponent(jobId)}/tasks`));
+}
+function deleteJobs(ctx, knId, ids) {
+  return request(ctx, knPath(knId, `jobs/${ids}`), { method: "DELETE" });
+}
+
+// src/utils/tar.ts
+import { spawnSync } from "child_process";
+import { resolve } from "path";
+var TAR_MISSING = "tar executable not found. On Windows, ensure tar.exe is in PATH (ships with Windows 10 1803+) or install GNU tar via Git for Windows / scoop.";
+function packDirectoryToTar(dirPath) {
+  const abs = resolve(dirPath);
+  const result = spawnSync("tar", ["cf", "-", "-C", abs, "."], {
+    maxBuffer: 1024 * 1024 * 512,
+    env: { ...process.env, COPYFILE_DISABLE: "1" }
+  });
+  if (result.error && result.error.code === "ENOENT") {
+    throw new Error(TAR_MISSING);
+  }
+  if (result.status !== 0) {
+    throw new Error(`tar pack failed: ${result.stderr?.toString() ?? result.status}`);
+  }
+  return result.stdout;
+}
+function extractTarToDirectory(tarBuffer, dirPath) {
+  const abs = resolve(dirPath);
+  const result = spawnSync("tar", ["xf", "-", "-C", abs], {
+    input: tarBuffer,
+    maxBuffer: 1024 * 1024 * 512
+  });
+  if (result.error && result.error.code === "ENOENT") {
+    throw new Error(TAR_MISSING);
+  }
+  if (result.status !== 0) {
+    throw new Error(`tar extract failed: ${result.stderr?.toString() ?? result.status}`);
+  }
+}
+
+// src/api/vega.ts
+import { z } from "zod";
+var VEGA_BASE = "/api/vega-backend/v1";
+var BuildMode = z.enum(["batch", "streaming"]);
+var CreateBuildTaskRequest = z.object({
+  resource_id: z.string().min(1),
+  mode: BuildMode,
+  embedding_fields: z.array(z.string()).optional(),
+  build_key_fields: z.array(z.string()).optional(),
+  embedding_model: z.string().optional(),
+  model_dimensions: z.number().int().positive().optional()
+});
+var BuildTask = z.object({
+  id: z.string(),
+  resource_id: z.string(),
+  mode: BuildMode,
+  state: z.string().optional(),
+  synced_count: z.number().optional(),
+  vectorized_count: z.number().optional()
+});
+async function createBuildTask(ctx, req) {
+  const body = CreateBuildTaskRequest.parse(req);
+  const res = await request(ctx, `${VEGA_BASE}/build-tasks`, { method: "POST", body });
+  return BuildTask.parse(res);
+}
+async function getBuildTask(ctx, taskId) {
+  const res = await request(ctx, `${VEGA_BASE}/build-tasks/${encodeURIComponent(taskId)}`);
+  return BuildTask.parse(res);
+}
+async function listCatalogs(ctx, opts = {}) {
+  return request(ctx, `${VEGA_BASE}/catalogs`, {
+    query: { limit: opts.limit, offset: opts.offset }
+  });
+}
+function getCatalog(ctx, id) {
+  return request(ctx, `${VEGA_BASE}/catalogs/${encodeURIComponent(id)}`);
+}
+function discoverCatalog(ctx, id, wait = true) {
+  return request(ctx, `${VEGA_BASE}/catalogs/${encodeURIComponent(id)}/discover`, {
+    method: "POST",
+    query: { wait },
+    timeoutMs: 12e4
+  });
+}
+function listCatalogResources(ctx, id, category) {
+  return request(ctx, `${VEGA_BASE}/catalogs/${encodeURIComponent(id)}/resources`, {
+    query: { category: category || void 0 }
+  });
+}
+function catalogHealthStatus(ctx, ids) {
+  return request(
+    ctx,
+    `${VEGA_BASE}/catalogs/${ids.map(encodeURIComponent).join(",")}/health-status`
+  );
+}
+function listConnectorTypes(ctx) {
+  return request(ctx, `${VEGA_BASE}/connector-types`, { query: { sort: "name", order: "asc" } });
+}
+function getConnectorType(ctx, type) {
+  return request(ctx, `${VEGA_BASE}/connector-types/${encodeURIComponent(type)}`);
+}
+
+// src/utils/csv-import.ts
+import { statSync } from "fs";
+import { glob, readFile } from "fs/promises";
+import { basename, resolve as resolve2 } from "path";
+import { parse } from "csv-parse/sync";
+async function parseCsvFile(filePath) {
+  let content = await readFile(filePath, "utf8");
+  if (content.charCodeAt(0) === 65279) content = content.slice(1);
+  const records = parse(content, {
+    columns: true,
+    skip_empty_lines: true,
+    trim: true,
+    relax_column_count: false
+  });
+  if (records.length === 0) {
+    const headerRows = parse(content, {
+      columns: false,
+      skip_empty_lines: false,
+      trim: true,
+      to: 1
+    });
+    return { headers: headerRows[0] ?? [], rows: [] };
+  }
+  const headers2 = Object.keys(records[0]);
+  const rows = records.map((rec) => {
+    const row = {};
+    for (const k of headers2) row[k] = rec[k] === "" ? null : rec[k] ?? null;
+    return row;
+  });
+  return { headers: headers2, rows };
+}
+function buildTableName(filePath, prefix = "") {
+  const stem = basename(filePath).replace(/\.csv$/i, "");
+  return `${prefix}${stem}`.replace(/[^a-zA-Z0-9_]/g, "_").replace(/^(\d)/, "_$1");
+}
+function splitBatches(rows, batchSize) {
+  const out = [];
+  for (let i = 0; i < rows.length; i += batchSize) out.push(rows.slice(i, i + batchSize));
+  return out;
+}
+function buildFieldMappings(headers2) {
+  return headers2.map((name) => ({ source: { name }, target: { name, data_type: "VARCHAR(512)" } }));
+}
+function buildImportDag(opts) {
+  return {
+    title: `import-csv-${opts.tableName}`,
+    description: `CSV import into table ${opts.tableName}`,
+    trigger_config: { operator: "@internal/trigger/manual" },
+    steps: [
+      { id: "step-trigger", title: "Trigger", operator: "@trigger/manual", parameters: {} },
+      {
+        id: "step-write",
+        title: "Write to Database",
+        operator: "@internal/database/write",
+        parameters: {
+          datasource_type: opts.datasourceType,
+          datasource_id: opts.catalogId,
+          table_name: opts.tableName,
+          table_exist: opts.tableExist,
+          operate_type: "append",
+          data: opts.data,
+          sync_model_fields: opts.fieldMappings
+        }
+      }
+    ]
+  };
+}
+async function resolveFiles(pattern) {
+  const out = [];
+  for (const part of pattern.split(",").map((p) => p.trim()).filter(Boolean)) {
+    if (part.includes("*") || part.includes("?")) {
+      for await (const entry of glob(part)) {
+        const p = String(entry);
+        if (/\.csv$/i.test(p)) out.push(resolve2(p));
+      }
+    } else {
+      statSync(resolve2(part));
+      out.push(resolve2(part));
+    }
+  }
+  if (out.length === 0) throw new Error(`No CSV files matched: ${pattern}`);
+  return out;
+}
+
+// src/utils/pk-detection.ts
+var PK_NAME_HINTS = ["id", "_id", "pk"];
+var DISPLAY_HINTS = ["name", "title", "label", "display_name", "description"];
+function detectPrimaryKey(table, rows) {
+  if (!rows || rows.length === 0) return { pk: null, candidates: [], sampleSize: 0 };
+  const candidates = table.columns.map((col) => ({ name: col.name, cardinality: new Set(rows.map((r) => r[col.name])).size })).sort((a, b) => b.cardinality - a.cardinality);
+  const full = candidates.filter((c) => c.cardinality === rows.length);
+  if (full.length === 0) return { pk: null, candidates, sampleSize: rows.length };
+  const named = full.find((c) => {
+    const lower = c.name.toLowerCase();
+    return PK_NAME_HINTS.some((h) => lower === h || lower.endsWith(`_${h}`));
+  });
+  return { pk: named?.name ?? full[0].name, candidates, sampleSize: rows.length };
+}
+function collectSchemaPks(table) {
+  const colNames = new Set(table.columns.map((c) => c.name));
+  if (Array.isArray(table.primaryKeys) && table.primaryKeys.length > 0) {
+    return table.primaryKeys.filter((n) => colNames.has(n));
+  }
+  return table.columns.filter((c) => c.isPrimaryKey === true).map((c) => c.name);
+}
+function resolvePrimaryKey(table, sampleRows2, override) {
+  if (override) return { pk: override, source: "override" };
+  const schemaPks = collectSchemaPks(table);
+  if (schemaPks.length === 1) return { pk: schemaPks[0], source: "schema" };
+  if (schemaPks.length > 1) return { pk: null, source: "ambiguous", ambiguous: schemaPks };
+  const sample = detectPrimaryKey(table, sampleRows2);
+  return {
+    pk: sample.pk,
+    source: "sample",
+    candidates: sample.candidates,
+    sampleSize: sample.sampleSize
+  };
+}
+function detectDisplayKey(table, primaryKey) {
+  for (const col of table.columns) {
+    if (DISPLAY_HINTS.some((h) => col.name.toLowerCase().includes(h))) return col.name;
+  }
+  return primaryKey;
+}
+function parsePkMap(input) {
+  const out = {};
+  for (const pair of input.split(",").map((s) => s.trim()).filter(Boolean)) {
+    const idx = pair.indexOf(":");
+    if (idx <= 0 || idx >= pair.length - 1) {
+      throw new Error(`Invalid --pk-map entry '${pair}'. Expected '<table>:<field>[,...]'`);
+    }
+    out[pair.slice(0, idx).trim()] = pair.slice(idx + 1).trim();
+  }
+  return out;
+}
+function formatPkDetectionError(tableName, result) {
+  const lines = [`Cannot auto-detect a primary key for table '${tableName}'.`];
+  if (result.sampleSize === 0) {
+    lines.push("  No sample data available \u2014 pass --pk-map <table>:<column>.");
+  } else {
+    lines.push(`  No column is unique across the ${result.sampleSize}-row sample.`);
+    lines.push("  Top candidates by cardinality:");
+    for (const c of result.candidates.slice(0, 5)) {
+      lines.push(`    ${c.name}  ${c.cardinality} unique`);
+    }
+  }
+  lines.push("", `  Specify explicitly:  --pk-map ${tableName}:<column>`);
+  return lines.join("\n");
+}
+
+// src/resources/bkn-create.ts
+function columnIsPk(col) {
+  if (col.is_primary_key === true) return true;
+  return typeof col.column_key === "string" && col.column_key.toUpperCase() === "PRI";
+}
+function toTableInfo(detail) {
+  const raw = detail.source_metadata?.columns ?? [];
+  const tablePks = Array.isArray(detail.primary_keys) ? detail.primary_keys.filter((x) => typeof x === "string") : [];
+  const columns = raw.map((c) => {
+    const name = String(c.name ?? c.field_name ?? "");
+    const flagged = columnIsPk(c) || tablePks.includes(name);
+    return {
+      name,
+      type: String(c.type ?? c.field_type ?? "varchar"),
+      ...flagged ? { isPrimaryKey: true } : {}
+    };
+  });
+  const pks = tablePks.length > 0 ? tablePks : columns.filter((c) => c.isPrimaryKey).map((c) => c.name);
+  return {
+    name: String(detail.name ?? ""),
+    columns,
+    ...pks.length > 0 ? { primaryKeys: pks } : {}
+  };
+}
+function asArray(v) {
+  if (Array.isArray(v)) return v;
+  if (v && typeof v === "object") {
+    const o = v;
+    if (Array.isArray(o.entries)) return o.entries;
+    if (Array.isArray(o.data)) return o.data;
+  }
+  return [];
+}
+async function sampleRows(ctx, resourceId) {
+  try {
+    const res = await queryResource(ctx, resourceId, { limit: 100 });
+    return asArray(res);
+  } catch {
+    return [];
+  }
+}
+async function createFromCatalog(ctx, opts) {
+  const log = opts.onProgress ?? (() => {
+  });
+  const pkMap = opts.pkMap ?? {};
+  const listTables = () => listResources2(ctx, { datasourceId: opts.catalogId, category: "table" }).then(asArray);
+  let summaries = await listTables();
+  if (summaries.length === 0) {
+    log("No tables found; scanning catalog metadata...");
+    await discoverCatalog(ctx, opts.catalogId, true);
+    summaries = await listTables();
+  }
+  if (summaries.length === 0) throw new Error("No tables available in catalog after scan.");
+  const details = await Promise.all(
+    summaries.map(async (s) => {
+      const id = s.id;
+      const detail = id ? await getResource(ctx, id) : s;
+      return toTableInfo(detail);
+    })
+  );
+  const targets = opts.tables && opts.tables.length > 0 ? details.filter((t) => opts.tables?.includes(t.name)) : details;
+  if (targets.length === 0) throw new Error("No matching tables to build from.");
+  for (const name of Object.keys(pkMap)) {
+    if (!targets.some((t) => t.name === name)) {
+      throw new Error(`--pk-map references unknown table '${name}'.`);
+    }
+  }
+  const tablePk = {};
+  for (const t of targets) {
+    const override = pkMap[t.name];
+    if (override && !t.columns.some((c) => c.name === override)) {
+      throw new Error(
+        `--pk-map '${override}' for table '${t.name}' is not a column. Columns: ${t.columns.map((c) => c.name).join(", ")}`
+      );
+    }
+    let res = resolvePrimaryKey(t, opts.sampleRows?.[t.name], override);
+    if (res.pk === null && res.source === "sample") {
+      const summary = summaries.find((s) => s.name === t.name);
+      const rows = summary?.id ? await sampleRows(ctx, summary.id) : [];
+      res = resolvePrimaryKey(t, rows, override);
+    }
+    if (res.source === "ambiguous") {
+      throw new Error(
+        `Table '${t.name}' has a composite primary key (${(res.ambiguous ?? []).join(", ")}). BKN object types take one key \u2014 pick with --pk-map ${t.name}:<column>.`
+      );
+    }
+    if (!res.pk) {
+      throw new Error(
+        formatPkDetectionError(t.name, {
+          candidates: res.candidates ?? [],
+          sampleSize: res.sampleSize ?? 0
+        })
+      );
+    }
+    tablePk[t.name] = res.pk;
+  }
+  log(`Creating resources for ${targets.length} table(s)...`);
+  const viewMap = {};
+  for (const t of targets) {
+    const found = asArray(
+      await findResource(ctx, t.name, { datasourceId: opts.catalogId, exact: true })
+    );
+    const existingId = found[0]?.id;
+    if (existingId) {
+      viewMap[t.name] = existingId;
+    } else {
+      const created = await createResource(ctx, {
+        name: t.name,
+        catalogId: opts.catalogId,
+        sourceIdentifier: t.name,
+        fields: t.columns.map((c) => ({ name: c.name, type: c.type }))
+      });
+      viewMap[t.name] = String(created.id ?? "");
+    }
+  }
+  const knCreated = await createKnowledgeNetwork(ctx, { name: opts.name });
+  const knItem = Array.isArray(knCreated) ? knCreated[0] : knCreated;
+  const knId = String(knItem?.id ?? "");
+  log(`Knowledge network created: ${knId}`);
+  let rollbackKn = knId;
+  try {
+    const entries = targets.map((t) => {
+      const pk = tablePk[t.name];
+      return {
+        branch: "main",
+        name: t.name,
+        data_source: { type: "resource", id: viewMap[t.name] },
+        primary_keys: [pk],
+        display_key: detectDisplayKey(t, pk),
+        data_properties: t.columns.map((c) => ({
+          name: c.name,
+          display_name: c.name,
+          type: "string",
+          mapped_field: { name: c.name, type: c.type || "varchar" }
+        }))
+      };
+    });
+    log(`Creating ${entries.length} object type(s)...`);
+    await createObjectTypes(ctx, knId, entries);
+    const builds = [];
+    if (opts.build) {
+      log("Submitting build tasks...");
+      for (const t of targets) {
+        const task = await createBuildTask(ctx, {
+          resource_id: viewMap[t.name],
+          mode: "batch",
+          build_key_fields: [tablePk[t.name]]
+        });
+        builds.push({ table: t.name, taskId: String(task.id ?? "") });
+      }
+    }
+    rollbackKn = void 0;
+    return {
+      kn_id: knId,
+      kn_name: opts.name,
+      object_types: targets.map((t) => ({ name: t.name, pk: tablePk[t.name] })),
+      build_tasks: builds
+    };
+  } finally {
+    if (rollbackKn !== void 0) {
+      if (opts.noRollback) {
+        log(`Leaving partial KN ${rollbackKn} in place (--no-rollback).`);
+      } else {
+        log(`Rolling back KN ${rollbackKn}...`);
+        try {
+          await deleteKnowledgeNetwork(ctx, rollbackKn);
+        } catch {
+        }
+      }
+    }
+  }
+}
+async function importCsvToCatalog(ctx, opts) {
+  const log = opts.onProgress ?? (() => {
+  });
+  const batchSize = opts.batchSize ?? 500;
+  const paths = await resolveFiles(opts.files);
+  const catalog = await getCatalog(ctx, opts.catalogId);
+  const datasourceType = catalog.connector_type ?? catalog.type ?? "";
+  const tables = [];
+  const failed = [];
+  const sampleRows2 = {};
+  for (const path of paths) {
+    const tableName = buildTableName(path, opts.tablePrefix ?? "");
+    const { headers: headers2, rows } = await parseCsvFile(path);
+    if (headers2.length === 0 || rows.length === 0) {
+      log(`Skipping ${tableName} (no headers/rows).`);
+      failed.push(tableName);
+      continue;
+    }
+    const fieldMappings = buildFieldMappings(headers2);
+    const batches = splitBatches(rows, batchSize);
+    try {
+      for (let i = 0; i < batches.length; i += 1) {
+        log(`[${tableName}] batch ${i + 1}/${batches.length} (${batches[i]?.length} rows)...`);
+        await executeDataflow(
+          ctx,
+          buildImportDag({
+            catalogId: opts.catalogId,
+            datasourceType,
+            tableName,
+            tableExist: i > 0,
+            data: batches[i],
+            fieldMappings
+          })
+        );
+      }
+      tables.push(tableName);
+      sampleRows2[tableName] = rows.slice(0, 100);
+    } catch (e) {
+      log(`[${tableName}] import failed: ${e instanceof Error ? e.message : String(e)}`);
+      failed.push(tableName);
+    }
+  }
+  await discoverCatalog(ctx, opts.catalogId, true).catch(() => {
+  });
+  return { tables, failed, sampleRows: sampleRows2 };
+}
+async function createFromCsv(ctx, opts) {
+  const log = opts.onProgress ?? (() => {
+  });
+  log("Phase 1: importing CSVs...");
+  const imported = await importCsvToCatalog(ctx, {
+    catalogId: opts.catalogId,
+    files: opts.files,
+    tablePrefix: opts.tablePrefix,
+    batchSize: opts.batchSize,
+    onProgress: log
+  });
+  if (imported.tables.length === 0) {
+    throw new Error(`No tables imported (failed: ${imported.failed.join(", ") || "none"}).`);
+  }
+  log(`Phase 2: building KN from ${imported.tables.length} table(s)...`);
+  const result = await createFromCatalog(ctx, {
+    catalogId: opts.catalogId,
+    name: opts.name,
+    tables: opts.tables && opts.tables.length > 0 ? opts.tables : imported.tables,
+    pkMap: opts.pkMap,
+    build: opts.build,
+    noRollback: opts.noRollback,
+    sampleRows: imported.sampleRows,
+    onProgress: log
+  });
+  return {
+    imported_tables: imported.tables,
+    failed_imports: imported.failed,
+    ...result
+  };
+}
+
+// src/resources/knowledge-networks.ts
+function kn(ctx) {
+  return {
+    list: (opts) => listKnowledgeNetworks(ctx, opts),
+    get: (knId, opts) => getKnowledgeNetwork(ctx, knId, opts),
+    search: (knId, query, opts) => semanticSearch(ctx, knId, query, opts),
+    create: (opts) => createKnowledgeNetwork(ctx, opts),
+    update: (knId, body) => updateKnowledgeNetwork(ctx, knId, body),
+    delete: (knId) => deleteKnowledgeNetwork(ctx, knId),
+    subgraph: (knId, body) => querySubgraph(ctx, knId, body),
+    actionLogs: (knId, opts) => listActionLogs(ctx, knId, opts),
+    actionLog: (knId, logId) => getActionLog(ctx, knId, logId),
+    cancelActionLog: (knId, logId) => cancelActionLog(ctx, knId, logId),
+    actionExecution: (knId, executionId) => getActionExecution(ctx, knId, executionId),
+    metricQuery: (knId, metricId, body) => queryMetricData(ctx, knId, metricId, body),
+    metricDryRun: (knId, body) => dryRunMetric(ctx, knId, body),
+    metricList: (knId, opts) => listMetrics(ctx, knId, opts),
+    metricGet: (knId, metricId) => getMetric(ctx, knId, metricId),
+    metricCreate: (knId, body) => createMetric(ctx, knId, body),
+    metricUpdate: (knId, metricId, body) => updateMetric(ctx, knId, metricId, body),
+    metricDelete: (knId, metricId) => deleteMetric(ctx, knId, metricId),
+    metricSearch: (knId, body) => searchMetrics(ctx, knId, body),
+    metricValidate: (knId, body) => validateMetric(ctx, knId, body),
+    objectTypes: (knId, opts) => listObjectTypes(ctx, knId, opts),
+    objectTypeQuery: (knId, otId, body) => queryObjectTypeInstances(ctx, knId, otId, body),
+    objectTypeProperties: (knId, otId) => getObjectTypeProperties(ctx, knId, otId),
+    objectTypeGet: (knId, id) => getSchemaItem(ctx, knId, "object-types", id),
+    objectTypeCreate: (knId, body) => createSchemaItem(ctx, knId, "object-types", body),
+    objectTypeUpdate: (knId, id, body) => updateSchemaItem(ctx, knId, "object-types", id, body),
+    objectTypeDelete: (knId, id) => deleteSchemaItem(ctx, knId, "object-types", id),
+    relationTypes: (knId, opts) => listRelationTypes(ctx, knId, opts),
+    relationTypeGet: (knId, id) => getSchemaItem(ctx, knId, "relation-types", id),
+    relationTypeCreate: (knId, body) => createSchemaItem(ctx, knId, "relation-types", body),
+    relationTypeUpdate: (knId, id, body) => updateSchemaItem(ctx, knId, "relation-types", id, body),
+    relationTypeDelete: (knId, id) => deleteSchemaItem(ctx, knId, "relation-types", id),
+    actionTypes: (knId, opts) => listActionTypes(ctx, knId, opts),
+    actionTypeQuery: (knId, atId, body) => queryActionType(ctx, knId, atId, body),
+    actionTypeExecute: (knId, atId, body) => executeActionType(ctx, knId, atId, body),
+    actionTypeInputs: (knId, atId) => getActionTypeInputs(ctx, knId, atId),
+    actionTypeGet: (knId, id) => getSchemaItem(ctx, knId, "action-types", id),
+    conceptGroups: (knId) => listConceptGroups(ctx, knId),
+    conceptGroup: (knId, cgId) => getConceptGroup(ctx, knId, cgId),
+    conceptGroupCreate: (knId, body) => createConceptGroup(ctx, knId, body),
+    conceptGroupUpdate: (knId, cgId, body) => updateConceptGroup(ctx, knId, cgId, body),
+    conceptGroupDelete: (knId, cgId) => deleteConceptGroup(ctx, knId, cgId),
+    conceptGroupAddMembers: (knId, cgId, body) => addConceptGroupMembers(ctx, knId, cgId, body),
+    conceptGroupRemoveMembers: (knId, cgId, otIds) => removeConceptGroupMembers(ctx, knId, cgId, otIds),
+    actionSchedules: (knId) => listActionSchedules(ctx, knId),
+    actionSchedule: (knId, scheduleId) => getActionSchedule(ctx, knId, scheduleId),
+    actionScheduleCreate: (knId, body) => createActionSchedule(ctx, knId, body),
+    actionScheduleUpdate: (knId, scheduleId, body) => updateActionSchedule(ctx, knId, scheduleId, body),
+    actionScheduleSetStatus: (knId, scheduleId, body) => setActionScheduleStatus(ctx, knId, scheduleId, body),
+    actionScheduleDelete: (knId, ids) => deleteActionSchedules(ctx, knId, ids),
+    jobs: (knId) => listJobs(ctx, knId),
+    job: (knId, jobId) => getJob(ctx, knId, jobId),
+    jobTasks: (knId, jobId) => getJobTasks(ctx, knId, jobId),
+    jobDelete: (knId, ids) => deleteJobs(ctx, knId, ids),
+    relationTypePaths: (knId, body) => relationTypePaths(ctx, knId, body),
+    bknResources: () => listBknResources(ctx),
+    createFromCatalog: (opts) => createFromCatalog(ctx, opts),
+    createFromCsv: (opts) => createFromCsv(ctx, opts),
+    /** Pack a local BKN directory and upload it as a knowledge network. */
+    push: (dir, opts) => uploadBkn(ctx, packDirectoryToTar(dir), opts),
+    /** Download a knowledge network and extract it into a local directory. */
+    pull: async (knId, dir, opts) => {
+      const tar = await downloadBkn(ctx, knId, opts);
+      mkdirSync2(resolve3(dir), { recursive: true });
+      extractTarToDirectory(tar, dir);
+      return { knId, dir: resolve3(dir), bytes: tar.length };
+    }
+  };
+}
+
+// src/api/models.ts
+var MANAGER = "/api/mf-model-manager/v1";
+var API = "/api/mf-model-api/v1";
+function listQuery(opts) {
+  return {
+    page: String(opts.page ?? 1),
+    size: String(opts.limit ?? 30),
+    name: opts.name ?? "",
+    model_type: opts.modelType ?? ""
+  };
+}
+function listLlmModels(ctx, opts = {}) {
+  return request(ctx, `${MANAGER}/llm/list`, { query: listQuery(opts) });
+}
+function getLlmModel(ctx, modelId) {
+  return request(ctx, `${MANAGER}/llm/get`, { query: { model_id: modelId } });
+}
+function listSmallModels(ctx, opts = {}) {
+  return request(ctx, `${MANAGER}/small-model/list`, { query: listQuery(opts) });
+}
+function getSmallModel(ctx, modelId) {
+  return request(ctx, `${MANAGER}/small-model/get`, { query: { model_id: modelId } });
+}
+function chatCompletions(ctx, model, messages) {
+  return request(ctx, `${API}/chat/completions`, {
+    method: "POST",
+    body: { model, messages, stream: false }
+  });
+}
+function deltaContent(chunk) {
+  const choices = chunk.choices;
+  const c = choices?.[0]?.delta?.content;
+  return typeof c === "string" ? c : "";
+}
+async function chatCompletionsStream(ctx, model, messages, onDelta) {
+  applyTls(ctx);
+  const res = await fetch(`${ctx.baseUrl}${API}/chat/completions`, {
+    method: "POST",
+    headers: {
+      ...buildHeaders(ctx),
+      "content-type": "application/json",
+      accept: "text/event-stream"
+    },
+    body: JSON.stringify({ model, messages, stream: true })
+  });
+  if (!res.ok) throw new HttpError(res.status, res.statusText, await res.text());
+  const reader = res.body?.getReader();
+  if (!reader) throw new Error("No response body for stream");
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let out = "";
+  const handle = (line) => {
+    const trimmed = line.trimEnd();
+    if (!trimmed.startsWith("data:")) return;
+    const payload = trimmed.slice(5).trim();
+    if (payload === "[DONE]" || payload === "") return;
+    try {
+      const text = deltaContent(JSON.parse(payload));
+      if (text) {
+        out += text;
+        onDelta(text);
+      }
+    } catch {
+    }
+  };
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const ln of lines) handle(ln);
+  }
+  if (buffer.trim()) handle(buffer);
+  return out;
+}
+function embeddings(ctx, model, input) {
+  return request(ctx, `${API}/small-model/embeddings`, { method: "POST", body: { model, input } });
+}
+function addModel(ctx, kind, body) {
+  return request(ctx, `${MANAGER}/${kind}/add`, { method: "POST", body });
+}
+function editModel(ctx, kind, body) {
+  return request(ctx, `${MANAGER}/${kind}/edit`, { method: "POST", body });
+}
+function deleteModels(ctx, kind, modelIds) {
+  return request(ctx, `${MANAGER}/${kind}/delete`, {
+    method: "POST",
+    body: { model_ids: modelIds }
+  });
+}
+function testModel(ctx, kind, body) {
+  return request(ctx, `${MANAGER}/${kind}/test`, { method: "POST", body });
+}
+function rerank(ctx, model, query, documents) {
+  return request(ctx, `${API}/small-model/reranker`, {
+    method: "POST",
+    body: { model, query, documents }
+  });
+}
+
+// src/resources/models.ts
+function models(ctx) {
+  return {
+    llm: {
+      list: (opts) => listLlmModels(ctx, opts),
+      get: (modelId) => getLlmModel(ctx, modelId),
+      chat: (modelId, messages) => chatCompletions(ctx, modelId, messages),
+      chatStream: (modelId, messages, onDelta) => chatCompletionsStream(ctx, modelId, messages, onDelta),
+      add: (body) => addModel(ctx, "llm", body),
+      edit: (body) => editModel(ctx, "llm", body),
+      delete: (modelIds) => deleteModels(ctx, "llm", modelIds),
+      test: (body) => testModel(ctx, "llm", body)
+    },
+    small: {
+      list: (opts) => listSmallModels(ctx, opts),
+      get: (modelId) => getSmallModel(ctx, modelId),
+      embeddings: (modelId, input) => embeddings(ctx, modelId, input),
+      rerank: (modelId, query, documents) => rerank(ctx, modelId, query, documents),
+      add: (body) => addModel(ctx, "small-model", body),
+      edit: (body) => editModel(ctx, "small-model", body),
+      delete: (modelIds) => deleteModels(ctx, "small-model", modelIds),
+      test: (body) => testModel(ctx, "small-model", body)
+    }
+  };
+}
+
+// src/resources/resources.ts
+function resources(ctx) {
+  return {
+    list: (opts) => listResources2(ctx, opts),
+    get: (id) => getResource(ctx, id),
+    delete: (id) => deleteResource(ctx, id),
+    find: (name, opts) => findResource(ctx, name, opts),
+    query: (id, opts) => queryResource(ctx, id, opts)
+  };
+}
+
+// src/resources/skills.ts
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
+import { basename as basename2, dirname as dirname2, resolve as resolve5 } from "path";
+
+// src/api/skills.ts
+var BASE5 = "/api/agent-operator-integration/v1";
+async function registerSkillZip(ctx, bytes, opts = {}) {
+  applyTls(ctx);
+  const form = new FormData();
+  form.set("file_type", "zip");
+  form.set("file", new Blob([bytes]), opts.filename ?? "skill.zip");
+  if (opts.source) form.set("source", opts.source);
+  if (opts.extendInfo) form.set("extend_info", JSON.stringify(opts.extendInfo));
+  const res = await fetch(`${ctx.baseUrl}${BASE5}/skills`, {
+    method: "POST",
+    headers: buildHeaders(ctx),
+    body: form
+  });
+  const text = await res.text();
+  if (!res.ok) throw new HttpError(res.status, res.statusText, text);
+  return text ? JSON.parse(text) : void 0;
+}
+async function updateSkillPackageZip(ctx, skillId, bytes, filename = "skill.zip") {
+  applyTls(ctx);
+  const form = new FormData();
+  form.set("file_type", "zip");
+  form.set("file", new Blob([bytes]), filename);
+  const res = await fetch(`${ctx.baseUrl}${BASE5}/skills/${encodeURIComponent(skillId)}/package`, {
+    method: "PUT",
+    headers: buildHeaders(ctx),
+    body: form
+  });
+  const text = await res.text();
+  if (!res.ok) throw new HttpError(res.status, res.statusText, text);
+  return text ? JSON.parse(text) : void 0;
+}
+async function downloadSkill(ctx, skillId) {
+  applyTls(ctx);
+  const res = await fetch(`${ctx.baseUrl}${BASE5}/skills/${encodeURIComponent(skillId)}/download`, {
+    headers: buildHeaders(ctx)
+  });
+  if (!res.ok) throw new HttpError(res.status, res.statusText, await res.text());
+  return new Uint8Array(await res.arrayBuffer());
+}
+function updateSkillMetadata(ctx, skillId, body) {
+  return request(ctx, `${BASE5}/skills/${encodeURIComponent(skillId)}`, { method: "PUT", body });
+}
+function republishSkillVersion(ctx, skillId, version) {
+  return request(ctx, `${BASE5}/skills/${encodeURIComponent(skillId)}/history/republish`, {
+    method: "POST",
+    body: { version }
+  });
+}
+function publishSkillVersion(ctx, skillId, version) {
+  return request(ctx, `${BASE5}/skills/${encodeURIComponent(skillId)}/history/publish`, {
+    method: "POST",
+    body: { version }
+  });
+}
+function listQuery2(opts) {
+  return {
+    page: opts.page ?? 1,
+    page_size: opts.pageSize ?? 30,
+    name: opts.name || void 0,
+    source: opts.source || void 0,
+    status: opts.status || void 0,
+    create_user: opts.createUser || void 0
+  };
+}
+function listSkills(ctx, opts = {}) {
+  return request(ctx, `${BASE5}/skills`, { query: listQuery2(opts) });
+}
+function listSkillMarket(ctx, opts = {}) {
+  return request(ctx, `${BASE5}/skills/market`, { query: listQuery2(opts) });
+}
+function getSkill(ctx, skillId) {
+  return request(ctx, `${BASE5}/skills/${encodeURIComponent(skillId)}`);
+}
+function getSkillMarket(ctx, skillId) {
+  return request(ctx, `${BASE5}/skills/market/${encodeURIComponent(skillId)}`);
+}
+function deleteSkill(ctx, skillId) {
+  return request(ctx, `${BASE5}/skills/${encodeURIComponent(skillId)}`, { method: "DELETE" });
+}
+function getSkillContent(ctx, skillId) {
+  return request(ctx, `${BASE5}/skills/${encodeURIComponent(skillId)}/content`);
+}
+function readSkillFile(ctx, skillId, relPath) {
+  return request(ctx, `${BASE5}/skills/${encodeURIComponent(skillId)}/files/read`, {
+    method: "POST",
+    body: { rel_path: relPath }
+  });
+}
+function getSkillHistory(ctx, skillId) {
+  return request(ctx, `${BASE5}/skills/${encodeURIComponent(skillId)}/history`);
+}
+function setSkillStatus(ctx, skillId, status2) {
+  return request(ctx, `${BASE5}/skills/${encodeURIComponent(skillId)}/status`, {
+    method: "PUT",
+    body: { status: status2 }
+  });
+}
+
+// src/utils/skill-archive.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname, join as join2, relative, resolve as resolve4, sep } from "path";
+import JSZip from "jszip";
+function walk(dir, base, files) {
+  for (const entry of readdirSync2(dir)) {
+    const full = join2(dir, entry);
+    const st = statSync2(full);
+    if (st.isDirectory()) walk(full, base, files);
+    else files.push(full);
+  }
+}
+async function zipDirectory(dir) {
+  const abs = resolve4(dir);
+  if (!existsSync2(abs)) throw new Error(`directory not found: ${abs}`);
+  const zip = new JSZip();
+  const files = [];
+  walk(abs, abs, files);
+  for (const file of files) {
+    const rel = relative(abs, file).split(sep).join("/");
+    zip.file(rel, readFileSync2(file));
+  }
+  return new Uint8Array(await zip.generateAsync({ type: "uint8array", compression: "DEFLATE" }));
+}
+async function unzipToDirectory(bytes, dir) {
+  const abs = resolve4(dir);
+  mkdirSync3(abs, { recursive: true });
+  const zip = await JSZip.loadAsync(bytes);
+  const written = [];
+  const entries = Object.values(zip.files);
+  for (const entry of entries) {
+    if (entry.dir) continue;
+    const out = join2(abs, entry.name);
+    mkdirSync3(dirname(out), { recursive: true });
+    writeFileSync2(out, await entry.async("nodebuffer"));
+    written.push(out);
+  }
+  return written;
+}
+
+// src/resources/skills.ts
+function skills(ctx) {
+  return {
+    list: (opts) => listSkills(ctx, opts),
+    get: (skillId) => getSkill(ctx, skillId),
+    market: (opts) => listSkillMarket(ctx, opts),
+    marketGet: (skillId) => getSkillMarket(ctx, skillId),
+    delete: (skillId) => deleteSkill(ctx, skillId),
+    content: (skillId) => getSkillContent(ctx, skillId),
+    readFile: (skillId, relPath) => readSkillFile(ctx, skillId, relPath),
+    history: (skillId) => getSkillHistory(ctx, skillId),
+    setStatus: (skillId, status2) => setSkillStatus(ctx, skillId, status2),
+    updateMetadata: (skillId, body) => updateSkillMetadata(ctx, skillId, body),
+    republish: (skillId, version) => republishSkillVersion(ctx, skillId, version),
+    publishHistory: (skillId, version) => publishSkillVersion(ctx, skillId, version),
+    /** Zip a local skill directory and register it. */
+    register: async (dir, opts) => registerSkillZip(ctx, await zipDirectory(dir), {
+      filename: `${basename2(resolve5(dir))}.zip`,
+      ...opts
+    }),
+    /** Replace a skill's package from a local directory. */
+    updatePackage: async (skillId, dir) => updateSkillPackageZip(ctx, skillId, await zipDirectory(dir), `${basename2(resolve5(dir))}.zip`),
+    /** Download a skill archive to a local .zip file. */
+    download: async (skillId, outPath) => {
+      const bytes = await downloadSkill(ctx, skillId);
+      const dest = resolve5(outPath ?? `${skillId}.zip`);
+      mkdirSync4(dirname2(dest), { recursive: true });
+      writeFileSync3(dest, bytes);
+      return { skillId, path: dest, bytes: bytes.length };
+    },
+    /** Download a skill archive and extract it into a directory. */
+    install: async (skillId, dir) => {
+      const bytes = await downloadSkill(ctx, skillId);
+      const target = resolve5(dir ?? skillId);
+      const files = await unzipToDirectory(bytes, target);
+      return { skillId, dir: target, files: files.length };
+    }
+  };
+}
+
+// src/resources/toolboxes.ts
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname3, resolve as resolve6 } from "path";
+
+// src/api/toolboxes.ts
+import { readFile as readFile2 } from "fs/promises";
+import { basename as basename3 } from "path";
+var PATH = "/api/agent-operator-integration/v1/tool-box";
+var IMPEX = "/api/agent-operator-integration/v1/impex";
+async function exportConfig(ctx, id, type = "toolbox") {
+  applyTls(ctx);
+  const res = await fetch(
+    `${ctx.baseUrl}${IMPEX}/export/${encodeURIComponent(type)}/${encodeURIComponent(id)}`,
+    { headers: buildHeaders(ctx) }
+  );
+  const buf = new Uint8Array(await res.arrayBuffer());
+  if (!res.ok) throw new HttpError(res.status, res.statusText, new TextDecoder().decode(buf));
+  return buf;
+}
+async function importConfig(ctx, filePath, type = "toolbox") {
+  applyTls(ctx);
+  const buf = await readFile2(filePath);
+  const form = new FormData();
+  form.append("data", new Blob([new Uint8Array(buf)]), basename3(filePath));
+  const res = await fetch(`${ctx.baseUrl}${IMPEX}/import/${encodeURIComponent(type)}`, {
+    method: "POST",
+    headers: buildHeaders(ctx),
+    body: form
+  });
+  const text = await res.text();
+  if (!res.ok) throw new HttpError(res.status, res.statusText, text);
+  return text ? JSON.parse(text) : text;
+}
+async function uploadTool(ctx, boxId, filePath, metadataType = "openapi") {
+  applyTls(ctx);
+  const buf = await readFile2(filePath);
+  const form = new FormData();
+  form.append("metadata_type", metadataType);
+  form.append("data", new Blob([new Uint8Array(buf)]), basename3(filePath));
+  const res = await fetch(`${ctx.baseUrl}${PATH}/${encodeURIComponent(boxId)}/tool`, {
+    method: "POST",
+    headers: buildHeaders(ctx),
+    body: form
+  });
+  const text = await res.text();
+  if (!res.ok) throw new HttpError(res.status, res.statusText, text);
+  return text ? JSON.parse(text) : text;
+}
+function listToolboxes(ctx, opts = {}) {
+  return request(ctx, `${PATH}/list`, {
+    query: { keyword: opts.keyword || void 0, limit: opts.limit, offset: opts.offset ?? 0 }
+  });
+}
+function listTools2(ctx, boxId) {
+  return request(ctx, `${PATH}/${encodeURIComponent(boxId)}/tools/list`);
+}
+function createToolbox(ctx, opts) {
+  return request(ctx, PATH, {
+    method: "POST",
+    body: {
+      metadata_type: "openapi",
+      box_name: opts.name,
+      box_desc: opts.description ?? "",
+      box_svc_url: opts.serviceUrl,
+      source: opts.source ?? "custom"
+    }
+  });
+}
+function deleteToolbox(ctx, boxId) {
+  return request(ctx, `${PATH}/${encodeURIComponent(boxId)}`, { method: "DELETE" });
+}
+function setToolboxStatus(ctx, boxId, status2) {
+  return request(ctx, `${PATH}/${encodeURIComponent(boxId)}/status`, {
+    method: "POST",
+    body: { status: status2 }
+  });
+}
+function envelope(e) {
+  return {
+    ...e.timeout !== void 0 ? { timeout: e.timeout } : {},
+    header: e.header ?? {},
+    query: e.query ?? {},
+    path: e.path ?? {},
+    body: e.body ?? {}
+  };
+}
+function executeTool(ctx, boxId, toolId, e = {}) {
+  return request(ctx, `${PATH}/${encodeURIComponent(boxId)}/proxy/${encodeURIComponent(toolId)}`, {
+    method: "POST",
+    body: envelope(e)
+  });
+}
+function debugTool(ctx, boxId, toolId, e = {}) {
+  return request(
+    ctx,
+    `${PATH}/${encodeURIComponent(boxId)}/tool/${encodeURIComponent(toolId)}/debug`,
+    {
+      method: "POST",
+      body: envelope(e)
+    }
+  );
+}
+function setToolStatuses(ctx, boxId, updates) {
+  return request(ctx, `${PATH}/${encodeURIComponent(boxId)}/tools/status`, {
+    method: "POST",
+    body: updates.map((u) => ({ tool_id: u.toolId, status: u.status }))
+  });
+}
+
+// src/resources/toolboxes.ts
+function toolboxes(ctx) {
+  return {
+    list: (opts) => listToolboxes(ctx, opts),
+    tools: (boxId) => listTools2(ctx, boxId),
+    create: (opts) => createToolbox(ctx, opts),
+    delete: (boxId) => deleteToolbox(ctx, boxId),
+    publish: (boxId) => setToolboxStatus(ctx, boxId, "published"),
+    unpublish: (boxId) => setToolboxStatus(ctx, boxId, "draft"),
+    setToolStatus: (boxId, toolIds, status2) => setToolStatuses(
+      ctx,
+      boxId,
+      toolIds.map((toolId) => ({ toolId, status: status2 }))
+    ),
+    upload: (boxId, filePath, metadataType) => uploadTool(ctx, boxId, filePath, metadataType),
+    /** Export a toolbox config to a local `.adp` file. */
+    export: async (id, outPath, type) => {
+      const bytes = await exportConfig(ctx, id, type);
+      const dest = resolve6(outPath);
+      mkdirSync5(dirname3(dest), { recursive: true });
+      writeFileSync4(dest, bytes);
+      return { id, path: dest, bytes: bytes.length };
+    },
+    /** Import a toolbox config from a local `.adp` file. */
+    import: (filePath, type) => importConfig(ctx, filePath, type),
+    execute: (boxId, toolId, e) => executeTool(ctx, boxId, toolId, e),
+    debug: (boxId, toolId, e) => debugTool(ctx, boxId, toolId, e)
+  };
+}
+
+// src/api/trace.ts
+var SEARCH = "/api/agent-observability/v1/traces/_search";
+function isoToNanos(iso) {
+  const ms = Date.parse(iso);
+  if (Number.isNaN(ms)) return void 0;
+  return (BigInt(ms) * 1000000n).toString();
+}
+function normalizeRawSpan(src) {
+  const spanIdRaw = src.spanId ?? src.span_id;
+  const spanId = typeof spanIdRaw === "string" ? spanIdRaw : "";
+  if (!spanId) return null;
+  const parentRaw = src.parentSpanId ?? src.parent_span_id;
+  const parentSpanId = typeof parentRaw === "string" && parentRaw !== "" && parentRaw !== "0" ? parentRaw : null;
+  const start = typeof src.startTimeUnixNano === "string" ? src.startTimeUnixNano : typeof src.startTime === "string" ? isoToNanos(src.startTime) : void 0;
+  const end = typeof src.endTimeUnixNano === "string" ? src.endTimeUnixNano : typeof src.endTime === "string" ? isoToNanos(src.endTime) : void 0;
+  const traceIdRaw = src.traceId ?? src.trace_id;
+  return {
+    spanId,
+    parentSpanId,
+    name: typeof src.name === "string" ? src.name : void 0,
+    traceId: typeof traceIdRaw === "string" ? traceIdRaw : void 0,
+    startTimeUnixNano: start,
+    endTimeUnixNano: end,
+    status: src.status,
+    attributes: src.attributes,
+    events: Array.isArray(src.events) ? src.events : void 0
+  };
+}
+async function getRawSpansByConversation(ctx, conversationId, opts = {}) {
+  const sources = await getSpansByConversation(ctx, conversationId, opts);
+  const spans = [];
+  const traceIds = /* @__PURE__ */ new Set();
+  for (const src of sources) {
+    const span = normalizeRawSpan(src);
+    if (!span) continue;
+    spans.push(span);
+    if (span.traceId) traceIds.add(span.traceId);
+  }
+  return { spans, traceIds: [...traceIds] };
+}
+function traceSearch(ctx, body) {
+  return request(ctx, SEARCH, { method: "POST", body });
+}
+async function getSpansByConversation(ctx, conversationId, opts = {}) {
+  const agg = await request(ctx, SEARCH, {
+    method: "POST",
+    body: {
+      size: 0,
+      query: { term: { "attributes.gen_ai.conversation.id.keyword": conversationId } },
+      aggs: { tids: { terms: { field: "traceId.keyword", size: opts.maxTraceIds ?? 100 } } }
+    }
+  }) ?? {};
+  const direct = agg.hits?.hits;
+  if (!agg.aggregations && Array.isArray(direct)) {
+    return direct.map((h) => h._source ?? {});
+  }
+  const traceIds = (agg.aggregations?.tids?.buckets ?? []).map((b) => b.key).filter((k) => typeof k === "string" && k.length > 0);
+  if (traceIds.length === 0) return [];
+  const spans = await request(ctx, SEARCH, {
+    method: "POST",
+    body: {
+      size: opts.maxSpans ?? 2e3,
+      query: { terms: { "traceId.keyword": traceIds } }
+    }
+  }) ?? {};
+  return (spans.hits?.hits ?? []).map((h) => h._source ?? {});
+}
+
+// src/trace-ai/claude-judge.ts
+import { spawn, spawnSync as spawnSync2 } from "child_process";
+var ClaudeJudgeError = class extends Error {
+  constructor(message, reason) {
+    super(message);
+    this.reason = reason;
+    this.name = "ClaudeJudgeError";
+  }
+  reason;
+};
+function claudeAvailable(binary = "claude") {
+  try {
+    const r = spawnSync2(binary, ["--version"], {
+      timeout: 5e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return r.status === 0;
+  } catch {
+    return false;
+  }
+}
+function extractEnvelope(stdout) {
+  const trimmed = stdout.trim();
+  if (!trimmed) throw new ClaudeJudgeError("claude returned empty stdout", "bad_output");
+  const env = JSON.parse(trimmed);
+  const text = typeof env.result === "string" ? env.result : env.text;
+  if (typeof text !== "string")
+    throw new ClaudeJudgeError("claude envelope had no result text", "bad_output");
+  return text;
+}
+function extractJsonObject(text) {
+  const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+  const body = fenced?.[1] ?? text;
+  const start = body.indexOf("{");
+  if (start === -1) throw new ClaudeJudgeError("no JSON object in judge output", "bad_output");
+  let depth = 0;
+  for (let i = start; i < body.length; i++) {
+    if (body[i] === "{") depth++;
+    else if (body[i] === "}" && --depth === 0) return body.slice(start, i + 1);
+  }
+  throw new ClaudeJudgeError("unbalanced JSON object in judge output", "bad_output");
+}
+async function judgeJson(prompt, opts = {}) {
+  const binary = opts.binary ?? "claude";
+  const timeoutMs = opts.timeoutMs ?? 12e4;
+  const args = ["-p", "--output-format=json", "--dangerously-skip-permissions"];
+  const stdout = await new Promise((resolve7, reject) => {
+    const child = spawn(binary, args, { stdio: ["pipe", "pipe", "pipe"] });
+    let out = "";
+    let timedOut = false;
+    const killer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      setTimeout(() => child.kill("SIGKILL"), 2e3).unref();
+    }, timeoutMs);
+    killer.unref();
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (d) => {
+      out += d;
+    });
+    child.on("error", (err) => {
+      clearTimeout(killer);
+      reject(
+        err.code === "ENOENT" ? new ClaudeJudgeError("`claude` not found on PATH", "not_available") : err
+      );
+    });
+    child.on("close", (code) => {
+      clearTimeout(killer);
+      if (timedOut)
+        return reject(new ClaudeJudgeError(`claude timed out after ${timeoutMs}ms`, "timeout"));
+      if (code !== 0) return reject(new ClaudeJudgeError(`claude exited ${code}`, "exit"));
+      resolve7(out);
+    });
+    child.stdin.on("error", (err) => {
+      if (err.code !== "EPIPE") reject(err);
+    });
+    child.stdin.end(prompt);
+  });
+  const text = extractEnvelope(stdout);
+  return JSON.parse(extractJsonObject(text));
+}
+
+// src/trace-ai/diagnose.ts
+var KIND_MAP = {
+  chat: "llm",
+  text_completion: "llm",
+  embeddings: "retrieval",
+  execute_tool: "tool",
+  model: "llm",
+  llm: "llm",
+  tool: "tool",
+  retrieval: "retrieval",
+  reasoning: "reasoning"
+};
+function deriveKind(attrs) {
+  const op = attrs["gen_ai.operation.name"];
+  if (typeof op === "string" && op in KIND_MAP) return KIND_MAP[op];
+  const t = attrs["agent.trace.type"];
+  if (typeof t === "string" && t in KIND_MAP) return KIND_MAP[t];
+  return "unknown";
+}
+function durationMs(start, end) {
+  if (!start || !end) return 0;
+  try {
+    return Number((BigInt(end) - BigInt(start)) / 1000000n);
+  } catch {
+    return 0;
+  }
+}
+function assembleTraceTree(traceId, raw) {
+  const spans = raw.map((r) => {
+    const attrs = r.attributes ?? {};
+    const code = r.status?.code?.toUpperCase();
+    return {
+      spanId: r.spanId,
+      parentSpanId: r.parentSpanId ?? null,
+      name: r.name ?? "",
+      kind: deriveKind(attrs),
+      startTimeUnixNano: r.startTimeUnixNano ?? "0",
+      endTimeUnixNano: r.endTimeUnixNano ?? "0",
+      durationMs: durationMs(r.startTimeUnixNano, r.endTimeUnixNano),
+      status: code === "OK" ? "ok" : code === "ERROR" ? "error" : "unset",
+      attributes: attrs
+    };
+  });
+  const byKind = /* @__PURE__ */ new Map();
+  for (const s of spans) {
+    const arr = byKind.get(s.kind) ?? [];
+    arr.push(s);
+    byKind.set(s.kind, arr);
+  }
+  return { traceId, spans, byKind };
+}
+function byStart(spans) {
+  return spans.slice().sort((a, b) => Number(BigInt(a.startTimeUnixNano) - BigInt(b.startTimeUnixNano)));
+}
+function strAttr(s, key) {
+  const v = s.attributes[key];
+  return typeof v === "string" ? v : "";
+}
+function toolName(s) {
+  return strAttr(s, "gen_ai.tool.name") || s.name;
+}
+var toolLoopNoStateChange = (trace2, params) => {
+  const STATE = "gen_ai.conversation.state";
+  const min = params.min_consecutive ?? 3;
+  const tools = byStart(trace2.byKind.get("tool") ?? []);
+  const hits = [];
+  let i = 0;
+  while (i < tools.length) {
+    const start = tools[i];
+    const name = toolName(start);
+    const args = start.attributes["gen_ai.tool.args"];
+    const state = start.attributes[STATE];
+    let j = i + 1;
+    while (j < tools.length && toolName(tools[j]) === name && JSON.stringify(tools[j].attributes["gen_ai.tool.args"]) === JSON.stringify(args) && tools[j].attributes[STATE] === state)
+      j++;
+    const runLen = j - i;
+    if (runLen >= min) {
+      hits.push({
+        evidenceSpans: tools.slice(i, j).map((s) => s.spanId),
+        excerpt: `tool '${name}' called ${runLen} times consecutively with identical args; conversation state unchanged`,
+        bindings: { tool_name: name, loop_count: runLen, max_count: min - 1 }
+      });
+    }
+    i = j;
+  }
+  return hits;
+};
+var toolErrorSwallowed = (trace2) => {
+  const all = byStart(trace2.spans);
+  const hits = [];
+  for (let i = 0; i < all.length; i++) {
+    const s = all[i];
+    if (s.kind !== "tool" || s.status !== "error") continue;
+    const errMsg = strAttr(s, "error.message");
+    let next;
+    for (let j = i + 1; j < all.length; j++) {
+      if (all[j].kind === "llm") {
+        next = all[j];
+        break;
+      }
+    }
+    if (!next) continue;
+    const prompt = (strAttr(next, "gen_ai.prompt") || strAttr(next, "llm.prompt")).toLowerCase();
+    if (!(errMsg.length > 0 && prompt.includes(errMsg.toLowerCase()))) {
+      hits.push({
+        evidenceSpans: [s.spanId, next.spanId],
+        excerpt: `tool '${toolName(s)}' errored ('${errMsg}') but the next LLM prompt did not propagate the error`,
+        bindings: { tool_name: toolName(s), error_message: errMsg }
+      });
+    }
+  }
+  return hits;
+};
+var retrievalEmptyNoFallback = (trace2) => {
+  const ordered = byStart(trace2.spans);
+  const hits = [];
+  for (let i = 0; i < ordered.length; i++) {
+    const s = ordered[i];
+    if (s.kind !== "retrieval") continue;
+    if (s.attributes["gen_ai.retrieval.result_count"] !== 0) continue;
+    const next = ordered[i + 1];
+    if (next?.kind === "llm") {
+      hits.push({
+        evidenceSpans: [s.spanId, next.spanId],
+        excerpt: "retrieval returned 0 results; next step was LLM generation with no fallback path",
+        bindings: {}
+      });
+    }
+  }
+  return hits;
+};
+var llmResponseTruncatedNoContinue = (trace2) => {
+  const finishReason = (s) => {
+    const arr = s.attributes["gen_ai.response.finish_reasons"];
+    if (Array.isArray(arr)) {
+      for (const r of arr) if (typeof r === "string" && r) return r;
+    }
+    return strAttr(s, "gen_ai.response.finish_reason") || strAttr(s, "llm.finish_reason");
+  };
+  const convId = (s) => strAttr(s, "gen_ai.conversation.id");
+  const llms = byStart(trace2.byKind.get("llm") ?? []);
+  const hits = [];
+  for (let i = 0; i < llms.length; i++) {
+    const s = llms[i];
+    if (finishReason(s) !== "length") continue;
+    const id = convId(s);
+    let cont = false;
+    for (let j = i + 1; j < llms.length; j++) if (convId(llms[j]) === id) cont = true;
+    if (!cont) {
+      hits.push({
+        evidenceSpans: [s.spanId],
+        excerpt: `LLM response truncated (finish_reason=length) with no continuation span in conversation '${id}'`,
+        bindings: { conversation_id: id }
+      });
+    }
+  }
+  return hits;
+};
+var excessiveToolCallsPerTurn = (trace2, params) => {
+  const max = params.max_tool_calls_per_turn ?? 10;
+  const tools = trace2.byKind.get("tool") ?? [];
+  if (tools.length <= max) return [];
+  return [
+    {
+      evidenceSpans: tools.map((t) => t.spanId),
+      excerpt: `tool calls per turn exceeded threshold: ${tools.length} > ${max}`,
+      bindings: { count: tools.length, max_calls: max }
+    }
+  ];
+};
+var BUILTIN_RULES = [
+  {
+    id: "tool_loop_no_state_change",
+    severity: "high",
+    symptom: "repeated_tool_call_without_state_change",
+    suggestedFix: {
+      target: "decision_agent.prompt",
+      changeTemplate: "add a stop condition after {{loop_count}} equivalent retries of '{{tool_name}}'"
+    },
+    predicate: toolLoopNoStateChange,
+    params: { min_consecutive: 3 }
+  },
+  {
+    id: "tool_error_swallowed",
+    severity: "high",
+    symptom: "tool_error_not_propagated_to_llm",
+    suggestedFix: {
+      target: "agent.tool_result_handling",
+      changeTemplate: "feed tool errors back into the next LLM prompt"
+    },
+    predicate: toolErrorSwallowed,
+    params: {}
+  },
+  {
+    id: "retrieval_empty_no_fallback",
+    severity: "medium",
+    symptom: "empty_retrieval_no_fallback",
+    suggestedFix: {
+      target: "retrieval.fallback",
+      changeTemplate: "add a rewrite/alternate-source fallback when retrieval returns 0 results"
+    },
+    predicate: retrievalEmptyNoFallback,
+    params: {}
+  },
+  {
+    id: "llm_response_truncated_no_continue",
+    severity: "medium",
+    symptom: "truncated_response_no_continuation",
+    suggestedFix: {
+      target: "llm.max_tokens",
+      changeTemplate: "raise max_tokens or add a continuation turn when finish_reason=length"
+    },
+    predicate: llmResponseTruncatedNoContinue,
+    params: {}
+  },
+  {
+    id: "excessive_tool_calls_per_turn",
+    severity: "low",
+    symptom: "excessive_tool_calls_per_turn",
+    suggestedFix: {
+      target: "decision_agent.prompt",
+      changeTemplate: "cap tool calls per turn at {{max_calls}}"
+    },
+    predicate: excessiveToolCallsPerTurn,
+    params: { max_tool_calls_per_turn: 10 }
+  }
+];
+function applyTemplate(tpl, bindings) {
+  return tpl.replace(/\{\{(\w+)\}\}/g, (_m, k) => String(bindings[k] ?? `{{${k}}}`));
+}
+function runRules(tree, rules = BUILTIN_RULES) {
+  const findings = [];
+  for (const rule of rules) {
+    for (const hit of rule.predicate(tree, rule.params)) {
+      findings.push({
+        ruleId: rule.id,
+        judgmentKind: "symbolic",
+        severity: rule.severity,
+        symptom: rule.symptom,
+        evidence: { spans: hit.evidenceSpans, excerpt: hit.excerpt },
+        suggestedFix: {
+          target: rule.suggestedFix.target,
+          change: applyTemplate(rule.suggestedFix.changeTemplate, hit.bindings)
+        }
+      });
+    }
+  }
+  return findings;
+}
+var BUILTIN_RUBRIC_RULES = [
+  {
+    id: "tool_retry_intent_mismatch",
+    severity: "high",
+    symptom: "repeated_tool_call_without_state_change",
+    gatesOn: "tool_loop_no_state_change",
+    judgeQuestion: "Given the user's intent and the tool retry pattern in this trace, classify why the agent kept calling the same tool: a legitimate retry (expecting changed state), a stale-results handling failure (results were identical and the agent didn't notice), prompt confusion (misinterpreted its own instructions), or other.",
+    suggestedFix: {
+      target: "decision_agent.prompt",
+      changeTemplate: "agent retried because of '{{category}}'; address that intent (staleness detection, broaden query, or escalate)"
+    }
+  }
+];
+function userIntent(tree) {
+  for (const s of tree.spans) {
+    const v = s.attributes["gen_ai.user.message"];
+    if (typeof v === "string" && v) return v;
+  }
+  const firstLlm = byStart(tree.byKind.get("llm") ?? [])[0];
+  return firstLlm ? strAttr(firstLlm, "gen_ai.prompt") || strAttr(firstLlm, "llm.prompt") : "";
+}
+function spanSequence(tree) {
+  return byStart(tree.spans).filter((s) => s.kind === "tool" || s.kind === "llm").map((s) => ({
+    span_id: s.spanId,
+    kind: s.kind,
+    name: s.name,
+    status: s.status,
+    tool: strAttr(s, "gen_ai.tool.name") || void 0,
+    args: s.attributes["gen_ai.tool.args"]
+  }));
+}
+function buildRubricPrompt(rule, tree) {
+  return [
+    "You are a trace-diagnosis judge. Answer the question about the agent trace below.",
+    "",
+    `QUESTION: ${rule.judgeQuestion}`,
+    "",
+    `USER INTENT: ${userIntent(tree) || "(unknown)"}`,
+    "",
+    "SPAN SEQUENCE (tool + llm steps, chronological):",
+    JSON.stringify(spanSequence(tree), null, 2),
+    "",
+    "Respond with ONLY a JSON object (no prose, no code fence) of exactly this shape:",
+    '{"category": "legitimate_retry|stale_results|prompt_confusion|other", "reasoning": "<one or two sentences>", "severity": "low|medium|high", "confidence": "low|medium|high", "first_violating_step_id": "<span_id>", "evidence_span_ids": ["<span_id>", ...]}'
+  ].join("\n");
+}
+async function runRubric(tree, symbolicFindings, judge, rules = BUILTIN_RUBRIC_RULES) {
+  const fired = new Set(symbolicFindings.map((f) => f.ruleId));
+  const out = [];
+  for (const rule of rules) {
+    if (!fired.has(rule.gatesOn)) continue;
+    let judged;
+    try {
+      judged = await judge(buildRubricPrompt(rule, tree));
+    } catch {
+      continue;
+    }
+    const category = typeof judged.category === "string" ? judged.category : "other";
+    const sev = judged.severity;
+    const conf = judged.confidence;
+    const spans = Array.isArray(judged.evidence_span_ids) ? judged.evidence_span_ids.filter((s) => typeof s === "string") : [];
+    out.push({
+      ruleId: rule.id,
+      judgmentKind: "rubric",
+      severity: sev === "low" || sev === "medium" || sev === "high" ? sev : rule.severity,
+      symptom: rule.symptom,
+      evidence: { spans, excerpt: typeof judged.reasoning === "string" ? judged.reasoning : "" },
+      suggestedFix: {
+        target: rule.suggestedFix.target,
+        change: applyTemplate(rule.suggestedFix.changeTemplate, { category })
+      },
+      ...conf === "low" || conf === "medium" || conf === "high" ? { confidence: conf } : {}
+    });
+  }
+  return out;
+}
+async function synthesizeFindings(findings, judge) {
+  if (findings.length === 0) {
+    return {
+      headline: "No issues found by the diagnosis rules.",
+      primaryRootCause: null,
+      targetForFix: null
+    };
+  }
+  const prompt = [
+    "You are a trace-diagnosis synthesizer. Given these findings, write a concise summary.",
+    "FINDINGS:",
+    JSON.stringify(
+      findings.map((f) => ({
+        rule: f.ruleId,
+        severity: f.severity,
+        symptom: f.symptom,
+        evidence: f.evidence.excerpt,
+        fix: f.suggestedFix
+      })),
+      null,
+      2
+    ),
+    "",
+    'Respond with ONLY JSON: {"headline":"<one sentence>","primary_root_cause":"<one sentence or null>","target_for_fix":"<component or null>"}'
+  ].join("\n");
+  try {
+    const out = await judge(prompt);
+    return {
+      headline: typeof out.headline === "string" ? out.headline : fallbackHeadline(findings),
+      primaryRootCause: typeof out.primary_root_cause === "string" ? out.primary_root_cause : null,
+      targetForFix: typeof out.target_for_fix === "string" ? out.target_for_fix : null
+    };
+  } catch {
+    return { headline: fallbackHeadline(findings), primaryRootCause: null, targetForFix: null };
+  }
+}
+function fallbackHeadline(findings) {
+  const high = findings.filter((f) => f.severity === "high").length;
+  return `${findings.length} finding(s)${high > 0 ? `, ${high} high-severity` : ""}.`;
+}
+function renderReportMarkdown(r) {
+  const lines = [`# Trace Diagnose \u2014 \`${r.traceId}\``, ""];
+  lines.push(
+    `> conversation \`${r.conversationId}\` \xB7 mode ${r.mode} \xB7 ${r.findingCount} finding(s)`,
+    ""
+  );
+  if (r.summary) {
+    lines.push(`**${r.summary.headline}**`, "");
+    if (r.summary.primaryRootCause) {
+      const tgt = r.summary.targetForFix ? ` (fix target: \`${r.summary.targetForFix}\`)` : "";
+      lines.push(`Primary root cause: ${r.summary.primaryRootCause}${tgt}`, "");
+    }
+  }
+  if (r.findings.length === 0) {
+    if (!r.summary) lines.push("No issues found by the symbolic rules.");
+    return lines.join("\n");
+  }
+  const order = { high: 0, medium: 1, low: 2 };
+  for (const f of r.findings.slice().sort((a, b) => order[a.severity] - order[b.severity])) {
+    const conf = f.confidence ? `, confidence ${f.confidence}` : "";
+    lines.push(`## [${f.severity.toUpperCase()}] ${f.ruleId} (${f.judgmentKind}${conf})`, "");
+    lines.push(`- **symptom**: ${f.symptom}`);
+    lines.push(`- **evidence**: ${f.evidence.excerpt}`);
+    lines.push(`- **spans**: ${f.evidence.spans.map((s) => `\`${s}\``).join(", ") || "\u2014"}`);
+    lines.push(`- **suggested fix** (\`${f.suggestedFix.target}\`): ${f.suggestedFix.change}`, "");
+  }
+  return lines.join("\n");
+}
+
+// src/trace-ai/eval-set.ts
+function hashId(s) {
+  let h = 5381;
+  for (let i = 0; i < s.length; i++) h = h * 33 ^ s.charCodeAt(i);
+  return `q_${(h >>> 0).toString(36)}`;
+}
+function buildCasesFromQueries(raw) {
+  const arr = Array.isArray(raw) ? raw : Array.isArray(raw?.cases) ? raw.cases : Array.isArray(raw?.queries) ? raw.queries : [];
+  return arr.map((entry) => {
+    const e = entry;
+    const userMessage = typeof e.query === "string" ? e.query : typeof e.input?.user_message === "string" ? e.input.user_message : "";
+    const refAnswer = e.reference?.answer;
+    return {
+      query_id: typeof e.query_id === "string" && e.query_id ? e.query_id : hashId(userMessage),
+      input: { user_message: userMessage },
+      ...typeof refAnswer === "string" ? { reference: { answer: refAnswer } } : {},
+      ...Array.isArray(e.assertions) ? { assertions: e.assertions } : {},
+      ...Array.isArray(e.tags) ? { tags: e.tags.map(String) } : {}
+    };
+  });
+}
+function applyOp(actual, op, expected) {
+  return op === "eq" ? actual === expected : op === "lt" ? actual < expected : op === "lte" ? actual <= expected : op === "gt" ? actual > expected : actual >= expected;
+}
+function toolName2(s) {
+  const v = s.attributes["gen_ai.tool.name"];
+  return typeof v === "string" ? v : s.name;
+}
+function orderedToolNames(spans) {
+  return spans.filter((s) => s.kind === "tool").slice().sort((a, b) => Number(BigInt(a.startTimeUnixNano) - BigInt(b.startTimeUnixNano))).map(toolName2);
+}
+function isSubsequence(seq, actual) {
+  let i = 0;
+  for (const n of actual) {
+    if (n === seq[i]) i++;
+    if (i === seq.length) return true;
+  }
+  return seq.length === 0;
+}
+async function evaluateAssertion(a, ctx) {
+  const r = a;
+  switch (a.type) {
+    case "contains": {
+      const v = String(r.value ?? "");
+      return ctx.answer.includes(v) ? { type: a.type, verdict: "pass" } : { type: a.type, verdict: "fail", actual: ctx.answer };
+    }
+    case "not_contains": {
+      const v = String(r.value ?? "");
+      return ctx.answer.includes(v) ? { type: a.type, verdict: "fail", actual: ctx.answer } : { type: a.type, verdict: "pass" };
+    }
+    case "regex": {
+      let re;
+      try {
+        re = new RegExp(String(r.pattern ?? ""));
+      } catch {
+        return { type: a.type, verdict: "skip", reason: `invalid regex: ${r.pattern}` };
+      }
+      return re.test(ctx.answer) ? { type: a.type, verdict: "pass" } : { type: a.type, verdict: "fail", actual: ctx.answer };
+    }
+    case "tool_call_count": {
+      const count = ctx.spans.filter(
+        (s) => s.kind === "tool" && toolName2(s) === String(r.tool ?? "")
+      ).length;
+      return applyOp(count, r.op ?? "eq", Number(r.value ?? 0)) ? { type: a.type, verdict: "pass", actual: count } : { type: a.type, verdict: "fail", actual: count };
+    }
+    case "tool_call_order": {
+      const seq = Array.isArray(r.sequence) ? r.sequence.map(String) : [];
+      const actual = orderedToolNames(ctx.spans);
+      return isSubsequence(seq, actual) ? { type: a.type, verdict: "pass", actual } : { type: a.type, verdict: "fail", actual };
+    }
+    case "latency_ms": {
+      if (ctx.durationMs == null)
+        return { type: a.type, verdict: "skip", reason: "durationMs unavailable" };
+      return applyOp(ctx.durationMs, r.op ?? "lte", Number(r.value ?? 0)) ? { type: a.type, verdict: "pass", actual: ctx.durationMs } : { type: a.type, verdict: "fail", actual: ctx.durationMs };
+    }
+    case "semantic_match": {
+      if (!ctx.judgeSemanticMatch)
+        return { type: a.type, verdict: "skip", reason: "no judge (pass --llm)" };
+      if (!ctx.reference?.answer)
+        return { type: a.type, verdict: "skip", reason: "no reference.answer on case" };
+      const smv = await ctx.judgeSemanticMatch(
+        String(r.question ?? ""),
+        ctx.answer,
+        ctx.reference.answer
+      );
+      return { type: a.type, verdict: smv.verdict, actual: smv.reasoning };
+    }
+    default:
+      return { type: a.type, verdict: "skip", reason: `unknown assertion type: ${a.type}` };
+  }
+}
+async function runEvalSet(agentId, cases, deps) {
+  const results = [];
+  for (const c of cases) {
+    const query = c.input.user_message;
+    let answer = "";
+    let conversationId = null;
+    let spans = [];
+    let errorCode;
+    let chatFailed = false;
+    try {
+      const run = await deps.runQuery(query);
+      answer = run.answer;
+      conversationId = run.conversationId;
+      if (conversationId) {
+        try {
+          spans = await deps.fetchSpans(conversationId);
+        } catch {
+          errorCode = "trace-fetch-failed";
+        }
+      }
+    } catch {
+      chatFailed = true;
+      errorCode = "chat-failed";
+    }
+    const assertionResults = [];
+    if (!chatFailed) {
+      for (const a of c.assertions ?? []) {
+        assertionResults.push(
+          await evaluateAssertion(a, {
+            answer,
+            spans,
+            reference: c.reference,
+            judgeSemanticMatch: deps.judgeSemanticMatch
+          })
+        );
+      }
+    }
+    results.push({
+      queryId: c.query_id,
+      query,
+      answer,
+      conversationId,
+      assertions: assertionResults,
+      ...errorCode ? { errorCode } : {}
+    });
+  }
+  const flat = results.flatMap((r) => r.assertions);
+  return {
+    agentId,
+    total: cases.length,
+    passed: flat.filter((a) => a.verdict === "pass").length,
+    failed: flat.filter((a) => a.verdict === "fail").length,
+    skipped: flat.filter((a) => a.verdict === "skip").length,
+    cases: results
+  };
+}
+
+// src/resources/trace.ts
+async function semanticJudge(question, answer, reference) {
+  const prompt = [
+    "You judge whether an agent ANSWER semantically matches a REFERENCE answer.",
+    question ? `QUESTION/CRITERION: ${question}` : "",
+    `ANSWER: ${answer}`,
+    `REFERENCE: ${reference}`,
+    'Respond with ONLY JSON: {"verdict":"pass|fail","reasoning":"<one sentence>"}'
+  ].filter(Boolean).join("\n");
+  const out = await judgeJson(prompt, { timeoutMs: 12e4 });
+  return {
+    verdict: out.verdict === "pass" ? "pass" : "fail",
+    reasoning: typeof out.reasoning === "string" ? out.reasoning : ""
+  };
+}
+function trace(ctx) {
+  const diagnoseOne = async (conversationId, opts = {}) => {
+    const { spans, traceIds } = await getRawSpansByConversation(ctx, conversationId);
+    if (spans.length === 0) throw new Error(`No spans found for conversation: ${conversationId}`);
+    const primaryTraceId = traceIds[0] ?? conversationId;
+    const spansForPrimary = traceIds.length > 0 ? spans.filter((s) => !s.traceId || s.traceId === primaryTraceId) : spans;
+    const tree = assembleTraceTree(primaryTraceId, spansForPrimary);
+    const findings = runRules(tree);
+    let mode = "symbolic-only";
+    let summary;
+    if (opts.llm && claudeAvailable()) {
+      const judge = (prompt) => judgeJson(prompt, { timeoutMs: opts.judgeTimeoutMs });
+      const rubric = await runRubric(tree, findings, judge);
+      findings.push(...rubric);
+      summary = await synthesizeFindings(findings, judge);
+      mode = "hybrid";
+    }
+    return {
+      traceId: primaryTraceId,
+      conversationId,
+      diagnosedAt: null,
+      mode,
+      rulesApplied: BUILTIN_RULES.map((r) => r.id),
+      findingCount: findings.length,
+      ...summary ? { summary } : {},
+      findings
+    };
+  };
+  return {
+    /** Raw trace search (OpenSearch-style body). */
+    search: (body) => traceSearch(ctx, body),
+    /** All span source docs for a conversation. */
+    spans: (conversationId, opts) => getSpansByConversation(ctx, conversationId, opts),
+    diagnose: diagnoseOne,
+    /**
+     * Scan (batch-diagnose) several conversations and aggregate the findings:
+     * per-trace reports + a recurring-rule tally across the batch.
+     */
+    scan: async (conversationIds, opts = {}) => {
+      const reports = [];
+      for (const id of conversationIds) {
+        try {
+          reports.push(await diagnoseOne(id, opts));
+        } catch (e) {
+          reports.push({
+            conversationId: id,
+            error: e instanceof Error ? e.message : String(e)
+          });
+        }
+      }
+      const byRule = {};
+      let totalFindings = 0;
+      for (const r of reports) {
+        if (!("findings" in r)) continue;
+        for (const f of r.findings) {
+          byRule[f.ruleId] = (byRule[f.ruleId] ?? 0) + 1;
+          totalFindings += 1;
+        }
+      }
+      return {
+        scanned: conversationIds.length,
+        totalFindings,
+        recurringRules: Object.entries(byRule).sort((a, b) => b[1] - a[1]).map(([ruleId, count]) => ({ ruleId, count })),
+        reports
+      };
+    },
+    /** Build eval cases from a loosely-shaped queries object/array. */
+    evalSetBuild: (raw) => buildCasesFromQueries(raw),
+    /**
+     * Run an eval set against an agent: each case's query is sent to the agent,
+     * the resulting trace is fetched, and assertions are checked. `llm` enables
+     * `semantic_match` assertions via the local claude judge.
+     */
+    evalSetTest: async (agentId, cases, opts = {}) => {
+      const info = await fetchAgentInfo(ctx, agentId, opts.version ?? "v0");
+      return runEvalSet(agentId, cases, {
+        runQuery: async (query) => {
+          const res = await sendChat(ctx, info, query, {});
+          return { answer: res.text, conversationId: res.conversationId ?? null };
+        },
+        fetchSpans: async (conversationId) => {
+          const { spans, traceIds } = await getRawSpansByConversation(ctx, conversationId);
+          const primary = traceIds[0] ?? conversationId;
+          return assembleTraceTree(
+            primary,
+            traceIds.length > 0 ? spans.filter((s) => !s.traceId || s.traceId === primary) : spans
+          ).spans;
+        },
+        judgeSemanticMatch: opts.llm && claudeAvailable() ? semanticJudge : void 0
+      });
+    }
+  };
+}
+
+// src/resources/vega.ts
+var TERMINAL_STATES = /* @__PURE__ */ new Set(["completed", "success", "failed"]);
+function vega(ctx) {
+  return {
+    catalogs: (opts) => listCatalogs(ctx, opts),
+    getCatalog: (id) => getCatalog(ctx, id),
+    catalogResources: (id, category) => listCatalogResources(ctx, id, category),
+    catalogHealth: (ids) => catalogHealthStatus(ctx, ids),
+    connectorTypes: () => listConnectorTypes(ctx),
+    connectorType: (type) => getConnectorType(ctx, type),
+    /** Build a resource's index. With `wait`, polls until terminal. */
+    build: async (req, opts = {}) => {
+      const task = await createBuildTask(ctx, req);
+      if (!opts.wait) return task;
+      return pollBuildTask(ctx, task.id, opts.timeoutMs ?? 3e5, opts.intervalMs ?? 2e3);
+    },
+    buildStatus: (taskId) => getBuildTask(ctx, taskId)
+  };
+}
+async function pollBuildTask(ctx, taskId, timeoutMs, intervalMs) {
+  const deadline = Date.now() + timeoutMs;
+  let last = await getBuildTask(ctx, taskId);
+  while (!TERMINAL_STATES.has((last.state ?? "").toLowerCase()) && Date.now() < deadline) {
+    await sleep(intervalMs);
+    last = await getBuildTask(ctx, taskId);
+  }
+  return last;
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/api/call.ts
+import { readFileSync as readFileSync3 } from "fs";
+function parseHeader(raw) {
+  const idx = raw.indexOf(":");
+  if (idx <= 0) return null;
+  return [raw.slice(0, idx).trim(), raw.slice(idx + 1).trim()];
+}
+function parseFormField(raw) {
+  const idx = raw.indexOf("=");
+  if (idx < 0) throw new Error(`Invalid form field (expected key=value): ${raw}`);
+  const key = raw.slice(0, idx);
+  const value = raw.slice(idx + 1);
+  if (value.startsWith("@")) return [key, value.slice(1), true];
+  return [key, value, false];
+}
+function resolveUrl(ctx, path) {
+  return path.startsWith("http") ? path : `${ctx.baseUrl}${path.startsWith("/") ? "" : "/"}${path}`;
+}
+async function rawCall(ctx, path, opts = {}) {
+  applyTls(ctx);
+  const url = resolveUrl(ctx, path);
+  const extra = {};
+  for (const h of opts.header ?? []) {
+    const parsed = parseHeader(h);
+    if (parsed) extra[parsed[0].toLowerCase()] = parsed[1];
+  }
+  let body;
+  if (opts.form && opts.form.length > 0) {
+    const fd = new FormData();
+    for (const field of opts.form) {
+      const [key, value, isFile] = parseFormField(field);
+      if (isFile) fd.append(key, new Blob([readFileSync3(value)]), value.split("/").pop());
+      else fd.append(key, value);
+    }
+    body = fd;
+  } else if (opts.data !== void 0) {
+    body = opts.data;
+    if (!extra["content-type"]) extra["content-type"] = "application/json";
+  }
+  const method = opts.method ?? (body !== void 0 ? "POST" : "GET");
+  const headers2 = buildHeaders(
+    { ...ctx, businessDomain: opts.businessDomain ?? ctx.businessDomain },
+    extra
+  );
+  if (opts.verbose) process.stderr.write(`> ${method} ${url}
+`);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), opts.timeoutMs ?? 3e4);
+  try {
+    const res = await fetch(url, { method, headers: headers2, body, signal: controller.signal });
+    return { status: res.status, statusText: res.statusText, body: await res.text() };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/client.ts
+function createClient(opts = {}) {
+  const ctx = resolveContext(opts);
+  return {
+    ctx,
+    kn: kn(ctx),
+    resource: resources(ctx),
+    dataflows: dataflows(ctx),
+    agents: agents(ctx),
+    context: context(ctx),
+    models: models(ctx),
+    skills: skills(ctx),
+    toolboxes: toolboxes(ctx),
+    trace: trace(ctx),
+    admin: admin(ctx),
+    vega: vega(ctx),
+    call: (path, callOpts) => rawCall(ctx, path, callOpts)
+  };
+}
+
+// src/resources/auth.ts
+var auth_exports = {};
+__export(auth_exports, {
+  attachToken: () => attachToken,
+  currentToken: () => currentToken,
+  deletePlatform: () => deletePlatform,
+  exportCreds: () => exportCreds,
+  hostOf: () => hostOf,
+  listPlatforms: () => listPlatforms2,
+  logout: () => logout,
+  status: () => status,
+  switchUser: () => switchUser,
+  use: () => use,
+  userIdFromToken: () => userIdFromToken,
+  usersOf: () => usersOf,
+  whoami: () => whoami
+});
+function hostOf(baseUrl) {
+  try {
+    return new URL(baseUrl).host;
+  } catch {
+    return baseUrl;
+  }
+}
+function normalize(baseUrl) {
+  return baseUrl.replace(/\/+$/, "");
+}
+function usernameOf(token) {
+  if (!token) return void 0;
+  const claims = decodeJwt(token.accessToken);
+  return token.username ?? token.displayName ?? claims?.preferred_username ?? claims?.name ?? claims?.sub;
+}
+function attachToken(baseUrl, accessToken, opts = {}) {
+  const url = normalize(baseUrl);
+  const token = {
+    baseUrl: url,
+    accessToken,
+    refreshToken: opts.refreshToken,
+    idToken: opts.idToken,
+    tlsInsecure: opts.insecure,
+    username: decodeJwt(opts.idToken ?? accessToken)?.preferred_username
+  };
+  const userId = writeToken(url, token);
+  setActivePlatform(url);
+  return { baseUrl: url, userId, username: usernameOf(token) };
+}
+function status() {
+  const baseUrl = activePlatform();
+  if (!baseUrl) return { hasToken: false };
+  const token = readToken(baseUrl);
+  return {
+    baseUrl,
+    userId: activeUserId(baseUrl),
+    hasToken: token !== void 0,
+    username: usernameOf(token),
+    expired: token ? isExpired(decodeJwt(token.accessToken)) : void 0
+  };
+}
+function currentToken() {
+  const baseUrl = activePlatform();
+  const token = baseUrl ? readToken(baseUrl) : void 0;
+  if (!token) throw new InputError("Not logged in. Run `openbkn auth login <url> --token <t>`.");
+  return token.accessToken;
+}
+function whoami() {
+  const baseUrl = activePlatform();
+  const token = baseUrl ? readToken(baseUrl) : void 0;
+  const claims = decodeJwt(token?.idToken ?? "") ?? decodeJwt(token?.accessToken ?? "");
+  if (!claims) {
+    throw new InputError(
+      "No decodable identity (token is opaque and no id_token saved). Use `auth status`."
+    );
+  }
+  return claims;
+}
+function listPlatforms2() {
+  const current = activePlatform();
+  return listPlatforms().flatMap(
+    (p) => p.users.map((u) => ({
+      baseUrl: p.baseUrl,
+      userId: u.userId,
+      username: u.username ?? u.displayName,
+      active: p.baseUrl === current && u.userId === p.activeUserId
+    }))
+  );
+}
+function use(baseUrl) {
+  const url = normalize(baseUrl);
+  if (!readToken(url)) {
+    throw new InputError(`No saved credentials for ${url}. Run \`openbkn auth login\` first.`);
+  }
+  setActivePlatform(url);
+}
+function logout() {
+  const baseUrl = activePlatform();
+  return baseUrl ? deleteToken(baseUrl) : false;
+}
+function deletePlatform(baseUrl, userId) {
+  return deleteToken(normalize(baseUrl), userId);
+}
+function switchUser(baseUrl, userId) {
+  const url = normalize(baseUrl);
+  if (!readToken(url, userId)) {
+    throw new InputError(`No saved token for user '${userId}' on ${url}.`);
+  }
+  setActiveUser(url, userId);
+  setActivePlatform(url);
+  return { baseUrl: url, userId };
+}
+function usersOf(baseUrl) {
+  const url = normalize(baseUrl);
+  return listPlatforms().find((p) => p.baseUrl === url)?.users ?? [];
+}
+function exportCreds() {
+  const baseUrl = activePlatform();
+  if (!baseUrl) throw new InputError("No active platform. Run `openbkn auth login` first.");
+  const token = readToken(baseUrl);
+  if (!token) throw new InputError(`No saved token for ${baseUrl}.`);
+  return {
+    baseUrl,
+    accessToken: token.accessToken,
+    refreshToken: token.refreshToken,
+    idToken: token.idToken
+  };
+}
+
+export {
+  rawCall,
+  DEFAULT_BUSINESS_DOMAIN,
+  DEFAULT_LIST_LIMIT,
+  DEFAULT_QUERY_LIMIT,
+  HttpError,
+  InputError,
+  toExitCode,
+  formatError,
+  activePlatform,
+  setActivePlatform,
+  readPlatformConfig,
+  writePlatformConfig,
+  resolveContext,
+  request,
+  changePassword,
+  renderOrgTree,
+  admin,
+  agents,
+  context,
+  dataflows,
+  parsePkMap,
+  kn,
+  models,
+  resources,
+  skills,
+  toolboxes,
+  renderReportMarkdown,
+  trace,
+  vega,
+  createClient,
+  attachToken,
+  status,
+  currentToken,
+  whoami,
+  listPlatforms2 as listPlatforms,
+  use,
+  logout,
+  deletePlatform,
+  switchUser,
+  usersOf,
+  exportCreds,
+  auth_exports
+};
+//# sourceMappingURL=chunk-4NXAIG4G.js.map