npm - @ryanfw/prompt-orchestration-pipeline - Versions diffs - 0.5.0 → 0.6.0 - Mend

@ryanfw/prompt-orchestration-pipeline 0.5.0 → 0.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (35) hide show

package/package.json +1 -1
package/src/components/JobCard.jsx +1 -1
package/src/components/JobDetail.jsx +45 -12
package/src/components/JobTable.jsx +40 -1
package/src/components/Layout.jsx +146 -22
package/src/components/PageSubheader.jsx +75 -0
package/src/components/UploadSeed.jsx +0 -70
package/src/components/ui/Logo.jsx +16 -0
package/src/core/config.js +145 -13
package/src/core/file-io.js +12 -27
package/src/core/pipeline-runner.js +13 -6
package/src/core/status-writer.js +63 -52
package/src/core/task-runner.js +61 -1
package/src/llm/index.js +97 -40
package/src/pages/Code.jsx +297 -0
package/src/pages/PipelineDetail.jsx +47 -8
package/src/pages/PromptPipelineDashboard.jsx +6 -53
package/src/providers/deepseek.js +17 -1
package/src/providers/openai.js +1 -1
package/src/ui/client/adapters/job-adapter.js +26 -2
package/src/ui/client/hooks/useJobDetailWithUpdates.js +0 -1
package/src/ui/client/index.css +6 -0
package/src/ui/client/index.html +1 -1
package/src/ui/client/main.jsx +2 -0
package/src/ui/dist/assets/{index-CxcrauYR.js → index-WgJUlSmE.js} +716 -307
package/src/ui/dist/assets/style-x0V-5m8e.css +62 -0
package/src/ui/dist/index.html +3 -3
package/src/ui/job-reader.js +0 -108
package/src/ui/server.js +54 -0
package/src/ui/sse-enhancer.js +0 -1
package/src/ui/transformers/list-transformer.js +32 -12
package/src/ui/transformers/status-transformer.js +11 -11
package/src/utils/token-cost-calculator.js +297 -0
package/src/utils/ui.jsx +4 -4
package/src/ui/dist/assets/style-D6K_oQ12.css +0 -62

package/src/ui/dist/index.html CHANGED Viewed

@@ -6,12 +6,12 @@
     <link rel="preconnect" href="https://fonts.googleapis.com" />
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link
-      href="https://fonts.googleapis.com/css2?family=Inter:wght@100..900&display=swap"
+      href="https://fonts.googleapis.com/css2?family=Lora:ital,wght@0,400..700;1,400..700&family=Source+Sans+3:ital,wght@0,200..900;1,200..900&display=swap"
       rel="stylesheet"
     />
     <title>Prompt Pipeline Dashboard</title>
-    <script type="module" crossorigin src="/assets/index-CxcrauYR.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/style-D6K_oQ12.css">
+    <script type="module" crossorigin src="/assets/index-WgJUlSmE.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/style-x0V-5m8e.css">
   </head>
   <body>
     <div id="root"></div>

package/src/ui/job-reader.js CHANGED Viewed

@@ -5,7 +5,6 @@
  *  - readJob(jobId)
  *  - readMultipleJobs(jobIds)
  *  - getJobReadingStats(jobIds, results)
- *  - validateJobData(jobData, expectedJobId)
  *
  * Uses config-bridge for paths/constants and file-reader for safe file I/O.
  */
@@ -44,14 +43,6 @@ export async function readJob(jobId) {
       `readJob: will check lock at ${jobDir} and attempt to read ${tasksPath}`
     );
-    // Check locks with retry
-    const maxLockAttempts =
-      configBridge.Constants?.RETRY_CONFIG?.MAX_ATTEMPTS ?? 3;
-    const configuredDelay =
-      configBridge.Constants?.RETRY_CONFIG?.DELAY_MS ?? 50;
-    // Cap lock retry delay during tests to avoid long waits; use small bound for responsiveness
-    const lockDelay = Math.min(configuredDelay, 20);
     // Check lock with a small, deterministic retry loop.
     // Tests mock isLocked to return true once then false; this loop allows that behavior.
     // Single-check lock flow with one re-check after a short wait.
@@ -173,102 +164,3 @@ export function getJobReadingStats(jobIds = [], results = []) {
     locations,
   };
 }
