@themoltnet/node-red-contrib-core 0.4.0 → 0.7.0

package/dist/nodes/task-artifact-utils.js

@@ -0,0 +1,149 @@
+import { a as nonEmpty, c as positiveInt } from "./query-utils.js";
+import { Readable } from "node:stream";
+import { Buffer } from "node:buffer";
+function payloadRecord(msg) {
+	if (!msg.payload || typeof msg.payload !== "object") return {};
+	if (Buffer.isBuffer(msg.payload)) return {};
+	return msg.payload;
+}
+function resolveTaskId(msg, configured) {
+	if (typeof msg.taskId === "string" && msg.taskId) return msg.taskId;
+	const payload = payloadRecord(msg);
+	return nonEmpty(payload.taskId) ?? nonEmpty(payload.id) ?? nonEmpty(recordField(payload.task, "id")) ?? nonEmpty(configured);
+}
+function resolveTeamId(msg, configured, agentNode, allowMsgTeamOverride) {
+	if (!allowMsgTeamOverride) return nonEmpty(configured) ?? agentNode.teamId;
+	if (typeof msg.teamId === "string" && msg.teamId) return msg.teamId;
+	return nonEmpty(payloadRecord(msg).teamId) ?? nonEmpty(configured) ?? agentNode.teamId;
+}
+function resolveAttemptN(msg, configured) {
+	const payload = payloadRecord(msg);
+	return positiveInt(msg.attemptN) ?? positiveInt(payload.attemptN) ?? positiveInt(recordField(payload.attempt, "attemptN")) ?? positiveInt(recordField(payload.artifact, "attemptN")) ?? positiveInt(configured);
+}
+function requireArtifactContext(nodeName, msg, configuredTaskId, configuredTeamId, agentNode, allowMsgTeamOverride) {
+	const taskId = resolveTaskId(msg, configuredTaskId);
+	if (!taskId) throw new Error(`${nodeName}: taskId is required`);
+	const teamId = resolveTeamId(msg, configuredTeamId, agentNode, allowMsgTeamOverride);
+	if (!teamId) throw new Error(`${nodeName}: teamId is required`);
+	return {
+		taskId,
+		teamId
+	};
+}
+function requireAttemptContext(nodeName, msg, configuredTaskId, configuredTeamId, configuredAttemptN, agentNode, allowMsgTeamOverride) {
+	const context = requireArtifactContext(nodeName, msg, configuredTaskId, configuredTeamId, agentNode, allowMsgTeamOverride);
+	const attemptN = resolveAttemptN(msg, configuredAttemptN);
+	if (!attemptN) throw new Error(`${nodeName}: attemptN is required`);
+	return {
+		...context,
+		attemptN
+	};
+}
+function resolveField(msg, name, configured) {
+	return nonEmpty(payloadRecord(msg)[name]) ?? nonEmpty(configured);
+}
+function resolveMaxBytes(configured) {
+	return positiveInt(configured) ?? 26214400;
+}
+function resolveUploadBody(msg, maxBytes) {
+	const payload = msg.payload;
+	if (Buffer.isBuffer(payload)) return enforceMaxBytes(payload, maxBytes);
+	if (payload instanceof Uint8Array) return enforceMaxBytes(payload, maxBytes);
+	if (payload instanceof ArrayBuffer) {
+		if (payload.byteLength > maxBytes) throw tooLarge("upload", maxBytes);
+		return new Uint8Array(payload);
+	}
+	if (typeof payload === "string") {
+		if (Buffer.byteLength(payload) > maxBytes) throw tooLarge("upload", maxBytes);
+		return new TextEncoder().encode(payload);
+	}
+	const record = payloadRecord(msg);
+	if (typeof record.contentBase64 === "string") {
+		const normalized = record.contentBase64.replace(/\s/g, "");
+		if (decodedBase64Length(normalized) > maxBytes) throw tooLarge("upload", maxBytes);
+		return Buffer.from(normalized, "base64");
+	}
+	const content = record.content ?? record.body;
+	if (Buffer.isBuffer(content)) return enforceMaxBytes(content, maxBytes);
+	if (content instanceof Uint8Array) return enforceMaxBytes(content, maxBytes);
+	if (content instanceof ArrayBuffer) {
+		if (content.byteLength > maxBytes) throw tooLarge("upload", maxBytes);
+		return new Uint8Array(content);
+	}
+	if (typeof content === "string") {
+		if (Buffer.byteLength(content) > maxBytes) throw tooLarge("upload", maxBytes);
+		return new TextEncoder().encode(content);
+	}
+	throw new Error("task-artifact-upload: payload content is required");
+}
+async function collectArtifactBody(value, maxBytes) {
+	const source = value && typeof value === "object" && "stream" in value ? value.stream : value;
+	if (Buffer.isBuffer(source)) {
+		if (source.byteLength > maxBytes) throw tooLarge("download", maxBytes);
+		return source;
+	}
+	if (source instanceof Uint8Array) {
+		if (source.byteLength > maxBytes) throw tooLarge("download", maxBytes);
+		return Buffer.from(source);
+	}
+	if (source instanceof ArrayBuffer) {
+		if (source.byteLength > maxBytes) throw tooLarge("download", maxBytes);
+		return Buffer.from(source);
+	}
+	if (typeof source === "string") {
+		if (Buffer.byteLength(source) > maxBytes) throw tooLarge("download", maxBytes);
+		return Buffer.from(source);
+	}
+	if (source instanceof Readable) {
+		const chunks = [];
+		let bytes = 0;
+		for await (const chunk of source) bytes = pushChunk(chunks, chunk, bytes, maxBytes);
+		return Buffer.concat(chunks);
+	}
+	if (source && typeof source === "object" && Symbol.asyncIterator in source) {
+		const chunks = [];
+		let bytes = 0;
+		for await (const chunk of source) bytes = pushChunk(chunks, chunk, bytes, maxBytes);
+		return Buffer.concat(chunks);
+	}
+	if (source && typeof source === "object" && "arrayBuffer" in source) {
+		const size = source.size;
+		if (typeof size === "number" && size > maxBytes) throw tooLarge("download", maxBytes);
+		const arrayBuffer = await source.arrayBuffer();
+		if (arrayBuffer.byteLength > maxBytes) throw tooLarge("download", maxBytes);
+		return Buffer.from(arrayBuffer);
+	}
+	throw new Error("task-artifact-download: unsupported artifact body");
+}
+function toBuffer(value) {
+	if (Buffer.isBuffer(value)) return value;
+	if (value instanceof Uint8Array) return Buffer.from(value);
+	if (value instanceof ArrayBuffer) return Buffer.from(value);
+	if (typeof value === "string") return Buffer.from(value);
+	return Buffer.from(String(value));
+}
+function recordField(value, key) {
+	if (!value || typeof value !== "object") return void 0;
+	return value[key];
+}
+function enforceMaxBytes(value, maxBytes) {
+	if (value.byteLength > maxBytes) throw tooLarge("upload", maxBytes);
+	return value;
+}
+function pushChunk(chunks, chunk, bytes, maxBytes) {
+	const next = toBuffer(chunk);
+	const total = bytes + next.byteLength;
+	if (total > maxBytes) throw tooLarge("download", maxBytes);
+	chunks.push(next);
+	return total;
+}
+function decodedBase64Length(value) {
+	if (!value) return 0;
+	const padding = value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0;
+	return Math.floor(value.length * 3 / 4) - padding;
+}
+function tooLarge(operation, maxBytes) {
+	return /* @__PURE__ */ new Error(`task-artifact-${operation}: artifact body exceeds ${maxBytes} bytes`);
+}
+//#endregion
+export { requireAttemptContext as a, resolveUploadBody as c, requireArtifactContext as i, payloadRecord as n, resolveField as o, recordField as r, resolveMaxBytes as s, collectArtifactBody as t };

