@themoltnet/node-red-contrib-core 0.1.0

package/dist/nodes/runtime-profile.html

@@ -0,0 +1,156 @@
+<script type="text/javascript">
+  RED.nodes.registerType('moltnet-runtime-profile', {
+    category: 'config',
+    paletteLabel: 'runtime profile',
+    defaults: {
+      name: { value: '' },
+      agent: { value: '', type: 'moltnet-agent', required: true },
+      profileId: { value: '', required: true },
+      profileName: { value: '' },
+    },
+    label: function () {
+      return (
+        this.name || this.profileName || this.profileId || 'runtime profile'
+      );
+    },
+    oneditprepare: function () {
+      const select = $('#node-config-input-profile-select');
+      const manualRow = $('#node-config-row-profileId');
+      const hint = $('#node-config-profile-hint');
+      const profileIdInput = $('#node-config-input-profileId');
+      const profileNameInput = $('#node-config-input-profileName');
+      const current = this.profileId;
+
+      const showManual = (message) => {
+        hint.text(message);
+        manualRow.show();
+        select.hide();
+      };
+
+      const loadProfiles = () => {
+        const agentId = $('#node-config-input-agent').val();
+        if (!agentId) {
+          showManual('Select an agent, or enter a Profile ID manually.');
+          return;
+        }
+        select.empty().append($('<option>').val('').text('loading…')).show();
+        manualRow.hide();
+        hint.text('');
+        $.getJSON('moltnet-runtime-profiles/' + agentId)
+          .done((data) => {
+            const profiles = (data && data.profiles) || [];
+            if (!profiles.length) {
+              let prefix;
+              if (data && data.error === 'agent-not-deployed') {
+                prefix = 'Deploy the agent first to list profiles. ';
+              } else if (data && data.error) {
+                // Surface the real backend error instead of hiding it behind
+                // a generic "no profiles" message.
+                prefix = 'Could not list profiles: ' + data.error + '. ';
+              } else {
+                prefix = 'No profiles found for this team. ';
+              }
+              showManual(prefix + 'Enter a Profile ID manually.');
+              return;
+            }
+            select.empty();
+            select.append($('<option>').val('').text('— select a profile —'));
+            profiles.forEach((p) => {
+              select.append(
+                $('<option>')
+                  .val(p.id)
+                  .text(p.name + ' (' + p.provider + '/' + p.model + ')'),
+              );
+            });
+            if (current) select.val(current);
+            manualRow.hide();
+            select.show();
+          })
+          .fail(() => {
+            showManual(
+              'Could not reach the editor backend; enter a Profile ID manually.',
+            );
+          });
+      };
+
+      $('#node-config-input-agent').on('change', loadProfiles);
+      loadProfiles();
+
+      // Keep the hidden profileId in sync from the dropdown selection.
+      select.on('change', function () {
+        const id = $(this).val();
+        if (id) {
+          profileIdInput.val(id);
+          const label = $(this).find('option:selected').text();
+          profileNameInput.val(label);
+        }
+      });
+    },
+    oneditsave: function () {
+      // If the dropdown has a selection, it already wrote profileId; otherwise
+      // the manual input is the source of truth.
+      const sel = $('#node-config-input-profile-select').val();
+      if (sel) $('#node-config-input-profileId').val(sel);
+    },
+  });
+</script>
+
+<script type="text/html" data-template-name="moltnet-runtime-profile">
+  <div class="form-row">
+    <label for="node-config-input-name"><i class="fa fa-tag"></i> Name</label>
+    <input
+      type="text"
+      id="node-config-input-name"
+      placeholder="e.g. fast-classify"
+    />
+  </div>
+  <div class="form-row">
+    <label for="node-config-input-agent"
+      ><i class="fa fa-user"></i> Agent</label
+    >
+    <input type="text" id="node-config-input-agent" />
+  </div>
+  <div class="form-row">
+    <label for="node-config-input-profile-select"
+      ><i class="fa fa-microchip"></i> Profile</label
+    >
+    <select id="node-config-input-profile-select" style="width: 70%"></select>
+  </div>
+  <div
+    class="form-tips"
+    id="node-config-profile-hint"
+    style="margin-bottom: 8px"
+  ></div>
+  <div class="form-row" id="node-config-row-profileId">
+    <label for="node-config-input-profileId"
+      ><i class="fa fa-hashtag"></i> Profile ID</label
+    >
+    <input
+      type="text"
+      id="node-config-input-profileId"
+      placeholder="profile UUID"
+    />
+  </div>
+  <input type="hidden" id="node-config-input-profileName" />
+</script>
+
+<script type="text/html" data-help-name="moltnet-runtime-profile">
+  <p>
+    Names one MoltNet <b>runtime profile</b> by its <code>profileId</code>.
+    <code>tasks: create</code> references this config to set the task's
+    <code>allowedProfiles</code>, routing the task to a daemon serving that
+    profile.
+  </p>
+  <p>
+    <b>Routing gate, not a model selector.</b> A daemon runs exactly one profile
+    (<code>--profile &lt;id&gt;</code>) and only claims tasks whose
+    <code>allowedProfiles</code> include it (an empty list = unrestricted).
+    Selecting a profile here does not run a different model by itself — a daemon
+    serving that profile must be running.
+  </p>
+  <p>
+    The <b>Profile</b> dropdown lists the team's profiles via the selected
+    <b>Agent</b>. The agent config node must be <b>deployed</b> first; otherwise
+    enter the <b>Profile ID</b> manually.
+  </p>
+</script>

