@nocobase/plugin-flow-engine 2.1.0-alpha.1 → 2.1.0-alpha.10

package/dist/ai/docs/runjs/resource/multi-record-resource.md

@@ -0,0 +1,188 @@
+# MultiRecordResource
+
+A collection-oriented Resource: requests return an array and support pagination, filtering, sorting, and CRUD operations. It is suitable for "multiple records" scenarios such as tables and lists. Unlike [APIResource](./api-resource.md), MultiRecordResource specifies the resource name via `setResourceName()`, automatically constructs URLs like `users:list` and `users:create`, and includes built-in capabilities for pagination, filtering, and row selection.
+
+**Inheritance**: FlowResource → APIResource → BaseRecordResource → MultiRecordResource.
+
+**Creation**: `ctx.makeResource('MultiRecordResource')` or `ctx.initResource('MultiRecordResource')`. Before use, you must call `setResourceName('collectionName')` (e.g., `'users'`). In RunJS, `ctx.api` is injected by the runtime environment.
+
+---
+
+## Use Cases
+
+| Scenario | Description |
+|------|------|
+| **Table Blocks** | Table and list blocks use MultiRecordResource by default, supporting pagination, filtering, and sorting. |
+| **JSBlock Lists** | Load data from collections like users or orders in a JSBlock and perform custom rendering. |
+| **Bulk Operations** | Use `getSelectedRows()` to get selected rows and `destroySelectedRows()` for bulk deletion. |
+| **Association Resources** | Load associated collections using formats like `users.tags`, which requires `setSourceId(parentRecordId)`. |
+
+---
+
+## Data Format
+
+- `getData()` returns an **array of records**, which is the `data` field from the list API response.
+- `getMeta()` returns pagination and other metadata: `page`, `pageSize`, `count`, `totalPage`, etc.
+
+---
+
+## Resource Name and Data Source
+
+| Method | Description |
+|------|------|
+| `setResourceName(name)` / `getResourceName()` | The resource name, e.g., `'users'`, `'users.tags'` (association resource). |
+| `setSourceId(id)` / `getSourceId()` | The parent record ID for association resources (e.g., for `users.tags`, pass the primary key of the user). |
+| `setDataSourceKey(key)` / `getDataSourceKey()` | Data source identifier (used in multi-data source scenarios). |
+
+---
+
+## Request Parameters (Filter / Fields / Sort)
+
+| Method | Description |
+|------|------|
+| `setFilterByTk(tk)` / `getFilterByTk()` | Filter by primary key (for single record `get`, etc.). |
+| `setFilter(filter)` / `getFilter()` / `resetFilter()` | Filter conditions, supporting operators like `$eq`, `$ne`, `$in`, etc. |
+| `addFilterGroup(key, filter)` / `removeFilterGroup(key)` | Filter groups (for combining multiple conditions). |
+| `setFields(fields)` / `getFields()` | Requested fields (whitelist). |
+| `setSort(sort)` / `getSort()` | Sorting, e.g., `['-createdAt']` for descending order by creation time. |
+| `setAppends(appends)` / `getAppends()` / `addAppends` / `removeAppends` | Association loading (e.g., `['user', 'tags']`). |
+
+---
+
+## Pagination
+
+| Method | Description |
+|------|------|
+| `setPage(page)` / `getPage()` | Current page (starting from 1). |
+| `setPageSize(size)` / `getPageSize()` | Number of items per page, default is 20. |
+| `getTotalPage()` | Total number of pages. |
+| `getCount()` | Total number of records (from server-side meta). |
+| `next()` / `previous()` / `goto(page)` | Change page and trigger `refresh`. |
+
+---
+
+## Selected Rows (Table Scenarios)
+
+| Method | Description |
+|------|------|
+| `setSelectedRows(rows)` / `getSelectedRows()` | Currently selected row data, used for bulk deletion and other operations. |
+
+---
+
+## CRUD and List Operations
+
+| Method | Description |
+|------|------|
+| `refresh()` | Requests the list with current parameters, updates `getData()` and pagination meta, and triggers the `'refresh'` event. |
+| `get(filterByTk)` | Requests a single record and returns it (does not write to `getData`). |
+| `create(data, options?)` | Creates a record. Optional `{ refresh: false }` prevents automatic refresh. Triggers `'saved'`. |
+| `update(filterByTk, data, options?)` | Updates a record by its primary key. |
+| `destroy(target)` | Deletes records. `target` can be a primary key, a row object, or an array of primary keys/row objects (bulk delete). |
+| `destroySelectedRows()` | Deletes currently selected rows (throws an error if none are selected). |
+| `setItem(index, item)` | Replaces a specific row of data locally (does not initiate a request). |
+| `runAction(actionName, options)` | Calls any resource action (e.g., custom actions). |
+
+---
+
+## Configuration and Events
+
+| Method | Description |
+|------|------|
+| `setRefreshAction(name)` | The action called during refresh, default is `'list'`. |
+| `setCreateActionOptions(options)` / `setUpdateActionOptions(options)` | Request configuration for create/update. |
+| `on('refresh', fn)` / `on('saved', fn)` | Triggered after refresh completion or after saving. |
+
+---
+
+## Examples
+
+### Basic List
+
+```js
+ctx.initResource('MultiRecordResource');
+ctx.resource.setResourceName('users');
+ctx.resource.setPageSize(20);
+await ctx.resource.refresh();
+const rows = ctx.resource.getData();
+const total = ctx.resource.getCount();
+```
+
+### Filtering and Sorting
+
+```js
+ctx.resource.setResourceName('users');
+ctx.resource.setFilter({ status: 'active' });
+ctx.resource.setSort(['-createdAt']);
+ctx.resource.setFields(['id', 'nickname', 'email']);
+await ctx.resource.refresh();
+```
+
+### Association Loading
+
+```js
+ctx.resource.setResourceName('orders');
+ctx.resource.setAppends(['user', 'items']);
+await ctx.resource.refresh();
+const orders = ctx.resource.getData();
+```
+
+### Create and Pagination
+
+```js
+await ctx.resource.create({ name: 'John Doe', email: 'john.doe@example.com' });
+
+await ctx.resource.next();
+await ctx.resource.previous();
+await ctx.resource.goto(3);
+```
+
+### Bulk Delete Selected Rows
+
+```js
+const rows = ctx.resource?.getSelectedRows?.() || [];
+if (rows.length === 0) {
+  ctx.message.warning('Please select data first');
+  return;
+}
+await ctx.resource.destroySelectedRows();
+ctx.message.success(ctx.t('Deleted'));
+```
+
+### Listening to the refresh Event
+
+```js
+ctx.resource?.on?.('refresh', () => {
+  const data = ctx.resource.getData();
+  ctx.render(<ul>{data?.map((r) => <li key={r.id}>{r.name}</li>)}</ul>);
+});
+await ctx.resource?.refresh?.();
+```
+
+### Association Resource (Sub-table)
+
+```js
+const res = ctx.makeResource('MultiRecordResource');
+res.setResourceName('users.roles');
+res.setSourceId(ctx.record?.id);
+await res.refresh();
+const roles = res.getData();
+```
+
+---
+
+## Notes
+
+- **setResourceName is Required**: You must call `setResourceName('collectionName')` before use, otherwise the request URL cannot be constructed.
+- **Association Resources**: When the resource name is in the format `parent.child` (e.g., `users.tags`), you must call `setSourceId(parentPrimaryKey)` first.
+- **Refresh Debouncing**: Multiple calls to `refresh()` within the same event loop will only execute the last one to avoid redundant requests.
+- **getData returns an Array**: The `data` returned by the list API is an array of records, and `getData()` returns this array directly.
+
+---
+
+## Related
+
+- [ctx.resource](../context/resource.md) - The resource instance in the current context
+- [ctx.initResource()](../context/init-resource.md) - Initialize and bind to ctx.resource
+- [ctx.makeResource()](../context/make-resource.md) - Create a new resource instance without binding
+- [APIResource](./api-resource.md) - General API resource requested by URL
+- [SingleRecordResource](./single-record-resource.md) - Oriented towards a single record

