diff --git a/core/http/react-ui/src/pages/AgentTaskDetails.jsx b/core/http/react-ui/src/pages/AgentTaskDetails.jsx
index 30be94351a..8807420f55 100644
--- a/core/http/react-ui/src/pages/AgentTaskDetails.jsx
+++ b/core/http/react-ui/src/pages/AgentTaskDetails.jsx
@@ -21,10 +21,12 @@ import { jobOfRun, STRIP } from '../utils/agentJobs'
import { jobSentence } from '../utils/agentJobText'
import { formatDuration, firstLine } from '../utils/agentRuns'
import { jobDurationMs } from '../utils/agentJobs'
+import { actsStatus } from '../utils/triggerActs'
import {
EVERY_HOURS, EVERY_MINUTES, HOURLY_MINUTES, dayCodes, emptyTrigger, formatNext, joinTimes, presetOrder,
scheduleText, triggerForm, triggerPayload,
} from '../utils/chatTrigger'
+import { ActsEditor, ActsSummary } from '../components/TriggerActs'
import Icon from '../components/Icon'
// eslint-disable-next-line no-unused-vars
import { Button, LoadError, Page, PageHeader, SkeletonRows, Switch } from '../components/ui'
@@ -178,6 +180,8 @@ function TaskView({ id }) {
{task.kind === 'file' ? t('jobs.task.watches', { folder: task.folder }) : task.summary}
{task.next_run && !off ?
· {t('chats:triggersPage.next', { time: formatNext(task.next_run, task.time_zone) })} : null}
+
{t('jobs.task.acts')}
+
{t('jobs.task.cap')}
{task.daily_cap || '-'}
{t('jobs.task.enabledSwitch')}
@@ -243,6 +247,7 @@ const SECTIONS = [
{ id: 'basics', keys: ['name', 'agent_id', 'model', 'enabled'] },
{ id: 'prompt', keys: ['prompt'] },
{ id: 'schedule', keys: ['kind', 'schedule', 'time_zone', 'folder', 'quiet_seconds'] },
+ { id: 'acts', keys: ['acts'] },
{ id: 'limits', keys: ['daily_cap'] },
]
@@ -440,6 +445,9 @@ function TaskForm({ id, isNew }) {
})
const picked = agents.find(a => a.id === task.agentId)
+ // The grants of the chosen agent cap what the trigger can hold; with no agent only the list does.
+ const agentGrants = picked ? (picked.builtins || []) : null
+ const status = actsStatus({ acts: task.acts, agentGrants, writes: task.writes, lock: task.lock })
const summary = (sid) => {
if (sid === 'basics') {
if (!task.name.trim()) return { state: 'needs', text: t('jobs.edit.summary.basicsEmpty') }
@@ -452,6 +460,10 @@ function TaskForm({ id, isNew }) {
if (task.schedule.preset === 'file') return { state: task.folder.trim() ? 'ready' : 'needs', text: task.folder.trim() ? t('jobs.task.watches', { folder: task.folder }) : t('jobs.edit.summary.folderEmpty') }
return { state: 'ready', text: scheduleText(task.schedule) }
}
+ if (sid === 'acts') {
+ if (status.readOnly) return { state: 'ready', text: t('chats:triggerActs.readOnly') }
+ return { state: 'ready', text: t('jobs.edit.summary.acts', { count: status.held.length }) }
+ }
return { state: 'ready', text: task.dailyCap ? t('jobs.edit.summary.cap', { count: Number(task.dailyCap) }) : t('jobs.edit.summary.capDefault') }
}
@@ -564,6 +576,13 @@ function TaskForm({ id, isNew }) {
diff --git a/core/http/react-ui/src/utils/chatTrigger.js b/core/http/react-ui/src/utils/chatTrigger.js
index 84fcd6d520..ed6800f3a0 100644
--- a/core/http/react-ui/src/utils/chatTrigger.js
+++ b/core/http/react-ui/src/utils/chatTrigger.js
@@ -126,6 +126,7 @@ export function emptyTrigger() {
return {
id: '', name: '', prompt: '', enabled: true, schedule: emptyForm(), zone: browserZone(),
folder: '', quiet: '', dailyCap: '', agentId: '', model: '', sourceChatId: '',
+ acts: [], writes: '', lock: '',
}
}
@@ -135,6 +136,10 @@ export function triggerForm(tr) {
id: tr.id, name: tr.name, prompt: tr.prompt, enabled: tr.enabled, schedule: presetOf(tr), zone: tr.time_zone || browserZone(),
folder: tr.folder || '', quiet: tr.quiet_seconds ? String(tr.quiet_seconds) : '', dailyCap: String(tr.daily_cap || ''),
agentId: tr.agent_id || '', model: tr.model || '', sourceChatId: tr.source_chat_id || '',
+ // What a run may do alone. writes (the file its plan names) and lock (why a
+ // run is read only whatever is ticked) come from the server and are not sent.
+ acts: Array.isArray(tr.acts) ? tr.acts : [], writes: tr.plan?.writes || '',
+ lock: tr.read_only && (tr.read_only_why === 'declared' || tr.read_only_why === 'binding') ? tr.read_only_why : '',
}
}
@@ -144,6 +149,8 @@ export function triggerPayload(v) {
const body = {
name: v.name.trim(), prompt: v.prompt, kind: file ? 'file' : 'schedule', enabled: v.enabled,
daily_cap: v.dailyCap ? Number(v.dailyCap) : 0,
+ // Always sent: an edit that leaves acts out keeps them, an empty list takes them away.
+ acts: v.acts || [],
agent_id: v.agentId || undefined, model: v.model || undefined, source_chat_id: v.sourceChatId || undefined,
}
if (file) {
diff --git a/core/http/react-ui/src/utils/triggerActs.js b/core/http/react-ui/src/utils/triggerActs.js
new file mode 100644
index 0000000000..52706e6689
--- /dev/null
+++ b/core/http/react-ui/src/utils/triggerActs.js
@@ -0,0 +1,96 @@
+// What the runs of a trigger may do with nobody present: the act.* names of a
+// trigger. A run starts read only; each name adds one class of action, within
+// the grants of the trigger's agent. These functions are the rules the editor,
+// the details page and the proposal card share, so they say the same thing.
+// The server applies the same rules at each tool call. No React, so a node test
+// drives them.
+
+const list = (x) => (Array.isArray(x) ? x : [])
+
+export const ACT_FILES = 'act.files'
+export const ACT_ADDONS = 'act.addons'
+
+/** True for the name of an act: act.files, act.addons, act.addons:, act.send, act.spend. */
+export const isActGrant = (name) => typeof name === 'string' && name.startsWith('act.')
+
+/** The act.* entries of the builtin grants the server declares. */
+export function actCatalog(grants) {
+ return list(grants).filter((g) => isActGrant(g?.name))
+}
+
+/**
+ * Whether an agent's grants cover an act: the name itself, or act.addons for
+ * act.addons:. Without an agent (null) nothing but the trigger's own list
+ * limits it.
+ */
+export function withinAgent(name, agentGrants) {
+ if (agentGrants == null) return true
+ const held = list(agentGrants)
+ return held.includes(name) || (name.startsWith(`${ACT_ADDONS}:`) && held.includes(ACT_ADDONS))
+}
+
+/**
+ * The rows of the permission list: every act the server declares, on when the
+ * trigger holds it, and blocked when the agent does not hold it (a blocked
+ * row can be switched off but not on). An act the trigger holds that the
+ * server does not list, such as act.addons:, stays as an extra row so it
+ * can be taken away.
+ */
+export function actRows(catalog, acts, agentGrants) {
+ const on = new Set(list(acts))
+ const known = new Set(list(catalog).map((g) => g.name))
+ const rows = list(catalog).map((g) => ({
+ name: g.name, title: g.title, description: g.description, sensitive: !!g.sensitive,
+ on: on.has(g.name), blocked: !withinAgent(g.name, agentGrants), extra: false,
+ }))
+ for (const name of list(acts)) {
+ if (known.has(name)) continue
+ rows.push({ name, title: name, description: '', sensitive: true, on: true, blocked: !withinAgent(name, agentGrants), extra: true })
+ }
+ return rows
+}
+
+/** The acts after one is switched on or off. */
+export function actsAfter(acts, name, on) {
+ const rest = list(acts).filter((x) => x !== name)
+ return on ? [...rest, name] : rest
+}
+
+/**
+ * What the runs of a trigger can do, from the fields of the form:
+ * { readOnly, why, held, unused }. held are the acts that apply; unused the
+ * ones the trigger lists but its agent does not hold. why is declared or
+ * binding (set by how the trigger was made, and nothing ticked changes it),
+ * agent (it lists acts its agent holds none of) or no_acts. A trigger whose
+ * plan names a file it writes also holds act.files, as the server does.
+ */
+export function actsStatus({ acts, agentGrants = null, writes = '', lock = '' }) {
+ const listed = list(acts)
+ if (lock) return { readOnly: true, why: lock, held: [], unused: listed }
+ const held = listed.filter((n) => withinAgent(n, agentGrants))
+ if (writes && !held.includes(ACT_FILES) && withinAgent(ACT_FILES, agentGrants)) held.push(ACT_FILES)
+ const unused = listed.filter((n) => !held.includes(n))
+ if (held.length === 0) return { readOnly: true, why: listed.length > 0 ? 'agent' : 'no_acts', held, unused }
+ return { readOnly: false, why: '', held, unused }
+}
+
+/** The same answer from a trigger as the server returns it (acts, acts_held, read_only, read_only_why). */
+export function actsStatusOf(trigger) {
+ const acts = list(trigger?.acts)
+ const held = list(trigger?.acts_held)
+ return {
+ readOnly: !!trigger?.read_only, why: trigger?.read_only_why || '', held,
+ unused: trigger?.read_only ? acts : acts.filter((n) => !held.includes(n)),
+ }
+}
+
+/** The rows of a list of act names, with the title and weight the server declares. */
+export function actNamed(catalog, names) {
+ const byName = new Map(list(catalog).map((g) => [g.name, g]))
+ return list(names).map((name) => {
+ const g = byName.get(name)
+ return g
+ ? { name, title: g.title, description: g.description, sensitive: !!g.sensitive }
+ : { name, title: name, description: '', sensitive: name.startsWith(`${ACT_ADDONS}:`) }
+ })
+}
diff --git a/core/http/react-ui/tests/unit/chattrigger.test.mjs b/core/http/react-ui/tests/unit/chattrigger.test.mjs
index 8c90d92bc4..2b30df9699 100644
--- a/core/http/react-ui/tests/unit/chattrigger.test.mjs
+++ b/core/http/react-ui/tests/unit/chattrigger.test.mjs
@@ -49,7 +49,7 @@ test('chat triggers: a stored file trigger is the file preset', () => {
test('chat triggers: the request body of a schedule and of a file trigger', () => {
const base = { name: ' Digest ', prompt: 'Go.', enabled: true, dailyCap: '', agentId: '', model: 'm', sourceChatId: '', zone: 'Europe/Rome', folder: '', quiet: '' }
assert.deepEqual(triggerPayload({ ...base, schedule: form({ preset: 'weekdays', time: '09:00' }) }), {
- name: 'Digest', prompt: 'Go.', kind: 'schedule', enabled: true, daily_cap: 0, agent_id: undefined, model: 'm', source_chat_id: undefined,
+ name: 'Digest', prompt: 'Go.', kind: 'schedule', enabled: true, daily_cap: 0, acts: [], agent_id: undefined, model: 'm', source_chat_id: undefined,
schedule: 'weekdays 09:00', time_zone: 'Europe/Rome',
})
const file = triggerPayload({ ...base, schedule: form({ preset: 'file' }), folder: ' /Contracts ', quiet: '45', dailyCap: '5', agentId: 'a1' })
diff --git a/core/http/react-ui/tests/unit/triggeracts.test.mjs b/core/http/react-ui/tests/unit/triggeracts.test.mjs
new file mode 100644
index 0000000000..b64f449ff7
--- /dev/null
+++ b/core/http/react-ui/tests/unit/triggeracts.test.mjs
@@ -0,0 +1,103 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import {
+ actCatalog, actNamed, actRows, actsAfter, actsStatus, actsStatusOf, isActGrant, withinAgent,
+} from '../../src/utils/triggerActs.js'
+import { emptyTrigger, triggerForm, triggerPayload } from '../../src/utils/chatTrigger.js'
+
+const grants = [
+ { name: 'memory.write', title: 'Save memory', description: 'd', sensitive: false },
+ { name: 'act.files', title: 'Write files on its own', description: 'files', sensitive: true },
+ { name: 'act.addons', title: 'Use add-on actions on its own', description: 'addons', sensitive: true },
+ { name: 'act.send', title: 'Send messages on its own', description: 'send', sensitive: true },
+ { name: 'act.spend', title: 'Use paid or external tools on its own', description: 'spend', sensitive: true },
+]
+
+test('trigger acts: the catalog keeps only the act names', () => {
+ assert.deepEqual(actCatalog(grants).map((g) => g.name), ['act.files', 'act.addons', 'act.send', 'act.spend'])
+ assert.deepEqual(actCatalog(undefined), [])
+ assert.equal(isActGrant('act.files'), true)
+ assert.equal(isActGrant('memory.write'), false)
+})
+
+test('trigger acts: an agent covers an act by name, or act.addons covers one add-on', () => {
+ assert.equal(withinAgent('act.files', ['act.files']), true)
+ assert.equal(withinAgent('act.spend', ['act.files']), false)
+ assert.equal(withinAgent('act.addons:mail', ['act.addons']), true)
+ assert.equal(withinAgent('act.addons:mail', ['act.files']), false)
+ assert.equal(withinAgent('act.spend', null), true, 'no agent, no ceiling')
+ assert.equal(withinAgent('act.spend', []), false, 'an agent with no grants covers nothing')
+})
+
+test('trigger acts: rows are on when held, blocked when the agent lacks them, and keep an unlisted act', () => {
+ const rows = actRows(actCatalog(grants), ['act.files', 'act.addons:mail'], ['act.files'])
+ const by = Object.fromEntries(rows.map((r) => [r.name, r]))
+ assert.equal(by['act.files'].on, true)
+ assert.equal(by['act.files'].blocked, false)
+ assert.equal(by['act.spend'].on, false)
+ assert.equal(by['act.spend'].blocked, true)
+ assert.equal(by['act.files'].sensitive, true)
+ assert.equal(by['act.addons:mail'].extra, true)
+ assert.equal(by['act.addons:mail'].on, true)
+ assert.equal(by['act.addons:mail'].blocked, true, 'the agent holds act.files only')
+ assert.equal(rows.length, 5)
+})
+
+test('trigger acts: switching an act on or off', () => {
+ assert.deepEqual(actsAfter(['act.files'], 'act.send', true), ['act.files', 'act.send'])
+ assert.deepEqual(actsAfter(['act.files', 'act.send'], 'act.files', false), ['act.send'])
+ assert.deepEqual(actsAfter(undefined, 'act.send', false), [])
+})
+
+test('trigger acts: a trigger with no acts is read only and says so', () => {
+ const s = actsStatus({ acts: [], agentGrants: ['act.files'] })
+ assert.deepEqual([s.readOnly, s.why], [true, 'no_acts'])
+})
+
+test('trigger acts: acts the agent does not hold do not apply, and the reason is the agent', () => {
+ const s = actsStatus({ acts: ['act.spend'], agentGrants: ['act.files'] })
+ assert.deepEqual([s.readOnly, s.why, s.held, s.unused], [true, 'agent', [], ['act.spend']])
+ const mixed = actsStatus({ acts: ['act.spend', 'act.files'], agentGrants: ['act.files'] })
+ assert.deepEqual([mixed.readOnly, mixed.held, mixed.unused], [false, ['act.files'], ['act.spend']])
+})
+
+test('trigger acts: a plan that names a file it writes holds act.files', () => {
+ const s = actsStatus({ acts: [], agentGrants: ['act.files'], writes: 'data/out.json' })
+ assert.deepEqual([s.readOnly, s.held], [false, ['act.files']])
+ assert.equal(actsStatus({ acts: [], agentGrants: [], writes: 'data/out.json' }).readOnly, true, 'the agent must hold it too')
+})
+
+test('trigger acts: a lock from the way it was made wins over every act', () => {
+ for (const lock of ['declared', 'binding']) {
+ const s = actsStatus({ acts: ['act.files'], agentGrants: ['act.files'], lock })
+ assert.deepEqual([s.readOnly, s.why, s.held], [true, lock, []])
+ }
+})
+
+test('trigger acts: the status of a trigger as the server returns it', () => {
+ const t = { acts: ['act.files', 'act.spend'], acts_held: ['act.files'], read_only: false }
+ assert.deepEqual(actsStatusOf(t), { readOnly: false, why: '', held: ['act.files'], unused: ['act.spend'] })
+ const ro = actsStatusOf({ acts: ['act.files'], read_only: true, read_only_why: 'binding' })
+ assert.deepEqual([ro.readOnly, ro.why, ro.unused], [true, 'binding', ['act.files']])
+ assert.equal(actsStatusOf(null).readOnly, false)
+})
+
+test('trigger acts: names get the title and weight of the catalog', () => {
+ const rows = actNamed(grants, ['act.send', 'act.addons:mail'])
+ assert.deepEqual(rows.map((r) => [r.name, r.title, r.sensitive]), [
+ ['act.send', 'Send messages on its own', true],
+ ['act.addons:mail', 'act.addons:mail', true],
+ ])
+})
+
+test('trigger acts: the editor sends the acts it loaded, and an empty list when none', () => {
+ const loaded = triggerForm({ id: 'x', name: 'n', prompt: 'p', enabled: true, kind: 'schedule', schedule: 'daily 08:00', acts: ['act.files'], read_only: false,
+ plan: { writes: 'data/out.json' } })
+ assert.deepEqual(loaded.acts, ['act.files'])
+ assert.equal(loaded.writes, 'data/out.json')
+ assert.deepEqual(triggerPayload(loaded).acts, ['act.files'])
+ assert.deepEqual(triggerPayload(emptyTrigger()).acts, [], 'a new trigger sends an empty list: read only')
+ const locked = triggerForm({ id: 'x', name: 'n', prompt: 'p', enabled: true, kind: 'schedule', schedule: 'daily 08:00', read_only: true, read_only_why: 'declared' })
+ assert.equal(locked.lock, 'declared')
+ assert.deepEqual(triggerPayload(locked).acts, [])
+})