package/dist/nodes/runtime-profile.js

@@ -0,0 +1,40 @@
+//#region src/nodes/runtime-profile.ts
+var init = (RED) => {
+	function MoltnetRuntimeProfileNode(def) {
+		RED.nodes.createNode(this, def);
+		this.agent = def.agent || void 0;
+		this.profileId = def.profileId?.trim() || void 0;
+		this.profileName = def.profileName?.trim() || void 0;
+	}
+	RED.nodes.registerType("moltnet-runtime-profile", MoltnetRuntimeProfileNode);
+	RED.httpAdmin?.get("/moltnet-runtime-profiles/:agentId", RED.auth.needsPermission("moltnet-runtime-profile.read"), (req, res) => {
+		const run = async () => {
+			try {
+				const agentId = String(req.params.agentId);
+				const agentNode = RED.nodes.getNode(agentId);
+				if (!agentNode || typeof agentNode.getAgent !== "function") {
+					res.json({
+						profiles: [],
+						error: "agent-not-deployed"
+					});
+					return;
+				}
+				const { items } = await (await agentNode.getAgent()).runtimeProfiles.list(agentNode.teamId ? { teamId: agentNode.teamId } : void 0);
+				res.json({ profiles: items.map((p) => ({
+					id: p.id,
+					name: p.name,
+					model: p.model,
+					provider: p.provider
+				})) });
+			} catch (err) {
+				res.json({
+					profiles: [],
+					error: err instanceof Error ? err.message : String(err)
+				});
+			}
+		};
+		run();
+	});
+};
+//#endregion
+export { init as default };

package/dist/nodes/task-builder.html