package/dist/ai/docs/runjs/resource/single-record-resource.md

@@ -0,0 +1,169 @@
+# SingleRecordResource
+
+A Resource oriented towards a **single record**: data is a single object, supporting retrieval by primary key, creation/updating (save), and deletion. It is suitable for "single record" scenarios such as details and forms. Unlike [MultiRecordResource](./multi-record-resource.md), the `getData()` method of `SingleRecordResource` returns a single object. You specify the primary key via `setFilterByTk(id)`, and `save()` will automatically call `create` or `update` based on the `isNewRecord` state.
+
+**Inheritance**: FlowResource → APIResource → BaseRecordResource → SingleRecordResource.
+
+**Creation**: `ctx.makeResource('SingleRecordResource')` or `ctx.initResource('SingleRecordResource')`. You must call `setResourceName('collectionName')` before use. When performing operations by primary key, call `setFilterByTk(id)`. In RunJS, `ctx.api` is injected by the runtime environment.
+
+---
+
+## Use Scenarios
+
+| Scenario | Description |
+|------|------|
+| **Details Block** | The Details block uses `SingleRecordResource` by default to load a single record by its primary key. |
+| **Form Block** | Create/Edit forms use `SingleRecordResource`, where `save()` automatically distinguishes between `create` and `update`. |
+| **JSBlock Details** | Load a single user, order, etc., in a JSBlock and customize the display. |
+| **Association Resources** | Load associated single records using the format `users.profile`, requiring `setSourceId(parentRecordID)`. |
+
+---
+
+## Data Format
+
+- `getData()` returns a **single record object**, which corresponds to the `data` field of the `get` API response.
+- `getMeta()` returns metadata (if available).
+
+---
+
+## Resource Name and Primary Key
+
+| Method | Description |
+|------|------|
+| `setResourceName(name)` / `getResourceName()` | Resource name, e.g., `'users'`, `'users.profile'` (association resource). |
+| `setSourceId(id)` / `getSourceId()` | The parent record ID for association resources (e.g., `users.profile` requires the primary key of the `users` record). |
+| `setDataSourceKey(key)` / `getDataSourceKey()` | Data source identifier (used in multi-data source environments). |
+| `setFilterByTk(tk)` / `getFilterByTk()` | The primary key of the current record; once set, `isNewRecord` becomes `false`. |
+
+---
+
+## State
+
+| Property/Method | Description |
+|----------|------|
+| `isNewRecord` | Whether it is in a "New" state (true if `filterByTk` is not set or if it was just created). |
+
+---
+
+## Request Parameters (Filter / Fields)
+
+| Method | Description |
+|------|------|
+| `setFilter(filter)` / `getFilter()` | Filter (available when not in "New" state). |
+| `setFields(fields)` / `getFields()` | Requested fields. |
+| `setAppends(appends)` / `getAppends()` / `addAppends` / `removeAppends` | Association loading (appends). |
+
+---
+
+## CRUD
+
+| Method | Description |
+|------|------|
+| `refresh()` | Requests `get` based on the current `filterByTk` and updates `getData()`; does nothing in "New" state. |
+| `save(data, options?)` | Calls `create` when in "New" state, otherwise calls `update`; optional `{ refresh: false }` prevents automatic refreshing. |
+| `destroy(options?)` | Deletes the record based on the current `filterByTk` and clears local data. |
+| `runAction(actionName, options)` | Calls any resource action. |
+
+---
+
+## Configuration and Events
+
+| Method | Description |
+|------|------|
+| `setSaveActionOptions(options)` | Request configuration for the `save` action. |
+| `on('refresh', fn)` / `on('saved', fn)` | Triggered after refresh is complete or after saving. |
+
+---
+
+## Examples
+
+### Basic Retrieval and Update
+
+```js
+ctx.initResource('SingleRecordResource');
+ctx.resource.setResourceName('users');
+ctx.resource.setFilterByTk(1);
+await ctx.resource.refresh();
+const user = ctx.resource.getData();
+
+// Update
+await ctx.resource.save({ name: 'John Doe' });
+```
+
+### Create New Record
+
+```js
+const newRes = ctx.makeResource('SingleRecordResource');
+newRes.setResourceName('users');
+await newRes.save({ name: 'Jane Smith', email: 'janesmith@example.com' });
+```
+
+### Delete Record
+
+```js
+ctx.resource.setResourceName('users');
+ctx.resource.setFilterByTk(1);
+await ctx.resource.destroy();
+// After destroy, getData() returns null
+```
+
+### Association Loading and Fields
+
+```js
+ctx.resource.setResourceName('users');
+ctx.resource.setFilterByTk(1);
+ctx.resource.setFields(['id', 'nickname', 'email']);
+ctx.resource.setAppends(['profile', 'roles']);
+await ctx.resource.refresh();
+const user = ctx.resource.getData();
+```
+
+### Association Resources (e.g., users.profile)
+
+```js
+const res = ctx.makeResource('SingleRecordResource');
+res.setResourceName('users.profile');
+res.setSourceId(ctx.record?.id); // Parent record primary key
+res.setFilterByTk(profileId);    // filterByTk can be omitted if profile is a hasOne relationship
+await res.refresh();
+const profile = res.getData();
+```
+
+### Save Without Auto-Refresh
+
+```js
+await ctx.resource.save({ status: 'active' }, { refresh: false });
+// getData() retains the old value as refresh is not triggered after saving
+```
+
+### Listening to refresh / saved Events
+
+```js
+ctx.resource?.on?.('refresh', () => {
+  const data = ctx.resource.getData();
+  ctx.render(<div>User: {data?.nickname}</div>);
+});
+ctx.resource?.on?.('saved', (savedData) => {
+  ctx.message.success('Saved successfully');
+});
+await ctx.resource?.refresh?.();
+```
+
+---
+
+## Notes
+
+- **setResourceName is Required**: You must call `setResourceName('collectionName')` before use, otherwise the request URL cannot be constructed.
+- **filterByTk and isNewRecord**: If `setFilterByTk` is not called, `isNewRecord` is `true`, and `refresh()` will not initiate a request; `save()` will execute a `create` action.
+- **Association Resources**: When the resource name is in `parent.child` format (e.g., `users.profile`), you must call `setSourceId(parentPrimaryKey)` first.
+- **getData Returns an Object**: The `data` returned by single-record APIs is a record object; `getData()` returns this object directly. It becomes `null` after `destroy()`.
+
+---
+
+## Related
+
+- [ctx.resource](../context/resource.md) - The resource instance in the current context
+- [ctx.initResource()](../context/init-resource.md) - Initialize and bind to `ctx.resource`
+- [ctx.makeResource()](../context/make-resource.md) - Create a new resource instance without binding
+- [APIResource](./api-resource.md) - General API resource requested by URL
+- [MultiRecordResource](./multi-record-resource.md) - Oriented towards collections/lists, supporting CRUD and pagination

