@ryanfw/prompt-orchestration-pipeline 0.16.4 → 0.17.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryanfw/prompt-orchestration-pipeline",
-  "version": "0.16.4",
+  "version": "0.17.1",
   "description": "A Prompt-orchestration pipeline (POP) is a framework for building, running, and experimenting with complex chains of LLM tasks.",
   "type": "module",
   "main": "src/ui/server.js",

package/src/api/validators/json.js

@@ -27,7 +27,12 @@ export const validateWithSchema = (schema, data) => {
     }
   }
 
-  const validateFunction = ajv.compile(schema);
+  // Check if schema already exists, otherwise compile and cache it
+  let validateFunction = schema.$id ? ajv.getSchema(schema.$id) : null;
+  if (!validateFunction) {
+    validateFunction = ajv.compile(schema);
+  }
+
   const isValid = validateFunction(parsedData);
 
   if (isValid) {

package/src/config/models.js

@@ -2,7 +2,7 @@
  * Canonical model configuration for prompt orchestration pipeline.
  * This module serves as single source of truth for all model metadata.
  *
- * Last updated: December 2025
+ * Last updated: January 2026
  */
 
 // Model alias constants grouped by provider
@@ -46,6 +46,16 @@ export const ModelAlias = Object.freeze({
   CLAUDE_CODE_SONNET: "claudecode:sonnet",
   CLAUDE_CODE_OPUS: "claudecode:opus",
   CLAUDE_CODE_HAIKU: "claudecode:haiku",
+
+  // Moonshot/Kimi (K2/K2.5 series as of Jan 2026)
+  MOONSHOT_K2: "moonshot:kimi-k2",
+  MOONSHOT_K2_TURBO: "moonshot:kimi-k2-turbo",
+  MOONSHOT_K2_THINKING: "moonshot:kimi-k2-thinking",
+  MOONSHOT_K2_THINKING_TURBO: "moonshot:kimi-k2-thinking-turbo",
+  MOONSHOT_K2_5: "moonshot:kimi-k2.5",
+  MOONSHOT_LATEST_8K: "moonshot:kimi-latest-8k",
+  MOONSHOT_LATEST_32K: "moonshot:kimi-latest-32k",
+  MOONSHOT_LATEST_128K: "moonshot:kimi-latest-128k",
 });
 
 // Consolidated model configuration with pricing metadata
@@ -225,6 +235,57 @@ export const MODEL_CONFIG = Object.freeze({
     tokenCostInPerMillion: 0,
     tokenCostOutPerMillion: 0,
   },
+
+  // ─── Moonshot/Kimi (Jan 2026) ───
+  // K2 and K2.5 series with built-in context caching
+  [ModelAlias.MOONSHOT_K2]: {
+    provider: "moonshot",
+    model: "kimi-k2",
+    tokenCostInPerMillion: 0.6,
+    tokenCostOutPerMillion: 2.5,
+  },
+  [ModelAlias.MOONSHOT_K2_TURBO]: {
+    provider: "moonshot",
+    model: "kimi-k2-turbo",
+    tokenCostInPerMillion: 1.15,
+    tokenCostOutPerMillion: 8.0,
+  },
+  [ModelAlias.MOONSHOT_K2_THINKING]: {
+    provider: "moonshot",
+    model: "kimi-k2-thinking",
+    tokenCostInPerMillion: 1.15,
+    tokenCostOutPerMillion: 8.0,
+  },
+  [ModelAlias.MOONSHOT_K2_THINKING_TURBO]: {
+    provider: "moonshot",
+    model: "kimi-k2-thinking-turbo",
+    tokenCostInPerMillion: 1.15,
+    tokenCostOutPerMillion: 8.0,
+  },
+  [ModelAlias.MOONSHOT_K2_5]: {
+    provider: "moonshot",
+    model: "kimi-k2.5", // Latest model (Jan 2026)
+    tokenCostInPerMillion: 0.6,
+    tokenCostOutPerMillion: 3.0,
+  },
+  [ModelAlias.MOONSHOT_LATEST_8K]: {
+    provider: "moonshot",
+    model: "kimi-latest-8k", // 8K context tier
+    tokenCostInPerMillion: 0.2,
+    tokenCostOutPerMillion: 2.0,
+  },
+  [ModelAlias.MOONSHOT_LATEST_32K]: {
+    provider: "moonshot",
+    model: "kimi-latest-32k", // 32K context tier
+    tokenCostInPerMillion: 1.0,
+    tokenCostOutPerMillion: 3.0,
+  },
+  [ModelAlias.MOONSHOT_LATEST_128K]: {
+    provider: "moonshot",
+    model: "kimi-latest-128k", // 128K context tier
+    tokenCostInPerMillion: 2.0,
+    tokenCostOutPerMillion: 5.0,
+  },
 });
 
 // Validation set of all valid model aliases