@@ -0,0 +1,175 @@
+<script type="text/javascript">
+  RED.nodes.registerType('moltnet-task-builder', {
+    category: 'moltnet',
+    color: '#00d4c8',
+    paletteLabel: 'task: build',
+    defaults: {
+      name: { value: '' },
+      agent: { value: '', type: 'moltnet-agent', required: true },
+      taskType: { value: 'freeform' },
+      brief: { value: '' },
+      title: { value: '' },
+      tags: { value: '' },
+      teamId: { value: '' },
+      teamIdType: { value: 'str' },
+      diaryId: { value: '' },
+      diaryIdType: { value: 'str' },
+      contexts: { value: [] },
+      referencesFrom: { value: '' },
+      referencesRole: { value: 'context' },
+      submitOutputGate: { value: true },
+      schemaCid: { value: '' },
+      workspace: { value: '' },
+      constraints: { value: [] },
+      expectedOutput: { value: '' },
+    },
+    inputs: 1,
+    outputs: 1,
+    icon: 'font-awesome/fa-wrench',
+    label: function () {
+      return this.name || 'task: build';
+    },
+    oneditprepare: function () {
+      // Team/diary overrides: typedInput (literal or msg/flow/global path).
+      // Blank ⇒ inherit the agent's context.
+      $('#node-input-teamId').typedInput({
+        default: 'str',
+        typeField: '#node-input-teamIdType',
+        types: ['str', 'msg', 'flow', 'global'],
+      });
+      $('#node-input-diaryId').typedInput({
+        default: 'str',
+        typeField: '#node-input-diaryIdType',
+        types: ['str', 'msg', 'flow', 'global'],
+      });
+    },
+  });
+</script>
+
+<script type="text/html" data-template-name="moltnet-task-builder">
+  <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-taskType"
+      ><i class="fa fa-cube"></i> Task type</label
+    >
+    <select id="node-input-taskType">
+      <option value="freeform">freeform</option>
+    </select>
+  </div>
+  <div class="form-row">
+    <label for="node-input-brief"><i class="fa fa-file-text"></i> Brief</label>
+    <input
+      type="text"
+      id="node-input-brief"
+      placeholder="msg.payload.input.brief"
+    />
+  </div>
+  <div class="form-row">
+    <label for="node-input-title"><i class="fa fa-header"></i> Title</label>
+    <input type="text" id="node-input-title" placeholder="(optional)" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-tags"><i class="fa fa-tags"></i> Tags</label>
+    <input
+      type="text"
+      id="node-input-tags"
+      placeholder="comma-separated, e.g. triage,issue-1"
+    />
+  </div>
+  <div class="form-row">
+    <label for="node-input-teamId"
+      ><i class="fa fa-users"></i> Team (override)</label
+    >
+    <input type="text" id="node-input-teamId" style="width:70%" />
+    <input type="hidden" id="node-input-teamIdType" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-diaryId"
+      ><i class="fa fa-book"></i> Diary (override)</label
+    >
+    <input type="text" id="node-input-diaryId" style="width:70%" />
+    <input type="hidden" id="node-input-diaryIdType" />
+  </div>
+  <div class="form-row node-builder-group" id="group-references">
+    <label for="node-input-referencesFrom"
+      ><i class="fa fa-link"></i> References from</label
+    >
+    <input
+      type="text"
+      id="node-input-referencesFrom"
+      placeholder="result.outputRef"
+    />
+  </div>
+  <div class="form-row">
+    <label for="node-input-referencesRole">Role</label>
+    <select id="node-input-referencesRole">
+      <option value="context">context</option>
+      <option value="judged_work">judged_work</option>
+      <option value="reviewed_diff">reviewed_diff</option>
+      <option value="target_source">target_source</option>
+    </select>
+  </div>
+  <div class="form-row">
+    <label for="node-input-submitOutputGate">Submit gate</label>
+    <input
+      type="checkbox"
+      id="node-input-submitOutputGate"
+      style="width:auto"
+    />
+  </div>
+  <div class="form-row">
+    <label for="node-input-workspace"
+      ><i class="fa fa-folder"></i> Workspace</label
+    >
+    <select id="node-input-workspace">
+      <option value="">(default)</option>
+      <option value="none">none</option>
+      <option value="shared_mount">shared_mount</option>
+      <option value="dedicated_worktree">dedicated_worktree</option>
+    </select>
+  </div>
+  <div class="form-row">
+    <label for="node-input-expectedOutput">Expected output</label>
+    <input type="text" id="node-input-expectedOutput" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-schemaCid">Schema CID</label>
+    <input type="text" id="node-input-schemaCid" />
+  </div>
+</script>
+
+<script type="text/html" data-help-name="moltnet-task-builder">
+  <p>
+    Composes a validated MoltNet <code>tasks.create</code> body from config +
+    the incoming message, using the SDK fluent builder. The built body —
+    <b>task type</b>, <b>title</b>, <b>tags</b>, <code>input</code>,
+    <code>references</code>, gates — is set on <code>msg.payload</code> for a
+    downstream <code>tasks: create</code>. Validation errors show on the node
+    (red ring) with the offending field.
+  </p>
+  <p>
+    <b>Title</b> and <b>Tags</b> (comma-separated → <code>string[]</code>) are
+    optional; <code>msg.payload.title</code> /
+    <code>msg.payload.tags</code> override the node values.
+    <b>Task type</b> defaults to <code>freeform</code>.
+  </p>
+  <p>
+    <b>Team / Diary (override)</b> default to the referenced <b>agent</b>'s
+    context. Set either field (literal, or a
+    <code>msg</code>/<code>flow</code>/<code>global</code> path) only to
+    <i>override</i> the agent for this task; leave blank to inherit.
+  </p>
+  <p>
+    <b>Context</b> rows map a slug to a value source (msg/flow/global/str/json);
+    objects are JSON-stringified. <b>References from</b> reads an
+    <code>outputRef</code> emitted by <code>task: read</code> to chain tasks
+    (the <code>outputCid</code> is pulled automatically).
+  </p>
+</script>