-/**
- * Validate job data conforms to minimal schema and expected job id.
- * Supports both legacy (id, name, tasks) and canonical (jobId, title, tasksStatus) fields.
- * Returns { valid: boolean, warnings: string[], error?: string }
- */
-export function validateJobData(jobData, expectedJobId) {
-  const warnings = [];
-  if (
-    jobData === null ||
-    typeof jobData !== "object" ||
-    Array.isArray(jobData)
-  ) {
-    return { valid: false, error: "Job data must be an object" };
-  }
-  // Support both legacy and canonical field names
-  const hasLegacyId = "id" in jobData;
-  const hasCanonicalId = "jobId" in jobData;
-  const hasLegacyName = "name" in jobData;
-  const hasCanonicalName = "title" in jobData;
-  const hasLegacyTasks = "tasks" in jobData;
-  const hasCanonicalTasks = "tasksStatus" in jobData;
-  // Required: at least one ID field
-  if (!hasLegacyId && !hasCanonicalId) {
-    return { valid: false, error: "Missing required field: id or jobId" };
-  }
-  // Required: at least one name field
-  if (!hasLegacyName && !hasCanonicalName) {
-    return { valid: false, error: "Missing required field: name or title" };
-  }
-  // Required: createdAt
-  if (!("createdAt" in jobData)) {
-    return { valid: false, error: "Missing required field: createdAt" };
-  }
-  // Required: at least one tasks field
-  if (!hasLegacyTasks && !hasCanonicalTasks) {
-    return {
-      valid: false,
-      error: "Missing required field: tasks or tasksStatus",
-    };
-  }
-  // Get actual ID for validation
-  const actualId = jobData.jobId ?? jobData.id;
-  if (actualId !== expectedJobId) {
-    warnings.push("Job ID mismatch");
-    console.warn(
-      `Job ID mismatch: expected ${expectedJobId}, found ${actualId}`
-    );
-  }
-  // Validate tasks (prefer canonical, fallback to legacy)
-  const tasks = jobData.tasksStatus ?? jobData.tasks;
-  if (typeof tasks !== "object" || tasks === null || Array.isArray(tasks)) {
-    return { valid: false, error: "Tasks must be an object" };
-  }
-  const validStates = configBridge.Constants?.TASK_STATES || [
-    "pending",
-    "running",
-    "done",
-    "error",
-  ];
-  for (const [taskName, task] of Object.entries(tasks)) {
-    if (!task || typeof task !== "object") {
-      return { valid: false, error: `Task ${taskName} missing state field` };
-    }
-    if (!("state" in task)) {
-      return { valid: false, error: `Task ${taskName} missing state field` };
-    }
-    const state = task.state;
-    if (!validStates.includes(state)) {
-      warnings.push(`Unknown state: ${state}`);
-      console.warn(`Unknown task state for ${taskName}: ${state}`);
-    }
-  }
-  // Add warnings for legacy field usage
-  if (hasLegacyId && hasCanonicalId) {
-    warnings.push("Both id and jobId present, using jobId");
-  }
-  if (hasLegacyName && hasCanonicalName) {
-    warnings.push("Both name and title present, using title");
-  }
-  if (hasLegacyTasks && hasCanonicalTasks) {
-    warnings.push("Both tasks and tasksStatus present, using tasksStatus");
-  }
-  return { valid: true, warnings };
-}

package/src/ui/server.js CHANGED Viewed

@@ -1072,6 +1072,11 @@ function createServer() {
       `http://${req.headers.host}`
     );
