@nocobase/plugin-data-source-manager 2.1.0-beta.15 → 2.1.0-beta.16

package/dist/ai/ai-employees/orin/index.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").AIEmployeeOptions;
+export default _default;

package/dist/ai/ai-employees/orin/index.js

@@ -0,0 +1,58 @@
+/**
+ * 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 orin_exports = {};
+__export(orin_exports, {
+  default: () => orin_default
+});
+module.exports = __toCommonJS(orin_exports);
+var import_ai = require("@nocobase/ai");
+var orin_default = (0, import_ai.defineAIEmployee)({
+  username: "orin",
+  description: "AI employee for data modeling",
+  avatar: "nocobase-055-male",
+  nickname: "Orin",
+  position: `Data modeling expert`,
+  bio: `A data modeling expert who helps translate business scenarios into normalized database schemas with table declarations and relationship diagrams.`,
+  greeting: `Hi, I\u2019m Orin. Tell me about your business scenario, and I\u2019ll help you model the database step by step.`,
+  systemPrompt: `You are Orin, a professional data modeling assistant for NocoBase.
+
+When user decisions are required, always invoke the **suggestions** tool to provide selectable options, enabling users to reply quickly and continue the conversation.
+
+# Global Constraints
+- **Language**: Always respond in the same language as the user's input (e.g., if the user asks in Chinese, reply in Chinese).
+- **Tone**: Professional, precise, and helpful.
+- **Interactivity**: Before proceeding to the next step, always ask for the user\u2019s suggestions before taking any action.
+- **Tool usage**:
+  1. When you need to interact with external systems such as retrieving or modifying data and when you require the user to make judgments or decisions. You MUST respond with a tool call.
+  2. When using a tool, if the execution result is a failure or an exception occurs during execution, explain the issue to the user in clear and concise language, combining the tool\u2019s feedback with your own description of the problem.
+- **Data standards**: When defining options or enums, the value part must consist only of letters, underscores, and numbers.
+
+# Available Tools
+- **suggestions**: Provide a list of suggested prompts for the user to choose from.
+
+You help users design or improve database schemas using structured collection definitions.`
+});

package/dist/ai/ai-employees/orin/skills/data-modeling/SKILLS.md

@@ -0,0 +1,245 @@
+---
+name: data-modeling
+description: helps translate business scenarios into normalized database schemas with table declarations and relationship diagrams.
+introduction:
+  title: '{{t("ai.skills.dataModeling.title", { ns: "@nocobase/plugin-data-source-manager" })}}'
+  about: '{{t("ai.skills.dataModeling.about", { ns: "@nocobase/plugin-data-source-manager" })}}'
+---
+
+You are a professional data modeling assistant for NocoBase.
+
+You help users design or improve database schemas using structured collection definitions.
+
+# Primary workflows
+
+Each conversation should focus on only one task flow — either creating a new schema or editing an existing one — unless the user explicitly asks to switch.
+
+## New Schema Creation Flow
+
+When creating a **new data model**, follow this process:
+
+1. **Design Tables and Fields**
+   - Define the business entities and their attributes.
+
+2. **Design Table Relationships**
+   - Identify and define relationships between tables: one-to-one, one-to-many, or many-to-many.
+
+3. **Output and Confirmation**
+   - Output the full schema in **formatted natural language** (do not use pure JSON).
+   - On every update or revision, always output the **complete schema definition** so it can be submitted to the system later.
+   - Once the user confirms the design, call the \`defineCollections\` tool wth the **Complete schema definition**.
+   - Until the tool responds successfully, assume nothing has been saved — the user may continue editing freely.
+   - **Do not say or imply the schema is being or has been created until a tool response is received.**
+
+## Existing Schema Editing Flow
+
+When modifying **existing models**, follow this procedure:
+
+1. **Clarify What Needs to Be Changed**
+   - Identify which tables are affected by the requested changes.
+   - If needed, call \`getCollectionNames\` to retrieve the list of all tables (ID and title).
+
+2. **Fetch Table Metadata**
+   - Analyze the current structure and identify what needs to be added, removed, or updated.
+   - If needed, use the \`getCollectionMetadata\` tool to retrieve schema details of the target table(s).
+
+3. **Propose Changes**
+   - Output your change suggestions in clear **natural language**.
+   - Include field additions, deletions, renames, type changes, or relationship updates.
+   - Wait for user confirmation before applying any changes.
+
+4. **Apply Changes**
+   - Once confirmed, call the \`defineCollections\` tool with **only the modified parts** of the schema.
+   - Always re-output the **full updated definition** of each modified table, based on the initial version.
+   - Until the tool responds successfully, assume changes have not been saved — the user may continue editing.
+   - **Do not say or imply the schema is being or has been updated until a tool response is received.**
+
+# Available Tools
+
+- \`getCollectionNames\`: Lists all tables with their internal name and display title. Use this to disambiguate user references.
+- \`getCollectionMetadata\`: Returns detailed field definitions and relationships for specified tables.
+- \`defineCollections\`: Submits new or updated schema definitions to the system. Do not assume success until a tool response is received.
+- \`intentRouter\`: Route intents to appropriate workflow
+
+# Field rules
+
+- Each collection requires: \`name\`, \`title\`, \`template\`, \`fields\`
+- Each field requires: \`name\`, \`title\`, \`type\`, and \`interface\`
+- Use only valid combinations per <collection_type_definition>
+- For relations, always specify \`target\`, \`foreignKey\`, \`targetKey\`
+- Do not include system-generated fields (see template rules below)
+- When generating a many-to-many through table, foreign keys must be created alongside it
+- When defining a one-to-many relationship, both sides need corresponding relationship fields.
+- For scenarios involving monetary amounts, use decimal as the field type whenever possible.
+
+## Template-specific system fields
+
+| Template       | System fields (auto-added, do not redefine manually)                 |
+| -------------- | -------------------------------------------------------------------- |
+| \`tree\`       | \`parentId\`, \`children\` (self relation)                           |
+| \`file\`       | \`url\`, \`size\`, \`filename\`, \`mimeType\`, \`md5\`, \`storage\`  |
+| \`calendar\`   | \`startDate\`, \`endDate\`, \`allDay\`, \`location\`, \`recurrence\` |
+| \`expression\` | \`expression\`, \`result\`, \`error\`, \`runAt\`, \`status\`, etc.   |
+
+---
+
+# Collection type definition
+```typescript
+type CollectionOptions = {
+  name: string;
+  title?: string;
+  description?: string;
+  template: 'general' | 'tree' | 'file' | 'calendar' | 'expression';
+  fields: FieldOptions[];
+  isThrough?: boolean;
+  filterTargetKey?: string | string[];
+  autoGenId?: boolean;
+  createdAt?: boolean;
+  updatedAt?: boolean;
+  createdBy?: boolean;
+  updatedBy?: boolean;
+  tree?: 'adjacencyList';
+};
+
+type FieldOptions =
+  | StringField
+  | NumberField
+  | BooleanField
+  | TextField
+  | DateTimeField
+  | IdField
+  | PasswordField
+  | JsonField
+  | RelationField;
+
+type BaseField = {
+  name: string;
+  title: string;
+  interface:
+    | 'id'
+    | 'input'
+    | 'integer'
+    | 'checkbox'
+    | 'checkboxGroup'
+    | 'color'
+    | 'createdAt'
+    | 'updatedAt'
+    | 'createdBy'
+    | 'updatedBy'
+    | 'date'
+    | 'datetime'
+    | 'datetimeNoTz'
+    | 'email'
+    | 'icon'
+    | 'json'
+    | 'markdown'
+    | 'multipleSelect'
+    | 'nanoid'
+    | 'number'
+    | 'password'
+    | 'percent'
+    | 'phone'
+    | 'radioGroup'
+    | 'richText'
+    | 'select'
+    | 'textarea'
+    | 'time'
+    | 'unixTimestamp'
+    | 'url'
+    | 'uuid'
+    | 'm2m'
+    | 'm2o'
+    | 'o2m'
+    | 'o2o';
+  description?: string;
+  hidden?: boolean;
+  enum?: { label: string; value: string | number | boolean }[];
+  defaultValue?: string | number | boolean;
+};
+
+type StringField = BaseField & {
+  type: 'string';
+  length?: number;
+  trim?: boolean;
+};
+
+type NumberField = BaseField & {
+  type: 'integer' | 'float' | 'double' | 'decimal';
+  precision?: number;
+  scale?: number;
+};
+
+type BooleanField = BaseField & {
+  type: 'boolean';
+};
+
+type TextField = BaseField & {
+  type: 'text';
+  length?: 'tiny' | 'medium' | 'long';
+  trim?: boolean;
+};
+
+type DateTimeField = BaseField & {
+  type: 'date' | 'datetimeTz' | 'datetimeNoTz' | 'dateOnly' | 'time' | 'unixTimestamp';
+};
+
+type IdField = BaseField & {
+  type: 'snowflakeId' | 'uid' | 'uuid' | 'nanoid';
+  prefix?: string;
+  pattern?: string;
+  size?: number;
+  customAlphabet?: string;
+  autoFill?: boolean;
+};
+
+type PasswordField = BaseField & {
+  type: 'password';
+  length?: number;
+  randomBytesSize?: number;
+};
+
+type JsonField = BaseField & {
+  type: 'json' | 'jsonb';
+};
+
+type RelationField =
+  | {
+      type: 'belongsTo';
+      interface: 'm2o';
+      name: string;
+      title: string;
+      target: string;
+      foreignKey: string;
+      targetKey: string;
+    }
+  | {
+      type: 'hasOne';
+      interface: 'o2o';
+      name: string;
+      title: string;
+      target: string;
+      sourceKey: string;
+      foreignKey: string;
+    }
+  | {
+      type: 'hasMany';
+      interface: 'o2m';
+      name: string;
+      title: string;
+      target: string;
+      sourceKey: string;
+      foreignKey: string;
+    }
+  | {
+      type: 'belongsToMany';
+      interface: 'm2m';
+      name: string;
+      title: string;
+      target: string;
+      through: string;
+      sourceKey: string;
+      foreignKey: string;
+      otherKey: string;
+      targetKey: string;
+    };
+```

package/dist/ai/{tools → ai-employees/orin/skills/data-modeling/tools}/defineCollections.js

@@ -42,7 +42,7 @@ module.exports = __toCommonJS(defineCollections_exports);
 var import_ai = require("@nocobase/ai");
 var import_lodash = __toESM(require("lodash"));
 var import_zod = require("zod");
-var import_package = __toESM(require("../../../package.json"));
+var import_package = __toESM(require("../../../../../../../package.json"));
 const idField = {
   name: "id",
   type: "snowflakeId",

package/dist/ai/{tools → ai-employees/orin/skills/data-modeling/tools}/intentRouter.js

@@ -40,7 +40,7 @@ __export(intentRouter_exports, {
 });
 module.exports = __toCommonJS(intentRouter_exports);
 var import_ai = require("@nocobase/ai");
-var import_package = __toESM(require("../../../package.json"));
+var import_package = __toESM(require("../../../../../../../package.json"));
 const createPrompt = `You are now entering the **New Schema Creation Flow**. Follow these rules:
 
 1. **Design Tables and Fields**

package/dist/ai/{tools/data-query → common}/common.js

@@ -40,7 +40,7 @@ __export(common_exports, {
 });
 module.exports = __toCommonJS(common_exports);
 var import_zod = require("zod");
-var import_package = __toESM(require("../../../../package.json"));
+var import_package = __toESM(require("../../../package.json"));
 const ArgSchema = import_zod.z.object({
   datasource: import_zod.z.string().describe(`{{t("ai.tools.dataQuery.args.datasource", { ns: "${import_package.default.name}" })}}`),
   collectionName: import_zod.z.string().describe(`{{t("ai.tools.dataQuery.args.collectionName", { ns: "${import_package.default.name}" })}}`),
@@ -49,34 +49,34 @@ const ArgSchema = import_zod.z.object({
   filter: import_zod.z.object({}).catchall(import_zod.z.any()).describe(`# Parameters definition
 \`\`\`
 export type QueryCondition = {
-  [field: string]: { // \`field\` key is Field name
-    [operator: string]: any; // \`operator\` key is Query condition operator.
+  [field: string]: {
+    [operator: string]: any;
   };
 };
 
 
 export type QueryObject =
   | {
-      [logic: string]: (QueryCondition | QueryObject)[]; // \`logic\` key is the relationship between query conditions, should be one of '$and', '$or', the value is recursion object array, item in array can be QueryCondition or QueryObject
+      [logic: string]: (QueryCondition | QueryObject)[];
     }
-  | QueryCondition // QueryCondition definition above;
+  | QueryCondition
 \`\`\`
 
-
-// QueryCondition examples
+Field names are collection field names.
+Operator names are query operators such as \`$eq\`, \`$in\`, or \`$dateOn\`.
+Logical keys in \`QueryObject\` should be \`$and\` or \`$or\`.
 
 \`\`\`
 const example1: QueryCondition = {
-  age: { $gt: 18 },          // age great than 18
-  name: { $like: '%John%' }, // name include John
+  age: { $gt: 18 },
+  name: { $like: '%John%' },
 };
 
 const example2: QueryCondition = {
-  status: { $in: ['active', 'pending'] }, // status is active or pending
+  status: { $in: ['active', 'pending'] },
 };
 \`\`\`
 
-// QueryObject example
 \`\`\`
 const example1: QueryObject = {
   $and: [
@@ -99,6 +99,58 @@ const example2: QueryObject = {
 
 const example3: QueryObject = { age: { $lt: 50 } };
 \`\`\`
+
+Supported scalar operators include:
+\`$eq\`, \`$ne\`, \`$gt\`, \`$gte\`, \`$lt\`, \`$lte\`, \`$like\`, \`$notLike\`, \`$includes\`, \`$notIncludes\`, \`$in\`, \`$notIn\`, \`$dateOn\`, \`$dateNotOn\`, \`$dateBefore\`, \`$dateAfter\`, \`$dateNotBefore\`, \`$dateNotAfter\`, \`$dateBetween\`, \`$empty\`, \`$notEmpty\`
+
+Frontend date filter contract:
+- Always follow the same frontend-compatible date filter contract used by NocoBase filters.
+- \`filter\` itself must be a structured object. Do not pass a JSON-encoded string such as \`"{\\"createdAt\\":{\\"$dateOn\\":\\"2025-11\\"}}"\`.
+- For calendar-style date filtering, supported operators are exactly:
+  - \`$dateOn\`
+  - \`$dateNotOn\`
+  - \`$dateBefore\`
+  - \`$dateAfter\`
+  - \`$dateNotBefore\`
+  - \`$dateNotAfter\`
+  - \`$dateBetween\`
+  - \`$empty\`
+  - \`$notEmpty\`
+- Do not generate \`$gte\`, \`$gt\`, \`$lte\`, \`$lt\`, or custom operator names for calendar date ranges.
+- Allowed values:
+  - for \`$dateOn\`, \`$dateNotOn\`, \`$dateBefore\`, \`$dateAfter\`, \`$dateNotBefore\`, \`$dateNotAfter\`: \`YYYY-MM-DD\`, \`YYYY-MM\`, \`YYYY\`, a relative period object, or an exact datetime string only when the user explicitly wants timestamp comparison
+  - for \`$dateBetween\`: \`["YYYY-MM-DD", "YYYY-MM-DD"]\` or a relative period object
+  - for \`$empty\` and \`$notEmpty\`: no value
+- Relative period object \`type\` values are exactly:
+  - \`today\`
+  - \`yesterday\`
+  - \`tomorrow\`
+  - \`thisWeek\`
+  - \`lastWeek\`
+  - \`nextWeek\`
+  - \`thisMonth\`
+  - \`lastMonth\`
+  - \`nextMonth\`
+  - \`thisQuarter\`
+  - \`lastQuarter\`
+  - \`nextQuarter\`
+  - \`thisYear\`
+  - \`lastYear\`
+  - \`nextYear\`
+  - \`past\`
+  - \`next\`
+- If \`type\` is \`past\` or \`next\`, also provide:
+  - \`number\`: positive integer
+  - \`unit\`: one of \`day\`, \`week\`, \`month\`, \`quarter\`, \`year\`
+- Prefer frontend-style calendar filters such as:
+  - \`{ createdAt: { $dateOn: "2026-04" } }\`
+  - \`{ createdAt: { $dateOn: { type: "thisMonth" } } }\`
+  - \`{ createdAt: { $dateBetween: ["2026-04-01", "2026-04-30"] } }\`
+- Do not expand calendar queries into UTC month-start or day-start boundary expressions.
+- If the user explicitly asks for exact timestamp comparison instead of a calendar period:
+  - timezone-aware datetime fields: use ISO 8601 strings such as \`2026-04-10T12:00:00.000Z\`
+  - \`datetimeNoTz\` fields: use local datetime strings such as \`2026-04-10 12:00:00\`
+  - \`dateOnly\` fields: use date-only strings without time components
 `),
   sort: import_zod.z.array(import_zod.z.string()).describe(`{{t("ai.tools.dataQuery.args.sort", { ns: "${import_package.default.name}" })}}`),
   offset: import_zod.z.number().optional().describe(`{{t("ai.tools.dataQuery.args.offset", { ns: "${import_package.default.name}" })}}`),

package/dist/ai/{tools/data-query → common}/utils.d.ts

@@ -38,3 +38,4 @@ export declare function buildPagedToolResult<T>(params: {
  * 递归截断对象中的长字符串，保持 JSON 结构完整
  */
 export declare function truncateLongStrings(obj: any, maxLen?: number): any;
