@themoltnet/node-red-contrib-core 0.1.0

package/dist/nodes/task-reader.js

@@ -0,0 +1,57 @@
+import { TaskResultError, createResultReader } from "@themoltnet/sdk";
+//#region src/nodes/task-reader.ts
+var init = (RED) => {
+	function TaskReaderNode(def) {
+		RED.nodes.createNode(this, def);
+		this.on("input", (msg, send, done) => {
+			try {
+				const sourcePath = def.source && def.source.length > 0 ? def.source : "payload";
+				const snapshot = RED.util.getMessageProperty(msg, sourcePath);
+				if (!snapshot || !snapshot.task || !snapshot.attempt) throw new TaskResultError([{
+					field: "payload",
+					message: "no task snapshot found on the message"
+				}]);
+				const reader = createResultReader(snapshot.task, snapshot.attempt);
+				const role = def.role ?? "context";
+				const filter = def.artifactKind ? def.artifactTitle ? {
+					kind: def.artifactKind,
+					title: def.artifactTitle
+				} : def.artifactKind : void 0;
+				let artifactBody;
+				const artifact = filter ? reader.artifact(filter) : void 0;
+				if (filter && artifact && typeof artifact.body === "string") try {
+					artifactBody = JSON.parse(artifact.body);
+				} catch {
+					artifactBody = void 0;
+				}
+				const out = RED.util.cloneMessage(msg);
+				out.payload = reader.output;
+				out.result = {
+					summary: reader.summary,
+					outputRef: reader.outputRef(role),
+					artifact,
+					artifactBody,
+					accepted: reader.accepted,
+					usage: reader.usage
+				};
+				this.status({
+					fill: "green",
+					shape: "dot",
+					text: "read"
+				});
+				send(out);
+				done();
+			} catch (err) {
+				this.status({
+					fill: "red",
+					shape: "ring",
+					text: "error"
+				});
+				done(err instanceof TaskResultError ? new Error(err.message) : err instanceof Error ? err : new Error(String(err)));
+			}
+		});
+	}
+	RED.nodes.registerType("moltnet-task-reader", TaskReaderNode);
+};
+//#endregion
+export { init as default };

package/dist/nodes/task-snapshot.js

@@ -0,0 +1,32 @@
+//#region src/nodes/task-snapshot.ts
+/** Task statuses that mean the run will not progress further. */
+var TERMINAL_TASK_STATUSES = new Set([
+	"completed",
+	"failed",
+	"cancelled",
+	"expired"
+]);
+function isTerminalTaskStatus(status) {
+	return TERMINAL_TASK_STATUSES.has(status);
+}
+function buildTaskSnapshot(task, attempts) {
+	const acceptedAttemptN = task.acceptedAttemptN;
+	const acceptedAttempt = acceptedAttemptN !== null ? attempts.find((a) => a.attemptN === acceptedAttemptN) ?? null : null;
+	const latestAttempt = attempts.length > 0 ? attempts.reduce((max, a) => a.attemptN > max.attemptN ? a : max) : null;
+	const attempt = acceptedAttempt ?? latestAttempt;
+	const accepted = acceptedAttempt !== null;
+	return {
+		taskId: task.id,
+		status: task.status,
+		terminal: isTerminalTaskStatus(task.status),
+		accepted,
+		acceptedAttemptN,
+		state: accepted ? acceptedAttempt?.output ?? null : null,
+		attempt,
+		attempts,
+		error: latestAttempt?.error ?? null,
+		task
+	};
+}
+//#endregion
+export { isTerminalTaskStatus as n, buildTaskSnapshot as t };

package/dist/nodes/task-wait.html