+    // DEBUG: Log all API requests
+    if (pathname.startsWith("/api/")) {
+      console.log(`DEBUG: API Request: ${req.method} ${pathname}`);
+    }
     // CORS headers for API endpoints
     if (pathname.startsWith("/api/")) {
       // Important for tests: avoid idle keep-alive sockets on short API calls
@@ -1404,6 +1409,55 @@ function createServer() {
       return;
     }
+    // Route: GET /api/llm/functions
+    if (pathname === "/api/llm/functions" && req.method === "GET") {
+      try {
+        const { getConfig } = await import("../core/config.js");
+        const config = getConfig();
+        // Helper to convert model alias to camelCase function name
+        const toCamelCase = (alias) => {
+          const [provider, ...modelParts] = alias.split(":");
+          const model = modelParts.join("-");
+          const camelModel = model.replace(/-([a-z0-9])/g, (match, char) =>
+            char.toUpperCase()
+          );
+          return camelModel;
+        };
+        // Filter for deepseek, openai only (no gemini provider exists)
+        const targetProviders = ["deepseek", "openai"];
+        const functions = {};
+        for (const [alias, modelConfig] of Object.entries(config.llm.models)) {
+          const { provider } = modelConfig;
+          if (!targetProviders.includes(provider)) continue;
+          if (!functions[provider]) {
+            functions[provider] = [];
+          }
+          const functionName = toCamelCase(alias);
+          functions[provider].push({
+            alias,
+            functionName,
+            fullPath: `llm.${provider}.${functionName}`,
+            model: modelConfig.model,
+          });
+        }
+        sendJson(res, 200, functions);
+      } catch (error) {
+        console.error("Error handling /api/llm/functions:", error);
+        sendJson(res, 500, {
+          ok: false,
+          error: "internal_error",
+          message: "Failed to get LLM functions",
+        });
+      }
+      return;
+    }
     // Route: GET /api/jobs/:jobId
     if (pathname.startsWith("/api/jobs/") && req.method === "GET") {
       const jobId = pathname.substring("/api/jobs/".length);

package/src/ui/sse-enhancer.js CHANGED Viewed

@@ -14,7 +14,6 @@
  *  - cleanup() clears timers
  */
-import { detectJobChange } from "./job-change-detector.js";
 import { transformJobStatus } from "./transformers/status-transformer.js";
 import { transformJobListForAPI } from "./transformers/list-transformer.js";

package/src/ui/transformers/list-transformer.js CHANGED Viewed

@@ -250,28 +250,48 @@ export function transformJobListForAPI(jobs = [], options = {}) {
       base.currentStage = job.currentStage;
     }
-    if (job.tasksStatus && typeof job.tasksStatus === "object") {
-      // Include tasksStatus with all required fields for UI computation
-      const tasksStatus = {};
-      for (const [taskId, task] of Object.entries(job.tasksStatus)) {
+    if (job.tasks && typeof job.tasks === "object") {
+      // Include tasks with all required fields for UI computation
+      const tasks = {};
+      for (const [taskId, task] of Object.entries(job.tasks)) {
         if (task && typeof task === "object") {
-          tasksStatus[taskId] = {
+          tasks[taskId] = {
             state: task.state || "pending",
           };
           // Include optional fields if present
-          if (task.startedAt != null)
-            tasksStatus[taskId].startedAt = task.startedAt;
-          if (task.endedAt != null) tasksStatus[taskId].endedAt = task.endedAt;
+          if (task.startedAt != null) tasks[taskId].startedAt = task.startedAt;
+          if (task.endedAt != null) tasks[taskId].endedAt = task.endedAt;
           if (task.executionTimeMs != null)
-            tasksStatus[taskId].executionTimeMs = task.executionTimeMs;
+            tasks[taskId].executionTimeMs = task.executionTimeMs;
           if (task.currentStage != null)
-            tasksStatus[taskId].currentStage = task.currentStage;
+            tasks[taskId].currentStage = task.currentStage;
           if (task.failedStage != null)
-            tasksStatus[taskId].failedStage = task.failedStage;
+            tasks[taskId].failedStage = task.failedStage;
         }
       }
-      base.tasksStatus = tasksStatus;
+      base.tasks = tasks;
+    }
+    // Add costs summary with zeroed structure if job.costs is absent
+    if (job.costs && job.costs.summary) {
+      base.costsSummary = {
+        totalTokens: job.costs.summary.totalTokens || 0,
+        totalInputTokens: job.costs.summary.totalInputTokens || 0,
+        totalOutputTokens: job.costs.summary.totalOutputTokens || 0,
+        totalCost: job.costs.summary.totalCost || 0,
+        totalInputCost: job.costs.summary.totalInputCost || 0,
+        totalOutputCost: job.costs.summary.totalOutputCost || 0,
+      };
+    } else {
+      base.costsSummary = {
+        totalTokens: 0,
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        totalCost: 0,
+        totalInputCost: 0,
+        totalOutputCost: 0,
+      };
     }
     // Only include pipeline metadata if option is enabled

package/src/ui/transformers/status-transformer.js CHANGED Viewed

@@ -1,5 +1,9 @@
 import { normalizeTaskFiles } from "../../utils/task-files.js";
 import { derivePipelineMetadata } from "../../utils/pipelines.js";
+import {
+  calculateJobCosts,
+  formatCostDataForAPI,
+} from "../../utils/token-cost-calculator.js";
 const VALID_TASK_STATES = new Set(["pending", "running", "done", "failed"]);
@@ -168,7 +172,7 @@ export function transformTasks(rawTasks) {
  *  - createdAt / updatedAt: ISO strings | null
  *  - location: lifecycle bucket
  *  - current / currentStage: stage metadata (optional)
- *  - tasksStatus: object keyed by task name
+ *  - tasks: object keyed by task name
  *  - files: normalized job-level files
  */
 export function transformJobStatus(raw, jobId, location) {
@@ -189,17 +193,13 @@ export function transformJobStatus(raw, jobId, location) {
   const updatedAt = raw.updatedAt || raw.lastUpdated || createdAt || null;
   const resolvedLocation = location || raw.location || null;
-  // Support both canonical (tasksStatus) and legacy (tasks) schema
-  const tasksStatus = transformTasks(raw.tasksStatus || raw.tasks);
-  const jobStatusObj = computeJobStatus(tasksStatus, raw.progress);
+  const tasks = transformTasks(raw.tasks);
+  const jobStatusObj = computeJobStatus(tasks, raw.progress);
   const jobFiles = normalizeTaskFiles(raw.files);
-  // Convert tasksStatus object to tasks array for API compatibility
-  const tasks = Object.entries(tasksStatus).map(([name, task]) => ({
-    name,
-    ...task,
-  }));
+  // Calculate costs for this job
+  const costs = calculateJobCosts(raw);
+  const costData = formatCostDataForAPI(costs);
   const job = {
     id: jobId, // API expects 'id' not 'jobId'
@@ -211,9 +211,9 @@ export function transformJobStatus(raw, jobId, location) {
     createdAt,
     updatedAt,
     location: resolvedLocation,
-    tasksStatus, // Keep tasksStatus for backward compatibility
     tasks, // API expects 'tasks' array
     files: jobFiles,
+    costs: costData, // Add cost data to job response
   };
   if (raw.current != null) job.current = raw.current;

package/src/utils/token-cost-calculator.js ADDED Viewed

@@ -0,0 +1,297 @@
+/**
+ * Token usage and cost calculation utilities
+ *
+ * This module provides functions to calculate costs from token usage data
+ * by cross-referencing with LLM model pricing configuration.
+ */
+import { getConfig } from "../core/config.js";
+/**
+ * Calculate cost for a single token usage entry
+ * @param {Array} tokenUsageEntry - [modelKey, inputTokens, outputTokens]
+ * @param {Object} modelsConfig - LLM models configuration
+ * @returns {Object} Cost calculation result
+ */
+export function calculateSingleTokenCost(tokenUsageEntry, modelsConfig = null) {
+  if (!Array.isArray(tokenUsageEntry) || tokenUsageEntry.length < 3) {
+    return {
+      modelKey: null,
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0,
+      inputCost: 0,
+      outputCost: 0,
+      totalCost: 0,
+    };
+  }
+  const [modelKey, inputTokens, outputTokens] = tokenUsageEntry;
+  // Get models config if not provided
+  const config = modelsConfig || getConfig()?.llm?.models || {};
+  const modelConfig = config[modelKey];
+  if (!modelConfig) {
+    console.warn(
+      `[token-cost-calculator] Model configuration not found for: ${modelKey}`
+    );
+    return {
+      modelKey,
+      inputTokens: Number(inputTokens) || 0,
+      outputTokens: Number(outputTokens) || 0,
+      totalTokens: (Number(inputTokens) || 0) + (Number(outputTokens) || 0),
+      inputCost: 0,
+      outputCost: 0,
+      totalCost: 0,
+    };
+  }
+  const inputCost =
+    ((Number(inputTokens) || 0) * (modelConfig.tokenCostInPerMillion || 0)) /
+    1_000_000;
+  const outputCost =
+    ((Number(outputTokens) || 0) * (modelConfig.tokenCostOutPerMillion || 0)) /
+    1_000_000;
+  const totalCost = inputCost + outputCost;
+  return {
+    modelKey,
+    inputTokens: Number(inputTokens) || 0,
+    outputTokens: Number(outputTokens) || 0,
+    totalTokens: (Number(inputTokens) || 0) + (Number(outputTokens) || 0),
+    inputCost: Math.round(inputCost * 10000) / 10000, // Round to 4 decimal places
+    outputCost: Math.round(outputCost * 10000) / 10000,
+    totalCost: Math.round(totalCost * 10000) / 10000,
+    provider: modelConfig.provider,
+    model: modelConfig.model,
+  };
+}
+/**
+ * Calculate costs for multiple token usage entries
+ * @param {Array} tokenUsageArray - Array of [modelKey, inputTokens, outputTokens] entries
+ * @param {Object} modelsConfig - LLM models configuration
+ * @returns {Object} Aggregated cost calculation
+ */
+export function calculateMultipleTokenCosts(
+  tokenUsageArray,
+  modelsConfig = null
+) {
+  if (!Array.isArray(tokenUsageArray) || tokenUsageArray.length === 0) {
+    return {
+      entries: [],
+      summary: {
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        totalTokens: 0,
+        totalInputCost: 0,
+        totalOutputCost: 0,
+        totalCost: 0,
+        modelBreakdown: {},
+      },
+    };
+  }
+  const entries = tokenUsageArray.map((entry) =>
+    calculateSingleTokenCost(entry, modelsConfig)
+  );
+  // Aggregate totals
+  const summary = entries.reduce(
+    (acc, entry) => {
+      acc.totalInputTokens += entry.inputTokens;
+      acc.totalOutputTokens += entry.outputTokens;
+      acc.totalTokens += entry.totalTokens;
+      acc.totalInputCost += entry.inputCost;
+      acc.totalOutputCost += entry.outputCost;
+      acc.totalCost += entry.totalCost;
+      // Model breakdown
+      const modelKey = entry.modelKey;
+      if (!acc.modelBreakdown[modelKey]) {
+        acc.modelBreakdown[modelKey] = {
+          provider: entry.provider,
+          model: entry.model,
+          inputTokens: 0,
+          outputTokens: 0,
+          totalTokens: 0,
+          inputCost: 0,
+          outputCost: 0,
+          totalCost: 0,
+          requestCount: 0,
+        };
+      }
+      const breakdown = acc.modelBreakdown[modelKey];
+      breakdown.inputTokens += entry.inputTokens;
+      breakdown.outputTokens += entry.outputTokens;
+      breakdown.totalTokens += entry.totalTokens;
+      breakdown.inputCost += entry.inputCost;
+      breakdown.outputCost += entry.outputCost;
+      breakdown.totalCost += entry.totalCost;
+      breakdown.requestCount += 1;
+      return acc;
+    },
+    {
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalTokens: 0,
+      totalInputCost: 0,
+      totalOutputCost: 0,
+      totalCost: 0,
+      modelBreakdown: {},
+    }
+  );
+  // Round all cost values in summary
+  summary.totalInputCost = Math.round(summary.totalInputCost * 10000) / 10000;
+  summary.totalOutputCost = Math.round(summary.totalOutputCost * 10000) / 10000;
+  summary.totalCost = Math.round(summary.totalCost * 10000) / 10000;
+  // Round model breakdown costs
+  Object.values(summary.modelBreakdown).forEach((breakdown) => {
+    breakdown.inputCost = Math.round(breakdown.inputCost * 10000) / 10000;
+    breakdown.outputCost = Math.round(breakdown.outputCost * 10000) / 10000;
+    breakdown.totalCost = Math.round(breakdown.totalCost * 10000) / 10000;
+  });
+  return { entries, summary };
+}
+/**
+ * Extract and calculate token usage costs from tasks-status.json data
+ * @param {Object} tasksStatus - The tasks-status.json content
+ * @param {string} taskName - Optional specific task name to calculate for
+ * @returns {Object} Cost calculation for entire job or specific task
+ */
+export function calculateJobCosts(tasksStatus, taskName = null) {
+  if (!tasksStatus || typeof tasksStatus !== "object") {
+    return {
+      jobLevel: {
+        entries: [],
+        summary: {
+          totalInputTokens: 0,
+          totalOutputTokens: 0,
+          totalTokens: 0,
+          totalInputCost: 0,
+          totalOutputCost: 0,
+          totalCost: 0,
+          modelBreakdown: {},
+        },
+      },
+      tasksLevel: {},
+    };
+  }
+  const tasks = tasksStatus.tasks || {};
+  // If specific task requested, calculate only for that task
+  if (taskName && tasks[taskName]) {
+    const taskTokenUsage = tasks[taskName].tokenUsage || [];
+    const taskCosts = calculateMultipleTokenCosts(taskTokenUsage);
+    return {
+      jobLevel: taskCosts,
+      tasksLevel: {
+        [taskName]: taskCosts,
+      },
+    };
+  }
+  // Calculate for all tasks
+  const tasksLevel = {};
+  const allEntries = [];
+  const allTuples = [];
+  for (const [currentTaskName, taskData] of Object.entries(tasks)) {
+    const taskTokenUsage = taskData.tokenUsage || [];
+    const taskCosts = calculateMultipleTokenCosts(taskTokenUsage);
+    tasksLevel[currentTaskName] = taskCosts;
+    allEntries.push(...taskCosts.entries);
+    allTuples.push(...taskTokenUsage);
+  }
+  // Calculate job-level aggregation from raw tuples
+  const jobLevel = calculateMultipleTokenCosts(allTuples);
+  return {
+    jobLevel,
+    tasksLevel,
+  };
+}
+/**
+ * Format cost data for API response
+ * @param {Object} costData - Cost calculation data
+ * @returns {Object} Formatted cost data for API
+ */
+export function formatCostDataForAPI(costData) {
+  const { jobLevel, tasksLevel } = costData;
+  return {
+    summary: {
+      totalInputTokens: jobLevel.summary.totalInputTokens,
+      totalOutputTokens: jobLevel.summary.totalOutputTokens,
+      totalTokens: jobLevel.summary.totalTokens,
+      totalInputCost: jobLevel.summary.totalInputCost,
+      totalOutputCost: jobLevel.summary.totalOutputCost,
+      totalCost: jobLevel.summary.totalCost,
+    },
+    modelBreakdown: jobLevel.summary.modelBreakdown,
+    taskBreakdown: Object.entries(tasksLevel).reduce(
+      (acc, [taskName, taskData]) => {
+        acc[taskName] = {
+          summary: taskData.summary,
+          entries: taskData.entries,
+        };
+        return acc;
+      },
+      {}
+    ),
+  };
+}
+/**
+ * Get model pricing information
+ * @param {string} modelKey - Model key (e.g., "openai:gpt-5-mini")
+ * @returns {Object|null} Model pricing information
+ */
+export function getModelPricing(modelKey) {
+  const config = getConfig()?.llm?.models || {};
+  const modelConfig = config[modelKey];
+  if (!modelConfig) {
+    return null;
+  }
+  return {
+    modelKey,
+    provider: modelConfig.provider,
+    model: modelConfig.model,
+    inputCostPerMillion: modelConfig.tokenCostInPerMillion,
+    outputCostPerMillion: modelConfig.tokenCostOutPerMillion,
+  };
+}
+/**
+ * Get all available model pricing information
+ * @returns {Object} All model pricing information
+ */
+export function getAllModelPricing() {
+  const config = getConfig()?.llm?.models || {};
+  const pricing = {};
+  for (const [modelKey, modelConfig] of Object.entries(config)) {
+    pricing[modelKey] = {
+      modelKey,
+      provider: modelConfig.provider,
+      model: modelConfig.model,
+      inputCostPerMillion: modelConfig.tokenCostInPerMillion,
+      outputCostPerMillion: modelConfig.tokenCostOutPerMillion,
+    };
+  }
+  return pricing;
+}

package/src/utils/ui.jsx CHANGED Viewed

@@ -6,26 +6,26 @@ export const statusBadge = (status) => {
   switch (status) {
     case "running":
       return (
-        <Badge variant="info" aria-label="Running">
+        <Badge intent="blue" aria-label="Running">
           Running
         </Badge>
       );
     case "failed":
       return (
-        <Badge variant="error" aria-label="Failed">
+        <Badge intent="red" aria-label="Failed">
           Failed
         </Badge>
       );
     case "completed":
     case "complete":
       return (
-        <Badge variant="success" aria-label="Completed">
+        <Badge intent="green" aria-label="Completed">
           Completed
         </Badge>
       );
     case "pending":
       return (
-        <Badge variant="default" aria-label="Pending">
+        <Badge intent="gray" aria-label="Pending">
           Pending
         </Badge>
       );