@ryanfw/prompt-orchestration-pipeline 0.5.0 → 0.6.0

package/src/core/config.js

@@ -182,39 +182,171 @@ export const defaultConfig = {
     llmRequestTimeout: 60000,
   },
   llm: {
-    defaultProvider: "openai",
-    defaultModel: "gpt-5-chat-latest",
+    defaultProvider: "deepseek",
+    defaultModel: "chat",
     maxConcurrency: 5,
     retryMaxAttempts: 3,
     retryBackoffMs: 1000,
     models: {
+      // DeepSeek (2025)
+      "deepseek:chat": {
+        provider: "deepseek",
+        model: "deepseek-chat", // V3.2 Exp (non-thinking) under the hood
+        tokenCostInPerMillion: 0.27,
+        tokenCostOutPerMillion: 1.1,
+      },
+      "deepseek:reasoner": {
+        provider: "deepseek",
+        model: "deepseek-reasoner", // R1 family
+        tokenCostInPerMillion: 0.55,
+        tokenCostOutPerMillion: 2.19,
+      },
+
+      // — OpenAI (2024 legacy still callable) —
       "openai:gpt-4": {
         provider: "openai",
         model: "gpt-4",
+        tokenCostInPerMillion: 30.0,
+        tokenCostOutPerMillion: 60.0,
       },
       "openai:gpt-4-turbo": {
         provider: "openai",
         model: "gpt-4-turbo",
+        tokenCostInPerMillion: 10.0,
+        tokenCostOutPerMillion: 30.0,
       },
+
+      // — OpenAI (2025) —
       "openai:gpt-5": {
         provider: "openai",
-        model: "gpt-5-chat-latest",
+        model: "gpt-5-chat-latest", // alias tracks GPT-5 pricing
+        tokenCostInPerMillion: 1.25,
+        tokenCostOutPerMillion: 10.0,
       },
-      "deepseek:reasoner": {
-        provider: "deepseek",
-        model: "deepseek-reasoner",
+
+      "openai:gpt-5-core": {
+        provider: "openai",
+        model: "gpt-5", // flagship
+        tokenCostInPerMillion: 1.25,
+        tokenCostOutPerMillion: 10.0,
       },
-      "deepseek:chat": {
-        provider: "deepseek",
-        model: "deepseek-chat",
+      "openai:gpt-5-chat": {
+        provider: "openai",
+        model: "gpt-5-chat-latest", // Chat variant
+        tokenCostInPerMillion: 1.25,
+        tokenCostOutPerMillion: 10.0,
+      },
+      "openai:gpt-5-pro": {
+        provider: "openai",
+        model: "gpt-5-pro", // higher-compute tier
+        tokenCostInPerMillion: 15.0,
+        tokenCostOutPerMillion: 120.0,
+      },
+      "openai:gpt-5-mini": {
+        provider: "openai",
+        model: "gpt-5-mini",
+        tokenCostInPerMillion: 0.25,
+        tokenCostOutPerMillion: 2.0,
+      },
+      "openai:gpt-5-nano": {
+        provider: "openai",
+        model: "gpt-5-nano",
+        tokenCostInPerMillion: 0.05,
+        tokenCostOutPerMillion: 0.4,
+      },
+
+      // — Google Gemini (2025) —
+      "gemini:2.5-pro": {
+        provider: "google",
+        model: "gemini-2.5-pro", // ≤200k input tier shown; >200k is higher
+        tokenCostInPerMillion: 1.25,
+        tokenCostOutPerMillion: 10.0,
+      },
+      "gemini:2.5-flash": {
+        provider: "google",
+        model: "gemini-2.5-flash",
+        tokenCostInPerMillion: 0.3,
+        tokenCostOutPerMillion: 2.5,
+      },
+      "gemini:2.5-flash-lite": {
+        provider: "google",
+        model: "gemini-2.5-flash-lite",
+        tokenCostInPerMillion: 0.1,
+        tokenCostOutPerMillion: 0.4,
+      },
+      "gemini:2.5-flash-image": {
+        provider: "google",
+        model: "gemini-2.5-flash-image",
+        // Inputs follow 2.5 Flash text pricing; outputs are **image tokens** at $30/M (≈$0.039 per 1024² image)
+        tokenCostInPerMillion: 0.3,
+        tokenCostOutPerMillion: 30.0,
+      },
+
+      // — Z.ai (formerly Zhipu) —
+      "zai:glm-4.6": {
+        provider: "zai",
+        model: "GLM-4.6",
+        tokenCostInPerMillion: 0.6,
+        tokenCostOutPerMillion: 2.2,
+      },
+      "zai:glm-4.5": {
+        provider: "zai",
+        model: "GLM-4.5",
+        tokenCostInPerMillion: 0.6,
+        tokenCostOutPerMillion: 2.2,
+      },
+      "zai:glm-4.5-air": {
+        provider: "zai",
+        model: "GLM-4.5-Air",
+        tokenCostInPerMillion: 0.2,
+        tokenCostOutPerMillion: 1.1,
+      },
+
+      // — Anthropic —
+      // current (Claude 4.5 / 4.1)
+      "anthropic:sonnet-4-5": {
+        provider: "anthropic",
+        model: "claude-sonnet-4-5",
+        tokenCostInPerMillion: 3.0,
+        tokenCostOutPerMillion: 15.0,
+      },
+      "anthropic:haiku-4-5": {
+        provider: "anthropic",
+        model: "claude-haiku-4-5",
+        tokenCostInPerMillion: 1.0,
+        tokenCostOutPerMillion: 5.0,
+      },
+      "anthropic:opus-4-1": {
+        provider: "anthropic",
+        model: "claude-opus-4-1",
+        tokenCostInPerMillion: 15.0,
+        tokenCostOutPerMillion: 75.0,
+      },
+
+      // legacy / still available
+      "anthropic:sonnet-4": {
+        provider: "anthropic",
+        model: "claude-sonnet-4-0",
+        tokenCostInPerMillion: 3.0,
+        tokenCostOutPerMillion: 15.0,
+      },
+      "anthropic:sonnet-3-7": {
+        provider: "anthropic",
+        model: "claude-3-7-sonnet-20250219",
+        tokenCostInPerMillion: 3.0,
+        tokenCostOutPerMillion: 15.0,
       },
-      "anthropic:opus": {
+      "anthropic:opus-4": {
         provider: "anthropic",
-        model: "claude-3-opus",
+        model: "claude-opus-4-0",
+        tokenCostInPerMillion: 15.0,
+        tokenCostOutPerMillion: 75.0,
       },
-      "anthropic:sonnet": {
+      "anthropic:haiku-3-5": {
         provider: "anthropic",
-        model: "claude-3-sonnet",
+        model: "claude-3-5-haiku-20241022",
+        tokenCostInPerMillion: 0.8,
+        tokenCostOutPerMillion: 4.0,
       },
     },
   },

package/src/core/file-io.js

@@ -1,5 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+import { writeJobStatus } from "./status-writer.js";
 
 /**
  * Creates a task-scoped file I/O interface that manages file operations
@@ -30,41 +31,25 @@ export function createTaskFileIO({ workDir, taskName, getStage, statusPath }) {
    * Updates tasks-status.json with file information, ensuring de-duplication
    */
   async function updateStatusWithFiles(fileType, fileName) {
-    try {
-      const statusContent = await fs.readFile(statusPath, "utf8");
-      const status = JSON.parse(statusContent);
-
-      // Initialize files object if it doesn't exist
-      if (!status.files) {
-        status.files = { artifacts: [], logs: [], tmp: [] };
-      }
-
-      // Initialize task files if they don't exist
-      if (!status.tasks[taskName].files) {
-        status.tasks[taskName].files = { artifacts: [], logs: [], tmp: [] };
-      }
-
-      // Add to job-level files array (de-duped)
-      const jobArray = status.files[fileType];
+    const jobDir = path.dirname(statusPath);
+    await writeJobStatus(jobDir, (snapshot) => {
+      snapshot.files ||= { artifacts: [], logs: [], tmp: [] };
+      snapshot.tasks ||= {};
+      snapshot.tasks[taskName] ||= {};
+      snapshot.tasks[taskName].files ||= { artifacts: [], logs: [], tmp: [] };
+
+      const jobArray = snapshot.files[fileType];
       if (!jobArray.includes(fileName)) {
         jobArray.push(fileName);
       }
 
-      // Add to task-level files array (de-duped)
-      const taskArray = status.tasks[taskName].files[fileType];
+      const taskArray = snapshot.tasks[taskName].files[fileType];
       if (!taskArray.includes(fileName)) {
         taskArray.push(fileName);
       }
 
-      // Write back to file atomically
-      await atomicWrite(statusPath, JSON.stringify(status, null, 2));
-    } catch (error) {
-      // If status file doesn't exist or is invalid, we'll log but not fail
-      console.warn(
-        `Failed to update status with file ${fileName}:`,
-        error.message
-      );
-    }
+      return snapshot;
+    });
   }
 
   /**

package/src/core/pipeline-runner.js

@@ -4,6 +4,7 @@ import { runPipeline } from "./task-runner.js";
 import { loadFreshModule } from "./module-loader.js";
 import { validatePipelineOrThrow } from "./validation.js";
 import { getPipelineConfig } from "./config.js";
+import { writeJobStatus } from "./status-writer.js";
 
 const ROOT = process.env.PO_ROOT || process.cwd();
 const DATA_DIR = path.join(ROOT, process.env.PO_DATA_DIR || "pipeline-data");
@@ -205,12 +206,18 @@ function now() {
 }
 
 async function updateStatus(taskName, patch) {
-  const current = JSON.parse(await fs.readFile(tasksStatusPath, "utf8"));
-  current.current = taskName;
-  current.tasks = current.tasks || {};
-  current.tasks[taskName] = { ...(current.tasks[taskName] || {}), ...patch };
-  await atomicWrite(tasksStatusPath, JSON.stringify(current, null, 2));
-  Object.assign(status, current);
+  return await writeJobStatus(workDir, (snapshot) => {
+    snapshot.current = taskName;
+    snapshot.tasks = snapshot.tasks || {};
+    snapshot.tasks[taskName] = {
+      ...(snapshot.tasks[taskName] || {}),
+      ...patch,
+    };
+    return snapshot;
+  }).then((snap) => {
+    Object.assign(status, snap);
+    return snap;
+  });
 }
 
 async function appendLine(file, line) {

package/src/core/status-writer.js

@@ -16,6 +16,9 @@ async function getSSERegistry() {
   return sseRegistry;
 }
 
+// Per-job write queues to serialize writes to tasks-status.json
+const writeQueues = new Map(); // Map<string jobDir, Promise<any>>
+
 // Instrumentation helper for status writer
 const createStatusWriterLogger = (jobId) => {
   const prefix = `[StatusWriter:${jobId || "unknown"}]`;
@@ -193,66 +196,74 @@ export async function writeJobStatus(jobDir, updateFn) {
   const jobId = path.basename(jobDir);
   const logger = createStatusWriterLogger(jobId);
 
-  logger.group("Status Write Operation");
-  logger.log(`Updating status for job: ${jobId}`);
-  logger.log(`Status file path: ${statusPath}`);
+  // Get or create the write queue for this job directory
+  const prev = writeQueues.get(jobDir) || Promise.resolve();
+  let resultSnapshot;
 
-  // Read existing status or create default
-  let snapshot = await readStatusFile(statusPath, jobId);
-  logger.log("Current status snapshot:", snapshot);
+  const next = prev
+    .then(async () => {
+      logger.group("Status Write Operation");
+      logger.log(`Updating status for job: ${jobId}`);
+      logger.log(`Status file path: ${statusPath}`);
 
-  // Validate basic structure
-  snapshot = validateStatusSnapshot(snapshot);
+      // Read existing status or create default
+      const current = await readStatusFile(statusPath, jobId);
+      logger.log("Current status snapshot:", current);
 
-  // Apply user updates
-  try {
-    const result = updateFn(snapshot);
-    // If updateFn returns a value, use it as new snapshot
-    if (result !== undefined) {
-      snapshot = result;
-    }
-    logger.log("Status after update function:", snapshot);
-  } catch (error) {
-    logger.error("Update function failed:", error);
-    throw new Error(`Update function failed: ${error.message}`);
-  }
+      // Validate basic structure
+      const validated = validateStatusSnapshot(current);
 
-  // Validate final structure
-  snapshot = validateStatusSnapshot(snapshot);
+      // Apply user updates
+      const maybeUpdated = updateFn(validated);
+      const snapshot = validateStatusSnapshot(
+        maybeUpdated === undefined ? validated : maybeUpdated
+      );
 
-  // Update timestamp
-  snapshot.lastUpdated = new Date().toISOString();
+      snapshot.lastUpdated = new Date().toISOString();
+      logger.log("Status after update function:", snapshot);
+
+      // Atomic write
+      await atomicWrite(statusPath, snapshot);
+      logger.log("Status file written successfully");
+
+      // Emit SSE event for tasks-status.json change
+      const registry = (await getSSERegistry().catch(() => null)) || null;
+      if (registry) {
+        try {
+          const eventData = {
+            type: "state:change",
+            data: {
+              path: path.join(jobDir, "tasks-status.json"),
+              id: jobId,
+              jobId,
+            },
+          };
+          registry.broadcast(eventData);
+          logger.sse("state:change", eventData.data);
+          logger.log("SSE event broadcasted successfully");
+        } catch (error) {
+          // Don't fail the write if SSE emission fails
+          logger.error("Failed to emit SSE event:", error);
+          console.warn(`Failed to emit SSE event: ${error.message}`);
+        }
+      } else {
+        logger.warn("SSE registry not available - no event broadcasted");
+      }
 
-  // Atomic write
-  await atomicWrite(statusPath, snapshot);
-  logger.log("Status file written successfully");
+      logger.groupEnd();
+      resultSnapshot = snapshot;
+    })
+    .catch((e) => {
+      throw e;
+    });
 
-  // Emit SSE event for tasks-status.json change
-  const registry = await getSSERegistry();
-  if (registry) {
-    try {
-      const eventData = {
-        type: "state:change",
-        data: {
-          path: path.join(jobDir, "tasks-status.json"),
-          id: jobId,
-          jobId,
-        },
-      };
-      registry.broadcast(eventData);
-      logger.sse("state:change", eventData.data);
-      logger.log("SSE event broadcasted successfully");
-    } catch (error) {
-      // Don't fail the write if SSE emission fails
-      logger.error("Failed to emit SSE event:", error);
-      console.warn(`Failed to emit SSE event: ${error.message}`);
-    }
-  } else {
-    logger.warn("SSE registry not available - no event broadcasted");
-  }
+  // Store the promise chain and set up cleanup
+  writeQueues.set(
+    jobDir,
+    next.finally(() => {})
+  );
 
-  logger.groupEnd();
-  return snapshot;
+  return next.then(() => resultSnapshot);
 }
 
 /**

package/src/core/task-runner.js

@@ -4,11 +4,28 @@ import fs from "fs";
 import { createLLM, getLLMEvents } from "../llm/index.js";
 import { loadFreshModule } from "./module-loader.js";
 import { loadEnvironment } from "./environment.js";
-import { getConfig } from "./config.js";
 import { createTaskFileIO } from "./file-io.js";
 import { writeJobStatus } from "./status-writer.js";
 import { computeDeterministicProgress } from "./progress.js";
 
+/**
+ * Derives model key and token counts from LLM metric event.
+ * Returns a tuple: [modelKey, inputTokens, outputTokens].
+ *
+ * @param {Object} metric - The LLM metric event from llm:request:complete
+ * @returns {Array<string, number, number>} [modelKey, inputTokens, outputTokens]
+ */
+export function deriveModelKeyAndTokens(metric) {
+  const provider = metric?.provider || "undefined";
+  const model = metric?.model || "undefined";
+  const modelKey = metric?.metadata?.alias || `${provider}:${model}`;
+  const input = Number.isFinite(metric?.promptTokens) ? metric.promptTokens : 0;
+  const output = Number.isFinite(metric?.completionTokens)
+    ? metric.completionTokens
+    : 0;
+  return [modelKey, input, output];
+}
+
 /**
  * Validates that a value is a plain object (not array, null, or class instance).
  * @param {*} value - The value to check
@@ -365,12 +382,45 @@ export async function runPipeline(modulePath, initialContext = {}) {
   const llmMetrics = [];
   const llmEvents = getLLMEvents();
 
+  // Per-run write queue for serializing tokenUsage appends
+  let tokenWriteQueue = Promise.resolve();
+
+  /**
+   * Appends token usage tuple to tasks-status.json with serialized writes.
+   * @param {string} workDir - Working directory path
+   * @param {string} taskName - Task identifier
+   * @param {Array<string, number, number>} tuple - [modelKey, inputTokens, outputTokens]
+   */
+  function appendTokenUsage(workDir, taskName, tuple) {
+    tokenWriteQueue = tokenWriteQueue
+      .then(() =>
+        writeJobStatus(workDir, (snapshot) => {
+          if (!snapshot.tasks[taskName]) {
+            snapshot.tasks[taskName] = {};
+          }
+          const task = snapshot.tasks[taskName];
+          if (!Array.isArray(task.tokenUsage)) {
+            task.tokenUsage = [];
+          }
+          task.tokenUsage.push(tuple);
+          return snapshot;
+        })
+      )
+      .catch((e) => console.warn("[task-runner] tokenUsage append failed:", e));
+  }
+
   const onLLMComplete = (metric) => {
     llmMetrics.push({
       ...metric,
       task: context.meta.taskName,
       stage: context.currentStage,
     });
+
+    // Append token usage immediately for each successful LLM completion
+    if (context.meta.workDir && context.meta.taskName) {
+      const tuple = deriveModelKeyAndTokens(metric);
+      appendTokenUsage(context.meta.workDir, context.meta.taskName, tuple);
+    }
   };
 
   llmEvents.on("llm:request:complete", onLLMComplete);
@@ -531,6 +581,8 @@ export async function runPipeline(modulePath, initialContext = {}) {
               error: errInfo,
               refinementCycle: refinementCount,
             });
+            await tokenWriteQueue.catch(() => {});
+            llmEvents.off("llm:request:complete", onLLMComplete);
             return {
               ok: false,
               failedStage: s,
@@ -824,6 +876,9 @@ export async function runPipeline(modulePath, initialContext = {}) {
           }
         }
 
+        await tokenWriteQueue.catch(() => {});
+        llmEvents.off("llm:request:complete", onLLMComplete);
+
         // For non-validation stages or when refinements are exhausted, fail immediately
         return {
           ok: false,
@@ -859,6 +914,8 @@ export async function runPipeline(modulePath, initialContext = {}) {
     typeof tasks.validateQuality === "function";
 
   if (context.flags.validationFailed && hasValidation) {
+    await tokenWriteQueue.catch(() => {});
+    llmEvents.off("llm:request:complete", onLLMComplete);
     return {
       ok: false,
       failedStage: "final-validation",
@@ -869,6 +926,9 @@ export async function runPipeline(modulePath, initialContext = {}) {
     };
   }
 
+  // Flush any trailing token usage appends before cleanup
+  await tokenWriteQueue.catch(() => {}); // absorb last error to not mask pipeline result
+
   llmEvents.off("llm:request:complete", onLLMComplete);
 
   // Write final status with currentStage: null to indicate completion