@@ -238,6 +299,7 @@ export const DEFAULT_MODEL_BY_PROVIDER = Object.freeze({
   zhipu: ModelAlias.ZAI_GLM_4_6,
   anthropic: ModelAlias.ANTHROPIC_OPUS_4_5, // Updated: Opus 4.5 available at better price
   claudecode: ModelAlias.CLAUDE_CODE_SONNET,
+  moonshot: ModelAlias.MOONSHOT_K2_5, // Latest K2.5 model (Jan 2026)
 });
 
 /**

package/src/core/orchestrator.js

@@ -245,7 +245,14 @@ export async function startOrchestrator(opts) {
 
   watcher.on("add", (file) => {
     // Return promise so tests awaiting the add handler block until processing completes
-    return handleSeedAdd(file);
+    // Catch rejections to prevent unhandled promise rejection crashes
+    return handleSeedAdd(file).catch((error) => {
+      logger.error("Failed to handle seed file", {
+        file,
+        error: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : undefined,
+      });
+    });
   });
 
   async function stop() {
@@ -380,65 +387,30 @@ function spawnRunner(
 
     child.on("exit", (code, signal) => {
       running.delete(jobId);
-
-      // Write job completion log synchronously
-      if (fileIO) {
-        try {
-          fileIO.writeLogSync(
-            generateLogName(jobId, "orchestrator", LogEvent.COMPLETE),
-            JSON.stringify(
-              {
-                jobId,
-                exitCode: code,
-                signal: signal,
-                timestamp: new Date().toISOString(),
-                completionType: code === 0 ? "success" : "failure",
-              },
-              null,
-              2
-            ),
-            { mode: "replace" }
-          );
-        } catch (error) {
-          logger.error("Failed to write job completion log", {
-            jobId,
-            error: error.message,
-          });
-        }
-      }
+      // Note: We intentionally don't write completion logs here because
+      // the pipeline-runner moves the job directory from current/ to complete/
+      // before exiting. Writing here would create a ghost directory under current/
+      // due to the race condition between fs.rename() and this exit handler.
+      // The pipeline-runner already writes its own execution logs and runs.jsonl.
+      logger.log("Pipeline runner exited", {
+        jobId,
+        exitCode: code,
+        signal: signal,
+        completionType: code === 0 ? "success" : "failure",
+      });
     });
 
     child.on("error", (error) => {
       running.delete(jobId);
-
-      // Write job error log synchronously
-      if (fileIO) {
-        try {
-          fileIO.writeLogSync(
-            generateLogName(jobId, "orchestrator", LogEvent.ERROR),
-            JSON.stringify(
-              {
-                jobId,
-                error: {
-                  message: error.message,
-                  name: error.name,
-                  code: error.code,
-                },
-                timestamp: new Date().toISOString(),
-                completionType: "error",
-              },
-              null,
-              2
-            ),
-            { mode: "replace" }
-          );
-        } catch (logError) {
-          logger.error("Failed to write job error log", {
-            jobId,
-            error: logError.message,
-          });
-        }
-      }
+      // Log spawn errors but don't write to filesystem to avoid race conditions
+      logger.error("Pipeline runner spawn error", {
+        jobId,
+        error: {
+          message: error.message,
+          name: error.name,
+          code: error.code,
+        },
+      });
     });
 
     // In test mode: return immediately; in real mode you might await readiness

package/src/core/pipeline-runner.js

@@ -2,6 +2,27 @@ import fs from "node:fs/promises";
 import fsSync from "node:fs";
 import path from "node:path";
 import { runPipeline } from "./task-runner.js";
+
+// Global unhandled rejection handler to prevent hanging on unexpected errors
+// This must be registered early before any async operations
+process.on("unhandledRejection", (reason, promise) => {
+  console.error("[PipelineRunner] Unhandled promise rejection:", reason);
+  console.error("[PipelineRunner] Promise:", promise);
+  // Force exit after a brief delay to allow logs to flush
+  setTimeout(() => {
+    console.error("[PipelineRunner] Forcing exit due to unhandled rejection");
+    process.exit(1);
+  }, 100);
+});
+
+process.on("uncaughtException", (error) => {
+  console.error("[PipelineRunner] Uncaught exception:", error);
+  // Force exit after a brief delay to allow logs to flush
+  setTimeout(() => {
+    console.error("[PipelineRunner] Forcing exit due to uncaught exception");
+    process.exit(1);
+  }, 100);
+});
 import { loadFreshModule } from "./module-loader.js";
 import { validatePipelineOrThrow } from "./validation.js";
 import { getPipelineConfig } from "./config.js";
@@ -106,6 +127,9 @@ const pipeline = JSON.parse(await fs.readFile(PIPELINE_DEF_PATH, "utf8"));
 // Validate pipeline format early with a friendly error message
 validatePipelineOrThrow(pipeline, PIPELINE_DEF_PATH);
 
+// Extract optional LLM override from pipeline config
+const llmOverride = pipeline.llm || null;
+
 const taskNames = pipeline.tasks.map(getTaskName);
 
 const tasks = (await loadFreshModule(TASK_REGISTRY)).default;
@@ -203,6 +227,7 @@ try {
         taskConfig: pipeline.taskConfig?.[taskName] || {},
         statusPath: tasksStatusPath,
         jobId,
+        llmOverride,
         meta: {
           pipelineTasks: [...pipeline.tasks],
         },
@@ -416,7 +441,32 @@ try {
     await cleanupTaskSymlinks(dest);
   }
 } catch (error) {
-  throw error;
+  // Log the error with full context instead of re-throwing
+  // Re-throwing at top-level causes unhandled promise rejection and hanging
+  logger.error("Pipeline execution failed with unhandled error", {
+    jobId,
+    pipelineSlug,
+    error: normalizeError(error),
+  });
+  
+  console.error("[PipelineRunner] Fatal error:", error);
+  
+  // Ensure we exit with failure code
+  process.exitCode = 1;
+  
+  // Set a forced exit timeout to prevent indefinite hanging
+  // This catches cases where cleanup or logging doesn't complete
+  const forceExitTimeout = setTimeout(() => {
+    console.error("[PipelineRunner] Force exit timeout reached, terminating process");
+    process.exit(1);
+  }, 5000);
+  
+  // Make the timeout non-blocking so it doesn't keep the event loop alive
+  forceExitTimeout.unref();
+  
+  // Clean up and exit
+  await cleanupRunnerPid();
+  process.exit(1);
 } finally {
   // Always ensure PID cleanup at the end of execution
   await cleanupRunnerPid();

package/src/core/task-runner.js

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import fs from "fs";
-import { createLLM, getLLMEvents } from "../llm/index.js";
+import { createLLM, createLLMWithOverride, getLLMEvents } from "../llm/index.js";
 import { loadFreshModule } from "./module-loader.js";
 import { loadEnvironment } from "./environment.js";
 import { createTaskFileIO, generateLogName } from "./file-io.js";
@@ -353,7 +353,11 @@ export async function runPipeline(modulePath, initialContext = {}) {
     initialContext.envLoaded = true;
   }
 
-  if (!initialContext.llm) initialContext.llm = createLLM();
+  if (!initialContext.llm) {
+    initialContext.llm = initialContext.llmOverride
+      ? createLLMWithOverride(initialContext.llmOverride)
+      : createLLM();
+  }
 
   const llmMetrics = [];
   const llmEvents = getLLMEvents();
@@ -399,10 +403,16 @@ export async function runPipeline(modulePath, initialContext = {}) {
     }
   };
 
+  const onLLMError = (m) => llmMetrics.push({ ...m, failed: true });
+
   llmEvents.on("llm:request:complete", onLLMComplete);
-  llmEvents.on("llm:request:error", (m) =>
-    llmMetrics.push({ ...m, failed: true })
-  );
+  llmEvents.on("llm:request:error", onLLMError);
+  
+  // Helper to clean up all LLM event listeners
+  const cleanupLLMListeners = () => {
+    llmEvents.off("llm:request:complete", onLLMComplete);
+    llmEvents.off("llm:request:error", onLLMError);
+  };
 
   const abs = toAbsFileURL(modulePath);
   const mod = await loadFreshModule(abs);
@@ -782,7 +792,7 @@ export async function runPipeline(modulePath, initialContext = {}) {
       }
 
       await tokenWriteQueue.catch(() => {});
-      llmEvents.off("llm:request:complete", onLLMComplete);
+      cleanupLLMListeners();
 
       // Fail immediately on any stage error
       return {
@@ -801,7 +811,7 @@ 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);
+  cleanupLLMListeners();
 
   // Write final status with currentStage: null to indicate completion
   if (context.meta.workDir && context.meta.taskName) {

package/src/llm/index.js

@@ -7,6 +7,7 @@ import {
   claudeCodeChat,
   isClaudeCodeAvailable,
 } from "../providers/claude-code.js";
+import { moonshotChat } from "../providers/moonshot.js";
 import { EventEmitter } from "node:events";
 import { getConfig } from "../core/config.js";
 import {
@@ -62,6 +63,7 @@ export function getAvailableProviders() {
     gemini: !!process.env.GEMINI_API_KEY,
     zhipu: !!process.env.ZHIPU_API_KEY,
     claudecode: isClaudeCodeAvailable(),
+    moonshot: !!process.env.MOONSHOT_API_KEY,
     mock: !!mockProviderInstance,
   };
 }
@@ -582,6 +584,83 @@ export async function chat(options) {
           totalTokens: promptTokens + completionTokens,
         };
       }
+    } else if (provider === "moonshot") {
+      logger.log("Using Moonshot provider");
+      const defaultAlias = DEFAULT_MODEL_BY_PROVIDER["moonshot"];
+      const defaultModelConfig = MODEL_CONFIG[defaultAlias];
+      const defaultModel = defaultModelConfig?.model;
+
+      // Infer JSON format if not explicitly provided
+      const effectiveResponseFormat =
+        responseFormat === undefined ||
+        responseFormat === null ||
+        responseFormat === ""
+          ? shouldInferJsonFormat(messages)
+            ? "json_object"
+            : undefined
+          : responseFormat;
+
+      const moonshotArgs = {
+        messages,
+        model: model || defaultModel,
+        temperature,
+        maxTokens,
+        ...rest,
+      };
+      logger.log("Moonshot call parameters:", {
+        model: moonshotArgs.model,
+        hasMessages: !!moonshotArgs.messages,
+        messageCount: moonshotArgs.messages?.length,
+      });
+      if (stream !== undefined) moonshotArgs.stream = stream;
+      if (topP !== undefined) moonshotArgs.topP = topP;
+      if (frequencyPenalty !== undefined)
+        moonshotArgs.frequencyPenalty = frequencyPenalty;
+      if (presencePenalty !== undefined)
+        moonshotArgs.presencePenalty = presencePenalty;
+      if (stop !== undefined) moonshotArgs.stop = stop;
+      if (effectiveResponseFormat !== undefined) {
+        moonshotArgs.responseFormat = effectiveResponseFormat;
+      }
+
+      logger.log("Calling moonshotChat()...");
+      const result = await moonshotChat(moonshotArgs);
+      logger.log("moonshotChat() returned:", {
+        hasResult: !!result,
+        isStream: typeof result?.[Symbol.asyncIterator] !== "undefined",
+        hasContent: !!result?.content,
+        hasUsage: !!result?.usage,
+      });
+
+      // Streaming mode - return async generator directly
+      if (stream && typeof result?.[Symbol.asyncIterator] !== "undefined") {
+        return result;
+      }
+
+      response = {
+        content: result.content,
+        raw: result.raw,
+      };
+
+      // Use actual usage from moonshot API if available; otherwise estimate
+      if (result?.usage) {
+        const { prompt_tokens, completion_tokens, total_tokens } = result.usage;
+        usage = {
+          promptTokens: prompt_tokens,
+          completionTokens: completion_tokens,
+          totalTokens: total_tokens,
+        };
+      } else {
+        const promptTokens = estimateTokens(systemMsg + userMsg);
+        const completionTokens = estimateTokens(
+          typeof result === "string" ? result : JSON.stringify(result)
+        );
+        usage = {
+          promptTokens,
+          completionTokens,
+          totalTokens: promptTokens + completionTokens,
+        };
+      }
     } else {
       logger.error("Unknown provider:", provider);
       throw new Error(`Provider ${provider} not yet implemented`);
@@ -806,6 +885,75 @@ export function createNamedModelsAPI() {
   return buildProviderFunctions(MODEL_CONFIG);
 }
 
+// Create LLM with pipeline-level override
+// When override is set, all provider method calls are intercepted and routed to the override provider/model
+export function createLLMWithOverride(override) {
+  logger.log("createLLMWithOverride called", {
+    hasOverride: !!override,
+    overrideProvider: override?.provider,
+    overrideModel: override?.model,
+  });
+
+  if (!override?.provider) {
+    logger.log("No override provider, returning standard LLM");
+    return createLLM();
+  }
+
+  logger.log("Creating LLM with override proxy", {
+    provider: override.provider,
+    model: override.model,
+  });
+
+  const baseLLM = createLLM();
+
+  return new Proxy(baseLLM, {
+    get(target, providerKey) {
+      const providerObj = target[providerKey];
+      if (typeof providerObj !== "object" || providerObj === null) {
+        return providerObj;
+      }
+
+      return new Proxy(providerObj, {
+        get(providerTarget, methodKey) {
+          // Skip non-string keys (symbols, etc.)
+          if (typeof methodKey !== "string") {
+            return providerTarget[methodKey];
+          }
+
+          // Skip built-in/serialization methods to prevent spurious API calls
+          // when the LLM object is serialized (e.g., JSON.stringify, logging)
+          const builtInMethods = ['toJSON', 'toString', 'valueOf', 'then', 'catch', 'finally', 'constructor'];
+          if (builtInMethods.includes(methodKey)) {
+            return providerTarget[methodKey];
+          }
+
+          // Log interception
+          logger.log("LLM call intercepted by override", {
+            originalProvider: providerKey,
+            originalMethod: methodKey,
+            overrideProvider: override.provider,
+            overrideModel: override.model,
+          });
+
+          // When override is active, return a function for ANY method key
+          // This routes all method calls to the override provider/model
+          return (options = {}) =>
+            chat({
+              ...options,
+              provider: override.provider,
+              model: override.model,
+              metadata: {
+                ...options.metadata,
+                originalProvider: providerKey,
+                originalModel: options.model,
+              },
+            });
+        },
+      });
+    },
+  });
+}
+
 // Separate function for high-level LLM interface (used by llm.test.js)
 export function createHighLevelLLM(options = {}) {
   // Skip config check in tests to avoid PO_ROOT requirement