package/dist/ai/docs/runjs/resource/sql-resource.md

@@ -0,0 +1,170 @@
+# SQLResource
+
+A Resource for executing queries based on **saved SQL configurations** or **dynamic SQL**, with data sourced from interfaces such as `flowSql:run` / `flowSql:runById`. It is suitable for reports, statistics, custom SQL lists, and other scenarios. Unlike [MultiRecordResource](./multi-record-resource.md), SQLResource does not depend on collections; it executes SQL queries directly and supports pagination, parameter binding, template variables (`{{ctx.xxx}}`), and result type control.
+
+**Inheritance**: FlowResource → APIResource → BaseRecordResource → SQLResource.
+
+**Creation**: `ctx.makeResource('SQLResource')` or `ctx.initResource('SQLResource')`. To execute based on a saved configuration, use `setFilterByTk(uid)` (the UID of the SQL template). For debugging, use `setDebug(true)` + `setSQL(sql)` to execute SQL directly. In RunJS, `ctx.api` is injected by the runtime environment.
+
+---
+
+## Use Cases
+
+| Scenario | Description |
+|------|------|
+| **Reports / Statistics** | Complex aggregations, cross-table queries, and custom statistical metrics. |
+| **JSBlock Custom Lists** | Implementing special filtering, sorting, or associations using SQL with custom rendering. |
+| **Chart Blocks** | Driving chart data sources with saved SQL templates, supporting pagination. |
+| **Choosing between SQLResource and ctx.sql** | Use SQLResource when pagination, events, or reactive data are required; use `ctx.sql.run()` / `ctx.sql.runById()` for simple one-off queries. |
+
+---
+
+## Data Format
+
+- `getData()` returns different formats based on `setSQLType()`:
+  - `selectRows` (default): **Array**, multiple row results.
+  - `selectRow`: **Single object**.
+  - `selectVar`: **Scalar value** (e.g., COUNT, SUM).
+- `getMeta()` returns metadata such as pagination: `page`, `pageSize`, `count`, `totalPage`, etc.
+
+---
+
+## SQL Configuration and Execution Modes
+
+| Method | Description |
+|------|------|
+| `setFilterByTk(uid)` | Sets the UID of the SQL template to execute (corresponds to `runById`; must be saved in the admin interface first). |
+| `setSQL(sql)` | Sets the raw SQL (used for `runBySQL` only when debug mode `setDebug(true)` is enabled). |
+| `setSQLType(type)` | Result type: `'selectVar'` / `'selectRow'` / `'selectRows'`. |
+| `setDebug(enabled)` | When set to `true`, `refresh` calls `runBySQL()`; otherwise, it calls `runById()`. |
+| `run()` | Calls `runBySQL()` or `runById()` based on the debug state. |
+| `runBySQL()` | Executes using the SQL defined in `setSQL` (requires `setDebug(true)`). |
+| `runById()` | Executes the saved SQL template using the current UID. |
+
+---
+
+## Parameters and Context
+
+| Method | Description |
+|------|------|
+| `setBind(bind)` | Binds variables. Use an object for `:name` placeholders or an array for `?` placeholders. |
+| `setLiquidContext(ctx)` | Template context (Liquid), used to parse `{{ctx.xxx}}`. |
+| `setFilter(filter)` | Additional filter conditions (passed into the request data). |
+| `setDataSourceKey(key)` | Data source identifier (used for multi-data source environments). |
+
+---
+
+## Pagination
+
+| Method | Description |
+|------|------|
+| `setPage(page)` / `getPage()` | Current page (default is 1). |
+| `setPageSize(size)` / `getPageSize()` | Items per page (default is 20). |
+| `next()` / `previous()` / `goto(page)` | Navigates pages and triggers `refresh`. |
+
+In SQL, you can use `{{ctx.limit}}` and `{{ctx.offset}}` to reference pagination parameters. SQLResource injects `limit` and `offset` into the context automatically.
+
+---
+
+## Data Fetching and Events
+
+| Method | Description |
+|------|------|
+| `refresh()` | Executes the SQL (`runById` or `runBySQL`), writes the result to `setData(data)`, updates meta, and triggers the `'refresh'` event. |
+| `runAction(actionName, options)` | Calls underlying actions (e.g., `getBind`, `run`, `runById`). |
+| `on('refresh', fn)` / `on('loading', fn)` | Triggered when refreshing is complete or when loading starts. |
+
+---
+
+## Examples
+
+### Executing via Saved Template (runById)
+
+```js
+ctx.initResource('SQLResource');
+ctx.resource.setFilterByTk('active-users-report'); // UID of the saved SQL template
+ctx.resource.setBind({ status: 'active' });
+await ctx.resource.refresh();
+const data = ctx.resource.getData();
+const meta = ctx.resource.getMeta(); // page, pageSize, count, etc.
+```
+
+### Debug Mode: Executing SQL Directly (runBySQL)
+
+```js
+const res = ctx.makeResource('SQLResource');
+res.setDebug(true);
+res.setSQL('SELECT * FROM users WHERE status = :status LIMIT {{ctx.limit}}');
+res.setBind({ status: 'active' });
+await res.refresh();
+const data = res.getData();
+```
+
+### Pagination and Navigation
+
+```js
+ctx.resource.setFilterByTk('user-list-sql');
+ctx.resource.setPageSize(20);
+await ctx.resource.refresh();
+
+// Navigation
+await ctx.resource.next();
+await ctx.resource.previous();
+await ctx.resource.goto(3);
+```
+
+### Result Types
+
+```js
+// Multiple rows (default)
+ctx.resource.setSQLType('selectRows');
+const rows = ctx.resource.getData(); // [{...}, {...}]
+
+// Single row
+ctx.resource.setSQLType('selectRow');
+const row = ctx.resource.getData(); // {...}
+
+// Single value (e.g., COUNT)
+ctx.resource.setSQLType('selectVar');
+const total = ctx.resource.getData(); // 42
+```
+
+### Using Template Variables
+
+```js
+ctx.defineProperty('minId', { get: () => 10 });
+const res = ctx.makeResource('SQLResource');
+res.setDebug(true);
+res.setSQL('SELECT * FROM users WHERE id > {{ctx.minId}} LIMIT {{ctx.limit}}');
+await res.refresh();
+```
+
+### Listening to the refresh Event
+
+```js
+ctx.resource?.on?.('refresh', () => {
+  const data = ctx.resource.getData();
+  ctx.render(<ul>{data?.map((r) => <li key={r.id}>{r.name}</li>)}</ul>);
+});
+await ctx.resource?.refresh?.();
+```
+
+---
+
+## Notes
+
+- **runById requires saving the template first**: The UID used in `setFilterByTk(uid)` must be a SQL template ID already saved in the admin interface. You can save it via `ctx.sql.save({ uid, sql })`.
+- **Debug mode requires permissions**: `setDebug(true)` uses `flowSql:run`, which requires the current role to have SQL configuration permissions. `runById` only requires the user to be logged in.
+- **Refresh Debouncing**: Multiple calls to `refresh()` within the same event loop will only execute the last one to avoid redundant requests.
+- **Parameter Binding for Injection Prevention**: Use `setBind()` with `:name` or `?` placeholders instead of string concatenation to prevent SQL injection.
+
+---
+
+## Related
+
+- [ctx.sql](../context/sql.md) - SQL execution and management; `ctx.sql.runById` is suitable for simple one-off queries.
+- [ctx.resource](../context/resource.md) - The resource instance in the current context.
+- [ctx.initResource()](../context/init-resource.md) - Initializes and binds to `ctx.resource`.
+- [ctx.makeResource()](../context/make-resource.md) - Creates a new resource instance without binding.
+- [APIResource](./api-resource.md) - General API resource.
+- [MultiRecordResource](./multi-record-resource.md) - Designed for collections and lists.