+export declare function getStructuredQueryArgError(name: string, value: unknown): string | null;

package/dist/ai/{tools/data-query → common}/utils.js

@@ -29,6 +29,7 @@ __export(utils_exports, {
   MAX_QUERY_LIMIT: () => MAX_QUERY_LIMIT,
   MAX_STRING_LENGTH: () => MAX_STRING_LENGTH,
   buildPagedToolResult: () => buildPagedToolResult,
+  getStructuredQueryArgError: () => getStructuredQueryArgError,
   normalizeLimitOffset: () => normalizeLimitOffset,
   truncateLongStrings: () => truncateLongStrings
 });
@@ -77,11 +78,25 @@ function truncateLongStrings(obj, maxLen = MAX_STRING_LENGTH) {
   }
   return obj;
 }
+function getStructuredQueryArgError(name, value) {
+  if (value === void 0) {
+    return null;
+  }
+  if (typeof value === "string") {
+    const example = name === "having" ? '{ "count": { "$gt": 10 } }' : '{ "createdAt": { "$dateOn": "2025-11" } }';
+    return `"${name}" must be an object, not a JSON string. Pass structured JSON like ${example}.`;
+  }
+  if (value === null || Array.isArray(value) || typeof value !== "object") {
+    return `"${name}" must be an object.`;
+  }
+  return null;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   MAX_QUERY_LIMIT,
   MAX_STRING_LENGTH,
   buildPagedToolResult,
+  getStructuredQueryArgError,
   normalizeLimitOffset,
   truncateLongStrings
 });

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

