@ryanfw/prompt-orchestration-pipeline 0.11.0 → 0.13.0

package/src/core/status-writer.js

@@ -208,6 +208,26 @@ export async function writeJobStatus(jobDir, updateFn) {
         logger.error("Failed to emit SSE event:", error);
       }
 
+      // Emit lifecycle_block event if update contains lifecycle block reason
+      if (snapshot.lifecycleBlockReason) {
+        try {
+          const lifecycleEventData = {
+            jobId,
+            taskId: snapshot.lifecycleBlockTaskId,
+            op: snapshot.lifecycleBlockOp,
+            reason: snapshot.lifecycleBlockReason,
+          };
+          await logger.sse("lifecycle_block", lifecycleEventData);
+          logger.log(
+            "lifecycle_block SSE event broadcasted successfully",
+            lifecycleEventData
+          );
+        } catch (error) {
+          // Don't fail the write if SSE emission fails
+          logger.error("Failed to emit lifecycle_block SSE event:", error);
+        }
+      }
+
       logger.groupEnd();
       resultSnapshot = snapshot;
     })
@@ -485,6 +505,70 @@ export async function resetJobToCleanSlate(
   });
 }
 
+/**
+ * Reset a single task to pending state without affecting other tasks
+ *
+ * @param {string} jobDir - Job directory path containing tasks-status.json
+ * @param {string} taskId - Task identifier to reset
+ * @param {Object} options - Reset options
+ * @param {boolean} [options.clearTokenUsage=true] - Whether to clear token usage arrays
+ * @returns {Promise<Object>} The updated status snapshot
+ */
+export async function resetSingleTask(
+  jobDir,
+  taskId,
+  { clearTokenUsage = true } = {}
+) {
+  if (!jobDir || typeof jobDir !== "string") {
+    throw new Error("jobDir must be a non-empty string");
+  }
+
+  if (!taskId || typeof taskId !== "string") {
+    throw new Error("taskId must be a non-empty string");
+  }
+
+  return writeJobStatus(jobDir, (snapshot) => {
+    // Ensure tasks object exists
+    if (!snapshot.tasks || typeof snapshot.tasks !== "object") {
+      snapshot.tasks = {};
+    }
+
+    // Ensure the target task exists
+    if (!snapshot.tasks[taskId]) {
+      snapshot.tasks[taskId] = {};
+    }
+
+    const task = snapshot.tasks[taskId];
+
+    // Reset only the target task state and metadata
+    task.state = TaskState.PENDING;
+    task.currentStage = null;
+
+    // Remove error-related fields
+    delete task.failedStage;
+    delete task.error;
+
+    // Reset counters
+    task.attempts = 0;
+    task.refinementAttempts = 0;
+
+    // Clear token usage if requested
+    if (clearTokenUsage) {
+      task.tokenUsage = [];
+    }
+
+    // Update lastUpdated timestamp
+    snapshot.lastUpdated = new Date().toISOString();
+
+    // Do not modify:
+    // - Any other tasks within snapshot.tasks
+    // - snapshot.files.artifacts|logs|tmp
+    // - Root-level fields other than lastUpdated
+
+    return snapshot;
+  });
+}
+
 /**
  * Consolidated path jail security validation with generic error messages
  * @param {string} filename - Filename to validate

package/src/llm/index.js

@@ -91,6 +91,15 @@ export function calculateCost(provider, model, usage) {
 
 // Core chat function - no metrics handling needed!
 export async function chat(options) {
+  console.log("[llm] chat() called with options:", {
+    provider: options.provider,
+    model: options.model,
+    messageCount: options.messages?.length || 0,
+    hasTemperature: options.temperature !== undefined,
+    hasMaxTokens: options.maxTokens !== undefined,
+    responseFormat: options.responseFormat,
+  });
+
   const {
     provider,
     model,
@@ -103,6 +112,7 @@ export async function chat(options) {
     presencePenalty,
     stop,
     responseFormat,
+    stream = false,
     ...rest
   } = options;
 
@@ -111,27 +121,41 @@ export async function chat(options) {
 
   const available = getAvailableProviders();
 
+  console.log("[llm] Available providers:", available);
+  console.log("[llm] Requested provider:", provider);
+
   if (!available[provider]) {
+    console.error("[llm] Provider not available:", provider);
     throw new Error(`Provider ${provider} not available. Check API keys.`);
   }
 
   const startTime = Date.now();
   const requestId = `req_${Date.now()}_${Math.random().toString(36).substring(7)}`;
 
-  // Default to JSON mode if not specified
-  const finalResponseFormat = responseFormat ?? "json";
-
   // Extract system and user messages
   const systemMsg = messages.find((m) => m.role === "system")?.content || "";
   const userMessages = messages.filter((m) => m.role === "user");
   const userMsg = userMessages.map((m) => m.content).join("\n");
 
+  console.log("[llm] Message analysis:", {
+    hasSystemMessage: !!systemMsg,
+    systemMessageLength: systemMsg.length,
+    userMessageCount: userMessages.length,
+    userMessageLength: userMsg.length,
+    totalMessageLength: systemMsg.length + userMsg.length,
+  });
+
   // DEBUG write_to_file messages to /tmp/messages.log for debugging
   fs.writeFileSync(
     "/tmp/messages.log",
     JSON.stringify({ messages, systemMsg, userMsg, provider, model }, null, 2)
   );
 
+  console.log(
+    "[llm] Emitting llm:request:start event for requestId:",
+    requestId
+  );
+
   // Emit request start event
   llmEvents.emit("llm:request:start", {
     id: requestId,
@@ -142,10 +166,12 @@ export async function chat(options) {
   });
 
   try {
+    console.log("[llm] Starting provider call for:", provider);
     let response;
     let usage;
 
     if (provider === "mock") {
+      console.log("[llm] Using mock provider");
       if (!mockProviderInstance) {
         throw new Error(
           "Mock provider not registered. Call registerMockProvider() first."
@@ -159,6 +185,7 @@ export async function chat(options) {
         maxTokens,
         ...rest,
       });
+      console.log("[llm] Mock provider returned result");
 
       response = {
         content: result.content,
@@ -171,6 +198,7 @@ export async function chat(options) {
         totalTokens: result.usage.total_tokens,
       };
     } else if (provider === "openai") {
+      console.log("[llm] Using OpenAI provider");
       const openaiArgs = {
         messages,
         model: model || "gpt-5-chat-latest",
@@ -178,7 +206,14 @@ export async function chat(options) {
         maxTokens,
         ...rest,
       };
-      openaiArgs.responseFormat = finalResponseFormat;
+      console.log("[llm] OpenAI call parameters:", {
+        model: openaiArgs.model,
+        hasMessages: !!openaiArgs.messages,
+        messageCount: openaiArgs.messages?.length,
+      });
+      if (responseFormat !== undefined) {
+        openaiArgs.responseFormat = responseFormat;
+      }
       if (topP !== undefined) openaiArgs.topP = topP;
       if (frequencyPenalty !== undefined)
         openaiArgs.frequencyPenalty = frequencyPenalty;
@@ -186,7 +221,13 @@ export async function chat(options) {
         openaiArgs.presencePenalty = presencePenalty;
       if (stop !== undefined) openaiArgs.stop = stop;
 
+      console.log("[llm] Calling openaiChat()...");
       const result = await openaiChat(openaiArgs);
+      console.log("[llm] openaiChat() returned:", {
+        hasResult: !!result,
+        hasContent: !!result?.content,
+        hasUsage: !!result?.usage,
+      });
 
       response = {
         content:
@@ -213,22 +254,43 @@ export async function chat(options) {
         };
       }
     } else if (provider === "deepseek") {
+      console.log("[llm] Using DeepSeek provider");
       const deepseekArgs = {
         messages,
-        model: model || "deepseek-reasoner",
+        model: model || MODEL_CONFIG[DEFAULT_MODEL_BY_PROVIDER.deepseek].model,
         temperature,
         maxTokens,
         ...rest,
       };
+      console.log("[llm] DeepSeek call parameters:", {
+        model: deepseekArgs.model,
+        hasMessages: !!deepseekArgs.messages,
+        messageCount: deepseekArgs.messages?.length,
+      });
+      if (stream !== undefined) deepseekArgs.stream = stream;
       if (topP !== undefined) deepseekArgs.topP = topP;
       if (frequencyPenalty !== undefined)
         deepseekArgs.frequencyPenalty = frequencyPenalty;
       if (presencePenalty !== undefined)
         deepseekArgs.presencePenalty = presencePenalty;
       if (stop !== undefined) deepseekArgs.stop = stop;
-      deepseekArgs.responseFormat = finalResponseFormat;
+      if (responseFormat !== undefined) {
+        deepseekArgs.responseFormat = responseFormat;
+      }
 
+      console.log("[llm] Calling deepseekChat()...");
       const result = await deepseekChat(deepseekArgs);
+      console.log("[llm] deepseekChat() 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,
@@ -254,6 +316,7 @@ export async function chat(options) {
         };
       }
     } else if (provider === "anthropic") {
+      console.log("[llm] Using Anthropic provider");
       const defaultAlias = DEFAULT_MODEL_BY_PROVIDER.anthropic;
       const defaultModelConfig = MODEL_CONFIG[defaultAlias];
       const defaultModel = defaultModelConfig?.model;
@@ -265,11 +328,24 @@ export async function chat(options) {
         maxTokens,
         ...rest,
       };
+      console.log("[llm] Anthropic call parameters:", {
+        model: anthropicArgs.model,
+        hasMessages: !!anthropicArgs.messages,
+        messageCount: anthropicArgs.messages?.length,
+      });
       if (topP !== undefined) anthropicArgs.topP = topP;
       if (stop !== undefined) anthropicArgs.stop = stop;
-      anthropicArgs.responseFormat = finalResponseFormat;
+      if (responseFormat !== undefined) {
+        anthropicArgs.responseFormat = responseFormat;
+      }
 
+      console.log("[llm] Calling anthropicChat()...");
       const result = await anthropicChat(anthropicArgs);
+      console.log("[llm] anthropicChat() returned:", {
+        hasResult: !!result,
+        hasContent: !!result?.content,
+        hasUsage: !!result?.usage,
+      });
 
       response = {
         content: result.content,
@@ -296,6 +372,7 @@ export async function chat(options) {
         };
       }
     } else if (provider === "gemini") {
+      console.log("[llm] Using Gemini provider");
       const geminiArgs = {
         messages,
         model: model || "gemini-2.5-flash",
@@ -303,11 +380,24 @@ export async function chat(options) {
         maxTokens,
         ...rest,
       };
+      console.log("[llm] Gemini call parameters:", {
+        model: geminiArgs.model,
+        hasMessages: !!geminiArgs.messages,
+        messageCount: geminiArgs.messages?.length,
+      });
       if (topP !== undefined) geminiArgs.topP = topP;
       if (stop !== undefined) geminiArgs.stop = stop;
-      geminiArgs.responseFormat = finalResponseFormat;
+      if (responseFormat !== undefined) {
+        geminiArgs.responseFormat = responseFormat;
+      }
 
+      console.log("[llm] Calling geminiChat()...");
       const result = await geminiChat(geminiArgs);
+      console.log("[llm] geminiChat() returned:", {
+        hasResult: !!result,
+        hasContent: !!result?.content,
+        hasUsage: !!result?.usage,
+      });
 
       response = {
         content: result.content,
@@ -334,6 +424,7 @@ export async function chat(options) {
         };
       }
     } else if (provider === "zhipu") {
+      console.log("[llm] Using Zhipu provider");
       const defaultAlias = DEFAULT_MODEL_BY_PROVIDER.zhipu;
       const defaultModelConfig = MODEL_CONFIG[defaultAlias];
       const defaultModel = defaultModelConfig?.model;
@@ -345,11 +436,24 @@ export async function chat(options) {
         maxTokens,
         ...rest,
       };
+      console.log("[llm] Zhipu call parameters:", {
+        model: zhipuArgs.model,
+        hasMessages: !!zhipuArgs.messages,
+        messageCount: zhipuArgs.messages?.length,
+      });
       if (topP !== undefined) zhipuArgs.topP = topP;
       if (stop !== undefined) zhipuArgs.stop = stop;
-      zhipuArgs.responseFormat = finalResponseFormat;
+      if (responseFormat !== undefined) {
+        zhipuArgs.responseFormat = responseFormat;
+      }
 
+      console.log("[llm] Calling zhipuChat()...");
       const result = await zhipuChat(zhipuArgs);
+      console.log("[llm] zhipuChat() returned:", {
+        hasResult: !!result,
+        hasContent: !!result?.content,
+        hasUsage: !!result?.usage,
+      });
 
       response = {
         content: result.content,
@@ -376,12 +480,21 @@ export async function chat(options) {
         };
       }
     } else {
+      console.error("[llm] Unknown provider:", provider);
       throw new Error(`Provider ${provider} not yet implemented`);
     }
 
+    console.log("[llm] Processing response from provider:", provider);
+
     const duration = Date.now() - startTime;
     const cost = calculateCost(provider, model, usage);
 
+    console.log("[llm] Request completed:", {
+      duration: `${duration}ms`,
+      cost,
+      usage,
+    });
+
     // Emit success event with metrics
     llmEvents.emit("llm:request:complete", {
       id: requestId,
@@ -402,6 +515,13 @@ export async function chat(options) {
   } catch (error) {
     const duration = Date.now() - startTime;
 
+    console.error("[llm] Error in chat():", {
+      error: error.message,
+      name: error.name,
+      stack: error.stack,
+      duration: `${duration}ms`,
+    });
+
     // Emit error event
     llmEvents.emit("llm:request:error", {
       id: requestId,

package/src/pages/Code.jsx

@@ -86,7 +86,14 @@ export default function CodePage() {
   useEffect(() => {
     fetch("/api/llm/functions")
       .then((res) => res.json())
-      .then(setLlmFunctions)
+      .then(({ ok, data }) => {
+        if (!ok || typeof data !== "object" || data === null) {
+          throw new Error(
+            "Invalid /api/llm/functions response: expected { ok:true, data:Object }"
+          );
+        }
+        setLlmFunctions(data);
+      })
       .catch(console.error);
   }, []);
 

package/src/pages/PipelineDetail.jsx

@@ -1,4 +1,4 @@
-import React from "react";
+import React, { useState } from "react";
 import { data, useParams } from "react-router-dom";
 import { Box, Flex, Text } from "@radix-ui/themes";
 import * as Tooltip from "@radix-ui/react-tooltip";
@@ -8,9 +8,16 @@ import Layout from "../components/Layout.jsx";
 import PageSubheader from "../components/PageSubheader.jsx";
 import { statusBadge } from "../utils/ui.jsx";
 import { formatCurrency4, formatTokensCompact } from "../utils/formatters.js";
+import { rescanJob } from "../ui/client/api.js";
+import StopJobModal from "../components/ui/StopJobModal.jsx";
+import { stopJob } from "../ui/client/api.js";
+import { Button } from "../components/ui/button.jsx";
 
 export default function PipelineDetail() {
   const { jobId } = useParams();
+  const [isRescanning, setIsRescanning] = useState(false);
+  const [isStopModalOpen, setIsStopModalOpen] = useState(false);
+  const [isStopping, setIsStopping] = useState(false);
 
   // Handle missing job ID (undefined/null)
   if (jobId === undefined || jobId === null) {
@@ -143,6 +150,12 @@ export default function PipelineDetail() {
     ...(job.name ? [{ label: job.name }] : []),
   ];
 
+  // Determine if job is currently running
+  const isRunning =
+    job?.status === "running" ||
+    (job?.tasks &&
+      Object.values(job.tasks).some((task) => task?.state === "running"));
+
   // Derive cost data from job object with safe fallbacks
   const totalCost = job?.totalCost || job?.costs?.summary?.totalCost || 0;
   const totalTokens = job?.totalTokens || job?.costs?.summary?.totalTokens || 0;
@@ -193,13 +206,74 @@ export default function PipelineDetail() {
       costIndicator
     );
 
-  // Right side content for PageSubheader: job ID, cost indicator, and status badge
+  const handleRescan = async () => {
+    setIsRescanning(true);
+    try {
+      const result = await rescanJob(jobId);
+      if (result.ok) {
+        const addedCount = result.added ? result.added.length : 0;
+        const removedCount = result.removed ? result.removed.length : 0;
+        let message = "Rescan complete.";
+        if (addedCount > 0 && removedCount > 0) {
+          message += ` Added ${addedCount} task${addedCount > 1 ? "s" : ""}: ${JSON.stringify(result.added)}. Removed ${removedCount} task${removedCount > 1 ? "s" : ""}: ${JSON.stringify(result.removed)}.`;
+        } else if (addedCount > 0) {
+          message += ` Added ${addedCount} task${addedCount > 1 ? "s" : ""}: ${JSON.stringify(result.added)}.`;
+        } else if (removedCount > 0) {
+          message += ` Removed ${removedCount} task${removedCount > 1 ? "s" : ""}: ${JSON.stringify(result.removed)}.`;
+        } else {
+          message += " No changes found.";
+        }
+        console.log(message);
+      }
+    } catch (err) {
+      console.error("Rescan failed:", err);
+      alert("Rescan failed: " + err.message);
+    } finally {
+      setIsRescanning(false);
+    }
+  };
+
+  const openStopModal = () => setIsStopModalOpen(true);
+  const closeStopModal = () => setIsStopModalOpen(false);
+
+  const handleStopConfirm = async () => {
+    setIsStopping(true);
+    try {
+      await stopJob(jobId);
+      closeStopModal();
+    } catch (error) {
+      console.warn("Failed to stop job:", error);
+      closeStopModal();
+    } finally {
+      setIsStopping(false);
+    }
+  };
+
+  // Right side content for PageSubheader: job ID, cost indicator, status badge, and Stop control
   const subheaderRightContent = (
     <Flex align="center" gap="3" className="shrink-0 flex-wrap">
       <Text size="2" color="gray">
         ID: {job.id || jobId}
       </Text>
       {costIndicatorWithTooltip}
+      {isRunning && (
+        <Button
+          size="sm"
+          variant="destructive"
+          disabled={isStopping}
+          onClick={openStopModal}
+        >
+          {isStopping ? "Stopping..." : "Stop"}
+        </Button>
+      )}
+      <Button
+        size="sm"
+        variant="outline"
+        disabled={isRescanning}
+        onClick={handleRescan}
+      >
+        {isRescanning ? "Rescanning..." : "Rescan"}
+      </Button>
       {statusBadge(job.status)}
     </Flex>
   );
@@ -215,6 +289,14 @@ export default function PipelineDetail() {
         )}
       </PageSubheader>
       <JobDetail job={job} pipeline={pipeline} />
+      <StopJobModal
+        isOpen={isStopModalOpen}
+        onClose={closeStopModal}
+        onConfirm={handleStopConfirm}
+        runningJobs={[{ id: job.id, name: job.name, progress: job.progress }]}
+        defaultJobId={job.id}
+        isSubmitting={isStopping}
+      />
     </Layout>
   );
 }