@matatbread/matbot-triggers 0.2.4 → 0.2.6

package/package.json

@@ -4,7 +4,7 @@
     "node",
     "browser"
   ],
-  "version": "0.2.4",
+  "version": "0.2.6",
   "engines": {
     "node": ">=24.0.0"
   },
@@ -33,11 +33,11 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@matatbread/matbot-plugin-api": "^0.2.4"
+    "@matatbread/matbot-plugin-api": "^0.2.6"
   },
   "devDependencies": {
     "typescript": "^5.8.0",
-    "@matatbread/matbot-plugin-api": "^0.2.4"
+    "@matatbread/matbot-plugin-api": "^0.2.6"
   },
   "scripts": {
     "typecheck": "tsc --noEmit"

package/src/dispatch.ts

@@ -1,15 +1,7 @@
-import type { MatbotMachine, Session, ToolContext, PromptFn, FormField, MessageContent } from '@matatbread/matbot-plugin-api';
+import type { MatbotMachine, Session, PromptFn, MessageContent } from '@matatbread/matbot-plugin-api';
+import { invokeTool } from '@matatbread/matbot-plugin-api';
 import type { Trigger } from './types.js';
 
-// Fallback when the firing hook carries no interactive prompt (cron/background run, or a frontend
-// that supplied none): a tool that tries to prompt resolves to a rejection it surfaces as a normal
-// tool error. When the hook DOES carry a prompt (a live interactive session behind this turn), it is
-// forwarded instead, so a trigger can invoke an interactive tool (e.g. `ask_user`) for real.
-const rejectingPrompt: PromptFn = (((p: string | FormField): Promise<string> => {
-  const label = typeof p === 'string' ? p : p.label;
-  return Promise.reject(new Error(`Non-interactive context: cannot prompt for "${label}"`));
-}) as PromptFn);
-
 export interface DispatchOutcome {
   /** Whether the tool yielded a result — i.e. whether the model should be woken with it (inject). */
   hadResult: boolean;
@@ -44,32 +36,23 @@ export async function dispatchTrigger(
   // and the worst case is "this trigger did nothing and left a trace"; sibling triggers, the hook,
   // and the session are unaffected. (The hook dispatcher's own try/catch is a second layer behind this.)
   try {
-    const tool = services.tools.resolve(trigger.invoke.tool);
-    if (tool === null) {
+    if (services.tools.resolve(trigger.invoke.tool) === null) {
       console.warn(`[triggers] trigger ${trigger.id} invokes unknown tool "${trigger.invoke.tool}"; skipped.`);
       fail(`tool "${trigger.invoke.tool}" not registered`);
       return { hadResult: false, result: undefined, markers };
     }
 
-    const toolCtx: ToolContext = {
-      callId:       crypto.randomUUID(),
-      session:      ctx.session,
-      signal:       ctx.signal,
-      vault:        services.Vault,
-      provider:     ctx.provider,
-      prompt:       ctx.prompt ?? rejectingPrompt,
-      // Forward the prompt into plugin loading too (mirrors the normal loop): collision resolution
-      // during a loaded plugin's setup() prompts the user, so a trigger that loads a plugin (e.g. the
-      // DRTX case — an agent reply triggers `plugin(load …)`) is interactive end-to-end, not just at
-      // the tool's own ctx.prompt calls.
-      loadPlugin:   (specifier: string) => services.loadPlugin(specifier, ctx.prompt ?? rejectingPrompt),
-      unloadPlugin: (specifier: string) => services.unloadPlugin(specifier),
-      ...(services.workdir    !== undefined ? { workdir:    services.workdir    } : {}),
-      ...(services.configPath !== undefined ? { configPath: services.configPath } : {}),
-      ...(services.files      !== undefined ? { files:      services.files      } : {}),
-    };
+    // The prompt (when the firing hook carries one — a live interactive session behind this turn) is
+    // forwarded so a trigger can invoke an interactive tool (e.g. `ask_user`) for real; absent, the
+    // tool runs non-interactively and a prompt attempt surfaces as a normal tool error.
+    const events = invokeTool(services, trigger.invoke.tool, trigger.invoke.params, {
+      session:  ctx.session,
+      signal:   ctx.signal,
+      provider: ctx.provider,
+      ...(ctx.prompt !== undefined ? { prompt: ctx.prompt } : {}),
+    });
 
-    for await (const ev of tool.executor.execute(trigger.invoke.params, toolCtx)) {
+    for await (const ev of events) {
       if      (ev.type === 'result') { result = ev.value; hadResult = true; }
       else if (ev.type === 'marker') { markers.push({ type: 'marker', creator: ev.creator, data: ev.data }); }
       else if (ev.type === 'error')  {

package/src/tools.ts

@@ -1,6 +1,26 @@
-import type { Tool, ToolExecutor, ToolContext, ToolEvent, MatbotMachine } from '@matatbread/matbot-plugin-api';
+import type { Tool, ToolExecutor, ToolResult, ToolResultOf, ToolContext, MatbotMachine } from '@matatbread/matbot-plugin-api';
 import type { TriggerManager } from './manager.js';
-import type { TriggerCondition, TriggerKind } from './types.js';
+import type { TriggerCondition, TriggerKind, Trigger } from './types.js';
+
+declare module '@matatbread/matbot-plugin-api' {
+  interface ToolResults {
+    // One arm per action: a caller of `invokeTool(machine, 'trigger_action', { action: '…' })` gets the
+    // matching result narrowed by the `action` it passed (see ToolResult / the multi-action note on ToolResults).
+    trigger_action:
+      | ToolResult<{ triggers: Trigger[] }, { action: 'list'   }>
+      | ToolResult<{ triggers: Trigger[] }, { action: 'query'  }>
+      | ToolResult<Trigger,                 { action: 'get'    }>
+      | ToolResult<{ id: string },          { action: 'add'    }>
+      | ToolResult<Trigger,                 { action: 'update' }>
+      | ToolResult<{ id: string },          { action: 'remove' }>
+      | ToolResult<{ triggers: Trigger[] }, { action: 'move'   }>
+      | ToolResult<{ triggers: Trigger[] }, { action: 'copy'   }>;
+    triggers_config:
+      | ToolResult<{ classifierProvider: string | null; available: string[] }, { action: 'get'   }>
+      | ToolResult<{ classifierProvider: string },                             { action: 'set'   }>
+      | ToolResult<{ classifierProvider: null },                               { action: 'clear' }>;
+  }
+}
 
 const KINDS: readonly TriggerKind[] = ['ephemeral', 'contextual', 'retract', 'followup'];
 const isKind = (x: unknown): x is TriggerKind => typeof x === 'string' && (KINDS as readonly string[]).includes(x);
@@ -39,7 +59,17 @@ type TriggerActionInput =
   | { action: 'get';    id: string }
   | { action: 'add';    conditions: TriggerCondition[]; tool: string; params?: unknown; enabled?: boolean }
   | { action: 'update'; id: string; conditions?: TriggerCondition[]; tool?: string; params?: unknown; enabled?: boolean }
-  | { action: 'remove'; id: string };
+  | { action: 'remove'; id: string }
+  | { action: 'move';   tool?: string; params?: unknown; toTool: string; toParams?: unknown }
+  | { action: 'copy';   tool?: string; params?: unknown; toTool: string; toParams?: unknown };
+
+// The query selector shared by query/move/copy: `tool`/`params` narrow the set by what a trigger invokes.
+function queryFilter(a: { tool?: unknown; params?: unknown }): { tool?: string; params?: unknown } {
+  return {
+    ...(typeof a.tool === 'string' ? { tool: a.tool } : {}),
+    ...(a.params !== undefined ? { params: a.params } : {}),
+  };
+}
 
 // A condition is valid if it has a recognised `kind` and a string `rule`.
 function validConditions(x: unknown): x is TriggerCondition[] {
@@ -49,9 +79,9 @@ function validConditions(x: unknown): x is TriggerCondition[] {
     typeof (c as { rule?: unknown }).rule === 'string');
 }
 
-export function createTriggerActionTool(manager: TriggerManager): Tool {
-  const executor: ToolExecutor = {
-    async *execute(input: unknown, _ctx: ToolContext): AsyncIterable<ToolEvent> {
+export function createTriggerActionTool(manager: TriggerManager): Tool<ToolResultOf<'trigger_action'>> {
+  const executor: ToolExecutor<ToolResultOf<'trigger_action'>> = {
+    async *execute(input: unknown, _ctx: ToolContext) {
       const args = input as Partial<TriggerActionInput> & { action?: string };
 
       switch (args.action) {
@@ -62,10 +92,7 @@ export function createTriggerActionTool(manager: TriggerManager): Tool {
 
         case 'query': {
           const a = args as Extract<TriggerActionInput, { action: 'query' }>;
-          yield { type: 'result', value: { triggers: manager.query({
-            ...(typeof a.tool === 'string' ? { tool: a.tool } : {}),
-            ...(a.params !== undefined ? { params: a.params } : {}),
-          }) } };
+          yield { type: 'result', value: { triggers: manager.query(queryFilter(a)) } };
           return;
         }
 
@@ -118,8 +145,39 @@ export function createTriggerActionTool(manager: TriggerManager): Tool {
           return;
         }
 
+        case 'move': {
+          const a = args as Extract<TriggerActionInput, { action: 'move' }>;
+          if (typeof a.toTool !== 'string')                  { yield { type: 'error', message: 'action "move" requires a string "toTool" to re-target the selected triggers onto.' }; return; }
+          if (a.tool === undefined && a.params === undefined) { yield { type: 'error', message: 'action "move" requires a filter ("tool" and/or "params") selecting which triggers to re-target — refusing to move every trigger.' }; return; }
+          const invoke = { tool: a.toTool, ...(a.toParams !== undefined ? { params: a.toParams } : {}) };
+          const triggers: Trigger[] = [];
+          for (const t of manager.query(queryFilter(a))) {
+            const updated = await manager.update(t.id, { invoke });
+            if (updated !== undefined) triggers.push(updated);
+          }
+          yield { type: 'result', value: { triggers } };
+          return;
+        }
+
+        case 'copy': {
+          const a = args as Extract<TriggerActionInput, { action: 'copy' }>;
+          if (typeof a.toTool !== 'string')                  { yield { type: 'error', message: 'action "copy" requires a string "toTool" to point the duplicates at.' }; return; }
+          if (a.tool === undefined && a.params === undefined) { yield { type: 'error', message: 'action "copy" requires a filter ("tool" and/or "params") selecting which triggers to duplicate — refusing to duplicate every trigger.' }; return; }
+          const invoke = { tool: a.toTool, ...(a.toParams !== undefined ? { params: a.toParams } : {}) };
+          const triggers: Trigger[] = [];
+          for (const t of manager.query(queryFilter(a))) {
+            triggers.push(await manager.add({
+              conditions: t.conditions,
+              invoke,
+              ...(t.enabled !== undefined ? { enabled: t.enabled } : {}),
+            }));
+          }
+          yield { type: 'result', value: { triggers } };
+          return;
+        }
+
         default:
-          yield { type: 'error', message: `Unknown action "${String(args.action)}". Expected one of: list, query, get, add, update, remove.` };
+          yield { type: 'error', message: `Unknown action "${String(args.action)}". Expected one of: list, query, get, add, update, remove, move, copy.` };
       }
     },
   };
@@ -129,7 +187,8 @@ export function createTriggerActionTool(manager: TriggerManager): Tool {
     description:
       'Manage triggers — data-driven hooks that invoke a tool when an LLM classifier judges one of ' +
       'their conditions matched against the current turn. Use this to list triggers, find the ones ' +
-      'that invoke a given tool (query), read one, create one, edit one by id, or delete one.\n\n' +
+      'that invoke a given tool (query), read one, create one, edit one by id, delete one, or bulk ' +
+      're-target a selected set onto a new tool — in place (move) or as duplicates (copy).\n\n' +
       GUIDANCE + '\n\n' +
       'A trigger has a stable `id` — address it by that, never by its conditions. To change one, ' +
       '"get" or "list" first to read the id, then "update" by id.\n\n' +
@@ -143,18 +202,25 @@ export function createTriggerActionTool(manager: TriggerManager): Tool {
       "  | { action: 'get';    id: string }                                                // -> the trigger\n" +
       "  | { action: 'add';    conditions: TriggerCondition[]; tool: string; params?: object; enabled?: boolean }  // -> { id }\n" +
       "  | { action: 'update'; id: string; conditions?: TriggerCondition[]; tool?: string; params?: object; enabled?: boolean }  // edit by id\n" +
-      "  | { action: 'remove'; id: string };                                               // -> { id }\n" +
-      '```',
+      "  | { action: 'remove'; id: string }                                                // -> { id }\n" +
+      "  | { action: 'move';   tool?: string; params?: object; toTool: string; toParams?: object }   // re-target the queried set's invoke to toTool/toParams in place -> { triggers: [...] }\n" +
+      "  | { action: 'copy';   tool?: string; params?: object; toTool: string; toParams?: object };  // duplicate the queried set, the copies invoking toTool/toParams -> { triggers: [...] }\n" +
+      '```\n\n' +
+      'For `move`/`copy`, `tool`/`params` are the SAME selector as `query` (they pick which triggers ' +
+      'to act on); `toTool`/`toParams` are the new invocation. A filter is required — both refuse to ' +
+      'act on the entire trigger set.',
     inputSchema: {
       type:       'object',
       required:   ['action'],
       properties: {
-        action:     { type: 'string', enum: ['list', 'query', 'get', 'add', 'update', 'remove'], description: 'The operation to perform.' },
+        action:     { type: 'string', enum: ['list', 'query', 'get', 'add', 'update', 'remove', 'move', 'copy'], description: 'The operation to perform.' },
         id:         { type: 'string', description: 'Trigger id. Required for get/update/remove.' },
         conditions: { type: 'array', description: 'Conditions [{ kind: "ephemeral"|"contextual"|"retract"|"followup", rule: string }]. Required for add.',
           items: { type: 'object', properties: { kind: { type: 'string', enum: ['ephemeral', 'contextual', 'retract', 'followup'] }, rule: { type: 'string' } } } },
-        tool:       { type: 'string', description: 'Name of the tool to invoke when a condition matches. Required for add.' },
-        params:     { type: 'object', description: 'Params passed verbatim as the invoked tool\'s input.' },
+        tool:       { type: 'string', description: 'For add: the tool to invoke. For query/move/copy: the selector matching invoke.tool.' },
+        params:     { type: 'object', description: 'For add: params passed verbatim as the invoked tool\'s input. For query/move/copy: the selector matching invoke.params.' },
+        toTool:     { type: 'string', description: 'New tool the selected triggers should invoke. Required for move/copy.' },
+        toParams:   { type: 'object', description: 'New params for the selected triggers\' invocation (move/copy).' },
         enabled:    { type: 'boolean', description: 'Set false to keep but disable the trigger.' },
       },
     },
@@ -168,10 +234,10 @@ export function createTriggerActionTool(manager: TriggerManager): Tool {
  * own provider (so triggers work with zero config); set it to pin a small/fast model. Resolved per
  * evaluation, so a change takes effect on the next turn without a restart.
  */
-export function createTriggersConfigTool(services: MatbotMachine): Tool {
+export function createTriggersConfigTool(services: MatbotMachine): Tool<ToolResultOf<'triggers_config'>> {
   const KEY = 'classifierProvider';
-  const executor: ToolExecutor = {
-    async *execute(input: unknown, _ctx: ToolContext): AsyncIterable<ToolEvent> {
+  const executor: ToolExecutor<ToolResultOf<'triggers_config'>> = {
+    async *execute(input: unknown, _ctx: ToolContext) {
       const args      = input as { action?: string; provider?: string };
       const settings  = services.settings();
       const available = [...services.providers.keys()];