@nocobase/plugin-data-source-manager 2.1.0-alpha.1 → 2.1.0-alpha.11

package/dist/ai/common/utils.js

@@ -0,0 +1,87 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  MAX_QUERY_LIMIT: () => MAX_QUERY_LIMIT,
+  MAX_STRING_LENGTH: () => MAX_STRING_LENGTH,
+  buildPagedToolResult: () => buildPagedToolResult,
+  normalizeLimitOffset: () => normalizeLimitOffset,
+  truncateLongStrings: () => truncateLongStrings
+});
+module.exports = __toCommonJS(utils_exports);
+const MAX_STRING_LENGTH = 500;
+const MAX_QUERY_LIMIT = 100;
+function normalizeLimitOffset(args, options) {
+  const defaultLimit = (options == null ? void 0 : options.defaultLimit) ?? 50;
+  const maxLimit = (options == null ? void 0 : options.maxLimit) ?? MAX_QUERY_LIMIT;
+  const rawLimit = typeof args.limit === "number" && Number.isFinite(args.limit) ? args.limit : void 0;
+  const rawOffset = typeof args.offset === "number" && Number.isFinite(args.offset) ? args.offset : void 0;
+  const limit = Math.min(Math.max(rawLimit ?? defaultLimit, 1), maxLimit);
+  const offset = Math.max(rawOffset ?? 0, 0);
+  return { limit, offset };
+}
+function buildPagedToolResult(params) {
+  const returned = params.records.length;
+  const nextOffset = params.offset + returned;
+  const hasMore = params.total > nextOffset;
+  return {
+    total: params.total,
+    offset: params.offset,
+    limit: params.limit,
+    returned,
+    hasMore,
+    nextOffset,
+    records: params.records
+  };
+}
+function truncateLongStrings(obj, maxLen = MAX_STRING_LENGTH) {
+  if (obj === null || obj === void 0) {
+    return obj;
+  }
+  if (typeof obj === "string") {
+    return obj.length > maxLen ? obj.slice(0, maxLen) + "...[truncated]" : obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => truncateLongStrings(item, maxLen));
+  }
+  if (typeof obj === "object") {
+    const result = {};
+    for (const key in obj) {
+      result[key] = truncateLongStrings(obj[key], maxLen);
+    }
+    return result;
+  }
+  return obj;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MAX_QUERY_LIMIT,
+  MAX_STRING_LENGTH,
+  buildPagedToolResult,
+  normalizeLimitOffset,
+  truncateLongStrings
+});

package/dist/ai/skills/data-metadata/SKILLS.md

