@ryanfw/prompt-orchestration-pipeline 0.14.1 → 0.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryanfw/prompt-orchestration-pipeline",
-  "version": "0.14.1",
+  "version": "0.15.0",
   "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/llm/index.js

@@ -11,6 +11,9 @@ import {
   aliasToFunctionName,
 } from "../config/models.js";
 import fs from "node:fs";
+import { createLogger } from "../core/logger.js";
+
+const logger = createLogger("LLM");
 
 // Global mock provider instance (for demo/testing)
 let mockProviderInstance = null;
@@ -103,7 +106,7 @@ function shouldInferJsonFormat(messages) {
 
 // Core chat function - no metrics handling needed!
 export async function chat(options) {
-  console.log("[llm] chat() called with options:", {
+  logger.log("chat() called with options:", {
     provider: options.provider,
     model: options.model,
     messageCount: options.messages?.length || 0,
@@ -133,11 +136,11 @@ export async function chat(options) {
 
   const available = getAvailableProviders();
 
-  console.log("[llm] Available providers:", available);
-  console.log("[llm] Requested provider:", provider);
+  logger.log("Available providers:", available);
+  logger.log("Requested provider:", provider);
 
   if (!available[provider]) {
-    console.error("[llm] Provider not available:", provider);
+    logger.error("Provider not available:", provider);
     throw new Error(`Provider ${provider} not available. Check API keys.`);
   }
 
@@ -149,7 +152,7 @@ export async function chat(options) {
   const userMessages = messages.filter((m) => m.role === "user");
   const userMsg = userMessages.map((m) => m.content).join("\n");
 
-  console.log("[llm] Message analysis:", {
+  logger.log("Message analysis:", {
     hasSystemMessage: !!systemMsg,
     systemMessageLength: systemMsg.length,
     userMessageCount: userMessages.length,
@@ -163,10 +166,7 @@ export async function chat(options) {
     JSON.stringify({ messages, systemMsg, userMsg, provider, model }, null, 2)
   );
 
-  console.log(
-    "[llm] Emitting llm:request:start event for requestId:",
-    requestId
-  );
+  logger.log("Emitting llm:request:start event for requestId:", requestId);
 
   // Emit request start event
   llmEvents.emit("llm:request:start", {
@@ -178,12 +178,12 @@ export async function chat(options) {
   });
 
   try {
-    console.log("[llm] Starting provider call for:", provider);
+    logger.log("Starting provider call for:", provider);
     let response;
     let usage;
 
     if (provider === "mock") {
-      console.log("[llm] Using mock provider");
+      logger.log("Using mock provider");
       if (!mockProviderInstance) {
         throw new Error(
           "Mock provider not registered. Call registerMockProvider() first."
@@ -197,7 +197,7 @@ export async function chat(options) {
         maxTokens,
         ...rest,
       });
-      console.log("[llm] Mock provider returned result");
+      logger.log("Mock provider returned result");
 
       response = {
         content: result.content,
@@ -210,7 +210,7 @@ export async function chat(options) {
         totalTokens: result.usage.total_tokens,
       };
     } else if (provider === "openai") {
-      console.log("[llm] Using OpenAI provider");
+      logger.log("Using OpenAI provider");
 
       // Infer JSON format if not explicitly provided
       const effectiveResponseFormat =
@@ -229,7 +229,7 @@ export async function chat(options) {
         maxTokens,
         ...rest,
       };
-      console.log("[llm] OpenAI call parameters:", {
+      logger.log("OpenAI call parameters:", {
         model: openaiArgs.model,
         hasMessages: !!openaiArgs.messages,
         messageCount: openaiArgs.messages?.length,
@@ -244,9 +244,9 @@ export async function chat(options) {
         openaiArgs.presencePenalty = presencePenalty;
       if (stop !== undefined) openaiArgs.stop = stop;
 
-      console.log("[llm] Calling openaiChat()...");
+      logger.log("Calling openaiChat()...");
       const result = await openaiChat(openaiArgs);
-      console.log("[llm] openaiChat() returned:", {
+      logger.log("openaiChat() returned:", {
         hasResult: !!result,
         hasContent: !!result?.content,
         hasUsage: !!result?.usage,
@@ -277,7 +277,7 @@ export async function chat(options) {
         };
       }
     } else if (provider === "deepseek") {
-      console.log("[llm] Using DeepSeek provider");
+      logger.log("Using DeepSeek provider");
 
       // Infer JSON format if not explicitly provided
       const effectiveResponseFormat =
@@ -296,7 +296,7 @@ export async function chat(options) {
         maxTokens,
         ...rest,
       };
-      console.log("[llm] DeepSeek call parameters:", {
+      logger.log("DeepSeek call parameters:", {
         model: deepseekArgs.model,
         hasMessages: !!deepseekArgs.messages,
         messageCount: deepseekArgs.messages?.length,
@@ -312,9 +312,9 @@ export async function chat(options) {
         deepseekArgs.responseFormat = effectiveResponseFormat;
       }
 
-      console.log("[llm] Calling deepseekChat()...");
+      logger.log("Calling deepseekChat()...");
       const result = await deepseekChat(deepseekArgs);
-      console.log("[llm] deepseekChat() returned:", {
+      logger.log("deepseekChat() returned:", {
         hasResult: !!result,
         isStream: typeof result?.[Symbol.asyncIterator] !== "undefined",
         hasContent: !!result?.content,
@@ -350,7 +350,7 @@ export async function chat(options) {
         };
       }
     } else if (provider === "anthropic") {
-      console.log("[llm] Using Anthropic provider");
+      logger.log("Using Anthropic provider");
       const defaultAlias = DEFAULT_MODEL_BY_PROVIDER.anthropic;
       const defaultModelConfig = MODEL_CONFIG[defaultAlias];
       const defaultModel = defaultModelConfig?.model;
@@ -362,7 +362,7 @@ export async function chat(options) {
         maxTokens,
         ...rest,
       };
-      console.log("[llm] Anthropic call parameters:", {
+      logger.log("Anthropic call parameters:", {
         model: anthropicArgs.model,
         hasMessages: !!anthropicArgs.messages,
         messageCount: anthropicArgs.messages?.length,
@@ -373,9 +373,9 @@ export async function chat(options) {
         anthropicArgs.responseFormat = responseFormat;
       }
 
-      console.log("[llm] Calling anthropicChat()...");
+      logger.log("Calling anthropicChat()...");
       const result = await anthropicChat(anthropicArgs);
-      console.log("[llm] anthropicChat() returned:", {
+      logger.log("anthropicChat() returned:", {
         hasResult: !!result,
         hasContent: !!result?.content,
         hasUsage: !!result?.usage,
@@ -406,7 +406,7 @@ export async function chat(options) {
         };
       }
     } else if (provider === "gemini") {
-      console.log("[llm] Using Gemini provider");
+      logger.log("Using Gemini provider");
 
       // Infer JSON format if not explicitly provided
       const effectiveResponseFormat =
@@ -425,7 +425,7 @@ export async function chat(options) {
         maxTokens,
         ...rest,
       };
-      console.log("[llm] Gemini call parameters:", {
+      logger.log("Gemini call parameters:", {
         model: geminiArgs.model,
         hasMessages: !!geminiArgs.messages,
         messageCount: geminiArgs.messages?.length,
@@ -436,9 +436,9 @@ export async function chat(options) {
         geminiArgs.responseFormat = effectiveResponseFormat;
       }
 
-      console.log("[llm] Calling geminiChat()...");
+      logger.log("Calling geminiChat()...");
       const result = await geminiChat(geminiArgs);
-      console.log("[llm] geminiChat() returned:", {
+      logger.log("geminiChat() returned:", {
         hasResult: !!result,
         hasContent: !!result?.content,
         hasUsage: !!result?.usage,
@@ -469,7 +469,7 @@ export async function chat(options) {
         };
       }
     } else if (provider === "zhipu") {
-      console.log("[llm] Using Zhipu provider");
+      logger.log("Using Zhipu provider");
       const defaultAlias = DEFAULT_MODEL_BY_PROVIDER.zhipu;
       const defaultModelConfig = MODEL_CONFIG[defaultAlias];
       const defaultModel = defaultModelConfig?.model;
@@ -481,7 +481,7 @@ export async function chat(options) {
         maxTokens,
         ...rest,
       };
-      console.log("[llm] Zhipu call parameters:", {
+      logger.log("Zhipu call parameters:", {
         model: zhipuArgs.model,
         hasMessages: !!zhipuArgs.messages,
         messageCount: zhipuArgs.messages?.length,
@@ -492,9 +492,9 @@ export async function chat(options) {
         zhipuArgs.responseFormat = responseFormat;
       }
 
-      console.log("[llm] Calling zhipuChat()...");
+      logger.log("Calling zhipuChat()...");
       const result = await zhipuChat(zhipuArgs);
-      console.log("[llm] zhipuChat() returned:", {
+      logger.log("zhipuChat() returned:", {
         hasResult: !!result,
         hasContent: !!result?.content,
         hasUsage: !!result?.usage,
@@ -525,16 +525,16 @@ export async function chat(options) {
         };
       }
     } else {
-      console.error("[llm] Unknown provider:", provider);
+      logger.error("Unknown provider:", provider);
       throw new Error(`Provider ${provider} not yet implemented`);
     }
 
-    console.log("[llm] Processing response from provider:", provider);
+    logger.log("Processing response from provider:", provider);
 
     const duration = Date.now() - startTime;
     const cost = calculateCost(provider, model, usage);
 
-    console.log("[llm] Request completed:", {
+    logger.log("Request completed:", {
       duration: `${duration}ms`,
       cost,
       usage,
@@ -560,7 +560,7 @@ export async function chat(options) {
   } catch (error) {
     const duration = Date.now() - startTime;
 
-    console.error("[llm] Error in chat():", {
+    logger.error("Error in chat():", {
       error: error.message,
       name: error.name,
       stack: error.stack,

package/src/providers/anthropic.js

@@ -7,6 +7,9 @@ import {
   ensureJsonResponseFormat,
   ProviderJsonParseError,
 } from "./base.js";
+import { createLogger } from "../core/logger.js";
+
+const logger = createLogger("Anthropic");
 
 export async function anthropicChat({
   messages,
@@ -18,16 +21,16 @@ export async function anthropicChat({
   stop,
   maxRetries = 3,
 }) {
-  console.log("\n[Anthropic] Starting anthropicChat call");
-  console.log("[Anthropic] Model:", model);
-  console.log("[Anthropic] Response format:", responseFormat);
+  logger.log("\nStarting anthropicChat call");
+  logger.log("Model:", model);
+  logger.log("Response format:", responseFormat);
 
   // Enforce JSON mode - reject calls without proper JSON responseFormat
   ensureJsonResponseFormat(responseFormat, "Anthropic");
 
   const { systemMsg, userMsg } = extractMessages(messages);
-  console.log("[Anthropic] System message length:", systemMsg.length);
-  console.log("[Anthropic] User message length:", userMsg.length);
+  logger.log("System message length:", systemMsg.length);
+  logger.log("User message length:", userMsg.length);
 
   // Build system guard for JSON enforcement
   let system = systemMsg;
@@ -43,7 +46,7 @@ export async function anthropicChat({
     }
 
     try {
-      console.log(`[Anthropic] Attempt ${attempt + 1}/${maxRetries + 1}`);
+      logger.log(`Attempt ${attempt + 1}/${maxRetries + 1}`);
 
       const requestBody = {
         model,
@@ -55,7 +58,7 @@ export async function anthropicChat({
         ...(stop !== undefined ? { stop_sequences: stop } : {}),
       };
 
-      console.log("[Anthropic] Calling Anthropic API...");
+      logger.log("Calling Anthropic API...");
       const response = await fetch("https://api.anthropic.com/v1/messages", {
         method: "POST",
         headers: {
@@ -74,7 +77,7 @@ export async function anthropicChat({
       }
 
       const data = await response.json();
-      console.log("[Anthropic] Response received from Anthropic API");
+      logger.log("Response received from Anthropic API");
 
       // Extract text from response.content blocks
       const blocks = Array.isArray(data?.content) ? data.content : [];
@@ -84,7 +87,7 @@ export async function anthropicChat({
         .join("");
       // Always strip markdown fences first to prevent parse failures
       const text = stripMarkdownFences(rawText);
-      console.log("[Anthropic] Response text length:", text.length);
+      logger.log("Response text length:", text.length);
 
       // Parse JSON - this is required for all calls
       const parsed = tryParseJSON(text);
@@ -106,7 +109,7 @@ export async function anthropicChat({
           ? { prompt_tokens, completion_tokens, total_tokens }
           : undefined;
 
-      console.log("[Anthropic] Returning response from Anthropic API");
+      logger.log("Returning response from Anthropic API");
       return {
         content: parsed,
         text,
@@ -116,13 +119,13 @@ export async function anthropicChat({
     } catch (error) {
       lastError = error;
       const msg = error?.error?.message || error?.message || "";
-      console.error("[Anthropic] Error occurred:", msg);
-      console.error("[Anthropic] Error status:", error?.status);
+      logger.error("Error occurred:", msg);
+      logger.error("Error status:", error?.status);
 
       if (error.status === 401) throw error;
 
       if (isRetryableError(error) && attempt < maxRetries) {
-        console.log("[Anthropic] Retrying due to retryable error");
+        logger.log("Retrying due to retryable error");
         continue;
       }
 

package/src/providers/deepseek.js

@@ -7,6 +7,9 @@ import {
   ensureJsonResponseFormat,
   ProviderJsonParseError,
 } from "./base.js";
+import { createLogger } from "../core/logger.js";
+
+const logger = createLogger("DeepSeek");
 
 export async function deepseekChat({
   messages,
@@ -163,7 +166,7 @@ async function* createStreamGenerator(stream) {
             }
           } catch (e) {
             // Skip malformed JSON
-            console.warn("[deepseek] Failed to parse stream chunk:", e);
+            logger.warn("Failed to parse stream chunk:", e);
           }
         }
       }

package/src/providers/gemini.js

@@ -7,6 +7,9 @@ import {
   ensureJsonResponseFormat,
   ProviderJsonParseError,
 } from "./base.js";
+import { createLogger } from "../core/logger.js";
+
+const logger = createLogger("Gemini");
 
 /**
  * Google Gemini provider implementation
@@ -120,15 +123,13 @@ export async function geminiChat(options) {
     }
 
     try {
-      console.log(
-        `[Gemini] Starting geminiChat call (attempt ${attempt + 1}/${maxRetries + 1})`
-      );
-      console.log(`[Gemini] Model: ${model}`);
-      console.log(`[Gemini] Response format:`, responseFormat);
-      console.log(
-        `[Gemini] System instruction length: ${systemInstruction.length}`
+      logger.log(
+        `Starting geminiChat call (attempt ${attempt + 1}/${maxRetries + 1})`
       );
-      console.log(`[Gemini] User message length: ${userMsg.length}`);
+      logger.log(`Model: ${model}`);
+      logger.log(`Response format:`, responseFormat);
+      logger.log(`System instruction length: ${systemInstruction.length}`);
+      logger.log(`User message length: ${userMsg.length}`);
 
       const response = await fetch(url, {
         method: "POST",
@@ -153,7 +154,7 @@ export async function geminiChat(options) {
 
         // Retry on retryable errors
         if (isRetryableError(error) && attempt < maxRetries) {
-          console.log(`[Gemini] Retryable error, retrying...`);
+          logger.log(`Retryable error, retrying...`);
           lastError = error;
           continue;
         }
@@ -162,8 +163,8 @@ export async function geminiChat(options) {
       }
 
       const data = await response.json();
-      console.log(
-        `[Gemini] Response received, candidates length: ${data.candidates?.length || 0}`
+      logger.log(
+        `Response received, candidates length: ${data.candidates?.length || 0}`
       );
 
       // Extract text from response
@@ -175,7 +176,7 @@ export async function geminiChat(options) {
       const rawText = candidate.content.parts[0].text;
       // Always strip markdown fences first to prevent parse failures
       const text = stripMarkdownFences(rawText);
-      console.log(`[Gemini] Text length: ${text.length}`);
+      logger.log(`Text length: ${text.length}`);
 
       // Parse JSON if required
       const parsed = tryParseJSON(text);
@@ -197,7 +198,7 @@ export async function geminiChat(options) {
           }
         : undefined;
 
-      console.log(`[Gemini] Usage:`, usage);
+      logger.log(`Usage:`, usage);
 
       return {
         content: parsed || text,
@@ -206,8 +207,8 @@ export async function geminiChat(options) {
         raw: data,
       };
     } catch (error) {
-      console.error(`[Gemini] Error occurred: ${error.message}`);
-      console.error(`[Gemini] Error status: ${error.status}`);
+      logger.error(`Error occurred: ${error.message}`);
+      logger.error(`Error status: ${error.status}`);
 
       lastError = error;
 

package/src/providers/openai.js

@@ -8,6 +8,9 @@ import {
   ensureJsonResponseFormat,
   ProviderJsonParseError,
 } from "./base.js";
+import { createLogger } from "../core/logger.js";
+
+const logger = createLogger("OpenAI");
 
 let client = null;
 
@@ -43,16 +46,16 @@ export async function openaiChat({
   maxRetries = 3,
   ...rest
 }) {
-  console.log("\n[OpenAI] Starting openaiChat call");
-  console.log("[OpenAI] Model:", model);
-  console.log("[OpenAI] Response format:", responseFormat);
+  logger.log("\nStarting openaiChat call");
+  logger.log("Model:", model);
+  logger.log("Response format:", responseFormat);
 
   const openai = getClient();
   if (!openai) throw new Error("OpenAI API key not configured");
 
   const { systemMsg, userMsg } = extractMessages(messages);
-  console.log("[OpenAI] System message length:", systemMsg.length);
-  console.log("[OpenAI] User message length:", userMsg.length);
+  logger.log("System message length:", systemMsg.length);
+  logger.log("User message length:", userMsg.length);
 
   // Determine if JSON mode is requested (handle both object and string formats)
   const isJsonMode =
@@ -68,11 +71,11 @@ export async function openaiChat({
     const useResponsesAPI = /^gpt-5/i.test(model);
 
     try {
-      console.log(`[OpenAI] Attempt ${attempt + 1}/${maxRetries + 1}`);
+      logger.log(`Attempt ${attempt + 1}/${maxRetries + 1}`);
 
       // ---------- RESPONSES API path (GPT-5 models) ----------
       if (useResponsesAPI) {
-        console.log("[OpenAI] Using Responses API for GPT-5 model");
+        logger.log("Using Responses API for GPT-5 model");
         const responsesReq = {
           model,
           instructions: systemMsg,
@@ -100,12 +103,12 @@ export async function openaiChat({
           responsesReq.text = { format: { type: "json_object" } };
         }
 
-        console.log("[OpenAI] Calling responses.create...");
+        logger.log("Calling responses.create...");
         const resp = await openai.responses.create(responsesReq);
         const rawText = resp.output_text ?? "";
         // Always strip markdown fences first to prevent parse failures
         const text = stripMarkdownFences(rawText);
-        console.log("[OpenAI] Response received, text length:", text.length);
+        logger.log("Response received, text length:", text.length);
 
         // Approximate usage (tests don't assert exact values)
         const promptTokens = Math.ceil((systemMsg + userMsg).length / 4);
@@ -127,20 +130,16 @@ export async function openaiChat({
               "Failed to parse JSON response from Responses API"
             );
           }
-          console.log(
-            "[OpenAI] Returning response from Responses API (JSON mode)"
-          );
+          logger.log("Returning response from Responses API (JSON mode)");
           return { content: parsed, text, usage, raw: resp };
         }
 
-        console.log(
-          "[OpenAI] Returning response from Responses API (text mode)"
-        );
+        logger.log("Returning response from Responses API (text mode)");
         return { content: text, text, usage, raw: resp };
       }
 
       // ---------- CLASSIC CHAT COMPLETIONS path (non-GPT-5) ----------
-      console.log("[OpenAI] Using Classic Chat Completions API");
+      logger.log("Using Classic Chat Completions API");
       const classicReq = {
         model,
         messages,
@@ -163,15 +162,12 @@ export async function openaiChat({
         classicReq.response_format = { type: "json_object" };
       }
 
-      console.log("[OpenAI] Calling chat.completions.create...");
+      logger.log("Calling chat.completions.create...");
       const classicRes = await openai.chat.completions.create(classicReq);
       const rawClassicText = classicRes?.choices?.[0]?.message?.content ?? "";
       // Always strip markdown fences first to prevent parse failures
       const classicText = stripMarkdownFences(rawClassicText);
-      console.log(
-        "[OpenAI] Response received, text length:",
-        classicText.length
-      );
+      logger.log("Response received, text length:", classicText.length);
 
       // Parse JSON only in JSON mode; return raw string for text mode
       if (isJsonMode) {
@@ -201,16 +197,16 @@ export async function openaiChat({
     } catch (error) {
       lastError = error;
       const msg = error?.error?.message || error?.message || "";
-      console.error("[OpenAI] Error occurred:", msg);
-      console.error("[OpenAI] Error status:", error?.status);
+      logger.error("Error occurred:", msg);
+      logger.error("Error status:", error?.status);
 
       // Only fall back when RESPONSES path failed due to lack of support
       if (
         useResponsesAPI &&
         (/not supported/i.test(msg) || /unsupported/i.test(msg))
       ) {
-        console.log(
-          "[OpenAI] Falling back to Classic API due to unsupported Responses API"
+        logger.log(
+          "Falling back to Classic API due to unsupported Responses API"
         );
         const classicReq = {
           model,

package/src/providers/zhipu.js

@@ -7,6 +7,9 @@ import {
   ensureJsonResponseFormat,
   ProviderJsonParseError,
 } from "./base.js";
+import { createLogger } from "../core/logger.js";
+
+const logger = createLogger("Zhipu");
 
 export async function zhipuChat({
   messages,
@@ -18,9 +21,9 @@ export async function zhipuChat({
   stop,
   maxRetries = 3,
 }) {
-  console.log("\n[Zhipu] Starting zhipuChat call");
-  console.log("[Zhipu] Model:", model);
-  console.log("[Zhipu] Response format:", responseFormat);
+  logger.log("\nStarting zhipuChat call");
+  logger.log("Model:", model);
+  logger.log("Response format:", responseFormat);
 
   // Enforce JSON mode - reject calls without proper JSON responseFormat
   ensureJsonResponseFormat(responseFormat, "Zhipu");
@@ -30,8 +33,8 @@ export async function zhipuChat({
   }
 
   const { systemMsg, userMsg } = extractMessages(messages);
-  console.log("[Zhipu] System message length:", systemMsg.length);
-  console.log("[Zhipu] User message length:", userMsg.length);
+  logger.log("System message length:", systemMsg.length);
+  logger.log("User message length:", userMsg.length);
 
   // Build system guard for JSON enforcement
   let system = systemMsg;
@@ -51,7 +54,7 @@ export async function zhipuChat({
     }
 
     try {
-      console.log(`[Zhipu] Attempt ${attempt + 1}/${maxRetries + 1}`);
+      logger.log(`Attempt ${attempt + 1}/${maxRetries + 1}`);
 
       const requestBody = {
         model,
@@ -65,7 +68,7 @@ export async function zhipuChat({
         ...(stop !== undefined ? { stop: stop } : {}),
       };
 
-      console.log("[Zhipu] Calling Zhipu API...");
+      logger.log("Calling Zhipu API...");
       const response = await fetch(
         "https://api.z.ai/api/paas/v4/chat/completions",
         {
@@ -102,13 +105,13 @@ export async function zhipuChat({
       }
 
       const data = await response.json();
-      console.log("[Zhipu] Response received from Zhipu API");
+      logger.log("Response received from Zhipu API");
 
       // Extract text from response
       const rawText = data?.choices?.[0]?.message?.content || "";
       // Always strip markdown fences first to prevent parse failures
       const text = stripMarkdownFences(rawText);
-      console.log("[Zhipu] Response text length:", text.length);
+      logger.log("Response text length:", text.length);
 
       // Parse JSON - this is required for all calls
       const parsed = tryParseJSON(text);
@@ -130,7 +133,7 @@ export async function zhipuChat({
           ? { prompt_tokens, completion_tokens, total_tokens }
           : undefined;
 
-      console.log("[Zhipu] Returning response from Zhipu API");
+      logger.log("Returning response from Zhipu API");
       return {
         content: parsed,
         text,
@@ -140,13 +143,13 @@ export async function zhipuChat({
     } catch (error) {
       lastError = error;
       const msg = error?.message || error?.toString() || "Unknown error";
-      console.error("[Zhipu] Error occurred:", msg);
-      console.error("[Zhipu] Error status:", error?.status);
+      logger.error("Error occurred:", msg);
+      logger.error("Error status:", error?.status);
 
       if (error.status === 401) throw error;
 
       if (isRetryableError(error) && attempt < maxRetries) {
-        console.log("[Zhipu] Retrying due to retryable error");
+        logger.log("Retrying due to retryable error");
         continue;
       }
 

package/src/ui/endpoints/job-control-endpoints.js

@@ -829,16 +829,80 @@ export async function handleTaskStart(
       return;
     }
 
-    // Validate task existence
-    if (!snapshot.tasks || !snapshot.tasks[taskId]) {
-      sendJson(res, 400, {
+    // Read job pipeline config (needed for both task validation and dependency checking)
+    const jobPipelinePath = getJobPipelinePath(dataDir, jobId, "current");
+    let jobPipeline;
+    try {
+      const content = await fs.promises.readFile(jobPipelinePath, "utf8");
+      jobPipeline = JSON.parse(content);
+    } catch (error) {
+      sendJson(res, 500, {
         ok: false,
-        code: "task_not_found",
-        message: "Task not found in job",
+        code: "pipeline_config_not_found",
+        message: "Pipeline configuration not found",
       });
       return;
     }
 
+    // Helper function to extract task name from string or object
+    const getTaskName = (t) => (typeof t === "string" ? t : t.name);
+
+    // Check if task exists in pipeline.json
+    const pipelineTaskNames = (jobPipeline.tasks || []).map(getTaskName);
+    const taskExistsInPipeline = pipelineTaskNames.includes(taskId);
+
+    // Validate task existence - check both tasks-status.json and pipeline.json
+    if (!snapshot.tasks || !snapshot.tasks[taskId]) {
+      if (!taskExistsInPipeline) {
+        // Task not found in either file - true error case
+        sendJson(res, 400, {
+          ok: false,
+          code: "task_not_found",
+          message: "Task not found in pipeline definition",
+        });
+        return;
+      }
+
+      // Task exists in pipeline.json but not in tasks-status.json
+      // Auto-add it with default pending state
+      console.log(
+        `[handleTaskStart] Auto-adding missing task "${taskId}" to tasks-status.json for job ${jobId}`
+      );
+
+      await writeJobStatus(jobDir, (s) => {
+        if (!s.tasks) {
+          s.tasks = {};
+        }
+        if (!s.tasks[taskId]) {
+          s.tasks[taskId] = {
+            state: "pending",
+            currentStage: null,
+            attempts: 0,
+            refinementAttempts: 0,
+            files: {
+              artifacts: [],
+              logs: [],
+              tmp: [],
+            },
+          };
+        }
+        return s;
+      });
+
+      // Re-read the updated snapshot
+      try {
+        const content = await fs.promises.readFile(statusPath, "utf8");
+        snapshot = JSON.parse(content);
+      } catch (error) {
+        sendJson(res, 500, {
+          ok: false,
+          code: "internal_error",
+          message: "Failed to read updated job status",
+        });
+        return;
+      }
+    }
+
     // Validate task state is Pending
     if (snapshot.tasks[taskId].state !== "pending") {
       sendJson(res, 400, {
@@ -849,21 +913,6 @@ export async function handleTaskStart(
       return;
     }
 
-    // Read job pipeline config
-    const jobPipelinePath = getJobPipelinePath(dataDir, jobId, "current");
-    let jobPipeline;
-    try {
-      const content = await fs.promises.readFile(jobPipelinePath, "utf8");
-      jobPipeline = JSON.parse(content);
-    } catch (error) {
-      sendJson(res, 500, {
-        ok: false,
-        code: "pipeline_config_not_found",
-        message: "Pipeline configuration not found",
-      });
-      return;
-    }
-
     // Validate dependencies via validateUpstreamDone
     const depCheck = validateUpstreamDone({
       jobPipelineTasks: jobPipeline.tasks,