loopengine 0.2.1 → 0.3.0

package/dist/core/system-tools/schedule.js

@@ -1,5 +1,6 @@
 import { cancelScheduledTask, createScheduledTask, getScheduledTask, listScheduledTasks, } from '../scheduler.js';
 import { formatWallTime, workspaceTimeZone } from '../time-zone.js';
+import { readWorkflows, validateParams } from '../workflows.js';
 /** How many active (not done or cancelled) tasks one agent may create
  * through these tools — each run is a model call, so a runaway loop of
  * "schedule another one" stops here. The console and API aren't capped. */
@@ -16,7 +17,7 @@ function summary(t, timeZone) {
     return {
         task_id: t.task_id,
         task_name: t.task_name,
-        message: t.message,
+        ...(t.workflow_id ? { workflow_id: t.workflow_id, ...(t.params ? { params: t.params } : {}) } : { message: t.message }),
         schedule: t.schedule,
         status: t.status,
         next_run_at: t.next_run_at,
@@ -25,10 +26,18 @@ function summary(t, timeZone) {
         last_status: t.last_status,
     };
 }
-export function createScheduleTools(agentName) {
-    // Read once per run: the time zone is in the tool description, which
-    // should stay the same from call to call.
+/** `agentDir`: the agent's folder, where its workflows are listed
+ * (workflows.yml). Without it the agent can only schedule messages. */
+export function createScheduleTools(agentName, options = {}) {
+    // Read once per run: the time zone and the workflows are in the tool
+    // description, which should stay the same from call to call.
     const timeZone = workspaceTimeZone();
+    const workflows = options.agentDir ? readWorkflows(options.agentDir) : [];
+    const paramList = (w) => {
+        const names = Object.entries(w.parameters).map(([name, p]) => `${name}${p.required ? '' : '?'}`);
+        return names.length ? `; params: ${names.join(', ')}` : '';
+    };
+    const workflowList = workflows.map((w) => `"${w.id}" (${w.title}: ${w.description}${paramList(w)})`).join('; ');
     async function ownTask(taskId, tool) {
         const task = await getScheduledTask(taskId);
         // Another agent's task reads exactly like a missing one.
@@ -38,14 +47,24 @@ export function createScheduleTools(agentName) {
     }
     const scheduleTask = {
         name: 'system_schedule_task',
-        description: 'Schedule a message to yourself for later — once at a set time, or repeatedly on an interval — like setting a reminder or a cron job. When it fires you receive the message as a new conversation (none of the current one carries over, so make the message self-contained) and handle it with your tools as usual, with no person live. A tool call that needs approval goes wherever your approval requests are sent and waits; if nowhere is set, it is denied. Use only when the user asks for something to happen later or regularly, never on your own initiative. Times are in this workspace\'s time zone, ' + timeZone + ', unless you give an offset, so when the user means another time zone, give its offset. Prefer the longest interval that serves them since each run is a model call, and confirm the schedule back in plain words. Returns task_id, next_run_at and next_run_local (the workspace\'s time).',
+        description: 'Schedule a message to yourself for later — once at a set time, or repeatedly on an interval — like setting a reminder or a cron job.' +
+            (workflows.length
+                ? ' To run one of your workflows on a schedule, give its workflow_id instead of a message, and its params (names ending in ? are optional): each run then starts with that workflow\'s start message and steps as they are at the time, so later edits to the workflow apply. Your workflows: ' + workflowList + '.'
+                : '') +
+            ' When it fires you receive the message as a new conversation (none of the current one carries over, so make the message self-contained) and handle it with your tools as usual, with no person live. A tool call that needs approval goes wherever your approval requests are sent and waits; if nowhere is set, it is denied. Use only when the user asks for something to happen later or regularly, never on your own initiative. Times are in this workspace\'s time zone, ' + timeZone + ', unless you give an offset, so when the user means another time zone, give its offset. Prefer the longest interval that serves them since each run is a model call, and confirm the schedule back in plain words. Returns task_id, next_run_at and next_run_local (the workspace\'s time).',
         input_schema: {
             type: 'object',
             properties: {
                 message: {
                     type: 'string',
-                    description: 'What you will receive when the task fires, written as an instruction to your future self with every detail it needs, e.g. "Check whether order 4417 has shipped and email the customer at a@example.com if it has."',
+                    description: 'What you will receive when the task fires, written as an instruction to your future self with every detail it needs, e.g. "Check whether order 4417 has shipped and email the customer at a@example.com if it has." Leave it out when giving workflow_id.',
                 },
+                ...(workflows.length
+                    ? {
+                        workflow_id: { type: 'string', enum: workflows.map((w) => w.id), description: 'One of your workflows, to run it on this schedule instead of a message.' },
+                        params: { type: 'object', description: 'The workflow\'s parameters for every run, e.g. { "region": "US" }.', additionalProperties: { type: 'string' } },
+                    }
+                    : {}),
                 schedule: {
                     type: 'object',
                     description: 'Either { "run_at": "<ISO 8601 timestamp>" } for once, or { "every": "<interval>", ... } to repeat until cancelled — a number plus s/m/h/d, e.g. "30m", "1h", "1d"; 30s at the shortest. A timestamp without an offset, like "2026-11-02T09:00", is in the workspace\'s time zone (' + timeZone + '). A repeating task keeps its first slot: started at 10:07 with "1h", it fires at 11:07, 12:07, ... For a time of day or day of week, add "at" (24-hour "HH:MM") and for weekly "weekday": "every day at 9am" is { "every": "1d", "at": "09:00" }; "every Monday at 9am" is { "every": "7d", "at": "09:00", "weekday": "monday" }. Daily and weekly tasks keep their time of day when the clocks change. Or give "start_at", a timestamp, for the first run.',
@@ -54,26 +73,42 @@ export function createScheduleTools(agentName) {
                 task_name: { type: 'string', description: 'Optional short label, shown when listing tasks and in the console.' },
                 notify: { type: 'boolean', description: 'Optional — also send each run\'s result through your notifier (where your approval requests go), so a person sees it.' },
             },
-            required: ['message', 'schedule'],
+            required: ['schedule'],
         },
         execute: async (input) => {
             const active = (await listScheduledTasks({ agent: agentName })).filter((t) => t.status !== 'done' && t.status !== 'cancelled');
             if (active.length >= maxActivePerAgent()) {
                 throw new Error(`system_schedule_task: you already have ${active.length} active scheduled tasks (the limit is ${maxActivePerAgent()}); cancel one you no longer need first`);
             }
+            const workflowId = typeof input.workflow_id === 'string' && input.workflow_id ? input.workflow_id : undefined;
+            const workflow = workflowId ? workflows.find((w) => w.id === workflowId) : undefined;
+            if (workflowId && !workflow) {
+                throw new Error(`system_schedule_task: you have no workflow "${workflowId}"${workflows.length ? `; yours are ${workflows.map((w) => `"${w.id}"`).join(', ')}` : ''}`);
+            }
+            let params;
+            if (workflow) {
+                try {
+                    params = validateParams(workflow, input.params);
+                }
+                catch (err) {
+                    throw new Error(`system_schedule_task: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
             const task = await createScheduledTask({
                 agent: agentName,
-                message: String(input.message ?? ''),
+                message: workflowId ? undefined : String(input.message ?? ''),
+                workflow_id: workflowId,
+                ...(params && Object.keys(params).length ? { params } : {}),
                 schedule: (input.schedule ?? {}),
                 task_name: typeof input.task_name === 'string' ? input.task_name : undefined,
                 notify: input.notify === true,
             });
-            return JSON.stringify({ task_id: task.task_id, next_run_at: task.next_run_at, next_run_local: nextRunLocal(task, timeZone), schedule: task.schedule });
+            return JSON.stringify({ task_id: task.task_id, ...(workflowId ? { workflow_id: workflowId } : {}), next_run_at: task.next_run_at, next_run_local: nextRunLocal(task, timeZone), schedule: task.schedule });
         },
     };
     const listTasks = {
         name: 'system_list_scheduled_tasks',
-        description: 'List your own scheduled tasks (task_id, name, message, schedule, status, next_run_at, run_count, last_status). Check this before scheduling something recurring, so you don\'t create a duplicate. status "awaiting_approval" means a run is waiting on someone to approve or answer.',
+        description: 'List your own scheduled tasks (task_id, name, message or workflow_id, schedule, status, next_run_at, run_count, last_status). Check this before scheduling something recurring, so you don\'t create a duplicate. status "awaiting_approval" means a run is waiting on someone to approve or answer.',
         input_schema: {
             type: 'object',
             properties: {

package/dist/core/workflows.d.ts

@@ -1,26 +1,55 @@
-import type { WorkflowStep } from './system-agents/workflow-planner.js';
-export interface WorkflowRecord {
-    /** lowercase-hyphenated; also its skill's folder name. */
+export interface WorkflowParameter {
+    description: string;
+    required: boolean;
+}
+export interface Workflow {
+    /** The skill's id (its folder name). */
     id: string;
-    name: string;
-    summary: string;
-    trigger: {
-        kind: 'schedule' | 'on_request';
-        description: string;
-    };
-    steps: WorkflowStep[];
-    /** The message each run starts with. */
+    /** A name for people, e.g. "Refund check". */
+    title: string;
+    description: string;
     startMessage: string;
-    /** Its schedule's name, when it has one (the Schedules tab's task_name). */
-    scheduleName?: string;
-    /** What the person wrote, kept for reference. */
-    description?: string;
-    createdAt: string;
+    /** When it runs, in plain words: "Every Monday at 9", "When asked". */
+    trigger: string;
+    parameters: Record<string, WorkflowParameter>;
+    /** Its steps: the skill body, placeholders unfilled. */
+    steps: string;
+}
+/** The front matter that makes a skill a workflow. */
+export interface WorkflowFields {
+    title?: string;
+    startMessage: string;
+    trigger?: string;
+    parameters?: Record<string, WorkflowParameter>;
 }
-export declare function workflowsPath(agentDir: string): string;
-/** The agent's workflows; none when it has no workflows.yml or it can't be read. */
-export declare function readWorkflows(agentDir: string): WorkflowRecord[];
-/** Adds a workflow, replacing one with the same id. */
-export declare function saveWorkflow(agentDir: string, workflow: WorkflowRecord): void;
-/** Forgets a workflow. Its skill, schedule and rules are left as they are. */
-export declare function removeWorkflow(agentDir: string, id: string): void;
+export declare class WorkflowParamsError extends Error {
+}
+/** Writes a skill file: its front matter (name and description first) and
+ * body. */
+export declare function writeSkillFile(path: string, frontmatter: Record<string, unknown>, body: string): void;
+/** The agent's workflows: its skills that have a start message. */
+export declare function readWorkflows(agentDir: string): Workflow[];
+export declare function readWorkflow(agentDir: string, id: string): Workflow | undefined;
+/** Makes a skill a workflow, or changes how its runs start. The skill must
+ * exist; its body and other front matter are kept. */
+export declare function setWorkflowFields(agentDir: string, id: string, fields: WorkflowFields): void;
+/** Stops a skill being a workflow. The skill itself stays. */
+export declare function clearWorkflowFields(agentDir: string, id: string): void;
+/** Checks a run's parameters against what the workflow declares: every
+ * required one given, no unknown ones. Values are given as text (numbers
+ * and true/false are accepted and turned into text). */
+export declare function validateParams(workflow: Workflow, input: unknown): Record<string, string>;
+/** The message a run of the workflow starts with: its start message, then
+ * its steps, each $parameter filled in. Values no placeholder uses are
+ * listed as inputs, so the agent still gets them. */
+export declare function workflowRunMessage(workflow: Workflow, params?: Record<string, string>): string;
+export declare function legacyWorkflowsPath(agentDir: string): string;
+/** Moves the workflows in an agent's workflows.yml into their skills'
+ * front matter, then renames the file to workflows.migrated.yml. Returns
+ * each moved workflow's id with the schedule name it was linked by, so
+ * the caller can point those schedules at the workflow. Does nothing
+ * when there is no workflows.yml. */
+export declare function migrateWorkflowsFile(agentDir: string): {
+    id: string;
+    scheduleName?: string;
+}[];

package/dist/core/workflows.js

@@ -1,39 +1,230 @@
-// An agent's workflows: jobs it does, each a skill (its steps), a trigger
-// (a schedule, or a message) and checkpoints (questions, and tools set to
-// "ask"). Recorded in agents/<name>/workflows.yml when one is added from
-// "Describe a workflow", so the agent's Overview can list them; the skill,
-// the schedule and the rules themselves live where they always do.
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+// An agent's workflows: skills it can be told to run, by hand, from an app
+// over the API, or on a schedule. A workflow is a skill
+// (agents/<name>/skills/<id>/SKILL.md) whose front matter also says how a
+// run starts:
+//
+//   ---
+//   name: refund-check
+//   description: Check a refund request against the order and our policy
+//   title: Refund check
+//   start_message: Check the refund request for order $order_number.
+//   trigger: When a refund request comes in
+//   parameters:
+//     order_number: { description: The order to check, required: true }
+//     customer_note: { description: What the customer wrote }
+//   ---
+//   1. Look up order $order_number…
+//
+// The body is its steps. A run starts with the start message and those
+// steps, with each $parameter filled in, so the model has them from its
+// first turn rather than picking the skill from its index. None of these
+// keys reach the model otherwise: the skill index shows only a skill's
+// name and description (core/skillgarden).
+//
+// Agents from before kept their workflows in workflows.yml;
+// migrateWorkflowsFile moves those into their skills.
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
 import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
-export function workflowsPath(agentDir) {
-    return join(agentDir, 'workflows.yml');
+import { parseSkillFile, substituteParameters } from './skillgarden/index.js';
+export class WorkflowParamsError extends Error {
+}
+const PARAMETER_NAME = /^[a-z_][a-z0-9_]*$/;
+const WORKFLOW_KEYS = ['title', 'start_message', 'trigger', 'parameters'];
+function skillsDir(agentDir) {
+    return join(agentDir, 'skills');
+}
+function skillPath(agentDir, id) {
+    return join(skillsDir(agentDir), id, 'SKILL.md');
+}
+function readSkillFile(path, id) {
+    if (!existsSync(path))
+        return undefined;
+    try {
+        const { frontmatter, body } = parseSkillFile(readFileSync(path, 'utf8'), id);
+        return { frontmatter: frontmatter, body };
+    }
+    catch {
+        return undefined;
+    }
 }
-/** The agent's workflows; none when it has no workflows.yml or it can't be read. */
+/** Writes a skill file: its front matter (name and description first) and
+ * body. */
+export function writeSkillFile(path, frontmatter, body) {
+    const { name, description, ...rest } = frontmatter;
+    const ordered = { name, description, ...rest };
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `---\n${stringifyYaml(ordered).trimEnd()}\n---\n\n${body.trim()}\n`);
+}
+function titleFromId(id) {
+    const words = id.replace(/-/g, ' ');
+    return words.charAt(0).toUpperCase() + words.slice(1);
+}
+function parametersFrom(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    const parameters = {};
+    for (const [name, spec] of Object.entries(value)) {
+        if (!PARAMETER_NAME.test(name))
+            continue;
+        const s = spec && typeof spec === 'object' ? spec : {};
+        parameters[name] = { description: typeof s.description === 'string' ? s.description : '', required: s.required === true };
+    }
+    return parameters;
+}
+function workflowFrom(id, frontmatter, body) {
+    const startMessage = typeof frontmatter.start_message === 'string' ? frontmatter.start_message.trim() : '';
+    if (!startMessage)
+        return undefined;
+    return {
+        id,
+        title: typeof frontmatter.title === 'string' && frontmatter.title.trim() ? frontmatter.title.trim() : titleFromId(id),
+        description: typeof frontmatter.description === 'string' ? frontmatter.description : '',
+        startMessage,
+        trigger: typeof frontmatter.trigger === 'string' && frontmatter.trigger.trim() ? frontmatter.trigger.trim() : 'When asked',
+        parameters: parametersFrom(frontmatter.parameters),
+        steps: body,
+    };
+}
+/** The agent's workflows: its skills that have a start message. */
 export function readWorkflows(agentDir) {
-    const path = workflowsPath(agentDir);
+    const dir = skillsDir(agentDir);
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .sort()
+        .flatMap((id) => {
+        const skill = readSkillFile(skillPath(agentDir, id), id);
+        const workflow = skill && workflowFrom(id, skill.frontmatter, skill.body);
+        return workflow ? [workflow] : [];
+    });
+}
+export function readWorkflow(agentDir, id) {
+    if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(id))
+        return undefined;
+    const skill = readSkillFile(skillPath(agentDir, id), id);
+    return skill && workflowFrom(id, skill.frontmatter, skill.body);
+}
+/** Makes a skill a workflow, or changes how its runs start. The skill must
+ * exist; its body and other front matter are kept. */
+export function setWorkflowFields(agentDir, id, fields) {
+    const path = skillPath(agentDir, id);
+    const skill = readSkillFile(path, id);
+    if (!skill)
+        throw new Error(`No skill "${id}" to make a workflow.`);
+    for (const name of Object.keys(fields.parameters ?? {})) {
+        if (!PARAMETER_NAME.test(name))
+            throw new Error(`Parameter "${name}": use lowercase letters, digits and _, starting with a letter, e.g. "order_number".`);
+    }
+    const frontmatter = { ...skill.frontmatter };
+    for (const key of WORKFLOW_KEYS)
+        delete frontmatter[key];
+    writeSkillFile(path, {
+        ...frontmatter,
+        ...(fields.title ? { title: fields.title } : {}),
+        start_message: fields.startMessage,
+        ...(fields.trigger ? { trigger: fields.trigger } : {}),
+        ...(fields.parameters && Object.keys(fields.parameters).length ? { parameters: fields.parameters } : {}),
+    }, skill.body);
+}
+/** Stops a skill being a workflow. The skill itself stays. */
+export function clearWorkflowFields(agentDir, id) {
+    const path = skillPath(agentDir, id);
+    const skill = readSkillFile(path, id);
+    if (!skill)
+        return;
+    const frontmatter = { ...skill.frontmatter };
+    for (const key of WORKFLOW_KEYS)
+        delete frontmatter[key];
+    writeSkillFile(path, frontmatter, skill.body);
+}
+/** Checks a run's parameters against what the workflow declares: every
+ * required one given, no unknown ones. Values are given as text (numbers
+ * and true/false are accepted and turned into text). */
+export function validateParams(workflow, input) {
+    if (input !== undefined && input !== null && (typeof input !== 'object' || Array.isArray(input))) {
+        throw new WorkflowParamsError('params must be an object of names to values, e.g. { "order_number": "EM20-123" }');
+    }
+    const given = (input ?? {});
+    const params = {};
+    const problems = [];
+    for (const [name, value] of Object.entries(given)) {
+        if (!(name in workflow.parameters)) {
+            problems.push(`unknown parameter "${name}"`);
+            continue;
+        }
+        if (value === undefined || value === null || value === '')
+            continue;
+        if (typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean') {
+            problems.push(`"${name}" must be text`);
+            continue;
+        }
+        params[name] = String(value);
+    }
+    for (const [name, spec] of Object.entries(workflow.parameters)) {
+        if (spec.required && !params[name]?.trim())
+            problems.push(`"${name}" is required`);
+    }
+    if (problems.length) {
+        const known = Object.keys(workflow.parameters);
+        throw new WorkflowParamsError(`${workflow.title}: ${problems.join('; ')}${known.length ? ` (its parameters: ${known.join(', ')})` : ' (it takes no parameters)'}`);
+    }
+    return params;
+}
+/** The message a run of the workflow starts with: its start message, then
+ * its steps, each $parameter filled in. Values no placeholder uses are
+ * listed as inputs, so the agent still gets them. */
+export function workflowRunMessage(workflow, params = {}) {
+    const used = new Set();
+    const declared = Object.keys(workflow.parameters);
+    // Named placeholders only: positional $1-style filling would eat dollar
+    // amounts like "$50" in the steps.
+    const fill = (text) => substituteParameters(text, params, { declared, used });
+    const start = fill(workflow.startMessage);
+    const steps = fill(workflow.steps).trim();
+    const unused = Object.entries(params).filter(([name]) => !used.has(name));
+    return [
+        start,
+        unused.length ? `Inputs:\n${unused.map(([name, value]) => `- ${name}: ${value}`).join('\n')}` : '',
+        steps ? `These are the steps, from your "${workflow.id}" skill:\n\n${steps}` : '',
+    ].filter(Boolean).join('\n\n');
+}
+export function legacyWorkflowsPath(agentDir) {
+    return join(agentDir, 'workflows.yml');
+}
+/** Moves the workflows in an agent's workflows.yml into their skills'
+ * front matter, then renames the file to workflows.migrated.yml. Returns
+ * each moved workflow's id with the schedule name it was linked by, so
+ * the caller can point those schedules at the workflow. Does nothing
+ * when there is no workflows.yml. */
+export function migrateWorkflowsFile(agentDir) {
+    const path = legacyWorkflowsPath(agentDir);
     if (!existsSync(path))
         return [];
+    let records = [];
     try {
         const parsed = parseYaml(readFileSync(path, 'utf8'));
-        return Array.isArray(parsed?.workflows) ? parsed.workflows.filter((w) => w && typeof w.id === 'string' && typeof w.name === 'string') : [];
+        records = Array.isArray(parsed?.workflows) ? parsed.workflows.filter((w) => w && typeof w.id === 'string') : [];
     }
     catch {
         return [];
     }
-}
-/** Adds a workflow, replacing one with the same id. */
-export function saveWorkflow(agentDir, workflow) {
-    const workflows = readWorkflows(agentDir).filter((w) => w.id !== workflow.id);
-    workflows.push(workflow);
-    const header = "# This agent's workflows, added from the console's \"Describe a workflow\". Each one's\n# steps are its skill (skills/<id>/SKILL.md); its schedule and rules are in the Schedules and Permissions tabs.\n";
-    writeFileSync(workflowsPath(agentDir), header + stringifyYaml({ workflows }));
-}
-/** Forgets a workflow. Its skill, schedule and rules are left as they are. */
-export function removeWorkflow(agentDir, id) {
-    const workflows = readWorkflows(agentDir);
-    if (!workflows.some((w) => w.id === id))
-        return;
-    const rest = workflows.filter((w) => w.id !== id);
-    writeFileSync(workflowsPath(agentDir), stringifyYaml({ workflows: rest }));
+    const moved = [];
+    for (const record of records) {
+        const skill = readSkillFile(skillPath(agentDir, record.id), record.id);
+        if (!skill || !record.startMessage?.trim())
+            continue;
+        if (!workflowFrom(record.id, skill.frontmatter, skill.body)) {
+            setWorkflowFields(agentDir, record.id, {
+                ...(record.name ? { title: record.name } : {}),
+                startMessage: record.startMessage,
+                ...(record.trigger?.description ? { trigger: record.trigger.description } : {}),
+            });
+        }
+        moved.push({ id: record.id, ...(record.scheduleName ? { scheduleName: record.scheduleName } : {}) });
+    }
+    renameSync(path, join(agentDir, 'workflows.migrated.yml'));
+    return moved;
 }

package/dist/index.d.ts

@@ -10,7 +10,7 @@ export { setUsageSink, recordUsage, type UsageEvent, type UsageSink } from '#cor
 export { readNotifierFile, writeNotifierFile, removeNotifierFile, validateNotifierFile, notifierConfigFromFile, NotifierFileError, NOTIFIER_SECRET_VARS, type NotifierFile, type MessagingApprover } from '#core/notifier-file.js';
 export { listDeliveries, recordDelivery, type NotifierDelivery } from '#core/notifier-deliveries.js';
 export { describeNotifier } from '#core/http-notifier.js';
-export { Scheduler, ScheduleError, FileSchedulerStore, getSchedulerStore, setSchedulerStore, createScheduledTask, listScheduledTasks, getScheduledTask, cancelScheduledTask, pauseScheduledTask, resumeScheduledTask, runScheduledTaskNow, deleteScheduledTask, nextScheduledWakeAt, moveScheduledTasksToTimeZone, importLegacyScheduledTasks, parseEvery, describeSchedule, type ScheduledTask, type ScheduledTaskRun, type ScheduledTaskStatus, type Schedule, type SchedulerStore, type FireTask, type CreateScheduledTaskInput } from '#core/scheduler.js';
+export { Scheduler, ScheduleError, FileSchedulerStore, getSchedulerStore, setSchedulerStore, createScheduledTask, listScheduledTasks, getScheduledTask, cancelScheduledTask, pauseScheduledTask, resumeScheduledTask, runScheduledTaskNow, setScheduledTaskNotify, deleteScheduledTask, nextScheduledWakeAt, moveScheduledTasksToTimeZone, importLegacyScheduledTasks, parseEvery, describeSchedule, type ScheduledTask, type ScheduledTaskRun, type ScheduledTaskStatus, type Schedule, type SchedulerStore, type FireTask, type CreateScheduledTaskInput } from '#core/scheduler.js';
 export { NOTIFIER_SLACK_SIGNING_SECRET_VAR } from '#core/notifier-file.js';
 export { firstSighting, handleInboundMessage, handleMessagingAction, settleThreadChoice, isPlainApproval, type MessagingDeps, type MessagingDecision, type DecisionOutcome } from '#core/messaging/engine.js';
 export { formatArgs, formatChange, labelFor } from '#core/messaging/format-args.js';
@@ -81,9 +81,12 @@ export { templatesPageHtml } from './web/templates-page.js';
 export { TemplateError, createFromTemplate, createFromTemplateObject, describeTemplateSchedule, listTemplates, previewTemplate, templateChecklist, type CreatedTemplateAgent, type LegacyTemplateCreateDeps, type TemplateChecklistItem, type TemplateCreateDeps, type TemplatePreview, type TemplateSummary, } from './web/templates-admin.js';
 export { STARTER_TEMPLATES, starterTemplate, templateScheduleStart, type StarterTemplate, type TemplateRule, type TemplateSchedule, type TemplateSetup, type TemplateSkill, } from './core/system-agents/templates.js';
 export { workflowPageHtml } from './web/workflow-page.js';
-export { WorkflowError, checkWorkflowForAgent, createWorkflow, forgetWorkflow, getPlanJob, listAgentWorkflows, planWorkflow, resolveConnections, runWorkflowNow, startPlanJob, type AgentWorkflowView, type CreatedWorkflow, type PlanJob, type PlannedWorkflow, type WorkflowAgentInfo, type WorkflowCheck, type WorkflowConflict, type WorkflowCreateDeps, type WorkflowMcpDeps, type WorkflowMcpCreateDeps, resolveMcpServers, prepareMcpAbilities, } from './web/workflow-admin.js';
-export { WORKFLOW_PLANNER_PROMPT, planWorkflowWithModel, validateWorkflowPlan, workflowTemplate, type WorkflowPlan, type WorkflowPlannerTools, type WorkflowStep } from './core/system-agents/workflow-planner.js';
-export { readWorkflows, removeWorkflow, saveWorkflow, type WorkflowRecord } from './core/workflows.js';
+export { WorkflowError, checkWorkflowForAgent, createWorkflow, forgetWorkflow, migrateAgentWorkflows, getPlanJob, listAgentWorkflows, planWorkflow, resolveConnections, prepareWorkflowRun, updateWorkflow, startPlanJob, type AgentWorkflowView, type CreatedWorkflow, type PlanJob, type PlannedWorkflow, type WorkflowAgentInfo, type WorkflowCheck, type WorkflowConflict, type WorkflowCreateDeps, type WorkflowMcpDeps, type WorkflowMcpCreateDeps, resolveMcpServers, prepareMcpAbilities, } from './web/workflow-admin.js';
+export { WORKFLOW_PLANNER_PROMPT, planParameters, planWorkflowWithModel, validateWorkflowPlan, workflowTemplate, type WorkflowPlan, type WorkflowPlannerTools, type WorkflowStep } from './core/system-agents/workflow-planner.js';
+export { createTrigger, updateTrigger, rotateTrigger, listTriggers, findTriggerByToken, publicTrigger, checkTriggerSettings, verifySenderSignature, parsePayload, valueAt, deliveryId, passesFilter, paramsFromPayload, recordDelivery as recordTriggerDelivery, FileTriggerStore, getTriggerStore, setTriggerStore, TriggerError, type WorkflowTrigger, type PublicTrigger, type TriggerSettings, type TriggerVerify, type TriggerFilter, type TriggerSender, type SignatureAlgorithm, type TriggerDelivery, type TriggerOutcome, type TriggerStore } from './core/workflow-triggers.js';
+export { checkCallbackUrl, callbackSecret, signCallback, deliverCallback, runCallbackPayload, isPrivateAddress, CallbackUrlError, type CallbackDelivery, type RunCallbackEvent } from './core/run-callbacks.js';
+export { WorkflowRunner, FileRunStore, getRunStore, setRunStore, listRuns, getRun, isUnderWay, RunError, type WorkflowRun, type WorkflowRunStatus, type RunStore, type ExecuteRun, type RunOutcome, type StartRunInput } from './core/workflow-runs.js';
+export { readWorkflows, readWorkflow, setWorkflowFields, clearWorkflowFields, validateParams, workflowRunMessage, migrateWorkflowsFile, WorkflowParamsError, type Workflow, type WorkflowFields, type WorkflowParameter } from './core/workflows.js';
 export { globalConfigPageHtml } from './web/global-config-page.js';
 export { playgroundHtml } from './web/playground.js';
 export { readSkill, writeSkill, deleteSkill, SkillInvalidIdError, SkillNotFoundError } from './web/skills-admin.js';

package/dist/index.js

@@ -12,7 +12,7 @@ export { setUsageSink, recordUsage } from '#core/usage.js';
 export { readNotifierFile, writeNotifierFile, removeNotifierFile, validateNotifierFile, notifierConfigFromFile, NotifierFileError, NOTIFIER_SECRET_VARS } from '#core/notifier-file.js';
 export { listDeliveries, recordDelivery } from '#core/notifier-deliveries.js';
 export { describeNotifier } from '#core/http-notifier.js';
-export { Scheduler, ScheduleError, FileSchedulerStore, getSchedulerStore, setSchedulerStore, createScheduledTask, listScheduledTasks, getScheduledTask, cancelScheduledTask, pauseScheduledTask, resumeScheduledTask, runScheduledTaskNow, deleteScheduledTask, nextScheduledWakeAt, moveScheduledTasksToTimeZone, importLegacyScheduledTasks, parseEvery, describeSchedule } from '#core/scheduler.js';
+export { Scheduler, ScheduleError, FileSchedulerStore, getSchedulerStore, setSchedulerStore, createScheduledTask, listScheduledTasks, getScheduledTask, cancelScheduledTask, pauseScheduledTask, resumeScheduledTask, runScheduledTaskNow, setScheduledTaskNotify, deleteScheduledTask, nextScheduledWakeAt, moveScheduledTasksToTimeZone, importLegacyScheduledTasks, parseEvery, describeSchedule } from '#core/scheduler.js';
 export { NOTIFIER_SLACK_SIGNING_SECRET_VAR } from '#core/notifier-file.js';
 export { firstSighting, handleInboundMessage, handleMessagingAction, settleThreadChoice, isPlainApproval } from '#core/messaging/engine.js';
 export { formatArgs, formatChange, labelFor } from '#core/messaging/format-args.js';
@@ -74,9 +74,12 @@ export { templatesPageHtml } from './web/templates-page.js';
 export { TemplateError, createFromTemplate, createFromTemplateObject, describeTemplateSchedule, listTemplates, previewTemplate, templateChecklist, } from './web/templates-admin.js';
 export { STARTER_TEMPLATES, starterTemplate, templateScheduleStart, } from './core/system-agents/templates.js';
 export { workflowPageHtml } from './web/workflow-page.js';
-export { WorkflowError, checkWorkflowForAgent, createWorkflow, forgetWorkflow, getPlanJob, listAgentWorkflows, planWorkflow, resolveConnections, runWorkflowNow, startPlanJob, resolveMcpServers, prepareMcpAbilities, } from './web/workflow-admin.js';
-export { WORKFLOW_PLANNER_PROMPT, planWorkflowWithModel, validateWorkflowPlan, workflowTemplate } from './core/system-agents/workflow-planner.js';
-export { readWorkflows, removeWorkflow, saveWorkflow } from './core/workflows.js';
+export { WorkflowError, checkWorkflowForAgent, createWorkflow, forgetWorkflow, migrateAgentWorkflows, getPlanJob, listAgentWorkflows, planWorkflow, resolveConnections, prepareWorkflowRun, updateWorkflow, startPlanJob, resolveMcpServers, prepareMcpAbilities, } from './web/workflow-admin.js';
+export { WORKFLOW_PLANNER_PROMPT, planParameters, planWorkflowWithModel, validateWorkflowPlan, workflowTemplate } from './core/system-agents/workflow-planner.js';
+export { createTrigger, updateTrigger, rotateTrigger, listTriggers, findTriggerByToken, publicTrigger, checkTriggerSettings, verifySenderSignature, parsePayload, valueAt, deliveryId, passesFilter, paramsFromPayload, recordDelivery as recordTriggerDelivery, FileTriggerStore, getTriggerStore, setTriggerStore, TriggerError } from './core/workflow-triggers.js';
+export { checkCallbackUrl, callbackSecret, signCallback, deliverCallback, runCallbackPayload, isPrivateAddress, CallbackUrlError } from './core/run-callbacks.js';
+export { WorkflowRunner, FileRunStore, getRunStore, setRunStore, listRuns, getRun, isUnderWay, RunError } from './core/workflow-runs.js';
+export { readWorkflows, readWorkflow, setWorkflowFields, clearWorkflowFields, validateParams, workflowRunMessage, migrateWorkflowsFile, WorkflowParamsError } from './core/workflows.js';
 export { globalConfigPageHtml } from './web/global-config-page.js';
 export { playgroundHtml } from './web/playground.js';
 export { readSkill, writeSkill, deleteSkill, SkillInvalidIdError, SkillNotFoundError } from './web/skills-admin.js';

package/dist/web/agent-file-admin.d.ts

@@ -3,6 +3,8 @@ export declare class AgentEditNotSupportedError extends Error {
 export declare class AgentFileNotFoundError extends Error {
 }
 type Provider = 'anthropic' | 'openai' | 'deepseek' | 'kimi' | 'glm' | 'gemini' | 'xai' | 'meta';
+/** The providers whose model calls take a reasoning effort. */
+export declare const REASONING_PROVIDERS: Provider[];
 export interface AgentEditableFields {
     systemPrompt?: string;
     model?: {

package/dist/web/agent-file-admin.js

@@ -48,6 +48,8 @@ export class AgentEditNotSupportedError extends Error {
 }
 export class AgentFileNotFoundError extends Error {
 }
+/** The providers whose model calls take a reasoning effort. */
+export const REASONING_PROVIDERS = ['openai', 'anthropic'];
 const MODEL_ENV_VAR = {
     anthropic: 'ANTHROPIC_API_KEY',
     openai: 'OPENAI_API_KEY',
@@ -178,12 +180,12 @@ export function editAgentFile(agentName, fields) {
             throw new AgentEditNotSupportedError('model.maxTokens must be a positive integer.');
         }
         const reasoningEffort = fields.model.reasoningEffort;
-        // Only AgentModelConfig's 'openai' variant carries this (see its own
-        // doc comment) — refusing rather than silently dropping it for
-        // another provider, same "don't guess" posture the model-name check
-        // right above already follows.
-        if (reasoningEffort !== undefined && provider !== 'openai') {
-            throw new AgentModelError(`model.reasoningEffort only applies to provider 'openai' — '${provider}' doesn't support it.`);
+        // Only AgentModelConfig's 'openai' and 'anthropic' variants carry this
+        // (see their doc comments) — refusing rather than silently dropping it
+        // for another provider, same "don't guess" posture the model-name
+        // check right above already follows.
+        if (reasoningEffort !== undefined && !REASONING_PROVIDERS.includes(provider)) {
+            throw new AgentModelError(`model.reasoningEffort only applies to providers ${REASONING_PROVIDERS.join(' and ')} — '${provider}' doesn't support it.`);
         }
         // Every field the form actually round-trips (not just provider/model)
         // — omitting maxTokens/reasoningEffort here, the way this used to