@@ -0,0 +1,103 @@
+---
+scope: GENERAL
+name: data-metadata
+description: helps get collection metadata (data model, like database table definition, RESTful API definition), like collection definition, field metadata
+introduction:
+  title: '{{t("ai.skills.dataMetadata.title", { ns: "@nocobase/plugin-data-source-manager" })}}'
+  about: '{{t("ai.skills.dataMetadata.about", { ns: "@nocobase/plugin-data-source-manager" })}}'
+---
+
+You are a professional data model metadata assistant for NocoBase.
+
+You help users explore and understand existing database schemas, including collection definitions, field metadata, and relationships.
+
+# Primary Workflows
+
+This skill focuses on reading and exploring existing data models, not creating or modifying them.
+
+## Data Source Exploration
+
+When users want to understand available data sources:
+
+1. **List Data Sources**
+   - Call `getDataSources` to retrieve all available data sources
+   - Present the data source list with their display names and database types
+
+2. **Select a Data Source**
+   - If the user mentions a specific data source, confirm which one to use
+   - Default to "main" if not specified
+
+## Collection Exploration
+
+When users want to understand what collections exist in a data source:
+
+1. **List Collections**
+   - Call `getCollectionNames` with the appropriate data source to get all collection names and titles
+
+2. **Explore Collection Details**
+   - Call `getCollectionMetadata` to retrieve detailed information about specific collections
+   - This includes field definitions, field types, interfaces, and options
+
+## Field Search
+
+When users want to find specific fields across collections:
+
+1. **Search by Keyword**
+   - Call `searchFieldMetadata` with keywords (e.g., "order amount", "user email")
+   - Optionally filter by data source, collection, or field type
+
+2. **Interpret Results**
+   - Present the search results with field names, titles, collection names, and data source
+   - If no exact results, explain suggested results
+
+# Available Tools
+
+- `getDataSources`: Lists all available data sources with their display names and database types.
+- `getCollectionNames`: Lists all collections in a specified data source with their names and titles. Use this to disambiguate user references.
+- `getCollectionMetadata`: Returns detailed field definitions and metadata for specified collections, including field types, interfaces, and options.
+- `searchFieldMetadata`: Searches for fields across data models by keyword. Returns either exact results or suggested results. Supports filtering by data source, collection, and field type.
+
+# Common Use Cases
+
+## Explore All Collections
+```
+User: "Show me all tables in the database"
+Action: Call getCollectionNames with dataSource="main"
+```
+
+## Get Collection Schema
+```
+User: "What fields does the users collection have?"
+Action: Call getCollectionMetadata with collectionNames=["users"]
+```
+
+## Search for Specific Fields
+```
+User: "Find fields related to email"
+Action: Call searchFieldMetadata with query="email"
+```
+
+## Understand Data Sources
+```
+User: "What databases are available?"
+Action: Call getDataSources
+```
+
+# Field Metadata Structure
+
+When displaying field metadata, present information clearly:
+
+| Property    | Description                                                     |
+| ----------- | --------------------------------------------------------------- |
+| `name`      | Field internal name                                             |
+| `title`     | Field display name                                              |
+| `type`      | Field data type (string, integer, boolean, etc.)                |
+| `interface` | Field interface type (input, select, m2o, etc.)                 |
+| `options`   | Additional field options (enum values, default, required, etc.) |
+
+# Notes
+
+- This skill is read-only - it does not modify any data or schema
+- Always confirm the data source before querying collections
+- When searching fields, provide context about which collection each field belongs to
+- Use clear formatting when presenting metadata to help users understand the schema

package/dist/ai/skills/data-metadata/tools/getCollectionMetadata.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+declare const _default: import("@nocobase/ai").ToolsOptions;
+export default _default;

package/dist/ai/skills/data-metadata/tools/getCollectionMetadata.js

@@ -0,0 +1,118 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getCollectionMetadata_exports = {};
+__export(getCollectionMetadata_exports, {
+  default: () => getCollectionMetadata_default
+});
+module.exports = __toCommonJS(getCollectionMetadata_exports);
+var import_ai = require("@nocobase/ai");
+var import_package = __toESM(require("../../../../../package.json"));
+var getCollectionMetadata_default = (0, import_ai.defineTools)({
+  scope: "SPECIFIED",
+  defaultPermission: "ALLOW",
+  introduction: {
+    title: `{{t("ai.tools.getCollectionMetadata.title", { ns: "${import_package.default.name}" })}}`,
+    about: `{{t("ai.tools.getCollectionMetadata.about", { ns: "${import_package.default.name}" })}}`
+  },
+  definition: {
+    name: "getCollectionMetadata",
+    description: "Retrieve metadata for specified collections and their fields",
+    schema: {
+      type: "object",
+      properties: {
+        dataSource: {
+          type: "string",
+          description: 'The data source name. Defaults to "main".'
+        },
+        collectionNames: {
+          type: "array",
+          items: {
+            type: "string"
+          },
+          description: "An array of collection names to retrieve metadata for."
+        }
+      },
+      required: ["collectionNames"],
+      additionalProperties: false
+    }
+  },
+  invoke: async (ctx, args) => {
+    const { collectionNames, dataSource = "main" } = args || {};
+    if (!collectionNames || !Array.isArray(collectionNames) || collectionNames.length === 0) {
+      return {
+        status: "error",
+        content: "No collection names provided or invalid format."
+      };
+    }
+    try {
+      const ds = ctx.app.dataSourceManager.dataSources.get(dataSource);
+      if (!ds) {
+        return {
+          status: "error",
+          content: `Data source "${dataSource}" not found`
+        };
+      }
+      const metadata = [];
+      for (const name of collectionNames) {
+        const collection = ds.collectionManager.getCollection(name);
+        if (!collection) continue;
+        const fields = collection.getFields().map((field) => {
+          return {
+            name: field.name,
+            type: field.type,
+            interface: field.options.interface,
+            options: field.options || {}
+          };
+        });
+        metadata.push({
+          name: collection.name,
+          title: collection.title,
+          fields
+        });
+      }
+      return {
+        status: "success",
+        content: JSON.stringify(metadata)
+      };
+    } catch (err) {
+      return {
+        status: "error",
+        content: `Failed to retrieve metadata: ${err.message}`
+      };
+    }
+  }
+});