package/dist/nodes/task-artifacts-list.html

@@ -0,0 +1,78 @@
+<script type="text/javascript">
+  RED.nodes.registerType('moltnet-task-artifacts-list', {
+    category: 'moltnet',
+    color: '#00d4c8',
+    paletteLabel: 'task artifacts: list',
+    defaults: {
+      name: { value: '' },
+      agent: { value: '', type: 'moltnet-agent', required: true },
+      taskId: { value: '' },
+      teamId: { value: '' },
+      allowMsgTeamOverride: { value: false },
+      limit: { value: 20, validate: RED.validators.number() },
+      cursor: { value: '' },
+    },
+    inputs: 1,
+    outputs: 1,
+    icon: 'font-awesome/fa-list',
+    label: function () {
+      return this.name || 'task artifacts: list';
+    },
+  });
+</script>
+
+<script type="text/html" data-template-name="moltnet-task-artifacts-list">
+  <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-teamId"><i class="fa fa-users"></i> Team ID</label>
+    <input type="text" id="node-input-teamId" placeholder="agent teamId" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-allowMsgTeamOverride"
+      ><i class="fa fa-random"></i> Team override</label
+    >
+    <input
+      type="checkbox"
+      id="node-input-allowMsgTeamOverride"
+      style="display: inline-block; width: auto; vertical-align: top"
+    />
+    <span>Allow <code>msg.teamId</code></span>
+  </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>
+  <div class="form-row">
+    <label for="node-input-cursor"><i class="fa fa-forward"></i> Cursor</label>
+    <input type="text" id="node-input-cursor" />
+  </div>
+</script>
+
+<script type="text/html" data-help-name="moltnet-task-artifacts-list">
+  <p>
+    Lists artifacts for a MoltNet task. The task id is taken from
+    <code>msg.taskId</code>, <code>msg.payload.taskId</code>,
+    <code>msg.payload.id</code>, or the configured Task ID. Team ID is taken
+    from this node or the configured agent. Enable Team override to allow
+    <code>msg.teamId</code> or <code>msg.payload.teamId</code>.
+  </p>
+  <p>
+    Emits artifact rows on <code>msg.payload</code>. Pagination metadata, the
+    final query, and the full page are on <code>msg.artifacts</code>.
+  </p>
+</script>