package/dist/nodes/task-builder.js

@@ -0,0 +1,110 @@
+import { TaskBuildError, buildTask } from "@themoltnet/sdk";
+//#region src/nodes/task-builder.ts
+/** Split a comma-separated config string into trimmed, non-empty values. */
+function parseCsv(raw) {
+	if (!raw) return [];
+	return raw.split(",").map((s) => s.trim()).filter(Boolean);
+}
+/** Resolve a context mapping's raw value from the message / context stores / literal. */
+function resolveValue(RED, node, msg, m) {
+	switch (m.valueType) {
+		case "msg": return RED.util.getMessageProperty(msg, m.value);
+		case "flow": return node.context().flow.get(m.value);
+		case "global": return node.context().global.get(m.value);
+		case "json": try {
+			return JSON.parse(m.value);
+		} catch {
+			return m.value;
+		}
+		default: return m.value;
+	}
+}
+/**
+* Resolve a typedInput override (literal or msg/flow/global path). Returns
+* `undefined` when the value field is blank so the caller can fall back to the
+* agent default.
+*/
+function resolveOverride(RED, node, msg, value, type) {
+	if (!value) return void 0;
+	switch (type) {
+		case "msg": {
+			const v = RED.util.getMessageProperty(msg, value);
+			return typeof v === "string" && v ? v : void 0;
+		}
+		case "flow": {
+			const v = node.context().flow.get(value);
+			return typeof v === "string" && v ? v : void 0;
+		}
+		case "global": {
+			const v = node.context().global.get(value);
+			return typeof v === "string" && v ? v : void 0;
+		}
+		default: return value;
+	}
+}
+var init = (RED) => {
+	function TaskBuilderNode(def) {
+		RED.nodes.createNode(this, def);
+		const agentNode = def.agent ? RED.nodes.getNode(def.agent) : null;
+		this.on("input", (msg, send, done) => {
+			try {
+				const payloadInput = msg.payload && typeof msg.payload === "object" ? msg.payload : {};
+				const brief = typeof payloadInput.input?.brief === "string" ? payloadInput.input.brief : def.brief ?? "";
+				const builder = buildTask(def.taskType?.trim() || "freeform", { brief });
+				const teamId = resolveOverride(RED, this, msg, def.teamId, def.teamIdType) ?? payloadInput.teamId ?? agentNode?.teamId;
+				const diaryId = resolveOverride(RED, this, msg, def.diaryId, def.diaryIdType) ?? payloadInput.diaryId ?? agentNode?.diaryId;
+				if (teamId) builder.team(teamId);
+				if (diaryId) builder.diary(diaryId);
+				for (const m of def.contexts ?? []) {
+					if (!m?.slug) continue;
+					const value = resolveValue(RED, this, msg, m);
+					const binding = m.binding ?? "context_inline";
+					if (binding === "context_inline") builder.contextInline(m.slug, value);
+					else if (binding === "user_inline") builder.userInline(m.slug, value);
+					else {
+						const content = typeof value === "string" ? value : JSON.stringify(value);
+						builder.context(m.slug, binding, content);
+					}
+				}
+				if (def.referencesFrom) {
+					const ref = RED.util.getMessageProperty(msg, def.referencesFrom);
+					if (ref && ref.outputCid) builder.references(ref, def.referencesRole ?? "context");
+				}
+				if (def.submitOutputGate) builder.requireSubmitOutput();
+				if (def.schemaCid) builder.requireSchema(def.schemaCid);
+				const inputPatch = {};
+				if (def.workspace) inputPatch.execution = { workspace: def.workspace };
+				if (def.constraints && def.constraints.length > 0) inputPatch.constraints = def.constraints;
+				if (def.expectedOutput) inputPatch.expectedOutput = def.expectedOutput;
+				if (Object.keys(inputPatch).length > 0) builder.input(inputPatch);
+				const title = typeof payloadInput.title === "string" && payloadInput.title ? payloadInput.title : def.title?.trim();
+				if (title) builder.title(title);
+				const tags = Array.isArray(payloadInput.tags) ? payloadInput.tags : parseCsv(def.tags);
+				if (tags.length > 0) builder.tags(...tags);
+				const built = builder.build();
+				const out = RED.util.cloneMessage(msg);
+				out.payload = {
+					...built.body,
+					teamId: built.teamId
+				};
+				this.status({
+					fill: "green",
+					shape: "dot",
+					text: "built"
+				});
+				send(out);
+				done();
+			} catch (err) {
+				this.status({
+					fill: "red",
+					shape: "ring",
+					text: "error"
+				});
+				done(err instanceof TaskBuildError ? new Error(err.message) : err instanceof Error ? err : new Error(String(err)));
+			}
+		});
+	}
+	RED.nodes.registerType("moltnet-task-builder", TaskBuilderNode);
+};
+//#endregion
+export { init as default, resolveOverride };