package/dist/ai/skills/data-metadata/tools/getCollectionNames.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+declare const _default: import("@nocobase/ai").ToolsOptions;
+export default _default;

package/dist/ai/skills/data-metadata/tools/getCollectionNames.js

@@ -0,0 +1,95 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getCollectionNames_exports = {};
+__export(getCollectionNames_exports, {
+  default: () => getCollectionNames_default
+});
+module.exports = __toCommonJS(getCollectionNames_exports);
+var import_ai = require("@nocobase/ai");
+var import_package = __toESM(require("../../../../../package.json"));
+var getCollectionNames_default = (0, import_ai.defineTools)({
+  scope: "SPECIFIED",
+  defaultPermission: "ALLOW",
+  introduction: {
+    title: `{{t("ai.tools.getCollectionNames.title", { ns: "${import_package.default.name}" })}}`,
+    about: `{{t("ai.tools.getCollectionNames.about", { ns: "${import_package.default.name}" })}}`
+  },
+  definition: {
+    name: "getCollectionNames",
+    description: "Retrieve names and titles map of all collections",
+    schema: {
+      type: "object",
+      properties: {
+        dataSource: {
+          type: "string",
+          description: 'The data source name to retrieve collections from. Defaults to "main".'
+        }
+      },
+      additionalProperties: false
+    }
+  },
+  invoke: async (ctx, args) => {
+    const { dataSource = "main" } = args || {};
+    let names = [];
+    try {
+      const ds = ctx.app.dataSourceManager.dataSources.get(dataSource);
+      if (!ds) {
+        throw new Error(`Data source "${dataSource}" not found`);
+      }
+      const collections = ds.collectionManager.getCollections();
+      names = collections.map((collection) => ({
+        name: collection.name,
+        title: collection.title
+      }));
+    } catch (err) {
+      ctx.log.error(err, {
+        module: "ai",
+        subModule: "toolCalling",
+        groupName: "dataModeling",
+        toolName: "getCollectionNames"
+      });
+      return {
+        status: "error",
+        content: `Failed to retrieve collection names: ${err.message}`
+      };
+    }
+    return {
+      status: "success",
+      content: JSON.stringify(names)
+    };
+  }
+});

package/dist/ai/skills/data-metadata/tools/getDataSources.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+declare const _default: import("@nocobase/ai").ToolsOptions;
+export default _default;

package/dist/ai/skills/data-metadata/tools/getDataSources.js

@@ -0,0 +1,84 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getDataSources_exports = {};
+__export(getDataSources_exports, {
+  default: () => getDataSources_default
+});
+module.exports = __toCommonJS(getDataSources_exports);
+var import_ai = require("@nocobase/ai");
+var import_package = __toESM(require("../../../../../package.json"));
+var getDataSources_default = (0, import_ai.defineTools)({
+  scope: "SPECIFIED",
+  defaultPermission: "ALLOW",
+  introduction: {
+    title: `{{t("ai.tools.getDataSources.title", { ns: "${import_package.default.name}" })}}`,
+    about: `{{t("ai.tools.getDataSources.about", { ns: "${import_package.default.name}" })}}`
+  },
+  definition: {
+    name: "getDataSources",
+    description: "Retrieve list of all available data sources",
+    schema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  },
+  invoke: async (ctx) => {
+    var _a, _b, _c;
+    try {
+      const records = await ctx.db.getRepository("dataSources").find();
+      const displayNameMap = new Map(records.map((r) => [r.get("key"), r.get("displayName")]));
+      const dataSources = [];
+      for (const [key, ds] of ctx.app.dataSourceManager.dataSources) {
+        dataSources.push({
+          key,
+          displayName: displayNameMap.get(key) || key,
+          type: ((_c = (_b = (_a = ds.collectionManager) == null ? void 0 : _a.db) == null ? void 0 : _b.sequelize) == null ? void 0 : _c.getDialect()) || "unknown"
+        });
+      }
+      return {
+        status: "success",
+        content: JSON.stringify(dataSources)
+      };
+    } catch (err) {
+      return {
+        status: "error",
+        content: `Failed to retrieve data sources: ${err.message}`
+      };
+    }
+  }
+});

