@nocobase/plugin-data-source-manager 2.1.0-beta.8 → 2.2.0-alpha.1

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}" })}}`,

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

@@ -0,0 +1,245 @@
+---
+scope: GENERAL
+name: data-query
+description: Inspect schemas, retrieve records, and run aggregate queries on specified datasources
+tools:
+  - dataQuery
+  - dataSourceQuery
+  - dataSourceCounting
+introduction:
+  title: '{{t("ai.skills.dataQuery.title", { ns: "@nocobase/plugin-data-source-manager" })}}'
+  about: '{{t("ai.skills.dataQuery.about", { ns: "@nocobase/plugin-data-source-manager" })}}'
+---
+You are a professional data query assistant for NocoBase.
+
+You help users inspect schemas, retrieve records, and run aggregate queries on NocoBase collections.
+
+# Primary Workflows
+
+This skill focuses on safe read-only data access.
+
+## Schema-first Querying
+
+When the user does not provide an exact collection or field name, or when this is the first query against a collection in the current conversation:
+
+1. If schema, field, relation path, or datasource choice is not already explicit and reliable, your first tool call must be `getSkill` with `skillName="data-metadata"`.
+2. Do not guess collection names, field names, relation paths, or data types before `data-metadata` has been loaded.
+3. Call `getDataSources` from the loaded `data-metadata` workflow if the target data source is unclear.
+4. If multiple data sources may contain relevant data, inspect each candidate before choosing the query scope.
+5. Do not silently default to `main` when other relevant data sources are available.
+6. If you intentionally limit the query to one data source, explain why that data source was chosen and why others were not used.
+7. Call `getCollectionNames` from the loaded `data-metadata` workflow to find the right collection.
+8. Call `getCollectionMetadata` or `searchFieldMetadata` from the loaded `data-metadata` workflow to confirm field names, relation paths, and data types.
+9. Only then run a data tool.
+10. Even if the user already mentions a collection name such as `date_boundary_cases` or a common field such as `createdAt`, verify them with the loaded `data-metadata` workflow before the first real query when the collection has not yet been confirmed in the current conversation.
+
+Do not guess collection names, measure aliases, or dotted relation paths.
+
+## Raw Record Query
+
+Use `dataSourceQuery` when the user wants actual records rather than grouped statistics.
+
+Typical cases:
+
+- list rows
+- inspect recent records
+- fetch selected fields
+- browse data with filter, sort, and pagination
+
+## Aggregate Query
+
+Use `dataQuery` when the user wants:
+
+- counts, sums, averages, min, max
+- grouped statistics
+- rankings
+- trend buckets
+- post-aggregation filtering with `having`
+
+Prefer `dataQuery` over `dataSourceCounting` whenever the request can be expressed as a measure query, because it is closer to the repository `query` capability used by charts, actions, ACL, and MCP.
+
+### Aggregate Query Failure Handling
+
+If `dataQuery` fails, do not immediately switch to `dataSourceQuery` and manually sum, count, group, or rank records.
+
+Before falling back to raw records, inspect the tool error and retry `dataQuery` with corrected parameters. Date filters are the most common source of aggregate query failures, so check them first. Common fixes include:
+
+- rebuild date ranges with the frontend date filter contract below, such as `$dateOn`, `$dateBetween`, or relative period objects
+- replace unsupported calendar operators such as `$gte`, `$gt`, `$lte`, `$lt`, or custom date operator names
+- avoid UTC boundary expansions like `2026-04-01T00:00:00.000Z` to `2026-05-01T00:00:00.000Z` unless the user explicitly asks for exact timestamp comparison
+- verify field names, relation paths, and data types with metadata
+- correct `measures`, `dimensions`, aliases, and `orders`
+- fix `filter` versus `having` placement
+- simplify grouping, relation paths, or post-aggregation filters
+- confirm the intended `dataSource` and `collectionName`
+
+For aggregation/statistics/rankings/trends, raw record fetching plus manual calculation is a last resort only. Use `dataSourceQuery` as a fallback only when:
+
+- the user explicitly asks to inspect raw records
+- the requested computation cannot be expressed with `dataQuery`
+- boundary-sensitive verification requires a small sample of source records
+- at least two corrected `dataQuery` attempts have failed and the error has been analyzed
+
+When a raw-record fallback is unavoidable, explain why `dataQuery` could not be used, keep the fetched record set small, and do not fetch large datasets just to manually aggregate them.
+
+## Count Records
+
+Use `dataSourceCounting` only for a simple total when grouped output is unnecessary.
+
+## Query Construction Rules
+
+1. `filter` is applied before aggregation.
+2. `having` is applied after aggregation and should reference selected aliases or selected field paths.
+3. For grouped results, put grouping fields in `dimensions`.
+4. For metrics, put aggregate definitions in `measures`.
+5. Use aliases when the user clearly needs stable output keys.
+6. For dotted relation fields, prefer the exact field path confirmed from metadata, such as `createdBy.nickname`.
+7. Default row limit is 50 and the tool caps the limit at 100.
+8. Always follow the same frontend date filter contract used by NocoBase filters.
+8.1. `filter` and `having` must be structured objects, not JSON-encoded strings.
+9. Supported date operators are exactly `$dateOn`, `$dateNotOn`, `$dateBefore`, `$dateAfter`, `$dateNotBefore`, `$dateNotAfter`, `$dateBetween`, `$empty`, and `$notEmpty`.
+10. For calendar-style date filtering, do not generate `$gte`, `$gt`, `$lte`, `$lt`, or custom operator names.
+11. Allowed value shapes are:
+    - 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
+12. Relative period objects must use exactly these `type` values: `today`, `yesterday`, `tomorrow`, `thisWeek`, `lastWeek`, `nextWeek`, `thisMonth`, `lastMonth`, `nextMonth`, `thisQuarter`, `lastQuarter`, `nextQuarter`, `thisYear`, `lastYear`, `nextYear`, `past`, `next`.
+13. If `type` is `past` or `next`, the object must also include `number` as a positive integer and `unit` as one of `day`, `week`, `month`, `quarter`, `year`.
+14. For day, week, month, quarter, year, and common relative-period queries, prefer frontend date filters such as `{ createdAt: { $dateOn: "2026-04" } }`, `{ createdAt: { $dateOn: { type: "thisMonth" } } }`, or `{ createdAt: { $dateBetween: ["2026-04-01", "2026-04-30"] } }`.
+15. Do not expand calendar queries into UTC boundary expressions such as `createdAt >= 2026-04-01T00:00:00.000Z` and `< 2026-05-01T00:00:00.000Z`.
+16. For fields such as `createdAt` and `updatedAt`, still prefer the frontend date operators above for calendar queries instead of UTC boundary expansion.
+17. Only inspect field type when the user explicitly asks for an exact timestamp comparison rather than a calendar period.
+18. If an exact timestamp comparison is required, keep the operator frontend-compatible and choose the value format that matches the field semantics:
+    - timezone-aware datetime fields: ISO 8601 timestamp strings such as `2026-04-10T12:00:00.000Z`
+    - `datetimeNoTz` fields: timezone-free local datetime strings such as `2026-04-10 12:00:00`
+    - `dateOnly` fields: date-only strings without time components
+19. Do not provide a timezone parameter yourself. The runtime request timezone is already supplied by the system.
+
+# Available Tools
+
+- `getSkill`: Load the `data-metadata` skill before metadata inspection so its schema exploration tools become available in the current conversation.
+- `dataSourceQuery`: Query data from a specified collection in a data source. Supports filtering, sorting, field selection, and pagination. Returns paged results with total count.
+- `dataQuery`: Run aggregate repository queries with measures, dimensions, orders, filter, and having.
+- `dataSourceCounting`: Get the total count of records matching the specified filter conditions in a collection.
+
+# Aggregate Query Parameters
+
+| Parameter        | Type     | Description                                                  |
+| ---------------- | -------- | ------------------------------------------------------------ |
+| `dataSource`     | string   | The data source key (default: `main`)                        |
+| `collectionName` | string   | The collection name to query                                 |
+| `measures`       | array    | Aggregate definitions, such as count / sum / avg             |
+| `dimensions`     | array    | Group-by field definitions                                   |
+| `orders`         | array    | Result ordering definitions                                  |
+| `filter`         | object   | Query conditions applied before aggregation                  |
+| `having`         | object   | Query conditions applied after aggregation                   |
+| `offset`         | number   | Number of rows to skip                                       |
+| `limit`          | number   | Maximum number of rows to return (default: 50, max: 100)     |
+
+# Filter Operators
+
+| Operator  | Description           | Example                                      |
+| --------- | --------------------- | -------------------------------------------- |
+| `$eq`     | Equal to              | `{ status: { $eq: 'active' } }`              |
+| `$ne`     | Not equal to          | `{ status: { $ne: 'deleted' } }`             |
+| `$gt`     | Greater than          | `{ age: { $gt: 18 } }`                       |
+| `$gte`    | Greater than or equal | `{ age: { $gte: 18 } }`                      |
+| `$lt`     | Less than             | `{ age: { $lt: 65 } }`                       |
+| `$lte`    | Less than or equal    | `{ age: { $lte: 65 } }`                      |
+| `$like`   | Contains (SQL LIKE)   | `{ name: { $like: '%John%' } }`              |
+| `$in`     | In array              | `{ status: { $in: ['active', 'pending'] } }` |
+| `$nin`    | Not in array          | `{ status: { $nin: ['deleted'] } }`          |
+| `$exists` | Field exists          | `{ email: { $exists: true } }`               |
+
+# Complex Filter Examples
+
+## AND Conditions
+```
+{
+  $and: [
+    { age: { $gte: 18 } },
+    { status: { $eq: 'active' } }
+  ]
+}
+```
+
+## OR Conditions
+```
+{
+  $or: [
+    { name: { $like: '%John%' } },
+    { email: { $like: '%john@%' } }
+  ]
+}
+```
+
+## Nested Conditions
+```
+{
+  $and: [
+    { age: { $gte: 18 } },
+    {
+      $or: [
+        { status: { $eq: 'active' } },
+        { role: { $eq: 'admin' } }
+      ]
+    }
+  ]
+}
+```
+
+# Common Use Cases
+
+## Simple Query
+```
+User: "Show me all users"
+Action: Call dataSourceQuery with collectionName="users"
+```
+
+## Aggregate Count
+```
+User: "How many active users are there?"
+Action: Call dataQuery with collectionName="users", measures=[{ field: "id", aggregation: "count", alias: "count" }], filter={ status: { $eq: "active" } }
+```
+
+## Grouped Statistics
+```
+User: "Count orders by status"
+Action: Call dataQuery with collectionName="orders", dimensions=[{ field: "status", alias: "status" }], measures=[{ field: "id", aggregation: "count", alias: "count" }]
+```
+
+## Having Query
+```
+User: "Show statuses with more than 10 orders"
+Action: Call dataQuery with collectionName="orders", dimensions=[{ field: "status", alias: "status" }], measures=[{ field: "id", aggregation: "count", alias: "count" }], having={ count: { $gt: 10 } }
+```
+
+## Raw Record Query
+```
+User: "Show me 20 latest paid orders"
+Action: Call dataSourceQuery with collectionName="orders", filter={ status: { $eq: "paid" } }, sort=["-createdAt"], limit=20
+```
+
+## Count Records
+```
+User: "How many active users are there?"
+Action: Call dataSourceCounting with collectionName="users", filter={ status: { $eq: 'active' } }
+```
+
+## Metadata First
+```
+User: "Show monthly revenue by salesperson"
+Action:
+1. Call getSkill with skillName="data-metadata".
+2. Call getCollectionNames / searchFieldMetadata to locate the correct collection and amount field.
+3. Call getCollectionMetadata if date or relation paths are unclear.
+4. Call dataQuery with the confirmed fields.
+```
+
+# Notes
+
+- Always validate collection and field names before querying.
+- Prefer metadata tools first when the request is ambiguous.
+- Prefer `dataQuery` for analysis and metrics. If it fails, first check whether the date range or date operator is invalid, then retry corrected aggregate queries before using raw records.
+- Use `dataSourceQuery` for raw rows and `dataSourceCounting` for the simplest count case.
+- Respect user permissions; if the tool returns `No permissions`, explain that the current role cannot access the requested data.

