@abot-ai/runtime 1.5.0 → 1.6.0

package/dist/src/web-ui/app/components/automations/editor-actions.js

@@ -0,0 +1,57 @@
+import { escapeHtml } from "../../lib/text-format.js";
+import { renderAutomationDraftRecovery } from "./draft-recovery-actions.js";
+import { renderAutomationEditorIcon } from "./editor-action-icons.js";
+
+function editorAction(action, label, icon, { className = "", disabled = false, busy = false, title = "" } = {}) {
+  return `<button type="button" class="automation-editor-action ${className}" data-action="${action}"${disabled ? " disabled" : ""}${busy ? ' aria-busy="true"' : ""}${title ? ` title="${escapeHtml(title)}"` : ""}>${renderAutomationEditorIcon(icon)}<span>${label}</span></button>`;
+}
+
+function renderDraftActions() {
+  return `<div class="automation-editor-action-group" role="group" aria-label="Draft actions">
+    <span class="automation-editor-action-label">Draft</span><div class="automation-actions">
+      ${editorAction("save-draft", "Save draft", "save", { title: "Save automation settings to the draft" })}
+      ${editorAction("describe", "Build with ABot", "build")}
+      ${editorAction("validate", "Check", "check", { title: "Check the draft before publishing" })}
+      ${editorAction("publish", "Publish", "publish", { className: "automation-primary", title: "Publish this draft for future runs" })}
+    </div></div>`;
+}
+
+function renderExecutionActions(snapshot, current, runUnavailable, activateUnavailable) {
+  const active = current.status === "active";
+  const runPending = Boolean(snapshot.runStartPending);
+  const runActionDisabled = runUnavailable || runPending || snapshot.loading || Boolean(snapshot.mutation);
+  return `<div class="automation-editor-action-group automation-editor-execution" role="group" aria-label="Execution actions">
+    <span class="automation-editor-action-label">Execution <span class="automation-editor-state" data-state="${active ? "active" : "paused"}">${active ? "Active" : "Paused"}</span></span>
+    <div class="automation-actions">
+      ${editorAction("run", runPending ? "Starting…" : "Run now", "run", { disabled: runActionDisabled, busy: runPending,
+        title: runUnavailable ? current.runUnavailableReason || "Run unavailable" : "Run the published version once" })}
+      ${editorAction("toggle-active", active ? "Pause" : "Activate", active ? "pause" : "activate", {
+        className: active ? "automation-editor-pause" : "automation-editor-activate", disabled: activateUnavailable,
+        title: activateUnavailable ? current.activateUnavailableReason || "Activation unavailable"
+          : active ? "Pause automatic triggers" : "Enable automatic triggers for the published version" })}
+    </div></div>`;
+}
+
+function renderManagementActions(snapshot, published, canDeleteDraft) {
+  const archive = published ? editorAction("archive", "Archive automation", "archive", { className: "automation-editor-archive" })
+    : canDeleteDraft ? editorAction("delete-draft", "Delete draft", "delete", { className: "automation-stop" }) : "";
+  return `<details class="automation-editor-management"><summary>${renderAutomationEditorIcon("manage")}<span>Manage automation</span></summary>
+    <div class="automation-editor-management-body">
+      <div class="automation-editor-action-group" role="group" aria-label="Draft recovery">
+        <span class="automation-editor-action-label">Draft recovery</span><div class="automation-actions">${renderAutomationDraftRecovery(snapshot)}</div>
+      </div>
+      ${archive ? `<div class="automation-editor-archive-group"><span class="automation-editor-action-label">${published ? "Archive" : "Delete draft"}</span><div class="automation-actions">${archive}</div>
+        <p>${published ? "Pause its schedule and move it to the archive. Runs and reports stay available." : "Permanently remove this unpublished draft."}</p></div>` : ""}
+    </div></details>`;
+}
+
+export function renderAutomationEditorActions(snapshot, { current, canDeleteDraft, runUnavailable, activateUnavailable }) {
+  if (current?.status === "archived") {
+    return `<div class="automation-editor-actionbar automation-actions">${editorAction("restore", "Restore automation", "restore", { className: "automation-primary" })}</div>`;
+  }
+  const published = Boolean(current?.publishedRevision);
+  return `<div class="automation-editor-actionbar" aria-label="Automation actions">
+    <div class="automation-editor-action-groups">${renderDraftActions()}${published ? renderExecutionActions(snapshot, current, runUnavailable, activateUnavailable) : ""}</div>
+    ${renderManagementActions(snapshot, published, canDeleteDraft)}
+  </div>`;
+}

package/dist/src/web-ui/app/components/automations/editor.js