package/dist/ai/skills/data-metadata/tools/searchFieldMetadata.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+declare const _default: import("@nocobase/ai").ToolsOptions;
+export default _default;

package/dist/ai/skills/data-metadata/tools/searchFieldMetadata.js

@@ -0,0 +1,151 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var searchFieldMetadata_exports = {};
+__export(searchFieldMetadata_exports, {
+  default: () => searchFieldMetadata_default
+});
+module.exports = __toCommonJS(searchFieldMetadata_exports);
+var import_ai = require("@nocobase/ai");
+var import_package = __toESM(require("../../../../../package.json"));
+var searchFieldMetadata_default = (0, import_ai.defineTools)({
+  scope: "SPECIFIED",
+  defaultPermission: "ALLOW",
+  introduction: {
+    title: `{{t("ai.tools.searchFieldMetadata.title", { ns: "${import_package.default.name}" })}}`,
+    about: `{{t("ai.tools.searchFieldMetadata.about", { ns: "${import_package.default.name}" })}}`
+  },
+  definition: {
+    name: "searchFieldMetadata",
+    description: "Search fields in data models by keyword (english first). Returns either search results or a suggested query.",
+    schema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: 'Search keywords, e.g. "order amount", "user email".'
+        },
+        dataSource: {
+          type: "string",
+          description: "Limit search to a specific data source."
+        },
+        collection: {
+          type: "string",
+          description: "Limit search to a specific collection."
+        },
+        fieldType: {
+          type: "string",
+          description: 'Limit search to a specific field type, e.g. "string", "number".'
+        },
+        limit: {
+          type: "number",
+          minimum: 1,
+          maximum: 20,
+          description: "Maximum number of results to return. Default is 5."
+        }
+      },
+      required: ["query"],
+      additionalProperties: false
+    }
+  },
+  invoke: async (ctx, args) => {
+    const { query, dataSource: dataSourceArg, collection: collectionArg, fieldType, limit = 5 } = args || {};
+    if (!query || typeof query !== "string") {
+      return {
+        status: "error",
+        content: "Search query is required."
+      };
+    }
+    try {
+      const aiManager = ctx.app.aiManager;
+      const index = aiManager.documentManager.getIndex("dataModels.fields");
+      if (!index) {
+        return {
+          status: "error",
+          content: "Field search index is not available."
+        };
+      }
+      let isSuggest = false;
+      let result = await index.search(query, {
+        limit: Math.min(limit * 3, 20)
+      });
+      if (!(result == null ? void 0 : result.length)) {
+        result = await index.search(query, {
+          suggest: true,
+          limit: Math.min(limit * 3, 20)
+        });
+        isSuggest = true;
+      }
+      const results = (result || []).map((path) => {
+        var _a, _b;
+        const [ds, coll, f] = path.split(".");
+        if (dataSourceArg && ds !== dataSourceArg) {
+          return null;
+        }
+        if (collectionArg && coll !== collectionArg) {
+          return null;
+        }
+        const dataSource = ctx.app.dataSourceManager.get(ds);
+        const collection = dataSource.collectionManager.getCollection(coll);
+        const field = collection.getField(f);
+        if (fieldType && field.type !== fieldType) {
+          return null;
+        }
+        return {
+          name: field.name,
+          title: ((_b = (_a = field.options) == null ? void 0 : _a.uiSchema) == null ? void 0 : _b.title) || field.name,
+          dataSource: ds,
+          collection: coll,
+          fieldType: field.type,
+          options: field.options
+        };
+      }).filter(Boolean).slice(0, limit);
+      return {
+        status: "success",
+        content: JSON.stringify({
+          kind: !isSuggest ? "exact_results" : "suggested_results",
+          results
+        })
+      };
+    } catch (err) {
+      ctx.log.error(err, { module: "ai-employees", submodule: "tool-calling", method: "searchFieldMetadata" });
+      return {
+        status: "error",
+        content: `Failed to search field metadata: ${err.message}`
+      };
+    }
+  }
+});