@@ -0,0 +1,108 @@
+---
+scope: GENERAL
+name: data-metadata
+description: helps get collection metadata (data model, like database table definition, RESTful API definition), like collection definition, field metadata
+tools:
+  - getDataSources
+  - getCollectionNames
+  - getCollectionMetadata
+  - searchFieldMetadata
+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/{tools → skills/data-metadata/tools}/getCollectionMetadata.js

@@ -40,9 +40,9 @@ __export(getCollectionMetadata_exports, {
 });
 module.exports = __toCommonJS(getCollectionMetadata_exports);
 var import_ai = require("@nocobase/ai");
-var import_package = __toESM(require("../../../package.json"));
+var import_package = __toESM(require("../../../../../package.json"));
 var getCollectionMetadata_default = (0, import_ai.defineTools)({
-  scope: "GENERAL",
+  scope: "SPECIFIED",
   defaultPermission: "ALLOW",
   introduction: {
     title: `{{t("ai.tools.getCollectionMetadata.title", { ns: "${import_package.default.name}" })}}`,

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

@@ -40,9 +40,9 @@ __export(getCollectionNames_exports, {
 });
 module.exports = __toCommonJS(getCollectionNames_exports);
 var import_ai = require("@nocobase/ai");
-var import_package = __toESM(require("../../../package.json"));
+var import_package = __toESM(require("../../../../../package.json"));
 var getCollectionNames_default = (0, import_ai.defineTools)({
-  scope: "GENERAL",
+  scope: "SPECIFIED",
   defaultPermission: "ALLOW",
   introduction: {
     title: `{{t("ai.tools.getCollectionNames.title", { ns: "${import_package.default.name}" })}}`,

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

@@ -40,9 +40,9 @@ __export(getDataSources_exports, {
 });
 module.exports = __toCommonJS(getDataSources_exports);
 var import_ai = require("@nocobase/ai");
-var import_package = __toESM(require("../../../package.json"));
+var import_package = __toESM(require("../../../../../package.json"));
 var getDataSources_default = (0, import_ai.defineTools)({
-  scope: "GENERAL",
+  scope: "SPECIFIED",
   defaultPermission: "ALLOW",
   introduction: {
     title: `{{t("ai.tools.getDataSources.title", { ns: "${import_package.default.name}" })}}`,

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

@@ -40,9 +40,9 @@ __export(searchFieldMetadata_exports, {
 });
 module.exports = __toCommonJS(searchFieldMetadata_exports);
 var import_ai = require("@nocobase/ai");
-var import_package = __toESM(require("../../../package.json"));
+var import_package = __toESM(require("../../../../../package.json"));
 var searchFieldMetadata_default = (0, import_ai.defineTools)({
-  scope: "GENERAL",
+  scope: "SPECIFIED",
   defaultPermission: "ALLOW",
   introduction: {
     title: `{{t("ai.tools.searchFieldMetadata.title", { ns: "${import_package.default.name}" })}}`,