@@ -0,0 +1,166 @@
+<script type="text/javascript">
+  const MN_MESSAGE_KINDS = [
+    'text_delta',
+    'tool_call_start',
+    'tool_call_end',
+    'turn_end',
+    'error',
+    'info',
+  ];
+  RED.nodes.registerType('moltnet-task-wait', {
+    category: 'moltnet',
+    color: '#00d4c8',
+    paletteLabel: 'task: wait',
+    defaults: {
+      name: { value: '' },
+      agent: { value: '', type: 'moltnet-agent', required: true },
+      taskId: { value: '' },
+      pollIntervalSec: { value: 5, validate: RED.validators.number() },
+      timeoutSec: { value: 1800, validate: RED.validators.number() },
+      tail: { value: false },
+      kinds: { value: '' },
+    },
+    inputs: 1,
+    outputs: 2,
+    outputLabels: ['tail', 'result'],
+    icon: 'font-awesome/fa-hourglass-half',
+    label: function () {
+      return this.name || 'task: wait';
+    },
+    oneditprepare: function () {
+      // Render one checkbox per message kind. `kinds` is stored as a
+      // comma-separated string (the runtime contract); empty = all kinds.
+      const selected = (this.kinds || '')
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+      const container = $('#node-input-kinds-list').empty();
+      MN_MESSAGE_KINDS.forEach((kind) => {
+        const checked = selected.length === 0 || selected.indexOf(kind) !== -1;
+        container.append(
+          '<label style="display:inline-block;width:auto;margin-right:12px;font-weight:normal">' +
+            '<input type="checkbox" class="mn-kind" value="' +
+            kind +
+            '" ' +
+            (checked ? 'checked' : '') +
+            ' style="display:inline-block;width:auto;vertical-align:baseline;margin-right:4px"/>' +
+            kind +
+            '</label>',
+        );
+      });
+      // Show the kinds row only when tailing is enabled.
+      const toggle = () => {
+        $('#node-row-kinds').toggle($('#node-input-tail').is(':checked'));
+      };
+      $('#node-input-tail').on('change', toggle);
+      toggle();
+    },
+    oneditsave: function () {
+      const all = $('.mn-kind').length;
+      const checked = $('.mn-kind:checked')
+        .map(function () {
+          return this.value;
+        })
+        .get();
+      // All (or none) checked = no filter → empty string forwards every kind.
+      this.kinds = checked.length === all ? '' : checked.join(',');
+    },
+  });
+</script>
+
+<script type="text/html" data-template-name="moltnet-task-wait">
+  <div class="form-row">
+    <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+    <input type="text" id="node-input-name" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-agent"><i class="fa fa-user"></i> Agent</label>
+    <input type="text" id="node-input-agent" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-taskId"><i class="fa fa-hashtag"></i> Task ID</label>
+    <input
+      type="text"
+      id="node-input-taskId"
+      placeholder="msg.payload.taskId"
+    />
+  </div>
+  <div class="form-row">
+    <label for="node-input-pollIntervalSec"
+      ><i class="fa fa-clock-o"></i> Poll (s)</label
+    >
+    <input type="text" id="node-input-pollIntervalSec" placeholder="5" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-timeoutSec"
+      ><i class="fa fa-hourglass-end"></i> Timeout (s)</label
+    >
+    <input
+      type="text"
+      id="node-input-timeoutSec"
+      placeholder="1800 (0 = none)"
+    />
+  </div>
+  <div class="form-row">
+    <label for="node-input-tail"><i class="fa fa-stream"></i> Tail</label>
+    <input
+      type="checkbox"
+      id="node-input-tail"
+      style="display: inline-block; width: auto; vertical-align: top"
+    />
+    <span>Emit live task messages on output 1</span>
+  </div>
+  <div class="form-row" id="node-row-kinds" style="margin-bottom: 0">
+    <label style="vertical-align: top"
+      ><i class="fa fa-filter"></i> Kinds</label
+    >
+    <div
+      id="node-input-kinds-list"
+      style="display: inline-block; width: 70%; vertical-align: top"
+    ></div>
+  </div>
+  <div class="form-tips" id="node-tip-kinds">
+    Tail forwards only the checked message kinds. All checked = forward every
+    kind.
+  </div>
+  <input type="hidden" id="node-input-kinds" />
+</script>
+
+<script type="text/html" data-help-name="moltnet-task-wait">
+  <p>
+    Polls a MoltNet task until it reaches a terminal status, in one loop that
+    does double duty (like the CLI's <code>task tail</code>).
+  </p>
+  <h3>Inputs</h3>
+  <dl class="message-properties">
+    <dt>taskId<span class="property-type">string</span></dt>
+    <dd>
+      From <code>msg.taskId</code>, <code>msg.payload.taskId</code>, or
+      <code>msg.payload.id</code>, falling back to the configured Task ID.
+    </dd>
+  </dl>
+  <h3>Outputs</h3>
+  <ol class="node-ports">
+    <li>
+      <b>tail</b> — each new task message (<code>text_delta</code>,
+      <code>tool_call_start/end</code>, <code>turn_end</code>,
+      <code>error</code>, <code>info</code>) as it arrives, on
+      <code>msg.payload</code>. Only emitted when <b>Tail</b> is enabled; the
+      optional <b>Kinds</b> filter forwards just those kinds (cursor still
+      advances past the rest). Fires many times.
+    </li>
+    <li>
+      <b>result</b> — the terminal snapshot on <code>msg.payload</code>:
+      <code
+        >{ status, terminal, accepted, state, attempt, attempts, error, task
+        }</code
+      >. Fires once. On failure, <code>error</code> carries the last attempt's
+      error for an agent/human to interpret.
+    </li>
+  </ol>
+  <p>
+    Terminal status is checked after draining each message page, so trailing
+    messages land on the tail output before the result fires. A
+    <b>Timeout</b> of <code>0</code> waits indefinitely.
+  </p>
+</script>

package/dist/nodes/task-wait.js

@@ -0,0 +1,133 @@
+import { n as isTerminalTaskStatus, t as buildTaskSnapshot } from "./task-snapshot.js";
+//#region src/nodes/task-wait.ts
+var DEFAULT_POLL_SEC = 5;
+var DEFAULT_TIMEOUT_SEC = 1800;
+var init = (RED) => {
+	function TaskWaitNode(def) {
+		RED.nodes.createNode(this, def);
+		const agentNode = def.agent ? RED.nodes.getNode(def.agent) : null;
+		const pollMs = Math.max(1, def.pollIntervalSec || DEFAULT_POLL_SEC) * 1e3;
+		const timeoutMs = (def.timeoutSec ?? DEFAULT_TIMEOUT_SEC) > 0 ? (def.timeoutSec ?? DEFAULT_TIMEOUT_SEC) * 1e3 : 0;
+		const kindAllow = parseKinds(def.kinds);
+		const pending = /* @__PURE__ */ new Set();
+		this.on("close", () => {
+			for (const t of pending) clearTimeout(t);
+			pending.clear();
+		});
+		this.on("input", (msg, send, done) => {
+			const run = async () => {
+				try {
+					if (!agentNode || typeof agentNode.getAgent !== "function") throw new Error("task-wait: no moltnet-agent configured");
+					const taskId = resolveTaskId(msg, def.taskId);
+					if (!taskId) throw new Error("task-wait: taskId is required");
+					const agent = await agentNode.getAgent();
+					const startedAt = Date.now();
+					let afterSeq;
+					let polls = 0;
+					this.status({
+						fill: "blue",
+						shape: "dot",
+						text: "waiting…"
+					});
+					for (;;) {
+						if (def.tail) afterSeq = await drainMessages({
+							agent,
+							taskId,
+							afterSeq,
+							kindAllow,
+							emit: (m) => {
+								const tailMsg = RED.util.cloneMessage(msg);
+								tailMsg.payload = m;
+								tailMsg.taskId = taskId;
+								send([tailMsg, null]);
+							}
+						});
+						const task = await agent.tasks.get(taskId);
+						if (isTerminalTaskStatus(task.status)) {
+							const snapshot = buildTaskSnapshot(task, await agent.tasks.listAttempts(taskId));
+							const resultMsg = RED.util.cloneMessage(msg);
+							resultMsg.payload = snapshot;
+							this.status({
+								fill: snapshot.accepted ? "green" : "red",
+								shape: "dot",
+								text: `${snapshot.status}${snapshot.accepted ? " ✓" : ""}`
+							});
+							send([null, resultMsg]);
+							done();
+							return;
+						}
+						polls += 1;
+						if (timeoutMs > 0 && Date.now() - startedAt >= timeoutMs) throw new Error(`task-wait: timed out after ${Math.round((Date.now() - startedAt) / 1e3)}s (${polls} polls) waiting for task ${taskId} to settle`);
+						this.status({
+							fill: "blue",
+							shape: "ring",
+							text: `${task.status} · ${polls}×`
+						});
+						await sleep(pollMs, pending);
+					}
+				} catch (err) {
+					this.status({
+						fill: "red",
+						shape: "ring",
+						text: "error"
+					});
+					done(err instanceof Error ? err : new Error(String(err)));
+				}
+			};
+			run();
+		});
+	}
+	RED.nodes.registerType("moltnet-task-wait", TaskWaitNode);
+};
+/**
+* Fetch the latest attempt's new messages and emit the allowed ones. Returns
+* the advanced cursor. The cursor advances for EVERY message seen (even ones the
+* kind filter drops), otherwise a fully-filtered page would re-fetch forever.
+*/
+async function drainMessages(args) {
+	const { agent, taskId, kindAllow, emit } = args;
+	let afterSeq = args.afterSeq;
+	const attempts = await agent.tasks.listAttempts(taskId);
+	if (attempts.length === 0) return afterSeq;
+	const latest = attempts.reduce((max, a) => a.attemptN > max.attemptN ? a : max);
+	const limit = 100;
+	for (;;) {
+		const messages = await agent.tasks.listMessages(taskId, latest.attemptN, {
+			afterSeq,
+			limit
+		});
+		for (const m of messages) {
+			if (afterSeq === void 0 || m.seq > afterSeq) afterSeq = m.seq;
+			if (kindAllow && !kindAllow.has(m.kind)) continue;
+			emit(m);
+		}
+		if (messages.length < limit) break;
+	}
+	return afterSeq;
+}
+function parseKinds(raw) {
+	if (!raw || !raw.trim()) return null;
+	const kinds = raw.split(",").map((s) => s.trim()).filter(Boolean);
+	return kinds.length > 0 ? new Set(kinds) : null;
+}
+function resolveTaskId(msg, configured) {
+	if (typeof msg.taskId === "string" && msg.taskId) return msg.taskId;
+	const payload = msg.payload;
+	if (payload && typeof payload === "object") {
+		const p = payload;
+		if (typeof p.taskId === "string" && p.taskId) return p.taskId;
+		if (typeof p.id === "string" && p.id) return p.id;
+	}
+	return configured && configured.length > 0 ? configured : void 0;
+}
+function sleep(ms, pending) {
+	return new Promise((resolve) => {
+		const t = setTimeout(() => {
+			pending.delete(t);
+			resolve();
+		}, ms);
+		pending.add(t);
+	});
+}
+//#endregion
+export { init as default };

package/dist/nodes/tasks-create.html

@@ -0,0 +1,122 @@
+<script type="text/javascript">
+  RED.nodes.registerType('moltnet-tasks-create', {
+    category: 'moltnet',
+    color: '#00d4c8',
+    paletteLabel: 'tasks: create',
+    defaults: {
+      name: { value: '' },
+      agent: { value: '', type: 'moltnet-agent', required: true },
+      runtimeProfile: {
+        value: '',
+        type: 'moltnet-runtime-profile',
+        // Optional: a config-typed field is implicitly required unless we
+        // explicitly allow the empty value.
+        required: false,
+        validate: function (v) {
+          return !v || v === '_ADD_' || typeof v === 'string';
+        },
+      },
+      maxAttempts: { value: null, validate: RED.validators.number(true) },
+      generateCorrelationId: { value: false },
+    },
+    inputs: 1,
+    outputs: 1,
+    icon: 'font-awesome/fa-plus-square',
+    label: function () {
+      return this.name || 'tasks: create';
+    },
+  });
+</script>
+
+<script type="text/html" data-template-name="moltnet-tasks-create">
+  <div class="form-row">
+    <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+    <input type="text" id="node-input-name" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-agent"><i class="fa fa-user"></i> Agent</label>
+    <input type="text" id="node-input-agent" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-runtimeProfile"
+      ><i class="fa fa-microchip"></i> Profile</label
+    >
+    <input type="text" id="node-input-runtimeProfile" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-maxAttempts"
+      ><i class="fa fa-repeat"></i> Max attempts</label
+    >
+    <input type="text" id="node-input-maxAttempts" placeholder="(optional)" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-generateCorrelationId"
+      ><i class="fa fa-link"></i> Correlation</label
+    >
+    <input
+      type="checkbox"
+      id="node-input-generateCorrelationId"
+      style="display: inline-block; width: auto; vertical-align: top"
+    />
+    <span>Mint a new correlationId if the message has none</span>
+  </div>
+</script>
+
+<script type="text/html" data-help-name="moltnet-tasks-create">
+  <p>
+    Creates a MoltNet task as the referenced <b>agent</b>. The created task is
+    returned on <code>msg.payload</code>.
+  </p>
+  <h3>Building the request</h3>
+  <p>
+    The task body — <b>task type</b>, <b>title</b>, <b>tags</b>,
+    <code>input</code>, <code>references</code>, gates — is composed upstream by
+    a <code>task: build</code> node and arrives on <code>msg.payload</code>.
+    This node submits it and fills only the dispatch-level gaps:
+  </p>
+  <ul>
+    <li>
+      <b>Profile</b> — a <code>moltnet-runtime-profile</code> config node sets
+      <code>allowedProfiles</code> (a routing gate pairing the task with the
+      daemon that claims it). Set here, not in the builder.
+      <code>msg.payload.allowedProfiles</code> overrides it.
+    </li>
+    <li><b>Max attempts</b> — per-task retry budget.</li>
+    <li>
+      <b>Correlation</b> — mint/thread a <code>correlationId</code> (below).
+    </li>
+  </ul>
+  <p>
+    If <code>msg.payload</code> carries no <code>taskType</code>, it defaults to
+    <code>freeform</code>. For ad-hoc flows you can still set the whole body on
+    <code>msg.payload</code> with a <code>function</code>/<code>change</code>
+    node instead of <code>task: build</code>; the <code>input</code> shape per
+    task type comes from <code>GET /tasks/schemas</code> and the
+    <a href="https://api.themolt.net/openapi.json" target="_blank"
+      >OpenAPI spec</a
+    >
+    (<code>CreateTask</code>).
+  </p>
+  <p>
+    <code>teamId</code>, <code>diaryId</code> and <code>correlationId</code> are
+    filled automatically (see below) — you rarely set them by hand.
+  </p>
+  <h3>Team &amp; diary context</h3>
+  <p>
+    <code>teamId</code> and <code>diaryId</code> come from the
+    <b>agent</b> config node, not this node — the agent establishes which team
+    and diary you act in. A <code>msg.payload.teamId</code> /
+    <code>msg.payload.diaryId</code> overrides the agent default.
+  </p>
+  <h3>correlationId (workflow runs)</h3>
+  <p>
+    A <code>correlationId</code> threads a workflow run across tasks (mandatory
+    for a workflow). It is resolved from
+    <code>msg.payload.correlationId</code> then <code>msg.correlationId</code>.
+    Enable <b>Correlation</b> on the first <code>tasks: create</code> of a run
+    to mint a fresh id when the message has none. The resolved id is written
+    back to <code>msg.correlationId</code>, so downstream
+    <code>task: wait</code> / <code>tasks: create</code> /
+    <code>workflow: status</code> nodes inherit the same run.
+  </p>
+</script>

package/dist/nodes/tasks-create.js

@@ -0,0 +1,64 @@
+import { randomUUID } from "node:crypto";
+//#region src/nodes/tasks-create.ts
+var init = (RED) => {
+	function TasksCreateNode(def) {
+		RED.nodes.createNode(this, def);
+		const agentNode = def.agent ? RED.nodes.getNode(def.agent) : null;
+		const profileNode = def.runtimeProfile ? RED.nodes.getNode(def.runtimeProfile) : null;
+		this.on("input", (msg, send, done) => {
+			const run = async () => {
+				try {
+					if (!agentNode || typeof agentNode.getAgent !== "function") throw new Error("tasks-create: no moltnet-agent configured");
+					this.status({
+						fill: "blue",
+						shape: "dot",
+						text: "creating…"
+					});
+					const agent = await agentNode.getAgent();
+					const base = msg.payload && typeof msg.payload === "object" ? { ...msg.payload } : {};
+					if (!base.taskType) base.taskType = "freeform";
+					if (!base.allowedProfiles && profileNode?.profileId) base.allowedProfiles = [{ profileId: profileNode.profileId }];
+					if (base.maxAttempts === void 0 && typeof def.maxAttempts === "number") base.maxAttempts = def.maxAttempts;
+					if (!base.teamId && agentNode.teamId) base.teamId = agentNode.teamId;
+					if (!base.diaryId && agentNode.diaryId) base.diaryId = agentNode.diaryId;
+					const correlationId = resolveCorrelationId(msg, base.correlationId, def.generateCorrelationId === true);
+					if (correlationId) base.correlationId = correlationId;
+					const { teamId, ...createBody } = base;
+					const task = await agent.tasks.create(createBody, { teamId });
+					const out = RED.util.cloneMessage(msg);
+					if (correlationId) out.correlationId = correlationId;
+					out.payload = task;
+					this.status({
+						fill: "green",
+						shape: "dot",
+						text: `task ${task.id ?? "created"}`
+					});
+					send(out);
+					done();
+				} catch (err) {
+					this.status({
+						fill: "red",
+						shape: "ring",
+						text: "error"
+					});
+					done(err instanceof Error ? err : new Error(String(err)));
+				}
+			};
+			run();
+		});
+	}
+	RED.nodes.registerType("moltnet-tasks-create", TasksCreateNode);
+};
+/**
+* Resolve the workflow correlationId in priority order: explicit payload value,
+* then `msg.correlationId`, then mint a fresh UUID when generation is enabled.
+* Returns `undefined` when none is available and generation is off (the task is
+* then created without one — valid for ad-hoc, non-workflow tasks).
+*/
+function resolveCorrelationId(msg, fromPayload, generate) {
+	if (typeof fromPayload === "string" && fromPayload) return fromPayload;
+	if (typeof msg.correlationId === "string" && msg.correlationId) return msg.correlationId;
+	return generate ? randomUUID() : void 0;
+}
+//#endregion
+export { init as default };

package/dist/nodes/workflow-status.html

@@ -0,0 +1,55 @@
+<script type="text/javascript">
+  RED.nodes.registerType('moltnet-workflow-status', {
+    category: 'moltnet',
+    color: '#00d4c8',
+    paletteLabel: 'workflow: status',
+    defaults: {
+      name: { value: '' },
+      agent: { value: '', type: 'moltnet-agent', required: true },
+      correlationId: { value: '' },
+      limit: { value: 50, validate: RED.validators.number() },
+    },
+    inputs: 1,
+    outputs: 1,
+    icon: 'font-awesome/fa-list',
+    label: function () {
+      return this.name || 'workflow: status';
+    },
+  });
+</script>
+
+<script type="text/html" data-template-name="moltnet-workflow-status">
+  <div class="form-row">
+    <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+    <input type="text" id="node-input-name" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-agent"><i class="fa fa-user"></i> Agent</label>
+    <input type="text" id="node-input-agent" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-correlationId"
+      ><i class="fa fa-link"></i> Correlation ID</label
+    >
+    <input
+      type="text"
+      id="node-input-correlationId"
+      placeholder="msg.correlationId overrides"
+    />
+  </div>
+  <div class="form-row">
+    <label for="node-input-limit"><i class="fa fa-hashtag"></i> Limit</label>
+    <input type="number" id="node-input-limit" />
+  </div>
+</script>
+
+<script type="text/html" data-help-name="moltnet-workflow-status">
+  <p>
+    Reads the tasks of one workflow run (by <code>correlationId</code>) and
+    emits a table-shaped <code>msg.payload</code> (array of rows) for a stock
+    Dashboard 2.0 <code>ui-table</code>. The correlation id comes from
+    <code>msg.correlationId</code>, <code>msg.payload.correlationId</code>, or
+    the node config, in that order. <code>msg.workflow</code> carries
+    <code>{ correlationId, total }</code>.
+  </p>
+</script>