@redonvn/redai-openapi-router 0.1.1

package/dist/index.js

@@ -0,0 +1,795 @@
+// index.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+
+// ../redai-agent-sdk/dist/index.js
+var DEFAULT_BASE_URL = "https://api.redai.vn/api/v1";
+var encodeQueryValue = (value) => {
+  if (value === void 0) {
+    return [];
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => String(item));
+  }
+  return [String(value)];
+};
+var headersToObject = (headers) => {
+  const result = {};
+  headers.forEach((value, key) => {
+    result[key] = value;
+  });
+  return result;
+};
+var applyPathParams = (pathTemplate, pathParams) => pathTemplate.replace(/\{([^}]+)\}/g, (_, key) => {
+  const raw = pathParams?.[key];
+  if (raw === void 0 || raw === null) {
+    throw new RedaiAgentError(`Missing required path parameter: ${key}`);
+  }
+  return encodeURIComponent(String(raw));
+});
+var buildUrl = (baseUrl, path2, query) => {
+  const url = new URL(baseUrl);
+  const normalizedBasePath = url.pathname.replace(/\/+$/, "");
+  const normalizedRequestPath = path2.startsWith("/") ? path2 : `/${path2}`;
+  url.pathname = `${normalizedBasePath}${normalizedRequestPath}`.replace(/\/{2,}/g, "/");
+  if (query) {
+    for (const [key, value] of Object.entries(query)) {
+      for (const item of encodeQueryValue(value)) {
+        url.searchParams.append(key, item);
+      }
+    }
+  }
+  return url;
+};
+var parseResponse = async (response) => {
+  const contentType = response.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    return response.json();
+  }
+  return response.text();
+};
+var RedaiAgentError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "RedaiAgentError";
+    this.status = options?.status;
+    this.body = options?.body;
+  }
+};
+var RedaiAgentClient = class {
+  constructor(options = {}) {
+    this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+    this.bearerToken = options.bearerToken;
+    this.apiKey = options.apiKey;
+    this.apiKeyHeader = options.apiKeyHeader ?? "x-api-key";
+    this.defaultHeaders = options.defaultHeaders;
+    this.timeoutMs = options.timeoutMs;
+    this.fetchImpl = options.fetch ?? globalThis.fetch;
+    this.tenantContext = {
+      workspaceId: options.workspaceId,
+      baseId: options.baseId
+    };
+  }
+  createTenantHeaders(overrides) {
+    const workspaceId = overrides?.workspaceId ?? this.tenantContext.workspaceId;
+    const baseId = overrides?.baseId ?? this.tenantContext.baseId;
+    return {
+      "x-workspace-id": workspaceId,
+      "x-base-id": baseId
+    };
+  }
+  async executeTool(tool, input = {}) {
+    return this.request({
+      method: tool.method,
+      path: tool.path,
+      pathParams: input.path,
+      query: input.query,
+      headers: input.headers,
+      body: input.body
+    });
+  }
+  async request(request) {
+    const url = buildUrl(this.baseUrl, applyPathParams(request.path, request.pathParams), request.query);
+    const controller = new AbortController();
+    const timeout = this.timeoutMs ? setTimeout(() => controller.abort(), this.timeoutMs) : void 0;
+    const headers = this.buildHeaders(request.method, request.headers, request.body !== void 0);
+    try {
+      const response = await this.fetchImpl(url, {
+        method: request.method,
+        headers,
+        body: request.body === void 0 ? void 0 : JSON.stringify(request.body),
+        signal: controller.signal
+      });
+      const data = await parseResponse(response);
+      const result = {
+        ok: response.ok,
+        status: response.status,
+        statusText: response.statusText,
+        headers: headersToObject(response.headers),
+        data
+      };
+      if (!response.ok) {
+        throw new RedaiAgentError(`Request failed with status ${response.status}`, {
+          status: response.status,
+          body: data
+        });
+      }
+      return result;
+    } catch (error) {
+      if (error instanceof RedaiAgentError) {
+        throw error;
+      }
+      throw new RedaiAgentError("Request failed", { body: error });
+    } finally {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+    }
+  }
+  buildHeaders(method, requestHeaders, hasBody) {
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(this.defaultHeaders ?? {})) {
+      headers.set(key, value);
+    }
+    for (const [key, value] of Object.entries(this.createTenantHeaders())) {
+      if (value !== void 0 && value !== null && value !== "") {
+        headers.set(key, value);
+      }
+    }
+    if (this.bearerToken) {
+      headers.set("authorization", `Bearer ${this.bearerToken}`);
+    } else if (this.apiKey) {
+      headers.set(this.apiKeyHeader ?? "x-api-key", this.apiKey);
+    }
+    for (const [key, value] of Object.entries(requestHeaders ?? {})) {
+      if (value !== void 0 && value !== null && value !== "") {
+        headers.set(key, value);
+      }
+    }
+    if (!headers.has("accept")) {
+      headers.set("accept", "application/json");
+    }
+    if (hasBody && method !== "GET" && !headers.has("content-type")) {
+      headers.set("content-type", "application/json");
+    }
+    return headers;
+  }
+};
+
+// tool-catalog.json
+var tool_catalog_default = {
+  pluginId: "redai-openapi-router",
+  pluginName: "RedAI OpenAPI Router",
+  version: "0.1.0",
+  description: "Router plugin de tim module, operation va execute lazy cho RedAI OpenAPI.",
+  optional: true,
+  tools: [
+    {
+      name: "redai_router_list_modules",
+      description: "Liet ke cac module RedAI co san trong router.",
+      parameters: { type: "object", properties: {}, additionalProperties: false }
+    },
+    {
+      name: "redai_router_search",
+      description: "Tim operation phu hop theo y nghia nghiep vu, module va tu khoa.",
+      parameters: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "Yeu cau nghiep vu can tim operation." },
+          moduleId: { type: "string", description: "Loc theo module cu the neu da biet." },
+          limit: { type: "number", description: "So ket qua toi da tra ve.", default: 8 }
+        },
+        required: ["query"],
+        additionalProperties: false
+      }
+    },
+    {
+      name: "redai_router_get_module",
+      description: "Lay metadata module, feature groups, common tasks va operations shortlist.",
+      parameters: {
+        type: "object",
+        properties: {
+          moduleId: { type: "string", description: "ID module can xem." },
+          includeOperations: { type: "boolean", description: "Co tra ve danh sach operation rut gon hay khong.", default: true },
+          operationLimit: { type: "number", description: "So operation toi da tra ve khi includeOperations=true.", default: 12 }
+        },
+        required: ["moduleId"],
+        additionalProperties: false
+      }
+    },
+    {
+      name: "redai_router_get_operation",
+      description: "Lay metadata chi tiet va schema tham so cua mot operation cu the.",
+      parameters: {
+        type: "object",
+        properties: {
+          operationId: { type: "string", description: "ID operation can xem." }
+        },
+        required: ["operationId"],
+        additionalProperties: false
+      }
+    },
+    {
+      name: "redai_router_execute",
+      description: "Execute operation thong qua router va auth RedAI da login trong DM.",
+      parameters: {
+        type: "object",
+        properties: {
+          operationId: { type: "string", description: "ID operation can goi." },
+          telegramUserId: { type: "string", description: "Telegram sender ID tu DM hien tai." },
+          args: { type: "object", description: "Tham so operation theo shape path/query/body/headers.", additionalProperties: true },
+          confirm: { type: "boolean", description: "Xac nhan cho operation co risk cao.", default: false }
+        },
+        required: ["operationId", "telegramUserId"],
+        additionalProperties: false
+      }
+    }
+  ]
+};
+
+// index.ts
+var typedToolCatalog = tool_catalog_default;
+var DEFAULT_AUTH_STORE_PATH = "C:\\Users\\Acer\\.openclaw\\workspace-nhan-vien-redai\\auth\\redai-auth.json";
+var currentDir = path.dirname(fileURLToPath(import.meta.url));
+var dataRoot = path.resolve(currentDir, "..", "data");
+var sitemapPath = path.join(dataRoot, "sitemap.json");
+var moduleCache = /* @__PURE__ */ new Map();
+var sitemapCache = null;
+var formatToolResult = (payload) => ({
+  content: [
+    {
+      type: "text",
+      text: typeof payload === "string" ? payload : JSON.stringify(payload, null, 2)
+    }
+  ]
+});
+var resolvePluginConfig = (api) => api.config?.plugins?.entries?.[typedToolCatalog.pluginId]?.config ?? {};
+var ensureStoreDirectory = async (storePath) => {
+  await mkdir(path.dirname(storePath), { recursive: true });
+};
+var getAuthStorePath = (runtimeConfig) => runtimeConfig.authStorePath?.trim() || DEFAULT_AUTH_STORE_PATH;
+var loadAuthStore = async (runtimeConfig) => {
+  const storePath = getAuthStorePath(runtimeConfig);
+  try {
+    const raw = await readFile(storePath, "utf8");
+    const parsed = JSON.parse(raw);
+    return { version: 1, users: parsed?.users ?? {} };
+  } catch (error) {
+    const maybeNodeError = error;
+    if (maybeNodeError?.code === "ENOENT") {
+      await ensureStoreDirectory(storePath);
+      await writeFile(storePath, JSON.stringify({ version: 1, users: {} }, null, 2), "utf8");
+      return { version: 1, users: {} };
+    }
+    throw error;
+  }
+};
+var getAuthStoreEntry = async (runtimeConfig, telegramUserId) => {
+  const store = await loadAuthStore(runtimeConfig);
+  return store.users[telegramUserId] ?? null;
+};
+var withRedaiAuth = (runtimeConfig, auth) => {
+  const defaultHeaders = {
+    ...runtimeConfig.defaultHeaders ?? {},
+    "x-workspace-id": auth.workspaceId
+  };
+  if (auth.baseId) {
+    defaultHeaders["x-base-id"] = auth.baseId;
+  } else {
+    delete defaultHeaders["x-base-id"];
+  }
+  return {
+    ...runtimeConfig,
+    bearerToken: auth.bearerToken,
+    apiKey: void 0,
+    apiKeyHeader: void 0,
+    defaultHeaders,
+    workspaceId: auth.workspaceId,
+    baseId: auth.baseId ?? void 0
+  };
+};
+var resolveUserRuntimeConfig = async (api, telegramUserId) => {
+  const runtimeConfig = resolvePluginConfig(api);
+  const authEntry = await getAuthStoreEntry(runtimeConfig, telegramUserId);
+  if (!authEntry || authEntry.status !== "active") {
+    return null;
+  }
+  return {
+    runtimeConfig,
+    scopedConfig: withRedaiAuth(runtimeConfig, authEntry)
+  };
+};
+var authRequiredResult = (telegramUserId) => formatToolResult({
+  ok: false,
+  status: 401,
+  statusText: "AUTH_REQUIRED",
+  data: {
+    message: "Ban chua dang nhap RedAI auth hop le. Hay dung /login <bearerToken> <workspaceId> [baseId] trong DM truoc khi thao tac nghiep vu.",
+    telegramUserId
+  }
+});
+var normalizeText = (value) => value.normalize("NFKD").replace(/[^\w\s-]/g, " ").toLowerCase();
+var tokenize = (value) => normalizeText(value).split(/\s+/).map((item) => item.trim()).filter(Boolean);
+var READ_HINTS = [
+  "xem",
+  "liet",
+  "lietke",
+  "list",
+  "get",
+  "chi",
+  "tiet",
+  "detail",
+  "thong",
+  "tin",
+  "tim",
+  "kiem",
+  "search",
+  "find",
+  "tra",
+  "cuu",
+  "kiemtra",
+  "check",
+  "doc",
+  "read",
+  "preview"
+];
+var MUTATION_HINTS = [
+  "tao",
+  "them",
+  "cap",
+  "nhat",
+  "update",
+  "create",
+  "edit",
+  "sua",
+  "run",
+  "execute",
+  "gui",
+  "send",
+  "pause",
+  "resume",
+  "sync",
+  "train",
+  "fine",
+  "tuning"
+];
+var DESTRUCTIVE_HINTS = [
+  "xoa",
+  "delete",
+  "remove",
+  "huy",
+  "cancel",
+  "reset",
+  "clear",
+  "drop"
+];
+var BULK_HINTS = ["hangloat", "bulk", "batch", "nhieu", "tatca", "all"];
+var EXPORT_HINTS = ["export", "tai", "file", "csv", "excel", "download"];
+var inferQueryIntent = (query, queryTokens) => {
+  const normalizedQuery = normalizeText(query);
+  const hasAnyHint = (hints) => hints.some((hint) => normalizedQuery.includes(normalizeText(hint)) || queryTokens.includes(normalizeText(hint)));
+  return {
+    wantsRead: hasAnyHint(READ_HINTS),
+    wantsMutation: hasAnyHint(MUTATION_HINTS),
+    wantsDestructive: hasAnyHint(DESTRUCTIVE_HINTS),
+    wantsBulk: hasAnyHint(BULK_HINTS),
+    wantsExport: hasAnyHint(EXPORT_HINTS),
+    mentionsExactOperation: normalizedQuery.includes(":") || normalizedQuery.includes("_v1")
+  };
+};
+var getSitemap = async () => {
+  if (!sitemapCache) {
+    sitemapCache = JSON.parse(await readFile(sitemapPath, "utf8"));
+  }
+  return sitemapCache;
+};
+var getModuleDoc = async (moduleId) => {
+  if (moduleCache.has(moduleId)) {
+    return moduleCache.get(moduleId) ?? null;
+  }
+  const sitemap = await getSitemap();
+  const entry = sitemap.modules.find((item) => item.id === moduleId);
+  if (!entry) {
+    return null;
+  }
+  const parsed = JSON.parse(await readFile(path.join(dataRoot, entry.moduleFile), "utf8"));
+  moduleCache.set(moduleId, parsed);
+  return parsed;
+};
+var findOperation = async (operationId) => {
+  const moduleId = operationId.split(":")[0];
+  const moduleDoc = await getModuleDoc(moduleId);
+  return moduleDoc?.operations.find((item) => item.id === operationId) ?? null;
+};
+var scoreOperation = (queryTokens, intent, requestedModuleId, moduleDoc, operation) => {
+  let score = 0;
+  const exactQuery = queryTokens.join(" ");
+  const opJoined = normalizeText(
+    [
+      operation.id,
+      operation.operationId,
+      operation.title,
+      operation.summary,
+      operation.businessMeaning,
+      ...operation.tags,
+      ...operation.keywords
+    ].join(" ")
+  );
+  const moduleJoined = normalizeText(
+    [moduleDoc.id, moduleDoc.title, moduleDoc.summary, moduleDoc.purpose, ...moduleDoc.keywords].join(" ")
+  );
+  if (requestedModuleId && moduleDoc.id === requestedModuleId) {
+    score += 20;
+  }
+  if (normalizeText(operation.id) === exactQuery || normalizeText(operation.operationId) === exactQuery) {
+    score += 100;
+  }
+  for (const token of queryTokens) {
+    if (normalizeText(operation.operationId).includes(token)) {
+      score += 20;
+    }
+    if (opJoined.includes(token)) {
+      score += 12;
+    }
+    if (moduleJoined.includes(token)) {
+      score += 6;
+    }
+  }
+  if (operation.method === "GET") {
+    score += 4;
+  } else {
+    score -= 2;
+  }
+  if (operation.riskLevel === "safe") {
+    score += 8;
+  }
+  if (operation.riskLevel === "confirm_required") {
+    score -= 8;
+  }
+  if (operation.riskLevel === "costly") {
+    score -= intent.wantsMutation ? 6 : 18;
+  }
+  if (operation.riskLevel === "destructive") {
+    score -= intent.wantsDestructive ? 10 : 32;
+  }
+  const opText = normalizeText(
+    [
+      operation.id,
+      operation.operationId,
+      operation.title,
+      operation.summary,
+      operation.businessMeaning,
+      ...operation.whenToUse,
+      ...operation.whenNotToUse,
+      ...operation.keywords
+    ].join(" ")
+  );
+  if (intent.wantsRead) {
+    if (operation.method === "GET") {
+      score += 10;
+    }
+    if (operation.riskLevel === "safe") {
+      score += 6;
+    }
+  }
+  if (intent.wantsMutation && operation.method !== "GET") {
+    score += 10;
+  }
+  if (intent.wantsDestructive && /(delete|remove|cancel|reset|bulkremove|bulkdelete|destroy|xoa|huy)/.test(opText)) {
+    score += 18;
+  }
+  if (intent.wantsBulk && /(bulk|batch|hang loat|tat ca|all)/.test(opText)) {
+    score += 12;
+  }
+  if (intent.wantsExport && /(export|download|csv|excel|file)/.test(opText)) {
+    score += 16;
+  }
+  if (!intent.wantsMutation && !intent.wantsDestructive && operation.method !== "GET") {
+    score -= 10;
+  }
+  if (!intent.wantsBulk && /(bulk|batch)/.test(opText)) {
+    score -= 10;
+  }
+  if (!intent.wantsExport && /(export|download)/.test(opText)) {
+    score -= 10;
+  }
+  if (!intent.mentionsExactOperation && operation.confirmationRequired) {
+    score -= 8;
+  }
+  return score;
+};
+var summarizeOperation = (operation) => ({
+  id: operation.id,
+  title: operation.title,
+  summary: operation.summary,
+  method: operation.method,
+  path: operation.path,
+  riskLevel: operation.riskLevel,
+  confirmationRequired: operation.confirmationRequired,
+  featureGroupId: operation.featureGroupId
+});
+var buildMatchReasons = (queryTokens, intent, moduleDoc, operation) => {
+  const reasons = [];
+  const normalizedOperation = normalizeText(
+    [operation.operationId, operation.title, ...operation.tags, ...operation.keywords].join(" ")
+  );
+  const normalizedModule = normalizeText([moduleDoc.title, ...moduleDoc.keywords].join(" "));
+  if (queryTokens.some((token) => normalizeText(operation.operationId).includes(token))) {
+    reasons.push("operation-id");
+  }
+  if (queryTokens.some((token) => normalizedOperation.includes(token))) {
+    reasons.push("keyword");
+  }
+  if (queryTokens.some((token) => normalizedModule.includes(token))) {
+    reasons.push("module");
+  }
+  if (intent.wantsRead && operation.method === "GET") {
+    reasons.push("read-safe");
+  }
+  if (intent.wantsMutation && operation.method !== "GET") {
+    reasons.push("write-intent");
+  }
+  if (intent.wantsDestructive && operation.riskLevel === "destructive") {
+    reasons.push("destructive-intent");
+  }
+  if (intent.wantsExport && /(export|download)/.test(normalizeText(operation.id))) {
+    reasons.push("export-intent");
+  }
+  return reasons.length > 0 ? reasons : [operation.tags[0] ?? moduleDoc.title];
+};
+var hasHeadersSection = (schema) => {
+  const objectSchema = schema;
+  return Boolean(objectSchema?.properties?.headers);
+};
+var mergeTenantHeaders = (schema, inputHeaders, runtimeConfig) => {
+  const entries = Object.entries(inputHeaders ?? {}).filter(([, value]) => value !== void 0 && value !== null && value !== "").map(([key, value]) => [key, String(value)]);
+  if (hasHeadersSection(schema)) {
+    if (runtimeConfig.workspaceId && !entries.some(([key]) => key.toLowerCase() === "x-workspace-id")) {
+      entries.push(["x-workspace-id", runtimeConfig.workspaceId]);
+    }
+    if (runtimeConfig.baseId && !entries.some(([key]) => key.toLowerCase() === "x-base-id")) {
+      entries.push(["x-base-id", runtimeConfig.baseId]);
+    }
+  }
+  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+};
+var executeOperation = async (runtimeConfig, operation, rawArgs) => {
+  const client = new RedaiAgentClient({
+    ...runtimeConfig,
+    baseUrl: runtimeConfig.baseUrl
+  });
+  const args = rawArgs ?? {};
+  return client.executeTool(
+    { method: operation.method, path: operation.path },
+    {
+      path: args.path,
+      query: args.query,
+      body: args.body,
+      headers: mergeTenantHeaders(operation.parameterSchema, args.headers, runtimeConfig)
+    }
+  );
+};
+function register(api) {
+  api.registerTool(
+    {
+      name: "redai_router_list_modules",
+      description: "Liet ke cac module RedAI co san trong router.",
+      parameters: { type: "object", properties: {}, additionalProperties: false },
+      execute: async () => {
+        const sitemap = await getSitemap();
+        return formatToolResult({
+          catalogVersion: sitemap.catalogVersion,
+          generatedAt: sitemap.generatedAt,
+          modules: sitemap.modules.map((item) => ({
+            id: item.id,
+            title: item.title,
+            summary: item.summary,
+            whenToUse: item.whenToUse,
+            whenNotToUse: item.whenNotToUse,
+            operationCount: item.operationCount,
+            topOperations: item.topOperations
+          }))
+        });
+      }
+    },
+    { optional: typedToolCatalog.optional ?? true }
+  );
+  api.registerTool(
+    {
+      name: "redai_router_search",
+      description: "Tim operation phu hop theo y nghia nghiep vu, module va tu khoa.",
+      parameters: {
+        type: "object",
+        properties: {
+          query: { type: "string" },
+          moduleId: { type: "string" },
+          limit: { type: "number", default: 8 }
+        },
+        required: ["query"],
+        additionalProperties: false
+      },
+      execute: async (_id, rawParams) => {
+        const params = rawParams ?? {};
+        const sitemap = await getSitemap();
+        const moduleEntries = params.moduleId ? sitemap.modules.filter((item) => item.id === params.moduleId) : sitemap.modules;
+        const queryTokens = tokenize(params.query);
+        const intent = inferQueryIntent(params.query, queryTokens);
+        const results = [];
+        for (const entry of moduleEntries) {
+          const moduleDoc = await getModuleDoc(entry.id);
+          if (!moduleDoc) {
+            continue;
+          }
+          for (const operation of moduleDoc.operations) {
+            const score = scoreOperation(queryTokens, intent, params.moduleId, moduleDoc, operation);
+            if (score < 12) {
+              continue;
+            }
+            results.push({
+              moduleId: moduleDoc.id,
+              moduleTitle: moduleDoc.title,
+              operationId: operation.id,
+              title: operation.title,
+              summary: operation.summary,
+              riskLevel: operation.riskLevel,
+              reasonMatched: buildMatchReasons(queryTokens, intent, moduleDoc, operation),
+              score
+            });
+          }
+        }
+        results.sort((left, right) => right.score - left.score);
+        return formatToolResult({
+          query: params.query,
+          moduleId: params.moduleId ?? null,
+          inferredIntent: intent,
+          matches: results.slice(0, Math.max(1, Math.min(params.limit ?? 8, 20)))
+        });
+      }
+    },
+    { optional: typedToolCatalog.optional ?? true }
+  );
+  api.registerTool(
+    {
+      name: "redai_router_get_module",
+      description: "Lay metadata module, feature groups, common tasks va operations shortlist.",
+      parameters: {
+        type: "object",
+        properties: {
+          moduleId: { type: "string" },
+          includeOperations: { type: "boolean", default: true },
+          operationLimit: { type: "number", default: 12 }
+        },
+        required: ["moduleId"],
+        additionalProperties: false
+      },
+      execute: async (_id, rawParams) => {
+        const params = rawParams ?? {};
+        const moduleDoc = await getModuleDoc(params.moduleId);
+        if (!moduleDoc) {
+          return formatToolResult({ ok: false, status: 404, statusText: "MODULE_NOT_FOUND", data: { moduleId: params.moduleId } });
+        }
+        return formatToolResult({
+          id: moduleDoc.id,
+          title: moduleDoc.title,
+          summary: moduleDoc.summary,
+          purpose: moduleDoc.purpose,
+          whenToUse: moduleDoc.whenToUse,
+          whenNotToUse: moduleDoc.whenNotToUse,
+          keywords: moduleDoc.keywords,
+          commonTasks: moduleDoc.commonTasks,
+          featureGroups: moduleDoc.featureGroups,
+          operations: params.includeOperations === false ? void 0 : moduleDoc.operations.slice(0, Math.max(1, Math.min(params.operationLimit ?? 12, 40))).map(summarizeOperation)
+        });
+      }
+    },
+    { optional: typedToolCatalog.optional ?? true }
+  );
+  api.registerTool(
+    {
+      name: "redai_router_get_operation",
+      description: "Lay metadata chi tiet va schema tham so cua mot operation cu the.",
+      parameters: {
+        type: "object",
+        properties: {
+          operationId: { type: "string" }
+        },
+        required: ["operationId"],
+        additionalProperties: false
+      },
+      execute: async (_id, rawParams) => {
+        const params = rawParams ?? {};
+        const operation = await findOperation(params.operationId);
+        if (!operation) {
+          return formatToolResult({ ok: false, status: 404, statusText: "OPERATION_NOT_FOUND", data: { operationId: params.operationId } });
+        }
+        return formatToolResult(operation);
+      }
+    },
+    { optional: typedToolCatalog.optional ?? true }
+  );
+  api.registerTool(
+    {
+      name: "redai_router_execute",
+      description: "Execute operation thong qua router va auth RedAI da login trong DM.",
+      parameters: {
+        type: "object",
+        properties: {
+          operationId: { type: "string" },
+          telegramUserId: { type: "string" },
+          args: { type: "object", additionalProperties: true },
+          confirm: { type: "boolean", default: false }
+        },
+        required: ["operationId", "telegramUserId"],
+        additionalProperties: false
+      },
+      execute: async (_id, rawParams) => {
+        const params = rawParams ?? {};
+        const operation = await findOperation(params.operationId);
+        if (!operation) {
+          return formatToolResult({ ok: false, status: 404, statusText: "OPERATION_NOT_FOUND", data: { operationId: params.operationId } });
+        }
+        if (operation.confirmationRequired && !params.confirm) {
+          return formatToolResult({
+            ok: false,
+            status: 412,
+            statusText: "CONFIRMATION_REQUIRED",
+            data: {
+              operationId: operation.id,
+              title: operation.title,
+              riskLevel: operation.riskLevel,
+              message: "Operation nay co risk cao hoac co tac dong that. Hay goi lai voi confirm=true sau khi da xac nhan voi user."
+            }
+          });
+        }
+        if (operation.riskLevel === "destructive" && !params.confirm) {
+          return formatToolResult({
+            ok: false,
+            status: 412,
+            statusText: "DESTRUCTIVE_CONFIRMATION_REQUIRED",
+            data: {
+              operationId: operation.id,
+              title: operation.title,
+              riskLevel: operation.riskLevel,
+              message: "Operation destructive bi chan mac dinh. Chi duoc goi khi user xac nhan ro va confirm=true."
+            }
+          });
+        }
+        const resolved = await resolveUserRuntimeConfig(api, params.telegramUserId);
+        if (!resolved) {
+          return authRequiredResult(params.telegramUserId);
+        }
+        try {
+          const response = await executeOperation(resolved.scopedConfig, operation, params.args);
+          return formatToolResult({
+            operationId: operation.id,
+            ok: response.ok,
+            status: response.status,
+            statusText: response.statusText,
+            data: response.data
+          });
+        } catch (error) {
+          if (error instanceof RedaiAgentError) {
+            return formatToolResult({
+              ok: false,
+              status: error.status ?? 500,
+              statusText: error.message,
+              data: error.body
+            });
+          }
+          return formatToolResult({
+            ok: false,
+            status: 500,
+            statusText: "ROUTER_EXECUTION_FAILED",
+            data: String(error)
+          });
+        }
+      }
+    },
+    { optional: typedToolCatalog.optional ?? true }
+  );
+}
+export {
+  register as default
+};
+//# sourceMappingURL=index.js.map