package/dist/ai/docs/runjs/window.md

@@ -0,0 +1,20 @@
+# window
+
+The following properties can be accessed directly via `window`:
+
+* `setTimeout` / `clearTimeout`
+* `setInterval` / `clearInterval`
+* `console`
+* `Math`
+* `Date`
+* `FormData`
+* `addEventListener`
+* `open` (Only `http:`, `https:`, or `about:blank` are allowed)
+* `location` (Read-only, supports secure navigation)
+* `navigator`
+
+Only basic and secure DOM query and creation capabilities are supported:
+
+* `createElement(tagName)`
+* `querySelector(selectors)`
+* `querySelectorAll(selectors)`

package/dist/ai/tools/getContextApis.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/getContextApis.js

@@ -0,0 +1,62 @@
+/**
+ * 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 getContextApis_exports = {};
+__export(getContextApis_exports, {
+  default: () => getContextApis_default
+});
+module.exports = __toCommonJS(getContextApis_exports);
+var import_ai = require("@nocobase/ai");
+var import_zod = require("zod");
+var getContextApis_default = (0, import_ai.defineTools)({
+  scope: "SPECIFIED",
+  execution: "frontend",
+  defaultPermission: "ALLOW",
+  introduction: {
+    title: `{{t("ai.tools.getContextApis.title")}}`,
+    about: `{{t("ai.tools.getContextApis.about")}}`
+  },
+  definition: {
+    name: "getContextApis",
+    description: "Get available API methods from context",
+    schema: import_zod.z.object({})
+  },
+  invoke: async (ctx, _args, id) => {
+    const { toolCallResults } = ctx.action.params.values || {};
+    const { result } = (toolCallResults == null ? void 0 : toolCallResults.find((item) => item.id === id)) ?? {};
+    if (toolCallResults && result) {
+      return {
+        status: "success",
+        content: JSON.stringify(result)
+      };
+    } else {
+      return {
+        status: "success",
+        content: "{}"
+      };
+    }
+  }
+});

package/dist/ai/tools/getContextEnvs.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;