package/dist/nodes/task-artifacts-list.js

@@ -0,0 +1,61 @@
+import { t as withAgent } from "./agent-call.js";
+import { a as nonEmpty, c as positiveInt, n as compact, t as bool } from "./query-utils.js";
+import { i as requireArtifactContext, n as payloadRecord } from "./task-artifact-utils.js";
+//#region src/nodes/task-artifacts-list.ts
+var init = (RED) => {
+	function TaskArtifactsListNode(def) {
+		RED.nodes.createNode(this, def);
+		const agentNode = def.agent ? RED.nodes.getNode(def.agent) : null;
+		this.on("input", (msg, send, done) => {
+			const run = async () => {
+				try {
+					if (!agentNode || typeof agentNode.getAgent !== "function") throw new Error("task-artifacts-list: no moltnet-agent configured");
+					const { taskId, teamId } = requireArtifactContext("task-artifacts-list", msg, def.taskId, def.teamId, agentNode, bool(def.allowMsgTeamOverride) ?? false);
+					this.status({
+						fill: "blue",
+						shape: "dot",
+						text: "loading…"
+					});
+					const query = buildQuery(def, msg);
+					const page = await withAgent(agentNode, (agent) => agent.tasks.artifacts.listPage(taskId, query, { teamId }));
+					const out = RED.util.cloneMessage(msg);
+					out.payload = page.artifacts;
+					out.taskId = taskId;
+					out.artifacts = {
+						taskId,
+						teamId,
+						query,
+						count: page.artifacts.length,
+						nextCursor: page.nextCursor,
+						page
+					};
+					this.status({
+						fill: "green",
+						shape: "dot",
+						text: `${page.artifacts.length} artifact(s)`
+					});
+					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-task-artifacts-list", TaskArtifactsListNode);
+};
+function buildQuery(def, msg) {
+	const payload = payloadRecord(msg);
+	return compact({
+		limit: positiveInt(payload.limit) ?? positiveInt(def.limit),
+		cursor: nonEmpty(payload.cursor) ?? nonEmpty(def.cursor)
+	});
+}
+//#endregion
+export { init as default };

package/dist/nodes/task-get.js

@@ -1,3 +1,4 @@
+import { t as withAgent } from "./agent-call.js";
 import { t as buildTaskSnapshot } from "./task-snapshot.js";
 //#region src/nodes/task-get.ts
 var init = (RED) => {
@@ -15,8 +16,7 @@ var init = (RED) => {
 						shape: "dot",
 						text: "loading…"
 					});
-					const agent = await agentNode.getAgent();
-					const [task, attempts] = await Promise.all([agent.tasks.get(taskId), agent.tasks.listAttempts(taskId)]);
+					const [task, attempts] = await withAgent(agentNode, (agent) => Promise.all([agent.tasks.get(taskId), agent.tasks.listAttempts(taskId)]));
 					const snapshot = buildTaskSnapshot(task, attempts);
 					const out = RED.util.cloneMessage(msg);
 					out.payload = snapshot;

package/dist/nodes/task-wait.js

@@ -1,3 +1,4 @@
+import { t as withAgent } from "./agent-call.js";
 import { n as isTerminalTaskStatus, t as buildTaskSnapshot } from "./task-snapshot.js";
 //#region src/nodes/task-wait.ts
 var DEFAULT_POLL_SEC = 5;
@@ -9,48 +10,63 @@ var init = (RED) => {
 		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 active = /* @__PURE__ */ new Map();
 		const pending = /* @__PURE__ */ new Set();
 		this.on("close", () => {
 			for (const t of pending) clearTimeout(t);
 			pending.clear();
 		});
 		this.on("input", (msg, send, done) => {
+			let taskIdForStatus;
+			let label = describeMessage(msg);
 			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();
+					taskIdForStatus = taskId;
+					label = describeWait(taskId, msg, label);
+					active.set(taskId, label);
+					const correlationId = resolveCorrelationId(msg);
 					const startedAt = Date.now();
 					let afterSeq;
 					let polls = 0;
 					this.status({
 						fill: "blue",
 						shape: "dot",
-						text: "waiting…"
+						text: statusText("waiting", label, active.size)
 					});
 					for (;;) {
-						if (def.tail) afterSeq = await drainMessages({
+						if (def.tail) afterSeq = await withAgent(agentNode, (agent) => drainMessages({
 							agent,
 							taskId,
 							afterSeq,
 							kindAllow,
 							emit: (m) => {
 								const tailMsg = RED.util.cloneMessage(msg);
-								tailMsg.payload = m;
+								tailMsg.payload = correlationId ? {
+									...m,
+									correlationId
+								} : m;
 								tailMsg.taskId = taskId;
+								if (correlationId) tailMsg.correlationId = correlationId;
 								send([tailMsg, null]);
 							}
-						});
-						const task = await agent.tasks.get(taskId);
+						}));
+						const task = await withAgent(agentNode, (agent) => agent.tasks.get(taskId));
 						if (isTerminalTaskStatus(task.status)) {
-							const snapshot = buildTaskSnapshot(task, await agent.tasks.listAttempts(taskId));
+							const snapshot = buildTaskSnapshot(task, await withAgent(agentNode, (agent) => agent.tasks.listAttempts(taskId)));
 							const resultMsg = RED.util.cloneMessage(msg);
-							resultMsg.payload = snapshot;
+							resultMsg.payload = correlationId ? {
+								...snapshot,
+								correlationId
+							} : snapshot;
+							if (correlationId) resultMsg.correlationId = correlationId;
+							active.delete(taskId);
 							this.status({
 								fill: snapshot.accepted ? "green" : "red",
 								shape: "dot",
-								text: `${snapshot.status}${snapshot.accepted ? " ✓" : ""}`
+								text: statusText(`${snapshot.status}${snapshot.accepted ? " ok" : ""}`, label, active.size)
 							});
 							send([null, resultMsg]);
 							done();
@@ -61,15 +77,16 @@ var init = (RED) => {
 						this.status({
 							fill: "blue",
 							shape: "ring",
-							text: `${task.status} · ${polls}×`
+							text: statusText(`${task.status} ${polls}x`, label, active.size)
 						});
 						await sleep(pollMs, pending);
 					}
 				} catch (err) {
+					if (taskIdForStatus) active.delete(taskIdForStatus);
 					this.status({
 						fill: "red",
 						shape: "ring",
-						text: "error"
+						text: statusText("error", label, active.size)
 					});
 					done(err instanceof Error ? err : new Error(String(err)));
 				}
@@ -120,6 +137,43 @@ function resolveTaskId(msg, configured) {
 	}
 	return configured && configured.length > 0 ? configured : void 0;
 }
+function resolveCorrelationId(msg) {
+	if (typeof msg.correlationId === "string" && msg.correlationId) return msg.correlationId;
+	const payload = msg.payload;
+	if (payload && typeof payload === "object") {
+		const p = payload;
+		if (typeof p.correlationId === "string" && p.correlationId) return p.correlationId;
+	}
+}
+function describeMessage(msg) {
+	if (typeof msg.reviewDimension === "string" && msg.reviewDimension) return msg.reviewDimension;
+	const payload = msg.payload;
+	if (payload && typeof payload === "object") {
+		const p = payload;
+		if (typeof p.dimension === "string" && p.dimension) return p.dimension;
+		if (typeof p.title === "string" && p.title) return p.title;
+	}
+	return "task";
+}
+function describeWait(taskId, msg, fallback) {
+	if (fallback !== "task") return fallback;
+	const payload = msg.payload;
+	if (payload && typeof payload === "object") {
+		const p = payload;
+		if (typeof p.title === "string" && p.title) return p.title;
+	}
+	return shortId(taskId);
+}
+function statusText(action, label, activeCount) {
+	const suffix = activeCount > 0 ? ` · ${activeCount} active` : "";
+	return `${action} · ${truncate(label, 34)}${suffix}`;
+}
+function shortId(id) {
+	return id.slice(0, 8);
+}
+function truncate(value, max) {
+	return value.length <= max ? value : `${value.slice(0, max - 1)}…`;
+}
 function sleep(ms, pending) {
 	return new Promise((resolve) => {
 		const t = setTimeout(() => {

package/dist/nodes/tasks-create.js

@@ -1,3 +1,4 @@
+import { t as withAgent } from "./agent-call.js";
 import { randomUUID } from "node:crypto";
 //#region src/nodes/tasks-create.ts
 var init = (RED) => {
@@ -5,18 +6,24 @@ var init = (RED) => {
 		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;
+		const active = /* @__PURE__ */ new Map();
+		let nextInvocationId = 0;
 		this.on("input", (msg, send, done) => {
+			const invocationId = ++nextInvocationId;
+			let label = describeMessage(msg);
 			const run = async () => {
 				try {
 					if (!agentNode || typeof agentNode.getAgent !== "function") throw new Error("tasks-create: no moltnet-agent configured");
+					active.set(invocationId, label);
 					this.status({
 						fill: "blue",
 						shape: "dot",
-						text: "creating…"
+						text: statusText("creating", label, active.size)
 					});
-					const agent = await agentNode.getAgent();
 					const base = msg.payload && typeof msg.payload === "object" ? { ...msg.payload } : {};
 					if (!base.taskType) base.taskType = "freeform";
+					label = describeTaskBody(base, label);
+					active.set(invocationId, label);
 					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;
@@ -24,22 +31,24 @@ var init = (RED) => {
 					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 task = await withAgent(agentNode, (agent) => agent.tasks.create(createBody, { teamId }));
 					const out = RED.util.cloneMessage(msg);
 					if (correlationId) out.correlationId = correlationId;
 					out.payload = task;
+					active.delete(invocationId);
 					this.status({
 						fill: "green",
 						shape: "dot",
-						text: `task ${task.id ?? "created"}`
+						text: statusText(`created ${shortId(task.id)}`, label, active.size)
 					});
 					send(out);
 					done();
 				} catch (err) {
+					active.delete(invocationId);
 					this.status({
 						fill: "red",
 						shape: "ring",
-						text: "error"
+						text: statusText("error", label, active.size)
 					});
 					done(err instanceof Error ? err : new Error(String(err)));
 				}
@@ -60,5 +69,37 @@ function resolveCorrelationId(msg, fromPayload, generate) {
 	if (typeof msg.correlationId === "string" && msg.correlationId) return msg.correlationId;
 	return generate ? randomUUID() : void 0;
 }
+function describeMessage(msg) {
+	if (typeof msg.reviewDimension === "string" && msg.reviewDimension) return msg.reviewDimension;
+	const payload = msg.payload;
+	if (payload && typeof payload === "object") {
+		const p = payload;
+		if (typeof p.dimension === "string" && p.dimension) return p.dimension;
+		if (typeof p.title === "string" && p.title) return p.title;
+	}
+	return "task";
+}
+function describeTaskBody(body, fallback) {
+	if (fallback !== "task") return fallback;
+	const input = body.input;
+	if (input && typeof input === "object") {
+		const execution = input.execution;
+		if (execution && typeof execution === "object") {
+			const dimension = execution.dimension;
+			if (typeof dimension === "string" && dimension) return dimension;
+		}
+	}
+	return typeof body.title === "string" && body.title ? body.title : fallback;
+}
+function statusText(action, label, activeCount) {
+	const suffix = activeCount > 0 ? ` · ${activeCount} active` : "";
+	return `${action} · ${truncate(label, 34)}${suffix}`;
+}
+function shortId(id) {
+	return typeof id === "string" && id ? id.slice(0, 8) : "task";
+}
+function truncate(value, max) {
+	return value.length <= max ? value : `${value.slice(0, max - 1)}…`;
+}
 //#endregion
 export { init as default };

package/dist/nodes/tasks-list.js

@@ -1,3 +1,4 @@
+import { t as withAgent } from "./agent-call.js";
 import { a as nonEmpty, c as positiveInt, n as compact, r as csv, t as bool } from "./query-utils.js";
 //#region src/nodes/tasks-list.ts
 var init = (RED) => {
@@ -15,9 +16,8 @@ var init = (RED) => {
 						shape: "dot",
 						text: "loading…"
 					});
-					const agent = await agentNode.getAgent();
 					const query = buildTasksQuery(def, msg);
-					const result = await agent.tasks.list(query, { teamId });
+					const result = await withAgent(agentNode, (agent) => agent.tasks.list(query, { teamId }));
 					const out = RED.util.cloneMessage(msg);
 					out.payload = result.items;
 					out.tasks = {

package/dist/nodes/workflow-status.js

@@ -1,3 +1,4 @@
+import { t as withAgent } from "./agent-call.js";
 //#region src/nodes/workflow-status.ts
 var init = (RED) => {
 	function WorkflowStatusNode(def) {
@@ -17,12 +18,11 @@ var init = (RED) => {
 					});
 					const teamId = agentNode.teamId;
 					if (!teamId) throw new Error("workflow-status: agent teamId is required");
-					const agent = await agentNode.getAgent();
 					const query = {
 						correlationId,
 						limit: def.limit && def.limit > 0 ? def.limit : 50
 					};
-					const res = await agent.tasks.list(query, { teamId });
+					const res = await withAgent(agentNode, (agent) => agent.tasks.list(query, { teamId }));
 					const rows = res.items.map((t) => ({
 						taskId: t.id,
 						type: t.taskType,