package/dist/nodes/task-get.html

@@ -0,0 +1,55 @@
+<script type="text/javascript">
+  RED.nodes.registerType('moltnet-task-get', {
+    category: 'moltnet',
+    color: '#00d4c8',
+    paletteLabel: 'task: get',
+    defaults: {
+      name: { value: '' },
+      agent: { value: '', type: 'moltnet-agent', required: true },
+      taskId: { value: '' },
+    },
+    inputs: 1,
+    outputs: 1,
+    icon: 'font-awesome/fa-search',
+    label: function () {
+      return this.name || 'task: get';
+    },
+  });
+</script>
+
+<script type="text/html" data-template-name="moltnet-task-get">
+  <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>
+</script>
+
+<script type="text/html" data-help-name="moltnet-task-get">
+  <p>
+    Reads a MoltNet task and its attempts once (no polling). The task id is
+    taken from <code>msg.taskId</code>, <code>msg.payload.taskId</code>, or
+    <code>msg.payload.id</code> (the shape <code>tasks: create</code> emits),
+    falling back to the configured Task ID.
+  </p>
+  <p>
+    Emits a normalized snapshot on <code>msg.payload</code>:
+    <code
+      >{ taskId, status, terminal, accepted, acceptedAttemptN, state, attempt,
+      attempts, error, task }</code
+    >. <code>state</code> is the accepted attempt's output artifact, or
+    <code>null</code> when not yet accepted.
+  </p>
+  <p>For "block until the run settles", use <code>task: wait</code> instead.</p>
+</script>