@@ -0,0 +1,218 @@
+import { escapeHtml } from "../../lib/text-format.js";
+import { findAutomationNode, renderAutomationTimeline } from "./timeline.js";
+import { operationIdentity } from "./node-inspector.js";
+import { renderAutomationStepPreview } from "./step-preview.js";
+import { renderAutomationEditorActions } from "./editor-actions.js";
+import { toolDisplayName } from "./tool-identity.js";
+export { toolDisplayName } from "./tool-identity.js";
+import { listAvailableAutomationProducers } from "../../lib/automation-binding-producers.js";
+import { requiresFullPlus, selectedAutomationOperations } from "./permission-selection.js";
+
+function triggerChoice(trigger) {
+  return trigger?.kind === "schedule" ? trigger.schedule?.kind || "daily" : trigger?.kind || "manual";
+}
+
+function renderTriggerFields(definition) {
+  const selected = triggerChoice(definition.trigger);
+  const schedule = definition.trigger?.schedule || {};
+  return `<div class="automation-trigger-fields"><label>Start<select name="triggerKind">
+    ${[["manual","Manual"],["folder","New files"],["timer","After delay"],["once","Once"],["interval","Interval"],["daily","Daily"],["weekly","Weekly"],["monthly","Monthly"]].map(([kind,label]) => `<option value="${kind}"${selected === kind ? " selected" : ""}>${label}</option>`).join("")}</select></label>
+    <label>Time or minutes<input name="triggerValue" value="${escapeHtml(selected === "interval" ? Math.round((schedule.everyMs || 3_600_000) / 60_000) : selected === "timer" ? Math.round((schedule.delayMs || 60_000) / 60_000) : selected === "once" ? schedule.at || "" : schedule.at || "09:00")}" placeholder="09:00 or minutes"></label>
+    <label>Weekdays (0–6)<input name="weekdays" value="${escapeHtml((schedule.weekdays || []).join(","))}" placeholder="1,2,3,4,5"></label>
+    <label>Day of month<input name="dayOfMonth" type="number" min="1" max="31" value="${escapeHtml(schedule.dayOfMonth || 1)}"></label>
+    <label>Minimum new files<input name="minimumEligibleFiles" type="number" min="1" value="${escapeHtml(definition.trigger?.minimumEligibleFiles || 1)}"></label>
+    <label>Check every (minutes)<input name="checkEveryMinutes" type="number" min="1" value="${escapeHtml(Math.round((definition.trigger?.checkEveryMs || 300_000) / 60_000))}"></label>
+  </div>`;
+}
+
+function renderSourceFields(source) {
+  return `<details class="automation-source"${source ? " open" : ""}><summary>Folder source · optional</summary>
+    <div class="automation-source-options">
+      <label><input type="checkbox" name="sourceEnabled"${source ? " checked" : ""}>Use a folder</label>
+      <label><input type="checkbox" name="sourceRecursive"${source?.recursive ? " checked" : ""}>Include subfolders</label>
+      <label><input type="checkbox" name="includeExisting"${source?.includeExisting ? " checked" : ""}>Include files already there on first activation</label>
+    </div><div class="automation-source-fields"><label>Runtime-visible folder<input name="sourcePath" value="${escapeHtml(source?.location?.path || "")}" placeholder="/workspace/inbox"></label>
+      <label>Process<select name="sourceMode"><option value="per_file"${source?.mode !== "batch" ? " selected" : ""}>Each file</option><option value="batch"${source?.mode === "batch" ? " selected" : ""}>Batch</option></select></label>
+      <label>Max files per batch<input type="number" name="maxBatchFiles" min="1" max="100" value="${escapeHtml(source?.maxBatchFiles || 100)}"></label>
+      <label>Include patterns<input name="includePatterns" value="${escapeHtml((source?.includePatterns || []).join(", "))}" placeholder="*.pdf, *.txt"></label>
+      <label>Exclude outputs and archive paths<input name="excludePatterns" value="${escapeHtml((source?.excludePatterns || []).join(", "))}" placeholder="archive/**, output/**"></label>
+    </div><p class="automation-muted">The Runtime must be able to read this folder. If a step writes or archives files, exclude those destinations so they cannot become new inputs. Publishing never starts processing existing files by itself.</p>
+  </details>`;
+}
+
+function renderLimits(limits) {
+  if (!limits) return "";
+  return `<details class="automation-limits"><summary>Resource limits</summary><div class="automation-limit-fields">
+    ${[["maxModelCallsPerRun","Model calls / run"],["maxToolCallsPerRun","Tool calls / run"],["maxConcurrentNodes","Parallel steps"],["maxRunsPerDay","Runs / day"],["maxRunDurationMs","Run duration (ms)"],["maxStoredArtifactBytes","Stored artifacts (bytes)"],["stopReportDeadlineMs","Stop report deadline (ms)"]].map(([key,label]) => `<label>${label}<input type="number" min="1" name="limit-${key}" value="${escapeHtml(limits[key])}"${key === "maxModelCallsPerRun" ? ` aria-describedby="automation-model-limit-help"` : ""}></label>`).join("")}
+  </div><p class="automation-muted" id="automation-model-limit-help">Model calls include decisions, tool discovery, input preparation and final responses across the whole run. This limit is a ceiling, not the desired number of calls. Usage varies by model and workflow; use completed-run usage in Execution details to choose headroom. Tool calls count admitted attempts, including failed attempts.</p>
+  <p class="automation-muted">Save the draft and publish to apply changed limits to future runs. An existing run keeps its published limits.</p></details>`;
+}
+
+function toolCatalogItems(catalog) {
+  const operations = Array.isArray(catalog?.grantableOperations)
+    ? catalog.grantableOperations : catalog?.operations || [];
+  const tools = new Map();
+  for (const operation of operations) {
+    const existing = tools.get(operation.toolName) || {
+      name: operation.toolName,
+      label: toolDisplayName(operation.toolName),
+      group: operation.pluginName || "Built-in",
+      description: operation.toolDescription || "",
+      operations: [],
+    };
+    existing.operations.push(operation);
+    tools.set(operation.toolName, existing);
+  }
+  return [...tools.values()].sort((left, right) =>
+    left.group.localeCompare(right.group) || left.label.localeCompare(right.label));
+}
+
+export function renderAutomationToolResults(catalog, { query = "", selectedToolName = "" } = {}) {
+  const normalized = query.trim().toLocaleLowerCase();
+  const tools = toolCatalogItems(catalog).filter((tool) => !normalized ||
+    [tool.label, tool.name, tool.group, tool.description,
+      ...tool.operations.map((operation) => `${operation.operationId} ${operation.label || ""}`)]
+      .some((value) => value.toLocaleLowerCase().includes(normalized)));
+  if (!tools.length) return `<p class="automation-muted">${normalized ? "No matching tools." : "No tools are configured yet. You can still build with agents."}</p>`;
+  const granted = new Set((catalog?.operations || []).map((item) =>
+    operationIdentity(item)));
+  const groups = new Map();
+  for (const tool of tools) {
+    if (!groups.has(tool.group)) groups.set(tool.group, []);
+    groups.get(tool.group).push(tool);
+  }
+  return [...groups.entries()].map(([group, entries]) => {
+    const expanded = Boolean(normalized || entries.some((tool) => tool.name === selectedToolName));
+    const operationCount = entries.reduce((count, tool) => count + tool.operations.length, 0);
+    return `<details class="automation-tool-group"${expanded ? " open" : ""}><summary><strong>${escapeHtml(toolDisplayName(group))}</strong><small>${entries.length} ${entries.length === 1 ? "tool" : "tools"} · ${operationCount} ${operationCount === 1 ? "operation" : "operations"}</small></summary><div class="automation-plugin-tools">${entries.map((tool) => {
+    const selected = tool.name === selectedToolName;
+    return `<div class="automation-tool-choice"><button type="button" draggable="true" class="automation-palette-item" data-palette-select-tool="${escapeHtml(tool.name)}" data-palette-tool="${escapeHtml(tool.name)}" aria-expanded="${selected}">${escapeHtml(tool.label)}<small>${escapeHtml(tool.operations.length)} ${tool.operations.length === 1 ? "operation" : "operations"}</small></button>
+      ${selected ? `<div class="automation-tool-operations"><p>Choose the operation and inputs after adding this tool.</p>${tool.operations.map((operation) => {
+        const identity = operationIdentity(operation);
+        const allowed = granted.has(identity);
+        return `<div class="automation-tool-operation"><strong>${escapeHtml(toolDisplayName(operation.operationId))}</strong><span>${requiresFullPlus(operation) ? "FULL+" : "Full"}${allowed ? "" : " · permission needed"}</span><small>${escapeHtml(operation.label || "")}</small></div>`;
+      }).join("")}<button type="button" class="automation-tool-add" data-palette-add-tool="${escapeHtml(tool.name)}">Add to timeline</button></div>` : ""}</div>`;
+  }).join("")}</div></details>`;
+  }).join("");
+}
+
+function paletteAgent(item) {
+  return `<button type="button" draggable="true" class="automation-palette-item automation-agent-choice" data-palette-agent="${escapeHtml(item.agentId || item.id)}"><strong dir="auto">${escapeHtml(item.agent?.title || item.title || "Saved agent")}</strong><small>Saved agent · revision ${escapeHtml(item.revision || 1)}</small></button>`;
+}
+
+function renderValidation(validation) {
+  const issues = Array.isArray(validation?.issues) ? validation.issues : [];
+  if (!issues.length) return "";
+  return `<div class="automation-validation" role="alert"><strong>Needs attention before publishing</strong>${issues.map((issue) => `<button type="button" data-select-node="${escapeHtml(issue.nodeId || "")}"><code>${escapeHtml(issue.code || "automation_graph_invalid")}</code>${issue.path ? ` · <code>${escapeHtml(issue.path)}</code>` : ""} · ${escapeHtml(issue.message || "Check this step")}</button>`).join("")}</div>`;
+}
+
+function renderToolPermissionRequirements(selection) {
+  let requirement = "";
+  if (selection.operations.length) {
+    const operations = selection.details.map((operation) => `<li><span>${escapeHtml(toolDisplayName(operation.toolName))} · ${escapeHtml(toolDisplayName(operation.operationId))}</span><strong>${requiresFullPlus(operation) ? "FULL+" : "Full"}</strong></li>`).join("");
+    requirement = `<ul class="automation-permission-list">${operations}</ul>`;
+  } else if (!selection.missing.length) {
+    requirement = `<p>No tool operations selected.</p>`;
+  }
+  const count = selection.operations.length;
+  const state = `${selectedToolPermissionLabel(selection)}${count ? ` · ${count} selected operation${count === 1 ? "" : "s"}` : ""}${selection.missing.length ? ` · ${selection.missing.length} unavailable` : ""}`;
+  return `<details class="automation-permission"><summary>Tool permission <span class="automation-permission-state">${escapeHtml(state)}</span></summary>
+    ${requirement}
+    ${selection.missing.length ? `<p>${selection.missing.length} selected operation${selection.missing.length === 1 ? " is" : "s are"} unavailable in the current tool catalog.</p>` : ""}
+  </details>`;
+}
+
+function selectedToolPermissionLabel(selection) {
+  if (!selection.operations.length && selection.missing.length) return "Selected tool unavailable";
+  if (!selection.operations.length) return "No tools selected";
+  return selection.mode === "full_plus" ? "FULL+ required" : "Full required";
+}
+
+export function renderAutomationEditor(snapshot, paletteState = {}) {
+  const definition = snapshot.draft?.definition;
+  if (!definition) return `<p class="automation-feedback" role="status">${escapeHtml(snapshot.error || "Loading draft…")}</p>`;
+  const selected = findAutomationNode(definition.body, snapshot.selectedNodeId);
+  const producers = listAvailableAutomationProducers(definition.body, snapshot.selectedNodeId);
+  const catalog = snapshot.catalog || { operations: [], models: [], savedAgents: [] };
+  const current = snapshot.automations.find((item) => item.id === snapshot.selectedAutomationId);
+  const published = Boolean(current?.publishedRevision);
+  const archived = current?.status === "archived" || Boolean(snapshot.draft?.archivedAt);
+  const runUnavailable = published && current?.canRun === false;
+  const activateUnavailable = published && current?.status !== "active" && current?.canActivate === false;
+  const selectedOperations = selectedAutomationOperations(definition, catalog);
+  const permission = selectedToolPermissionLabel(selectedOperations);
+  const inspectorMarkup = !archived ? renderAutomationStepPreview(selected, catalog, producers) : "";
+  return `<div class="automation-workspace" data-automation-view="editor">
+    <section class="automation-definition-panel" aria-label="Automation details">
+    <div class="automation-heading"><div><button type="button" class="automation-text-button" data-action="back">← All automations</button><h3 dir="auto">${escapeHtml(definition.title || "ABot Automation")}</h3><p>Draft revision ${escapeHtml(snapshot.draft.revision)}${published ? ` · Published revision ${escapeHtml(current.publishedRevision)}` : " · Not published"}${archived ? " · Archived" : ""}</p></div>
+      <div class="automation-heading-actions"><button type="button" class="automation-details-toggle" data-action="toggle-details" aria-controls="automation-editor-details" aria-expanded="true"><span data-details-label>Collapse details</span></button></div></div>
+    ${renderAutomationEditorActions(snapshot, { current: archived ? { ...current, status: "archived" } : current, canDeleteDraft: current && !snapshot.publishedDefinition, runUnavailable, activateUnavailable })}
+    ${!archived && (runUnavailable || activateUnavailable) ? `<p class="automation-action-note" role="status">${escapeHtml(current.runUnavailableReason || current.activateUnavailableReason || "This automation cannot start yet.")}</p>` : ""}
+    <p class="automation-feedback" role="status" aria-live="polite" data-tone="${snapshot.error ? "error" : ""}">${escapeHtml(snapshot.error || snapshot.feedback || (archived ? "Archived. Restore to edit or run it. Reports remain available." : "Step and order changes are saved to the draft immediately. Automation settings use Save draft. Publishing is separate."))}</p>
+    <div class="automation-editor-details" id="automation-editor-details">
+    <div class="automation-tabs" role="tablist"><button type="button" role="tab" aria-selected="true">Editor</button><button type="button" role="tab" aria-selected="false" data-action="show-runs">Runs (${escapeHtml(snapshot.runs.length)})</button></div>
+    <div class="automation-summary"><span><strong>Start</strong> · ${escapeHtml(triggerChoice(definition.trigger))}</span><span><strong>Permission</strong> · ${permission}</span><span><strong>Model</strong> · Per agent</span></div>
+    ${renderValidation(!archived && snapshot.validationVisible ? snapshot.validation : null)}
+    <form class="automation-definition-form" data-automation-definition-form${archived ? " inert" : ""}><div class="automation-top-fields"><label>Name<input name="title" value="${escapeHtml(definition.title || "")}" required dir="auto"></label><label>Goal<textarea name="objective" dir="auto">${escapeHtml(definition.objective || "")}</textarea></label></div>
+      <label>Working directory<input name="workingDirectory" value="${escapeHtml(definition.workingDirectory || "")}" placeholder="Optional absolute path on the Runtime host"></label>
+      <details class="automation-run-inputs"><summary>Run inputs · JSON object</summary><label>Values supplied when a run starts<textarea name="inputsJson" spellcheck="false">${escapeHtml(JSON.stringify(definition.inputs || {}, null, 2))}</textarea></label></details>
+      ${renderTriggerFields(definition)}${renderSourceFields(definition.source)}${renderLimits(definition.limits)}
+      ${renderToolPermissionRequirements(selectedOperations)}
+    </form>
+    </div>
+    </section>
+    ${archived ? `<section class="automation-canvas automation-archived-canvas" aria-label="Workflow">${renderAutomationTimeline(definition, { editable: false, catalog })}</section>` : `<div class="automation-editor-layout"><div class="automation-editor-sidebar"><section class="automation-palette" aria-label="Agents"><h4>Agents</h4><p>Add a new agent or reuse one you saved.</p>
+        <button type="button" draggable="true" class="automation-palette-item automation-agent-choice" data-palette-agent="new"><strong>New agent</strong><small>Set model, role, and prompt</small></button>
+        ${(catalog.savedAgents || []).map(paletteAgent).join("")}
+      </section><section class="automation-palette" aria-label="Tools"><h4>Tools</h4><p>Open a plugin to choose a tool.</p>
+      <label class="automation-tool-search">Search plugins, tools, or operations<input type="search" data-tool-search value="${escapeHtml(paletteState.query || "")}" placeholder="Search plugins or tools" autocomplete="off"></label>
+      <div data-automation-tool-results>${renderAutomationToolResults(catalog, paletteState)}</div>
+      <button type="button" data-action="move-to-slot" hidden>Move selected step here</button></section>
+      </div><section class="automation-canvas" aria-label="Workflow">${renderAutomationTimeline(definition, { editable: true, selectedNodeId: snapshot.selectedNodeId, inspectorMarkup, catalog })}</section></div>`}
+  </div>`;
+}
+
+function commaValues(value) {
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+
+function readTrigger(fields) {
+  const kind = String(fields.get("triggerKind") || "manual");
+  if (kind === "manual") return { kind };
+  if (kind === "folder") return {
+    kind, checkEveryMs: Number(fields.get("checkEveryMinutes")) * 60_000,
+    minimumEligibleFiles: Number(fields.get("minimumEligibleFiles")),
+  };
+  const value = String(fields.get("triggerValue") || "").trim();
+  if (kind === "timer") return { kind: "schedule", schedule: { kind, delayMs: Number(value) * 60_000 } };
+  if (kind === "interval") return { kind: "schedule", schedule: { kind, everyMs: Number(value) * 60_000 } };
+  if (kind === "weekly") return { kind: "schedule", schedule: { kind, at: value, weekdays: commaValues(String(fields.get("weekdays") || "")).map(Number) } };
+  if (kind === "monthly") return { kind: "schedule", schedule: { kind, at: value, dayOfMonth: Number(fields.get("dayOfMonth")) } };
+  return { kind: "schedule", schedule: { kind, at: value } };
+}
+
+export function readAutomationDefinitionPatch(form, definition) {
+  const fields = new FormData(form);
+  let inputs;
+  try { inputs = JSON.parse(String(fields.get("inputsJson") || "{}")); }
+  catch { throw new Error("Run inputs must be valid JSON."); }
+  if (!inputs || typeof inputs !== "object" || Array.isArray(inputs))
+    throw new Error("Run inputs must be a JSON object.");
+  const sourceEnabled = fields.has("sourceEnabled");
+  const source = sourceEnabled ? {
+    sourceId: definition.source?.sourceId || "",
+    location: { kind: "runtime_path", path: String(fields.get("sourcePath") || "").trim() },
+    includePatterns: commaValues(String(fields.get("includePatterns") || "")),
+    excludePatterns: commaValues(String(fields.get("excludePatterns") || "")),
+    recursive: fields.has("sourceRecursive"), includeExisting: fields.has("includeExisting"),
+    mode: fields.get("sourceMode") === "batch" ? "batch" : "per_file",
+    maxBatchFiles: Number(fields.get("maxBatchFiles")),
+  } : null;
+  const limits = { ...definition.limits };
+  for (const key of Object.keys(limits)) limits[key] = Number(fields.get(`limit-${key}`));
+  return {
+    title: String(fields.get("title") || "").trim(), objective: String(fields.get("objective") || "").trim(),
+    workingDirectory: String(fields.get("workingDirectory") || "").trim() || null,
+    trigger: readTrigger(fields), source, inputs, limits,
+  };
+}

package/dist/src/web-ui/app/components/automations/failure-presentation.js

@@ -0,0 +1,299 @@
+import { escapeHtml } from "../../lib/text-format.js";
+
+const FAILURE_DESCRIPTIONS = {
+  automation_model_call_limit_reached: {
+    title: "Model call limit reached",
+    reason: "The run used all permitted model calls before its next model invocation.",
+    action: "Review model usage below. Increase Model calls / run in Resource limits, save the draft and publish before trying again. The eventual call count depends on the model and workflow.",
+  },
+  automation_tool_call_limit_reached: {
+    title: "Tool call limit reached",
+    reason: "The run reached its tool-attempt limit before another tool could be admitted.",
+    action: "Review admitted tool attempts below. Adjust Tool calls / run in Resource limits, save the draft and publish before trying again.",
+  },
+  automation_run_duration_exceeded: {
+    scope: "run",
+    title: "Run duration limit reached",
+    reason: "The run exceeded its configured duration.",
+    action: "Review the steps and any recorded effects. If more time is appropriate, increase Run duration in Resource limits, save the draft and publish.",
+  },
+  automation_budget_exhausted: {
+    scope: "run",
+    title: "Resource limit reached",
+    reason: "A resource limit stopped this run. The recorded error does not identify which limit was reached.",
+    action: "Review Execution details and Resource limits. A new run can record a more specific limit reason.",
+  },
+  automation_agent_context_too_large: {
+    title: "Agent input exceeds the model context",
+    reason: "The agent request could not fit within the model's available context.",
+    action: "Reduce the step's inputs or use a model with more context capacity. Increasing Model calls / run does not increase context capacity.",
+  },
+  automation_agent_provider_failed: {
+    title: "Model provider request failed",
+    reason: "The model provider could not complete the agent request.",
+    action: "Check that the configured model provider is available, and review any recorded effects before retrying.",
+  },
+  request_inactivity_timeout: {
+    title: "Agent request stopped making progress",
+    reason: "No request activity was recorded within the configured inactivity interval.",
+    action: "Inspect retained results and tool effects, and check the model provider before retrying. This inactivity limit is separate from the whole-run duration limit.",
+  },
+  llm_stream_inactivity_timeout: {
+    title: "Model stream stopped sending data",
+    reason: "The model stream produced no new data within its configured inactivity interval.",
+    action: "Check the model provider and inspect recorded effects before retrying. This inactivity limit is separate from the whole-run duration limit.",
+  },
+  automation_agent_failed: {
+    title: "Agent request failed",
+    reason: "The saved error does not include a more specific cause for the agent request failure.",
+    action: "Inspect the step result and Diagnostics. The recorded information cannot confirm whether a limit, timeout or provider issue caused this failure.",
+  },
+  automation_run_deadline_elapsed: {
+    scope: "run",
+    title: "Run deadline elapsed",
+    reason: "The run could not complete within its configured deadline.",
+    action: "Review completed steps and recorded effects. Check Run duration and Stop report deadline in Resource limits before trying again.",
+  },
+  automation_stop_deadline_elapsed: {
+    scope: "run",
+    title: "Stop report deadline reached",
+    reason: "The Runtime stopped waiting for this run to finish after the stop report deadline elapsed.",
+    action: "Review retained results, uncertain tool effects and any later evidence before starting another run. The cancelled status does not confirm that an external action has stopped.",
+  },
+  automation_agent_blocked: {
+    title: "Agent could not complete the step",
+    reason: "The agent reported that it was blocked from completing the requested work.",
+    action: "Review its inputs, instructions and allowed tools. Check any saved result for the agent's explanation.",
+  },
+  automation_agent_acceptance_failed: {
+    title: "Agent result did not meet the step conditions",
+    reason: "The agent result did not meet this step's acceptance conditions.",
+    action: "Review its inputs and any saved output, then check the configured acceptance conditions.",
+  },
+  automation_dependency_missing: {
+    title: "An earlier step result is missing",
+    reason: "This step could not receive a required result from an earlier step.",
+    action: "Inspect the earlier step and the input connection. Confirm that the source step completes and saves the expected output.",
+  },
+  automation_output_pointer_invalid: {
+    title: "An input connection could not find its value",
+    reason: "The configured JSON pointer did not resolve within an earlier step's output.",
+    action: "Inspect the source output and correct the input connection's JSON pointer.",
+  },
+  automation_source_unavailable: {
+    title: "A selected source file is unavailable",
+    reason: "The run could not access one of its selected input files.",
+    action: "Check the folder source and file availability from the Runtime environment.",
+  },
+  automation_source_changed: {
+    title: "A selected source file changed",
+    reason: "The input file changed after this run selected its version.",
+    action: "Check the source file and start a new run with its current version.",
+  },
+  automation_source_reader_unavailable: {
+    title: "Source reader is unavailable",
+    reason: "The Runtime has no available reader for the selected source.",
+    action: "Check the configured source reader and its permissions before trying again.",
+  },
+  automation_source_type_unsupported: {
+    title: "Source file type is unsupported",
+    reason: "The source reader does not support the selected file type.",
+    action: "Use a supported file type or change the source reader.",
+  },
+  automation_source_capacity_exceeded: {
+    title: "Folder source capacity reached",
+    reason: "The retained source files or their metadata exceeded a source capacity limit.",
+    action: "Review source selection and retained inputs. Narrow the source or reduce the batch size before trying again.",
+  },
+  automation_operation_unavailable: {
+    title: "A required tool operation is unavailable",
+    reason: "A selected operation is unavailable or its automation permission is no longer valid.",
+    action: "Check installed tools and the automation's Tool permission, then validate and publish the updated draft.",
+  },
+  automation_approval_required: {
+    title: "Tool approval is required",
+    reason: "The requested operation needs approval that this unattended run could not obtain.",
+    action: "Review the operation and the automation's published tool permissions before running again.",
+  },
+  automation_model_unavailable: {
+    title: "The selected model is unavailable",
+    reason: "The agent's configured model profile is not available.",
+    action: "Select an available model for the step, save the draft and publish.",
+  },
+  automation_artifact_budget_exhausted: {
+    title: "Saved output capacity reached",
+    reason: "The Runtime could not retain another output within the available artifact capacity.",
+    action: "Review output size, retained artifacts and Stored artifacts in Resource limits. Capacity may also be constrained by total Runtime storage.",
+  },
+  automation_effect_uncertain: {
+    title: "A tool's outcome is uncertain",
+    reason: "The Runtime could not confirm whether a tool finished its action.",
+    action: "Inspect the recorded tool effects and actual target before retrying, to avoid repeating an action that may already have happened.",
+  },
+  automation_run_stopped: {
+    scope: "run",
+    title: "Run stopped",
+    reason: "A stop request interrupted this run.",
+    action: "Review any completed steps and recorded effects before starting another run.",
+  },
+  automation_tool_failed: {
+    title: "A tool reported failure",
+    reason: "A tool could not complete its requested operation.",
+    action: "Inspect the saved tool result and effects for its specific error before retrying.",
+  },
+  automation_required_operation_missing: {
+    title: "A required operation was not completed",
+    reason: "The agent finished without a successful receipt for a required tool operation.",
+    action: "Review the agent's saved result, instructions and required tools before running again.",
+  },
+};
+
+const REQUEST_TIMEOUT_PHASES = {
+  request_timeout: "Agent request",
+  execution_agent_decision_timeout: "Agent decision",
+  execution_capability_refinement_timeout: "Tool input selection",
+  execution_agent_response_timeout: "Agent response",
+  supervisor_decision_timeout: "Supervisor decision",
+  supervisor_response_timeout: "Supervisor response",
+  supervisor_memory_authoring_timeout: "Session memory authoring",
+  planner_decision_timeout: "Planning decision",
+  planner_graph_timeout: "Plan authoring",
+  worker_decision_timeout: "Worker decision",
+  worker_result_timeout: "Worker result",
+  worker_capability_payload_timeout: "Tool input preparation",
+  reviewer_decision_timeout: "Result review",
+  auditor_decision_timeout: "Result audit",
+  degraded_finalization_timeout: "Final response",
+  context_compaction_timeout: "Context compaction",
+  session_memory_compaction_timeout: "Session memory compaction",
+};
+
+const REQUEST_OUTPUT_FAILURES = new Set([
+  "invalid_supervisor_decision", "invalid_execution_agent_decision", "invalid_planner_decision",
+  "invalid_worker_decision", "invalid_reviewer_decision", "invalid_execution_agent_authored_response",
+  "invalid_worker_result", "invalid_supervisor_response", "invalid_execution_agent_response",
+  "invalid_supervisor_memory_candidates", "invalid_context_compaction_output",
+  "invalid_session_memory_compaction_output", "worker_capability_payload_model_output_invalid",
+  "invalid_degraded_finalization_output",
+]);
+
+function requestFailureDescription(code) {
+  const timeoutPhase = Object.hasOwn(REQUEST_TIMEOUT_PHASES, code) ? REQUEST_TIMEOUT_PHASES[code] : "";
+  if (timeoutPhase) return {
+    title: `${timeoutPhase} timed out`,
+    reason: `${timeoutPhase} did not finish before its configured request deadline.`,
+    action: "Inspect retained results and tool effects before retrying. This request deadline is separate from the whole-run duration limit.",
+  };
+  if (REQUEST_OUTPUT_FAILURES.has(code)) return {
+    title: "The model response did not match the required format",
+    reason: "A model response could not be accepted under the request's required structure.",
+    action: "Inspect the step result and technical error. Review the model and its requested output format before trying again.",
+  };
+  if (code === "context_compaction_projection_not_reduced") return {
+    title: "Context could not be reduced",
+    reason: "Compaction did not reduce the model context enough to continue safely.",
+    action: "Reduce the step's inputs or use a model with more context capacity before trying again.",
+  };
+  return {
+    title: "The step could not finish",
+    reason: "This view cannot explain the recorded error.",
+    action: "Inspect the step result and the technical error in Diagnostics before retrying.",
+  };
+}
+
+function normalizeFailureCode(error) {
+  if (typeof error !== "string") return "";
+  return error.replace(/^Error: /, "");
+}
+
+function recordedCallUsage(used, limit, label) {
+  const count = Number.isSafeInteger(used) && used >= 0 ? String(used) : "Not recorded";
+  if (!Number.isSafeInteger(limit) || limit <= 0) return `${label}: ${count}`;
+  return `${label}: ${count} · Published limit: ${limit}`;
+}
+
+function failureUsage(code, run) {
+  const limits = run?.definition?.limits;
+  if (code === "automation_model_call_limit_reached")
+    return recordedCallUsage(run?.report?.modelCalls, limits?.maxModelCallsPerRun, "Model calls admitted");
+  if (code === "automation_tool_call_limit_reached")
+    return recordedCallUsage(run?.report?.toolAttempts, limits?.maxToolCallsPerRun, "Tool attempts admitted");
+  if (code !== "automation_run_duration_exceeded") return "";
+  const limit = limits?.maxRunDurationMs;
+  if (!Number.isSafeInteger(limit) || limit <= 0) return "";
+  return `Published run duration limit: ${limit / 1000} seconds`;
+}
+
+export function automationFailurePresentation(error, run = null) {
+  const code = normalizeFailureCode(error);
+  const description = Object.hasOwn(FAILURE_DESCRIPTIONS, code)
+    ? FAILURE_DESCRIPTIONS[code] : requestFailureDescription(code);
+  return { ...description, usage: failureUsage(code, run) };
+}
+
+export function renderAutomationFailure(error, run = null, stepTitle = "") {
+  if (!error) return "";
+  const failure = automationFailurePresentation(error, run);
+  return `<section class="automation-failure-notice" aria-label="Failure reason"><h4>${escapeHtml(failure.title)}</h4>
+    ${stepTitle ? `<p class="automation-failure-step" dir="auto">${escapeHtml(stepTitle)}</p>` : ""}
+    <p>${escapeHtml(failure.reason)}</p>${failure.usage ? `<p class="automation-failure-usage">${escapeHtml(failure.usage)}</p>` : ""}
+    <p class="automation-failure-action">${escapeHtml(failure.action)}</p></section>`;
+}
+
+function isRunWideAutomationFailure(code) {
+  if (!Object.hasOwn(FAILURE_DESCRIPTIONS, code)) return false;
+  return FAILURE_DESCRIPTIONS[code].scope === "run";
+}
+
+function hasMatchingFailedStepCause(record, code) {
+  if (record.status !== "failed") return false;
+  return normalizeFailureCode(record.errorCode) === code;
+}
+
+const OUTCOME_FAILURE_STATUSES = {
+  failed: ["failed", "interrupted"],
+  interrupted: ["interrupted", "failed"],
+  cancelled: ["interrupted", "cancelled"],
+  completed_with_skips: ["skipped"],
+};
+
+function isCompatibleUncertainStep(record, statuses) {
+  if (normalizeFailureCode(record.errorCode) !== "automation_effect_uncertain") return false;
+  return statuses.includes(record.status);
+}
+
+function hasStepFailureAtStatus(record, status) {
+  if (record.status !== status) return false;
+  return Boolean(normalizeFailureCode(record.errorCode));
+}
+
+function findRunFailureStep(records, error, outcome) {
+  const code = normalizeFailureCode(error);
+  if (isRunWideAutomationFailure(code)) return null;
+  if (code) return records.find((record) => hasMatchingFailedStepCause(record, code));
+  const statuses = Object.hasOwn(OUTCOME_FAILURE_STATUSES, outcome) ? OUTCOME_FAILURE_STATUSES[outcome] : [];
+  const uncertain = records.find((record) => isCompatibleUncertainStep(record, statuses));
+  if (uncertain) return uncertain;
+  for (const status of statuses) {
+    const step = records.find((record) => hasStepFailureAtStatus(record, status));
+    if (step) return step;
+  }
+  return null;
+}
+
+export function automationRunFailureCause(run) {
+  if (!run) return null;
+  const outcome = run.report?.outcome || run.status;
+  if (["pending", "running", "stopping", "succeeded"].includes(outcome)) return null;
+  const records = Array.isArray(run.report?.nodeResults) ? run.report.nodeResults : run.nodes || [];
+  const step = findRunFailureStep(records, run.error, outcome);
+  const error = run.error || step?.errorCode || "";
+  const stepTitle = isRunWideAutomationFailure(normalizeFailureCode(error)) ? "" : step?.title || "";
+  return { error, stepTitle };
+}
+
+export function renderAutomationRunFailure(run) {
+  const cause = automationRunFailureCause(run);
+  if (!cause) return "";
+  return renderAutomationFailure(cause.error || "automation_failure_cause_not_recorded", run, cause.stepTitle);
+}

package/dist/src/web-ui/app/components/automations/library-tabs.js

@@ -0,0 +1,45 @@
+import { escapeHtml } from "../../lib/text-format.js";
+import { renderAutomationTemplateGallery } from "./template-gallery.js";
+
+const tabs = ["studio", "templates"];
+
+export function automationLibraryTabForKey(key, index) {
+  if (key === "Home") return tabs[0];
+  if (key === "End") return tabs.at(-1);
+  if (key === "ArrowRight") return tabs[(index + 1) % tabs.length];
+  if (key === "ArrowLeft") return tabs[(index + tabs.length - 1) % tabs.length];
+  return "";
+}
+
+export function renderAutomationLibraryTabs(snapshot, studioMarkup, activeTab = "studio") {
+  const selected = tabs.includes(activeTab) ? activeTab : "studio";
+  const tabButton = (name, label) => `<button id="automation-${name}-tab" class="config-category-tab${selected === name ? " active" : ""}" type="button" role="tab" data-automation-library-tab="${name}" aria-controls="automation-${name}-panel" aria-selected="${selected === name}" tabindex="${selected === name ? 0 : -1}">${label}</button>`;
+  return `<div class="config-dashboard automation-workspace-content">
+    <nav class="config-category-nav automation-workspace-nav" role="tablist" aria-label="ABot Studio views">
+      ${tabButton("studio", "Studio")}${tabButton("templates", "Templates")}
+    </nav>
+    <div class="config-category-panels">
+      <div id="automation-studio-panel" class="config-category-panel" role="tabpanel" aria-labelledby="automation-studio-tab" tabindex="0" data-automation-library-panel="studio"${selected === "studio" ? "" : " hidden"}>${studioMarkup}</div>
+      <div id="automation-templates-panel" class="config-category-panel" role="tabpanel" aria-labelledby="automation-templates-tab" tabindex="0" data-automation-library-panel="templates"${selected === "templates" ? "" : " hidden"}>
+        ${snapshot.error ? `<p class="automation-feedback" data-tone="error" role="status">${escapeHtml(snapshot.error)}</p>` : ""}
+        ${renderAutomationTemplateGallery(snapshot)}
+      </div>
+    </div>
+  </div>`;
+}
+
+export function activateAutomationLibraryTab(root, name, { focus = false } = {}) {
+  if (!tabs.includes(name)) return false;
+  for (const tabName of tabs) {
+    const button = root.querySelector(`[data-automation-library-tab="${tabName}"]`);
+    const panel = root.querySelector(`[data-automation-library-panel="${tabName}"]`);
+    if (!button || !panel) return false;
+    const active = tabName === name;
+    button.setAttribute("aria-selected", String(active));
+    button.setAttribute("tabindex", active ? "0" : "-1");
+    button.className = `config-category-tab${active ? " active" : ""}`;
+    panel.hidden = !active;
+    if (focus && active) button.focus();
+  }
+  return true;
+}