@nocobase/plugin-ai 2.0.0-alpha.9 → 2.0.0-beta.1

package/dist/server/tools/data-modeling.js

@@ -39,24 +39,30 @@ __export(data_modeling_exports, {
   dataModelingIntentRouter: () => dataModelingIntentRouter,
   defineCollections: () => defineCollections,
   getCollectionMetadata: () => getCollectionMetadata,
-  getCollectionNames: () => getCollectionNames
+  getCollectionNames: () => getCollectionNames,
+  getDataSources: () => getDataSources
 });
 module.exports = __toCommonJS(data_modeling_exports);
 var import_lodash = __toESM(require("lodash"));
 var import_zod = require("zod");
 const idField = {
   name: "id",
-  type: "bigInt",
-  autoIncrement: true,
+  type: "snowflakeId",
+  autoIncrement: false,
   primaryKey: true,
   allowNull: false,
   uiSchema: {
     type: "number",
     title: '{{t("ID")}}',
     "x-component": "InputNumber",
-    "x-read-pretty": true
+    "x-component-props": {
+      stringMode: true,
+      separator: "0.00",
+      step: "1"
+    },
+    "x-validator": "integer"
   },
-  interface: "id"
+  interface: "snowflakeId"
 };
 const createdAtField = {
   name: "createdAt",
@@ -94,20 +100,20 @@ const createPrompt = `You are now entering the **New Schema Creation Flow**. Fol
 
 3. **Output and Confirmation**
    - Present the full schema in **formatted natural language** (not plain JSON).
-   - Wait for user confirmation, then call the \`defineCollections\` tool with the **complete schema definition**.
+   - Wait for user confirmation, then call the \`dataModeling-defineCollections\` tool with the **complete schema definition**.
    - Until the tool responds, **assume the schema is not saved** \u2014 user may continue editing.
    - **Do not say or imply the schema has been created without tool response.**
 
-Only the \`defineCollections\` tool may be used.`;
+Only the \`dataModeling-defineCollections\` tool may be used.`;
 const editPrompt = `## Existing Schema Editing Flow
 
 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).
+   - If needed, call \`dataModeling-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).
+   - If needed, use the \`dataModeling-getCollectionMetadata\` tool to retrieve schema details of the target table(s).
 
 3. **Propose Changes**
    - Output your change suggestions in clear **natural language**.
@@ -115,9 +121,14 @@ const editPrompt = `## Existing Schema Editing Flow
    - 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.
+   - Once confirmed, call the \`dataModeling-defineCollections\` tool with **only the modified parts** of the schema.
    - Until the tool responds successfully, assume changes have not been saved \u2014 the user may continue editing.
    - **Do not say or imply the schema is being or has been updated until a tool response is received.**`;
+class IntentError extends Error {
+  constructor(message) {
+    super(message);
+  }
+}
 const dataModelingIntentRouter = {
   name: "intentRouter",
   title: '{{t("Intent Router")}}',
@@ -158,13 +169,23 @@ const getCollectionNames = {
   description: '{{t("Retrieve names and titles map of all collections")}}',
   schema: {
     type: "object",
-    properties: {},
+    properties: {
+      dataSource: {
+        type: "string",
+        description: 'The data source name to retrieve collections from. Defaults to "main".'
+      }
+    },
     additionalProperties: false
   },
-  invoke: async (ctx) => {
+  invoke: async (ctx, args) => {
+    const { dataSource = "main" } = args || {};
     let names = [];
     try {
-      const collections = await ctx.db.getRepository("collections").find();
+      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
@@ -194,6 +215,10 @@ const getCollectionMetadata = {
   schema: {
     type: "object",
     properties: {
+      dataSource: {
+        type: "string",
+        description: 'The data source name. Defaults to "main".'
+      },
       collectionNames: {
         type: "array",
         items: {
@@ -206,36 +231,83 @@ const getCollectionMetadata = {
     additionalProperties: false
   },
   invoke: async (ctx, args) => {
-    const { collectionNames } = 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."
       };
     }
-    const collections = await ctx.db.getRepository("collections").find({
-      filter: { name: collectionNames },
-      appends: ["fields"]
-    });
-    const metadata = collections.map((collection) => {
-      const fields = collection.fields.map((field) => {
+    try {
+      const ds = ctx.app.dataSourceManager.dataSources.get(dataSource);
+      if (!ds) {
         return {
-          name: field.name,
-          type: field.type,
-          interface: field.interface,
-          options: field.options || {}
+          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 {
-        name: collection.name,
-        title: collection.title,
-        fields
+        status: "success",
+        content: JSON.stringify(metadata)
       };
-    });
-    return {
-      status: "success",
-      content: JSON.stringify(metadata)
-    };
+    } catch (err) {
+      return {
+        status: "error",
+        content: `Failed to retrieve metadata: ${err.message}`
+      };
+    }
+  }
+};
+const getDataSources = {
+  name: "getDataSources",
+  title: '{{t("Get data sources")}}',
+  description: '{{t("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}`
+      };
+    }
   }
 };
 const defineCollections = {
@@ -243,14 +315,26 @@ const defineCollections = {
   title: '{{t("Define collections")}}',
   description: '{{t("Create or edit collections")}}',
   schema: import_zod.z.object({
+    intent: import_zod.z.enum(["create", "edit"]).describe(
+      `Pass the intent of the current tool invocation as an enum value. The value must be either 'create' or 'edit':
+- create: create a brand-new data table definition
+- edit: modify an existing data table definition`
+    ),
     collections: import_zod.z.array(
       import_zod.z.object({}).catchall(import_zod.z.any()).describe("Valid collection object which defined in collection_type_definition")
     ).describe("An array of collections to be defined or edited.")
   }),
-  invoke: async (ctx) => {
-    const {
-      args: { collections }
-    } = ctx.action.params.values || {};
+  invoke: async (ctx, args) => {
+    var _a, _b, _c;
+    const { intent, collections: originalCollections } = ((_c = (_b = (_a = ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.values) == null ? void 0 : _c.args) ?? args ?? {};
+    if (!intent || !["create", "edit"].includes(intent)) {
+      return {
+        status: "error",
+        content: `Please explicitly specify your intent. The value of the intent parameter must be either 'create' or 'edit'.`
+      };
+    }
+    const collectionsType = typeof originalCollections;
+    const collections = collectionsType === "string" ? JSON.parse(originalCollections) : originalCollections;
     if (!collections || !Array.isArray(collections)) {
       return {
         status: "error",
@@ -290,12 +374,22 @@ const defineCollections = {
           const baseFields = [...systemFields, ...normalFields];
           const collection = await repo.findOne({ filter: { name: options.name }, transaction });
           if (!collection) {
+            if (intent === "edit") {
+              throw new IntentError(
+                `You want to edit a collection definition, but there is no existing data table definition named '${options.name}'.`
+              );
+            }
             await repo.create({
               values: { ...options, fields: baseFields },
               transaction,
               context: ctx
             });
           } else {
+            if (intent === "create") {
+              throw new IntentError(
+                `You want to create a collection definition, but a collection definition named '${options.name}' already exists. Please change the name of your collection definition and then invoke this tool again.`
+              );
+            }
             await repo.update({
               filterByTk: options.name,
               values: import_lodash.default.omit(options, ["fields"]),
@@ -367,6 +461,17 @@ const defineCollections = {
         stack: e.stack,
         cause: e.cause
       });
+      if (e instanceof IntentError) {
+        return {
+          status: "error",
+          content: e.message
+        };
+      }
+      if (intent === "create") {
+        for (const options of sorted) {
+          ctx.db.removeCollection(options.name);
+        }
+      }
       return {
         status: "error",
         content: `Failed to define collections: ${e.message}`
@@ -383,5 +488,6 @@ const defineCollections = {
   dataModelingIntentRouter,
   defineCollections,
   getCollectionMetadata,
-  getCollectionNames
+  getCollectionNames,
+  getDataSources
 });

package/dist/server/tools/datasource-query.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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.
+ */
+import { ToolOptions } from '../manager/tool-manager';
+export declare const dataSourceQuery: ToolOptions;
+export declare const dataSourceCounting: ToolOptions;

package/dist/server/tools/datasource-query.js

@@ -0,0 +1,143 @@
+/**
+ * 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 datasource_query_exports = {};
+__export(datasource_query_exports, {
+  dataSourceCounting: () => dataSourceCounting,
+  dataSourceQuery: () => dataSourceQuery
+});
+module.exports = __toCommonJS(datasource_query_exports);
+var import_zod = require("zod");
+var import_utils = require("./utils");
+const ArgSchema = import_zod.z.object({
+  datasource: import_zod.z.string().describe('{{t("Data source key")}}'),
+  collectionName: import_zod.z.string().describe('{{t("Collection name")}}'),
+  fields: import_zod.z.array(import_zod.z.string()).describe('{{t("Fields to be queried")}}'),
+  appends: import_zod.z.array(import_zod.z.string()).describe('{{t("Related collection to be queried")}}'),
+  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.
+  };
+};
+
+
+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
+    }
+  | QueryCondition // QueryCondition definition above;
+\`\`\`
+
+
+// QueryCondition examples
+
+\`\`\`
+const example1: QueryCondition = {
+  age: { $gt: 18 },          // age great than 18
+  name: { $like: '%John%' }, // name include John
+};
+
+const example2: QueryCondition = {
+  status: { $in: ['active', 'pending'] }, // status is active or pending
+};
+\`\`\`
+
+// QueryObject example
+\`\`\`
+const example1: QueryObject = {
+  $and: [
+    { age: { $gt: 18 } },
+    { status: { $eq: 'active' } }
+  ]
+};
+
+const example2: QueryObject = {
+  $or: [
+    { name: { $like: '%John%' } },
+    {
+      $and: [
+        { age: { $gte: 30 } },
+        { status: { $eq: 'pending' } }
+      ]
+    }
+  ]
+};
+
+const example3: QueryObject = { age: { $lt: 50 } };
+\`\`\`
+`),
+  sort: import_zod.z.array(import_zod.z.string()).describe(
+    '{{t("Sort field names. By default, they are in ascending order. A minus sign before the field name indicates descending order")}}'
+  ),
+  offset: import_zod.z.number().optional().describe('{{t("Offset of records to be queried")}}'),
+  limit: import_zod.z.number().optional().describe('{{t("Maximum number of records to be queried")}}')
+});
+const dataSourceQuery = {
+  name: "dataSourceQuery",
+  title: '{{t("Data source query")}}',
+  description: '{{t("Use dataSource, collectionName, and collection fields to query data from the database")}}',
+  schema: ArgSchema,
+  invoke: async (ctx, args) => {
+    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, {
+      ...args,
+      limit,
+      offset
+    });
+    const records = (0, import_utils.truncateLongStrings)((content == null ? void 0 : content.records) || []);
+    const total = (content == null ? void 0 : content.total) || 0;
+    const result = (0, import_utils.buildPagedToolResult)({ total, offset, limit, records });
+    if (result.hasMore) {
+      result.note = `Showing ${result.returned} of ${result.total} records. To fetch more, call this tool again with offset:${result.nextOffset}`;
+    }
+    return {
+      status: "success",
+      content: JSON.stringify(result)
+    };
+  }
+};
+const dataSourceCounting = {
+  name: "dataSourceCounting",
+  title: '{{t("Data source records counting")}}',
+  description: '{{t("Use dataSource, collectionName, and collection fields to query data from the database, get total count of records")}}',
+  schema: ArgSchema,
+  invoke: async (ctx, args) => {
+    const plugin = ctx.app.pm.get("ai");
+    const content = await plugin.aiContextDatasourceManager.query(ctx, { ...args, offset: 0, limit: 1 });
+    return {
+      status: "success",
+      content: String((content == null ? void 0 : content.total) ?? 0)
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dataSourceCounting,
+  dataSourceQuery
+});

package/dist/server/tools/suggestions.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.
+ */
+import { ToolOptions } from '../manager/tool-manager';
+export declare const suggestions: ToolOptions;

package/dist/server/tools/suggestions.js

@@ -0,0 +1,74 @@
+/**
+ * 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 suggestions_exports = {};
+__export(suggestions_exports, {
+  suggestions: () => suggestions
+});
+module.exports = __toCommonJS(suggestions_exports);
+var import_zod = require("zod");
+const suggestions = {
+  name: "suggestions",
+  title: '{{t("Suggestions")}}',
+  description: '{{t("Provide a list of suggested prompts for the user to choose from.")}}',
+  schema: import_zod.z.object({
+    options: import_zod.z.array(import_zod.z.string()).describe(
+      "A list of suggested prompts that can be presented to the user as selectable options.Each option represents a possible next user message."
+    )
+  }),
+  invoke: async (ctx, _args, id) => {
+    var _a, _b;
+    const { messageId, args } = ((_b = (_a = ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.values) || {};
+    if (messageId) {
+      const messageRepo = ctx.app.db.getRepository("aiMessages");
+      const message = await messageRepo.findOne({
+        filterByTk: messageId
+      });
+      const toolCalls = message.toolCalls || [];
+      const index = toolCalls.findIndex((toolCall) => toolCall.id === id);
+      if (index !== -1) {
+        toolCalls[index] = {
+          ...toolCalls[index],
+          selectedSuggestion: args == null ? void 0 : args.option
+        };
+        await messageRepo.update({
+          filter: { messageId },
+          values: {
+            toolCalls
+          }
+        });
+      }
+    }
+    return {
+      status: "success",
+      content: args == null ? void 0 : args.option
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  suggestions
+});

package/dist/server/tools/utils.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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.
+ */
+/** 单个字符串字段最大长度 */
+export declare const MAX_STRING_LENGTH = 500;
+/** 单次查询最大记录数 */
+export declare const MAX_QUERY_LIMIT = 100;
+export declare function normalizeLimitOffset(args: {
+    limit?: unknown;
+    offset?: unknown;
+}, options?: {
+    defaultLimit?: number;
+    maxLimit?: number;
+}): {
+    limit: number;
+    offset: number;
+};
+export declare function buildPagedToolResult<T>(params: {
+    total: number;
+    offset: number;
+    limit: number;
+    records: T[];
+}): {
+    total: number;
+    offset: number;
+    limit: number;
+    returned: number;
+    hasMore: boolean;
+    nextOffset: number;
+    records: T[];
+};
+/**
+ * 递归截断对象中的长字符串，保持 JSON 结构完整
+ */
+export declare function truncateLongStrings(obj: any, maxLen?: number): any;

package/dist/server/tools/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/server/tools/workflow-caller.js

@@ -31,6 +31,7 @@ __export(workflow_caller_exports, {
 module.exports = __toCommonJS(workflow_caller_exports);
 var import_zod = require("zod");
 var import_plugin_workflow = require("@nocobase/plugin-workflow");
+var import_utils = require("./utils");
 const buildSchema = (config) => {
   var _a;
   const schemaProperties = {};
@@ -86,7 +87,7 @@ const invoke = async (ctx, workflow, args) => {
   if (processor.execution.status !== import_plugin_workflow.EXECUTION_STATUS.RESOLVED) {
     return { status: "error", content: "Workflow execution exceptions" };
   }
-  const lastJobResult = processor.lastSavedJob.result;
+  const lastJobResult = (0, import_utils.truncateLongStrings)(processor.lastSavedJob.result);
   return {
     status: "success",
     content: JSON.stringify(lastJobResult)