package/dist/ai/skills/data-query/tools/dataQuery.js

@@ -0,0 +1,282 @@
+/**
+ * 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 dataQuery_exports = {};
+__export(dataQuery_exports, {
+  default: () => dataQuery_default
+});
+module.exports = __toCommonJS(dataQuery_exports);
+var import_acl = require("@nocobase/acl");
+var import_ai = require("@nocobase/ai");
+var import_plugin_acl = require("@nocobase/plugin-acl");
+var import_utils = require("../../../common/utils");
+var import_package = __toESM(require("../../../../../package.json"));
+const queryFieldSchema = {
+  anyOf: [
+    { type: "string" },
+    {
+      type: "array",
+      items: { type: "string" },
+      minItems: 1
+    }
+  ]
+};
+const queryMeasureSchema = {
+  type: "object",
+  additionalProperties: true,
+  required: ["field"],
+  properties: {
+    field: queryFieldSchema,
+    type: {
+      type: "string",
+      description: "Optional field type hint."
+    },
+    aggregation: {
+      type: "string",
+      description: "Aggregation function, such as count, sum, avg, max, or min."
+    },
+    alias: {
+      type: "string",
+      description: "Output field alias."
+    },
+    distinct: {
+      type: "boolean",
+      description: "Whether to apply distinct before aggregation."
+    }
+  }
+};
+const queryDimensionSchema = {
+  type: "object",
+  additionalProperties: true,
+  required: ["field"],
+  properties: {
+    field: queryFieldSchema,
+    type: {
+      type: "string",
+      description: "Optional field type hint."
+    },
+    alias: {
+      type: "string",
+      description: "Output field alias."
+    },
+    format: {
+      type: "string",
+      description: "Optional output format, usually for date and time dimensions."
+    },
+    options: {
+      type: "object",
+      description: "Additional formatter options.",
+      additionalProperties: true
+    }
+  }
+};
+const queryOrderSchema = {
+  type: "object",
+  additionalProperties: true,
+  required: ["field"],
+  properties: {
+    field: queryFieldSchema,
+    alias: {
+      type: "string",
+      description: "Alias to sort by when the selected field is projected with an alias."
+    },
+    order: {
+      type: "string",
+      enum: ["asc", "desc"],
+      description: "Sort direction."
+    },
+    nulls: {
+      type: "string",
+      enum: ["default", "first", "last"],
+      description: "Null value ordering."
+    }
+  }
+};
+const AggregateQuerySchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["collectionName"],
+  properties: {
+    dataSource: {
+      type: "string",
+      description: "Data source key. Defaults to main."
+    },
+    datasource: {
+      type: "string",
+      description: "Legacy alias of dataSource. Defaults to main."
+    },
+    collectionName: {
+      type: "string",
+      description: "Collection name to query."
+    },
+    measures: {
+      type: "array",
+      description: "Measure definitions for aggregate query.",
+      items: queryMeasureSchema
+    },
+    dimensions: {
+      type: "array",
+      description: "Dimension definitions for grouped query.",
+      items: queryDimensionSchema
+    },
+    orders: {
+      type: "array",
+      description: "Order definitions for aggregate query.",
+      items: queryOrderSchema
+    },
+    filter: {
+      type: "object",
+      description: 'Filter object applied before aggregation. Pass a structured object, not a JSON string. Follow the frontend NocoBase date filter contract: use only $dateOn, $dateNotOn, $dateBefore, $dateAfter, $dateNotBefore, $dateNotAfter, $dateBetween, $empty, and $notEmpty for calendar-style date filtering; prefer YYYY-MM-DD, YYYY-MM, YYYY, relative period objects, or ["start","end"] date ranges; do not expand month/day queries into UTC boundary timestamps.',
+      additionalProperties: true
+    },
+    having: {
+      type: "object",
+      description: "Having object applied after grouping. Pass a structured object, not a JSON string. Reference selected measure aliases or selected field paths here, for example { count: { $gt: 10 } }.",
+      additionalProperties: true
+    },
+    offset: {
+      type: "number",
+      description: "Offset for query result rows."
+    },
+    limit: {
+      type: "number",
+      description: `Maximum number of rows to return. Defaults to 50 and is capped at ${import_utils.MAX_QUERY_LIMIT}.`
+    }
+  }
+};
+function getDataSourceKey(args) {
+  return args.dataSource || args.datasource || "main";
+}
+function getTimezone(ctx, args) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const value = ((_a = ctx.get) == null ? void 0 : _a.call(ctx, "x-timezone")) || ((_c = (_b = ctx.request) == null ? void 0 : _b.get) == null ? void 0 : _c.call(_b, "x-timezone")) || ((_e = (_d = ctx.request) == null ? void 0 : _d.header) == null ? void 0 : _e["x-timezone"]) || ((_g = (_f = ctx.req) == null ? void 0 : _f.headers) == null ? void 0 : _g["x-timezone"]);
+  return Array.isArray(value) ? value[0] : value;
+}
+var dataQuery_default = (0, import_ai.defineTools)({
+  scope: "SPECIFIED",
+  defaultPermission: "ALLOW",
+  introduction: {
+    title: `{{t("ai.tools.dataQuery.title", { ns: "${import_package.default.name}" })}}`,
+    about: `{{t("ai.tools.dataQuery.about", { ns: "${import_package.default.name}" })}}`
+  },
+  definition: {
+    name: "dataQuery",
+    description: "Run the repository query action on a collection with measures, dimensions, orders, filter, and having.",
+    schema: AggregateQuerySchema
+  },
+  invoke: async (ctx, args) => {
+    var _a, _b, _c, _d, _e;
+    const filterError = (0, import_utils.getStructuredQueryArgError)("filter", args.filter);
+    if (filterError) {
+      return {
+        status: "error",
+        content: filterError
+      };
+    }
+    const havingError = (0, import_utils.getStructuredQueryArgError)("having", args.having);
+    if (havingError) {
+      return {
+        status: "error",
+        content: havingError
+      };
+    }
+    const dataSourceKey = getDataSourceKey(args);
+    const ds = ctx.app.dataSourceManager.get(dataSourceKey);
+    if (!ds) {
+      return {
+        status: "error",
+        content: `Data source "${dataSourceKey}" not found`
+      };
+    }
+    const collection = ds.collectionManager.getCollection(args.collectionName);
+    if (!collection) {
+      return {
+        status: "error",
+        content: `Collection "${args.collectionName}" not found in data source "${dataSourceKey}"`
+      };
+    }
+    const { limit, offset } = (0, import_utils.normalizeLimitOffset)(args, { defaultLimit: 50, maxLimit: import_utils.MAX_QUERY_LIMIT });
+    const timezone = getTimezone(ctx, args);
+    if (!((_a = args.measures) == null ? void 0 : _a.length) && !((_b = args.dimensions) == null ? void 0 : _b.length)) {
+      return {
+        status: "error",
+        content: "Aggregate query requires at least one measure or dimension"
+      };
+    }
+    try {
+      const db = ds.collectionManager.db || ctx.db;
+      const result = await (0, import_plugin_acl.applyQueryPermission)({
+        acl: ds.acl || ctx.app.acl,
+        db,
+        resourceName: args.collectionName,
+        query: {
+          measures: args.measures,
+          dimensions: args.dimensions,
+          orders: args.orders,
+          filter: args.filter,
+          having: args.having,
+          limit,
+          offset
+        },
+        currentUser: (_c = ctx.state) == null ? void 0 : _c.currentUser,
+        currentRole: (_d = ctx.state) == null ? void 0 : _d.currentRole,
+        currentRoles: (_e = ctx.state) == null ? void 0 : _e.currentRoles,
+        timezone,
+        state: ctx.state
+      });
+      const queryResult = await db.getRepository(args.collectionName).query({
+        ...result.query,
+        context: ctx,
+        timezone
+      });
+      return {
+        status: "success",
+        content: JSON.stringify((0, import_utils.truncateLongStrings)(queryResult))
+      };
+    } catch (error) {
+      if (error instanceof import_acl.NoPermissionError) {
+        return {
+          status: "error",
+          content: "No permissions"
+        };
+      }
+      return {
+        status: "error",
+        content: (error == null ? void 0 : error.message) || "Aggregate query failed"
+      };
+    }
+  }
+});

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

@@ -40,10 +40,11 @@ __export(dataSourceCounting_exports, {
 });
 module.exports = __toCommonJS(dataSourceCounting_exports);
 var import_ai = require("@nocobase/ai");
-var import_common = require("./common");
-var import_package = __toESM(require("../../../../package.json"));
+var import_common = require("../../../common/common");
+var import_utils = require("../../../common/utils");
+var import_package = __toESM(require("../../../../../package.json"));
 var dataSourceCounting_default = (0, import_ai.defineTools)({
-  scope: "GENERAL",
+  scope: "SPECIFIED",
   defaultPermission: "ALLOW",
   introduction: {
     title: `{{t("ai.tools.dataSourceCounting.title", { ns: "${import_package.default.name}" })}}`,
@@ -51,10 +52,17 @@ var dataSourceCounting_default = (0, import_ai.defineTools)({
   },
   definition: {
     name: "dataSourceCounting",
-    description: "Use dataSource, collectionName, and collection fields to query data from the database, get total count of records",
+    description: "Use dataSource, collectionName, and collection fields to query data from the database, get total count of records. The filter argument must be a structured object, not a JSON string.",
     schema: import_common.ArgSchema
   },
   invoke: async (ctx, args) => {
+    const filterError = (0, import_utils.getStructuredQueryArgError)("filter", args.filter);
+    if (filterError) {
+      return {
+        status: "error",
+        content: filterError
+      };
+    }
     const plugin = ctx.app.pm.get("ai");
     const content = await plugin.aiContextDatasourceManager.query(ctx, { ...args, offset: 0, limit: 1 });
     return {

package/dist/ai/skills/data-query/tools/dataSourceQuery.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/{tools/data-query → skills/data-query/tools}/dataSourceQuery.js

@@ -40,11 +40,11 @@ __export(dataSourceQuery_exports, {
 });
 module.exports = __toCommonJS(dataSourceQuery_exports);
 var import_ai = require("@nocobase/ai");
-var import_common = require("./common");
-var import_utils = require("./utils");
-var import_package = __toESM(require("../../../../package.json"));
+var import_common = require("../../../common/common");
+var import_utils = require("../../../common/utils");
+var import_package = __toESM(require("../../../../../package.json"));
 var dataSourceQuery_default = (0, import_ai.defineTools)({
-  scope: "GENERAL",
+  scope: "SPECIFIED",
   defaultPermission: "ALLOW",
   introduction: {
     title: `{{t("ai.tools.dataSourceQuery.title", { ns: "${import_package.default.name}" })}}`,
@@ -52,10 +52,17 @@ var dataSourceQuery_default = (0, import_ai.defineTools)({
   },
   definition: {
     name: "dataSourceQuery",
-    description: "Use dataSource, collectionName, and collection fields to query data from the database",
+    description: "Use dataSource, collectionName, and collection fields to query data from the database. The filter argument must be a structured object, not a JSON string.",
     schema: import_common.ArgSchema
   },
   invoke: async (ctx, args) => {
+    const filterError = (0, import_utils.getStructuredQueryArgError)("filter", args.filter);
+    if (filterError) {
+      return {
+        status: "error",
+        content: filterError
+      };
+    }
     const plugin = ctx.app.pm.get("ai");
     const { limit, offset } = (0, import_utils.normalizeLimitOffset)(args, { defaultLimit: 50, maxLimit: import_utils.MAX_QUERY_LIMIT });
     const content = await plugin.aiContextDatasourceManager.query(ctx, {