package/dist/nodes/task-get.js

@@ -0,0 +1,60 @@
+import { t as buildTaskSnapshot } from "./task-snapshot.js";
+//#region src/nodes/task-get.ts
+var init = (RED) => {
+	function TaskGetNode(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-get: no moltnet-agent configured");
+					const taskId = resolveTaskId(msg, def.taskId);
+					if (!taskId) throw new Error("task-get: taskId is required");
+					this.status({
+						fill: "blue",
+						shape: "dot",
+						text: "loading…"
+					});
+					const agent = await agentNode.getAgent();
+					const [task, attempts] = await Promise.all([agent.tasks.get(taskId), agent.tasks.listAttempts(taskId)]);
+					const snapshot = buildTaskSnapshot(task, attempts);
+					const out = RED.util.cloneMessage(msg);
+					out.payload = snapshot;
+					this.status({
+						fill: snapshot.accepted ? "green" : "grey",
+						shape: "dot",
+						text: `${snapshot.status}${snapshot.accepted ? " ✓" : ""}`
+					});
+					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-get", TaskGetNode);
+};
+/**
+* Resolve the task id from the message (in priority order) or fall back to the
+* node's configured id. Accepts both `msg.payload.taskId` and the shape emitted
+* by `moltnet-tasks-create` (`msg.payload.id`).
+*/
+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;
+}
+//#endregion
+export { init as default };

package/dist/nodes/task-reader.html

@@ -0,0 +1,64 @@
+<script type="text/javascript">
+  RED.nodes.registerType('moltnet-task-reader', {
+    category: 'moltnet',
+    color: '#00d4c8',
+    paletteLabel: 'task: read',
+    defaults: {
+      name: { value: '' },
+      source: { value: '' },
+      role: { value: 'context' },
+      artifactKind: { value: '' },
+      artifactTitle: { value: '' },
+    },
+    inputs: 1,
+    outputs: 1,
+    icon: 'font-awesome/fa-book',
+    label: function () {
+      return this.name || 'task: read';
+    },
+  });
+</script>
+
+<script type="text/html" data-template-name="moltnet-task-reader">
+  <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-source"><i class="fa fa-sign-in"></i> Source</label>
+    <input type="text" id="node-input-source" placeholder="payload" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-role"><i class="fa fa-link"></i> Output role</label>
+    <select id="node-input-role">
+      <option value="context">context</option>
+      <option value="judged_work">judged_work</option>
+      <option value="reviewed_diff">reviewed_diff</option>
+      <option value="target_source">target_source</option>
+    </select>
+  </div>
+  <div class="form-row">
+    <label for="node-input-artifactKind">Artifact kind</label>
+    <input type="text" id="node-input-artifactKind" placeholder="(optional)" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-artifactTitle">Artifact title</label>
+    <input type="text" id="node-input-artifactTitle" placeholder="(optional)" />
+  </div>
+</script>
+
+<script type="text/html" data-help-name="moltnet-task-reader">
+  <p>
+    Parses a completed task snapshot (from <code>task: wait</code>/<code
+      >task: get</code
+    >) into typed result data via the SDK reader. Sets the typed output on
+    <code>msg.payload</code> and a flat <code>msg.result</code> with
+    <code>{ summary, outputRef, artifact, artifactBody, accepted, usage }</code
+    >. The <code>outputRef</code> chains directly into a downstream
+    <code>task: build</code>'s "References from".
+  </p>
+  <p>
+    Set <b>Artifact kind/title</b> to pre-parse a JSON artifact body into
+    <code>msg.result.artifactBody</code>.
+  </p>
+</script>