@ryanfw/prompt-orchestration-pipeline 0.5.0 → 0.7.0

package/src/ui/client/adapters/job-adapter.js

@@ -1,17 +1,24 @@
 import { derivePipelineMetadata } from "../../../utils/pipelines.js";
-
-const ALLOWED_STATES = new Set(["pending", "running", "done", "failed"]);
+import {
+  normalizeTaskState,
+  deriveJobStatusFromTasks,
+} from "../../../config/statuses.js";
 
 /**
  * Normalize a raw task state into canonical enum.
  * Returns { state, warning? } where warning is a string if normalization occurred.
  */
-function normalizeTaskState(raw) {
+function normalizeTaskStateWithWarning(raw) {
   if (!raw || typeof raw !== "string")
     return { state: "pending", warning: "missing_state" };
-  const s = raw.toLowerCase();
-  if (ALLOWED_STATES.has(s)) return { state: s };
-  return { state: "pending", warning: `unknown_state:${raw}` };
+
+  const normalizedState = normalizeTaskState(raw);
+
+  if (raw !== normalizedState) {
+    return { state: normalizedState, warning: `unknown_state:${raw}` };
+  }
+
+  return { state: normalizedState };
 }
 
 /**
@@ -28,7 +35,7 @@ function normalizeTasks(rawTasks) {
     // Object shape - canonical format
     const tasks = {};
     Object.entries(rawTasks).forEach(([name, t]) => {
-      const ns = normalizeTaskState(t && t.state);
+      const ns = normalizeTaskStateWithWarning(t && t.state);
       if (ns.warning) warnings.push(`${name}:${ns.warning}`);
       const taskObj = {
         name,
@@ -66,6 +73,8 @@ function normalizeTasks(rawTasks) {
         artifacts: Array.isArray(t && t.artifacts)
           ? t.artifacts.slice()
           : undefined,
+        // Preserve tokenUsage if present
+        ...(t && t.tokenUsage ? { tokenUsage: t.tokenUsage } : {}),
       };
       tasks[name] = taskObj;
     });
@@ -77,7 +86,7 @@ function normalizeTasks(rawTasks) {
     const tasks = {};
     rawTasks.forEach((t, idx) => {
       const name = t && t.name ? String(t.name) : `task-${idx}`;
-      const ns = normalizeTaskState(t && t.state);
+      const ns = normalizeTaskStateWithWarning(t && t.state);
       if (ns.warning) warnings.push(`${name}:${ns.warning}`);
       tasks[name] = {
         name,
@@ -100,6 +109,8 @@ function normalizeTasks(rawTasks) {
         artifacts: Array.isArray(t && t.artifacts)
           ? t.artifacts.slice()
           : undefined,
+        // Preserve tokenUsage if present
+        ...(t && t.tokenUsage ? { tokenUsage: t.tokenUsage } : {}),
       };
     });
     return { tasks, warnings };
@@ -108,23 +119,6 @@ function normalizeTasks(rawTasks) {
   return { tasks: {}, warnings: ["invalid_tasks_shape"] };
 }
 
-/**
- * Derive status from tasks when status is missing/invalid.
- * Rules:
- * - failed if any task state === 'failed'
- * - running if >=1 running and none failed
- * - complete if all done
- * - pending otherwise
- */
-function deriveStatusFromTasks(tasks) {
-  const taskList = Object.values(tasks);
-  if (!Array.isArray(taskList) || taskList.length === 0) return "pending";
-  if (taskList.some((t) => t.state === "failed")) return "failed";
-  if (taskList.some((t) => t.state === "running")) return "running";
-  if (taskList.every((t) => t.state === "done")) return "complete";
-  return "pending";
-}
-
 /**
  * Clamp number to 0..100 and ensure integer.
  */
@@ -143,7 +137,7 @@ function computeJobSummaryStats(tasks) {
     (acc, t) => acc + (t.state === "done" ? 1 : 0),
     0
   );
-  const status = deriveStatusFromTasks(tasks);
+  const status = deriveJobStatusFromTasks(Object.values(tasks));
   const progress =
     taskCount > 0 ? Math.round((doneCount / taskCount) * 100) : 0;
   return { status, progress, doneCount, taskCount };
@@ -158,7 +152,7 @@ export function adaptJobSummary(apiJob) {
   // Demo-only: read canonical fields strictly
   const id = apiJob.jobId;
   const name = apiJob.title || "";
-  const rawTasks = apiJob.tasksStatus;
+  const rawTasks = apiJob.tasks;
   const location = apiJob.location;
 
   // Job-level stage metadata
@@ -197,6 +191,21 @@ export function adaptJobSummary(apiJob) {
   if (pipeline != null) job.pipeline = pipeline;
   if (pipelineLabel != null) job.pipelineLabel = pipelineLabel;
 
+  // Costs summary from API
+  if (apiJob.costsSummary) {
+    job.costsSummary = {
+      totalTokens: apiJob.costsSummary.totalTokens || 0,
+      totalInputTokens: apiJob.costsSummary.totalInputTokens || 0,
+      totalOutputTokens: apiJob.costsSummary.totalOutputTokens || 0,
+      totalCost: apiJob.costsSummary.totalCost || 0,
+      totalInputCost: apiJob.costsSummary.totalInputCost || 0,
+      totalOutputCost: apiJob.costsSummary.totalOutputCost || 0,
+    };
+    // Add top-level numeric mirrors for convenience
+    job.totalCost = job.costsSummary.totalCost;
+    job.totalTokens = job.costsSummary.totalTokens;
+  }
+
   // Include warnings for debugging
   if (warnings.length > 0) job.__warnings = warnings;
 
@@ -212,7 +221,7 @@ export function adaptJobDetail(apiDetail) {
   // Demo-only: read canonical fields strictly
   const id = apiDetail.jobId;
   const name = apiDetail.title || "";
-  const rawTasks = apiDetail.tasksStatus;
+  const rawTasks = apiDetail.tasks;
   const location = apiDetail.location;
 
   // Job-level stage metadata
@@ -251,6 +260,11 @@ export function adaptJobDetail(apiDetail) {
   if (pipeline != null) detail.pipeline = pipeline;
   if (pipelineLabel != null) detail.pipelineLabel = pipelineLabel;
 
+  // Preserve job detail costs
+  if (apiDetail.costs) {
+    detail.costs = apiDetail.costs;
+  }
+
   // Include warnings for debugging
   if (warnings.length > 0) detail.__warnings = warnings;
 

package/src/ui/client/api.js

@@ -0,0 +1,134 @@
+/**
+ * Client-side API helpers for making HTTP requests to the backend
+ */
+
+/**
+ * Restart a job with clean-slate mode
+ *
+ * @param {string} jobId - The ID of the job to restart
+ * @param {Object} opts - Options object
+ * @param {Object} opts.options - Additional options for the restart
+ * @param {boolean} opts.options.clearTokenUsage - Whether to clear token usage (default: true)
+ * @returns {Promise<Object>} Parsed JSON response from the server
+ * @throws {Object} Structured error object with { code, message } for non-2xx responses
+ */
+export async function restartJob(jobId, opts = {}) {
+  const options = {
+    clearTokenUsage: true,
+    ...opts.options,
+  };
+
+  const requestBody = opts.fromTask
+    ? { fromTask: opts.fromTask, options }
+    : { mode: "clean-slate", options };
+
+  try {
+    const response = await fetch(
+      `/api/jobs/${encodeURIComponent(jobId)}/restart`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(requestBody),
+      }
+    );
+
+    if (!response.ok) {
+      // Try to parse error response, fall back to status text if parsing fails
+      let errorData;
+      try {
+        errorData = await response.json();
+      } catch {
+        errorData = { message: response.statusText };
+      }
+
+      // Throw structured error with code and message
+      throw {
+        code: errorData.code || getErrorCodeFromStatus(response.status),
+        message: getRestartErrorMessage(errorData, response.status),
+        status: response.status,
+      };
+    }
+
+    // Return parsed JSON for successful responses
+    return await response.json();
+  } catch (error) {
+    // Re-throw structured errors as-is
+    if (error.code && error.message) {
+      throw error;
+    }
+
+    // Handle network errors or other unexpected errors
+    throw {
+      code: "network_error",
+      message: error.message || "Failed to connect to server",
+    };
+  }
+}
+
+/**
+ * Map HTTP status codes to error codes for structured error handling
+ */
+function getErrorCodeFromStatus(status) {
+  switch (status) {
+    case 404:
+      return "job_not_found";
+    case 409:
+      return "conflict";
+    case 500:
+      return "spawn_failed";
+    default:
+      return "unknown_error";
+  }
+}
+
+/**
+ * Map HTTP status codes to error messages for structured error handling
+ */
+function getErrorMessageFromStatus(status) {
+  switch (status) {
+    case 404:
+      return "Job not found";
+    case 409:
+      return "Job restart conflict";
+    case 500:
+      return "Failed to start restart";
+    default:
+      return `Request failed with status ${status}`;
+  }
+}
+
+/**
+ * Get specific error message from error response for restart functionality
+ */
+function getRestartErrorMessage(errorData, status) {
+  // Handle specific 409 conflict errors
+  if (status === 409) {
+    if (errorData.code === "job_running") {
+      return "Job is currently running; restart is unavailable.";
+    }
+    if (errorData.code === "unsupported_lifecycle") {
+      return "Job must be in current to restart.";
+    }
+    if (errorData.message?.includes("job_running")) {
+      return "Job is currently running; restart is unavailable.";
+    }
+    if (errorData.message?.includes("unsupported_lifecycle")) {
+      return "Job must be in current to restart.";
+    }
+  }
+
+  // Handle 404 errors
+  if (status === 404) {
+    return "Job not found.";
+  }
+
+  // Handle 500 errors
+  if (status === 500) {
+    return "Failed to start restart. Try again.";
+  }
+
+  // Fall back to provided message or default
+  return errorData.message || "Failed to restart job.";
+}